/* 285 */
struct _G_fpos_t;

/* 242 */
struct _IO_FILE
{
int _flags;
char *_IO_read_ptr;
char *_IO_read_end;
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
_IO_marker *_markers;
_IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned __int16 _cur_column;
char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[20];
};

/* 753 */
struct _ProfilerLiteTimer
{
__int8 gap0[1];
};

/* 122541 */
struct _TickPtr
{
int (**_vptr$_TickPtr)(void);
};

/* 6881 */
struct __atomic_flag_base
{
std::__atomic_flag_data_type _M_i;
};

/* 478099 */
struct __attribute__((aligned(2))) DatagramHeaderFormat
{
DatagramSequenceNumberType datagramNumber;
float AS;
bool isACK;
bool isNAK;
bool isPacketPair;
bool hasBAndAS;
bool isContinuousSend;
bool needsBAndAs;
bool isValid;
};

/* 5807 */
struct __attribute__((aligned(2))) LevelData
{
AdventureSettings mAdventureSettings;
WorldTemplateLevelData mWorldTemplateLevelData;
GameRules mGameRules;
Abilities mDefaultAbilities;
std::string mLevelName;
StorageVersion mStorageVersion;
GameVersion mMinCompatibleClientVersion;
int mNetworkVersion;
SemVersion mInventoryVersion;
Tick mCurrentTick;
RandomSeed mSeed;
BlockPos mSpawnPos;
bool mHasSpawnPos;
BlockPos mLimitedWorldOrigin;
int mTime;
time_t mLastPlayed;
CompoundTag mLoadedPlayerTag;
uint32_t mServerTickRange;
float mRainLevel;
int mRainTime;
float mLightningLevel;
int mLightningTime;
int mNetherScale;
GameVersion mLastOpenedWithVersion;
GameType mGameType;
Difficulty mGameDifficulty;
bool mForceGameType;
bool mSpawnMobs;
GeneratorType mGenerator;
Json::Value mFlatworldGeneratorOptions;
uint32_t mWorldStartCount;
bool mAchievementsDisabled;
EducationEditionOffer mEducationEditionOffer;
bool mEducationFeaturesEnabled;
bool mConfirmedPlatformLockedContent;
bool mMultiplayerGameIntent;
bool mMultiplayerGame;
bool mLANBroadcastIntent;
bool mLANBroadcast;
Social::GamePublishSetting mXBLBroadcastIntent;
Social::GamePublishSetting mXBLBroadcastMode;
Social::GamePublishSetting mPlatformBroadcastIntent;
Social::GamePublishSetting mPlatformBroadcastMode;
bool mCommandsEnabled;
bool mTexturePacksRequired;
bool mHasLockedBehaviorPack;
bool mHasLockedResourcePack;
bool mIsFromLockedTemplate;
std::string mEducationOid;
std::string mEducationProductId;
bool mUseMsaGamertagsOnly;
bool mBonusChestEnabled;
bool mBonusChestSpawned;
bool mStartWithMapEnabled;
bool mMapsCenteredToOrigin;
bool mRequiresCopiedPackRemovalCheck;
bool mSpawnV1Villagers;
};

/* 81169 */
struct __attribute__((aligned(2))) LevelData_0
{
AdventureSettings mAdventureSettings;
WorldTemplateLevelData mWorldTemplateLevelData;
GameRules mGameRules;
Abilities mDefaultAbilities;
std::string mLevelName;
StorageVersion mStorageVersion;
GameVersion mMinCompatibleClientVersion;
int mNetworkVersion;
SemVersion mInventoryVersion;
Tick mCurrentTick;
RandomSeed_0 mSeed;
BlockPos mSpawnPos;
bool mHasSpawnPos;
BlockPos mLimitedWorldOrigin;
int mTime;
time_t mLastPlayed;
CompoundTag mLoadedPlayerTag;
uint32_t mServerTickRange;
float mRainLevel;
int mRainTime;
float mLightningLevel;
int mLightningTime;
int mNetherScale;
GameVersion mLastOpenedWithVersion;
GameType mGameType;
Difficulty mGameDifficulty;
bool mForceGameType;
bool mSpawnMobs;
GeneratorType mGenerator;
Json::Value mFlatworldGeneratorOptions;
uint32_t mWorldStartCount;
bool mAchievementsDisabled;
EducationEditionOffer mEducationEditionOffer;
bool mEducationFeaturesEnabled;
bool mConfirmedPlatformLockedContent;
bool mMultiplayerGameIntent;
bool mMultiplayerGame;
bool mLANBroadcastIntent;
bool mLANBroadcast;
Social::GamePublishSetting mXBLBroadcastIntent;
Social::GamePublishSetting mXBLBroadcastMode;
Social::GamePublishSetting mPlatformBroadcastIntent;
Social::GamePublishSetting mPlatformBroadcastMode;
bool mCommandsEnabled;
bool mTexturePacksRequired;
bool mHasLockedBehaviorPack;
bool mHasLockedResourcePack;
bool mIsFromLockedTemplate;
std::string mEducationOid;
std::string mEducationProductId;
bool mUseMsaGamertagsOnly;
bool mBonusChestEnabled;
bool mBonusChestSpawned;
bool mStartWithMapEnabled;
bool mMapsCenteredToOrigin;
bool mRequiresCopiedPackRemovalCheck;
bool mSpawnV1Villagers;
};

