P~1

PortalParticle

struct __cppobj PortalParticle : Particle
{
  float oSize;
  float xStart;
  float yStart;
  float zStart;
};

PortalParticle_vtbl

struct /*VFT*/ PortalParticle_vtbl
{
  void (__fastcall *init)(Particle *this, const Vec3 *, const Vec3 *, int, ParticleEngine *);
  void (__fastcall *addTagData)(Particle *this, const CompoundTag *);
  void (__fastcall *~Particle)(Particle *this);
  void (__fastcall *normalTick)(Particle *this);
  void (__fastcall *tessellate)(Particle *this, const ParticleRenderContext *);
  const mce::TexturePtr *(__fastcall *getParticleTexture)(Particle *this);
  mce::Color *(__fastcall *getParticleLightColor)(Particle *this, mce::Color *result, float, const LightTexture *);
  void (__fastcall *setEmittingEntity)(Particle *this, Actor *);
  bool (__fastcall *_shouldUpdateVertexData)(Particle *this, float);
};

ParticleEngine::forceTessellationForTemporaryCamera::__l2::<lambda_1c4f5db753384ce095ac3ebf109ad35d>

struct __cppobj ParticleEngine::forceTessellationForTemporaryCamera::__l2::<lambda_1c4f5db753384ce095ac3ebf109ad35d>
{
  ParticleEngine *const __this;
};

ParticleSystem::ParticleAppearanceLightingComponent

struct __cppobj ParticleSystem::ParticleAppearanceLightingComponent : ParticleSystem::ParticleAppearanceComponentBase
{
};

ParticleSystem::ParticleAppearanceLightingComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleAppearanceLightingComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const Vec3 *);
  void (__fastcall *updateParticleAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *updateEmitterAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterLocalSpaceComponent

struct __cppobj __declspec(align(8)) ParticleSystem::EmitterLocalSpaceComponent : ParticleSystem::EmitterInitialComponentBase
{
  bool mUseActorPosition;
  bool mUseActorRotation;
  bool mUseEmitterVelocity;
};

ParticleSystem::EmitterLocalSpaceComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterLocalSpaceComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setupInitial)(ParticleSystem::EmitterInitialComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
  void (__fastcall *update)(ParticleSystem::EmitterInitialComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterInitialExpressionComponent

struct __cppobj ParticleSystem::EmitterInitialExpressionComponent : ParticleSystem::EmitterInitialComponentBase
{
  ExpressionNode mSetupExpr;
  ExpressionNode mUpdateExpr;
};

ParticleSystem::EmitterInitialExpressionComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterInitialExpressionComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setupInitial)(ParticleSystem::EmitterInitialComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
  void (__fastcall *update)(ParticleSystem::EmitterInitialComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterLifetimeLoopingComponent

struct __cppobj ParticleSystem::EmitterLifetimeLoopingComponent : ParticleSystem::EmitterLifetimeComponentBase
{
  ExpressionNode mActivationTimeExpr;
  ExpressionNode mSleepTimeExpr;
};

ParticleSystem::EmitterLifetimeOnceComponent

struct __cppobj ParticleSystem::EmitterLifetimeOnceComponent : ParticleSystem::EmitterLifetimeComponentBase
{
  ExpressionNode mActivationTimeExpr;
};

ParticleSystem::EmitterLifetimeExpressionComponent

struct __cppobj ParticleSystem::EmitterLifetimeExpressionComponent : ParticleSystem::EmitterLifetimeComponentBase
{
  ExpressionNode mActivationExpr;
  ExpressionNode mExpirationExpr;
};

ParticleSystem::EmitterRateInstantComponent

struct __cppobj ParticleSystem::EmitterRateInstantComponent : ParticleSystem::EmitterRateComponentBase
{
  ExpressionNode mNumberOfParticlesToEmitExpr;
};

ParticleSystem::EmitterRateInstantComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterRateInstantComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  unsigned __int64 (__fastcall *getNumberOfParticlesToEmit)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
  unsigned __int64 (__fastcall *getNumberOfManualParticlesAllowed)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterRateSteadyComponent

struct __cppobj ParticleSystem::EmitterRateSteadyComponent : ParticleSystem::EmitterRateComponentBase
{
  ExpressionNode mSpawnRateExpr;
  ExpressionNode mMaxParticlesExpr;
};

ParticleSystem::EmitterRateSteadyComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterRateSteadyComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  unsigned __int64 (__fastcall *getNumberOfParticlesToEmit)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
  unsigned __int64 (__fastcall *getNumberOfManualParticlesAllowed)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterRateManualComponent

struct __cppobj ParticleSystem::EmitterRateManualComponent : ParticleSystem::EmitterRateComponentBase
{
  ExpressionNode mManualParticlesAllowedExpr;
};

ParticleSystem::EmitterRateManualComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterRateManualComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  unsigned __int64 (__fastcall *getNumberOfParticlesToEmit)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
  unsigned __int64 (__fastcall *getNumberOfManualParticlesAllowed)(ParticleSystem::EmitterRateComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterShapePointComponent

struct __cppobj ParticleSystem::EmitterShapePointComponent : ParticleSystem::EmitterShapeComponentBase
{
  ExpressionNode mOffsetExpr[3];
  ExpressionNode mDirectionExpr[3];
};

ParticleSystem::EmitterShapePointComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapePointComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterShapeBoxComponent

struct __cppobj ParticleSystem::EmitterShapeBoxComponent : ParticleSystem::EmitterShapeComponentBase
{
  ExpressionNode mOffsetExpr[3];
  ExpressionNode mHalfDimensions[3];
  bool mSurfaceOnly;
  bool mDirectionInwards;
  bool mDirectionOutwards;
  ExpressionNode mDirectionExpr[3];
};

ParticleSystem::EmitterShapeBoxComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapeBoxComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterShapeSphereComponent

struct __cppobj ParticleSystem::EmitterShapeSphereComponent : ParticleSystem::EmitterShapeComponentBase
{
  ExpressionNode mOffsetExpr[3];
  ExpressionNode mRadiusExpr;
  bool mSurfaceOnly;
  bool mDirectionInwards;
  bool mDirectionOutwards;
  ExpressionNode mDirectionExpr[3];
};

ParticleSystem::EmitterShapeSphereComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapeSphereComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
  void (__fastcall *applyPreNormalizationModifiers)(ParticleSystem::EmitterShapeSphereComponent *this, Vec3 *, RenderParams *);
};

ParticleSystem::EmitterShapeCustomComponent

struct __cppobj ParticleSystem::EmitterShapeCustomComponent : ParticleSystem::EmitterShapeComponentBase
{
  ExpressionNode mOffsetExpr[3];
  ExpressionNode mDirectionExpr[3];
};

ParticleSystem::EmitterShapeCustomComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapeCustomComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterShapeEntityAABBComponent

struct __cppobj __declspec(align(8)) ParticleSystem::EmitterShapeEntityAABBComponent : ParticleSystem::EmitterShapeComponentBase
{
  ExpressionNode mDirectionExpr[3];
  bool mDirectionInwards;
  bool mDirectionOutwards;
  bool mSurfaceOnly;
};

ParticleSystem::EmitterShapeEntityAABBComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapeEntityAABBComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::EmitterShapeDiscComponent

struct __cppobj ParticleSystem::EmitterShapeDiscComponent : ParticleSystem::EmitterShapeSphereComponent
{
  ExpressionNode mPlaneNormal[3];
};

ParticleSystem::EmitterShapeDiscComponent_vtbl

struct /*VFT*/ ParticleSystem::EmitterShapeDiscComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *getNextParticleSpawnOffsetAndDirection)(ParticleSystem::EmitterShapeComponentBase *this, Vec3 *, Vec3 *, const ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
  void (__fastcall *applyPreNormalizationModifiers)(ParticleSystem::EmitterShapeSphereComponent *this, Vec3 *, RenderParams *);
};

ParticleSystem::ParticleAppearanceBillboardBaseComponent::DirectionSettings

struct __cppobj __declspec(align(8)) ParticleSystem::ParticleAppearanceBillboardBaseComponent::DirectionSettings
{
  _BYTE mMode[4];
  ExpressionNode mCustomDirectionExpr[3];
  float mMinSpeedThresholdSqr;
};

ParticleSystem::ParticleAppearanceBillboardBaseComponent

struct __cppobj ParticleSystem::ParticleAppearanceBillboardBaseComponent : ParticleSystem::ParticleAppearanceComponentBase
{
  ParticleSystem::ParticleAppearanceBillboardBaseComponent::DirectionSettings mDirection;
};

ParticleSystem::ParticleAppearanceBillboardBaseComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleAppearanceBillboardBaseComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const Vec3 *);
  void (__fastcall *updateParticleAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *updateEmitterAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::ParticleAppearanceBillboardComponent::FlipBook

struct __cppobj __declspec(align(8)) ParticleSystem::ParticleAppearanceBillboardComponent::FlipBook
{
  ExpressionNode mBaseUV[2];
  Vec2 mSizeUV;
  Vec2 mStepUV;
  float mFPS;
  ExpressionNode mMaxFrame;
  bool mStretchToLifetime;
  bool mLoop;
};

ParticleSystem::ParticleAppearanceBillboardComponent

struct __cppobj ParticleSystem::ParticleAppearanceBillboardComponent : ParticleSystem::ParticleAppearanceBillboardBaseComponent
{
  ExpressionNode mSizeExpr[2];
  HashedString mFacing;
  ExpressionNode mUVExpr[2];
  ExpressionNode mUVSizeExpr[2];
  Vec2 mAssumedTextureDimensions;
  bool mUseFlipBook;
  ParticleSystem::ParticleAppearanceBillboardComponent::FlipBook mFlipBook;
};

ParticleSystem::ParticleAppearanceBillboardComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleAppearanceBillboardComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const Vec3 *);
  void (__fastcall *updateParticleAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *updateEmitterAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::ParticleAppearanceTintingComponent::ParticleColors

struct __cppobj __declspec(align(8)) ParticleSystem::ParticleAppearanceTintingComponent::ParticleColors
{
  const HashedString mName;
  const std::string mAppearanceTintColors;
  std::array<ExpressionNode,4> mOriginalColor;
  const bool mAlpha;
  float mCol[4];
  float mParticleColorFloat[4];
};

ParticleSystem::ParticleAppearanceTintingComponent

struct __cppobj ParticleSystem::ParticleAppearanceTintingComponent : ParticleSystem::ParticleAppearanceComponentBase
{
  std::vector<ParticleSystem::ParticleAppearanceTintingComponent::ParticleColors> mParticleColors;
  const bool mAlpha;
  float mCol[4];
  float mParticleColorFloat[4];
  std::vector<ParticleSystem::ParticleAppearanceTintingComponent::ColorFrame> mColorFrames;
  ExpressionNode mInterpolantExpr;
};

ParticleSystem::ParticleAppearanceTintingComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleAppearanceTintingComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const Vec3 *);
  void (__fastcall *updateParticleAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *updateEmitterAppearance)(ParticleSystem::ParticleAppearanceComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, RenderParams *);
};

ParticleSystem::ParticleInitialSpinComponent

struct __cppobj ParticleSystem::ParticleInitialSpinComponent : ParticleSystem::ParticleInitialComponentBase
{
  ExpressionNode mRotationExpr;
  ExpressionNode mRotationRateExpr;
};

ParticleSystem::ParticleInitialSpinComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleInitialSpinComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleInitialComponentBase *this, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *update)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
  void (__fastcall *renderPreparation)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
};

ParticleSystem::ParticleInitialSpeedComponent

struct __cppobj __declspec(align(8)) ParticleSystem::ParticleInitialSpeedComponent : ParticleSystem::ParticleInitialComponentBase
{
  std::array<ExpressionNode,3> mSpeedExpr;
  bool mOverrideInitialDirection;
};

ParticleSystem::ParticleInitialSpeedComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleInitialSpeedComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleInitialComponentBase *this, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *update)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
  void (__fastcall *renderPreparation)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
};

ParticleSystem::ParticleInitialExpressionComponent

struct __cppobj ParticleSystem::ParticleInitialExpressionComponent : ParticleSystem::ParticleInitialComponentBase
{
  ExpressionNode mUpdateExpr;
  ExpressionNode mRenderExpr;
};

ParticleSystem::ParticleInitialExpressionComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleInitialExpressionComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *setInitialState)(ParticleSystem::ParticleInitialComponentBase *this, ParticleSystem::CommonParticle *, RenderParams *);
  void (__fastcall *update)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
  void (__fastcall *renderPreparation)(ParticleSystem::ParticleInitialComponentBase *this, RenderParams *);
};

ParticleSystem::ParticleLifetimeExpressionComponent

struct __cppobj ParticleSystem::ParticleLifetimeExpressionComponent : ParticleSystem::ParticleLifetimeComponentBase
{
  bool mLifetimeExprSet;
  ExpressionNode mLifetimeExpr;
  ExpressionNode mExpirationExpr;
};

ParticleSystem::ParticleLifetimeBlockDependentComponent

struct __cppobj __declspec(align(8)) ParticleSystem::ParticleLifetimeBlockDependentComponent : ParticleSystem::ParticleLifetimeComponentBase
{
  std::vector<std::string> mSurviveBlockList;
  bool mExpireIfOnList;
};

ParticleSystem::ParticleLifetimeKillPlaneComponent

struct __cppobj ParticleSystem::ParticleLifetimeKillPlaneComponent : ParticleSystem::ParticleLifetimeComponentBase
{
  Vec4 mKillPlane;
};

ParticleSystem::ParticleMotionDynamicComponent

struct __cppobj ParticleSystem::ParticleMotionDynamicComponent : ParticleSystem::ParticleMotionComponentBase
{
  ExpressionNode mLinearAccelerationExpr[3];
  ExpressionNode mLinearDragCoefficientExpr;
  ExpressionNode mRotationAccelerationExpr;
  ExpressionNode mRotationDragCoefficientExpr;
};

ParticleSystem::ParticleMotionDynamicComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleMotionDynamicComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *updateParticleMotion)(ParticleSystem::ParticleMotionComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
};

ParticleSystem::ParticleMotionParametricComponent

struct __cppobj ParticleSystem::ParticleMotionParametricComponent : ParticleSystem::ParticleMotionComponentBase
{
  bool mRelativePositionSpecified;
  bool mDirectionSpecified;
  bool mRotationSpecified;
  ExpressionNode mRelativePositionExpr[3];
  ExpressionNode mDirectionExpr[3];
  ExpressionNode mRotationExpr;
};

ParticleSystem::ParticleMotionParametricComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleMotionParametricComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *updateParticleMotion)(ParticleSystem::ParticleMotionComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
};

ParticleSystem::ParticleMotionCollisionComponent

struct __cppobj ParticleSystem::ParticleMotionCollisionComponent : ParticleSystem::ParticleMotionComponentBase
{
  ExpressionNode mCollisionEnabledExpr;
  float mCollisionDrag;
  float mCoefficientOfRestitution;
  Vec3 mCollisionRadius;
  bool mExpireOnContact;
  std::vector<std::pair<float,HashedString>> mCollisionEvents;
};

ParticleSystem::ParticleMotionCollisionComponent_vtbl

struct /*VFT*/ ParticleSystem::ParticleMotionCollisionComponent_vtbl
{
  void (__fastcall *~EffectComponentBase)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *parseJson)(ParticleSystem::EffectComponentBase *this, const ConstDeserializeDataParams *);
  ParticleSystem::EffectComponentBase::EffectComponentType (__fastcall *getParticleComponentType)(ParticleSystem::EffectComponentBase *this);
  int (__fastcall *getSortOrderNumber)(ParticleSystem::EffectComponentBase *this);
  void (__fastcall *updateParticleMotion)(ParticleSystem::ParticleMotionComponentBase *this, ParticleSystem::ComponentAccessParticleEmitter *, ParticleSystem::CommonParticle *, RenderParams *, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *);
};

ParticleSystem::ParticleCurveSimpleBase

struct __cppobj ParticleSystem::ParticleCurveSimpleBase : ParticleSystem::ParticleCurveBase
{
  HashedString mMolangVariableName;
  std::vector<ExpressionNode> mCurveNodes;
  ExpressionNode mInputExpr;
  ExpressionNode mHorizontalRange;
};

ParticleSystem::ParticleCurveSimpleBase_vtbl

struct /*VFT*/ ParticleSystem::ParticleCurveSimpleBase_vtbl
{
  void (__fastcall *~ParticleCurveBase)(ParticleSystem::ParticleCurveBase *this);
  void (__fastcall *parseJson)(ParticleSystem::ParticleCurveBase *this, const ConstDeserializeDataParams *, const HashedString *);
  void (__fastcall *evaluateCurve)(ParticleSystem::ParticleCurveBase *this, RenderParams *);
  unsigned __int64 (__fastcall *_getMinCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  unsigned __int64 (__fastcall *_getMaxCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  float (__fastcall *_evaluateCurve)(ParticleSystem::ParticleCurveSimpleBase *this, float, RenderParams *);
};

ParticleSystem::ParticleCurveBezier

struct __cppobj ParticleSystem::ParticleCurveBezier : ParticleSystem::ParticleCurveSimpleBase
{
};

ParticleSystem::ParticleCurveBezier_vtbl

struct /*VFT*/ ParticleSystem::ParticleCurveBezier_vtbl
{
  void (__fastcall *~ParticleCurveBase)(ParticleSystem::ParticleCurveBase *this);
  void (__fastcall *parseJson)(ParticleSystem::ParticleCurveBase *this, const ConstDeserializeDataParams *, const HashedString *);
  void (__fastcall *evaluateCurve)(ParticleSystem::ParticleCurveBase *this, RenderParams *);
  unsigned __int64 (__fastcall *_getMinCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  unsigned __int64 (__fastcall *_getMaxCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  float (__fastcall *_evaluateCurve)(ParticleSystem::ParticleCurveSimpleBase *this, float, RenderParams *);
};

ParticleSystem::NodeParseData::Node

struct __cppobj ParticleSystem::NodeParseData::Node
{
  float mLeftValue;
  float mRightValue;
  float mLeftSlope;
  float mRightSlope;
};

ParticleSystem::ParticleCurveBezierChain::Segment

struct __cppobj ParticleSystem::ParticleCurveBezierChain::Segment
{
  float mStartValue;
  float mEndValue;
  float mStartValueControlPoint;
  float mEndValueControlPoint;
  float mStartRange;
  float mEndRange;
};

ParticleSystem::ParticleCurveBezierChain

struct __cppobj ParticleSystem::ParticleCurveBezierChain : ParticleSystem::ParticleCurveBase
{
  HashedString mMolangVariableName;
  ExpressionNode mInputExpr;
  ExpressionNode mHorizontalRange;
  std::vector<ParticleSystem::ParticleCurveBezierChain::Segment> mSegments;
};

ParticleSystem::ParticleCurveBezierChain_vtbl

struct /*VFT*/ ParticleSystem::ParticleCurveBezierChain_vtbl
{
  void (__fastcall *~ParticleCurveBase)(ParticleSystem::ParticleCurveBase *this);
  void (__fastcall *parseJson)(ParticleSystem::ParticleCurveBase *this, const ConstDeserializeDataParams *, const HashedString *);
  void (__fastcall *evaluateCurve)(ParticleSystem::ParticleCurveBase *this, RenderParams *);
};

ParticleSystem::ParticleCurveCatmullRom

struct __cppobj ParticleSystem::ParticleCurveCatmullRom : ParticleSystem::ParticleCurveSimpleBase
{
};

ParticleSystem::ParticleCurveCatmullRom_vtbl

struct /*VFT*/ ParticleSystem::ParticleCurveCatmullRom_vtbl
{
  void (__fastcall *~ParticleCurveBase)(ParticleSystem::ParticleCurveBase *this);
  void (__fastcall *parseJson)(ParticleSystem::ParticleCurveBase *this, const ConstDeserializeDataParams *, const HashedString *);
  void (__fastcall *evaluateCurve)(ParticleSystem::ParticleCurveBase *this, RenderParams *);
  unsigned __int64 (__fastcall *_getMinCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  unsigned __int64 (__fastcall *_getMaxCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  float (__fastcall *_evaluateCurve)(ParticleSystem::ParticleCurveSimpleBase *this, float, RenderParams *);
};

ParticleSystem::ParticleCurveLinear

struct __cppobj ParticleSystem::ParticleCurveLinear : ParticleSystem::ParticleCurveSimpleBase
{
};

ParticleSystem::ParticleCurveLinear_vtbl

struct /*VFT*/ ParticleSystem::ParticleCurveLinear_vtbl
{
  void (__fastcall *~ParticleCurveBase)(ParticleSystem::ParticleCurveBase *this);
  void (__fastcall *parseJson)(ParticleSystem::ParticleCurveBase *this, const ConstDeserializeDataParams *, const HashedString *);
  void (__fastcall *evaluateCurve)(ParticleSystem::ParticleCurveBase *this, RenderParams *);
  unsigned __int64 (__fastcall *_getMinCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  unsigned __int64 (__fastcall *_getMaxCurveNodesAllowed)(ParticleSystem::ParticleCurveSimpleBase *this);
  float (__fastcall *_evaluateCurve)(ParticleSystem::ParticleCurveSimpleBase *this, float, RenderParams *);
};

ParticleSystem::ParticleEmitterActual

struct __cppobj ParticleSystem::ParticleEmitterActual : ParticleSystem::ComponentAccessParticleEmitter
{
  ParticleEffectPtr mEffect;
  std::vector<ParticleSystem::CommonParticle> mParticles;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mEmitterCurrentLoopAge;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mSleepDuration;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mEmissionDuration;
  std::chrono::duration<__int64,std::ratio<1,1000000000> > mTickDeltaTimeAccumulator;
  float mEmitterCurrentTravelDistance;
  Vec3 mEmitterPosition;
  Vec3 mEmitterWorldPosition;
  Vec3 mEmitterLastWorldPosition;
  Vec3 mEmitterWorldVelocity;
  unsigned __int32 mEnableRender : 1;
  unsigned __int32 mEnableUpdate : 1;
  unsigned __int32 mManualParticleEmission : 1;
  unsigned __int32 mIsValid : 1;
  unsigned __int32 mEmitterExpired : 1;
  unsigned __int32 mFirstUpdate : 1;
  unsigned __int32 mUseActorPosition : 1;
  unsigned __int32 mUseActorRotation : 1;
  unsigned __int32 mUseEmitterVelocity : 1;
  unsigned __int32 mBlockListInitialized : 1;
  int mEmitterDynamicsFrameCounter;
  int mParticlesDynamicsFrameCounter;
  int mEmitterRenderingFrameCounter;
  int mParticlesRenderingFrameCounter;
  int mNumberOfFramesToInterpolate;
  RenderParams mRenderParams;
  MolangVariableMap mMolangVariableMap;
  Matrix mEmitterTransform;
  ParticleSystem::ActorBindInfo mActorBindInfo;
  AABB mAABB;
  float mCullingBufferDistance;
  unsigned __int64 mMaxNumParticles;
  unsigned __int64 mNumParticlesEmitted;
  mce::MaterialPtr mMaterial;
  mce::TexturePtr mTexture;
  const std::array<std::array<mce::Color,16>,16> *mLightTextureData;
  _BYTE mFaceCameraMode[4];
  BlockSource *mBlockSource;
  std::unordered_set<BlockLegacy const *> mBlocksToCheckAgainst;
  std::unordered_map<BlockPos,ParticleSystem::ParticleEmitterActual::AABBCacheElement> mAABBCache;
  unsigned int mCurrentCacheFrame;
  std::vector<AABB> mCollisionAabbList;
  std::vector<ParticleSystem::ComponentAccessParticleEmitter::CollisionHelper> mCollisionSweepList;
  ParticleSystemEngine *mParticleSystemEngine;
  std::unordered_map<HashedString,unsigned int> mSpawnedParticleEmitterList;
};

ParticleSystem::ParticleEmitterActual_vtbl

struct /*VFT*/ ParticleSystem::ParticleEmitterActual_vtbl
{
  void (__fastcall *~ParticleEmitter)(ParticleSystem::ParticleEmitter *this);
  void (__fastcall *setActorBindInfo)(ParticleSystem::ParticleEmitter *this, Dimension *, ActorUniqueID, const HashedString *, const Vec3 *);
  void (__fastcall *setEnableUpdate)(ParticleSystem::ParticleEmitter *this, bool);
  void (__fastcall *setEnableRender)(ParticleSystem::ParticleEmitter *this, bool);
  void (__fastcall *runInitializationScript)(ParticleSystem::ParticleEmitter *this, const ExpressionNode *);
  void (__fastcall *onBlockChanged)(ParticleSystem::ParticleEmitter *this, const BlockPos *);
  void (__fastcall *expire)(ParticleSystem::ParticleEmitter *this);
  void (__fastcall *emitParticleManually)(ParticleSystem::ParticleEmitter *this, const Vec3 *, const Vec3 *, const float);
  bool (__fastcall *isValid)(ParticleSystem::ParticleEmitter *this);
  bool (__fastcall *isManualEmitter)(ParticleSystem::ParticleEmitter *this);
  bool (__fastcall *expirationRequested)(ParticleSystem::ParticleEmitter *this);
  bool (__fastcall *hasExpired)(ParticleSystem::ParticleEmitter *this);
  const AABB *(__fastcall *getAABB)(ParticleSystem::ParticleEmitter *this);
  const ParticleEffectPtr *(__fastcall *getEffect)(ParticleSystem::ParticleEmitter *this);
  unsigned __int64 (__fastcall *getParticleCount)(ParticleSystem::ParticleEmitter *this);
  unsigned __int64 (__fastcall *getEffectEmitterCount)(ParticleSystem::ParticleEmitter *this);
  unsigned __int64 (__fastcall *getEffectParticleCount)(ParticleSystem::ParticleEmitter *this);
  unsigned __int64 (__fastcall *getTotalEmitterCount)(ParticleSystem::ParticleEmitter *this);
  unsigned __int64 (__fastcall *getTotalParticleCount)(ParticleSystem::ParticleEmitter *this);
  void (__fastcall *handleExpireManually)(ParticleSystem::ParticleEmitter *this);
  void (__fastcall *tick)(ParticleSystem::ParticleEmitter *this, const std::chrono::duration<__int64,std::ratio<1,1000000000> > *, const float);
  void (__fastcall *frameUpdate)(ParticleSystem::ParticleEmitter *this, ClientFrameUpdateContext *);
  void (__fastcall *extractForRendering)(ParticleSystem::ParticleEmitter *this, ParticleRenderData *, float);
  void (__fastcall *setManualParticleEmission)(ParticleSystem::ParticleEmitter *this, bool);
  ParticleSystem::ActorBindInfo *(__fastcall *getActorBindInfo)(ParticleSystem::ParticleEmitter *this, ParticleSystem::ActorBindInfo *result);
  const Vec3 *(__fastcall *getPosition)(ParticleSystem::ComponentAccessParticleEmitter *this);
  const Matrix *(__fastcall *getTransform)(ParticleSystem::ComponentAccessParticleEmitter *this);
  const Vec3 *(__fastcall *getWorldPosition)(ParticleSystem::ComponentAccessParticleEmitter *this);
  const Vec3 *(__fastcall *getWorldVelocity)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *setMaxNumParticles)(ParticleSystem::ComponentAccessParticleEmitter *this, unsigned __int64);
  unsigned __int64 (__fastcall *getMaxNumParticles)(ParticleSystem::ComponentAccessParticleEmitter *this);
  unsigned __int64 (__fastcall *getNumParticles)(ParticleSystem::ComponentAccessParticleEmitter *this);
  unsigned __int64 (__fastcall *getNumParticlesEmitted)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *setActorFrameOfReference)(ParticleSystem::ComponentAccessParticleEmitter *this, bool, bool, bool);
  void (__fastcall *setEmitRate)(ParticleSystem::ComponentAccessParticleEmitter *this, float);
  float (__fastcall *getEmitRate)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *setEmissionDuration)(ParticleSystem::ComponentAccessParticleEmitter *this, float);
  float *(__fastcall *getEmissionAccumulator)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *setSleepDuration)(ParticleSystem::ComponentAccessParticleEmitter *this, float);
  void (__fastcall *setFacing)(ParticleSystem::ComponentAccessParticleEmitter *this, const HashedString *);
  bool (__fastcall *blockListInitialized)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *initializeBlockList)(ParticleSystem::ComponentAccessParticleEmitter *this, buffer_span<std::string >);
  bool (__fastcall *blockAtPositionIsInList)(ParticleSystem::ComponentAccessParticleEmitter *this, const BlockPos *);
  mce::Color *(__fastcall *getGamePlayLightAtBlock)(ParticleSystem::ComponentAccessParticleEmitter *this, mce::Color *result, const BlockPos *);
  const std::vector<AABB> *(__fastcall *getCollisionShapesForBlockPosition)(ParticleSystem::ComponentAccessParticleEmitter *this, const BlockPos *);
  std::vector<AABB> *(__fastcall *getCollisionAabbList)(ParticleSystem::ComponentAccessParticleEmitter *this);
  std::vector<ParticleSystem::ComponentAccessParticleEmitter::CollisionHelper> *(__fastcall *getCollisionSweepList)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *fireEvent)(ParticleSystem::ComponentAccessParticleEmitter *this, const HashedString *, const Matrix *, const Vec3 *);
  void (__fastcall *fireEvent)(ParticleSystem::ComponentAccessParticleEmitter *this, const HashedString *, const Vec3 *, const Vec3 *);
  bool (__fastcall *getUseActorPosition)(ParticleSystem::ComponentAccessParticleEmitter *this);
  bool (__fastcall *getUseActorRotation)(ParticleSystem::ComponentAccessParticleEmitter *this);
  void (__fastcall *getParticleWorldPositionAndVelocity)(ParticleSystem::ComponentAccessParticleEmitter *this, ParticleSystem::CommonParticle *, Vec3 *, Vec3 *);
};

ParticleEffectGroup::loadParticleEffects::__l2::<lambda_bf04ca8603471ed8cde49c0c9179ec56>

struct __cppobj ParticleEffectGroup::loadParticleEffects::__l2::<lambda_bf04ca8603471ed8cde49c0c9179ec56>
{
  ResourcePackManager *resourcePackManager;
  ParticleEffectGroup *const __this;
  const ParticleSystem::ParticleEffectComponentRegistry *particleComponentRegistry;
};

ParticleEffectGroup::loadParticleEffects::__l2::<lambda_bf04ca8603471ed8cde49c0c9179ec56>::()::__l4::<lambda_7568bce39ec60a121a8c84bd338ed034>

struct __cppobj ParticleEffectGroup::loadParticleEffects::__l2::<lambda_bf04ca8603471ed8cde49c0c9179ec56>::()::__l4::<lambda_7568bce39ec60a121a8c84bd338ed034>
{
  ParticleEffectGroup *const __this;
  const ParticleSystem::ParticleEffectComponentRegistry *particleComponentRegistry;
  std::reverse_iterator<std::_Vector_iterator<std::_Vector_val<std::_Simple_types<PackInstance> > > > *rit;
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_2d7cdfd51de427305042854b5907cef0>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_2d7cdfd51de427305042854b5907cef0>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_d6ac7357f70dd8d9f7993bfe0bb60db0>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_d6ac7357f70dd8d9f7993bfe0bb60db0>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_eaf66890cca84909b81745b78709bad0>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_eaf66890cca84909b81745b78709bad0>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_2b76d3ca544880ea2f832de9f61c6de3>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_2b76d3ca544880ea2f832de9f61c6de3>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_50b2518df62a90dd754329f0dbc64090>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_50b2518df62a90dd754329f0dbc64090>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_79a33a68063f12bcdbe9a33b86f196d8>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l3::<lambda_79a33a68063f12bcdbe9a33b86f196d8>
{
};

ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l2::<lambda_ab749ba7c28af240ae783b3b24f0c7a9>

struct __cppobj ParticleSystem::_buildParticleCurveBezierChainSchema::__l2::<lambda_e56cd5ca9004cc9b1754c4299e5ee273>::()::__l2::<lambda_ab749ba7c28af240ae783b3b24f0c7a9>
{
};

PortalBlock

struct __cppobj PortalBlock : BlockLegacy
{
};

PortalBlock_vtbl

struct /*VFT*/ PortalBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PyHandleObject

struct PyHandleObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  const void *ptr;
};

PersonaResourceLocationExpander

struct __cppobj PersonaResourceLocationExpander : IResourceLocationExpander
{
  ResourcePack *mPersonaResourcePack;
};

PersonaResourceLocationExpander_vtbl

struct /*VFT*/ PersonaResourceLocationExpander_vtbl
{
  void (__fastcall *~IResourceLocationExpander)(IResourceLocationExpander *this);
  ResourceLocation *(__fastcall *getFullPath)(IResourceLocationExpander *this, ResourceLocation *result, const ResourceLocation *, const std::vector<std::string> *);
};

PersonaTextureComposer

struct __cppobj PersonaTextureComposer
{
};

PersonaRepository::_findAndAddPiecesInPack::__l2::PieceInfoStruct

struct __cppobj PersonaRepository::_findAndAddPiecesInPack::__l2::PieceInfoStruct
{
  std::string metaFilePath;
  std::string geoFilePath;
  std::string storeInfoFilePath;
};

PersonaRepositoryTestWrapper

struct __cppobj PersonaRepositoryTestWrapper
{
  PersonaRepository *mPersonaRepository;
};

PersonaRepository::_registerPersonaUserPieceTextures::__l9::<lambda_9ba0fc83626afbe85d07dc9acfc80a7a>::()::__l5::<lambda_a215f31bca4640187c72544ee7315982>

struct __cppobj PersonaRepository::_registerPersonaUserPieceTextures::__l9::<lambda_9ba0fc83626afbe85d07dc9acfc80a7a>::()::__l5::<lambda_a215f31bca4640187c72544ee7315982>
{
  std::weak_ptr<PersonaRepository> weakThis;
  persona::PersonaCharacterHandle currentCharacterHandle;
};

PersonaRepository::_updatePersonaWithExistingUser::__l2::<lambda_5b34ffd3acf5eece0b18816e2c3bb48b>

struct __cppobj PersonaRepository::_updatePersonaWithExistingUser::__l2::<lambda_5b34ffd3acf5eece0b18816e2c3bb48b>
{
  std::function<void __cdecl(bool)> cb;
};

PersonaRepository::_loadDefaultPersonaDefinitions::__l2::<lambda_f4d13497ddbdde2833863fade78ee5ab>

struct __cppobj PersonaRepository::_loadDefaultPersonaDefinitions::__l2::<lambda_f4d13497ddbdde2833863fade78ee5ab>
{
  PersonaRepository *const __this;
};

PersonaRepository::_checkLoadingAppearancesForComplete::__l42::<lambda_4bdcb62dc0d8012969c56c5837f0c3a3>

struct __cppobj __declspec(align(8)) PersonaRepository::_checkLoadingAppearancesForComplete::__l42::<lambda_4bdcb62dc0d8012969c56c5837f0c3a3>
{
  std::weak_ptr<PersonaRepository> weakThis;
  unsigned int personaIndex;
};

PersonaRepository::_processLoadedPieces::__l2::<lambda_95f04875f3fafb853eaa7db1512b8f91>

struct __cppobj PersonaRepository::_processLoadedPieces::__l2::<lambda_95f04875f3fafb853eaa7db1512b8f91>
{
  std::weak_ptr<PersonaRepository> weakThis;
  std::vector<std::string> emotes;
};

PersonaRepository::_findAndAddPiecesInPack::__l2::<lambda_ce817b1c59274d46195a3cc036ae23d7>

struct __cppobj PersonaRepository::_findAndAddPiecesInPack::__l2::<lambda_ce817b1c59274d46195a3cc036ae23d7>
{
  std::map<std::string,`PersonaRepository::_findAndAddPiecesInPack'::`2'::PieceInfoStruct> *pieceInfo;
};

PersonaRepository::_initPackSources::__l2::<lambda_371456de2778ccef82d8ede4e4ae9984>

struct __cppobj PersonaRepository::_initPackSources::__l2::<lambda_371456de2778ccef82d8ede4e4ae9984>
{
  PersonaRepository *const __this;
};

PersonaRepository::reloadEmoteAnimationData::__l2::<lambda_9856da88cb4f9f78a018e831e3f642fc>

struct __cppobj PersonaRepository::reloadEmoteAnimationData::__l2::<lambda_9856da88cb4f9f78a018e831e3f642fc>
{
  std::weak_ptr<PersonaRepository> weakThis;
};

PersonaRepository::update::__l7::<lambda_7d294108bbcaa3b109378acfa57aaad3>

struct __cppobj PersonaRepository::update::__l7::<lambda_7d294108bbcaa3b109378acfa57aaad3>
{
  std::weak_ptr<PersonaRepository> weakThis;
  std::shared_ptr<std::vector<std::string> > loadedPieces;
  const mce::UUID id;
};

PersonaRepository::update::__l7::<lambda_f3b150f0f5b7573cc4b9e2a6f64c7f46>

struct __cppobj PersonaRepository::update::__l7::<lambda_f3b150f0f5b7573cc4b9e2a6f64c7f46>
{
  std::weak_ptr<PersonaRepository> weakThis;
  std::shared_ptr<std::vector<std::string> > loadedPieces;
  Pack *pack;
};

PersonaRepository::tryLoadingTexturePieceTexture::__l4::<lambda_29660483cd96615a32c0c2cde2a0a1be>

struct __cppobj PersonaRepository::tryLoadingTexturePieceTexture::__l4::<lambda_29660483cd96615a32c0c2cde2a0a1be>
{
  PersonaRepository *const __this;
  std::string pieceId;
};

PersonaRepository::tryLoadingTexturePieceTexture::__l4::<lambda_4cb23999558092aaa8df4cd282e6124b>

struct __cppobj PersonaRepository::tryLoadingTexturePieceTexture::__l4::<lambda_4cb23999558092aaa8df4cd282e6124b>
{
};

PersonaRepository::_changePieces::__l14::<lambda_245bdfa0a34cd586d6a14df8447e139c>

struct __cppobj PersonaRepository::_changePieces::__l14::<lambda_245bdfa0a34cd586d6a14df8447e139c>
{
  std::function<void __cdecl(bool)> cb;
};

PersonaRepository::loadPiecePack::__l2::<lambda_5df3b41bbd5a0b1226e95e38b77eacca>

struct __cppobj PersonaRepository::loadPiecePack::__l2::<lambda_5df3b41bbd5a0b1226e95e38b77eacca>
{
  PersonaRepository *const __this;
  mce::UUID *packId;
};

PersonaRepository::beginAsyncInit::__l2::<lambda_2215c89392c779e32b7deb573677dc9f>

struct __cppobj PersonaRepository::beginAsyncInit::__l2::<lambda_2215c89392c779e32b7deb573677dc9f>
{
  std::weak_ptr<PersonaRepository> weakThis;
  std::shared_ptr<std::vector<std::string> > loadedPieces;
};

PersonaRepository::beginAsyncInit::__l2::<lambda_b4947d69284f08399beca0c274379be6>

struct __cppobj PersonaRepository::beginAsyncInit::__l2::<lambda_b4947d69284f08399beca0c274379be6>
{
  std::weak_ptr<PersonaRepository> weakThis;
  std::shared_ptr<std::vector<std::string> > loadedPieces;
};

PaintingRenderer

struct __cppobj PaintingRenderer : ActorRenderer, AppPlatformListener
{
  std::unordered_map<Motive const *,mce::Mesh> mPaintingMeshes;
  mce::TexturePtr mPaintingTex;
};

PaintingRenderer_vtbl

struct /*VFT*/ PaintingRenderer_vtbl
{
  void (__fastcall *~ActorShaderManager)(ActorShaderManager *this);
  mce::Color *(__fastcall *_getOverlayColor)(ActorShaderManager *this, mce::Color *result, Actor *, float);
  void (__fastcall *render)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *renderDebug)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *renderEffects)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *renderTrading)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *, float);
  void (__fastcall *renderFlame)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *renderLeash)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *renderWaterHole)(ActorRenderer *this, BaseActorRenderContext *, ActorRenderData *);
  void (__fastcall *addAdditionalRenderingIfNeeded)(ActorRenderer *this, mce::TextureGroup *);
  void (__fastcall *renderWeaponEffect)(ActorRenderer *this, BaseActorRenderContext *, Actor *);
  void (__fastcall *renderBindEffects)(ActorRenderer *this, BaseActorRenderContext *, Actor *);
  AABB *(__fastcall *getRenderBounds)(ActorRenderer *this, AABB *result, const Actor *);
  Vec3 *(__fastcall *getLeashOffset)(ActorRenderer *this, Vec3 *result, Actor *, float, float, float, bool, bool);
  void (__fastcall *setIsOnScreen)(ActorRenderer *this, Actor *, const bool, float);
  bool (__fastcall *shouldUpdateBonesAndEffectsIfOffScreen)(ActorRenderer *this, RenderParams *);
  bool (__fastcall *shouldUpdateEffectsIfOffScreen)(ActorRenderer *this, RenderParams *);
  void (__fastcall *_bindModelEffectRender)(ActorRenderer *this, BaseActorRenderContext *, Mob *);
};

