/* 478096 */
struct CSHA1
{
unsigned int m_state[5];
unsigned int m_count[2];
unsigned int m_reserved0[1];
unsigned __int8 m_buffer[64];
unsigned __int8 m_digest[20];
unsigned int m_reserved1[3];
unsigned __int8 m_workspace[64];
SHA1_WORKSPACE_BLOCK *m_block;
};

/* 457056 */
struct CameraCallbacks;

/* 180676 */
struct CameraItemComponent
{
int (**_vptr$CameraItemComponent)(void);
float mBlackBarsDuration;
float mBlackBarsScreenRatio;
float mShutterScreenRatio;
float mShutterDuration;
float mPictureDuration;
float mSlideAwayDuration;
bool mPlacingTripod;
uint64_t mPlacingTripodClientTick;
uint64_t mPlacingTripodServerTick;
CameraCallbacks *mCallbacks;
};

/* 124057 */
struct Cat::updateEntitySpecificMolangVariables::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 226316 */
struct CauldronBlock::spawnPotionParticles::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 226317 */
struct CauldronBlock::spawnSplashParticles::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 89834 */
struct ChangeDimensionRequest
{
ChangeDimensionRequest::State mState;
DimensionType mFromDimensionId;
DimensionType mToDimensionId;
Vec3 mPosition;
bool mUsePortal;
bool mRespawn;
Unique<CompoundTag> mAgentTag;
};

/* 124574 */
struct ChannelTransform
{
ExpressionNode mXYZ[3];
Vec3 mAxis;
ChannelTransformAxisType mTransformDataType;
};

/* 456240 */
struct ChemistryIngredient
{
ItemInstance mItem;
};

/* 457266 */
struct ChemistryRecipes
{
__int8 gap0[1];
};

/* 124065 */
struct Chicken::updateEntitySpecificMolangVariables::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 33813 */
struct ChunkBlockPos
{
uint8_t x;
uint8_t z;
Height y;
};

/* 34799 */
struct ChunkBuildOrderPolicyBase
{
int (**_vptr$ChunkBuildOrderPolicyBase)(void);
};

/* 5799 */
struct ChunkPos
{
ChunkPos::$9F8988CC0F9198BEB3D9C07F7FC1F2E7 _anon_0;
};

/* 5801 */
struct ChunkPos::$9F8988CC0F9198BEB3D9C07F7FC1F2E7::$71D3E18752AF5CECAE552A00ECF6483C
{
int x;
int z;
};

/* 34214 */
struct ChunkSource
{
int (**_vptr$ChunkSource)(void);
int mChunkSide;
Level *mLevel;
Dimension *mDimension;
ChunkSource *mParent;
Unique<ChunkSource> mOwnedParent;
LevelChunkBuilderData *mLevelChunkBuilderData;
};

/* 34454 */
struct CircuitComponentList
{
std::vector<CircuitComponentList::Item> mComponents;
};

/* 34467 */
struct CircuitComponentList::Item
{
BaseCircuitComponent *mComponent;
int mDampening;
BlockPos mPos;
FacingID mDirection;
bool mDirectlyPowered;
int mData;
};

/* 34425 */
struct CircuitSceneGraph
{
CircuitSceneGraph::ComponentMap mAllComponents;
CircuitComponentList mActiveComponents;
CircuitSceneGraph::ComponentsPerPosMap mActiveComponentsPerChunk;
CircuitSceneGraph::ComponentsPerPosMap mPowerAssociationMap;
std::unordered_map<BlockPos,CircuitSceneGraph::PendingEntry> mPendingAdds;
std::unordered_map<BlockPos,CircuitSceneGraph::PendingEntry> mPendingUpdates;
std::unordered_map<BlockPos,std::vector<BlockPos>> mComponentsToReEvaluate;
std::vector<CircuitSceneGraph::PendingEntry> mPendingRemoves;
};

/* 34569 */
struct CircuitSystem::LevelChunkTracking
{
BlockPos mChunkPos;
};

/* 292130 */
struct CircuitTrackingInfo::Entry
{
BaseCircuitComponent *mComponent;
BlockPos mPos;
FacingID mDirection;
uint64_t mTypeID;
};

/* 7501 */
struct ClacksServer::ExecutionAndResult
{
ResetEventObj execution;
grpc::Status error;
};

/* 40727 */
struct ClassID
{
__int8 gap0[1];
};

/* 73674 */
struct ClientBlobCache::Server::ActiveTransfer
{
ClientBlobCache::Server::ActiveTransfersManager *mCache;
NetworkIdentifier mOwner;
std::unordered_map<unsigned long,std::shared_ptr<ClientBlobCache::Server::Blob>> mIdsWaitingForACK;
};