/* 187294 */
struct __attribute__((aligned(2))) PendingArea
{
mce::UUID mUID;
std::string mName;
ActorUniqueID mEntityId;
Bounds mBounds;
float mMaxDistToPlayers;
bool mIsCircle;
bool mAlwaysActive;
bool mCreated;
};

/* 190406 */
struct __attribute__((aligned(2))) PortalRecord
{
BlockPos mBaseBlockPos;
char mSpan;
char mXInc;
char mZInc;
};

/* 486267 */
struct __attribute__((aligned(4))) $10AD719A749B48FD0C0A3351B1A2B499
{
uint32_t length;
uint16_t buffer[1];
};

/* 13333 */
struct __attribute__((aligned(4))) AABB
{
Vec3 min;
Vec3 max;
bool empty;
};

/* 3302 */
struct __attribute__((aligned(4))) Ability
{
Ability::Type mType;
Ability::Value mValue;
Ability::Options mOptions;
};

/* 89285 */
struct __attribute__((aligned(4))) ActionEvent
{
int mActionId;
ActionEvent::ActionState mActionState;
bool mIsExclusive;
FocusImpact mFocusImpact;
};

/* 77954 */
struct __attribute__((aligned(4))) AvailableCommandsPacket::ParamData
{
std::string name;
uint32_t parseSymbol;
bool optional;
uint8_t paramOptions;
};

/* 50192 */
struct __attribute__((aligned(4))) BalloonComponent
{
ActorUniqueID mAttachedID;
float mMaxHeight;
bool mShouldDropAttached;
};

/* 45358 */
struct __attribute__((aligned(4))) BaseCommandBlock
{
std::string mLastOutputId;
std::vector<std::string> mLastOutputParams;
std::string mCommand;
std::string mName;
std::unique_ptr<Command> mCompiledCommand;
uint64_t mLastExecution;
int mVersion;
int mSuccessCount;
int mTickDelay;
bool mExecuteOnFirstTick;
bool mTrackOutput;
};

/* 88389 */
struct __attribute__((aligned(4))) BiomeComponentFactory
{
JsonUtil::JsonSchemaRoot<BiomeComponentLoading::BiomeParseContext> mSchema;
std::vector<std::function<void (CompoundTag &,EntityContext &,IWorldRegistriesProvider &)>> mExtraSerialization;
BiomeComponentFactory::FactoryScope mScope;
bool mClosedForRegistration;
};

/* 13204 */
struct __attribute__((aligned(4))) Block
{
int (**_vptr$Block)(void);
const DataID mData;
WeakPtr<BlockLegacy> mLegacyBlock;
BlockSerializationId mSerializationId;
BlockRuntimeId mRuntimeId;
bool mHasRuntimeId;
};

/* 294441 */
struct __attribute__((aligned(4))) BlockGeometry::Face
{
float u0;
float v0;
float u1;
float v1;
int rotation;
std::string texture;
int textureIndex;
bool enabled;
};

/* 42311 */
struct __attribute__((aligned(4))) BlockPosIterator
{
const BlockPos mMinCorner;
const BlockPos mMaxCorner;
BlockPos mCurrentPos;
bool mDone;
};

/* 1486 */
struct __attribute__((aligned(4))) Command
{
int (**_vptr$Command)(void);
int mVersion;
const CommandRegistry *mRegistry;
int mCommandSymbol;
CommandPermissionLevel mPermissionLevel;
CommandFlag mFlags;
};

/* 52184 */
struct __attribute__((aligned(4))) CommandBlockComponent
{
BaseCommandBlock mBaseCommandBlock;
int mCurrentTickCount;
bool mTicking;
};

/* 90964 */
struct __attribute__((aligned(4))) CommandIntegerRange
{
int mMinValue;
int mMaxValue;
bool mInvert;
};

/* 5677 */
struct __attribute__((aligned(4))) CommandRegistry::Parser
{
const CommandRegistry *mRegistry;
const CommandRegistry::ParseTable *mParseTable;
std::deque<std::pair<CommandRegistry::Symbol,CommandRegistry::ParseToken *>> mStack;
CommandRegistry::LexicalToken mNext;
std::string mInput;
std::unique_ptr<CommandRegistry::ParseToken> mRoot;
std::string mError;
std::vector<std::string> mErrorParams;
int mVersion;
bool mGenerateParams;
bool mBreakAtEnd;
};

/* 1462 */
struct __attribute__((aligned(4))) CommandRegistry::Signature
{
std::string name;
std::string description;
std::vector<CommandRegistry::Overload> overloads;
CommandPermissionLevel permissionLevel;
CommandRegistry::Symbol commandSymbol;
CommandRegistry::Symbol commandAliasEnum;
CommandFlag flags;
int firstRule;
int firstFactorization;
int firstOptional;
bool runnable;
};