ProfilingManager::Impl::init::__l2::<lambda_7902db97bb640511b33ee410815a276f>

struct __cppobj ProfilingManager::Impl::init::__l2::<lambda_7902db97bb640511b33ee410815a276f>
{
  ProfilingManager::Impl *const __this;
};

ProfilingManager::Impl::init::__l21::<lambda_5de63696168117d58cfad08fe299e310>

struct __cppobj ProfilingManager::Impl::init::__l21::<lambda_5de63696168117d58cfad08fe299e310>
{
};

PythonCallBackOnHitSubcomponent

struct __cppobj PythonCallBackOnHitSubcomponent : OnHitSubcomponent
{
};

PythonCallBackOnHitSubcomponent_vtbl

struct /*VFT*/ PythonCallBackOnHitSubcomponent_vtbl
{
  void (__fastcall *~OnHitSubcomponent)(OnHitSubcomponent *this);
  void (__fastcall *readfromJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *writetoJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *doOnHitEffect)(OnHitSubcomponent *this, Actor *, ProjectileComponent *);
  const char *(__fastcall *getName)(OnHitSubcomponent *this);
};

ParticleOnHitSubcomponent

struct __cppobj __declspec(align(8)) ParticleOnHitSubcomponent : OnHitSubcomponent
{
  ParticleType mParticleType;
  bool mOnEntityHit;
  bool mOnOtherHit;
  int mNumParticles;
};

ParticleOnHitSubcomponent_vtbl

struct /*VFT*/ ParticleOnHitSubcomponent_vtbl
{
  void (__fastcall *~OnHitSubcomponent)(OnHitSubcomponent *this);
  void (__fastcall *readfromJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *writetoJSON)(OnHitSubcomponent *this, Json::Value *);
  void (__fastcall *doOnHitEffect)(OnHitSubcomponent *this, Actor *, ProjectileComponent *);
  const char *(__fastcall *getName)(OnHitSubcomponent *this);
};

PistonBlock

struct __cppobj __declspec(align(8)) PistonBlock : ActorBlock
{
  PistonBlock::Type mType;
};

PistonBlock_vtbl

struct /*VFT*/ PistonBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  ItemInstance *(__fastcall *getEntityResourceItem)(ActorBlock *this, ItemInstance *result, Random *, const BlockActor *, int);
};

PistonBlockActorRenderer

struct __cppobj PistonBlockActorRenderer : BlockActorRenderer
{
  mce::TexturePtr mPistonArmTex;
  mce::TexturePtr mPistonArmStickyTex;
  PistonArmModel mPistonArm;
};

PistonBlockActorRenderer_vtbl

struct /*VFT*/ PistonBlockActorRenderer_vtbl
{
  void (__fastcall *~ActorShaderManager)(ActorShaderManager *this);
  mce::Color *(__fastcall *_getOverlayColor)(ActorShaderManager *this, mce::Color *result, Actor *, float);
  void (__fastcall *render)(BlockActorRenderer *this, BaseActorRenderContext *, BlockActorRenderData *);
  void (__fastcall *renderAlpha)(BlockActorRenderer *this, BaseActorRenderContext *, BlockActorRenderData *);
  std::vector<NameTagRenderObject> *(__fastcall *extractText)(BlockActorRenderer *this, std::vector<NameTagRenderObject> *result, Tessellator *, BlockActor *, const std::string *, const std::vector<int> *, Vec3, bool);
};

Palette

struct __cppobj Palette
{
};

PlayerRenderChunkModificationLatencyTracker::TimeDelta

struct __cppobj __declspec(align(8)) PlayerRenderChunkModificationLatencyTracker::TimeDelta
{
  std::string mName;
  float mDeltaSeconds;
};

PlayerRenderChunkModificationLatencyTracker::TimeMarker

struct __cppobj PlayerRenderChunkModificationLatencyTracker::TimeMarker
{
  std::string mName;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mTime;
};

PlayerRenderChunkModificationLatencyTracker

struct __cppobj PlayerRenderChunkModificationLatencyTracker
{
  bool mTimingIsActive;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStartTime;
  std::vector<PlayerRenderChunkModificationLatencyTracker::TimeMarker> mTimeMarkers;
  BlockPos mBlockToTrack;
  SubChunkPos mRenderChunkPosToTrack;
};

ParticlesPointCloudEvent

struct __cppobj ParticlesPointCloudEvent
{
  ParticleType mParticleType;
  std::vector<std::pair<Vec3,Vec3>> mParticles;
};

ptr_move<std::shared_ptr<RenderChunkInstanced> >

struct __cppobj ptr_move<std::shared_ptr<RenderChunkInstanced> >
{
};

PostprocessRenderModule::declareFullscreenPass::__l2::PostprocessPass

const struct __cppobj PostprocessRenderModule::declareFullscreenPass::__l2::PostprocessPass
{
  mce::MaterialPtr mFullscreenMaterial;
  glm::tvec2<float,0> mTextureDimensions;
  std::function<void __cdecl(mce::RenderContext &,IClientInstance &)> mPreRenderCallback;
  IClientInstance *mClient;
};

PlayerRenderView::_declarePasses::__l19::<lambda_fd48232efcc19ba0bbffd230344f0add>

struct __cppobj PlayerRenderView::_declarePasses::__l19::<lambda_fd48232efcc19ba0bbffd230344f0add>
{
};

PlayerRenderView::_declarePasses::__l16::<lambda_270b09ff7d1614eff2236703a8648d0a>

struct __cppobj PlayerRenderView::_declarePasses::__l16::<lambda_270b09ff7d1614eff2236703a8648d0a>
{
  PlayerRenderView *const __this;
};

PlayerRenderView::_declarePasses::__l2::<lambda_75d793f24d52434fc09af39da3e425e3>

struct __cppobj PlayerRenderView::_declarePasses::__l2::<lambda_75d793f24d52434fc09af39da3e425e3>
{
};

PostprocessRenderModule::declareFullscreenPass::__l2::<lambda_37fe96ee7aea597de53c5a46a0e38524>

struct __cppobj PostprocessRenderModule::declareFullscreenPass::__l2::<lambda_37fe96ee7aea597de53c5a46a0e38524>
{
};

PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_4a57614e42f484fdeccb223dc00eb8e1>

struct __cppobj PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_4a57614e42f484fdeccb223dc00eb8e1>
{
  PlayerRenderView *const __this;
  mce::RenderStage *leftStage;
  mce::RenderStage *rightStage;
  mce::RenderStage *livingRoomStage;
};

PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_88348bdedb218924fb3016ff33e9de80>

struct __cppobj PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_88348bdedb218924fb3016ff33e9de80>
{
  PlayerRenderView *const __this;
  mce::RenderStage *livingRoomStage;
  mce::RenderStage *gameStage;
};

PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_69e4fe0242596a3ffaabceb11ae9f01a>

struct __cppobj PlayerRenderView::setupRenderOrderPiggybackingExistingRenderStages::__l2::<lambda_69e4fe0242596a3ffaabceb11ae9f01a>
{
  mce::RenderStage *gameStage;
};

PackLoadError_vtbl

struct /*VFT*/ PackLoadError_vtbl
{
  void (__fastcall *~PackError)(PackError *this);
  std::string *(__fastcall *getLocErrorMessage)(PackError *this, std::string *result);
  const std::unordered_map<int,std::string> *(__fastcall *getLocErrorMessageMap)(PackError *this);
  const std::unordered_map<int,std::string> *(__fastcall *getEventErrorMessageMap)(PackError *this);
};

PersonaValidationDocument

struct __cppobj __declspec(align(8)) PersonaValidationDocument : DurableDocument
{
  bool mIsPlatformLocked;
  bool mCanWearItem;
};

PersonaValidationResponse

struct __cppobj __declspec(align(8)) PersonaValidationResponse : CatalogSearchResponseCallbackHandler
{
  std::shared_ptr<PersonaProfile> mUserProfile;
  const std::string mPlatformId;
  const unsigned int mDesiredResultCount;
  std::function<void __cdecl(PersonaAppearance const &,enum persona::ProfileType)> mCallback;
  PersonaAppearance mAppearance;
  persona::ProfileType mProfileType;
};

PersonaValidationResponse_vtbl

struct /*VFT*/ PersonaValidationResponse_vtbl
{
  void (__fastcall *~ResponseCallbackHandler)(ResponseCallbackHandler *this);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::array *, int, const CatalogBackend *, SearchRequestURLType);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::value *);
  void (__fastcall *handleResponseCallback)(ResponseCallbackHandler *this);
};

PersonaLegacyValidationResponse

struct __cppobj PersonaLegacyValidationResponse : CatalogSearchResponseCallbackHandler
{
  PersonaAppearance mAppearance;
  std::shared_ptr<PersonaProfile> mUserProfile;
  const std::string mPlatformId;
  const std::string mLegacySkinId;
  std::function<void __cdecl(PersonaAppearance const &,enum persona::ProfileType)> mCallback;
};

PersonaLegacyValidationResponse_vtbl

struct /*VFT*/ PersonaLegacyValidationResponse_vtbl
{
  void (__fastcall *~ResponseCallbackHandler)(ResponseCallbackHandler *this);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::array *, int, const CatalogBackend *, SearchRequestURLType);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::value *);
  void (__fastcall *handleResponseCallback)(ResponseCallbackHandler *this);
};

PersonaEmoteValidationResponse

struct __cppobj PersonaEmoteValidationResponse : CatalogSearchResponseCallbackHandler
{
  const std::string mPlatformId;
  std::function<void __cdecl(std::vector<std::string> const &)> mCallback;
  std::vector<std::string> mPersonaProductIds;
};

PersonaEmoteValidationResponse_vtbl

struct /*VFT*/ PersonaEmoteValidationResponse_vtbl
{
  void (__fastcall *~ResponseCallbackHandler)(ResponseCallbackHandler *this);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::array *, int, const CatalogBackend *, SearchRequestURLType);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::value *);
  void (__fastcall *handleResponseCallback)(ResponseCallbackHandler *this);
};

PostReview

struct __cppobj PostReview : RequestHandler
{
  std::shared_ptr<CatalogBackend> mBackend;
  const std::string mAcceptLanguage;
  CreateReviewParams mParams;
  std::function<void __cdecl(bool)> mCallback;
  std::shared_ptr<bool> mSuccess;
};

PostReview_vtbl

struct /*VFT*/ PostReview_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

PlayFab::PlayFabBaseModel

struct __cppobj PlayFab::PlayFabBaseModel
{
  PlayFab::PlayFabBaseModel_vtbl *__vftable /*VFT*/;
};

PlayFab::PlayFabBaseModel_vtbl

struct /*VFT*/ PlayFab::PlayFabBaseModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<__int64>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<__int64>
{
  __int64 boxedValue;
  bool isSet;
};

PersonaService::_saveDirtyProfiles::__l19::<lambda_721e9c3541bc3735421baaea0ee0c1b4>

struct __cppobj PersonaService::_saveDirtyProfiles::__l19::<lambda_721e9c3541bc3735421baaea0ee0c1b4>
{
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > startTime;
};

PersonaResponse

struct __cppobj __declspec(align(8)) PersonaResponse : ResponseCallbackHandler
{
  _BYTE mStatusCode[4];
};

PersonaResponse_vtbl

struct /*VFT*/ PersonaResponse_vtbl
{
  void (__fastcall *~ResponseCallbackHandler)(ResponseCallbackHandler *this);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::array *, int, const CatalogBackend *, SearchRequestURLType);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::value *);
  void (__fastcall *handleResponseCallback)(ResponseCallbackHandler *this);
};

PersonaPutResponse

struct __cppobj PersonaPutResponse : PersonaResponse
{
  std::function<void __cdecl(void)> mCallback;
};

PersonaPutResponse_vtbl

struct /*VFT*/ PersonaPutResponse_vtbl
{
  void (__fastcall *~ResponseCallbackHandler)(ResponseCallbackHandler *this);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::array *, int, const CatalogBackend *, SearchRequestURLType);
  bool (__fastcall *parseResponse)(ResponseCallbackHandler *this, const struct web::json::value *);
  void (__fastcall *handleResponseCallback)(ResponseCallbackHandler *this);
};

PlayFabCurrencyRequest

struct __cppobj PlayFabCurrencyRequest : RequestHandler
{
  std::function<void __cdecl(std::unordered_map<enum VirtualCurrencyType,unsigned int> &&)> mCallback;
  std::unordered_map<enum VirtualCurrencyType,unsigned int> mResponseCurrencies;
};

PlayFabCurrencyRequest_vtbl

struct /*VFT*/ PlayFabCurrencyRequest_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

PlayFabInventoryRequest

struct __cppobj PlayFabInventoryRequest : RequestHandler
{
  std::function<void __cdecl(std::string &&)> mCallback;
  std::string mRealDeviceId;
  std::string mResultData;
};

PlayFabInventoryRequest_vtbl

struct /*VFT*/ PlayFabInventoryRequest_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

PlayFabPurchaseCatalogOfferRequest

struct __cppobj __declspec(align(8)) PlayFabPurchaseCatalogOfferRequest : RequestHandler
{
  std::string mCorrelationId;
  std::string mProductId;
  std::string mPlatformStoreName;
  std::string mTransactionId;
  std::string mExpectedPrice;
  std::string mSalesDocID;
  std::function<void __cdecl(enum TransactionStatus)> mCallback;
  TransactionStatus mTransactionStatus;
};

PlayFabPurchaseCatalogOfferRequest_vtbl

struct /*VFT*/ PlayFabPurchaseCatalogOfferRequest_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

PlayFabPurchaseCurrencyRequest

struct __cppobj PlayFabPurchaseCurrencyRequest : RequestHandler
{
  bool mTransactionSuccessful;
  __declspec(align(4)) _BYTE mStorePlatform[4];
  std::string mReceipt;
  PurchaseInfo mPurchaseInfo;
  std::function<void __cdecl(bool)> mCallback;
  std::unordered_map<enum VirtualCurrencyType,unsigned int> mResponseCurrencies;
};

PlayFabPurchaseCurrencyRequest_vtbl

struct /*VFT*/ PlayFabPurchaseCurrencyRequest_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

PlayFabReceiptPemCertificateRequest

struct __cppobj PlayFabReceiptPemCertificateRequest : RequestHandler
{
  std::function<void __cdecl(std::string &&)> mCallback;
  std::string mResultData;
};

PlayFabReceiptPemCertificateRequest_vtbl

struct /*VFT*/ PlayFabReceiptPemCertificateRequest_vtbl
{
  void (__fastcall *~RequestHandler)(RequestHandler *this);
  void (__fastcall *send)(RequestHandler *this);
  void (__fastcall *sendCachedRequest)(RequestHandler *this);
  bool (__fastcall *update)(RequestHandler *this);
  bool (__fastcall *isDone)(RequestHandler *this);
  void (__fastcall *onComplete)(RequestHandler *this);
  bool (__fastcall *canSendRequest)(RequestHandler *this);
  void (__fastcall *fireTelemetry)(RequestHandler *this, IMinecraftEventing *);
};

ProtocolActivation

struct __cppobj ProtocolActivation
{
  char uri[512];
};

Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::AccessTag

struct __cppobj Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad
{
};

Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >

struct __cppobj Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad
{
  std::shared_ptr<Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::AccessTag> mAccessTag;
  MPMCQueue<std::unique_ptr<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources>> > mPool;
  std::function<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> * __cdecl(void)> mAllocator;
};

Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::Deleter

struct __cppobj Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad
{
  std::weak_ptr<Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::AccessTag> mParentLifetime;
  Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> > *mParentPool;
};

Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad,mce::framebuilder::gamecomponents::FadeToBlackEffect,mce::framebuilder::bgfxbridge::RTXMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::VanillaMinecraftFrameRendererResources,mce::framebuilder::bgfxbridge::HolographicMinecraftFrameRendererResources> >::WithCustomAllocator

struct __cppobj Pool<dragon::frameobject::Frame<mce::framebuilder::gamecomponents::AlphaTestCracks,mce::framebuilder::gamecomponents::Atmosphere,mce::framebuilder::gamecomponents::BlendedCracksObject,mce::framebuilder::gamecomponents::EnvironmentalText,mce::framebuilder::gamecomponents::Gameface,mce::framebuilder::gamecomponents::InLevelCubeMapObject,mce::framebuilder::gamecomponents::ItemInHandObject,mce::framebuilder::gamecomponents::SceneObjectActors,mce::framebuilder::gamecomponents::TransparentItemInWorldObject,mce::framebuilder::gamecomponents::WaterHoleObject,mce::framebuilder::gamecomponents::PlayerUI,mce::framebuilder::gamecomponents::PlayerVision,mce::framebuilder::gamecomponents::OverlayUI,mce::framebuilder::gamecomponents::VrConfiguration,mce::framebuilder::gamecomponents::VrPresenceObject,mce::framebuilder::gamecomponents::LivingRoomViewFilter,mce::framebuilder::gamecomponents::LivingRoomTransitionFilter,mce::framebuilder::gamecomponents::LivingRoomSceneObject,mce::framebuilder::gamecomponents::VrFloatingUiQuad
{
};

PlayerTickPolicy::createGreedyPolicy::__l2::GreedyTickPolicy

struct __cppobj PlayerTickPolicy::createGreedyPolicy::__l2::GreedyTickPolicy : IPlayerTickPolicy
{
};

PlayerTickPolicy::createGreedyPolicy::__l2::GreedyTickPolicy_vtbl

struct /*VFT*/ PlayerTickPolicy::createGreedyPolicy::__l2::GreedyTickPolicy_vtbl
{
  void (__fastcall *~IPlayerTickPolicy)(IPlayerTickPolicy *this);
  void (__fastcall *setupTick)(IPlayerTickPolicy *this, PlayerTickComponent *);
  IPlayerTickPolicy::TickAction (__fastcall *shouldTickPlayer)(IPlayerTickPolicy *this, const PlayerTickComponent *);
};

PlayerTickPolicy::createThrottledTickPolicy::__l2::ThrottledTickPolicy

struct __cppobj PlayerTickPolicy::createThrottledTickPolicy::__l2::ThrottledTickPolicy : IPlayerTickPolicy
{
  const unsigned __int8 mMaxBatchedTicks;
  const unsigned __int64 mMaxTickCredits;
};

PlayerTickPolicy::createThrottledTickPolicy::__l2::ThrottledTickPolicy_vtbl

struct /*VFT*/ PlayerTickPolicy::createThrottledTickPolicy::__l2::ThrottledTickPolicy_vtbl
{
  void (__fastcall *~IPlayerTickPolicy)(IPlayerTickPolicy *this);
  void (__fastcall *setupTick)(IPlayerTickPolicy *this, PlayerTickComponent *);
  IPlayerTickPolicy::TickAction (__fastcall *shouldTickPlayer)(IPlayerTickPolicy *this, const PlayerTickComponent *);
};

PlayerTickSystem

struct __cppobj PlayerTickSystem : ITickingSystem, LevelEventListener
{
};