/* 73628 */
struct ClientBlobCache::Server::ActiveTransfersManager
{
std::unordered_map<NetworkIdentifier,std::unique_ptr<ClientBlobCache::Server::ActiveTransfersManager::TransferTracker>> mTransferTrackerMap;
ClientBlobCache::Server::ActiveTransfersManager::CacheMap mSentBlobs;
size_t mCacheSizeBytes;
};

/* 68463 */
struct ClientBlobCache::Server::Blob
{
const ClientBlobCache::BlobId id;
const std::string data;
};

/* 77424 */
struct ClientBlobCache::Server::TransferBuilder
{
ClientBlobCache::Server::ActiveTransfer mTransfer;
};

/* 193499 */
struct ClimateAttributes
{
float mTemperature;
float mDownfall;
float mSnowAccumulationMin;
float mSnowAccumulationMax;
};

/* 88760 */
struct ClockSpriteCalculator
{
int mFrame;
float mRot;
float mRotA;
};

/* 424868 */
struct CloneCommand::execute::CloneBlockInfo
{
BlockPos mPos;
const Block *mState;
std::unique_ptr<CompoundTag> mTag;
};

/* 33169 */
struct Color
{
float r;
float g;
float b;
float a;
};

/* 191006 */
struct ColorPaletteAttributes
{
std::string mPaletteName;
};

/* 33669 */
struct ColumnCachedData
{
int grassColor;
int waterColor;
};

/* 90986 */
struct CommandArea
{
std::unique_ptr<ChunkViewSource> mChunkSource;
BlockSource mBlockSource;
};

/* 91477 */
struct CommandAreaFactory
{
Dimension *mDimension;
};

/* 459308 */
struct CommandBlock::_executeChain::$8760BA774438E6A855C8C1CB8DE2843F
{
const CommandBlock *this;
};

/* 90965 */
struct CommandFilePath
{
std::string mText;
};

/* 1614 */
struct CommandFlag
{
uint8_t flag;
};

/* 90962 */
struct CommandItem
{
int mVersion;
int mId;
};

/* 5665 */
struct CommandLexer
{
const std::string *mInput;
CommandLexer::Token mToken;
};

/* 5666 */
struct CommandLexer::Token
{
const char *text;
uint32_t length;
CommandLexer::TokenType type;
};

/* 6364 */
struct CommandMessage
{
std::vector<CommandMessage::MessageComponent> mData;
};

/* 6331 */
struct CommandMessage::MessageComponent
{
std::string string;
std::unique_ptr<CommandSelector<Actor>> selection;
};

/* 1616 */
struct CommandOrigin
{
int (**_vptr$CommandOrigin)(void);
mce::UUID mUUID;
};

/* 78833 */
struct CommandOriginData
{
CommandOriginType mType;
mce::UUID mUUID;
std::string mRequestId;
int64_t mPlayerId;
};

/* 6083 */
struct CommandOutputMessage
{
CommandOutputMessageType mType;
std::string mMessageId;
std::vector<std::string> mParams;
};

/* 91536 */
struct CommandOutputParameter::CommandOutputParameter::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 4443 */
struct CommandOutputSender
{
int (**_vptr$CommandOutputSender)(void);
Automation::AutomationClient *mAutomationClient;
std::function<void (AutomationCmdOutput &)> mEmplaceTestCommandOutputCallback;
};

/* 33044 */
struct CommandPosition
{
Vec3 mOffset;
bool mRelativeX;
bool mRelativeY;
bool mRelativeZ;
bool mLocal;
};

/* 90960 */
struct CommandRawText
{
std::string mText;
};

/* 1503 */
struct CommandRegistry
{
std::function<void (const Packet &)> mNetworkUpdateCallback;
CommandRegistry::ScoreboardScoreAccessor mGetScoreForObjective;
std::vector<CommandRegistry::ParseRule> mRules;
CommandRegistry::ParseTableMap mParseTables;
std::vector<CommandRegistry::OptionalParameterChain> mOptionals;
std::vector<std::string> mEnumValues;
std::vector<CommandRegistry::Enum> mEnums;
std::vector<CommandRegistry::Factorization> mFactorizations;
std::vector<std::string> mPostfixes;
std::map<std::string,unsigned int> mEnumLookup;
std::map<std::string,unsigned long> mEnumValueLookup;
std::vector<CommandRegistry::Symbol> mCommandSymbols;
std::map<std::string,CommandRegistry::Signature> mSignatures;
std::map<typeid_t<CommandRegistry>,int> mTypeLookup;
std::map<std::string,std::string> mAliases;
std::vector<SemanticConstraint> mSemanticConstraints;
std::map<SemanticConstraint,unsigned char> mSemanticConstraintLookup;
std::vector<CommandRegistry::ConstrainedValue> mConstrainedValues;
std::map<std::pair<unsigned long,unsigned int>,unsigned int> mConstrainedValueLookup;
std::vector<CommandRegistry::SoftEnum> mSoftEnums;
std::map<std::string,unsigned int> mSoftEnumLookup;
std::vector<CommandRegistry::RegistryState> mStateStack;
CommandRegistry::ParamSymbols mArgs;
CommandRegistry::CommandOverrideFunctor mCommandOverrideFunctor;
};