/* 5683 */
struct __attribute__((aligned(4))) CommandSelectorBase
{
int mVersion;
CommandSelectionType mType;
CommandSelectionOrder mOrder;
std::vector<InvertableFilter<std::string >> mNameFilters;
std::vector<InvertableFilter<ActorDefinitionIdentifier>> mTypeFilters;
std::vector<InvertableFilter<std::string >> mTagFilters;
std::vector<std::function<bool (const CommandOrigin &,const Actor &)>> mFilterChain;
CommandPosition mPosition;
BlockPos mBoxDeltas;
float mRadiusMin;
float mRadiusMax;
size_t mCount;
bool mIncludeDeadPlayers;
bool mIsPositionBound;
bool mDistanceFiltered;
bool mHaveDeltas;
bool mForcePlayer;
bool mIsExplicitIdSelector;
};

/* 47291 */
struct __attribute__((aligned(4))) DataItem
{
int (**_vptr$DataItem)(void);
const DataItemType mType;
const DataItem::ID mId;
bool mDirty;
};

/* 5 */
struct __attribute__((aligned(4))) Elf64_Vernaux
{
unsigned __int32 vna_hash;
unsigned __int16 vna_flags;
unsigned __int16 vna_other;
unsigned __int32 vna_name;
unsigned __int32 vna_next;
};

/* 4 */
struct __attribute__((aligned(4))) Elf64_Verneed
{
unsigned __int16 vn_version;
unsigned __int16 vn_cnt;
unsigned __int32 vn_file;
unsigned __int32 vn_aux;
unsigned __int32 vn_next;
};

/* 13329 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$30DBAAB0C52B2A0F9E419B4088A015FC
{
int mCurrentWave;
int mTotalWaves;
bool mSuccess;
};

/* 13314 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$3EA7AF8D67CA2C237D54EACA0411C0BB
{
int mInteractedEntityType;
MinecraftEventing::InteractionType mInteractionType;
int mInteractedEntityVariant;
unsigned __int8 mInteractedEntityColor;
};

/* 13319 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$8DB381A6CBFA50BDCCF821038DD76269
{
__int16 mContentsType;
uint32_t mContentsColor;
__int16 mFillLevel;
};

/* 13325 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$E47DE5B305D15144F0589DE3337858CF
{
int32_t mPattern;
int32_t mPreset;
int32_t mType;
bool mRelease;
};

/* 13326 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$FEA48FE64DE27FADBA89F8BAEC4B7A9C
{
int mBabyType;
int mBabyVariant;
unsigned __int8 mBabyColor;
};

/* 13320 */
struct __attribute__((aligned(4))) EventPacket::Data::$A9B56BB2A8A14AFA32257D71180A3DDB::$FF0AE4D4703BAEB84232F79BCFC2EBCD
{
int32_t mKillerId;
int mKillerVariant;
int32_t mDamageSource;
bool mInRaid;
};

/* 55336 */
struct __attribute__((aligned(4))) ExplodeComponent
{
int mFuseLength;
int mInitialFuseLength;
float mExplosionPower;
float mMaxResistance;
bool mIsFuseLit;
bool mCausesFire;
bool mBreaksBlocks;
bool mFireAffectedByGriefing;
bool mDestroyAffectedByGriefing;
bool mAllowUnderwater;
};

/* 55428 */
struct __attribute__((aligned(4))) ExplodeDefinition
{
FloatRange mFuseLength;
float mExplosionPower;
float mMaxResistance;
bool mIsFuseLit;
bool mCausesFire;
bool mBreaksBlocks;
bool mFireAffectedByGriefing;
bool mDestroyAffectedByGriefing;
};

/* 13213 */
struct __attribute__((aligned(4))) HitResult
{
Vec3 mStartPos;
Vec3 mRayDir;
HitResultType mType;
FacingID mFacing;
BlockPos mBlock;
Vec3 mPos;
Actor *mEntity;
bool mIsHitLiquid;
FacingID mLiquidFacing;
BlockPos mLiquid;
Vec3 mLiquidPos;
bool mIndirectHit;
};

/* 33230 */
struct __attribute__((aligned(4))) InventoryTransactionItemGroup
{
int mItemId;
int mItemAux;
Unique<CompoundTag> mTag;
int32_t mCount;
bool mOverflow;
};

/* 174686 */
struct __attribute__((aligned(4))) ItemTransferAmount
{
const ItemTransferAmount::ItemTransferAmountTag mTag;
ItemTransferAmount::$8A9EA68892D5133F1EC35B6C915D03B5 mData;
const bool mFromMax;
};