PlayerTickSystem_vtbl

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

PlayerFogPacket::read::__l2::<lambda_a5ea82baf753a639b33e182b0ff0f38f>

struct __cppobj PlayerFogPacket::read::__l2::<lambda_a5ea82baf753a639b33e182b0ff0f38f>
{
};

PlayerFogPacket::write::__l2::<lambda_1b14e6212d29435a1eb6c4384abae34c>

struct __cppobj PlayerFogPacket::write::__l2::<lambda_1b14e6212d29435a1eb6c4384abae34c>
{
};

PackSettingsError_vtbl

struct /*VFT*/ PackSettingsError_vtbl
{
  void (__fastcall *~PackError)(PackError *this);
  std::string *(__fastcall *getLocErrorMessage)(PackError *this, std::string *result);
  const std::unordered_map<int,std::string> *(__fastcall *getLocErrorMessageMap)(PackError *this);
  const std::unordered_map<int,std::string> *(__fastcall *getEventErrorMessageMap)(PackError *this);
};

PackStackStorage

struct __cppobj PackStackStorage : IPackStackStorage
{
  std::unique_ptr<IPackStackStorageFileSystem> mFileSystem;
  std::vector<PackStackStorage::PackEntry> mPacks;
  std::shared_ptr<IPackStorage> mLoosePack;
  std::function<std::unique_ptr<IPackStorage> __cdecl(void)> mCreatePack;
  std::vector<PackStackStorage::PackEntry> mPacksToDiscard;
  std::unique_ptr<IPackStackStorageTelemetry> mTelemetry;
};

PackStorageFileSystem

struct __cppobj PackStorageFileSystem : IPackStackStorageFileSystem
{
  Core::PathBuffer<std::string > mRoot;
  Core::PathBuffer<std::string > mSubdirectory;
};

PackStackStorageTelemetry

struct __cppobj PackStackStorageTelemetry : IPackStackStorageTelemetry
{
  IMinecraftEventing *mEventing;
};

PackStorage::deletePackCache::__l2::<lambda_1b62e3f85874ab682abdf33a6bdb8814>

struct __cppobj PackStorage::deletePackCache::__l2::<lambda_1b62e3f85874ab682abdf33a6bdb8814>
{
};

PackStackStorage::hintSessionType::__l12::<lambda_33d88fb3f98cb77b557beada7d233d96>

struct __cppobj PackStackStorage::hintSessionType::__l12::<lambda_33d88fb3f98cb77b557beada7d233d96>
{
  std::shared_ptr<IPackStorage> storage;
};

PackStackStorage::hintSessionType::__l9::<lambda_5885e97b5da681d6f2e01cf8d8451804>

struct __cppobj PackStackStorage::hintSessionType::__l9::<lambda_5885e97b5da681d6f2e01cf8d8451804>
{
  std::shared_ptr<IPackStorage> storage;
};

PackStackStorage::onLoadSessionEnd::__l18::<lambda_fc0b6cd085562af88a7599b3cb378a5f>

struct __cppobj PackStackStorage::onLoadSessionEnd::__l18::<lambda_fc0b6cd085562af88a7599b3cb378a5f>
{
  PackStackStorage *const __this;
  std::shared_ptr<IPackStorage> pack;
};

PackStorage::AccessHistory

struct __cppobj PackStorage::AccessHistory
{
  std::vector<Core::Path> mHistory;
  std::unordered_set<unsigned __int64> mAdded;
  std::mutex mHistoryMutex;
  std::atomic<unsigned __int64> mMisses;
  std::atomic<unsigned __int64> mBadFiles;
  std::atomic<unsigned __int64> mHits;
};

PackStorage::PackStorageImpl

struct __cppobj PackStorage::PackStorageImpl : IPackStorage, Bedrock::EnableNonOwnerReferences
{
  std::unordered_map<std::string,PackStorage::FileEntry> mFiles;
  __int64 mNewestFile;
  std::unique_ptr<ICRCDataInput> mStream;
  std::shared_ptr<ITaskGroupProxy> mIOGroup;
  std::unique_ptr<BatchWorker<PackStorage::PendingTask>> mIOTasks;
  std::unique_ptr<BatchWorker<PackStorage::PendingTask>> mCallbackTasks;
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mInitializerTask;
  PackStorage::AccessHistory mHistory;
  std::unique_ptr<IPackStoragePolicy> mPolicy;
};

PackStorage::PackStorageImpl_vtbl

struct /*VFT*/ PackStorage::PackStorageImpl_vtbl
{
  void (__fastcall *~IPackStorage)(IPackStorage *this);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<std::string > > *(__fastcall *getResource)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<std::string > > *result, const Core::Path *, std::shared_ptr<IPackStorageFallback const >);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *writeOptimizedPack)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, std::unique_ptr<IDataOutput>, std::shared_ptr<IPackStorageFallback const >);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *readOptimizedPack)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, std::unique_ptr<IDataInput>);
  bool (__fastcall *wantsToWriteOptimizedPack)(IPackStorage *this);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *closePackStream)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result);
  PackStorageMetrics *(__fastcall *getMetrics)(IPackStorage *this, PackStorageMetrics *result);
};

PackStorage::PackFooter

struct __cppobj PackStorage::PackFooter
{
  unsigned __int64 mIndexOffset;
  __int64 mLastModified;
  __int64 mAppLastModified;
  char mCommitId[40];
  int mVersionCode;
  unsigned int mCRC;
};

PackStorage::PackStorageImpl::readOptimizedPack::__l2::<lambda_aa328192fb3f8fe908cc2fcdfa50f1ef>::()::__l2::<lambda_5791056fa0ffbea34fc54057b3e8238e>

struct __cppobj PackStorage::PackStorageImpl::readOptimizedPack::__l2::<lambda_aa328192fb3f8fe908cc2fcdfa50f1ef>::()::__l2::<lambda_5791056fa0ffbea34fc54057b3e8238e>
{
  Bedrock::NonOwnerPointer<PackStorage::PackStorageImpl> *self;
};

PackStorage::PackStorageImpl::_processPendingIOItem::__l2::<lambda_497389d3a9ef0e52b45a8cefedfc03f1>

struct __cppobj PackStorage::PackStorageImpl::_processPendingIOItem::__l2::<lambda_497389d3a9ef0e52b45a8cefedfc03f1>
{
  PackStorage::PendingTask *item;
  PackStorage::PackStorageImpl *const __this;
};

PackStorage::DefaultPolicy

struct __cppobj PackStorage::DefaultPolicy : IPackStoragePolicy
{
};

PackStorage::DefaultPolicy_vtbl

struct /*VFT*/ PackStorage::DefaultPolicy_vtbl
{
  void (__fastcall *~IPackStoragePolicy)(IPackStoragePolicy *this);
  bool (__fastcall *shouldWriteOptimizedPack)(IPackStoragePolicy *this, const PackStorageMetrics *);
  IPackStoragePolicy::CacheInvalidationMode (__fastcall *getCacheInvalidationMode)(IPackStoragePolicy *this);
};

PackStorage::createLooseStorageFallback::__l2::Fallback

struct __cppobj PackStorage::createLooseStorageFallback::__l2::Fallback : IPackStorageFallback
{
};

PackStorage::createLooseStorageFallback::__l2::Fallback_vtbl

struct /*VFT*/ PackStorage::createLooseStorageFallback::__l2::Fallback_vtbl
{
  void (__fastcall *~IPackStorageFallback)(IPackStorageFallback *this);
  std::string *(__fastcall *getResource)(IPackStorageFallback *this, std::string *result, const Core::Path *);
  __int64 (__fastcall *getLastModified)(IPackStorageFallback *this, const Core::Path *);
  std::unique_ptr<IDataOutput> *(__fastcall *createEncryptor)(IPackStorageFallback *this, std::unique_ptr<IDataOutput> *result, std::unique_ptr<IDataOutput>);
  std::unique_ptr<IDataInput> *(__fastcall *createDecryptor)(IPackStorageFallback *this, std::unique_ptr<IDataInput> *result, std::unique_ptr<IDataInput>);
};

PackStorage::PackStorageImpl::_verifyFileUpToDate::__l5::<lambda_e929aab9989f624044a665b6451109e4>

struct __cppobj PackStorage::PackStorageImpl::_verifyFileUpToDate::__l5::<lambda_e929aab9989f624044a665b6451109e4>
{
  const Core::Path resourceName;
  std::shared_ptr<IPackStorageFallback const > packAccess;
  Bedrock::NonOwnerPointer<PackStorage::PackStorageImpl> self;
  std::shared_ptr<Bedrock::Threading::AsyncDeferredResultT<bool> > result;
};

PackStorage::RawPackStorage

struct __cppobj PackStorage::RawPackStorage : IPackStorage
{
  BatchWorker<PackStorage::PendingTask> mWorker;
};

PackStorage::RawPackStorage_vtbl

struct /*VFT*/ PackStorage::RawPackStorage_vtbl
{
  void (__fastcall *~IPackStorage)(IPackStorage *this);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<std::string > > *(__fastcall *getResource)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<std::string > > *result, const Core::Path *, std::shared_ptr<IPackStorageFallback const >);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *writeOptimizedPack)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, std::unique_ptr<IDataOutput>, std::shared_ptr<IPackStorageFallback const >);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *readOptimizedPack)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result, std::unique_ptr<IDataInput>);
  bool (__fastcall *wantsToWriteOptimizedPack)(IPackStorage *this);
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *(__fastcall *closePackStream)(IPackStorage *this, std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > *result);
  PackStorageMetrics *(__fastcall *getMetrics)(IPackStorage *this, PackStorageMetrics *result);
};

PackStorage::RawPackStorage::<lambda_ed23f787af52dcf5aabb7c1388b47e74>

struct __cppobj PackStorage::RawPackStorage::<lambda_ed23f787af52dcf5aabb7c1388b47e74>
{
  PackStorage::RawPackStorage *const __this;
};

PlayAnimationCommand

struct __cppobj __declspec(align(8)) PlayAnimationCommand : Command
{
  CommandSelector<Actor> mTargets;
  std::string mAnimation;
  std::string mNextState;
  std::string mStopExpression;
  std::string mController;
  float mBlendOutTime;
};

PlayAnimationCommand_vtbl

struct /*VFT*/ PlayAnimationCommand_vtbl
{
  void (__fastcall *~Command)(Command *this);
  void (__fastcall *execute)(Command *this, const CommandOrigin *, CommandOutput *);
};

Panda

struct __cppobj Panda : Animal
{
  float mRollAmount;
  float mRollAmountO;
  bool mFinishedTransitionLastTick;
  int mSneezeCounter;
};

PolarBear

struct __cppobj PolarBear : Animal
{
  float clientSideStandAnimationO;
  float clientSideStandAnimation;
};

Parrot

struct __cppobj __declspec(align(8)) Parrot : Animal
{
  float mFlap;
  float mOFlap;
  float mFlapSpeed;
  float mOFlapSpeed;
  float mFlapping;
};

persona::<lambda_90fbfbd9dbf76e54fa116a1770bfbe80>::()::__l2::Literal

struct __cppobj persona::<lambda_90fbfbd9dbf76e54fa116a1770bfbe80>::()::__l2::Literal
{
};

persona::<lambda_90fbfbd9dbf76e54fa116a1770bfbe80>

struct __cppobj persona::<lambda_90fbfbd9dbf76e54fa116a1770bfbe80>
{
};

persona::<lambda_70ec61b444458b0c1c1d37478cb63047>::()::__l2::Literal

struct __cppobj persona::<lambda_70ec61b444458b0c1c1d37478cb63047>::()::__l2::Literal
{
};

persona::<lambda_70ec61b444458b0c1c1d37478cb63047>

struct __cppobj persona::<lambda_70ec61b444458b0c1c1d37478cb63047>
{
};

persona::<lambda_16e7b2f71bdc87066fa9402922251d9d>::()::__l2::Literal

struct __cppobj persona::<lambda_16e7b2f71bdc87066fa9402922251d9d>::()::__l2::Literal
{
};

persona::<lambda_16e7b2f71bdc87066fa9402922251d9d>

struct __cppobj persona::<lambda_16e7b2f71bdc87066fa9402922251d9d>
{
};

persona::<lambda_19bc83edccfba190371370cbae2a8ab0>::()::__l2::Literal

struct __cppobj persona::<lambda_19bc83edccfba190371370cbae2a8ab0>::()::__l2::Literal
{
};

persona::<lambda_19bc83edccfba190371370cbae2a8ab0>

struct __cppobj persona::<lambda_19bc83edccfba190371370cbae2a8ab0>
{
};

ParticleEffectResponse

struct __cppobj __declspec(align(4)) ParticleEffectResponse : EventResponse
{
  std::string mEffect;
  int mData;
  _BYTE mTarget[2];
};

ParticleEffectResponse_vtbl

struct /*VFT*/ ParticleEffectResponse_vtbl
{
  void (__fastcall *~EventResponse)(EventResponse *this);
  const std::string *(__fastcall *getName)(EventResponse *this);
  void (__fastcall *executeAction)(EventResponse *this, RenderParams *);
  void (__fastcall *buildSchema)(EventResponse *this, std::shared_ptr<JsonUtil::JsonSchemaObjectNode<JsonUtil::EmptyClass,EventResponseCollection> > *, const Factory<EventResponse> *);
};

PlaySoundResponse

struct __cppobj __declspec(align(8)) PlaySoundResponse : EventResponse
{
  std::string mSound;
  _BYTE mTarget[2];
};

PlaySoundResponse_vtbl

struct /*VFT*/ PlaySoundResponse_vtbl
{
  void (__fastcall *~EventResponse)(EventResponse *this);
  const std::string *(__fastcall *getName)(EventResponse *this);
  void (__fastcall *executeAction)(EventResponse *this, RenderParams *);
  void (__fastcall *buildSchema)(EventResponse *this, std::shared_ptr<JsonUtil::JsonSchemaObjectNode<JsonUtil::EmptyClass,EventResponseCollection> > *, const Factory<EventResponse> *);
};

PerlinNoise

struct __cppobj __declspec(align(8)) PerlinNoise
{
  const int mLevels;
  const int mMinLevel;
  std::vector<ImprovedNoise> mNoiseLevels;
  float mNormalizationFactor;
};

PoolElementStructurePiece

struct __cppobj __declspec(align(8)) PoolElementStructurePiece : StructurePiece
{
  BoundingBox mCachedPieceBounds;
  int mCachedPieceBaseY;
  int mCachedXCenter;
  int mCachedZCenter;
  float mCachedMaxRadius;
  const StructurePoolElement *mElement;
  BlockPos mPosition;
  Rotation mRotation;
  JigsawJunction mJigsawJunction;
  std::unordered_map<BlockPos,std::optional<ActorDefinitionIdentifier>> mEntitiesToPlace;
  BlockPos mRefPos;
};

PieceWeight

struct __cppobj __declspec(align(8)) PieceWeight
{
  std::string pieceClass;
  int weight;
  int placeCount;
  int maxPlaceCount;
  int minDepth;
  bool allowInRow;
};

ParticleTypeMap

struct __cppobj ParticleTypeMap
{
};

ParticleEffectResponse::buildSchema::__l2::<lambda_de1b04c552a0438e8279206be094e199>

struct __cppobj ParticleEffectResponse::buildSchema::__l2::<lambda_de1b04c552a0438e8279206be094e199>
{
};

ParticleEffectResponse::buildSchema::__l2::<lambda_0034dab471f323b034ce00aa0e0dcd56>

struct __cppobj ParticleEffectResponse::buildSchema::__l2::<lambda_0034dab471f323b034ce00aa0e0dcd56>
{
};

ParticleEffectResponse::buildSchema::__l2::<lambda_cae2e7ef37368a7ac80f012ba6c9ef27>

struct __cppobj ParticleEffectResponse::buildSchema::__l2::<lambda_cae2e7ef37368a7ac80f012ba6c9ef27>
{
  const Factory<EventResponse> *factory;
};

PlaySoundResponse::buildSchema::__l2::<lambda_2dde32ae6f785840a14eee35786885c6>

struct __cppobj PlaySoundResponse::buildSchema::__l2::<lambda_2dde32ae6f785840a14eee35786885c6>
{
};

PlaySoundResponse::buildSchema::__l2::<lambda_7c3cc20b051dafad0999cc3dac165103>

struct __cppobj PlaySoundResponse::buildSchema::__l2::<lambda_7c3cc20b051dafad0999cc3dac165103>
{
  const Factory<EventResponse> *factory;
};

PeekDefinition

struct __cppobj PeekDefinition
{
  DefinitionTrigger mOnOpen;
  DefinitionTrigger mOnClose;
  DefinitionTrigger mOnTargetOpen;
};

PeekComponent

struct __cppobj PeekComponent : IEntityComponent
{
  bool mHadTarget;
  int mDuration;
};

PhysicsDefinition

struct __cppobj PhysicsDefinition
{
  bool mHasGravity;
  bool mHasCollision;
};

PhysicsComponent

struct __cppobj PhysicsComponent : IEntityComponent
{
};

PreferredPathComponent

struct __cppobj PreferredPathComponent : IEntityComponent
{
};

PushableComponent

struct __cppobj PushableComponent : IEntityComponent
{
  bool mIsPushable;
  bool mIsPushableByPiston;
  float mPushthrough;
};

ProjectileSystem

struct __cppobj ProjectileSystem : ITickingSystem
{
};

ProjectileSystem_vtbl

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

PacketReplayNetworkHandler

struct __cppobj PacketReplayNetworkHandler : NetEventCallback
{
  NetworkHandler *mNetworkHandler;
  const std::string mBotName;
  LocalAuthentication mLocalAuthentication;
  ActorRuntimeID mRuntimeID;
  bool mIsDisconnected;
  std::function<void __cdecl(std::chrono::duration<__int64,std::ratio<1,1000> > const &)> mNetworkStatHandler;
};

PacketHandlerDispatcherInstance<LoginPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<LoginPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LoginPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LoginPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayStatusPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<PlayStatusPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<PlayStatusPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayStatusPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PositionTrackingDBServerBroadcastPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<PositionTrackingDBServerBroadcastPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<PositionTrackingDBServerBroadcastPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PositionTrackingDBServerBroadcastPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PositionTrackingDBClientRequestPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<PositionTrackingDBClientRequestPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<PositionTrackingDBClientRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PositionTrackingDBClientRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ServerToClientHandshakePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<ServerToClientHandshakePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ServerToClientHandshakePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ServerToClientHandshakePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ClientToServerHandshakePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<ClientToServerHandshakePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ClientToServerHandshakePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ClientToServerHandshakePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ClientCacheStatusPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<ClientCacheStatusPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ClientCacheStatusPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ClientCacheStatusPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ClientCacheBlobStatusPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<ClientCacheBlobStatusPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ClientCacheBlobStatusPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ClientCacheBlobStatusPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ClientCacheMissResponsePacket,1>

struct __cppobj PacketHandlerDispatcherInstance<ClientCacheMissResponsePacket,1> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ClientCacheMissResponsePacket,1>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ClientCacheMissResponsePacket,1>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ResourcePacksInfoPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<ResourcePacksInfoPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<ResourcePacksInfoPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ResourcePacksInfoPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ResourcePackStackPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ResourcePackStackPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<DisconnectPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<DisconnectPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<DisconnectPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<DisconnectPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetTimePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<SetTimePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<SetTimePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetTimePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetDimensionLocalTimePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<SetDimensionLocalTimePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<SetDimensionLocalTimePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetDimensionLocalTimePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TextPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<TextPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<TextPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TextPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StartGamePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<StartGamePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<StartGamePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StartGamePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddActorPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<AddActorPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<AddActorPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddActorPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddEntityPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<AddEntityPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<AddEntityPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddEntityPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddItemActorPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<AddItemActorPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<AddItemActorPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddItemActorPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TakeItemActorPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<TakeItemActorPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<TakeItemActorPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TakeItemActorPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddPlayerPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<AddPlayerPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<AddPlayerPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddPlayerPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MoveActorAbsolutePacket,0>

struct __cppobj PacketHandlerDispatcherInstance<MoveActorAbsolutePacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<MoveActorAbsolutePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MoveActorAbsolutePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MoveActorDeltaPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<MoveActorDeltaPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<MoveActorDeltaPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MoveActorDeltaPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MovePlayerPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<MovePlayerPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<MovePlayerPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MovePlayerPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RiderJumpPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<RiderJumpPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<RiderJumpPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RiderJumpPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RespawnPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<RespawnPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<RespawnPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RespawnPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RemoveActorPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<RemoveActorPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<RemoveActorPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RemoveActorPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RemoveEntityPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<RemoveEntityPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<RemoveEntityPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RemoveEntityPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateBlockPacket,1>

struct __cppobj PacketHandlerDispatcherInstance<UpdateBlockPacket,1> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<UpdateBlockPacket,1>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateBlockPacket,1>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateBlockSyncedPacket,1>

struct __cppobj PacketHandlerDispatcherInstance<UpdateBlockSyncedPacket,1> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<UpdateBlockSyncedPacket,1>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateBlockSyncedPacket,1>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SpawnParticleEffectPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<SpawnParticleEffectPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<SpawnParticleEffectPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SpawnParticleEffectPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelSoundEventPacketV2,0>

struct __cppobj PacketHandlerDispatcherInstance<LevelSoundEventPacketV2,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LevelSoundEventPacketV2,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelSoundEventPacketV2,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelSoundEventPacketV1,0>

struct __cppobj PacketHandlerDispatcherInstance<LevelSoundEventPacketV1,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LevelSoundEventPacketV1,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelSoundEventPacketV1,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelSoundEventPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<LevelSoundEventPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LevelSoundEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelSoundEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelEventPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<LevelEventPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LevelEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelEventGenericPacket,0>

struct __cppobj PacketHandlerDispatcherInstance<LevelEventGenericPacket,0> : IPacketHandlerDispatcher
{
};

PacketHandlerDispatcherInstance<LevelEventGenericPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelEventGenericPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BlockEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BlockEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BlockPickRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BlockPickRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ActorPickRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ActorPickRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<GuiDataPickItemPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<GuiDataPickItemPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ActorEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ActorEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MobEffectPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MobEffectPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MobEquipmentPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MobEquipmentPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MobArmorEquipmentPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MobArmorEquipmentPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<InteractPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<InteractPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerActionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerActionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<HurtArmorPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<HurtArmorPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerArmorDamagePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerArmorDamagePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetActorDataPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetActorDataPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetActorMotionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetActorMotionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MotionPredictionHintsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MotionPredictionHintsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetHealthPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetHealthPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetSpawnPositionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetSpawnPositionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AnimatePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AnimatePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<InventoryTransactionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<InventoryTransactionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ItemFrameDropItemPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ItemFrameDropItemPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ContainerOpenPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ContainerOpenPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ContainerClosePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ContainerClosePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ContainerSetDataPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ContainerSetDataPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerHotbarPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerHotbarPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<InventoryContentPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<InventoryContentPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<InventorySlotPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<InventorySlotPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CraftingDataPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CraftingDataPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CraftingEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CraftingEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddPaintingPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddPaintingPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AdventureSettingsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AdventureSettingsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetActorLinkPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetActorLinkPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BlockActorDataPacket,1>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BlockActorDataPacket,1>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerInputPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerInputPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerAuthInputPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerAuthInputPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LevelChunkPacket,1>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LevelChunkPacket,1>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetCommandsEnabledPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetCommandsEnabledPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetDifficultyPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetDifficultyPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChangeDimensionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChangeDimensionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetPlayerGameTypePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetPlayerGameTypePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdatePlayerGameTypePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdatePlayerGameTypePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetDefaultGameTypePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetDefaultGameTypePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateAttributesPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateAttributesPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerListPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerListPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SimpleEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SimpleEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<EventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<EventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SpawnExperienceOrbPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SpawnExperienceOrbPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RequestChunkRadiusPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RequestChunkRadiusPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChunkRadiusUpdatedPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChunkRadiusUpdatedPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ClientboundMapItemDataPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ClientboundMapItemDataPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MapCreateLockedCopyPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MapCreateLockedCopyPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MapInfoRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MapInfoRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateTradePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateTradePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateEquipPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateEquipPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BossEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BossEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AvailableCommandsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AvailableCommandsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CommandRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CommandRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CommandOutputPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CommandOutputPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CommandBlockUpdatePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CommandBlockUpdatePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CameraPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CameraPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CameraShakePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CameraShakePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<GameRulesChangedPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<GameRulesChangedPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ShowCreditsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ShowCreditsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ResourcePackDataInfoPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ResourcePackDataInfoPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ResourcePackChunkDataPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ResourcePackChunkDataPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ResourcePackChunkRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ResourcePackChunkRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<NetworkChunkPublisherUpdatePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<NetworkChunkPublisherUpdatePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StructureBlockUpdatePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StructureBlockUpdatePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StructureTemplateDataRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StructureTemplateDataRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StructureTemplateDataResponsePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StructureTemplateDataResponsePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TransferPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TransferPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AddBehaviorTreePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AddBehaviorTreePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetTitlePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetTitlePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlaySoundPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlaySoundPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StopSoundPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StopSoundPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ShowStoreOfferPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ShowStoreOfferPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<RemoveObjectivePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<RemoveObjectivePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetDisplayObjectivePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetDisplayObjectivePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PurchaseReceiptPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PurchaseReceiptPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerSkinPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerSkinPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetScorePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetScorePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetScoreboardIdentityPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetScoreboardIdentityPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SubClientLoginPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SubClientLoginPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetLastHurtByPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetLastHurtByPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BookEditPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BookEditPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<NpcRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<NpcRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AutomationClientConnectPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AutomationClientConnectPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ModalFormRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ModalFormRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ModalFormResponsePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ModalFormResponsePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<OnScreenTextureAnimationPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<OnScreenTextureAnimationPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ServerSettingsRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ServerSettingsRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ServerSettingsResponsePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ServerSettingsResponsePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PhotoTransferPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PhotoTransferPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ShowProfilePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ShowProfilePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CustomPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CustomPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TransportPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TransportPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TransportNoCompressPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TransportNoCompressPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<VConnectionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<VConnectionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CombinePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CombinePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChangeModelPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChangeModelPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChangeModelTexturePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChangeModelTexturePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChangeModelOffsetPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChangeModelOffsetPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ChangeModelBindPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ChangeModelBindPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<StoreBuySuccPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<StoreBuySuccPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<HungerAttrPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<HungerAttrPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ConfirmSkinPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ConfirmSkinPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<WithdrawFurnaceXpPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<WithdrawFurnaceXpPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LabTablePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LabTablePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<NetworkStackLatencyPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<NetworkStackLatencyPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<UpdateSoftEnumPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<UpdateSoftEnumPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SetLocalPlayerAsInitializedPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SetLocalPlayerAsInitializedPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ScriptCustomEventPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ScriptCustomEventPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<BiomeDefinitionListPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<BiomeDefinitionListPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AvailableActorIdentifiersPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AvailableActorIdentifiersPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<LecternUpdatePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<LecternUpdatePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<EducationSettingsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<EducationSettingsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<SettingsCommandPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<SettingsCommandPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<EmoteListPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<EmoteListPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<EmotePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<EmotePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<MultiplayerSettingsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<MultiplayerSettingsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AnvilDamagePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AnvilDamagePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<TickSyncPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<TickSyncPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CompletedUsingItemPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CompletedUsingItemPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CreativeContentPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CreativeContentPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<NetworkSettingsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<NetworkSettingsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerEnchantOptionsPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerEnchantOptionsPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ItemStackRequestPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ItemStackRequestPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ItemStackResponsePacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ItemStackResponsePacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CodeBuilderPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CodeBuilderPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<DebugInfoPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<DebugInfoPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PacketViolationWarningPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PacketViolationWarningPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<AnimateEntityPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<AnimateEntityPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<PlayerFogPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<PlayerFogPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<CorrectPlayerMovePredictionPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<CorrectPlayerMovePredictionPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<ItemComponentPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<ItemComponentPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PacketHandlerDispatcherInstance<FilterTextPacket,0>_vtbl

struct /*VFT*/ PacketHandlerDispatcherInstance<FilterTextPacket,0>_vtbl
{
  void (__fastcall *~IPacketHandlerDispatcher)(IPacketHandlerDispatcher *this);
  void (__fastcall *handle)(IPacketHandlerDispatcher *this, const NetworkIdentifier *, NetEventCallback *, std::shared_ptr<Packet> *);
};

PlayerEnchantOptionsPacket::read::__l2::<lambda_6d726cd88d75f149990f4367e841d8aa>

struct __cppobj PlayerEnchantOptionsPacket::read::__l2::<lambda_6d726cd88d75f149990f4367e841d8aa>
{
};

PlayerEnchantOptionsPacket::write::__l2::<lambda_2929a6237d8bf38cb7fa7cfddfb96afa>

struct __cppobj PlayerEnchantOptionsPacket::write::__l2::<lambda_2929a6237d8bf38cb7fa7cfddfb96afa>
{
};

Performance

struct __cppobj Performance
{
};

PackErrorFactory

struct __cppobj PackErrorFactory
{
};

PackDependencyManager::getMissingDependencyIdentities::__l11::<lambda_695d0b45646b19b66c28ff5d4679d8d0>

struct __cppobj PackDependencyManager::getMissingDependencyIdentities::__l11::<lambda_695d0b45646b19b66c28ff5d4679d8d0>
{
  PackIdVersion *identity;
  bool *foundIdentity;
};

PackAccessStrategyFactory::create::__l10::<lambda_e1c4a7aa4d5d24da37883fd07a384a0a>

struct __cppobj PackAccessStrategyFactory::create::__l10::<lambda_e1c4a7aa4d5d24da37883fd07a384a0a>
{
  Core::PathBuffer<std::string > *nestedFolderPath;
  int *nestedFolderCount;
};

PackAccessStrategy::generateAssetSet::__l33::<lambda_f01d8532fd1bf7fd33ea89346818e971>

struct __cppobj PackAccessStrategy::generateAssetSet::__l33::<lambda_f01d8532fd1bf7fd33ea89346818e971>
{
  PackAccessStrategy *const __this;
};