/* 1567 */
struct CommandRegistry::ConstrainedValue
{
CommandRegistry::Symbol mValue;
CommandRegistry::Symbol mEnum;
std::vector<unsigned char> mConstraints;
};

/* 476454 */
struct CommandRegistry::DefaultIdConverter<AgentCommand::Mode>
{
__int8 gap0[1];
};

/* 476455 */
struct CommandRegistry::DefaultIdConverter<AgentCommands::CollectCommand::CollectionSpecification>
{
__int8 gap0[1];
};

/* 476453 */
struct CommandRegistry::DefaultIdConverter<AgentCommands::Direction>
{
__int8 gap0[1];
};

/* 426570 */
struct CommandRegistry::DefaultIdConverter<BlockSlot>
{
__int8 gap0[1];
};

/* 6284 */
struct CommandRegistry::DefaultIdConverter<ChangeSettingCommand::Setting>
{
__int8 gap0[1];
};

/* 424974 */
struct CommandRegistry::DefaultIdConverter<CloneCommand::CloneMode>
{
__int8 gap0[1];
};

/* 424973 */
struct CommandRegistry::DefaultIdConverter<CloneCommand::MaskMode>
{
__int8 gap0[1];
};

/* 93242 */
struct CommandRegistry::DefaultIdConverter<CommandItem>
{
__int8 gap0[1];
};

/* 425122 */
struct CommandRegistry::DefaultIdConverter<Difficulty>
{
__int8 gap0[1];
};

/* 425322 */
struct CommandRegistry::DefaultIdConverter<EffectCommand::Mode>
{
__int8 gap0[1];
};

/* 94436 */
struct CommandRegistry::DefaultIdConverter<Enchant::Type>
{
__int8 gap0[1];
};

/* 426571 */
struct CommandRegistry::DefaultIdConverter<EquipmentSlot>
{
__int8 gap0[1];
};

/* 425418 */
struct CommandRegistry::DefaultIdConverter<ExecuteCommand::Mode>
{
__int8 gap0[1];
};

/* 425513 */
struct CommandRegistry::DefaultIdConverter<FillCommand::FillMode>
{
__int8 gap0[1];
};

/* 93243 */
struct CommandRegistry::DefaultIdConverter<GameType>
{
__int8 gap0[1];
};

/* 425967 */
struct CommandRegistry::DefaultIdConverter<ListDCommand::DetailMode>
{
__int8 gap0[1];
};

/* 426875 */
struct CommandRegistry::DefaultIdConverter<ObjectiveSortOrder>
{
__int8 gap0[1];
};

/* 426289 */
struct CommandRegistry::DefaultIdConverter<PermissionCommand::Action>
{
__int8 gap0[1];
};

/* 426290 */
struct CommandRegistry::DefaultIdConverter<PermissionCommand::AvailableCommandPermissionPresets>
{
__int8 gap0[1];
};

/* 426572 */
struct CommandRegistry::DefaultIdConverter<ReplaceItemCommand::TargetType>
{
__int8 gap0[1];
};

/* 6637 */
struct CommandRegistry::DefaultIdConverter<SaveCommand::Mode>
{
__int8 gap0[1];
};

/* 426874 */
struct CommandRegistry::DefaultIdConverter<ScoreboardCommand::Action>
{
__int8 gap0[1];
};

/* 426873 */
struct CommandRegistry::DefaultIdConverter<ScoreboardCommand::Category>
{
__int8 gap0[1];
};

/* 426971 */
struct CommandRegistry::DefaultIdConverter<SetBlockCommand::SetBlockMode>
{
__int8 gap0[1];
};

/* 94435 */
struct CommandRegistry::DefaultIdConverter<StructureFeatureType>
{
__int8 gap0[1];
};

/* 427377 */
struct CommandRegistry::DefaultIdConverter<TagCommand::Action>
{
__int8 gap0[1];
};

/* 427474 */
struct CommandRegistry::DefaultIdConverter<TeleportCommand::FacingResult>
{
__int8 gap0[1];
};

/* 427659 */
struct CommandRegistry::DefaultIdConverter<TestForBlocksCommand::Mode>
{
__int8 gap0[1];
};

/* 427930 */
struct CommandRegistry::DefaultIdConverter<TickingAreaCommand::AddAreaType>
{
__int8 gap0[1];
};

/* 427929 */
struct CommandRegistry::DefaultIdConverter<TickingAreaCommand::Mode>
{
__int8 gap0[1];
};

/* 427931 */
struct CommandRegistry::DefaultIdConverter<TickingAreaCommand::TargetDimensions>
{
__int8 gap0[1];
};