/* 34999 */
struct __attribute__((aligned(4))) LevelChunk
{
Level *mLevel;
Dimension *mDimension;
BlockPos mMin;
BlockPos mMax;
ChunkPos mPosition;
bool mLightingFixupDone;
std::atomic<bool> mLightingTaskActive;
bool mReadOnly;
ChunkSource *mGenerator;
LevelChunkFormat mLoadedFormat;
std::string mSerializedEntitiesBuffer;
std::atomic<ChunkState> mLoadState;
ChunkTerrainDataState mTerrainDataState;
ChunkDebugDisplaySavedState mDebugDisplaySavedState;
ChunkCachedDataState mCachedDataState;
SpinLock mCachedDataStateSpinLock;
Tick mLastTick;
std::unique_ptr<BlockTickingQueue> mTickQueue;
std::unique_ptr<BlockTickingQueue> mRandomTickQueue;
AppendOnlyAtomicLookupTable<SubChunk,16> mSubChunks;
std::array<SpinLock,16> mSubChunkSpinLocks;
std::array<BiomeChunkData,256> mBiomes;
std::array<ColumnCachedData,256> mCachedData;
std::array<short,256> mHeightmap;
std::unique_ptr<std::vector<short>> mPreWorldGenHeightmap;
std::unordered_map<unsigned char,BiomeChunkState> mBiomeStates;
bool mHasCachedTemperatureNoise;
std::array<unsigned char,256> mBorderBlockMap;
LevelChunk::Finalization mFinalized;
bool mIsRedstoneLoaded;
bool mOwnedByTickingThread;
DirtyTicksCounter mFullChunkDirtyTicksCounters[6];
std::array<short,256> mRainHeights;
OwnedActorSet mEntities;
LevelChunk::OwnedBlockActorMap mBlockEntities;
LevelChunk::BlockActorVector mDeletedBlockEntities;
BrightnessPair mDefaultBrightness;
std::vector<LevelChunk::HardcodedSpawningArea> mHardcodedSpawningAreas;
uint8_t mbChunkInterpolants[2][2];
bool mbChunkHasConverterTag;
bool mDBChunkSurroundedByNeighbors;
};

/* 34078 */
struct __attribute__((aligned(4))) LevelChunk::HardcodedSpawningArea
{
BoundingBox aabb;
HardcodedSpawnAreaType type;
};

/* 36573 */
struct __attribute__((aligned(4))) MobSpawnRules
{
int mMinBrightness;
int mMaxBrightness;
float mMinMoonBrightness;
float mMaxMoonBrightness;
bool mAdjustForWeather;
int mMinHeight;
int mMaxHeight;
int mRarity;
int mSurfaceCap;
int mUndergroundCap;
Difficulty mMinDifficulty;
Difficulty mMaxDifficulty;
int mSpawnDistanceCap;
int mMinSpawnDistance;
int mMaxSpawnDistance;
bool mSurfaceSpawner;
bool mUndergroundSpawner;
bool mWaterSpawner;
bool mLavaSpawner;
unsigned int mPlayerInVillageDistance;
unsigned int mPlayerInVillageBorderTolerance;
bool mExperimentalSpawner;
uint64_t mMinWorldAge;
uint64_t mMaxWorldAge;
int mMinDelay;
int mMaxDelay;
HerdList mHerdList;
MobPermutationList mPermutationList;
std::string mMobEventName;
std::unordered_set<const BlockLegacy *> mSpawnOnBlockList;
MobGuaranteedPermutationList mGuaranteedList;
std::string mMobToDelayId;
int mDelaySpawnChance;
bool mPersistence;
};

/* 122841 */
struct __attribute__((aligned(4))) MoveToVillageGoal:992
{
__int8 baseclass_0[116];
int mVillageSearchRangeBlocks;
bool mReachedVillage;
};

/* 88761 */
struct __attribute__((aligned(4))) MovementInterpolator
{
Vec3 mPos;
Vec2 mRot;
float mHeadYaw;
int mPositionSteps;
int mRotationSteps;
int mHeadYawSteps;
bool mInterpolationActive;
};

/* 5708 */
struct __attribute__((aligned(4))) PackManifest
{
int (**_vptr$PackManifest)(void);
ResourceLocation mLocation;
PackIdVersion mIdentity;
ContentIdentity mContentIdentity;
SemVersion mMinEngineVersion;
BaseGameVersion mRequiredBaseGameVersion;
std::unordered_set<std::string> mCapabilities;
std::unordered_set<std::string> mTrustedCapabilities;
std::string mName;
std::string mDescription;
bool mExpired;
ResourceLocation mPackIconLocation;
std::vector<ResourceInformation> mModules;
std::vector<PackIdVersion> mPackDependencies;
std::vector<LegacyPackIdVersion> mLegacyModuleDependencies;
Json::Value mSettings;
ResourceMetadata mMetadata;
PackType mPackType;
PackCategory mPackCategory;
PackOrigin mPackOrigin;
ManifestOrigin mManifestOrigin;
ManifestType mManifestType;
bool mIsHidden;
uint64_t mSize;
std::string mLastModifiedDate;
bool mHasValidUUID;
bool mHasPlugins;
bool mHasClientData;
bool mHasEducationMetadata;
bool mIsPlatformLocked;
bool mIsTitleLocked;
bool mCanUseTrustedPackCapabilities;
TemplateLockState mTemplateOptionLockState;
PackScope mScope;
ContentIdentity mSourceIdentity;
std::vector<std::string> mLanguageCodesForPackKeywords;
PackManifest::PackRedownloadableState mPackRedownloadableState;
PackManifestFormat mFormatVersion;
PackManifestFormat mOriginalFormatVersion;
};