PackAccessStrategy::generateAssetSet::__l21::<lambda_7b5e62afb225bcc594e35c861dcefe6a>

struct __cppobj PackAccessStrategy::generateAssetSet::__l21::<lambda_7b5e62afb225bcc594e35c861dcefe6a>
{
  PackAccessStrategy *const __this;
};

PackInstance::createPackStorageFallback::__l2::Fallback

struct __cppobj __declspec(align(8)) PackInstance::createPackStorageFallback::__l2::Fallback : IPackStorageFallback
{
  const ResourcePack *mPack;
  int mSubpack;
};

PackInstance::createPackStorageFallback::__l2::Fallback_vtbl

struct /*VFT*/ PackInstance::createPackStorageFallback::__l2::Fallback_vtbl
{
  void (__fastcall *~IPackStorageFallback)(IPackStorageFallback *this);
  std::string *(__fastcall *getResource)(IPackStorageFallback *this, std::string *result, const Core::Path *);
  __int64 (__fastcall *getLastModified)(IPackStorageFallback *this, const Core::Path *);
  std::unique_ptr<IDataOutput> *(__fastcall *createEncryptor)(IPackStorageFallback *this, std::unique_ptr<IDataOutput> *result, std::unique_ptr<IDataOutput>);
  std::unique_ptr<IDataInput> *(__fastcall *createDecryptor)(IPackStorageFallback *this, std::unique_ptr<IDataInput> *result, std::unique_ptr<IDataInput>);
};

PackSourceFactory::getDirectoryPackSourceContaining::__l6::<lambda_3a2684eeb5efe9f9fa680cd6b87c3bb4>

struct __cppobj PackSourceFactory::getDirectoryPackSourceContaining::__l6::<lambda_3a2684eeb5efe9f9fa680cd6b87c3bb4>
{
  const PackIdVersion *packId;
  bool *containsPack;
};

PackMover::copyPack::__l2::<lambda_d0dea2db41fda175eebc6788cb5f1044>::()::__l37::<lambda_c63384b138e7aaa670f6996b71e331ea>

struct __cppobj PackMover::copyPack::__l2::<lambda_d0dea2db41fda175eebc6788cb5f1044>::()::__l37::<lambda_c63384b138e7aaa670f6996b71e331ea>
{
  unsigned __int64 *pendingWrite;
};

PackSource::fetchPack::__l2::<lambda_cf507e6912f1c48e35b94fa1293705ea>

struct __cppobj PackSource::fetchPack::__l2::<lambda_cf507e6912f1c48e35b94fa1293705ea>
{
  const PackIdVersion *packId;
  Pack **result;
};

PackSource::resolveUpgradeDependencies::__l9::<lambda_0753b2c20b2cc90aac7a93337d2e69e3>

struct __cppobj PackSource::resolveUpgradeDependencies::__l9::<lambda_0753b2c20b2cc90aac7a93337d2e69e3>
{
  PackIdVersion *upgradedVersion;
  std::vector<PackIdVersion> *dependentPackIds;
};

PrecompiledCommandOrigin_vtbl

struct /*VFT*/ PrecompiledCommandOrigin_vtbl
{
  void (__fastcall *~CommandOrigin)(CommandOrigin *this);
  const std::string *(__fastcall *getRequestId)(CommandOrigin *this);
  std::string *(__fastcall *getName)(CommandOrigin *this, std::string *result);
  BlockPos *(__fastcall *getBlockPosition)(CommandOrigin *this, BlockPos *result);
  Vec3 *(__fastcall *getWorldPosition)(CommandOrigin *this, Vec3 *result);
  Level *(__fastcall *getLevel)(CommandOrigin *this);
  Dimension *(__fastcall *getDimension)(CommandOrigin *this);
  Actor *(__fastcall *getEntity)(CommandOrigin *this);
  CommandPermissionLevel (__fastcall *getPermissionsLevel)(CommandOrigin *this);
  std::unique_ptr<CommandOrigin> *(__fastcall *clone)(CommandOrigin *this, std::unique_ptr<CommandOrigin> *result);
  std::optional<BlockPos> *(__fastcall *getCursorHitBlockPos)(CommandOrigin *this, std::optional<BlockPos> *result);
  std::optional<Vec3> *(__fastcall *getCursorHitPos)(CommandOrigin *this, std::optional<Vec3> *result);
  bool (__fastcall *hasChatPerms)(CommandOrigin *this);
  bool (__fastcall *hasTellPerms)(CommandOrigin *this);
  bool (__fastcall *canUseAbility)(CommandOrigin *this, AbilitiesIndex);
  bool (__fastcall *isWorldBuilder)(CommandOrigin *this);
  bool (__fastcall *canUseCommandsWithoutCheatsEnabled)(CommandOrigin *this);
  bool (__fastcall *isSelectorExpansionAllowed)(CommandOrigin *this);
  const NetworkIdentifier *(__fastcall *getSourceId)(CommandOrigin *this);
  unsigned __int8 (__fastcall *getSourceSubId)(CommandOrigin *this);
  const CommandOrigin *(__fastcall *getOutputReceiver)(CommandOrigin *this);
  CommandOriginType (__fastcall *getOriginType)(CommandOrigin *this);
  CommandOriginData *(__fastcall *toCommandOriginData)(CommandOrigin *this, CommandOriginData *result);
  const mce::UUID *(__fastcall *getUUID)(CommandOrigin *this);
  void (__fastcall *handleCommandOutputCallback)(CommandOrigin *this, Json::Value *);
  void (__fastcall *_setUUID)(CommandOrigin *this, const mce::UUID *);
};

ParticleCommand

struct __cppobj ParticleCommand : Command
{
  std::string mEffectName;
  CommandPositionFloat mSpawnPosition;
};

ParticleCommand_vtbl

struct /*VFT*/ ParticleCommand_vtbl
{
  void (__fastcall *~Command)(Command *this);
  void (__fastcall *execute)(Command *this, const CommandOrigin *, CommandOutput *);
};

PermissionCommand

struct __cppobj PermissionCommand : ServerCommand
{
  PermissionCommand::Action mAction;
  _BYTE mPermissionLevel[4];
  CommandSelector<Player> mTargetPlayers;
};

PermissionCommand_vtbl

struct /*VFT*/ PermissionCommand_vtbl
{
  void (__fastcall *~Command)(Command *this);
  void (__fastcall *execute)(Command *this, const CommandOrigin *, CommandOutput *);
};

PlaySoundCommand

struct __cppobj __declspec(align(4)) PlaySoundCommand : Command
{
  std::string mSound;
  CommandSelector<Player> mTargets;
  CommandPositionFloat mPosition;
  float mVolume;
  float mPitch;
  float mMinVolume;
  bool mPositionSet;
};

PlaySoundCommand_vtbl

struct /*VFT*/ PlaySoundCommand_vtbl
{
  void (__fastcall *~Command)(Command *this);
  void (__fastcall *execute)(Command *this, const CommandOrigin *, CommandOutput *);
};

PermissionCommand::reload::__l8::<lambda_3c0b2eae9affcf19475d7ecf5fca24ae>

struct __cppobj PermissionCommand::reload::__l8::<lambda_3c0b2eae9affcf19475d7ecf5fca24ae>
{
  _BYTE permissionLevel[1];
};

PyCodeObject

struct PyCodeObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  int co_argcount;
  int co_nlocals;
  int co_stacksize;
  int co_flags;
  _object *co_code;
  _object *co_consts;
  _object *co_names;
  _object *co_varnames;
  _object *co_freevars;
  _object *co_cellvars;
  _object *co_filename;
  _object *co_name;
  int co_firstlineno;
  _object *co_lnotab;
  void *co_zombieframe;
  _object *co_weakreflist;
};

PyTryBlock

struct PyTryBlock
{
  int b_type;
  int b_handler;
  int b_level;
};

png_compression_buffer

struct __declspec(align(8)) png_compression_buffer
{
  png_compression_buffer *next;
  unsigned __int8 output[1];
};

png_color_struct

struct png_color_struct
{
  unsigned __int8 red;
  unsigned __int8 green;
  unsigned __int8 blue;
};

png_text_struct

struct png_text_struct
{
  int compression;
  char *key;
  char *text;
  unsigned __int64 text_length;
  unsigned __int64 itxt_length;
  char *lang;
  char *lang_key;
};

png_time_struct

struct __declspec(align(2)) png_time_struct
{
  unsigned __int16 year;
  unsigned __int8 month;
  unsigned __int8 day;
  unsigned __int8 hour;
  unsigned __int8 minute;
  unsigned __int8 second;
};

png_sPLT_entry_struct

struct png_sPLT_entry_struct
{
  unsigned __int16 red;
  unsigned __int16 green;
  unsigned __int16 blue;
  unsigned __int16 alpha;
  unsigned __int16 frequency;
};

png_sPLT_struct

struct __declspec(align(8)) png_sPLT_struct
{
  char *name;
  unsigned __int8 depth;
  png_sPLT_entry_struct *entries;
  int nentries;
};

png_info_def

struct png_info_def
{
  unsigned int width;
  unsigned int height;
  unsigned int valid;
  unsigned __int64 rowbytes;
  png_color_struct *palette;
  unsigned __int16 num_palette;
  unsigned __int16 num_trans;
  unsigned __int8 bit_depth;
  unsigned __int8 color_type;
  unsigned __int8 compression_type;
  unsigned __int8 filter_type;
  unsigned __int8 interlace_type;
  unsigned __int8 channels;
  unsigned __int8 pixel_depth;
  unsigned __int8 spare_byte;
  unsigned __int8 signature[8];
  png_colorspace colorspace;
  char *iccp_name;
  unsigned __int8 *iccp_profile;
  unsigned int iccp_proflen;
  int num_text;
  int max_text;
  png_text_struct *text;
  png_time_struct mod_time;
  png_color_8_struct sig_bit;
  unsigned __int8 *trans_alpha;
  png_color_16_struct trans_color;
  png_color_16_struct background;
  int x_offset;
  int y_offset;
  unsigned __int8 offset_unit_type;
  unsigned int x_pixels_per_unit;
  unsigned int y_pixels_per_unit;
  unsigned __int8 phys_unit_type;
  int num_exif;
  unsigned __int8 *exif;
  unsigned __int8 *eXIf_buf;
  unsigned __int16 *hist;
  char *pcal_purpose;
  int pcal_X0;
  int pcal_X1;
  char *pcal_units;
  char **pcal_params;
  unsigned __int8 pcal_type;
  unsigned __int8 pcal_nparams;
  unsigned int free_me;
  png_unknown_chunk_t *unknown_chunks;
  int unknown_chunks_num;
  png_sPLT_struct *splt_palettes;
  int splt_palettes_num;
  unsigned __int8 scal_unit;
  char *scal_s_width;
  char *scal_s_height;
  unsigned __int8 **row_pointers;
};

PerfTimer::<lambda_8db8e8a6f3f91755809d25badf24f7c1>

struct __cppobj PerfTimer::<lambda_8db8e8a6f3f91755809d25badf24f7c1>
{
};

Pufferfish

struct __cppobj Pufferfish : Fish
{
};

PushThroughDefinition

struct __cppobj PushThroughDefinition
{
  float mValue;
};

Pig

struct __cppobj Pig : Animal
{
};

PlaceBlockNode

struct __cppobj __declspec(align(8)) PlaceBlockNode : BehaviorNode
{
  bool mRightMouseDown;
  bool mPreActionDone;
};

PlaceBlockNode_vtbl

struct /*VFT*/ PlaceBlockNode_vtbl
{
  void (__fastcall *~BehaviorNode)(BehaviorNode *this);
  BehaviorStatus (__fastcall *tick)(BehaviorNode *this, Actor *);
  void (__fastcall *initializeFromDefinition)(BehaviorNode *this, Actor *);
};

PlaceBlockDefinition

struct __cppobj PlaceBlockDefinition : BehaviorDefinition
{
};

PlaceBlockDefinition_vtbl

struct /*VFT*/ PlaceBlockDefinition_vtbl
{
  void (__fastcall *~BehaviorDefinition)(BehaviorDefinition *this);
  void (__fastcall *load)(BehaviorDefinition *this, Json::Value, const BehaviorFactory *);
  std::unique_ptr<BehaviorNode> *(__fastcall *createNode)(BehaviorDefinition *this, std::unique_ptr<BehaviorNode> *result, Actor *, const BehaviorFactory *, BehaviorNode *, BehaviorData *);
};

PyBehaviorNode

struct __cppobj PyBehaviorNode : BehaviorNode
{
  int mScriptNodeId;
  std::string mModulePath;
  std::string mFuncName;
  std::string mArgs;
};

PyBehaviorNode_vtbl

struct /*VFT*/ PyBehaviorNode_vtbl
{
  void (__fastcall *~BehaviorNode)(BehaviorNode *this);
  BehaviorStatus (__fastcall *tick)(BehaviorNode *this, Actor *);
  void (__fastcall *initializeFromDefinition)(BehaviorNode *this, Actor *);
};

PyBehaviorDefinition

struct __cppobj PyBehaviorDefinition : BehaviorDefinition
{
  std::string mModulePath;
  std::string mFuncName;
  std::string mArgs;
  std::string mModulePathId;
  std::string mFuncNameId;
  std::string mArgsId;
};

PyBehaviorDefinition_vtbl

struct /*VFT*/ PyBehaviorDefinition_vtbl
{
  void (__fastcall *~BehaviorDefinition)(BehaviorDefinition *this);
  void (__fastcall *load)(BehaviorDefinition *this, Json::Value, const BehaviorFactory *);
  std::unique_ptr<BehaviorNode> *(__fastcall *createNode)(BehaviorDefinition *this, std::unique_ptr<BehaviorNode> *result, Actor *, const BehaviorFactory *, BehaviorNode *, BehaviorData *);
};

PopFromStackDefinition

struct __cppobj PopFromStackDefinition : BehaviorDefinition
{
  std::string mDataId;
};

PopFromStackDefinition_vtbl

struct /*VFT*/ PopFromStackDefinition_vtbl
{
  void (__fastcall *~BehaviorDefinition)(BehaviorDefinition *this);
  void (__fastcall *load)(BehaviorDefinition *this, Json::Value, const BehaviorFactory *);
  std::unique_ptr<BehaviorNode> *(__fastcall *createNode)(BehaviorDefinition *this, std::unique_ptr<BehaviorNode> *result, Actor *, const BehaviorFactory *, BehaviorNode *, BehaviorData *);
};

PopFromStackNode

struct __cppobj PopFromStackNode : BehaviorNode
{
  std::string mDataId;
};

PopFromStackNode_vtbl

struct /*VFT*/ PopFromStackNode_vtbl
{
  void (__fastcall *~BehaviorNode)(BehaviorNode *this);
  BehaviorStatus (__fastcall *tick)(BehaviorNode *this, Actor *);
  void (__fastcall *initializeFromDefinition)(BehaviorNode *this, Actor *);
};

Phantom

struct __cppobj Phantom : Monster
{
};

Piglin

struct __cppobj Piglin : HumanoidMonster
{
};

PigZombie

struct __cppobj __declspec(align(8)) PigZombie : Zombie
{
  int mAngerTime;
  int mPlayAngrySoundIn;
  int mStunedTime;
};

Pillager

struct __cppobj Pillager : HumanoidMonster
{
};

Phantom::checkSpawnRules::__l2::<lambda_12a9f30a884e74c4f5ecd2dd2382019c>

struct __cppobj Phantom::checkSpawnRules::__l2::<lambda_12a9f30a884e74c4f5ecd2dd2382019c>
{
  Phantom *const __this;
  const bool *hasSkyLight;
  const float *MAX_DISTANCE_TO_SPAWN_SQUARED;
  Random *random;
  bool *result;
  bool *fromSpawner;
};

PotionItem

struct __cppobj __declspec(align(8)) PotionItem : Item
{
  TextureUVCoordinateSet mPotionIcons[27];
  _BYTE mPotionVariants[108];
};

Player::_updateInteraction::__l30::<lambda_3fc96c50e03a58a13d487126a70a73e9>

struct __cppobj Player::_updateInteraction::__l30::<lambda_3fc96c50e03a58a13d487126a70a73e9>
{
  Player *const __this;
};

Player::_updateInteraction::__l22::<lambda_77ba73b985eb41920ebf53e90b20b2fb>

struct __cppobj Player::_updateInteraction::__l22::<lambda_77ba73b985eb41920ebf53e90b20b2fb>
{
  Player *const __this;
  ActorUniqueID *newInteractingEntity;
};

Player::dispatchMainhandExchange::__l38::<lambda_7c9840d03b0fe1ce24454495305f0439>

struct __cppobj Player::dispatchMainhandExchange::__l38::<lambda_7c9840d03b0fe1ce24454495305f0439>
{
  const ItemStack *oldItem;
  const ItemStack *item;
  Player *const __this;
};

Player::updateCreativeItemList::__l2::<lambda_b5810c07c2234f11dce359d32de45d80>

struct __cppobj Player::updateCreativeItemList::__l2::<lambda_b5810c07c2234f11dce359d32de45d80>
{
  Player *const __this;
};

Player::_registerElytraLoopSound::__l2::<lambda_ab6d8ffc739ad0fac2b70be5d4547655>

struct __cppobj Player::_registerElytraLoopSound::__l2::<lambda_ab6d8ffc739ad0fac2b70be5d4547655>
{
  Player *const __this;
};

Player::inventoryChanged::__l13::<lambda_97c92d9465bc3e22bf13ce2ec83e63f5>

struct __cppobj Player::inventoryChanged::__l13::<lambda_97c92d9465bc3e22bf13ce2ec83e63f5>
{
  const ItemStack *oldItem;
  const ItemStack *newItem;
  Player *const __this;
  int *slot;
};

Player::inventoryChanged::__l11::<lambda_82caf1531727f45cd958dfcc47d418f5>

struct __cppobj Player::inventoryChanged::__l11::<lambda_82caf1531727f45cd958dfcc47d418f5>
{
  const ItemStack *oldItem;
  const ItemStack *newItem;
  Player *const __this;
  int *slot;
};

Player::eat::__l11::<lambda_dc4a9fef74ffdb090ae7d331ccdee6e6>

struct __cppobj Player::eat::__l11::<lambda_dc4a9fef74ffdb090ae7d331ccdee6e6>
{
  Player *const __this;
  const ItemStack *instance;
  int *nutrition;
  float *saturationModifier;
};

Player::respawn::__l8::<lambda_08c4ed0b2e7b87cba38396226544bcb4>

struct __cppobj Player::respawn::__l8::<lambda_08c4ed0b2e7b87cba38396226544bcb4>
{
  Player *const __this;
};

Player::handleMovePlayerPacket::__l18::<lambda_f5062f5eb349e5e9727dfa309954866a>

struct __cppobj Player::handleMovePlayerPacket::__l18::<lambda_f5062f5eb349e5e9727dfa309954866a>
{
  IPlayerMovementProxy *player;
  const Vec3 *pos;
};

Player::_isDangerousSpawn::__l2::<lambda_0b65570db0dcfef8ff31b9aeb4fc4e99>

struct __cppobj Player::_isDangerousSpawn::__l2::<lambda_0b65570db0dcfef8ff31b9aeb4fc4e99>
{
};

Player::attack::__l12::<lambda_22f2ad2482b075a3688187c8fc24918b>

struct __cppobj Player::attack::__l12::<lambda_22f2ad2482b075a3688187c8fc24918b>
{
  Player *const __this;
  Actor *actor;
};

Player::interact::__l8::<lambda_304ddabc0fd03b92029eb43e95124fcf>

struct __cppobj Player::interact::__l8::<lambda_304ddabc0fd03b92029eb43e95124fcf>
{
  Player *const __this;
  ItemStack *item;
  Actor *entity;
};

Player::_aiStep::__l70::<lambda_3bd6c150f9cd685f950a17ac5303f4b3>

struct __cppobj Player::_aiStep::__l70::<lambda_3bd6c150f9cd685f950a17ac5303f4b3>
{
  IPlayerMovementProxy *player;
  BlockPos *collisionBlockPos;
  const Block **collisionBlock;
  const BlockSource *blockSource;
};

Player::_aiStep::__l68::<lambda_ab02a4c4b858498b3730d87f477d6044>

struct __cppobj Player::_aiStep::__l68::<lambda_ab02a4c4b858498b3730d87f477d6044>
{
  IPlayerMovementProxy *player;
  BlockPos *collisionBlockPos;
  const Block **collisionBlock;
};

Player::_aiStep::__l65::<lambda_8e8c49a92d5c8180a5d8414cc84715c5>

struct __cppobj Player::_aiStep::__l65::<lambda_8e8c49a92d5c8180a5d8414cc84715c5>
{
  IPlayerMovementProxy *player;
  BlockPos *collisionBlockPos;
  const Block **collisionBlock;
};

Player::_jumpFromGround::__l18::<lambda_5c2db43f6f2690a44d312953073f3ff8>

struct __cppobj Player::_jumpFromGround::__l18::<lambda_5c2db43f6f2690a44d312953073f3ff8>
{
  IPlayerMovementProxy *player;
};

Player::completeUsingItem::__l5::<lambda_f3fc531278ca780241bc198bc49e0219>

struct __cppobj Player::completeUsingItem::__l5::<lambda_f3fc531278ca780241bc198bc49e0219>
{
  Player *const __this;
  ItemStack *itemStack;
  std::unique_ptr<ItemReleaseInventoryTransaction> *transaction;
  ItemUseMethod *useMethod;
};

Player::completeUsingItem::__l5::<lambda_de04237fb66980410b17ba846bf7fd87>

struct __cppobj Player::completeUsingItem::__l5::<lambda_de04237fb66980410b17ba846bf7fd87>
{
  Player *const __this;
  std::unique_ptr<ItemReleaseInventoryTransaction> *transaction;
};

Player::stopUsingItem::__l5::<lambda_8c189cb350e6870bc964979fd25e9568>

struct __cppobj Player::stopUsingItem::__l5::<lambda_8c189cb350e6870bc964979fd25e9568>
{
  Player *const __this;
};

Player::startUsingItem::__l8::<lambda_33dabfb182a560cf013f02f7bd2636fb>

struct __cppobj Player::startUsingItem::__l8::<lambda_33dabfb182a560cf013f02f7bd2636fb>
{
  Player *const __this;
  const ItemStack *instance;
};

Player::teleportTo::__l5::<lambda_3f3631994be62a98cd8fb582aefc5073>

struct __cppobj Player::teleportTo::__l5::<lambda_3f3631994be62a98cd8fb582aefc5073>
{
  Player *const __this;
};

ProjectileFactory::shootProjectileFromDefinition::__l7::<lambda_3860a118675a117743b7158ec36f3649>

struct __cppobj ProjectileFactory::shootProjectileFromDefinition::__l7::<lambda_3860a118675a117743b7158ec36f3649>
{
  Actor **projectile;
  const ActorDefinitionIdentifier *identifier;
  Mob **owner;
};

ProjectileFactory::initFactory::__l2::<lambda_41787ecc6a4e49ac6623e4d131900cf0>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_41787ecc6a4e49ac6623e4d131900cf0>
{
};

ProjectileFactory::initFactory::__l2::<lambda_b5e8a86f1d9867809194c65df34acc1b>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_b5e8a86f1d9867809194c65df34acc1b>
{
};

ProjectileFactory::initFactory::__l2::<lambda_23cb8fad3db44f934d7c9ba523d2eb47>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_23cb8fad3db44f934d7c9ba523d2eb47>
{
};

ProjectileFactory::initFactory::__l2::<lambda_6e1e8169f9ebeb6fd953570d74ef71e1>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_6e1e8169f9ebeb6fd953570d74ef71e1>
{
};

ProjectileFactory::initFactory::__l2::<lambda_e2269ea6f2e347072fea0bd87085fd14>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_e2269ea6f2e347072fea0bd87085fd14>
{
};

ProjectileFactory::initFactory::__l2::<lambda_17d376b9ff2d1e4bb236ad15e4f48554>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_17d376b9ff2d1e4bb236ad15e4f48554>
{
};

ProjectileFactory::initFactory::__l2::<lambda_6784107cef9cf58fe1d3e64e228b06b5>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_6784107cef9cf58fe1d3e64e228b06b5>
{
};

ProjectileFactory::initFactory::__l2::<lambda_22b6a629884a3df8800728cece5c3ec7>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_22b6a629884a3df8800728cece5c3ec7>
{
};

ProjectileFactory::initFactory::__l2::<lambda_0d2af7695c6c5aa7dc85709a42c3c1ee>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_0d2af7695c6c5aa7dc85709a42c3c1ee>
{
};

ProjectileFactory::initFactory::__l2::<lambda_eb9ba125844baa83db5a92c245f267f3>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_eb9ba125844baa83db5a92c245f267f3>
{
};

ProjectileFactory::initFactory::__l2::<lambda_dd9c95e610f4b8f20669d37b6345bd13>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_dd9c95e610f4b8f20669d37b6345bd13>
{
};

ProjectileFactory::initFactory::__l2::<lambda_77c05a3621025da1c6acebe0cec04510>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_77c05a3621025da1c6acebe0cec04510>
{
};

ProjectileFactory::initFactory::__l2::<lambda_98e953315acdc2496ff83496f801873d>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_98e953315acdc2496ff83496f801873d>
{
};

ProjectileFactory::initFactory::__l2::<lambda_28e62265407d40c72f3c5ffa37c17f8b>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_28e62265407d40c72f3c5ffa37c17f8b>
{
};

ProjectileFactory::initFactory::__l2::<lambda_111c3ec581eb802b53ba6b0d8373453e>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_111c3ec581eb802b53ba6b0d8373453e>
{
};

ProjectileFactory::initFactory::__l2::<lambda_58b1b28c0b9c3e1ccc3f8dca308a90ef>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_58b1b28c0b9c3e1ccc3f8dca308a90ef>
{
};

ProjectileFactory::initFactory::__l2::<lambda_7ca62f21217f39da33a91ebad50267b0>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_7ca62f21217f39da33a91ebad50267b0>
{
};

ProjectileFactory::initFactory::__l2::<lambda_d1981935671b9c2bfeb37aa26be22b06>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_d1981935671b9c2bfeb37aa26be22b06>
{
};

ProjectileFactory::initFactory::__l2::<lambda_93e33fd9318d6cd78576e0d4e34bc40a>

struct __cppobj ProjectileFactory::initFactory::__l2::<lambda_93e33fd9318d6cd78576e0d4e34bc40a>
{
};

PlayerUIContainerModelBase

struct __cppobj PlayerUIContainerModelBase : ContainerModel
{
  Player *mPlayer;
};

PlayerUIContainerModelBase_vtbl

struct /*VFT*/ PlayerUIContainerModelBase_vtbl
{
  void (__fastcall *containerContentChanged)(ContainerContentChangeListener *this, int);
  void (__fastcall *~ContainerContentChangeListener)(ContainerContentChangeListener *this);
  void (__fastcall *containerAddCallback)(ContainerContentChangeListener *this, Container *);
  void (__fastcall *containerRemoveCallback)(ContainerContentChangeListener *this, Container *);
  void (__fastcall *postInit)(ContainerModel *this);
  void (__fastcall *releaseResources)(ContainerModel *this);
  int (__fastcall *getContainerSize)(ContainerModel *this);
  int (__fastcall *getFilteredContainerSize)(ContainerModel *this);
  void (__fastcall *tick)(ContainerModel *this, int);
  ContainerWeakRef *(__fastcall *getContainerWeakRef)(ContainerModel *this, ContainerWeakRef *result);
  const ItemStack *(__fastcall *getItemStack)(ContainerModel *this, int);
  const std::vector<ItemStack> *(__fastcall *getItems)(ContainerModel *this);
  const ItemInstance *(__fastcall *getItemInstance)(ContainerModel *this, int);
  const ItemStackBase *(__fastcall *getItemStackBase)(ContainerModel *this, int);
  bool (__fastcall *isItemInstanceBased)(ContainerModel *this);
  void (__fastcall *setItem)(ContainerModel *this, int, const ItemStack *);
  bool (__fastcall *isValid)(ContainerModel *this);
  bool (__fastcall *isItemFiltered)(ContainerModel *this, const ItemStackBase *);
  bool (__fastcall *isExpanableItemFiltered)(ContainerModel *this, int);
  ContainerExpandStatus (__fastcall *getItemExpandStatus)(ContainerModel *this, int);
  const std::string *(__fastcall *getItemGroupName)(ContainerModel *this, int);
  void (__fastcall *switchItemExpando)(ContainerModel *this, int);
  Container *(__fastcall *_getContainer)(ContainerModel *this);
  int (__fastcall *_getContainerOffset)(ContainerModel *this);
  void (__fastcall *_onItemChanged)(ContainerModel *this, int, const ItemStack *, const ItemStack *);
};

PlayerUIContainerModel

struct __cppobj PlayerUIContainerModel : PlayerUIContainerModelBase
{
};

PlayerUIContainerModel_vtbl

struct /*VFT*/ PlayerUIContainerModel_vtbl
{
  void (__fastcall *containerContentChanged)(ContainerContentChangeListener *this, int);
  void (__fastcall *~ContainerContentChangeListener)(ContainerContentChangeListener *this);
  void (__fastcall *containerAddCallback)(ContainerContentChangeListener *this, Container *);
  void (__fastcall *containerRemoveCallback)(ContainerContentChangeListener *this, Container *);
  void (__fastcall *postInit)(ContainerModel *this);
  void (__fastcall *releaseResources)(ContainerModel *this);
  int (__fastcall *getContainerSize)(ContainerModel *this);
  int (__fastcall *getFilteredContainerSize)(ContainerModel *this);
  void (__fastcall *tick)(ContainerModel *this, int);
  ContainerWeakRef *(__fastcall *getContainerWeakRef)(ContainerModel *this, ContainerWeakRef *result);
  const ItemStack *(__fastcall *getItemStack)(ContainerModel *this, int);
  const std::vector<ItemStack> *(__fastcall *getItems)(ContainerModel *this);
  const ItemInstance *(__fastcall *getItemInstance)(ContainerModel *this, int);
  const ItemStackBase *(__fastcall *getItemStackBase)(ContainerModel *this, int);
  bool (__fastcall *isItemInstanceBased)(ContainerModel *this);
  void (__fastcall *setItem)(ContainerModel *this, int, const ItemStack *);
  bool (__fastcall *isValid)(ContainerModel *this);
  bool (__fastcall *isItemFiltered)(ContainerModel *this, const ItemStackBase *);
  bool (__fastcall *isExpanableItemFiltered)(ContainerModel *this, int);
  ContainerExpandStatus (__fastcall *getItemExpandStatus)(ContainerModel *this, int);
  const std::string *(__fastcall *getItemGroupName)(ContainerModel *this, int);
  void (__fastcall *switchItemExpando)(ContainerModel *this, int);
  Container *(__fastcall *_getContainer)(ContainerModel *this);
  int (__fastcall *_getContainerOffset)(ContainerModel *this);
  void (__fastcall *_onItemChanged)(ContainerModel *this, int, const ItemStack *, const ItemStack *);
};