/* 428127 */
struct CommandRegistry::DefaultIdConverter<TimeCommand::Mode>
{
__int8 gap0[1];
};

/* 428128 */
struct CommandRegistry::DefaultIdConverter<TimeCommand::Query>
{
__int8 gap0[1];
};

/* 428129 */
struct CommandRegistry::DefaultIdConverter<TimeCommand::TimeSpec>
{
__int8 gap0[1];
};

/* 428284 */
struct CommandRegistry::DefaultIdConverter<TitleCommand::Mode>
{
__int8 gap0[1];
};

/* 428379 */
struct CommandRegistry::DefaultIdConverter<TitleRawCommand::Mode>
{
__int8 gap0[1];
};

/* 428495 */
struct CommandRegistry::DefaultIdConverter<VideoStreamConnectPacket::Action>
{
__int8 gap0[1];
};

/* 428676 */
struct CommandRegistry::DefaultIdConverter<WeatherCommand::WeatherRequest>
{
__int8 gap0[1];
};

/* 428675 */
struct CommandRegistry::DefaultIdConverter<WeatherCommand::WeatherType>
{
__int8 gap0[1];
};

/* 6816 */
struct CommandRegistry::DefaultIdConverter<WhitelistCommand::Action>
{
__int8 gap0[1];
};

/* 93244 */
struct CommandRegistry::DefaultIdConverter<bool>
{
__int8 gap0[1];
};

/* 94434 */
struct CommandRegistry::DefaultIdConverter<const ActorDefinitionIdentifier *>
{
__int8 gap0[1];
};

/* 93246 */
struct CommandRegistry::DefaultIdConverter<const Block *>
{
__int8 gap0[1];
};

/* 425323 */
struct CommandRegistry::DefaultIdConverter<const MobEffect *>
{
__int8 gap0[1];
};

/* 93245 */
struct CommandRegistry::DefaultIdConverter<int>
{
__int8 gap0[1];
};

/* 1203 */
struct CommandRegistry::Enum
{
std::string name;
typeid_t<CommandRegistry> type;
CommandRegistry::ParseFunction parse;
_BYTE gap30[8];
std::vector<std::pair<unsigned long,unsigned long>> values;
};

/* 1239 */
struct CommandRegistry::Factorization
{
CommandRegistry::Terminal commandSymbol;
};

/* 49176 */
struct CommandRegistry::LexicalToken
{
const char *mText;
uint32_t mLength;
CommandRegistry::Terminal mType;
CommandRegistry::Terminal mIdentifierInfo;
const CommandRegistry *mRegistry;
};

/* 1167 */
struct CommandRegistry::OptionalParameterChain
{
int parameterCount;
CommandRegistry::RuleIndex followingRuleIndex;
CommandRegistry::Symbol paramSymbol;
};

/* 1607 */
struct CommandRegistry::ParamSymbols
{
CommandRegistry::Terminal x;
CommandRegistry::Terminal y;
CommandRegistry::Terminal z;
CommandRegistry::Terminal dx;
CommandRegistry::Terminal dy;
CommandRegistry::Terminal dz;
CommandRegistry::Terminal r;
CommandRegistry::Terminal rm;
CommandRegistry::Terminal rx;
CommandRegistry::Terminal rxm;
CommandRegistry::Terminal ry;
CommandRegistry::Terminal rym;
CommandRegistry::Terminal l;
CommandRegistry::Terminal lm;
CommandRegistry::Terminal c;
CommandRegistry::Terminal m;
CommandRegistry::Terminal name;
CommandRegistry::Terminal type;
CommandRegistry::Terminal score;
CommandRegistry::Terminal tag;
};

/* 1071 */
struct CommandRegistry::ParseRule
{
CommandRegistry::NonTerminal nonTerminal;
CommandRegistry::ProcessFunction process;
CommandRegistry::SymbolVector derivation;
CommandVersion versions;
};

/* 1125 */
struct CommandRegistry::ParseTable
{
CommandRegistry::ParseSet first;
CommandRegistry::ParseSet follow;
CommandRegistry::PredictTable predict;
};

/* 1615 */
struct CommandRegistry::ParseToken
{
std::unique_ptr<CommandRegistry::ParseToken> child;
std::unique_ptr<CommandRegistry::ParseToken> next;
CommandRegistry::ParseToken *parent;
const char *text;
uint32_t length;
CommandRegistry::Symbol type;
};

/* 1606 */
struct CommandRegistry::RegistryState
{
uint32_t signatureCount;
uint32_t enumValueCount;
uint32_t postfixCount;
uint32_t enumCount;
uint32_t factorizationCount;
uint32_t optionalCount;
uint32_t ruleCount;
uint32_t softEnumCount;
uint32_t constraintCount;
std::vector<unsigned int> constrainedValueCount;
std::vector<unsigned int> softEnumValuesCount;
};