/* 45310 */
struct __attribute__((aligned(4))) PlayerRespawnTelemetryData
{
uint32_t mSearchTimeMS;
uint32_t mLongJumpCount;
uint32_t mShortJumpCount;
double mJumpDistance;
uint32_t mPositionSourceType;
bool mChangedDimension;
};

/* 55577 */
struct __attribute__((aligned(4))) PrioritizedGoal
{
Unique<Goal> mGoal;
int mPriority;
bool mUsed;
bool mToStart;
};

/* 45320 */
struct __attribute__((aligned(4))) PurchaseInfo
{
ProductSku mProductSku;
std::string mPlatformPurchaseId;
std::string mReceipt;
std::string mCorrelationId;
PurchasePath mPurchasePath;
bool mActive;
bool mRenewal;
};

/* 90961 */
struct __attribute__((aligned(4))) RelativeFloat
{
float mOffset;
bool mRelative;
};

/* 173202 */
struct __attribute__((aligned(4))) ReverseableIterator
{
const int mStartValue;
const int mEndValue;
const bool mReversed;
};

/* 173203 */
struct __attribute__((aligned(4))) ReverseableIterator::Iterator
{
int mI;
bool mReversed;
};

/* 88912 */
struct __attribute__((aligned(4))) RopeAABB
{
AABB mBB;
bool mBlacklisted;
};

/* 88886 */
struct __attribute__((aligned(4))) RopeNode
{
Vec3 mPos;
Vec3 mPrevPos;
char mFrictionAxis;
};

/* 43918 */
struct __attribute__((aligned(4))) Social::Events::EventManager
{
std::vector<std::unique_ptr<Social::Events::IEventListener>> mEventListeners;
PropertyList mGlobalProperties;
PropertyList mCommonProperties;
PropertyListMap mPlayerCommonProperties;
PropertyListMap mPlayerGlobalProperties;
SharedMutex mGlobalPropertiesMutex;
SharedMutex mCommonPropertiesMutex;
SharedMutex mPlayerCommonPropertiesMutex;
SharedMutex mPlayerGlobalPropertiesMutex;
Bedrock::Threading::Mutex mListenersMutex;
uint32_t mGlobalSeqNum;
bool mAcceptNewEvents;
};

/* 59071 */
struct __attribute__((aligned(4))) SpawnActorEntry
{
SpawnActorParameters mParams;
int mSpawnTimer;
bool mStopSpawning;
};

/* 34119 */
struct __attribute__((aligned(4))) SubChunkLightUpdate
{
SubChunkBlockPos mPos;
Brightness mOldBrightness;
Brightness mNewBrightness;
Brightness mOldAbsorption;
Brightness mNewAbsorption;
bool mIsSkyLight;
};

/* 253684 */
struct __attribute__((aligned(4))) SubtractiveLightInfo::$6B0E6A960ECE12370BB5BB4D4B3FBF4C::$8A8F0A98EC9223C9E9CC01AC2399BC8B
{
SubChunkLightIndex mCoordIndex;
Brightness mOldBrightness;
};

/* 43941 */
struct __attribute__((aligned(4))) TelemetryInfo
{
PropertyBag mOldInfo;
PropertyBag mNewPendingInfo;
Core::HeapPathBuffer mFilePath;
int mPropertyChangeVersion;
bool mTampered;
bool mFirstSession;
};