PlayerEventCoordinator::sendPlayerPiglinBarter::__l2::<lambda_0ef778d107926d8a9d982e514c269478>

struct __cppobj __declspec(align(8)) PlayerEventCoordinator::sendPlayerPiglinBarter::__l2::<lambda_0ef778d107926d8a9d982e514c269478>
{
  Player *player;
  const std::string *item;
  const bool wasTargetingBarteringPlayer;
};

PlayerEventCoordinator::sendPlayerOpenContainer::__l2::<lambda_ad5773f3b7a6a6a98724898b921a3bce>

struct __cppobj PlayerEventCoordinator::sendPlayerOpenContainer::__l2::<lambda_ad5773f3b7a6a6a98724898b921a3bce>
{
  Player *player;
  ContainerType *containerType;
  const BlockPos *pos;
  ActorUniqueID *uniqueId;
};

PlayerEventCoordinator::sendPlayerItemEquipped::__l2::<lambda_361078b246cced90cf9fe9e0ada637bd>

struct __cppobj PlayerEventCoordinator::sendPlayerItemEquipped::__l2::<lambda_361078b246cced90cf9fe9e0ada637bd>
{
  Player *player;
  const ItemInstance *equippedItem;
  int *equipmentSlotId;
};

PlayerEventCoordinator::sendPlayerItemPlaceInteraction::__l2::<lambda_c7e5a5ce08f66391a5e9909650adcdb6>

struct __cppobj PlayerEventCoordinator::sendPlayerItemPlaceInteraction::__l2::<lambda_c7e5a5ce08f66391a5e9909650adcdb6>
{
  Player *player;
  const ItemInstance *itemBeforeUse;
};

PlayerEventCoordinator::sendPlayerItemUseInteraction::__l2::<lambda_856efbed4ce010763c6318937b8890eb>

struct __cppobj PlayerEventCoordinator::sendPlayerItemUseInteraction::__l2::<lambda_856efbed4ce010763c6318937b8890eb>
{
  Player *player;
  const ItemInstance *itemBeforeUse;
};

PlayerEventCoordinator::sendPlayerSaved::__l2::<lambda_96989c33ccd758a5d8496b3153833b1d>

struct __cppobj PlayerEventCoordinator::sendPlayerSaved::__l2::<lambda_96989c33ccd758a5d8496b3153833b1d>
{
  Player *player;
};

PlayerEventCoordinator::sendPlayerCaravanChanged::__l2::<lambda_82a630a2e1bae5765b448e98bf685def>

struct __cppobj PlayerEventCoordinator::sendPlayerCaravanChanged::__l2::<lambda_82a630a2e1bae5765b448e98bf685def>
{
  const Actor *mob;
  int *caravanCount;
};

PlayerEventCoordinator::sendPlayerPortalUsed::__l2::<lambda_a7db23ef556e63cbaec5140de53a1bfb>

struct __cppobj PlayerEventCoordinator::sendPlayerPortalUsed::__l2::<lambda_a7db23ef556e63cbaec5140de53a1bfb>
{
  Player *player;
  AutomaticID<Dimension,int> *fromDimension;
  AutomaticID<Dimension,int> *toDimension;
};

PlayerEventCoordinator::sendPlayerPortalBuilt::__l2::<lambda_3a78e1b870635b4f42052bdd4acf4f78>

struct __cppobj PlayerEventCoordinator::sendPlayerPortalBuilt::__l2::<lambda_3a78e1b870635b4f42052bdd4acf4f78>
{
  Player *player;
  AutomaticID<Dimension,int> *dimensionBuiltIn;
};

PlayerEventCoordinator::sendPlayerAwardAchievement::__l2::<lambda_34cf7c5c9114e688b9710b04129028bb>

struct __cppobj PlayerEventCoordinator::sendPlayerAwardAchievement::__l2::<lambda_34cf7c5c9114e688b9710b04129028bb>
{
  Player *player;
  MinecraftEventing::AchievementIds *achievement;
};

PlayerEventCoordinator::sendPlayerNamedItem::__l2::<lambda_a73641db2836bc033598d9a219bc6c06>

struct __cppobj PlayerEventCoordinator::sendPlayerNamedItem::__l2::<lambda_a73641db2836bc033598d9a219bc6c06>
{
  Player *player;
  const ItemDescriptor *item;
};

PlayerEventCoordinator::sendPlayerEnchantedItem::__l2::<lambda_486eb06ebcfae2ed4523eaa2e6168fd5>

struct __cppobj PlayerEventCoordinator::sendPlayerEnchantedItem::__l2::<lambda_486eb06ebcfae2ed4523eaa2e6168fd5>
{
  Player *player;
  const ItemStack *item;
  const ItemEnchants *enchants;
};

PlayerEventCoordinator::sendPlayerDestroyedBlock::__l2::<lambda_69d9c149e38be472000885ed9502e8d2>

struct __cppobj __declspec(align(8)) PlayerEventCoordinator::sendPlayerDestroyedBlock::__l2::<lambda_69d9c149e38be472000885ed9502e8d2>
{
  Player *player;
  int x;
  int y;
  int z;
};

PlayerEventCoordinator::sendPlayerTeleported::__l2::<lambda_27a7dc85c12060e2f520bd43324e01ca>

struct __cppobj PlayerEventCoordinator::sendPlayerTeleported::__l2::<lambda_27a7dc85c12060e2f520bd43324e01ca>
{
  Player *player;
};

PlayerEventCoordinator::sendPlayerTick::__l2::<lambda_ea34bc49ab71abc2387251a85d26a731>

struct __cppobj PlayerEventCoordinator::sendPlayerTick::__l2::<lambda_ea34bc49ab71abc2387251a85d26a731>
{
  Player *player;
};

PlayerEventCoordinator::sendPlayerTargetBlockHit::__l2::<lambda_f3a88f5709006ebeeea1b7e57a15294c>

struct __cppobj __declspec(align(8)) PlayerEventCoordinator::sendPlayerTargetBlockHit::__l2::<lambda_f3a88f5709006ebeeea1b7e57a15294c>
{
  Player *player;
  const int signalStrength;
};

PlayerEventCoordinator::sendPlayerSlide::__l2::<lambda_4b0e0be8738e75c0923f43a4c4b3f778>

struct __cppobj PlayerEventCoordinator::sendPlayerSlide::__l2::<lambda_4b0e0be8738e75c0923f43a4c4b3f778>
{
  Player *player;
};

PlayerEventCoordinator::sendPlayerMove::__l2::<lambda_e1e9a417179baf6fba48f1a04338c133>

struct __cppobj PlayerEventCoordinator::sendPlayerMove::__l2::<lambda_e1e9a417179baf6fba48f1a04338c133>
{
  Player *player;
};

PlanksBlock

struct __cppobj PlanksBlock : BlockLegacy
{
};

PlanksBlock_vtbl

struct /*VFT*/ PlanksBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

ProtectionEnchant

struct __cppobj ProtectionEnchant : Enchant
{
};

ProtectionEnchant_vtbl

struct /*VFT*/ ProtectionEnchant_vtbl
{
  void (__fastcall *~Enchant)(Enchant *this);
  bool (__fastcall *isCompatibleWith)(Enchant *this, Enchant::Type);
  int (__fastcall *getMinCost)(Enchant *this, int);
  int (__fastcall *getMaxCost)(Enchant *this, int);
  int (__fastcall *getMinLevel)(Enchant *this);
  int (__fastcall *getMaxLevel)(Enchant *this);
  int (__fastcall *getDamageProtection)(Enchant *this, int, const ActorDamageSource *);
  float (__fastcall *getDamageBonus)(Enchant *this, int, const Actor *);
  void (__fastcall *doPostAttack)(Enchant *this, Actor *, Actor *, int);
  void (__fastcall *doPostHurt)(Enchant *this, ItemInstance *, Actor *, Actor *, int);
  bool (__fastcall *isMeleeDamageEnchant)(Enchant *this);
  bool (__fastcall *isProtectionEnchant)(Enchant *this);
  bool (__fastcall *isTreasureOnly)(Enchant *this);
  bool (__fastcall *isDiscoverable)(Enchant *this);
};

PromoteItemIdPair::__l2::IdPairHasher

struct __cppobj PromoteItemIdPair::__l2::IdPairHasher
{
};

PickaxeItem

struct __cppobj PickaxeItem : DiggerItem
{
};

PortfolioBookItem

struct __cppobj PortfolioBookItem : Item
{
};

PumpkinBlockItem

struct __cppobj PumpkinBlockItem : BlockItem
{
};

PosibleTransformation

struct __cppobj __declspec(align(8)) PosibleTransformation
{
  std::vector<std::pair<Biome *,unsigned int>> mTransformsInto;
  BiomeFilterGroup mCondition;
  unsigned int mMinPassingNeighbors;
};

ProducerComponent

struct __cppobj __declspec(align(4)) ProducerComponent : BaseCircuitComponent
{
  int mNextStrength;
  bool mAttachedAllowed;
  bool mStopPower;
};

ProducerComponent_vtbl

struct /*VFT*/ ProducerComponent_vtbl
{
  void (__fastcall *~BaseCircuitComponent)(BaseCircuitComponent *this);
  int (__fastcall *getStrength)(BaseCircuitComponent *this);
  int (__fastcall *getDirection)(BaseCircuitComponent *this);
  void (__fastcall *setStrength)(BaseCircuitComponent *this, int);
  void (__fastcall *setDirection)(BaseCircuitComponent *this, unsigned __int8);
  bool (__fastcall *consumePowerAnyDirection)(BaseCircuitComponent *this);
  bool (__fastcall *canConsumerPower)(BaseCircuitComponent *this);
  bool (__fastcall *canStopPower)(BaseCircuitComponent *this);
  void (__fastcall *setStopPower)(BaseCircuitComponent *this, bool);
  unsigned __int64 (__fastcall *getBaseType)(BaseCircuitComponent *this);
  unsigned __int64 (__fastcall *getInstanceType)(BaseCircuitComponent *this);
  bool (__fastcall *removeSource)(BaseCircuitComponent *this, const BlockPos *, const BaseCircuitComponent *);
  bool (__fastcall *addSource)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, int *, bool *);
  bool (__fastcall *allowConnection)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, bool *);
  void (__fastcall *checkLock)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  bool (__fastcall *evaluate)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *cacheValues)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *updateDependencies)(BaseCircuitComponent *this, CircuitSceneGraph *, const BlockPos *);
  bool (__fastcall *allowIndirect)(BaseCircuitComponent *this);
  bool (__fastcall *isHalfPulse)(BaseCircuitComponent *this);
  bool (__fastcall *hasSource)(BaseCircuitComponent *this, BaseCircuitComponent *);
  bool (__fastcall *hasChildrenSource)(BaseCircuitComponent *this);
  bool (__fastcall *isSecondaryPowered)(BaseCircuitComponent *this);
};

PlaySoundReactionComponent

struct __cppobj __declspec(align(8)) PlaySoundReactionComponent : LabTableReactionComponent
{
  LevelSoundEvent mSound;
};

PlaySoundReactionComponent_vtbl

struct /*VFT*/ PlaySoundReactionComponent_vtbl
{
  void (__fastcall *~LabTableReactionComponent)(LabTableReactionComponent *this);
  void (__fastcall *_onStart)(LabTableReactionComponent *this, LabTableReaction *, BlockSource *);
  void (__fastcall *_onTick)(LabTableReactionComponent *this, LabTableReaction *, BlockSource *);
  void (__fastcall *_onEnd)(LabTableReactionComponent *this, LabTableReaction *, BlockSource *);
};

PistonArmBlock

struct __cppobj __declspec(align(8)) PistonArmBlock : BlockLegacy
{
  PistonBlock::Type mType;
};

PistonArmBlock_vtbl

struct /*VFT*/ PistonArmBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PistonBlockActor::_checkInceptionAchievement::__l19::<lambda_80fcf4e7ebc9359179644a5d2e9a0eaf>

struct __cppobj PistonBlockActor::_checkInceptionAchievement::__l19::<lambda_80fcf4e7ebc9359179644a5d2e9a0eaf>
{
  AABB *areaofeffect;
};

PistonBlockActor::dispatchPistonActionServerEvent::__l2::<lambda_63e7435699aac76473e379984bf06022>

struct __cppobj PistonBlockActor::dispatchPistonActionServerEvent::__l2::<lambda_63e7435699aac76473e379984bf06022>
{
  bool *doFront;
  PistonBlockActor *const __this;
  BlockSource *region;
  unsigned __int8 *pistonFacing;
  unsigned __int8 *pistonMoveFacing;
  const BlockPos *entityBP;
};

PortalComponentDescription

struct __cppobj __declspec(align(8)) PortalComponentDescription : BlockComponentDescription
{
  std::string mParticleEastWest;
  std::string mParticleNorthSouth;
  int mTargetDimension;
};

PortalComponentDescription_vtbl

struct /*VFT*/ PortalComponentDescription_vtbl
{
  void (__fastcall *~BlockComponentDescription)(BlockComponentDescription *this);
  const std::string *(__fastcall *getName)(BlockComponentDescription *this);
  void (__fastcall *initializeComponent)(BlockComponentDescription *this, EntityContext *);
  void (__fastcall *buildSchema)(BlockComponentDescription *this, std::shared_ptr<JsonUtil::JsonSchemaObjectNode<JsonUtil::EmptyClass,BlockComponentGroupDescription> > *, const BlockComponentFactory *);
  bool (__fastcall *isNetworkComponent)(BlockComponentDescription *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(BlockComponentDescription *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(BlockComponentDescription *this, const CompoundTag *);
};

PathableComponent

struct PathableComponent
{
  bool mPathable;
};

PathableComponentDescription

struct __cppobj __declspec(align(8)) PathableComponentDescription : BlockComponentDescription
{
  bool mPathable;
};

PathableComponentDescription_vtbl

struct /*VFT*/ PathableComponentDescription_vtbl
{
  void (__fastcall *~BlockComponentDescription)(BlockComponentDescription *this);
  const std::string *(__fastcall *getName)(BlockComponentDescription *this);
  void (__fastcall *initializeComponent)(BlockComponentDescription *this, EntityContext *);
  void (__fastcall *buildSchema)(BlockComponentDescription *this, std::shared_ptr<JsonUtil::JsonSchemaObjectNode<JsonUtil::EmptyClass,BlockComponentGroupDescription> > *, const BlockComponentFactory *);
  bool (__fastcall *isNetworkComponent)(BlockComponentDescription *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(BlockComponentDescription *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(BlockComponentDescription *this, const CompoundTag *);
};

PoweredBlockComponent

struct __cppobj __declspec(align(8)) PoweredBlockComponent : BaseCircuitComponent
{
  bool mPromotedToProducer;
  bool mAllowAsPowerSource;
};

PoweredBlockComponent_vtbl

struct /*VFT*/ PoweredBlockComponent_vtbl
{
  void (__fastcall *~BaseCircuitComponent)(BaseCircuitComponent *this);
  int (__fastcall *getStrength)(BaseCircuitComponent *this);
  int (__fastcall *getDirection)(BaseCircuitComponent *this);
  void (__fastcall *setStrength)(BaseCircuitComponent *this, int);
  void (__fastcall *setDirection)(BaseCircuitComponent *this, unsigned __int8);
  bool (__fastcall *consumePowerAnyDirection)(BaseCircuitComponent *this);
  bool (__fastcall *canConsumerPower)(BaseCircuitComponent *this);
  bool (__fastcall *canStopPower)(BaseCircuitComponent *this);
  void (__fastcall *setStopPower)(BaseCircuitComponent *this, bool);
  unsigned __int64 (__fastcall *getBaseType)(BaseCircuitComponent *this);
  unsigned __int64 (__fastcall *getInstanceType)(BaseCircuitComponent *this);
  bool (__fastcall *removeSource)(BaseCircuitComponent *this, const BlockPos *, const BaseCircuitComponent *);
  bool (__fastcall *addSource)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, int *, bool *);
  bool (__fastcall *allowConnection)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, bool *);
  void (__fastcall *checkLock)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  bool (__fastcall *evaluate)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *cacheValues)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *updateDependencies)(BaseCircuitComponent *this, CircuitSceneGraph *, const BlockPos *);
  bool (__fastcall *allowIndirect)(BaseCircuitComponent *this);
  bool (__fastcall *isHalfPulse)(BaseCircuitComponent *this);
  bool (__fastcall *hasSource)(BaseCircuitComponent *this, BaseCircuitComponent *);
  bool (__fastcall *hasChildrenSource)(BaseCircuitComponent *this);
  bool (__fastcall *isSecondaryPowered)(BaseCircuitComponent *this);
};

PulseCapacitor

struct __cppobj __declspec(align(8)) PulseCapacitor : CapacitorComponent
{
  bool mPowered;
  bool mNewPowered;
};

PulseCapacitor_vtbl

struct /*VFT*/ PulseCapacitor_vtbl
{
  void (__fastcall *~BaseCircuitComponent)(BaseCircuitComponent *this);
  int (__fastcall *getStrength)(BaseCircuitComponent *this);
  int (__fastcall *getDirection)(BaseCircuitComponent *this);
  void (__fastcall *setStrength)(BaseCircuitComponent *this, int);
  void (__fastcall *setDirection)(BaseCircuitComponent *this, unsigned __int8);
  bool (__fastcall *consumePowerAnyDirection)(BaseCircuitComponent *this);
  bool (__fastcall *canConsumerPower)(BaseCircuitComponent *this);
  bool (__fastcall *canStopPower)(BaseCircuitComponent *this);
  void (__fastcall *setStopPower)(BaseCircuitComponent *this, bool);
  unsigned __int64 (__fastcall *getBaseType)(BaseCircuitComponent *this);
  unsigned __int64 (__fastcall *getInstanceType)(BaseCircuitComponent *this);
  bool (__fastcall *removeSource)(BaseCircuitComponent *this, const BlockPos *, const BaseCircuitComponent *);
  bool (__fastcall *addSource)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, int *, bool *);
  bool (__fastcall *allowConnection)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, bool *);
  void (__fastcall *checkLock)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  bool (__fastcall *evaluate)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *cacheValues)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *updateDependencies)(BaseCircuitComponent *this, CircuitSceneGraph *, const BlockPos *);
  bool (__fastcall *allowIndirect)(BaseCircuitComponent *this);
  bool (__fastcall *isHalfPulse)(BaseCircuitComponent *this);
  bool (__fastcall *hasSource)(BaseCircuitComponent *this, BaseCircuitComponent *);
  bool (__fastcall *hasChildrenSource)(BaseCircuitComponent *this);
  bool (__fastcall *isSecondaryPowered)(BaseCircuitComponent *this);
  unsigned __int8 (__fastcall *getPoweroutDirection)(CapacitorComponent *this);
};

PortalForcer::PortalPosition

struct __cppobj PortalForcer::PortalPosition : Pos
{
  int lastUsed;
};

PistonConsumer

struct __cppobj __declspec(align(8)) PistonConsumer : ConsumerComponent
{
  unsigned __int8 mBlockedFace;
};

PistonConsumer_vtbl

struct /*VFT*/ PistonConsumer_vtbl
{
  void (__fastcall *~BaseCircuitComponent)(BaseCircuitComponent *this);
  int (__fastcall *getStrength)(BaseCircuitComponent *this);
  int (__fastcall *getDirection)(BaseCircuitComponent *this);
  void (__fastcall *setStrength)(BaseCircuitComponent *this, int);
  void (__fastcall *setDirection)(BaseCircuitComponent *this, unsigned __int8);
  bool (__fastcall *consumePowerAnyDirection)(BaseCircuitComponent *this);
  bool (__fastcall *canConsumerPower)(BaseCircuitComponent *this);
  bool (__fastcall *canStopPower)(BaseCircuitComponent *this);
  void (__fastcall *setStopPower)(BaseCircuitComponent *this, bool);
  unsigned __int64 (__fastcall *getBaseType)(BaseCircuitComponent *this);
  unsigned __int64 (__fastcall *getInstanceType)(BaseCircuitComponent *this);
  bool (__fastcall *removeSource)(BaseCircuitComponent *this, const BlockPos *, const BaseCircuitComponent *);
  bool (__fastcall *addSource)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, int *, bool *);
  bool (__fastcall *allowConnection)(BaseCircuitComponent *this, CircuitSceneGraph *, const CircuitTrackingInfo *, bool *);
  void (__fastcall *checkLock)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  bool (__fastcall *evaluate)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *cacheValues)(BaseCircuitComponent *this, CircuitSystem *, const BlockPos *);
  void (__fastcall *updateDependencies)(BaseCircuitComponent *this, CircuitSceneGraph *, const BlockPos *);
  bool (__fastcall *allowIndirect)(BaseCircuitComponent *this);
  bool (__fastcall *isHalfPulse)(BaseCircuitComponent *this);
  bool (__fastcall *hasSource)(BaseCircuitComponent *this, BaseCircuitComponent *);
  bool (__fastcall *hasChildrenSource)(BaseCircuitComponent *this);
  bool (__fastcall *isSecondaryPowered)(BaseCircuitComponent *this);
};

PodzolBlock

struct __cppobj PodzolBlock : BlockLegacy
{
};

PodzolBlock_vtbl

struct /*VFT*/ PodzolBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PotatoBlock

struct __cppobj PotatoBlock : CropBlock
{
};

PotatoBlock_vtbl

struct /*VFT*/ PotatoBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *checkAlive)(BushBlock *this, BlockSource *, const BlockPos *);
  const ItemInstance *(__fastcall *getBaseSeed)(CropBlock *this, const ItemInstance *result);
  const ItemInstance *(__fastcall *getBaseCrop)(CropBlock *this, const ItemInstance *result);
  int (__fastcall *getSeedNum)(CropBlock *this, Random *, int, int, bool);
  int (__fastcall *getCropNum)(CropBlock *this, Random *, int, int, bool);
};

PoweredRailBlock

struct __cppobj PoweredRailBlock : BaseRailBlock
{
};

PoweredRailBlock_vtbl

struct /*VFT*/ PoweredRailBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PressurePlateBlock

struct __cppobj __declspec(align(8)) PressurePlateBlock : BasePressurePlateBlock
{
  PressurePlateBlock::Sensitivity mSensitivity;
};

PressurePlateBlock_vtbl

struct /*VFT*/ PressurePlateBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  int (__fastcall *getTickDelay)(BasePressurePlateBlock *this);
  int (__fastcall *getSignalStrength)(BasePressurePlateBlock *this, BlockSource *, const BlockPos *);
  int (__fastcall *getSignalForData)(BasePressurePlateBlock *this, int);
  int (__fastcall *getRedstoneSignal)(BasePressurePlateBlock *this, int);
  const AABB *(__fastcall *getSensitiveAABB)(BasePressurePlateBlock *this, const AABB *result, const BlockPos *);
};

PrismarineBlock

struct __cppobj PrismarineBlock : BlockLegacy
{
};

PrismarineBlock_vtbl

struct /*VFT*/ PrismarineBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PumpkinBlock

struct __cppobj __declspec(align(8)) PumpkinBlock : BlockLegacy
{
  bool mLit;
  bool mCarved;
};

PumpkinBlock_vtbl