/* 5676 */
struct CommandRegistry::SemanticInfo
{
bool mIsValid;
std::vector<CommandRegistry::Symbol> mConstrainedParams;
std::string mSoftEnumText;
std::string mSoftEnumEscapeCharExceptions;
std::set<CommandRegistry::Symbol> mAlreadyCompletedSymbols;
};

/* 1593 */
struct CommandRegistry::SoftEnum
{
std::string mName;
std::vector<std::string> mValues;
};

/* 1407 */
struct CommandRegistry::Symbol
{
int mValue;
};

/* 6316 */
struct CommandSelectorResults<Actor>
{
CommandResultVector mTargets;
};

/* 6317 */
struct CommandSelectorResults<Player>
{
CommandResultVector mTargets;
};

/* 88496 */
struct CommandSoftEnumRegistry
{
CommandRegistry *mRegistry;
};

/* 5681 */
struct CommandSyntaxInformation
{
bool isValid;
std::string description;
std::vector<OverloadSyntaxInformation> possibilities;
};

/* 1476 */
struct CommandVersion
{
int mFrom;
int mTo;
};

/* 90963 */
struct CommandWildcardInt
{
bool mIsWildcard;
int mValue;
};

/* 237970 */
struct ComparatorCapacitor
{
__int8 baseclass_0[68];
int mRearAnalogStrength;
int mSideAnalogStrengthRight;
int mSideAnalogStrengthLeft;
int mOldStrength;
ComparatorCapacitor::Mode mMode;
int mRearStrength;
int mSideStrengths;
bool mHasAnalogBeenSet;
CircuitComponentList mSideComponents;
};

/* 82474 */
struct CompareScheduledCallback
{
__int8 gap0[1];
};

/* 88759 */
struct CompassSpriteCalculator
{
int mFrame;
float mRot;
float mRotA;
};

/* 76549 */
struct ComplexInventoryTransaction
{
int (**_vptr$ComplexInventoryTransaction)(void);
ComplexInventoryTransaction::Type mType;
InventoryTransaction mTransaction;
};

/* 13371 */
struct CompoundTagEditHelper
{
Tag *mTag;
std::vector<Tag *> mParentTag;
std::vector<std::string> mTagName;
};

/* 13354 */
struct CompoundTagUpdater
{
uint32_t mVersion;
std::vector<std::function<bool (CompoundTagEditHelper &)>> mFilters;
std::vector<std::function<void (CompoundTagEditHelper &)>> mUpdates;
};

/* 13574 */
struct CompoundTagUpdaterBuilder
{
CompoundTagUpdater *mUpdater;
};

/* 235034 */
struct CompoundTagUpdaterBuilder::TagType<ByteTag>
{
__int8 gap0[1];
};

/* 235035 */
struct CompoundTagUpdaterBuilder::TagType<IntTag>
{
__int8 gap0[1];
};

/* 60952 */
struct CompoundTagVariant
{
CompoundTagVariant::Variant mTagStorage;
};

/* 237979 */
struct ConduitBlockActor::_animateTick::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 5663 */
struct ConnectionDefinition
{
uint16_t ipv4Port;
uint16_t ipv6Port;
ConnectionDefinition::PortBusyFallbackPolicy fallback;
int maxNumPlayers;
int maxNumConnections;
};

/* 63711 */
struct Connector
{
int (**_vptr$Connector)(void);
};

/* 72969 */
struct Connector::ConnectionStateListener;

/* 73236 */
struct Connector::NatPunchInfo
{
bool isValid;
bool addressIsDirty;
bool succeeded;
RakNet::SystemAddress externalAddress;
RakNet::TimeMS startPingSentTime;
RakNet::TimeMS pingSentTime;
RakNet::TimeMS startPongReceivedTime;
RakNet::TimeMS pongReceivedTime;
};

/* 477546 */
struct ConsoleChunkBlender
{
SpinLock mSpinLock;
float mInterpCorners[2][2];
float mInterpTable[16][16];
};

/* 89316 */
struct ContainerContentChangeListener
{
int (**_vptr$ContainerContentChangeListener)(void);
};

/* 174786 */
struct ContainerEnumNameHasher
{
__int8 gap0[1];
};

/* 175176 */
struct ContainerFactory
{
__int8 gap0[1];
};

/* 79729 */
struct ContainerItemStack
{
ItemStack itemStackInstance;
ItemInstance itemInstance;
};

/* 75576 */
struct ContainerMixDataEntry
{
int fromItemId;
int reagentItemId;
int toItemId;
};

/* 173090 */
struct ContainerSizeChangeListener
{
int (**_vptr$ContainerSizeChangeListener)(void);
};

/* 84138 */
struct ContentCatalogPackSource;

/* 3051 */
struct ContentLog
{
bool mEnabled;
std::vector<ContentLogEndPoint *> mEndPoints;
ThreadLocal<ThreadSpecificData> mThreadSpecificData;
Bedrock::Threading::Mutex mEndpointMutex;
};