/* 486203 */
struct __attribute__((aligned(4))) `anonymous namespace'::MinidumpWriter::WriteCPUInformation::CpuInfoEntry
{
const char *info_name;
int value;
bool found;
};

/* 294349 */
struct __attribute__((aligned(4))) ifmap
{
unsigned __int64 mem_start;
unsigned __int64 mem_end;
unsigned __int16 base_addr;
unsigned __int8 irq;
unsigned __int8 dma;
unsigned __int8 port;
};

/* 88899 */
struct __attribute__((aligned(8))) AABBBucket
{
AABB mBucketBounds;
int mCachedTicks;
std::vector<RopeAABB> mBBs;
bool mDirty;
bool mNeedsFinalize;
};

/* 133513 */
struct __attribute__((aligned(8))) ActorAnimationControllerGroupParseMetaData
{
ActorAnimationControllerGroup *mActorAnimationControllerGroup;
CurrentCmdVersion mCurrentCommandVersion;
};

/* 124799 */
struct __attribute__((aligned(8))) ActorAnimationEvent
{
ExpressionNode mExpression;
HashedString mCommand;
CurrentCmdVersion mCommandVersion;
std::string mEvent;
float mTime;
};

/* 87785 */
struct __attribute__((aligned(8))) ActorAnimationGroup
{
std::unordered_map<HashedString,std::shared_ptr<ActorAnimationInfo>> mAnimations;
Bedrock::Threading::Mutex mActorAnimationLock;
bool mIsExperimental;
};

/* 155453 */
struct __attribute__((aligned(8))) ActorAnimationGroupParseMetaData
{
ActorAnimationGroup *mActorAnimationGroup;
CurrentCmdVersion mCurrentCommandVersion;
};

/* 88691 */
struct __attribute__((aligned(8))) ActorAnimationPlayer
{
int (**_vptr$ActorAnimationPlayer)(void);
const HashedString mFriendlyName;
const ExpressionNode mBlendExpression;
bool mExpanded;
bool mAnimationFinished;
};

/* 77419 */
struct __attribute__((aligned(8))) ActorBlockSyncMessage
{
ActorUniqueID mEntityUniqueID;
ActorBlockSyncMessage::MessageId mMessage;
};

/* 13196 */
struct __attribute__((aligned(8))) ActorDamageSource
{
int (**_vptr$ActorDamageSource)(void);
ActorDamageCause mCause;
};

/* 49557 */
struct __attribute__((aligned(8))) ActorDefinitionFeedItem
{
const Item *mItem;
float mGrowth;
};

/* 111230 */
struct __attribute__((aligned(8))) ActorFactoryData
{
ActorDefinitionIdentifier mIdentifier;
ActorDefinitionIdentifier mBaseIdentifier;
bool mAllowSummon;
ActorFactoryFunction mFactory;
bool mIsExperimental;
ActorType mActorType;
float mWalkAnimSpeed;
};

/* 74392 */
struct __attribute__((aligned(8))) ActorInfo
{
unsigned int mRuntimeId;
ActorDefinitionIdentifier mIdentifier;
ActorDefinitionIdentifier mBaseIdentifier;
bool mHasSpawnEgg;
bool mIsSummonable;
bool mIsExperimental;
};

/* 76618 */
struct __attribute__((aligned(8))) ActorInfoRegistry
{
std::unordered_map<std::string,unsigned int> mActorInfoNameMap;
std::unordered_map<unsigned int,ActorInfo> mActorInfoMap;
unsigned int mLastId;
};

/* 45370 */
struct __attribute__((aligned(8))) ActorInteraction
{
std::string mInteractText;
ActorInteraction::OnInteraction mInteraction;
bool mNoCapture;
};

/* 35035 */
struct __attribute__((aligned(8))) ActorLink
{
ActorLinkType type;
ActorUniqueID A;
ActorUniqueID B;
bool mImmediate;
};

/* 124716 */
struct __attribute__((aligned(8))) ActorParticleEffect
{
HashedString mParticleEffectName;
HashedString mLocatorName;
ExpressionNode mInitializationScripts;
bool mBindToActor;
};

/* 124715 */
struct __attribute__((aligned(8))) ActorParticleEffectEvent
{
ActorParticleEffect mParticleEffect;
float mTime;
};

/* 124757 */
struct __attribute__((aligned(8))) ActorSoundEffectEvent
{
ActorSoundEffect mSoundEffect;
float mTime;
};

/* 89259 */
struct __attribute__((aligned(8))) ActorTerrainInterlockData
{
ActorTerrainInterlockData::VisibilityState mRenderVisibilityState;
std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1,1000000000> > > mCreationTime;
bool mHasBeenDelayedDeleted;
};

/* 49766 */
struct __attribute__((aligned(8))) AgentCommandComponent
{
Unique<AgentCommands::Command> mCurrentCommand;
int mWaitForNextCommandTicks;
};

/* 49735 */
struct __attribute__((aligned(8))) AgentCommands::Command
{
int (**_vptr$Command)(void);
Actor *mTarget;
Player *mCommander;
std::string mCommandName;
bool mResult;
bool mIsQueryResult;
};

/* 74257 */
struct __attribute__((aligned(8))) AnimatedImageData
{
persona::AnimatedTextureType mType;
mce::Image mImage;
float mFrames;
};

/* 173106 */
struct __attribute__((aligned(8))) AnimatedImageData_0
{
persona::AnimatedTextureType mType;
mce::Image_0 mImage;
float mFrames;
};

/* 73254 */
struct __attribute__((aligned(8))) AsynchronousIPResolver::ResolvedIp
{
std::string ip;
std::atomic<bool> ready;
};

/* 171071 */
struct __attribute__((aligned(8))) AttributeBuff
{
int (**_vptr$AttributeBuff)(void);
float mAmount;
AttributeBuffInfo mInfo;
std::shared_ptr<Amplifier> mValueAmplifier;
std::shared_ptr<Amplifier> mDurationAmplifier;
float mScale;
int mAmplification;
size_t mId;
int mOperand;
};

/* 174241 */
struct __attribute__((aligned(8))) AttributeCollection
{
std::unordered_map<StringKey,Attribute *> mAttributesMap;
uint32_t mIDValueIndex;
};

/* 51001 */
struct __attribute__((aligned(8))) AttributeModifier
{
int (**_vptr$AttributeModifier)(void);
float mAmount;
int mOperation;
int mOperand;
std::string mName;
mce::UUID mId;
bool mSerialize;
};

/* 91957 */
struct __attribute__((aligned(8))) AutoCompleteOption
{
std::string visualText;
std::string tabCompleteText;
std::string description;
AutoCompleteOption::CursorPos matchStart;
AutoCompleteOption::CursorPos matchLength;
AutoCompleteOption::CursorPos commandLineMatchStart;
AutoCompleteOption::CursorPos commandLineMatchOffset;
CommandItem item;
bool highlight;
};

/* 174695 */
struct __attribute__((aligned(8))) AutoPlaceItem
{
std::string collection;
bool stopWhenPlaced;
};

/* 174696 */
struct __attribute__((aligned(8))) AutoPlaceResult
{
std::string collectionName;
int collectionIndex;
};

/* 77928 */
struct __attribute__((aligned(8))) AvailableCommandsPacket::CommandData
{
std::string name;
std::string description;
uint8_t flags;
CommandPermissionLevel permission;
std::vector<AvailableCommandsPacket::OverloadData> overloads;
int aliasEnum;
};

/* 81895 */
struct __attribute__((aligned(8))) BackgroundTaskQueue
{
Bedrock::Threading::Mutex mIngressLock;
Bedrock::Threading::Mutex mEgressLock;
BackgroundTaskQueue::TaskPipe mTasks;
std::atomic_size_t mQueuedTasksCount;
std::atomic<bool> mResortQueue;
Bedrock::Threading::Mutex mQueueLock;
BackgroundTaskQueue::SortingJobQueue mLocalPriorityQueue;
std::atomic<int> mNextItemPriority;
};

/* 235084 */
struct __attribute__((aligned(8))) BannerBlockActor
{
__int8 baseclass_0[201];
bool mDirtyBounds;
uint8_t mBaseColor;
std::vector<unsigned char> mPatterns;
std::vector<unsigned char> mColors;
BannerBlockType mType;
};

/* 184502 */
struct __attribute__((aligned(8))) BannerPattern
{
uint8_t mID;
RowList mPattern;
ItemStack mIngredientItem;
std::string mName;
std::string mNameID;
__int16 mPatternItemType;
bool mIgnoreAux;
};

/* 34468 */
struct __attribute__((aligned(8))) BaseCircuitComponent
{
int (**_vptr$BaseCircuitComponent)(void);
CircuitComponentList mSources;
bool mIgnoreFirstUpdate;
bool mIsFirstTime;
bool mNeedsUpdate;
BlockPos mChunkPosition;
bool mShouldEvaluate;
int mStrength;
FacingID mDirection;
bool mAllowPowerUp;
bool mAllowPowerDown;
bool mRemoved;
};

/* 6935 */
struct __attribute__((aligned(8))) BedrockEngine::PlatformBuildInfo
{
std::string mInstallerPackageName;
Core::HeapPathBuffer mPlatformTempPath;
Core::HeapPathBuffer mOnDiskScratchPath;
Core::HeapPathBuffer mDataUrl;
Core::HeapPathBuffer mAltDataUrl;
std::string mFeedbackURL;
bool mHasBuyButtonWhenLicenseInvalid;
};

/* 480226 */
struct __attribute__((aligned(8))) BedrockLog::CategoryLogFile
{
std::unordered_map<BedrockLog::LogChannel,std::unique_ptr<BedrockLog::LogDetails>,std::enum_hash<BedrockLog::LogChannel>,std::equal_to<BedrockLog::LogChannel>,std::allocator<std::pair<const BedrockLog::LogChannel,std::unique_ptr<BedrockLog::LogDetails> > > > mChannel;
std::bitset<3> mCombinedChannelMask;
int mMessageCount;
};

/* 461263 */
struct __attribute__((aligned(8))) BeehiveBlockActor::Occupant
{
ActorDefinitionIdentifier mActorIdentifier;
CompoundTag mSaveData;
unsigned int mTicksLeftToStay;
};

/* 50372 */
struct __attribute__((aligned(8))) BehaviorData::DataProxy
{
int (**_vptr$DataProxy)(void);
std::string mId;
BehaviorData::DataType mType;
};

/* 50294 */
struct __attribute__((aligned(8))) BehaviorNode
{
int (**_vptr$BehaviorNode)(void);
const BehaviorDefinition *mNodeDefinition;
BehaviorTreeDefinitionPtr mTreeDefinition;
BehaviorNode *mParent;
BehaviorComponent *mComponent;
BehaviorData *mTreeData;
BehaviorStatus mStatus;
};

/* 170930 */
struct __attribute__((aligned(8))) BinaryHeap
{
std::vector<PathfinderNode *> heap;
int sizeVar;
};

/* 74633 */
struct __attribute__((aligned(8))) Blacklist::Entry
{
mce::UUID mUuid;
std::string mXuid;
std::string mBlockedMessage;
Blacklist::Duration mDuration;
};

/* 33515 */
struct __attribute__((aligned(8))) BlockActor
{
int (**_vptr$BlockActor)(void);
int mTickCount;
const Block *mBlock;
float mDestroyTimer;
Vec3 mDestroyDirection;
float mDestroyProgress;
BlockPos mPosition;
AABB mBB;
const BlockActorType mType;
BlockActorRendererId mRendererId;
std::string mCustomName;
std::string mFilteredCustomName;
int mRepairCost;
bool mClientSideOnly;
bool mIsMovable;
bool mSaveCustomName;
bool mCanRenderCustomName;
const float signShadowRadius;
ActorTerrainInterlockData mTerrainInterlockData;
bool mChanged;
};

/* 13249 */
struct __attribute__((aligned(8))) BlockDefinitionGroup
{
std::unordered_map<std::string,std::unique_ptr<BlockDefinition>> mBlockDefinitions;
int mLastBlockId;
};

/* 13254 */
struct __attribute__((aligned(8))) BlockDescription
{
std::string mIdentifier;
bool mRegisterToCreativeMenu;
bool mIsExperimental;
};

/* 34316 */
struct __attribute__((aligned(8))) BlockEventDispatcher
{
ListenerSet mRegisteredListeners;
ListenerHandle mHandleCounter;
};

/* 285795 */
struct __attribute__((aligned(8))) BlockLayer
{
const Block *mBlock;
int mNumLayers;
};

/* 169704 */
struct __attribute__((aligned(8))) BlockPatternBuilder
{
BlockSource *mRegion;
std::vector<std::string> mPattern;
std::map<char,PatternEntry> mLookup;
bool mReadyForMatch;
int mNumPatterns;
int mPatternLength;
};

/* 33536 */
struct __attribute__((aligned(8))) BlockTickingQueue
{
LevelChunk *mOwningChunk;
Tick mCurrentTick;
BlockTickingQueue::TickDataSet mNextTickQueue;
BlockTickingQueue::TickDataSet mActiveTickQueue;
TickingQueueType mQueueType;
bool mInstaTick;
};

/* 35010 */
struct __attribute__((aligned(8))) BlockVolume
{
buffer_span_mut<const Block *> blocks;
uint32_t mWidth;
uint32_t mHeight;
uint32_t mDepth;
};

/* 124533 */
struct __attribute__((aligned(8))) BoneAnimation
{
HashedString mBoneName;
std::vector<BoneAnimationChannel> mAnimationChannels;
BoneAnimationRelativeMode mRotationRelativeMode;
};

/* 104601 */
struct __attribute__((aligned(8))) BoneOrientation
{
int mParentBoneIndex;
SkeletalHierarchyIndex mParentSkeletalHierarchyIndex;
HashedString mName;
Matrix mLocalPreTransformMatrix;
Matrix mMatrix;
BoneAnimationRelativeMode mRotationRelativeMode;
BoneOrientationTransform mTransform;
BoneOrientationTransform mDefaultTransform;
Vec3 mPivot;
bool mOverrideStackMatrix;
bool mApplyLocalPreTransformMatrix;
};

/* 307360 */
struct __attribute__((aligned(8))) BoostItem
{
const Item *mItem;
const Item *mReplacement;
int mDamageAmount;
};

/* 307497 */
struct __attribute__((aligned(8))) BoostableDefinition
{
std::vector<BoostItem> mBoostItems;
float mMaxBoostTime;
float mSpeedModifier;
float mFovMod;
};

/* 51698 */
struct __attribute__((aligned(8))) BreathableComponent
{
int mSuffocateTime;
float mInhaleTime;
int mAirRegenPerTick;
bool mBreathesAir;
bool mBreathesWater;
bool mBreathesLava;
bool mBreathesSolids;
bool mGeneratesBubbles;
__int16 mAirSupply;
__int16 mAirSupplyMax;
std::set<const Block *> mBreathableBlocks;
std::set<const Block *> mNonBreathableBlocks;
BreathableComponent::BreathableState mBreathableState;
};

/* 51843 */
struct __attribute__((aligned(8))) BreedableDefinition
{
bool mTame;
bool mBlendAttributes;
float mExtraChance;
float mBreedCooldownTimeSeconds;
bool mInheritTamed;
bool mAllowSitting;
std::vector<ItemDescriptor> mBreedItems;
std::vector<EnvironmentRequirement> mEnvironmentRequirements;
ActorFilterGroup mLoveFilter;
std::vector<BreedableType> mBreedTypes;
MutationFactorData mMutationFactors;
DenySameParentsVariantData mDenyParentsVariant;
bool mCausesPregnancy;
};

/* 51957 */
struct __attribute__((aligned(8))) BribeableComponent
{
const BribeableDefinition *mStaticData;
int mBribeTimer;
int mBribeCooldown;
int mBribeCooldownTime;
};

/* 40161 */
struct __attribute__((aligned(8))) CanyonFeature
{
int (**_vptr$CanyonFeature)(void);
bool mAllowMegaRavines;
};

/* 7687 */
struct __attribute__((aligned(8))) Certificate
{
UnverifiedCertificate mUnverifiedCertificate;
Unique<Certificate> mParentCertificate;
bool mIsValid;
};

/* 237670 */
struct __attribute__((aligned(8))) ChalkboardBlockActor::CachedLineData
{
std::string text;
int lineLength;
};

/* 237693 */
struct __attribute__((aligned(8))) ChalkboardBlockActor::CachedMessageData
{
std::array<ChalkboardBlockActor::CachedLineData,16> lineData;
unsigned int numLines;
std::string filteredMessage;
const void *cachedFontCompare;
bool dirty;
};