struct /*VFT*/ PumpkinBlock_vtbl
{
  void (__fastcall *~BlockLegacy)(BlockLegacy *this);
  const Block *(__fastcall *getStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  const Block *(__fastcall *getModBlockStateFromLegacyData)(BlockLegacy *this, unsigned __int16);
  std::shared_ptr<BlockActor> *(__fastcall *newBlockEntity)(BlockLegacy *this, std::shared_ptr<BlockActor> *result, const BlockPos *, const Block *);
  const Block *(__fastcall *getNextBlockPermutation)(BlockLegacy *this, const Block *);
  bool (__fastcall *hasTag)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *);
  bool (__fastcall *getCollisionShape)(BlockLegacy *this, AABB *, const Block *, BlockSource *, const BlockPos *, Actor *);
  bool (__fastcall *isObstructingChests)(BlockLegacy *this, BlockSource *, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *);
  Vec3 *(__fastcall *randomlyModifyPosition)(BlockLegacy *this, Vec3 *result, const BlockPos *, int *);
  void (__fastcall *addAABBs)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *);
  const AABB *(__fastcall *getAABB)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, AABB *, bool);
  bool (__fastcall *addCollisionShapes)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, const AABB *, std::vector<AABB> *, Actor *);
  const AABB *(__fastcall *getOutline)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  bool (__fastcall *getLiquidClipVolume)(BlockLegacy *this, BlockSource *, const BlockPos *, AABB *);
  void (__fastcall *onProjectileHit)(BlockLegacy *this, BlockSource *, const BlockPos *, const Actor *);
  bool (__fastcall *liquidCanFlowIntoFromDirection)(BlockLegacy *this, unsigned __int8, const std::function<Block const & __cdecl(BlockPos const &)> *, const BlockPos *);
  bool (__fastcall *hasVariableLighting)(BlockLegacy *this);
  bool (__fastcall *isStrippable)(BlockLegacy *this, const Block *);
  const Block *(__fastcall *getStrippedBlock)(BlockLegacy *this, const Block *);
  bool (__fastcall *canProvideSupport)(BlockLegacy *this, const Block *, unsigned __int8, BlockSupportType);
  bool (__fastcall *canConnect)(BlockLegacy *this, const Block *, unsigned __int8, const Block *);
  void (__fastcall *getConnectedDirections)(BlockLegacy *this, const Block *, const BlockPos *, BlockSource *, bool *, bool *, bool *, bool *);
  bool (__fastcall *isStemBlock)(BlockLegacy *this);
  bool (__fastcall *isContainerBlock)(BlockLegacy *this);
  bool (__fastcall *isCraftingBlock)(BlockLegacy *this);
  bool (__fastcall *isWaterBlocking)(BlockLegacy *this);
  bool (__fastcall *isHurtableBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isFenceGateBlock)(BlockLegacy *this);
  bool (__fastcall *isThinFenceBlock)(BlockLegacy *this);
  bool (__fastcall *isWallBlock)(BlockLegacy *this);
  bool (__fastcall *isStairBlock)(BlockLegacy *this);
  bool (__fastcall *isSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoubleSlabBlock)(BlockLegacy *this);
  bool (__fastcall *isDoorBlock)(BlockLegacy *this);
  bool (__fastcall *isRailBlock)(BlockLegacy *this);
  bool (__fastcall *isButtonBlock)(BlockLegacy *this);
  bool (__fastcall *canHurtAndBreakItem)(BlockLegacy *this);
  bool (__fastcall *isSignalSource)(BlockLegacy *this);
  bool (__fastcall *canBeOriginalSurface)(BlockLegacy *this);
  bool (__fastcall *isValidAuxValue)(BlockLegacy *this, int);
  void (__fastcall *setTargetLandBlocks)(BlockLegacy *this, const std::vector<std::string> *);
  bool (__fastcall *canFillAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  const Block *(__fastcall *sanitizeFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *onFillBlock)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getDirectSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  bool (__fastcall *waterSpreadCausesSpawn)(BlockLegacy *this);
  bool (__fastcall *canContainLiquid)(BlockLegacy *this);
  bool (__fastcall *shouldConnectToRedstone)(BlockLegacy *this, BlockSource *, const BlockPos *, int);
  void (__fastcall *handleRain)(BlockLegacy *this, BlockSource *, const BlockPos *, float);
  bool (__fastcall *canBeUsedInCommands)(BlockLegacy *this, const BaseGameVersion *);
  float (__fastcall *getThickness)(BlockLegacy *this);
  float (__fastcall *getFlexibility)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *checkIsPathable)(BlockLegacy *this, Actor *, const BlockPos *, const BlockPos *);
  bool (__fastcall *shouldDispense)(BlockLegacy *this, BlockSource *, Container *);
  bool (__fastcall *dispense)(BlockLegacy *this, BlockSource *, Container *, int, const Vec3 *, unsigned __int8);
  void (__fastcall *transformOnFall)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *onRedstoneUpdate)(BlockLegacy *this, BlockSource *, const BlockPos *, int, bool);
  void (__fastcall *onMove)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *detachesOnPistonMove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *movedByPiston)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onStructureNeighborBlockPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *setupRedstoneComponent)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *specialUse)(BlockLegacy *this, Player *, const BlockPos *, ItemStack *);
  BlockProperty (__fastcall *getRedstoneProperty)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *updateEntityAfterFallOn)(BlockLegacy *this, IActorMovementProxy *);
  bool (__fastcall *isBounceBlock)(BlockLegacy *this);
  bool (__fastcall *ignoreEntitiesOnPistonMove)(BlockLegacy *this, const Block *);
  bool (__fastcall *onFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, FertilizerType);
  bool (__fastcall *mayConsumeFertilizer)(BlockLegacy *this, BlockSource *);
  bool (__fastcall *canBeFertilized)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *mayPick)(BlockLegacy *this, BlockSource *, const Block *, bool);
  bool (__fastcall *mayPick)(BlockLegacy *this);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *mayPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, unsigned __int8);
  bool (__fastcall *mayPlaceOn)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *tryToPlace)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const ActorBlockSyncMessage *);
  bool (__fastcall *breaksFallingBlocks)(BlockLegacy *this, const Block *);
  void (__fastcall *destroy)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, Actor *);
  bool (__fastcall *playerWillDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  bool (__fastcall *getIgnoresDestroyPermissions)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *neighborChanged)(BlockLegacy *this, BlockSource *, const BlockPos *, const BlockPos *);
  bool (__fastcall *getSecondPart)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  int (__fastcall *getResourceCount)(BlockLegacy *this, Random *, const Block *, int, bool);
  ItemInstance *(__fastcall *getResourceItem)(BlockLegacy *this, ItemInstance *result, Random *, const Block *, int);
  ItemInstance *(__fastcall *asItemInstance)(BlockLegacy *this, ItemInstance *result, BlockSource *, const BlockPos *, const Block *);
  void (__fastcall *spawnResources)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  void (__fastcall *trySpawnResourcesOnExplosion)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, std::vector<Item const *> *, float, int, bool);
  bool (__fastcall *spawnBurnResources)(BlockLegacy *this, BlockSource *, float, float, float);
  const Block *(__fastcall *getPlacementBlock)(BlockLegacy *this, Actor *, const BlockPos *, unsigned __int8, const Vec3 *, int);
  int (__fastcall *calcVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *isAttachedTo)(BlockLegacy *this, BlockSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *attack)(BlockLegacy *this, Player *, const BlockPos *);
  void (__fastcall *handleEntityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, Vec3 *);
  void (__fastcall *entityInside)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  int (__fastcall *getExperienceDrop)(BlockLegacy *this, Random *);
  bool (__fastcall *canBeBuiltOver)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *triggerEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, int, int);
  void (__fastcall *executeEvent)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, const std::string *, Actor *);
  void (__fastcall *executeEvent)(BlockLegacy *this, const std::string *, RenderParams *);
  bool (__fastcall *executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  bool (__fastcall *executeTriggerChain)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, RenderParams *);
  const MobSpawnerData *(__fastcall *getMobToSpawn)(BlockLegacy *this, const SpawnConditions *, BlockSource *);
  bool (__fastcall *shouldStopFalling)(BlockLegacy *this, Actor *);
  bool (__fastcall *pushesUpFallingBlocks)(BlockLegacy *this);
  float (__fastcall *calcGroundFriction)(BlockLegacy *this, Mob *, const BlockPos *);
  bool (__fastcall *canHaveExtraData)(BlockLegacy *this);
  bool (__fastcall *hasComparatorSignal)(BlockLegacy *this);
  int (__fastcall *getComparatorSignal)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *, unsigned __int8);
  bool (__fastcall *onDig)(BlockLegacy *this, const Block *, Actor *, ItemStack *, const BlockPos *);
  bool (__fastcall *canSlide)(BlockLegacy *this, BlockSource *, const BlockPos *);
  bool (__fastcall *canSpawnAt)(BlockLegacy *this, const BlockSource *, const BlockPos *);
  void (__fastcall *notifySpawnedAt)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getIconYOffset)(BlockLegacy *this);
  std::string *(__fastcall *buildDescriptionId)(BlockLegacy *this, std::string *result, const Block *);
  bool (__fastcall *isAuxValueRelevantForPicking)(BlockLegacy *this);
  int (__fastcall *getColor)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  int (__fastcall *getColor)(BlockLegacy *this, const Block *);
  int (__fastcall *getColorAtPos)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getColorForParticle)(BlockLegacy *this, BlockSource *, const BlockPos *, const Block *);
  bool (__fastcall *isSeasonTinted)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  void (__fastcall *onGraphicsModeChanged)(BlockLegacy *this, const BlockGraphicsModeChangeContext *);
  float (__fastcall *getShadeBrightness)(BlockLegacy *this, const Block *);
  const AABB *(__fastcall *getVisualShapeInWorld)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *, AABB *, bool);
  const AABB *(__fastcall *getVisualShape)(BlockLegacy *this, const Block *, AABB *, bool);
  const AABB *(__fastcall *getUIShape)(BlockLegacy *this, const Block *, AABB *);
  int (__fastcall *telemetryVariant)(BlockLegacy *this, BlockSource *, const BlockPos *);
  int (__fastcall *getVariant)(BlockLegacy *this, const Block *);
  bool (__fastcall *canSpawnOn)(BlockLegacy *this);
  const Block *(__fastcall *getRenderBlock)(BlockLegacy *this);
  unsigned __int8 (__fastcall *getMappedFace)(BlockLegacy *this, unsigned __int8, const Block *);
  bool (__fastcall *renderTwoFaced)(BlockLegacy *this);
  Flip (__fastcall *getFaceFlip)(BlockLegacy *this, unsigned __int8, const Block *);
  void (__fastcall *animateTick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  BlockLegacy *(__fastcall *init)(BlockLegacy *this);
  BlockLegacy *(__fastcall *setLightBlock)(BlockLegacy *this, Brightness);
  BlockLegacy *(__fastcall *setLightEmission)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setExplodeable)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFlammable)(BlockLegacy *this, FlameOdds, BurnOdds);
  BlockLegacy *(__fastcall *setDestroyTime)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *setFriction)(BlockLegacy *this, float);
  BlockLegacy *(__fastcall *addProperty)(BlockLegacy *this, BlockProperty);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *, unsigned __int64);
  BlockLegacy *(__fastcall *addState)(BlockLegacy *this, const ItemState *);
  BlockLegacy *(__fastcall *setAllowsRunes)(BlockLegacy *this, bool);
  BlockLegacy *(__fastcall *setMapColor)(BlockLegacy *this, const mce::Color *);
  bool (__fastcall *canBeSilkTouched)(BlockLegacy *this);
  ItemInstance *(__fastcall *getSilkTouchItemInstance)(BlockLegacy *this, ItemInstance *result, const Block *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const Vec3 *, const Vec3 *);
  void (__fastcall *setVisualShape)(BlockLegacy *this, const AABB *);
  const Block *(__fastcall *tryLegacyUpgrade)(BlockLegacy *this, unsigned __int16);
  bool (__fastcall *dealsContactDamage)(BlockLegacy *this, const Actor *, const Block *, bool);
  void (__fastcall *onRemove)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onExploded)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *);
  void (__fastcall *onStandOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOn)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onStepOff)(BlockLegacy *this, Actor *, const BlockPos *);
  void (__fastcall *onPlayerPlacing)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, unsigned __int8);
  void (__fastcall *onPlace)(BlockLegacy *this, BlockSource *, const BlockPos *);
  void (__fastcall *onFallOn)(BlockLegacy *this, BlockSource *, const BlockPos *, Actor *, float);
  void (__fastcall *playerDestroy)(BlockLegacy *this, Player *, const BlockPos *, const Block *);
  void (__fastcall *tick)(BlockLegacy *this, BlockSource *, const BlockPos *, Random *);
  bool (__fastcall *shouldRandomTick)(BlockLegacy *this);
  bool (__fastcall *isInteractiveBlock)(BlockLegacy *this);
  HitResult *(__fastcall *clip)(BlockLegacy *this, HitResult *result, BlockSource *, const BlockPos *, const Vec3 *, const Vec3 *, bool);
  bool (__fastcall *use)(BlockLegacy *this, Player *, const BlockPos *, unsigned __int8);
  bool (__fastcall *canSurvive)(BlockLegacy *this, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this, const Block *, BlockSource *, const BlockPos *);
  BlockRenderLayer (__fastcall *getRenderLayer)(BlockLegacy *this);
  int (__fastcall *getExtraRenderLayers)(BlockLegacy *this);
  float (__fastcall *getExplosionResistance)(BlockLegacy *this, Actor *);
  Brightness *(__fastcall *getLightEmission)(BlockLegacy *this, Brightness *result, const Block *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result, BlockSource *, const BlockPos *);
  mce::Color *(__fastcall *getMapColor)(BlockLegacy *this, mce::Color *result);
  bool (__fastcall *isCropBlock)(BlockLegacy *this);
  void (__fastcall *_executeEvent)(BlockLegacy *this, const std::string *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  bool (__fastcall *_executeTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
  void (__fastcall *_forceExecuteTrigger)(BlockLegacy *this, const DefinitionTrigger *, std::vector<std::pair<std::string const ,std::string const >> *, RenderParams *);
};

PumpkinBlock::_canSpawnGolem::__l41::<lambda_8bd9c7cabed61562b6255f3b5e7e8780>

struct __cppobj PumpkinBlock::_canSpawnGolem::__l41::<lambda_8bd9c7cabed61562b6255f3b5e7e8780>
{
  const BlockPos *pos;
  Actor **added;
  BlockSource *region;
};

PumpkinBlock::_canSpawnGolem::__l26::<lambda_6042f3e319a3318934781374c2908672>

struct __cppobj PumpkinBlock::_canSpawnGolem::__l26::<lambda_6042f3e319a3318934781374c2908672>
{
  const BlockPos *pos;
  BlockSource *region;
};

PumpkinBlock::_canSpawnGolem::__l20::<lambda_1bf95c25b4c9b8a1aaafe168a6f88149>

struct __cppobj PumpkinBlock::_canSpawnGolem::__l20::<lambda_1bf95c25b4c9b8a1aaafe168a6f88149>
{
  const BlockPos *pos;
  Actor **added;
  BlockSource *region;
};

PumpkinBlock::_canSpawnGolem::__l8::<lambda_2b60a8bd82e8930770ec88cd15cfc591>

struct __cppobj PumpkinBlock::_canSpawnGolem::__l8::<lambda_2b60a8bd82e8930770ec88cd15cfc591>
{
  const BlockPos *pos;
  BlockSource *region;
};

PumpkinBlock::_canSpawnGolem::__l2::<lambda_aaafdb5f67f3f6e2bf7574e660ac5309>

struct __cppobj PumpkinBlock::_canSpawnGolem::__l2::<lambda_aaafdb5f67f3f6e2bf7574e660ac5309>
{
};

PostprocessingManager::LockedChunk

struct __cppobj PostprocessingManager::LockedChunk
{
  std::shared_ptr<LevelChunk> mChunk;
  std::unique_lock<std::mutex> mChunkLock;
};

PineTreeCanopy

struct __cppobj PineTreeCanopy : ITreeCanopy
{
  IntRange mHeight;
  int mRadius;
  BlockDescriptor mLeafBlockDescriptor;
};

PineTreeCanopy_vtbl

struct /*VFT*/ PineTreeCanopy_vtbl
{
  void (__fastcall *~ITreeCanopy)(ITreeCanopy *this);
  std::optional<BlockPos> *(__fastcall *placeCanopy)(ITreeCanopy *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *, const TreeHelper::TreeParams *);
  bool (__fastcall *parseTreeCanopy)(ITreeCanopy *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
};

PositionTrackingDB::UpdateOperation

struct __cppobj PositionTrackingDB::UpdateOperation : PositionTrackingDB::OperationBase
{
  BlockPos mUpdatedPosition;
  AutomaticID<Dimension,int> mDimensionType;
};

PositionTrackingDB::UpdateOperation_vtbl

struct /*VFT*/ PositionTrackingDB::UpdateOperation_vtbl
{
  void (__fastcall *~OperationBase)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *tick)(PositionTrackingDB::OperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  const char *(__fastcall *getDescription)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isAsync)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isComplete)(PositionTrackingDB::OperationBase *this);
};

PositionTrackingDB::AsyncOperationBase

struct __cppobj __declspec(align(4)) PositionTrackingDB::AsyncOperationBase : PositionTrackingDB::OperationBase
{
  PositionTrackingDB::AsyncOperationBase::InternalState mInternalState;
  bool mErrored;
};

PositionTrackingDB::AsyncOperationBase_vtbl

struct /*VFT*/ PositionTrackingDB::AsyncOperationBase_vtbl
{
  void (__fastcall *~OperationBase)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *tick)(PositionTrackingDB::OperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  const char *(__fastcall *getDescription)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isAsync)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isComplete)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *_init)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_tick)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_quit)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
};

PositionTrackingDB::DestroyOperation

struct __cppobj PositionTrackingDB::DestroyOperation : PositionTrackingDB::AsyncOperationBase
{
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mStorageTaskHandle;
};

PositionTrackingDB::DestroyOperation_vtbl

struct /*VFT*/ PositionTrackingDB::DestroyOperation_vtbl
{
  void (__fastcall *~OperationBase)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *tick)(PositionTrackingDB::OperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  const char *(__fastcall *getDescription)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isAsync)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isComplete)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *_init)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_tick)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_quit)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
};

PositionTrackingDB::LoadOperation

struct __cppobj PositionTrackingDB::LoadOperation : PositionTrackingDB::AsyncOperationBase
{
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mTaskHandle;
};

PositionTrackingDB::LoadOperation_vtbl

struct /*VFT*/ PositionTrackingDB::LoadOperation_vtbl
{
  void (__fastcall *~OperationBase)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *tick)(PositionTrackingDB::OperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  const char *(__fastcall *getDescription)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isAsync)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *isComplete)(PositionTrackingDB::OperationBase *this);
  bool (__fastcall *_init)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_tick)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
  bool (__fastcall *_quit)(PositionTrackingDB::AsyncOperationBase *this, std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer>, PositionTrackingDB::TrackingRecord *);
};

PositionTrackingDB::LoadOperation::_init::__l2::<lambda_8dba2277dd60122bb3d381ce7e4835cb>

struct __cppobj PositionTrackingDB::LoadOperation::_init::__l2::<lambda_8dba2277dd60122bb3d381ce7e4835cb>
{
  std::weak_ptr<PositionTrackingDB::PositionTrackingDBServer> databasePtr;
  PositionTrackingDB::TrackingRecord *record;
  PositionTrackingDB::LoadOperation *const __this;
};

PathFinder::_checkForDamagingBlock::__l2::<lambda_ed889324c6ec9ad6aee101d4e2373d93>

struct __cppobj PathFinder::_checkForDamagingBlock::__l2::<lambda_ed889324c6ec9ad6aee101d4e2373d93>
{
  Actor *actor;
};

PhotoStorage::getLoosePhotos::__l2::<lambda_1fb954a4a49327471b3fcc81e5250686>

struct __cppobj PhotoStorage::getLoosePhotos::__l2::<lambda_1fb954a4a49327471b3fcc81e5250686>
{
  PhotoStorage *const __this;
  std::vector<Core::PathBuffer<std::string >> *result;
};

PDFWriterWindows

struct __cppobj PDFWriterWindows : PDFWriter
{
};

PDFWriterWindows_vtbl

struct /*VFT*/ PDFWriterWindows_vtbl
{
  void (__fastcall *exportImagesToAlbum)(PDFWriter *this, PDFOptions, std::function<void __cdecl(std::optional<PDFError>)>);
  void (__fastcall *~PDFWriter)(PDFWriter *this);
};

PyStringObject

const struct __declspec(align(8)) PyStringObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 ob_size;
  int ob_shash;
  int ob_sstate;
  char ob_sval[1];
};

PythonInstance

struct __cppobj PythonInstance : ScriptInstance
{
  PythonRuntime *m_runtime;
  _object *m_pyInstance;
};

PythonInstance_vtbl

struct /*VFT*/ PythonInstance_vtbl
{
  void (__fastcall *~ScriptInstance)(ScriptInstance *this);
  void (__fastcall *bindInternalObject)(ScriptInstance *this, void *);
  void (__fastcall *unbindInternalObject)(ScriptInstance *this);
  void (__fastcall *callVoidFunction)(ScriptInstance *this, const char *);
  void (__fastcall *callIntFunction)(ScriptInstance *this, const char *, int);
  void (__fastcall *callStringFunction)(ScriptInstance *this, const char *, const std::string *);
  int (__fastcall *callStringFunctionInt)(ScriptInstance *this, const char *, const std::string *);
  void (__fastcall *callString2Function)(ScriptInstance *this, const char *, const std::string *, const std::string *);
  void (__fastcall *callProtocolFunction)(ScriptInstance *this, const char *, const std::string *, const std::string *);
};

PyObjectHelper

struct __cppobj PyObjectHelper
{
};

PyTypeTraits<unsigned long>

struct __cppobj PyTypeTraits<unsigned long>
{
};

PyDictEntry

struct PyDictEntry
{
  __int64 me_hash;
  _object *me_key;
  _object *me_value;
};

PyUnicodeObject

struct PyUnicodeObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 length;
  wchar_t *str;
  int hash;
  _object *defenc;
};

PyFloatObject

struct PyFloatObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  long double ob_fval;
};

PyByteArrayObject

struct PyByteArrayObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 ob_size;
  int ob_exports;
  __int64 ob_alloc;
  char *ob_bytes;
};

PyTupleObject

struct PyTupleObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 ob_size;
  _object *ob_item[1];
};

PyListObject

struct PyListObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 ob_size;
  _object **ob_item;
  __int64 allocated;
};

PyClassObject

struct PyClassObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *cl_bases;
  _object *cl_dict;
  _object *cl_name;
  _object *cl_getattr;
  _object *cl_setattr;
  _object *cl_delattr;
  _object *cl_weakreflist;
};

PyInstanceObject

struct PyInstanceObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  PyClassObject *in_class;
  _object *in_dict;
  _object *in_weakreflist;
};

PyGenObject

struct PyGenObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _frame *gi_frame;
  int gi_running;
  _object *gi_code;
  _object *gi_weakreflist;
};

PyDescrObject

struct PyDescrObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _typeobject *d_type;
  _object *d_name;
};

PyBaseExceptionObject

struct PyBaseExceptionObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
};

PySyntaxErrorObject

struct PySyntaxErrorObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
  _object *msg;
  _object *filename;
  _object *lineno;
  _object *offset;
  _object *text;
  _object *print_file_and_line;
};

PyUnicodeErrorObject

struct PyUnicodeErrorObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
  _object *encoding;
  _object *object;
  __int64 start;
  __int64 end;
  _object *reason;
};

PySystemExitObject

struct PySystemExitObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
  _object *code;
};

PyEnvironmentErrorObject

struct PyEnvironmentErrorObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
  _object *myerrno;
  _object *strerror;
  _object *filename;
};

PyWindowsErrorObject

struct PyWindowsErrorObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *dict;
  _object *args;
  _object *message;
  _object *myerrno;
  _object *strerror;
  _object *filename;
  _object *winerror;
};

PyTypeTraits<double>

struct __cppobj PyTypeTraits<double>
{
};

PyTypeTraits<long>

struct __cppobj PyTypeTraits<long>
{
};

PyTypeTraits<_object *>

struct __cppobj PyTypeTraits<_object *>
{
};

PyTypeTraits<float>

struct __cppobj PyTypeTraits<float>
{
};

PyTypeTraits<PyStringObject const *>

struct __cppobj PyTypeTraits<PyStringObject const *>
{
};

PyFileObject

struct __declspec(align(8)) PyFileObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _iobuf *f_fp;
  _object *f_name;
  _object *f_mode;
  int (__fastcall *f_close)(_iobuf *);
  int f_softspace;
  int f_binary;
  char *f_buf;
  char *f_bufend;
  char *f_bufptr;
  char *f_setbuf;
  int f_univ_newline;
  int f_newlinetypes;
  int f_skipnextlf;
  _object *f_encoding;
  _object *f_errors;
  _object *weakreflist;
  int unlocked_count;
  int readable;
  int writable;
};

PyCObject

struct PyCObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  void *cobject;
  void *desc;
  void (__fastcall *destructor)(void *);
};

PyTypeTraits<char const *>

struct __cppobj PyTypeTraits<char const *>
{
};

PyWrapperDescrObject

struct PyWrapperDescrObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _typeobject *d_type;
  _object *d_name;
  wrapperbase *d_base;
  void *d_wrapped;
};

PyCellObject

struct PyCellObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *ob_ref;
};

PyVarObject

struct PyVarObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  __int64 ob_size;
};

PySliceObject

struct PySliceObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *start;
  _object *stop;
  _object *step;
};

PyTypeTraits<unsigned int>

struct __cppobj PyTypeTraits<unsigned int>
{
};

PyTypeTraits<int>

struct __cppobj PyTypeTraits<int>
{
};

PyTypeTraits<char>

struct __cppobj PyTypeTraits<char>
{
};

PyBehaviorNode::{dtor}::__l2::<lambda_c7b4f04c6d01aaecadecc93b7cb3fdab>

struct __cppobj PyBehaviorNode::{dtor}::__l2::<lambda_c7b4f04c6d01aaecadecc93b7cb3fdab>
{
  PyBehaviorNode *const __this;
};

PyBehaviorNode::initializeFromDefinition::__l2::<lambda_083757b4507f93dff8376126328128c2>

struct __cppobj PyBehaviorNode::initializeFromDefinition::__l2::<lambda_083757b4507f93dff8376126328128c2>
{
  PyBehaviorNode *const __this;
  Actor *owner;
};

PyBehaviorNode::tick::__l2::<lambda_64d5bc822c52d27fda6cb28b2de8981b>

struct __cppobj PyBehaviorNode::tick::__l2::<lambda_64d5bc822c52d27fda6cb28b2de8981b>
{
};

PatchUpdater

struct __cppobj PatchUpdater
{
  PatchUpdater_vtbl *__vftable /*VFT*/;
  bool check_md5_;
  int max_conn_;
  std::string patchlist_cont_;
  int errCode_;
  std::string cacheEngineVer_;
  std::atomic<enum PatchUpdater::State> update_state_;
  std::atomic<int> failed_size_;
  std::atomic<__int64> total_size_;
  std::atomic<int> total_file_;
  std::shared_ptr<Downloader> downloader_;
  std::string http_server_;
  std::string version_;
  Core::PathBuffer<std::string > storage_path_;
  std::string before_ver_dir_;
  std::string after_ver_dir_;
  std::string res_dir_;
  std::string manifest_url_;
  std::shared_ptr<std::ofstream > resume_record_;
  std::shared_ptr<Manifest> local_manifest_;
  std::shared_ptr<Manifest> remote_manifest_;
  Downloader::DownloadUnit manifest_unit;
  std::unordered_map<std::string,Downloader::DownloadUnit> pending_units_;
  std::unordered_map<std::string,Downloader::DownloadUnit> downloading_units_;
  std::unordered_map<std::string,Downloader::DownloadUnit> failed_units_;
  std::unordered_map<std::string,Downloader::DownloadUnit> downloaded_units_;
  std::unordered_set<std::string> resume_set_;
  std::unordered_set<std::string> delete_set_;
  std::unordered_set<std::string> checkok_set_;
};

PatchUpdater_vtbl

struct /*VFT*/ PatchUpdater_vtbl
{
  void (__fastcall *~PatchUpdater)(PatchUpdater *this);
  void (__fastcall *onError)(PatchUpdater *this, const std::string *, const Downloader::Error *);
  void (__fastcall *onProgress)(PatchUpdater *this, int, int, const std::string *, const std::string *);
  void (__fastcall *onSuccess)(PatchUpdater *this, const std::string *);
};

PatchScripter

struct __cppobj PatchScripter
{
};

PatchUpdateMgr

struct __cppobj PatchUpdateMgr
{
  PatchUpdateMgr_vtbl *__vftable /*VFT*/;
  unsigned int mNowDownloadCount;
  unsigned int mTotalUpdateCount;
  __int64 mTotalUpdateSize;
  int mErrorCode;
  eUpdateStatus mUpdateStatus;
  std::string mPatchListUrl;
  std::string mLocalDataUrl;
  std::function<void __cdecl(void)> mSuccCallback;
  std::function<void __cdecl(int)> mFailCallback;
  EasyThread mUnzipThread;
  std::atomic<bool> mIsPatchUnzipping;
  std::vector<tPatchUpdateInfo> mPatchList;
  std::map<std::string,tDownloadInfo> mDownloadMap;
};

PatchUpdateMgr_vtbl

struct /*VFT*/ PatchUpdateMgr_vtbl
{
  void (__fastcall *~PatchUpdateMgr)(PatchUpdateMgr *this);
};

packhelper::PackInformation

struct __cppobj __declspec(align(8)) packhelper::PackInformation
{
  PackIdVersion mId;
  std::string mName;
  std::string mDescription;
  std::string mIconPath;
  std::string mZipPath;
  std::string mFileSystem;
  std::string mFullPath;
  unsigned __int64 mSize;
  _BYTE mPackType[1];
};

packhelper::NEPackManager

struct __cppobj packhelper::NEPackManager
{
  std::string mPath;
  _BYTE mPackType[1];
  std::vector<packhelper::PackInformation> *objectList;
  std::vector<packhelper::PackInformation> selectedList;
  std::vector<packhelper::PackInformation> availableList;
};

packhelper::WorldPacksModelManagerInfor

struct __cppobj packhelper::WorldPacksModelManagerInfor
{
  std::string path;
  std::shared_ptr<packhelper::NEPackManager> resourceMgr;
  std::shared_ptr<packhelper::NEPackManager> behaviorMgr;
  LevelSummary mEditoLevel;
};

param_encode::EFLoat

struct __cppobj param_encode::EFLoat : param_encode::EValue
{
  __int16 id;
  char *data[4];
};

param_encode::EFLoat_vtbl

struct /*VFT*/ param_encode::EFLoat_vtbl
{
  void (__fastcall *~EValue)(param_encode::EValue *this);
};

ProfilerObject

struct __declspec(align(8)) ProfilerObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  rotating_node_s *profilerEntries;
  _ProfilerContext *currentProfilerContext;
  _ProfilerContext *freelistProfilerContext;
  int flags;
};

PathableComponentDescription::buildSchema::__l2::<lambda_30e7c7048f8cb138b166e5c058545c4f>

struct __cppobj PathableComponentDescription::buildSchema::__l2::<lambda_30e7c7048f8cb138b166e5c058545c4f>
{
  const BlockComponentFactory *factory;
};

PathableComponentDescription::buildSchema::__l2::<lambda_1b3c70435a2a4fad9d277f705a74249d>

struct __cppobj PathableComponentDescription::buildSchema::__l2::<lambda_1b3c70435a2a4fad9d277f705a74249d>
{
};

PortalComponentDescription::buildSchema::__l2::<lambda_3f2d736a7e44415e3425b3554d4a0939>

struct __cppobj PortalComponentDescription::buildSchema::__l2::<lambda_3f2d736a7e44415e3425b3554d4a0939>
{
};

PortalComponentDescription::buildSchema::__l2::<lambda_44bf26706ca97033bf72960d23dd0f69>

struct __cppobj PortalComponentDescription::buildSchema::__l2::<lambda_44bf26706ca97033bf72960d23dd0f69>
{
  const BlockComponentFactory *factory;
};

PortalComponentDescription::buildSchema::__l2::<lambda_68229901329795c9abab26b6ae904c3f>

struct __cppobj PortalComponentDescription::buildSchema::__l2::<lambda_68229901329795c9abab26b6ae904c3f>
{
};

PortalComponentDescription::buildSchema::__l2::<lambda_968a3878dcaad9a3200bb8e1df3641b2>

struct __cppobj PortalComponentDescription::buildSchema::__l2::<lambda_968a3878dcaad9a3200bb8e1df3641b2>
{
};

PeekSystem

struct __cppobj PeekSystem : ITickingSystem
{
};

PeekSystem_vtbl

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

PanicGoal

struct __cppobj PanicGoal : Goal
{
  Mob *mMob;
  Mob *mHurtByMob;
  bool mIgnoreMobDamage;
  std::vector<enum ActorDamageCause> mDamageCauses;
  bool mPanicOnAllCauses;
  bool mForceUse;
  bool mPreferWater;
  float mSpeedMultipler;
  Vec3 mPosition;
  LevelSoundEvent mSoundEvent;
  FloatRange mSoundIntervalRange;
  Tick mNextSoundEventTick;
};

PanicGoal_vtbl

struct /*VFT*/ PanicGoal_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>);
};

PetSleepWithOwnerGoalData

struct PetSleepWithOwnerGoalData
{
  float speedModifier;
  int searchRange;
  int searchHeight;
  float goalRadius;
};

PetSleepWithOwnerState

struct __cppobj PetSleepWithOwnerState
{
  PetSleepWithOwnerState_vtbl *__vftable /*VFT*/;
  PetSleepWithOwnerGoal *mGoal;
};

PetSleepWithOwnerState_vtbl

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

PetSleepWithOwnerGoal

struct __cppobj PetSleepWithOwnerGoal : Goal
{
  PetSleepWithOwnerGoalData mData;
  Mob *mMob;
  std::unique_ptr<PetSleepWithOwnerState> mState;
  Vec3 mBedTargetPos;
  TempEPtr<Mob> mOwner;
};

PetSleepWithOwnerGoal_vtbl

struct /*VFT*/ PetSleepWithOwnerGoal_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>);
};

PickupItemsGoal

struct __cppobj __declspec(align(4)) PickupItemsGoal : Goal
{
  TempEPtr<Actor> mTarget;
  Vec3 mTargetPos;
  Mob *mMob;
  int mSearchRange;
  float mSpeedModifier;
  bool mTrackTarget;
  std::unique_ptr<Path> mPath;
  int mRandomStopInterval;
  float mGoalRadiusSq;
  int mTimeToRecalcPath;
  bool mPickupBasedOnChance;
  bool mCanPickupAnyItem;
  int mTimeoutAfterBeingAttacked;
  bool mCanPickupToHandOrEquipment;
};

PickupItemsGoal_vtbl

struct /*VFT*/ PickupItemsGoal_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>);
};

PlayerRideTamedGoal

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

PlayerRideTamedGoal_vtbl

struct /*VFT*/ PlayerRideTamedGoal_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>);
};

PlayGoal

struct __cppobj PlayGoal : Goal
{
  Villager *mVillager;
  TempEPtr<Villager> mFollowFriend;
  float mSpeedModifier;
  int mPlayTime;
};

PlayGoal_vtbl

struct /*VFT*/ PlayGoal_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>);
};

PillagerOutpostFeature

struct __cppobj PillagerOutpostFeature : StructureFeature
{
  const int OUTPOST_SPACING;
  const int MIN_OUTPOST_SEPARATION;
  std::vector<int> mAllowedBiomes;
};

PillagerOutpostFeature_vtbl