/* 5785 */
struct ContentTierInfo
{
MemoryTier mMemoryTier;
};

/* 5071 */
struct ContentTierManager
{
MemoryTier mMemoryTier;
};

/* 421009 */
struct ContextAccessor
{
uint16_t mTypeId;
std::unique_ptr<ContextAccessor::TypeBase> mContext;
};

/* 420937 */
struct ContextAccessor::TypeBase
{
__int8 gap0[1];
};

/* 420968 */
struct ContextAccessor::TypeDerived<EntityContext>
{
EntityContext mData;
};

/* 480752 */
struct ContextMessage
{
LogArea mArea;
LogLevel mLevel;
std::string mMessage;
};

/* 480816 */
struct ContextMessageLoggerOptions
{
bool mStoreMessages[4];
bool mAssertIfMessageTypeWasReceived[4];
bool mAssertInDestructorIfMessageTypeWasReceived[4];
bool mAllowMessagesToPostToParentMessageLoggers;
bool mOutputAllMessagesOnDestruction;
};

/* 116992 */
struct Control
{
int (**_vptr$Control)(void);
};

/* 481956 */
struct Core::BufferedFileOperations
{
__int8 gap0[1];
};

/* 481957 */
struct Core::BufferedFileOperations::_copyFileSection<8192>::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 83872 */
struct Core::DirectoryIterationItem
{
Core::HeapPathBuffer mFullPathName;
Core::PathPart mName;
Core::FileSize mFileSize;
Core::FileSize mFileSizeAllocationOnDisk;
Core::FileType mType;
Core::FileTime mCreateTime;
Core::FileTime mModifyTime;
};

/* 480877 */
struct Core::DiskAccessDiagnostics
{
std::chrono::_V2::steady_clock::duration mLogInterval;
std::chrono::_V2::steady_clock::time_point mLastLogTime;
double mWriteMBPerMinuteHWM;
double mWriteCountPerMinuteHWM;
};

/* 480898 */
struct Core::DiskAccessTracker
{
std::chrono::_V2::steady_clock::duration mBytesWrittenInterval;
std::chrono::_V2::steady_clock::duration mNumWritesInterval;
std::vector<Core::DiskAccessTracker::WriteOperation> mWriteOperations;
std::set<Core::PathBuffer<std::string >> mIgnoredPaths;
std::unique_ptr<Core::DiskAccessDiagnostics> mDiskAccessDiagnostics;
Bedrock::Threading::Mutex mMutex;
};

/* 480830 */
struct Core::DiskAccessTracker::WriteOperation
{
Core::FileSize writeAmount;
std::chrono::_V2::steady_clock::time_point timePoint;
};

/* 5529 */
struct Core::File
{
std::unique_ptr<Core::FileImpl> muptFile;
std::unique_ptr<Core::FileSystemImpl> muptTransaction;
};

/* 5530 */
struct Core::FileOpenMode
{
__int8 mRead : 1;
__int8 mWrite : 1;
__int8 mCreate : 1;
__int8 mTruncate : 1;
__int8 mAppend : 1;
__int8 mBinary : 1;
};

/* 5545 */
struct Core::FilePathManager
{
bool mIsDedicatedServer;
Core::HeapPathBuffer mRoot;
Core::HeapPathBuffer mPackagePath;
Core::HeapPathBuffer mDataUrl;
Core::HeapPathBuffer mExternalFilePath;
Core::HeapPathBuffer mTemporaryFilePath;
Core::HeapPathBuffer mCacheFilePath;
Core::HeapPathBuffer mSettingsPath;
};

/* 479769 */
struct Core::FileStats
{
std::atomic<unsigned long> mNumSuccessfulWriteOperations;
std::atomic<unsigned long> mNumBytesWritten;
std::atomic<unsigned long> mNumFailedWriteOperations;
std::atomic<unsigned long> mNumSuccessfulReadOperations;
std::atomic<unsigned long> mNumBytesRead;
std::atomic<unsigned long> mNumFailedReadOperations;
std::atomic<unsigned long> mFileSystemSize;
std::atomic<unsigned long> mFileSystemAllocatedSize;
};

/* 5526 */
struct Core::FileStdStreamBuf
{
__int8 baseclass_0[64];
Core::File mFile;
Core::FileOpenMode mFileOpenMode;
std::vector<char> mBuffer;
Core::FileSize mBufferSize;
};

/* 481579 */
struct Core::FileStorageArea::_beginTransaction::$A402370104E9C52EF545D733D86F5169
{
Core::FileStorageArea *this;
};

/* 479784 */
struct Core::FileStorageAreaObserver;

/* 481922 */
struct Core::FileSystem
{
__int8 gap0[1];
};