struct /*VFT*/ PillagerOutpostFeature_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);
};

PillagerOutpostStart

struct __cppobj PillagerOutpostStart : StructureStart
{
};

PillagerOutpostStart_vtbl

struct /*VFT*/ PillagerOutpostStart_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);
};

PodzolAreaFeature

struct __cppobj PodzolAreaFeature : Feature
{
};

PodzolAreaFeature_vtbl

struct /*VFT*/ PodzolAreaFeature_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 *);
};

PineTreeCanopy::_buildSchema::__l2::<lambda_182782a30b4a3f542b5b6c9fb2f55a34>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_182782a30b4a3f542b5b6c9fb2f55a34>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_dcd492bcc2be655cb1b8d2bca2f97002>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_dcd492bcc2be655cb1b8d2bca2f97002>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_b13b8d47350665710d2b8f2f5979603f>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_b13b8d47350665710d2b8f2f5979603f>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_d90f946bcfa4304fbc5ab4e0fae6df0f>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_d90f946bcfa4304fbc5ab4e0fae6df0f>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_c40a7745c9a1460d433bb53987f160ca>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_c40a7745c9a1460d433bb53987f160ca>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_6a5a6b913cc59afe8661b089d740cd0e>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_6a5a6b913cc59afe8661b089d740cd0e>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_ca8ac339c3f01159a70fec961c780a9e>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_ca8ac339c3f01159a70fec961c780a9e>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_de54f44a253749f9408f5b5646ed09d8>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_de54f44a253749f9408f5b5646ed09d8>
{
};

PineTreeCanopy::_buildSchema::__l2::<lambda_3359e2193e6598a29a5408e169880f44>

struct __cppobj PineTreeCanopy::_buildSchema::__l2::<lambda_3359e2193e6598a29a5408e169880f44>
{
};

PillagerOutpostPieces

struct __cppobj PillagerOutpostPieces
{
};

PillagerOutpostPieces::PillagerOutpostPiece

struct __cppobj __declspec(align(8)) PillagerOutpostPieces::PillagerOutpostPiece : TemplateStructurePiece
{
  std::vector<BlockPos> mPillagerPositions;
  std::vector<BlockPos> mCaptainPositions;
  std::vector<BlockPos> mIronGolemPositions;
  std::string mTemplateName;
  StructureManager *mStructureManager;
  BlockPos mPosition;
  float mIntegrity;
  Rotation mRotation;
  bool mIsSatellite;
  bool mHeightSet;
};

PillagerOutpostPieces::PillagerOutpostPiece_vtbl

struct /*VFT*/ PillagerOutpostPieces::PillagerOutpostPiece_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 *);
  void (__fastcall *_handleDataMarker)(TemplateStructurePiece *this, const std::string *, const BlockPos *, BlockSource *, Random *, const BoundingBox *);
};

PlayerInteractionSystem::InteractionMapping<InteractComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<InteractComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<InteractComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<InteractComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<BucketableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<BucketableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<BucketableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<BucketableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<TameableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<TameableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<TameableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<TameableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<TrustingComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<TrustingComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<TrustingComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<TrustingComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<AgeableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<AgeableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<AgeableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<AgeableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<BalloonableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<BalloonableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<BalloonableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<BalloonableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<HealableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<HealableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<HealableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<HealableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<BreedableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<BreedableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<BreedableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<BreedableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<BribeableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<BribeableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<BribeableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<BribeableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<LeashableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<LeashableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<LeashableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<LeashableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<NameableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<NameableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<NameableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<NameableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<MountTamingComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<MountTamingComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<MountTamingComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<MountTamingComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<RideableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<RideableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<RideableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<RideableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<SitComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<SitComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<SitComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<SitComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<NpcComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<NpcComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<NpcComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<NpcComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<TripodCameraComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<TripodCameraComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<TripodCameraComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<TripodCameraComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<LegacyTradeableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<LegacyTradeableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<LegacyTradeableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<LegacyTradeableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlayerInteractionSystem::InteractionMapping<GiveableComponent>

struct __cppobj PlayerInteractionSystem::InteractionMapping<GiveableComponent> : PlayerInteractionSystem::InteractionMappingBase
{
};

PlayerInteractionSystem::InteractionMapping<GiveableComponent>_vtbl

struct /*VFT*/ PlayerInteractionSystem::InteractionMapping<GiveableComponent>_vtbl
{
  void (__fastcall *~InteractionMappingBase)(PlayerInteractionSystem::InteractionMappingBase *this);
  bool (__fastcall *getInteraction)(PlayerInteractionSystem::InteractionMappingBase *this, Actor *, Player *, ActorInteraction *);
};

PlatformGestureEvent

struct PlatformGestureEvent
{
  GGInput::Event mType;
  unsigned int mSourceId;
  float x;
  float y;
  float z;
};

png_control

struct __declspec(align(8)) png_control
{
  png_struct_def *png_ptr;
  png_info_def *info_ptr;
  void *error_buf;
  const unsigned __int8 *memory;
  unsigned __int64 size;
  unsigned __int32 for_write : 1;
  unsigned __int32 owned_file : 1;
};

png_image

struct __declspec(align(8)) png_image
{
  png_control *opaque;
  unsigned int version;
  unsigned int width;
  unsigned int height;
  unsigned int format;
  unsigned int flags;
  unsigned int colormap_entries;
  unsigned int warning_or_error;
  char message[64];
};

png_image_read_control

struct __declspec(align(8)) png_image_read_control
{
  png_image *image;
  void *buffer;
  int row_stride;
  void *colormap;
  const png_color_struct *background;
  void *local_row;
  void *first_row;
  __int64 row_bytes;
  int file_encoding;
  int gamma_to_linear;
  int colormap_processing;
};

png_dsort_struct

struct __declspec(align(8)) png_dsort_struct
{
  png_dsort_struct *next;
  unsigned __int8 left;
  unsigned __int8 right;
};

png_image_write_control

struct png_image_write_control
{
  png_image *image;
  const void *buffer;
  int row_stride;
  const void *colormap;
  int convert_to_8bit;
  const void *first_row;
  __int64 row_bytes;
  void *local_row;
  unsigned __int8 *memory;
  unsigned __int64 memory_bytes;
  unsigned __int64 output_bytes;
};

PerfMetrics::Counter

struct __cppobj PerfMetrics::Counter
{
  std::atomic<unsigned __int64> mCurrentTotal;
  std::atomic<unsigned __int64> mPeakTotal;
  std::atomic<unsigned __int64> mNumSamples;
};

PerfMetrics::Gauge

struct __cppobj PerfMetrics::Gauge : PerfMetrics::Counter
{
};

PerfMetrics::Timer

struct __cppobj PerfMetrics::Timer
{
  std::atomic<unsigned __int64> mNumSamples;
  std::atomic<unsigned __int64> mLargestSample;
  std::atomic<unsigned __int64> mSmallestSample;
  std::atomic<unsigned __int64> mTotalTime;
};

PackRenderCapabilitiesBitSet

struct __cppobj PackRenderCapabilitiesBitSet : EnumBitset<enum RenderCapability,14>
{
};

pkcs7_enc_content_st

struct pkcs7_enc_content_st
{
  asn1_object_st *content_type;
  X509_algor_st *algorithm;
  asn1_string_st *enc_data;
  const evp_cipher_st *cipher;
};

pkcs7_signedandenveloped_st

struct pkcs7_signedandenveloped_st
{
  asn1_string_st *version;
  stack_st_X509_ALGOR *md_algs;
  stack_st_X509 *cert;
  stack_st_X509_CRL *crl;
  stack_st_PKCS7_SIGNER_INFO *signer_info;
  pkcs7_enc_content_st *enc_data;
  stack_st_PKCS7_RECIP_INFO *recipientinfo;
};

pkcs7_enveloped_st

struct pkcs7_enveloped_st
{
  asn1_string_st *version;
  stack_st_PKCS7_RECIP_INFO *recipientinfo;
  pkcs7_enc_content_st *enc_data;
};

pkcs7_encrypted_st

struct pkcs7_encrypted_st
{
  asn1_string_st *version;
  pkcs7_enc_content_st *enc_data;
};

private_key_st

struct private_key_st
{
  int version;
  X509_algor_st *enc_algor;
  asn1_string_st *enc_pkey;
  struct evp_pkey_st *dec_pkey;
  int key_length;
  char *key_data;
  int key_free;
  evp_cipher_info_st cipher;
};

pkcs7_st

struct pkcs7_st
{
  unsigned __int8 *asn1;
  int length;
  int state;
  int detached;
  asn1_object_st *type;
  pkcs7_st::<unnamed_type_d> d;
};

pkcs7_signed_st

struct pkcs7_signed_st
{
  asn1_string_st *version;
  stack_st_X509_ALGOR *md_algs;
  stack_st_X509 *cert;
  stack_st_X509_CRL *crl;
  stack_st_PKCS7_SIGNER_INFO *signer_info;
  pkcs7_st *contents;
};

pkcs7_digest_st

struct pkcs7_digest_st
{
  asn1_string_st *version;
  X509_algor_st *md;
  pkcs7_st *contents;
  asn1_string_st *digest;
};

pkcs7_issuer_and_serial_st

struct pkcs7_issuer_and_serial_st
{
  X509_name_st *issuer;
  asn1_string_st *serial;
};

pkcs7_signer_info_st

struct pkcs7_signer_info_st
{
  asn1_string_st *version;
  pkcs7_issuer_and_serial_st *issuer_and_serial;
  X509_algor_st *digest_alg;
  struct stack_st_X509_ATTRIBUTE *auth_attr;
  X509_algor_st *digest_enc_alg;
  asn1_string_st *enc_digest;
  struct stack_st_X509_ATTRIBUTE *unauth_attr;
  struct evp_pkey_st *pkey;
};

pkcs7_recip_info_st

struct pkcs7_recip_info_st
{
  asn1_string_st *version;
  pkcs7_issuer_and_serial_st *issuer_and_serial;
  X509_algor_st *key_enc_algor;
  asn1_string_st *enc_key;
  struct x509_st *cert;
};

PlayFab::CallRequestContainerBase

struct __cppobj PlayFab::CallRequestContainerBase
{
  PlayFab::CallRequestContainerBase_vtbl *__vftable /*VFT*/;
  std::string url;
  std::unordered_map<std::string,std::string> headers;
  std::string requestBody;
  std::shared_ptr<PlayFab::PlayFabApiSettings> apiSettings;
  std::function<void __cdecl(int,std::string,std::unique_ptr<PlayFab::CallRequestContainerBase>)> callback;
  void *customData;
};

PlayFab::CallRequestContainerBase_vtbl

struct /*VFT*/ PlayFab::CallRequestContainerBase_vtbl
{
  void (__fastcall *~CallRequestContainerBase)(PlayFab::CallRequestContainerBase *this);
};

PlayFab::PlayFabApiSettings

struct __cppobj __declspec(align(8)) PlayFab::PlayFabApiSettings
{
  std::string verticalName;
  std::string baseServiceHost;
  std::string titleId;
  std::string advertisingIdType;
  std::string advertisingIdValue;
  bool disableAdvertising;
};

PlayFab::PlayFabError

struct __cppobj PlayFab::PlayFabError : PlayFab::PlayFabBaseModel
{
  int HttpCode;
  std::string HttpStatus;
  PlayFab::PlayFabErrorCode ErrorCode;
  std::string ErrorName;
  std::string ErrorMessage;
  Json::Value ErrorDetails;
  Json::Value Data;
  std::string UrlPath;
  Json::Value Request;
};

PlayFab::PlayFabError_vtbl

struct /*VFT*/ PlayFab::PlayFabError_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::CallRequestContainer

struct __cppobj PlayFab::CallRequestContainer : PlayFab::CallRequestContainerBase
{
  bool finished;
  std::string responseString;
  Json::Value responseJson;
  PlayFab::PlayFabError errorWrapper;
  std::shared_ptr<void> successCallback;
  std::function<void __cdecl(PlayFab::PlayFabError const &,void *)> errorCallback;
};

PlayFab::CallRequestContainer_vtbl

struct /*VFT*/ PlayFab::CallRequestContainer_vtbl
{
  void (__fastcall *~CallRequestContainerBase)(PlayFab::CallRequestContainerBase *this);
};

PlayFab::IPlayFabPlugin

struct __cppobj PlayFab::IPlayFabPlugin
{
};

PlayFab::OneDSCallRequestContainer

struct __cppobj PlayFab::OneDSCallRequestContainer : PlayFab::CallRequestContainer
{
  std::vector<unsigned char> requestBinaryBody;
};

PlayFab::OneDSCallRequestContainer_vtbl

struct /*VFT*/ PlayFab::OneDSCallRequestContainer_vtbl
{
  void (__fastcall *~CallRequestContainerBase)(PlayFab::CallRequestContainerBase *this);
};

PlayFab::IPlayFabHttpPlugin

struct __cppobj PlayFab::IPlayFabHttpPlugin : PlayFab::IPlayFabPlugin
{
  PlayFab::IPlayFabHttpPlugin_vtbl *__vftable /*VFT*/;
};

PlayFab::IPlayFabHttpPlugin_vtbl

struct /*VFT*/ PlayFab::IPlayFabHttpPlugin_vtbl
{
  void (__fastcall *~IPlayFabHttpPlugin)(PlayFab::IPlayFabHttpPlugin *this);
  void (__fastcall *MakePostRequest)(PlayFab::IPlayFabHttpPlugin *this, std::unique_ptr<PlayFab::CallRequestContainerBase>);
  unsigned __int64 (__fastcall *Update)(PlayFab::IPlayFabHttpPlugin *this);
};

PlayFab::PlayFabCurlHttpPlugin

struct __cppobj PlayFab::PlayFabCurlHttpPlugin : PlayFab::IPlayFabHttpPlugin
{
  std::thread workerThread;
  std::mutex httpRequestMutex;
  std::atomic<bool> threadRunning;
  int activeRequestCount;
  std::deque<std::unique_ptr<PlayFab::CallRequestContainerBase>> pendingRequests;
  std::deque<std::unique_ptr<PlayFab::CallRequestContainerBase>> pendingResults;
};

PlayFab::PlayFabCurlHttpPlugin_vtbl

struct /*VFT*/ PlayFab::PlayFabCurlHttpPlugin_vtbl
{
  void (__fastcall *~IPlayFabHttpPlugin)(PlayFab::IPlayFabHttpPlugin *this);
  void (__fastcall *MakePostRequest)(PlayFab::IPlayFabHttpPlugin *this, std::unique_ptr<PlayFab::CallRequestContainerBase>);
  unsigned __int64 (__fastcall *Update)(PlayFab::IPlayFabHttpPlugin *this);
  void (__fastcall *ExecuteRequest)(PlayFab::PlayFabCurlHttpPlugin *this, std::unique_ptr<PlayFab::CallRequestContainer>);
};

PlayFab::OneDSCurlHttpPlugin

struct __cppobj PlayFab::OneDSCurlHttpPlugin : PlayFab::PlayFabCurlHttpPlugin
{
};

PlayFab::OneDSCurlHttpPlugin_vtbl

struct /*VFT*/ PlayFab::OneDSCurlHttpPlugin_vtbl
{
  void (__fastcall *~IPlayFabHttpPlugin)(PlayFab::IPlayFabHttpPlugin *this);
  void (__fastcall *MakePostRequest)(PlayFab::IPlayFabHttpPlugin *this, std::unique_ptr<PlayFab::CallRequestContainerBase>);
  unsigned __int64 (__fastcall *Update)(PlayFab::IPlayFabHttpPlugin *this);
  void (__fastcall *ExecuteRequest)(PlayFab::PlayFabCurlHttpPlugin *this, std::unique_ptr<PlayFab::CallRequestContainer>);
};

PlayFab::IPlayFabEmitEventRequest

const struct __cppobj PlayFab::IPlayFabEmitEventRequest
{
  PlayFab::IPlayFabEmitEventRequest_vtbl *__vftable /*VFT*/;
};

PlayFab::IPlayFabEmitEventRequest_vtbl

struct /*VFT*/ PlayFab::IPlayFabEmitEventRequest_vtbl
{
  void (__fastcall *~IPlayFabEmitEventRequest)(PlayFab::IPlayFabEmitEventRequest *this);
};

PlayFab::EventsModels::EntityKey

struct __cppobj PlayFab::EventsModels::EntityKey : PlayFab::PlayFabBaseModel
{
  std::string Id;
  std::string Type;
};

PlayFab::EventsModels::EntityKey_vtbl

struct /*VFT*/ PlayFab::EventsModels::EntityKey_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::EventsModels::EntityKey>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::EventsModels::EntityKey>
{
  PlayFab::EventsModels::EntityKey boxedValue;
  bool isSet;
};

PlayFab::EventsModels::EventContents

struct __cppobj PlayFab::EventsModels::EventContents : PlayFab::PlayFabBaseModel
{
  PlayFab::Boxed<PlayFab::EventsModels::EntityKey> Entity;
  std::string EventNamespace;
  std::string Name;
  std::string OriginalId;
  PlayFab::Boxed<__int64> OriginalTimestamp;
  Json::Value Payload;
  std::string PayloadJSON;
};

PlayFab::EventsModels::EventContents_vtbl

struct /*VFT*/ PlayFab::EventsModels::EventContents_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::IPlayFabEventPipeline

struct __cppobj PlayFab::IPlayFabEventPipeline
{
  PlayFab::IPlayFabEventPipeline_vtbl *__vftable /*VFT*/;
};

PlayFab::IPlayFabEventPipeline_vtbl

struct /*VFT*/ PlayFab::IPlayFabEventPipeline_vtbl
{
  void (__fastcall *~IPlayFabEventPipeline)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *Start)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *IntakeEvent)(PlayFab::IPlayFabEventPipeline *this, std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >);
};

PlayFab::PlayFabEventPipeline

struct __cppobj PlayFab::PlayFabEventPipeline : PlayFab::IPlayFabEventPipeline
{
  std::unordered_map<void *,std::vector<std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >>> batchesInFlight;
  std::vector<std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >> batch;
  std::shared_ptr<PlayFab::PlayFabEventPipelineSettings> settings;
  PlayFab::PlayFabEventBuffer buffer;
  std::thread workerThread;
  std::atomic<bool> isWorkerThreadRunning;
  std::mutex userExceptionCallbackMutex;
  std::function<void __cdecl(std::exception)> userExceptionCallback;
};

PlayFab::PlayFabEventPipelineSettings

struct __cppobj PlayFab::PlayFabEventPipelineSettings
{
  PlayFab::PlayFabEventPipelineSettings_vtbl *__vftable /*VFT*/;
  unsigned __int64 bufferSize;
  unsigned __int64 maximalNumberOfItemsInBatch;
  unsigned __int64 maximalBatchWaitTime;
  unsigned __int64 maximalNumberOfRetries;
  unsigned __int64 maximalNumberOfBatchesInFlight;
  __int64 readBufferWaitTime;
  std::shared_ptr<PlayFab::PlayFabAuthenticationContext> authenticationContext;
};

PlayFab::PlayFabEventPipelineSettings_vtbl

struct /*VFT*/ PlayFab::PlayFabEventPipelineSettings_vtbl
{
  void (__fastcall *~PlayFabEventPipelineSettings)(PlayFab::PlayFabEventPipelineSettings *this);
};

PlayFab::PlayFabAuthenticationContext

struct __cppobj PlayFab::PlayFabAuthenticationContext
{
  std::string clientSessionTicket;
  std::string entityToken;
};

PlayFab::AtomicSpin

struct __cppobj PlayFab::AtomicSpin
{
  std::atomic<std::thread::id> threadId;
  int count;
};

PlayFab::PlayFabEventPacket

struct __cppobj PlayFab::PlayFabEventPacket
{
  std::atomic<PlayFab::PlayFabEventPacket *> next;
  unsigned __int64 eventIndex;
  __int64 timestamp;
  std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const > eventRequest;
};

PlayFab::PlayFabEventBuffer

struct __cppobj PlayFab::PlayFabEventBuffer
{
  PlayFab::AtomicSpin atomicSpin;
  std::atomic<bool> disabled;
  const unsigned __int64 buffMask;
  std::unique_ptr<unsigned char [0]> bufferArray;
  const unsigned __int64 buffStart;
  const unsigned __int64 buffEnd;
  std::atomic<PlayFab::PlayFabEventPacket *> head;
  PlayFab::PlayFabEventPacket *tail;
  std::shared_ptr<std::atomic<unsigned __int64> > eventIndex;
};

PlayFab::PlayFabEventPipeline_vtbl

struct /*VFT*/ PlayFab::PlayFabEventPipeline_vtbl
{
  void (__fastcall *~IPlayFabEventPipeline)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *Start)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *IntakeEvent)(PlayFab::IPlayFabEventPipeline *this, std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >);
  void (__fastcall *SendBatch)(PlayFab::PlayFabEventPipeline *this, unsigned __int64 *);
};

PlayFab::OneDSEventsAPI

struct __cppobj PlayFab::OneDSEventsAPI
{
  bool isOneDSAuthenticated;
  std::string oneDSProjectIdIkey;
  std::string oneDSIngestionKey;
  std::string oneDSJwtToken;
  std::string oneDSHeaderJwtTicketKey;
  std::string oneDSHeaderJwtTicketPrefix;
};

PlayFab::OneDSEventPipeline

struct __cppobj PlayFab::OneDSEventPipeline : PlayFab::PlayFabEventPipeline
{
  PlayFab::OneDSEventsAPI oneDSEventsApi;
};

PlayFab::OneDSEventPipeline_vtbl

struct /*VFT*/ PlayFab::OneDSEventPipeline_vtbl
{
  void (__fastcall *~IPlayFabEventPipeline)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *Start)(PlayFab::IPlayFabEventPipeline *this);
  void (__fastcall *IntakeEvent)(PlayFab::IPlayFabEventPipeline *this, std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >);
  void (__fastcall *SendBatch)(PlayFab::PlayFabEventPipeline *this, unsigned __int64 *);
};

PlayFab::IPlayFabEmitEventResponse

struct __cppobj PlayFab::IPlayFabEmitEventResponse
{
  PlayFab::IPlayFabEmitEventResponse_vtbl *__vftable /*VFT*/;
};

PlayFab::IPlayFabEmitEventResponse_vtbl

struct /*VFT*/ PlayFab::IPlayFabEmitEventResponse_vtbl
{
  void (__fastcall *~IPlayFabEmitEventResponse)(PlayFab::IPlayFabEmitEventResponse *this);
};

PlayFab::PlayFabResultCommon

struct __cppobj PlayFab::PlayFabResultCommon : PlayFab::PlayFabBaseModel
{
  Json::Value Request;
};

PlayFab::PlayFabResultCommon_vtbl

struct /*VFT*/ PlayFab::PlayFabResultCommon_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::EventsModels::WriteEventsResponse

const struct __cppobj PlayFab::EventsModels::WriteEventsResponse : PlayFab::PlayFabResultCommon
{
  std::list<std::string> AssignedEventIds;
};

PlayFab::EventsModels::WriteEventsResponse_vtbl

struct /*VFT*/ PlayFab::EventsModels::WriteEventsResponse_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::PlayFabEmitEventResponse

struct __cppobj PlayFab::PlayFabEmitEventResponse : PlayFab::IPlayFabEmitEventResponse
{
  PlayFab::EmitEventResult emitEventResult;
  std::shared_ptr<PlayFab::PlayFabError const > playFabError;
  std::shared_ptr<PlayFab::EventsModels::WriteEventsResponse const > writeEventsResponse;
  std::shared_ptr<std::vector<std::shared_ptr<PlayFab::IPlayFabEmitEventRequest const >> const > batch;
  unsigned __int64 batchNumber;
};

PlayFab::PlayFabEmitEventResponse_vtbl

struct /*VFT*/ PlayFab::PlayFabEmitEventResponse_vtbl
{
  void (__fastcall *~IPlayFabEmitEventResponse)(PlayFab::IPlayFabEmitEventResponse *this);
};

PlayFab::EventsModels::TelemetryIngestionConfigResponse

const struct __cppobj PlayFab::EventsModels::TelemetryIngestionConfigResponse : PlayFab::PlayFabResultCommon
{
  std::string IngestionKey;
  std::string TelemetryJwtHeaderKey;
  std::string TelemetryJwtHeaderPrefix;
  std::string TelemetryJwtToken;
  std::string TenantId;
};

PlayFab::EventsModels::TelemetryIngestionConfigResponse_vtbl

struct /*VFT*/ PlayFab::EventsModels::TelemetryIngestionConfigResponse_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::EventsModels::OneDSWriteEventsResponse

const struct __cppobj PlayFab::EventsModels::OneDSWriteEventsResponse : PlayFab::EventsModels::WriteEventsResponse
{
  const PlayFab::PlayFabError *errorWrapper;
};

PlayFab::EventsModels::OneDSWriteEventsResponse_vtbl

struct /*VFT*/ PlayFab::EventsModels::OneDSWriteEventsResponse_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::IPlayFabEvent

const struct __cppobj PlayFab::IPlayFabEvent
{
  PlayFab::IPlayFabEvent_vtbl *__vftable /*VFT*/;
};

PlayFab::IPlayFabEvent_vtbl

struct /*VFT*/ PlayFab::IPlayFabEvent_vtbl
{
  void (__fastcall *~IPlayFabEvent)(PlayFab::IPlayFabEvent *this);
};

PlayFab::PlayFabEvent

const struct __cppobj PlayFab::PlayFabEvent : PlayFab::IPlayFabEvent
{
  PlayFab::PlayFabEventType eventType;
  PlayFab::EventsModels::EventContents eventContents;
};

PlayFab::PlayFabEvent_vtbl

struct /*VFT*/ PlayFab::PlayFabEvent_vtbl
{
  void (__fastcall *~IPlayFabEvent)(PlayFab::IPlayFabEvent *this);
};

PlayFab::PlayFabEmitEventRequest

struct __cppobj PlayFab::PlayFabEmitEventRequest : PlayFab::IPlayFabEmitEventRequest
{
  std::shared_ptr<PlayFab::PlayFabEvent const > event;
  std::function<void __cdecl(std::shared_ptr<PlayFab::IPlayFabEvent const >,std::shared_ptr<PlayFab::IPlayFabEmitEventResponse const >)> callback;
};

PlayFab::PlayFabEmitEventRequest_vtbl

struct /*VFT*/ PlayFab::PlayFabEmitEventRequest_vtbl
{
  void (__fastcall *~IPlayFabEmitEventRequest)(PlayFab::IPlayFabEmitEventRequest *this);
};

PlayFab::OneDSEventPipelineSettings

struct __cppobj PlayFab::OneDSEventPipelineSettings : PlayFab::PlayFabEventPipelineSettings
{
};

PlayFab::OneDSEventPipelineSettings_vtbl

struct /*VFT*/ PlayFab::OneDSEventPipelineSettings_vtbl
{
  void (__fastcall *~PlayFabEventPipelineSettings)(PlayFab::PlayFabEventPipelineSettings *this);
};

PlayFab::PlayFabRequestCommon

struct __cppobj PlayFab::PlayFabRequestCommon : PlayFab::PlayFabBaseModel
{
  std::shared_ptr<PlayFab::PlayFabAuthenticationContext> authenticationContext;
};

PlayFab::PlayFabRequestCommon_vtbl

struct /*VFT*/ PlayFab::PlayFabRequestCommon_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::EventsModels::TelemetryIngestionConfigRequest

struct __cppobj PlayFab::EventsModels::TelemetryIngestionConfigRequest : PlayFab::PlayFabRequestCommon
{
};

PlayFab::EventsModels::TelemetryIngestionConfigRequest_vtbl

struct /*VFT*/ PlayFab::EventsModels::TelemetryIngestionConfigRequest_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::EventsModels::WriteEventsRequest

struct __cppobj PlayFab::EventsModels::WriteEventsRequest : PlayFab::PlayFabRequestCommon
{
  std::list<PlayFab::EventsModels::EventContents> Events;
};

PlayFab::EventsModels::WriteEventsRequest_vtbl

struct /*VFT*/ PlayFab::EventsModels::WriteEventsRequest_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::PlayFabSettings

struct __cppobj PlayFab::PlayFabSettings
{
};

PlayFab::PlayFabPluginManager

struct __cppobj PlayFab::PlayFabPluginManager
{
  std::map<std::pair<enum PlayFab::PlayFabPluginContract const ,std::string const > const ,std::shared_ptr<PlayFab::IPlayFabPlugin>,std::less<std::pair<enum PlayFab::PlayFabPluginContract const ,std::string const > const >,std::allocator<std::pair<std::pair<enum PlayFab::PlayFabPluginContract const ,std::string const > const ,std::shared_ptr<PlayFab::IPlayFabPlugin> > > > plugins;
  std::mutex userExceptionCallbackMutex;
  std::function<void __cdecl(std::exception)> userExceptionCallback;
};

PlayFab::AuthenticationModels::EntityKey

struct __cppobj PlayFab::AuthenticationModels::EntityKey : PlayFab::PlayFabBaseModel
{
  std::string Id;
  std::string Type;
};

PlayFab::AuthenticationModels::EntityKey_vtbl

struct /*VFT*/ PlayFab::AuthenticationModels::EntityKey_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::AuthenticationModels::EntityKey>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::AuthenticationModels::EntityKey>
{
  PlayFab::AuthenticationModels::EntityKey boxedValue;
  bool isSet;
};

PlayFab::AuthenticationModels::GetEntityTokenResponse

const struct __cppobj PlayFab::AuthenticationModels::GetEntityTokenResponse : PlayFab::PlayFabResultCommon
{
  PlayFab::Boxed<PlayFab::AuthenticationModels::EntityKey> Entity;
  std::string EntityToken;
  PlayFab::Boxed<__int64> TokenExpiration;
};

PlayFab::AuthenticationModels::GetEntityTokenResponse_vtbl

struct /*VFT*/ PlayFab::AuthenticationModels::GetEntityTokenResponse_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::PlayFabAuthenticationAPI

struct __cppobj PlayFab::PlayFabAuthenticationAPI
{
};

PlayFab::AuthenticationModels::GetEntityTokenRequest

struct __cppobj PlayFab::AuthenticationModels::GetEntityTokenRequest : PlayFab::PlayFabRequestCommon
{
  PlayFab::Boxed<PlayFab::AuthenticationModels::EntityKey> Entity;
};

PlayFab::AuthenticationModels::GetEntityTokenRequest_vtbl

struct /*VFT*/ PlayFab::AuthenticationModels::GetEntityTokenRequest_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::PlayFabAuthenticationInstanceAPI

struct __cppobj PlayFab::PlayFabAuthenticationInstanceAPI
{
  std::shared_ptr<PlayFab::PlayFabApiSettings> settings;
  std::shared_ptr<PlayFab::PlayFabAuthenticationContext> authContext;
};

PlayFab::Boxed<enum PlayFab::ClientModels::UserDataPermission>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::UserDataPermission>
{
  PlayFab::ClientModels::UserDataPermission boxedValue;
  bool isSet;
};

PlayFab::ClientModels::SharedGroupDataRecord

struct __cppobj PlayFab::ClientModels::SharedGroupDataRecord : PlayFab::PlayFabBaseModel
{
  __int64 LastUpdated;
  std::string LastUpdatedBy;
  PlayFab::Boxed<enum PlayFab::ClientModels::UserDataPermission> Permission;
  std::string Value;
};

PlayFab::ClientModels::SharedGroupDataRecord_vtbl

struct /*VFT*/ PlayFab::ClientModels::SharedGroupDataRecord_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::TagModel

struct __cppobj PlayFab::ClientModels::TagModel : PlayFab::PlayFabBaseModel
{
  std::string TagValue;
};

PlayFab::ClientModels::TagModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::TagModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<int>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<int>
{
  int boxedValue;
  bool isSet;
};

PlayFab::ClientModels::ItemInstance

struct __cppobj __declspec(align(8)) PlayFab::ClientModels::ItemInstance : PlayFab::PlayFabBaseModel
{
  std::string Annotation;
  std::list<std::string> BundleContents;
  std::string BundleParent;
  std::string CatalogVersion;
  std::map<std::string,std::string> CustomData;
  std::string DisplayName;
  PlayFab::Boxed<__int64> Expiration;
  std::string ItemClass;
  std::string ItemId;
  std::string ItemInstanceId;
  PlayFab::Boxed<__int64> PurchaseDate;
  PlayFab::Boxed<int> RemainingUses;
  std::string UnitCurrency;
  unsigned int UnitPrice;
  PlayFab::Boxed<int> UsesIncrementedBy;
};

PlayFab::ClientModels::ItemInstance_vtbl

struct /*VFT*/ PlayFab::ClientModels::ItemInstance_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::CharacterInventory

struct __cppobj PlayFab::ClientModels::CharacterInventory : PlayFab::PlayFabBaseModel
{
  std::string CharacterId;
  std::list<PlayFab::ClientModels::ItemInstance> Inventory;
};

PlayFab::ClientModels::CharacterInventory_vtbl

struct /*VFT*/ PlayFab::ClientModels::CharacterInventory_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<unsigned int>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<unsigned int>
{
  unsigned int boxedValue;
  bool isSet;
};

PlayFab::ClientModels::StatisticUpdate

struct __cppobj __declspec(align(8)) PlayFab::ClientModels::StatisticUpdate : PlayFab::PlayFabBaseModel
{
  std::string StatisticName;
  int Value;
  PlayFab::Boxed<unsigned int> Version;
};

PlayFab::ClientModels::StatisticUpdate_vtbl

struct /*VFT*/ PlayFab::ClientModels::StatisticUpdate_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::FacebookPlayFabIdPair

struct __cppobj PlayFab::ClientModels::FacebookPlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string FacebookId;
  std::string PlayFabId;
};

PlayFab::ClientModels::FacebookPlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::FacebookPlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::VirtualCurrencyRechargeTime

struct __cppobj __declspec(align(8)) PlayFab::ClientModels::VirtualCurrencyRechargeTime : PlayFab::PlayFabBaseModel
{
  int RechargeMax;
  __int64 RechargeTime;
  int SecondsToRecharge;
};

PlayFab::ClientModels::VirtualCurrencyRechargeTime_vtbl

struct /*VFT*/ PlayFab::ClientModels::VirtualCurrencyRechargeTime_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::Region>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::Region>
{
  PlayFab::ClientModels::Region boxedValue;
  bool isSet;
};

PlayFab::ClientModels::RegionInfo

struct __cppobj PlayFab::ClientModels::RegionInfo : PlayFab::PlayFabBaseModel
{
  bool Available;
  std::string Name;
  std::string PingUrl;
  PlayFab::Boxed<enum PlayFab::ClientModels::Region> pfRegion;
};

PlayFab::ClientModels::RegionInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::RegionInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::StatisticValue

struct __cppobj PlayFab::ClientModels::StatisticValue : PlayFab::PlayFabBaseModel
{
  std::string StatisticName;
  int Value;
  unsigned int Version;
};

PlayFab::ClientModels::StatisticValue_vtbl

struct /*VFT*/ PlayFab::ClientModels::StatisticValue_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::ValueToDateModel

struct __cppobj PlayFab::ClientModels::ValueToDateModel : PlayFab::PlayFabBaseModel
{
  std::string Currency;
  unsigned int TotalValue;
  std::string TotalValueAsDecimal;
};

PlayFab::ClientModels::ValueToDateModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::ValueToDateModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::UserFacebookInfo

struct __cppobj PlayFab::ClientModels::UserFacebookInfo : PlayFab::PlayFabBaseModel
{
  std::string FacebookId;
  std::string FullName;
};

PlayFab::ClientModels::UserFacebookInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserFacebookInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::UserFacebookInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::UserFacebookInfo>
{
  PlayFab::ClientModels::UserFacebookInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::UserGameCenterInfo

struct __cppobj PlayFab::ClientModels::UserGameCenterInfo : PlayFab::PlayFabBaseModel
{
  std::string GameCenterId;
};

PlayFab::ClientModels::UserGameCenterInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserGameCenterInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::UserGameCenterInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::UserGameCenterInfo>
{
  PlayFab::ClientModels::UserGameCenterInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::AdCampaignAttributionModel

struct __cppobj PlayFab::ClientModels::AdCampaignAttributionModel : PlayFab::PlayFabBaseModel
{
  __int64 AttributedAt;
  std::string CampaignId;
  std::string Platform;
};

PlayFab::ClientModels::AdCampaignAttributionModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::AdCampaignAttributionModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::EmailVerificationStatus>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::EmailVerificationStatus>
{
  PlayFab::ClientModels::EmailVerificationStatus boxedValue;
  bool isSet;
};

PlayFab::ClientModels::ContactEmailInfoModel

struct __cppobj PlayFab::ClientModels::ContactEmailInfoModel : PlayFab::PlayFabBaseModel
{
  std::string EmailAddress;
  std::string Name;
  PlayFab::Boxed<enum PlayFab::ClientModels::EmailVerificationStatus> VerificationStatus;
};

PlayFab::ClientModels::ContactEmailInfoModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::ContactEmailInfoModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::LoginIdentityProvider>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::LoginIdentityProvider>
{
  PlayFab::ClientModels::LoginIdentityProvider boxedValue;
  bool isSet;
};

PlayFab::ClientModels::LinkedPlatformAccountModel

struct __cppobj PlayFab::ClientModels::LinkedPlatformAccountModel : PlayFab::PlayFabBaseModel
{
  std::string Email;
  PlayFab::Boxed<enum PlayFab::ClientModels::LoginIdentityProvider> Platform;
  std::string PlatformUserId;
  std::string Username;
};

PlayFab::ClientModels::LinkedPlatformAccountModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::LinkedPlatformAccountModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::ContinentCode>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::ContinentCode>
{
  PlayFab::ClientModels::ContinentCode boxedValue;
  bool isSet;
};

PlayFab::Boxed<enum PlayFab::ClientModels::CountryCode>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::CountryCode>
{
  PlayFab::ClientModels::CountryCode boxedValue;
  bool isSet;
};

PlayFab::Boxed<double>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<double>
{
  long double boxedValue;
  bool isSet;
};

PlayFab::ClientModels::LocationModel

struct __cppobj PlayFab::ClientModels::LocationModel : PlayFab::PlayFabBaseModel
{
  std::string City;
  PlayFab::Boxed<enum PlayFab::ClientModels::ContinentCode> pfContinentCode;
  PlayFab::Boxed<enum PlayFab::ClientModels::CountryCode> pfCountryCode;
  PlayFab::Boxed<double> Latitude;
  PlayFab::Boxed<double> Longitude;
};

PlayFab::ClientModels::LocationModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::LocationModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::SubscriptionProviderStatus>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::SubscriptionProviderStatus>
{
  PlayFab::ClientModels::SubscriptionProviderStatus boxedValue;
  bool isSet;
};

PlayFab::ClientModels::SubscriptionModel

struct __cppobj PlayFab::ClientModels::SubscriptionModel : PlayFab::PlayFabBaseModel
{
  __int64 Expiration;
  __int64 InitialSubscriptionTime;
  bool IsActive;
  PlayFab::Boxed<enum PlayFab::ClientModels::SubscriptionProviderStatus> Status;
  std::string SubscriptionId;
  std::string SubscriptionItemId;
  std::string SubscriptionProvider;
};

PlayFab::ClientModels::SubscriptionModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::SubscriptionModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::MembershipModel

struct __cppobj PlayFab::ClientModels::MembershipModel : PlayFab::PlayFabBaseModel
{
  bool IsActive;
  __int64 MembershipExpiration;
  std::string MembershipId;
  PlayFab::Boxed<__int64> OverrideExpiration;
  std::list<PlayFab::ClientModels::SubscriptionModel> Subscriptions;
};

PlayFab::ClientModels::MembershipModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::MembershipModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::PushNotificationPlatform>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::PushNotificationPlatform>
{
  PlayFab::ClientModels::PushNotificationPlatform boxedValue;
  bool isSet;
};

PlayFab::ClientModels::PushNotificationRegistrationModel

struct __cppobj PlayFab::ClientModels::PushNotificationRegistrationModel : PlayFab::PlayFabBaseModel
{
  std::string NotificationEndpointARN;
  PlayFab::Boxed<enum PlayFab::ClientModels::PushNotificationPlatform> Platform;
};

PlayFab::ClientModels::PushNotificationRegistrationModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::PushNotificationRegistrationModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::StatisticModel

struct __cppobj PlayFab::ClientModels::StatisticModel : PlayFab::PlayFabBaseModel
{
  std::string Name;
  int Value;
  int Version;
};

PlayFab::ClientModels::StatisticModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::StatisticModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::PlayerProfileModel

struct __cppobj PlayFab::ClientModels::PlayerProfileModel : PlayFab::PlayFabBaseModel
{
  std::list<PlayFab::ClientModels::AdCampaignAttributionModel> AdCampaignAttributions;
  std::string AvatarUrl;
  PlayFab::Boxed<__int64> BannedUntil;
  std::list<PlayFab::ClientModels::ContactEmailInfoModel> ContactEmailAddresses;
  PlayFab::Boxed<__int64> Created;
  std::string DisplayName;
  PlayFab::Boxed<__int64> LastLogin;
  std::list<PlayFab::ClientModels::LinkedPlatformAccountModel> LinkedAccounts;
  std::list<PlayFab::ClientModels::LocationModel> Locations;
  std::list<PlayFab::ClientModels::MembershipModel> Memberships;
  PlayFab::Boxed<enum PlayFab::ClientModels::LoginIdentityProvider> Origination;
  std::string PlayerId;
  std::string PublisherId;
  std::list<PlayFab::ClientModels::PushNotificationRegistrationModel> PushNotificationRegistrations;
  std::list<PlayFab::ClientModels::StatisticModel> Statistics;
  std::list<PlayFab::ClientModels::TagModel> Tags;
  std::string TitleId;
  PlayFab::Boxed<unsigned int> TotalValueToDateInUSD;
  std::list<PlayFab::ClientModels::ValueToDateModel> ValuesToDate;
};

PlayFab::ClientModels::PlayerProfileModel_vtbl

struct /*VFT*/ PlayFab::ClientModels::PlayerProfileModel_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::PlayerProfileModel>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::PlayerProfileModel>
{
  PlayFab::ClientModels::PlayerProfileModel boxedValue;
  bool isSet;
};

PlayFab::ClientModels::UserPsnInfo

struct __cppobj PlayFab::ClientModels::UserPsnInfo : PlayFab::PlayFabBaseModel
{
  std::string PsnAccountId;
  std::string PsnOnlineId;
};

PlayFab::ClientModels::UserPsnInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserPsnInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::UserPsnInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::UserPsnInfo>
{
  PlayFab::ClientModels::UserPsnInfo boxedValue;
  bool isSet;
};

PlayFab::Boxed<enum PlayFab::ClientModels::TitleActivationStatus>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::TitleActivationStatus>
{
  PlayFab::ClientModels::TitleActivationStatus boxedValue;
  bool isSet;
};

PlayFab::Boxed<enum PlayFab::ClientModels::Currency>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::Currency>
{
  PlayFab::ClientModels::Currency boxedValue;
  bool isSet;
};

PlayFab::ClientModels::UserSteamInfo

struct __cppobj PlayFab::ClientModels::UserSteamInfo : PlayFab::PlayFabBaseModel
{
  PlayFab::Boxed<enum PlayFab::ClientModels::TitleActivationStatus> SteamActivationStatus;
  std::string SteamCountry;
  PlayFab::Boxed<enum PlayFab::ClientModels::Currency> SteamCurrency;
  std::string SteamId;
};

PlayFab::ClientModels::UserSteamInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserSteamInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::UserSteamInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::UserSteamInfo>
{
  PlayFab::ClientModels::UserSteamInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::UserXboxInfo

struct __cppobj PlayFab::ClientModels::UserXboxInfo : PlayFab::PlayFabBaseModel
{
  std::string XboxUserId;
};

PlayFab::ClientModels::UserXboxInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserXboxInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::UserXboxInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::UserXboxInfo>
{
  PlayFab::ClientModels::UserXboxInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::FriendInfo

struct __cppobj PlayFab::ClientModels::FriendInfo : PlayFab::PlayFabBaseModel
{
  std::string CurrentMatchmakerLobbyId;
  PlayFab::Boxed<PlayFab::ClientModels::UserFacebookInfo> FacebookInfo;
  std::string FriendPlayFabId;
  PlayFab::Boxed<PlayFab::ClientModels::UserGameCenterInfo> GameCenterInfo;
  PlayFab::Boxed<PlayFab::ClientModels::PlayerProfileModel> Profile;
  PlayFab::Boxed<PlayFab::ClientModels::UserPsnInfo> PSNInfo;
  PlayFab::Boxed<PlayFab::ClientModels::UserSteamInfo> SteamInfo;
  std::list<std::string> Tags;
  std::string TitleDisplayName;
  std::string Username;
  PlayFab::Boxed<PlayFab::ClientModels::UserXboxInfo> XboxInfo;
};

PlayFab::ClientModels::FriendInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::FriendInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::TitleNewsItem

struct __cppobj PlayFab::ClientModels::TitleNewsItem : PlayFab::PlayFabBaseModel
{
  std::string Body;
  std::string NewsId;
  __int64 Timestamp;
  std::string Title;
};

PlayFab::ClientModels::TitleNewsItem_vtbl

struct /*VFT*/ PlayFab::ClientModels::TitleNewsItem_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::StatisticNameVersion

struct __cppobj __declspec(align(8)) PlayFab::ClientModels::StatisticNameVersion : PlayFab::PlayFabBaseModel
{
  std::string StatisticName;
  unsigned int Version;
};

PlayFab::ClientModels::StatisticNameVersion_vtbl

struct /*VFT*/ PlayFab::ClientModels::StatisticNameVersion_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::CharacterLeaderboardEntry

struct __cppobj PlayFab::ClientModels::CharacterLeaderboardEntry : PlayFab::PlayFabBaseModel
{
  std::string CharacterId;
  std::string CharacterName;
  std::string CharacterType;
  std::string DisplayName;
  std::string PlayFabId;
  int Position;
  int StatValue;
};

PlayFab::ClientModels::CharacterLeaderboardEntry_vtbl

struct /*VFT*/ PlayFab::ClientModels::CharacterLeaderboardEntry_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GetSegmentResult

struct __cppobj PlayFab::ClientModels::GetSegmentResult : PlayFab::PlayFabResultCommon
{
  std::string ABTestParent;
  std::string Id;
  std::string Name;
};

PlayFab::ClientModels::GetSegmentResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::GetSegmentResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::UserDataRecord

struct __cppobj PlayFab::ClientModels::UserDataRecord : PlayFab::PlayFabBaseModel
{
  __int64 LastUpdated;
  PlayFab::Boxed<enum PlayFab::ClientModels::UserDataPermission> Permission;
  std::string Value;
};

PlayFab::ClientModels::UserDataRecord_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserDataRecord_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::XboxLiveAccountPlayFabIdPair

struct __cppobj PlayFab::ClientModels::XboxLiveAccountPlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string PlayFabId;
  std::string XboxLiveAccountId;
};

PlayFab::ClientModels::XboxLiveAccountPlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::XboxLiveAccountPlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::LogStatement

struct __cppobj PlayFab::ClientModels::LogStatement : PlayFab::PlayFabBaseModel
{
  Json::Value Data;
  std::string Level;
  std::string Message;
};

PlayFab::ClientModels::LogStatement_vtbl

struct /*VFT*/ PlayFab::ClientModels::LogStatement_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::ItemPurchaseRequest

struct __cppobj PlayFab::ClientModels::ItemPurchaseRequest : PlayFab::PlayFabRequestCommon
{
  std::string Annotation;
  std::string ItemId;
  unsigned int Quantity;
  std::list<std::string> UpgradeFromItems;
};

PlayFab::ClientModels::ItemPurchaseRequest_vtbl

struct /*VFT*/ PlayFab::ClientModels::ItemPurchaseRequest_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::CharacterResult

struct __cppobj PlayFab::ClientModels::CharacterResult : PlayFab::PlayFabResultCommon
{
  std::string CharacterId;
  std::string CharacterName;
  std::string CharacterType;
};

PlayFab::ClientModels::CharacterResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::CharacterResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::StoreItem

struct __cppobj PlayFab::ClientModels::StoreItem : PlayFab::PlayFabBaseModel
{
  Json::Value CustomData;
  PlayFab::Boxed<unsigned int> DisplayPosition;
  std::string ItemId;
  std::map<std::string,unsigned int> RealCurrencyPrices;
  std::map<std::string,unsigned int> VirtualCurrencyPrices;
};

PlayFab::ClientModels::StoreItem_vtbl

struct /*VFT*/ PlayFab::ClientModels::StoreItem_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GenericServiceId

struct __cppobj PlayFab::ClientModels::GenericServiceId : PlayFab::PlayFabBaseModel
{
  std::string ServiceName;
  std::string UserId;
};

PlayFab::ClientModels::GenericServiceId_vtbl

struct /*VFT*/ PlayFab::ClientModels::GenericServiceId_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::PSNAccountPlayFabIdPair

struct __cppobj PlayFab::ClientModels::PSNAccountPlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string PlayFabId;
  std::string PSNAccountId;
};

PlayFab::ClientModels::PSNAccountPlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::PSNAccountPlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::KongregatePlayFabIdPair

struct __cppobj PlayFab::ClientModels::KongregatePlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string KongregateId;
  std::string PlayFabId;
};

PlayFab::ClientModels::KongregatePlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::KongregatePlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::FacebookInstantGamesPlayFabIdPair

struct __cppobj PlayFab::ClientModels::FacebookInstantGamesPlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string FacebookInstantGamesId;
  std::string PlayFabId;
};

PlayFab::ClientModels::FacebookInstantGamesPlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::FacebookInstantGamesPlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GetPlayFabIDsFromPSNAccountIDsResult

const struct __cppobj PlayFab::ClientModels::GetPlayFabIDsFromPSNAccountIDsResult : PlayFab::PlayFabResultCommon
{
  std::list<PlayFab::ClientModels::PSNAccountPlayFabIdPair> Data;
};

PlayFab::ClientModels::GetPlayFabIDsFromPSNAccountIDsResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::GetPlayFabIDsFromPSNAccountIDsResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::UserOpenIdInfo

struct __cppobj PlayFab::ClientModels::UserOpenIdInfo : PlayFab::PlayFabBaseModel
{
  std::string ConnectionId;
  std::string Issuer;
  std::string Subject;
};

PlayFab::ClientModels::UserOpenIdInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::UserOpenIdInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::GameInstanceState>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::GameInstanceState>
{
  PlayFab::ClientModels::GameInstanceState boxedValue;
  bool isSet;
};

PlayFab::ClientModels::GameInfo

struct __cppobj PlayFab::ClientModels::GameInfo : PlayFab::PlayFabBaseModel
{
  std::string BuildVersion;
  std::string GameMode;
  std::string GameServerData;
  PlayFab::Boxed<enum PlayFab::ClientModels::GameInstanceState> GameServerStateEnum;
  PlayFab::Boxed<__int64> LastHeartbeat;
  std::string LobbyID;
  PlayFab::Boxed<int> MaxPlayers;
  std::list<std::string> PlayerUserIds;
  PlayFab::Boxed<enum PlayFab::ClientModels::Region> pfRegion;
  unsigned int RunTime;
  std::string ServerIPV4Address;
  std::string ServerIPV6Address;
  PlayFab::Boxed<int> ServerPort;
  std::string ServerPublicDNSName;
  std::string StatisticName;
  std::map<std::string,std::string> Tags;
};

PlayFab::ClientModels::GameInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::GameInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::UnlinkTwitchAccountResult

const struct __cppobj PlayFab::ClientModels::UnlinkTwitchAccountResult : PlayFab::PlayFabResultCommon
{
};

PlayFab::ClientModels::UnlinkTwitchAccountResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::UnlinkTwitchAccountResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::CatalogItemBundleInfo

struct __cppobj PlayFab::ClientModels::CatalogItemBundleInfo : PlayFab::PlayFabBaseModel
{
  std::list<std::string> BundledItems;
  std::list<std::string> BundledResultTables;
  std::map<std::string,unsigned int> BundledVirtualCurrencies;
};

PlayFab::ClientModels::CatalogItemBundleInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::CatalogItemBundleInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::CatalogItemBundleInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::CatalogItemBundleInfo>
{
  PlayFab::ClientModels::CatalogItemBundleInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::CatalogItemConsumableInfo

struct __cppobj PlayFab::ClientModels::CatalogItemConsumableInfo : PlayFab::PlayFabBaseModel
{
  PlayFab::Boxed<unsigned int> UsageCount;
  PlayFab::Boxed<unsigned int> UsagePeriod;
  std::string UsagePeriodGroup;
};

PlayFab::ClientModels::CatalogItemConsumableInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::CatalogItemConsumableInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::CatalogItemConsumableInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::CatalogItemConsumableInfo>
{
  PlayFab::ClientModels::CatalogItemConsumableInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::CatalogItemContainerInfo

struct __cppobj PlayFab::ClientModels::CatalogItemContainerInfo : PlayFab::PlayFabBaseModel
{
  std::list<std::string> ItemContents;
  std::string KeyItemId;
  std::list<std::string> ResultTableContents;
  std::map<std::string,unsigned int> VirtualCurrencyContents;
};

PlayFab::ClientModels::CatalogItemContainerInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::CatalogItemContainerInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<PlayFab::ClientModels::CatalogItemContainerInfo>

struct __cppobj __declspec(align(8)) PlayFab::Boxed<PlayFab::ClientModels::CatalogItemContainerInfo>
{
  PlayFab::ClientModels::CatalogItemContainerInfo boxedValue;
  bool isSet;
};

PlayFab::ClientModels::CatalogItem

struct __cppobj PlayFab::ClientModels::CatalogItem : PlayFab::PlayFabBaseModel
{
  PlayFab::Boxed<PlayFab::ClientModels::CatalogItemBundleInfo> Bundle;
  bool CanBecomeCharacter;
  std::string CatalogVersion;
  PlayFab::Boxed<PlayFab::ClientModels::CatalogItemConsumableInfo> Consumable;
  PlayFab::Boxed<PlayFab::ClientModels::CatalogItemContainerInfo> Container;
  std::string CustomData;
  std::string Description;
  std::string DisplayName;
  int InitialLimitedEditionCount;
  bool IsLimitedEdition;
  bool IsStackable;
  bool IsTradable;
  std::string ItemClass;
  std::string ItemId;
  std::string ItemImageUrl;
  std::map<std::string,unsigned int> RealCurrencyPrices;
  std::list<std::string> Tags;
  std::map<std::string,unsigned int> VirtualCurrencyPrices;
};

PlayFab::ClientModels::CatalogItem_vtbl

struct /*VFT*/ PlayFab::ClientModels::CatalogItem_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::LinkSteamAccountResult

const struct __cppobj PlayFab::ClientModels::LinkSteamAccountResult : PlayFab::PlayFabResultCommon
{
};

PlayFab::ClientModels::LinkSteamAccountResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::LinkSteamAccountResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::TwitchPlayFabIdPair

struct __cppobj PlayFab::ClientModels::TwitchPlayFabIdPair : PlayFab::PlayFabBaseModel
{
  std::string PlayFabId;
  std::string TwitchId;
};

PlayFab::ClientModels::TwitchPlayFabIdPair_vtbl

struct /*VFT*/ PlayFab::ClientModels::TwitchPlayFabIdPair_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GetPlayFabIDsFromTwitchIDsResult

const struct __cppobj PlayFab::ClientModels::GetPlayFabIDsFromTwitchIDsResult : PlayFab::PlayFabResultCommon
{
  std::list<PlayFab::ClientModels::TwitchPlayFabIdPair> Data;
};

PlayFab::ClientModels::GetPlayFabIDsFromTwitchIDsResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::GetPlayFabIDsFromTwitchIDsResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::StartGameResult

const struct __cppobj PlayFab::ClientModels::StartGameResult : PlayFab::PlayFabResultCommon
{
  std::string Expires;
  std::string LobbyID;
  std::string Password;
  std::string ServerIPV4Address;
  std::string ServerIPV6Address;
  PlayFab::Boxed<int> ServerPort;
  std::string ServerPublicDNSName;
  std::string Ticket;
};

PlayFab::ClientModels::StartGameResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::StartGameResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GetPlayFabIDsFromFacebookInstantGamesIdsResult

struct __cppobj PlayFab::ClientModels::GetPlayFabIDsFromFacebookInstantGamesIdsResult : PlayFab::PlayFabResultCommon
{
  std::list<PlayFab::ClientModels::FacebookInstantGamesPlayFabIdPair> Data;
};

PlayFab::ClientModels::GetPlayFabIDsFromFacebookInstantGamesIdsResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::GetPlayFabIDsFromFacebookInstantGamesIdsResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::RemoveFriendResult

const struct __cppobj PlayFab::ClientModels::RemoveFriendResult : PlayFab::PlayFabResultCommon
{
};

PlayFab::ClientModels::RemoveFriendResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::RemoveFriendResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::UpdateCharacterDataResult

const struct __cppobj __declspec(align(8)) PlayFab::ClientModels::UpdateCharacterDataResult : PlayFab::PlayFabResultCommon
{
  unsigned int DataVersion;
};

PlayFab::ClientModels::UpdateCharacterDataResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::UpdateCharacterDataResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::LinkKongregateAccountResult

const struct __cppobj PlayFab::ClientModels::LinkKongregateAccountResult : PlayFab::PlayFabResultCommon
{
};

PlayFab::ClientModels::LinkKongregateAccountResult_vtbl

struct /*VFT*/ PlayFab::ClientModels::LinkKongregateAccountResult_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::Boxed<enum PlayFab::ClientModels::TradeStatus>

struct __cppobj __declspec(align(4)) PlayFab::Boxed<enum PlayFab::ClientModels::TradeStatus>
{
  PlayFab::ClientModels::TradeStatus boxedValue;
  bool isSet;
};

PlayFab::ClientModels::TradeInfo

struct __cppobj PlayFab::ClientModels::TradeInfo : PlayFab::PlayFabBaseModel
{
  std::list<std::string> AcceptedInventoryInstanceIds;
  std::string AcceptedPlayerId;
  std::list<std::string> AllowedPlayerIds;
  PlayFab::Boxed<__int64> CancelledAt;
  PlayFab::Boxed<__int64> FilledAt;
  PlayFab::Boxed<__int64> InvalidatedAt;
  std::list<std::string> OfferedCatalogItemIds;
  std::list<std::string> OfferedInventoryInstanceIds;
  std::string OfferingPlayerId;
  PlayFab::Boxed<__int64> OpenedAt;
  std::list<std::string> RequestedCatalogItemIds;
  PlayFab::Boxed<enum PlayFab::ClientModels::TradeStatus> Status;
  std::string TradeId;
};

PlayFab::ClientModels::TradeInfo_vtbl

struct /*VFT*/ PlayFab::ClientModels::TradeInfo_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};

PlayFab::ClientModels::GetPlayerTradesResponse

const struct __cppobj PlayFab::ClientModels::GetPlayerTradesResponse : PlayFab::PlayFabResultCommon
{
  std::list<PlayFab::ClientModels::TradeInfo> AcceptedTrades;
  std::list<PlayFab::ClientModels::TradeInfo> OpenedTrades;
};

PlayFab::ClientModels::GetPlayerTradesResponse_vtbl

struct /*VFT*/ PlayFab::ClientModels::GetPlayerTradesResponse_vtbl
{
  void (__fastcall *~PlayFabBaseModel)(PlayFab::PlayFabBaseModel *this);
  void (__fastcall *FromJson)(PlayFab::PlayFabBaseModel *this, Json::Value *);
  Json::Value *(__fastcall *ToJson)(PlayFab::PlayFabBaseModel *this, Json::Value *result);
};