/* 481656 */
struct Core::FileSystem::BasicFileData
{
Core::HeapPathBuffer mPath;
Core::FileSize mSize;
};

/* 481691 */
struct Core::FileSystem::FileTransferProgress
{
Core::FileSize mStartPosition;
Core::FileSize mBytesWritten;
Core::FileSize mBytesRemaining;
};

/* 481818 */
struct Core::FileSystem::copyDirectoryAndContentsRecursivelyWithLimit::$F457DC01F16FBA362CDB9DA581FCE3BD
{
bool *directoriesCreated;
std::vector<Core::PathBuffer<std::string >> *directories;
std::vector<Core::FileSystem::BasicFileData> *files;
Core::FileSize *currentFileBytesWritten;
};

/* 481835 */
struct Core::FileSystem::copyFlatFile::$F457DC01F16FBA362CDB9DA581FCE3BD
{
bool *directoriesCreated;
std::vector<Core::PathBuffer<std::string >> *directories;
std::vector<Core::FileSystem::BasicFileData> *files;
Core::FileSize *currentFileBytesWritten;
};

/* 4554 */
struct Core::FileSystemImpl
{
int (**_vptr$FileSystemImpl)(void);
std::shared_ptr<Core::FileStorageArea> mpStorageArea;
bool mLoggingEnabled;
bool mTransactionEnded;
Core::FileAccessType mAccessType;
Core::FileStats mStats;
Bedrock::Threading::Mutex mFileLock;
std::vector<Core::FileImpl *> mFiles;
Core::FlatFileSystemImpl mFlatFileSystem;
};

/* 481117 */
struct Core::FlatFileManifest
{
std::unordered_map<std::string,unsigned long> mManifestEntriesMap;
std::vector<Core::FlatFileManifestInfo> mManifestInfoVector;
size_t mEntriesCount;
uint64_t mVersion;
Core::HeapPathBuffer mManifestPath;
};

/* 479811 */
struct Core::FlatFileManifestTracker
{
Bedrock::Threading::Mutex mManifestsLock;
std::unordered_map<std::string,std::shared_ptr<Core::FlatFileManifest>> mManifestMap;
std::set<std::string> mManifestNames;
};

/* 482745 */
struct Core::FlatFileOperations
{
__int8 gap0[1];
};

/* 482754 */
struct Core::FlatFileOperations::createFlatFile::$A33D1747C0AB08CA482DA30473C7FFB8
{
bool *deleteTargetDirectory;
Core::FileSystemImpl **targetTransaction;
const Core::Path *targetDirectoryPath;
};

/* 482726 */
struct Core::FlatFileOperations::createFlatFile::$B53007EAE32060CC4F6B30C0745D046E
{
std::unique_ptr<Core::FileImpl> *flatFile;
std::vector<char> *writeBuffer;
Core::FileSize *writeBufferSize;
};

/* 482462 */
struct Core::FlatFileSearchResult
{
std::shared_ptr<const Core::FlatFileManifest> mManifest;
const Core::FlatFileManifestInfo *mManifestInfoEntry;
};

/* 482369 */
struct Core::FlatFileSystemImpl
{
Core::FileSystemImpl *mFileSystemImpl;
std::shared_ptr<Core::FlatFileManifestTracker> mFlatFileManifestTracker;
};

/* 482800 */
struct Core::FullCopyFileOperations
{
__int8 gap0[1];
};

/* 87049 */
struct Core::LevelStorageResult
{
Core::LevelStorageState state;
std::string telemetryMsg;
};

/* 479688 */
struct Core::LoadTimeData
{
const std::string mName;
int mScope;
double mTotalTime;
};

/* 481498 */
struct Core::Observer<Core::FileStorageAreaObserver,Core::SingleThreadedLock>;

/* 76904 */
struct Core::Observer<Social::MultiplayerServiceObserver,Core::SingleThreadedLock>
{
int (**_vptr$Observer)(void);
Core::Observer<Social::MultiplayerServiceObserver,Core::SingleThreadedLock>::SubjectType *mpSubject;
};

/* 74585 */
struct Core::Observer<Social::XboxLiveUserObserver,Core::SingleThreadedLock>
{
int (**_vptr$Observer)(void);
Core::Observer<Social::XboxLiveUserObserver,Core::SingleThreadedLock>::SubjectType *mpSubject;
};

/* 44953 */
struct Core::Observer<WebviewObserver,Core::SingleThreadedLock>
{
int (**_vptr$Observer)(void);
Core::Observer<WebviewObserver,Core::SingleThreadedLock>::SubjectType *mpSubject;
};

/* 5539 */
struct Core::Path
{
Core::PathPart mPathPart;
};

/* 5063 */
struct Core::PathBuffer<Core::StackString<char,1024> >
{
Core::StackString<char,1024> mContainer;
};

/* 5548 */
struct Core::PathContainerConversions<Core::StackString<char,1024> >
{
__int8 gap0[1];
};

/* 676 */
struct Core::PathPart
{
std::string mUtf8StdString;
};

/* 63864 */
struct Core::Profile::CounterToken
{
MicroProfileToken mMicroProfileToken;
};

/* 485594 */
struct Core::Profile::FileCounters
{
uint64_t requests;
uint64_t retries;
uint64_t retrySuccess;
uint64_t failures;
};

/* 485592 */
struct Core::Profile::ProfileMultiSectionCPU
{
__int8 gap0[1];
};

/* 485593 */
struct Core::Profile::ProfileMultiSectionCPU::ProfileSectionSuspend
{
__int8 gap0[1];
};

/* 32841 */
struct Core::Profile::ProfileSectionCPU
{
const Core::Profile::CPUProfileToken *mToken;
};

/* 87047 */
struct Core::Profile::ProfileThread
{
__int8 gap0[1];
};

/* 31072 */
struct Core::Random
{
RandomSeed mSeed;
uint32_t _mt[624];
int _mti;
bool mHaveNextNextGaussian;
float mNextNextGaussian;
int mInitedIdx;
};

/* 479652 */
struct Core::ScopedLoadTimeSection
{
double mStartTime;
Core::LoadTimeData mProfileData;
};

/* 44760 */
struct Core::SingleThreadedLock
{
__int8 gap0[1];
};

/* 13123 */
struct Core::SplitPathT<1024,64>
{
std::array<Core::Path,64> mParts;
size_t mNumParts;
};

/* 13248 */
struct Core::SplitPathT<1024,64>::SplitPathT::$1CC25A583192B38B92CA1589E23791C2
{
Core::SplitPathT<1024,64> *this;
__gnu_cxx::__normal_iterator<const char *,std::string > *splitEnd;
__gnu_cxx::__normal_iterator<const char *,std::string > *splitStart;
const std::string *fullPath;
};

/* 5064 */
struct Core::StackString<char,1024>
{
const size_t MAX_LENGTH;
std::array<char,1024> mBuf;
size_t mLength;
};

/* 479785 */
struct Core::StorageAreaState
{
Bedrock::Threading::Mutex mMutex;
Core::HeapPathBuffer mStorageAreaRootPath;
std::atomic<bool> mIsExtendDiskSpaceEvent;
std::atomic<bool> mIsLowDiskSpaceWarning;
std::atomic<bool> mIsOutOfDiskSpaceError;
std::atomic<bool> mIsCriticalDiskError;
std::vector<Core::StorageAreaStateListener *> mListeners;
};

/* 479798 */
struct Core::StorageAreaStateListener;

/* 481500 */
struct Core::StorageAreasTree
{
Core::StorageAreasTree::TreeNode mRoot;
std::vector<Core::FileStorageArea *> mStorageAreas;
};

/* 481200 */
struct Core::StorageAreasTree::TreeChild
{
HashedString mKey;
std::unique_ptr<Core::StorageAreasTree::TreeNode> mNode;
};

/* 481209 */
struct Core::StorageAreasTree::TreeNode
{
std::vector<Core::StorageAreasTree::TreeChild> mChildren;
Core::FileStorageArea *mStorageArea;
};

/* 485134 */
struct Core::String
{
__int8 gap0[1];
};

/* 13124 */
struct Core::StringSpan
{
string_span mStringSpan;
};

/* 479771 */
struct Core::Subject<Core::FileStorageAreaObserver,Core::SingleThreadedLock>
{
Core::SingleThreadedLock mLock;
std::vector<Core::FileStorageAreaObserver *> mObservers;
};

/* 76906 */
struct Core::Subject<Social::MultiplayerServiceObserver,Core::SingleThreadedLock>
{
Core::SingleThreadedLock mLock;
std::vector<Social::MultiplayerServiceObserver *> mObservers;
};

/* 74587 */
struct Core::Subject<Social::XboxLiveUserObserver,Core::SingleThreadedLock>
{
Core::SingleThreadedLock mLock;
std::vector<Social::XboxLiveUserObserver *> mObservers;
};

/* 44955 */
struct Core::Subject<WebviewObserver,Core::SingleThreadedLock>
{
Core::SingleThreadedLock mLock;
std::vector<WebviewObserver *> mObservers;
};

/* 481729 */
struct Core::TransactionFrame
{
std::shared_ptr<Core::FileSystemImpl> msptTransaction;
Core::StackPathBuffer mCleanPath;
Core::Result mResult;
};

/* 481724 */
struct Core::TransactionFrameSourceTarget
{
Core::StackPathBuffer mSource;
Core::StackPathBuffer mTarget;
bool mSameStorageArea;
std::shared_ptr<Core::FileSystemImpl> msptSourceTransaction;
std::shared_ptr<Core::FileSystemImpl> msptTargetTransaction;
Core::Result mResult;
};