# W

# `WorldInfo`

Offset	Type	Name
0	(4) `_BYTE[4]`	mWorldType
4	(4) `WorldInfo::Status`	mStatus

# `WorldSettingsScreenController::_createWorld::__l17::<lambda_30eacbc3767aa70fa725f906225512f7>`

Offset	Type	Name

# `WorldSeedCatalogModel::_filterWorldSeedModels::__l2::<lambda_1f94c8840b7eed1643578473f67d7bf3>`

Offset	Type	Name

# `WeatherRenderObject::WeatherParameters`

Offset	Type	Name
0	(4) `float`	fSpeed
4	(4) `float`	fLength
8	(4) `float`	fWidth
12	(4) `float`	fAlpha
16	(4) `float`	fWindScale
20	(1) `bool`	bNormalizeWind
24	(4) `float`	fGravityScale
28	(4) `float`	fRandomDirScale
32	(4) `float`	fDespawnProbability

# `WeakPtr<Item>`

Offset	Type	Name
0	(8) `SharedCounter<Item> *`	pc

# `WorkerConfiguration`

Offset	Type	Name
0	(32) `ThreadConfiguration`	baseclass_0
32	(4) `unsigned int`	NumWorkers
36	(1) `bool`	SuppressProfiling

# `WeakPtr<BlockLegacy>`

Offset	Type	Name
0	(8) `SharedCounter<BlockLegacy> *`	pc

# `wrapperbase`

Offset	Type	Name
0	(8) `char *`	name
8	(4) `int`	offset
16	(8) `void *`	function
24	(8) `_object (__fastcall )(_object , _object , void *)`	wrapper
32	(8) `char *`	doc
40	(4) `int`	flags
48	(8) `_object *`	name_strobj

# `WideByteMask`

Offset	Type	Name
0	(2) `unsigned __int16`	mask

# `WeakRefT<EntityRefTraits>`

Offset	Type	Name
0	(24) `WeakStorageEntity`	baseclass_0

# `WeakStorageEntity`

Offset	Type	Name
0	(16) `WeakRefT<EntityRegistryRefTraits>`	mRegistry
16	(4) `EntityId`	mEntity

# `WeakRefT<EntityRegistryRefTraits>`

Offset	Type	Name
0	(16) `WeakStorageSharePtr<EntityRegistry>`	baseclass_0

# `WeakStorageSharePtr<EntityRegistry>`

Offset	Type	Name
0	(16) `std::weak_ptr<EntityRegistry>`	mHandle

# `WorldTemplateLevelData`

Offset	Type	Name
0	(24) `ContentIdentity`	mPremiumTemplateContentIdentity
24	(136) `PackIdVersion`	mWorldTemplateIdentity
160	(112) `BaseGameVersion`	mBaseGameVersion
272	(1) `bool`	mIsFromWorldTemplate
273	(1) `bool`	mIsWorldTemplateOptionLocked

# `WorldTemplateInfo`

Offset	Type	Name
0	(32) `std::string`	mName
32	(32) `std::string`	mDescription
64	(32) `std::string`	mAuthors
96	(32) `std::string`	mVersion
128	(32) `Core::PathBuffer<std::string >`	mPath
160	(32) `std::string`	mGameType
192	(32) `Core::PathBuffer<std::string >`	mWorldIconPath
224	(1) `bool`	mWorldIconOverride
232	(8) `const WorldTemplatePackManifest *`	mManifest
240	(24) `std::vector<std::reference_wrapper<WorldTemplatePackSource>>`	mPacksInWorldTemplate

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_ae66c086c4017b718f91abcd596e1644>`

Offset	Type	Name
0	(32) `const std::string`	dropdownName
32	(8) `WorldConversionErrorReportScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l5::<lambda_4619b5e0188b36fe9f50cb3bc06c281f>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1a9419c082bd732c9cdabe3db6e7c7d2>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4a4111f343976fe3e70a853f8071ff93>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8fa18923b3c9b0352921c8507355935e>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_df222c82b64efe052d4401ead3d855ac>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d27709ce8af69f27a742eebd131ebde2>`

Offset	Type	Name

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2a0d82b796cc03ef7e9ca7fff726c49b>`

Offset	Type	Name
0	(8) `WorldSettingsScreenController *const`	__this

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldSettingsScreenController>`	weakThis
16	(3360) `LevelSettings`	levelSettings
3376	(32) `const std::string`	levelId

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_e7b026eda446f274701718f9837342db>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldSettingsScreenController>`	weakThis
16	(3360) `LevelSettings`	levelSettings
3376	(32) `const std::string`	levelId

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldSettingsScreenController>`	weakThis
16	(3360) `LevelSettings`	levelSettings
3376	(32) `const std::string`	levelId

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>::()::__l8::<lambda_448fe23cf5d2eb28baea85c687e5b921>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldSettingsScreenController>`	weakThis
16	(32) `const std::string`	levelId

# `WorldSettingsScreenController::_deleteWorld::__l5::<lambda_bc4423b008cb0436831c7091689d60da>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldSettingsScreenController>`	weakThis
16	(16) `std::weak_ptr<MainMenuScreenModel>`	weakModel
32	(32) `std::string`	levelId

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>`

Offset	Type	Name
0	(8) `WorldTemplatesScreenController *const`	__this
8	(8) `const WorldTemplateInfo *`	level
16	(64) `std::function<void __cdecl(bool)>`	successCallback

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_4dfc45f582529d3ed727b3945c94bf27>`

Offset	Type	Name
0	(64) `std::function<void __cdecl(bool)>`	successCallback

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_af9feea12623906003f5ce55a09ccef2>`

Offset	Type	Name
0	(8) `WorldTemplatesScreenController *const`	__this
8	(8) `const WorldTemplateInfo *`	level
16	(64) `std::function<void __cdecl(bool)>`	successCallback

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_edcbed0e3f42203445918c7695c8684b>::()::__l8::<lambda_bc73e247c820d38008e0a4e5693880f1>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldTemplatesScreenController>`	weakThis
16	(264) `const WorldTemplateInfo`	level

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_c82335fd1d8bab14ec8b416ff3685b1f>::()::__l8::<lambda_21a21ae3b0985dfbe01e5b781fae38d9>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldTemplatesScreenController>`	weakThis
16	(264) `const WorldTemplateInfo`	level

# `WorldSeedCatalogModel::fetch::__l2::<lambda_55fb1a16544d2a415662441120666ac9>::()::__l9::<lambda_01c062cbc5d985f30c7ffd330cec1890>`

Offset	Type	Name
0	(8) `WorldSeedCatalogModel *const`	__this
8	(16) `std::weak_ptr<bool>`	weakTracker
24	(32) `std::string`	productId

# `WorldSeedCatalogModel::WorldSeedFilteredLookup`

Offset	Type	Name
0	(4) `int`	contentIndex
8	(8) `unsigned __int64`	startStringIndex
16	(32) `std::string`	matchedText

# `WebToken`

Offset	Type	Name
0	(32) `std::string`	mHeader
32	(16) `Json::Value`	mHeaderInfo
48	(32) `std::string`	mData
80	(16) `Json::Value`	mDataInfo
96	(32) `std::string`	mSignature

# `WeatherRenderObject`

Offset	Type	Name
0	(16) `std::shared_ptr<mce::Mesh>`	mParticleMesh
16	(72) `mce::TexturePtr`	mWeatherTexture
88	(16) `mce::ServerTexture`	mOcclusionTexture
104	(16) `mce::ServerTexture`	mBrightnessTexture
120	(8) `const mce::MaterialPtr *`	mRainMat
128	(8) `const mce::MaterialPtr *`	mSnowMat
136	(8) `const mce::MaterialPtr *`	mPlanktonMat
144	(8) `const mce::MaterialPtr *`	mRedSporesMat
152	(8) `const mce::MaterialPtr *`	mBlueSporesMat
160	(8) `const mce::MaterialPtr *`	mAshMat
168	(8) `const mce::MaterialPtr *`	mWhiteAshMat
176	(252) `std::array<WeatherRenderObject::WeatherParameters,7>`	mParams
428	(10080) `std::array<std::array<WeatherRenderObject::RenderRuntimeSettings,10>,7>`	mSettings
10508	(4) `float`	mDensityRain
10512	(4) `float`	mDensitySnow
10516	(4) `float`	mDensityPlankton
10520	(4) `float`	mDensityRedSpores
10524	(4) `float`	mDensityBlueSpores
10528	(4) `float`	mDensityAsh
10532	(4) `float`	mDensityWhiteAsh
10536	(4) `float`	mParticleBoxSize
10540	(4) `float`	mLuminance
10544	(4) `int`	mParticleCount

# `WeatherRenderObject::RenderRuntimeSettings`

Offset	Type	Name
0	(72) `WeatherRenderObject::RuntimeValues`	t0
72	(72) `WeatherRenderObject::RuntimeValues`	t

# `WeatherRenderObject::RuntimeValues`

Offset	Type	Name
0	(4) `float`	m_fSpeedScale
4	(4) `float`	m_fWindScale
8	(12) `glm::tvec3<float,0>`	m_vWind
20	(12) `glm::tvec3<float,0>`	m_vOffset
32	(12) `glm::tvec3<float,0>`	m_vRandom
44	(12) `glm::tvec3<float,0>`	m_vSnowOffset
56	(12) `glm::tvec3<float,0>`	m_vRandomDir
68	(4) `int`	m_ParticleIndexOffset

# `WeakRefT<SharePtrRefTraits<FogDefinition const > >`

Offset	Type	Name
0	(16) `WeakStorageSharePtr<FogDefinition const >`	baseclass_0

# `WeakStorageSharePtr<FogDefinition const >`

Offset	Type	Name
0	(16) `std::weak_ptr<FogDefinition const >`	mHandle

# `WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_1fd7857a6c54915173786814bb19a325>::()::__l5::<lambda_0afcd04c1373b2f5c9f5f644c8d1b5c7>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldFileDownloadManager>`	weak_this
16	(32) `Core::PathBuffer<std::string >`	filePath
48	(4) `_BYTE[4]`	result

# `WorldFileDownloadManager::_transformLevel::__l19::<lambda_d7071557326ed3291a542974045ff48b>`

Offset	Type	Name
0	(64) `std::function<void __cdecl(void)>`	callback
64	(16) `std::shared_ptr<LevelStorage>`	levelStorage

# `WorldFileDownloadManager::_importLevel::__l13::<lambda_f751d7d2807b10c0b06e3015f280143d>`

Offset	Type	Name
0	(16) `std::weak_ptr<WorldFileDownloadManager>`	weak_this
16	(32) `Core::PathBuffer<std::string >`	filePath

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l25::<lambda_af1791171d63bd6d3087491c8d97b837>`

Offset	Type	Name
0	(72) `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>`	archiveLevel
72	(16) `std::shared_ptr<LevelStorage>`	levelStorage

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>`

Offset	Type	Name
0	(8) `WorldFileUploadManager *const`	__this
8	(32) `const std::string`	worldID
40	(32) `const std::string`	uploadId

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>`

Offset	Type	Name
0	(16) `std::weak_ptr<FileUploadManager>`	weakThis
16	(32) `const std::string`	uploadId

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>::()::__l8::<lambda_99eb832ba02257e8fca44c2455ddc9b7>`

Offset	Type	Name
0	(16) `std::weak_ptr<FileUploadManager>`	weakThis
16	(32) `const std::string`	uploadId
48	(40) `FileArchiver::Result`	result

# `WINDOWPLACEMENT`

Offset	Type	Name
0	(4) `unsigned int`	length
4	(4) `unsigned int`	flags
8	(4) `unsigned int`	showCmd
12	(8) `tagPOINT`	ptMinPosition
20	(8) `tagPOINT`	ptMaxPosition
28	(16) `tagRECT`	rcNormalPosition

# `WeakPtr<ActorPlacerItem>`

Offset	Type	Name
0	(8) `SharedCounter<ActorPlacerItem> *`	pc

# `WeakPtr<ComponentItem>`

Offset	Type	Name
0	(8) `SharedCounter<ComponentItem> *`	pc

# `WeakPtr<MicroBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<MicroBlockItem> *`	pc

# `WeakPtr<BlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<BlockItem> *`	pc

# `WeightedChoices<float>`

Offset	Type	Name
0	(24) `std::vector<WeightedChoice<float>>`	mChoices

# `WorldPackHistory`

Offset	Type	Name
0	(136) `PackIdVersion`	mPackIdVersion
136	(32) `std::string`	mUnlocalizedName
168	(64) `std::unordered_map<std::string,std::string>`	mLocalizedNames
232	(4) `int`	mSubpackCount
236	(1) `bool`	mCanBeRedownloaded
240	(16) `mce::UUID`	mSourceUUID

# `WorldTemplateManager::postDeleteWorldTemplate::__l2::<lambda_0f606a778526b0f1aa838bcfccd6baae>`

Offset	Type	Name
0	(8) `WorldTemplateManager *const`	__this
8	(136) `const PackIdVersion`	packIdentity

# `WorldGenClimateMappingAttributes`

Offset	Type	Name
0	(24) `std::vector<WorldGenClimateMappingAttributes::WeightedTemperatureCategory>`	mClimateMappings

# `WeighedRandom::WeighedRandomItem`

Offset	Type	Name
0	(4) `int`	mRandomWeight

# `WeakPtr<AirBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<AirBlockItem> *`	pc

# `WeakPtr<ShovelItem>`

Offset	Type	Name
0	(8) `SharedCounter<ShovelItem> *`	pc

# `WeakPtr<PickaxeItem>`

Offset	Type	Name
0	(8) `SharedCounter<PickaxeItem> *`	pc

# `WeakPtr<HatchetItem>`

Offset	Type	Name
0	(8) `SharedCounter<HatchetItem> *`	pc

# `WeakPtr<FlintAndSteelItem>`

Offset	Type	Name
0	(8) `SharedCounter<FlintAndSteelItem> *`	pc

# `WeakPtr<BowItem>`

Offset	Type	Name
0	(8) `SharedCounter<BowItem> *`	pc

# `WeakPtr<ArrowItem>`

Offset	Type	Name
0	(8) `SharedCounter<ArrowItem> *`	pc

# `WeakPtr<CoalItem>`

Offset	Type	Name
0	(8) `SharedCounter<CoalItem> *`	pc

# `WeakPtr<WeaponItem>`

Offset	Type	Name
0	(8) `SharedCounter<WeaponItem> *`	pc

# `WeakPtr<BlockPlanterItem>`

Offset	Type	Name
0	(8) `SharedCounter<BlockPlanterItem> *`	pc

# `WeakPtr<HoeItem>`

Offset	Type	Name
0	(8) `SharedCounter<HoeItem> *`	pc

# `WeakPtr<ArmorItem>`

Offset	Type	Name
0	(8) `SharedCounter<ArmorItem> *`	pc

# `WeakPtr<ShieldItem>`

Offset	Type	Name
0	(8) `SharedCounter<ShieldItem> *`	pc

# `WeakPtr<HangingActorItem>`

Offset	Type	Name
0	(8) `SharedCounter<HangingActorItem> *`	pc

# `WeakPtr<SignItem>`

Offset	Type	Name
0	(8) `SharedCounter<SignItem> *`	pc

# `WeakPtr<DoorItem>`

Offset	Type	Name
0	(8) `SharedCounter<DoorItem> *`	pc

# `WeakPtr<BucketItem>`

Offset	Type	Name
0	(8) `SharedCounter<BucketItem> *`	pc

# `WeakPtr<MinecartItem>`

Offset	Type	Name
0	(8) `SharedCounter<MinecartItem> *`	pc

# `WeakPtr<RedStoneDustItem>`

Offset	Type	Name
0	(8) `SharedCounter<RedStoneDustItem> *`	pc

# `WeakPtr<SnowballItem>`

Offset	Type	Name
0	(8) `SharedCounter<SnowballItem> *`	pc

# `WeakPtr<BoatItem>`

Offset	Type	Name
0	(8) `SharedCounter<BoatItem> *`	pc

# `WeakPtr<EnchantedBookItem>`

Offset	Type	Name
0	(8) `SharedCounter<EnchantedBookItem> *`	pc

# `WeakPtr<EggItem>`

Offset	Type	Name
0	(8) `SharedCounter<EggItem> *`	pc

# `WeakPtr<CompassItem>`

Offset	Type	Name
0	(8) `SharedCounter<CompassItem> *`	pc

# `WeakPtr<FishingRodItem>`

Offset	Type	Name
0	(8) `SharedCounter<FishingRodItem> *`	pc

# `WeakPtr<ClockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ClockItem> *`	pc

# `WeakPtr<DyePowderItem>`

Offset	Type	Name
0	(8) `SharedCounter<DyePowderItem> *`	pc

# `WeakPtr<BedItem>`

Offset	Type	Name
0	(8) `SharedCounter<BedItem> *`	pc

# `WeakPtr<MapItem>`

Offset	Type	Name
0	(8) `SharedCounter<MapItem> *`	pc

# `WeakPtr<ShearsItem>`

Offset	Type	Name
0	(8) `SharedCounter<ShearsItem> *`	pc

# `WeakPtr<EnderpearlItem>`

Offset	Type	Name
0	(8) `SharedCounter<EnderpearlItem> *`	pc

# `WeakPtr<PotionItem>`

Offset	Type	Name
0	(8) `SharedCounter<PotionItem> *`	pc

# `WeakPtr<BottleItem>`

Offset	Type	Name
0	(8) `SharedCounter<BottleItem> *`	pc

# `WeakPtr<EnderEyeItem>`

Offset	Type	Name
0	(8) `SharedCounter<EnderEyeItem> *`	pc

# `WeakPtr<ExperiencePotionItem>`

Offset	Type	Name
0	(8) `SharedCounter<ExperiencePotionItem> *`	pc

# `WeakPtr<FireChargeItem>`

Offset	Type	Name
0	(8) `SharedCounter<FireChargeItem> *`	pc

# `WeakPtr<WritableBookItem>`

Offset	Type	Name
0	(8) `SharedCounter<WritableBookItem> *`	pc

# `WeakPtr<WrittenBookItem>`

Offset	Type	Name
0	(8) `SharedCounter<WrittenBookItem> *`	pc

# `WeakPtr<EmptyMapItem>`

Offset	Type	Name
0	(8) `SharedCounter<EmptyMapItem> *`	pc

# `WeakPtr<SkullItem>`

Offset	Type	Name
0	(8) `SharedCounter<SkullItem> *`	pc

# `WeakPtr<CarrotOnAStickItem>`

Offset	Type	Name
0	(8) `SharedCounter<CarrotOnAStickItem> *`	pc

# `WeakPtr<FireworksItem>`

Offset	Type	Name
0	(8) `SharedCounter<FireworksItem> *`	pc

# `WeakPtr<FireworkChargeItem>`

Offset	Type	Name
0	(8) `SharedCounter<FireworkChargeItem> *`	pc

# `WeakPtr<HorseArmorItem>`

Offset	Type	Name
0	(8) `SharedCounter<HorseArmorItem> *`	pc

# `WeakPtr<RecordItem>`

Offset	Type	Name
0	(8) `SharedCounter<RecordItem> *`	pc

# `WeakPtr<TridentItem>`

Offset	Type	Name
0	(8) `SharedCounter<TridentItem> *`	pc

# `WeakPtr<LeadItem>`

Offset	Type	Name
0	(8) `SharedCounter<LeadItem> *`	pc

# `WeakPtr<ArmorStandItem>`

Offset	Type	Name
0	(8) `SharedCounter<ArmorStandItem> *`	pc

# `WeakPtr<SplashPotionItem>`

Offset	Type	Name
0	(8) `SharedCounter<SplashPotionItem> *`	pc

# `WeakPtr<LingeringPotionItem>`

Offset	Type	Name
0	(8) `SharedCounter<LingeringPotionItem> *`	pc

# `WeakPtr<BannerItem>`

Offset	Type	Name
0	(8) `SharedCounter<BannerItem> *`	pc

# `WeakPtr<CrossbowItem>`

Offset	Type	Name
0	(8) `SharedCounter<CrossbowItem> *`	pc

# `WeakPtr<BannerPatternItem>`

Offset	Type	Name
0	(8) `SharedCounter<BannerPatternItem> *`	pc

# `WeakPtr<SuspiciousStewItem>`

Offset	Type	Name
0	(8) `SharedCounter<SuspiciousStewItem> *`	pc

# `WeakPtr<CameraItem>`

Offset	Type	Name
0	(8) `SharedCounter<CameraItem> *`	pc

# `WeakPtr<CompoundItem>`

Offset	Type	Name
0	(8) `SharedCounter<CompoundItem> *`	pc

# `WeakPtr<IceBombItem>`

Offset	Type	Name
0	(8) `SharedCounter<IceBombItem> *`	pc

# `WeakPtr<ChemistryItem>`

Offset	Type	Name
0	(8) `SharedCounter<ChemistryItem> *`	pc

# `WeakPtr<RapidFertilizerItem>`

Offset	Type	Name
0	(8) `SharedCounter<RapidFertilizerItem> *`	pc

# `WeakPtr<BalloonItem>`

Offset	Type	Name
0	(8) `SharedCounter<BalloonItem> *`	pc

# `WeakPtr<MedicineItem>`

Offset	Type	Name
0	(8) `SharedCounter<MedicineItem> *`	pc

# `WeakPtr<SparklerItem>`

Offset	Type	Name
0	(8) `SharedCounter<SparklerItem> *`	pc

# `WeakPtr<GlowStickItem>`

Offset	Type	Name
0	(8) `SharedCounter<GlowStickItem> *`	pc

# `WeakPtr<LodestoneCompassItem>`

Offset	Type	Name
0	(8) `SharedCounter<LodestoneCompassItem> *`	pc

# `WeakPtr<WarpedFungusOnAStickItem>`

Offset	Type	Name
0	(8) `SharedCounter<WarpedFungusOnAStickItem> *`	pc

# `WeakPtr<SlabBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<SlabBlockItem> *`	pc

# `WeakPtr<AuxDataBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<AuxDataBlockItem> *`	pc

# `WeakPtr<ClothBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ClothBlockItem> *`	pc

# `WeakPtr<StoneSlabBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<StoneSlabBlockItem> *`	pc

# `WeakPtr<CoralFanBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<CoralFanBlockItem> *`	pc

# `WeakPtr<SeaPickleBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<SeaPickleBlockItem> *`	pc

# `WeakPtr<SaplingBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<SaplingBlockItem> *`	pc

# `WeakPtr<LeafBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<LeafBlockItem> *`	pc

# `WeakPtr<WoodSlabBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<WoodSlabBlockItem> *`	pc

# `WeakPtr<WaterLilyBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<WaterLilyBlockItem> *`	pc

# `WeakPtr<TopSnowBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<TopSnowBlockItem> *`	pc

# `WeakPtr<ShulkerBoxBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ShulkerBoxBlockItem> *`	pc

# `WeakPtr<BambooBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<BambooBlockItem> *`	pc

# `WeakPtr<ScaffoldingBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ScaffoldingBlockItem> *`	pc

# `WeakPtr<BellBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<BellBlockItem> *`	pc

# `WeakPtr<ChemistryAuxDataBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ChemistryAuxDataBlockItem> *`	pc

# `WeakPtr<PumpkinBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<PumpkinBlockItem> *`	pc

# `WeakPtr<ElementBlockItem>`

Offset	Type	Name
0	(8) `SharedCounter<ElementBlockItem> *`	pc

# `WeakRefT<FeatureRefTraits>`

Offset	Type	Name
0	(24) `WeakStorageFeature`	baseclass_0

# `WeakStorageFeature`

Offset	Type	Name
0	(16) `std::optional<std::reference_wrapper<FeatureRegistry> >`	mRegistry
16	(8) `unsigned __int64`	mIndex

# `WireframeQuad`

Offset	Type	Name
0	(48) `std::array<Vec3,4>`	mQuad
48	(4) `int`	mColor

# `WorldChangeTransaction`

Offset	Type	Name
0	(8) `IBlockWorldGenAPI *`	mTarget
8	(8) `std::unique_ptr<WorldChangeTransaction::Data>`	mData

# `WeightedRandomFeature::WeightedFeatureReference`

Offset	Type	Name
0	(24) `WeakRefT<FeatureRefTraits>`	mFeature
24	(4) `float`	mWeight

# `WeakPtr<CustomRangedWeaponItem>`

Offset	Type	Name
0	(8) `SharedCounter<CustomRangedWeaponItem> *`	pc

# `WeakPtr<CustomProjectileItem>`

Offset	Type	Name
0	(8) `SharedCounter<CustomProjectileItem> *`	pc

# `WeightedBiomeAttributes<ShoreTransformation>`

Offset	Type	Name
0	(24) `std::vector<std::pair<Biome *,unsigned int>>`	mBiomes

# `WellKnownBiomeTags`

Offset	Type	Name
0	(24) `WellKnownTagID`	MONSTER_TAG_ID
24	(24) `WellKnownTagID`	ANIMAL_TAG_ID
48	(24) `WellKnownTagID`	OCEAN_TAG_ID
72	(24) `WellKnownTagID`	NETHER_TAG_ID
96	(24) `WellKnownTagID`	END_TAG_ID
120	(24) `WellKnownTagID`	MOOSHROOM_TAG_ID
144	(24) `WellKnownTagID`	PLAINS_TAG_ID
168	(24) `WellKnownTagID`	DESERT_TAG_ID
192	(24) `WellKnownTagID`	JUNGLE_TAG_ID
216	(24) `WellKnownTagID`	BAMBOO_JUNGLE_TAG_ID
240	(24) `WellKnownTagID`	TAIGA_TAG_ID
264	(24) `WellKnownTagID`	EXTREME_HILLS_TAG_ID
288	(24) `WellKnownTagID`	SAVANNA_TAG_ID
312	(24) `WellKnownTagID`	FROZEN_TAG_ID
336	(24) `WellKnownTagID`	COLD_TAG_ID
360	(24) `WellKnownTagID`	LUKEWARM_TAG_ID
384	(24) `WellKnownTagID`	WARM_TAG_ID
408	(24) `WellKnownTagID`	RIVER_TAG_ID
432	(24) `WellKnownTagID`	SWAMP_TAG_ID
456	(24) `WellKnownTagID`	BEACH_TAG_ID
480	(24) `WellKnownTagID`	FLOWER_FOREST_TAG_ID
504	(24) `WellKnownTagID`	FOREST_TAG_ID
528	(24) `WellKnownTagID`	BIRCH_TAG_ID
552	(24) `WellKnownTagID`	HILLS_TAG_ID
576	(24) `WellKnownTagID`	MUTATED_TAG_ID
600	(24) `WellKnownTagID`	EDGE_TAG_ID
624	(24) `WellKnownTagID`	PLATEAU_TAG_ID
648	(24) `WellKnownTagID`	DEEP_TAG_ID
672	(24) `WellKnownTagID`	MESA_TAG_ID
696	(24) `WellKnownTagID`	ICE_PLAINS_TAG_ID
720	(24) `WellKnownTagID`	ICE_TAG_ID
744	(24) `WellKnownTagID`	MOUNTAIN_TAG_ID
768	(24) `WellKnownTagID`	SHORE_TAG_ID
792	(24) `WellKnownTagID`	STONE_TAG_ID
816	(24) `WellKnownTagID`	ROOFED_TAG_ID
840	(24) `WellKnownTagID`	MEGA_TAG_ID
864	(24) `WellKnownTagID`	RARE_TAG_ID
888	(24) `WellKnownTagID`	NO_LEGACY_WORLDGEN_TAG_ID
912	(24) `WellKnownTagID`	OVERWORLD_TAG_ID
936	(24) `WellKnownTagID`	OVERWORLD_GEN_TAG_ID
960	(24) `WellKnownTagID`	FOREST_GEN_TAG_ID
984	(24) `WellKnownTagID`	NO_SPAWN_END_DRAGON

# `WellKnownTagID`

Offset	Type	Name
0	(16) `IDType<BiomeTagIDType>`	mTagID
16	(8) `TagRegistry<IDType<BiomeTagIDType>,IDType<BiomeTagSetIDType> > *`	mTagRegistry

# `WeakPtr<EndCrystalItem>`

Offset	Type	Name
0	(8) `SharedCounter<EndCrystalItem> *`	pc

# `working_state`

Offset	Type	Name
0	(8) `unsigned __int8 *`	next_output_byte
8	(8) `unsigned __int64`	free_in_buffer
16	(20) `_BYTE[20]`	cur
40	(8) `jpeg_compress_struct *`	cinfo

# `WSAData`

Offset	Type	Name
0	(2) `unsigned __int16`	wVersion
2	(2) `unsigned __int16`	wHighVersion
4	(2) `unsigned __int16`	iMaxSockets
6	(2) `unsigned __int16`	iMaxUdpDg
8	(8) `char *`	lpVendorInfo
16	(257) `char[257]`	szDescription
273	(129) `char[129]`	szSystemStatus

# `WFILE`

Offset	Type	Name
0	(8) `_iobuf *`	fp
8	(4) `int`	error
12	(4) `int`	depth
16	(8) `_object *`	str
24	(8) `char *`	ptr
32	(8) `char *`	end
40	(8) `_object *`	strings
48	(4) `int`	version

# `WeightedBiomeAttributes<RiverTransformation>`

Offset	Type	Name
0	(24) `std::vector<std::pair<Biome *,unsigned int>>`	mBiomes

# `WaterMovementComponent`

const struct __cppobj WaterMovementComponent : IEntityComponent
{
  float mDragFactor;
};

# `WithdrawFurnaceXpPacket`

const struct __cppobj __declspec(align(8)) WithdrawFurnaceXpPacket : Packet
{
  BlockPos mPos;
};

# `WithdrawFurnaceXpPacket_vtbl`

struct /*VFT*/ WithdrawFurnaceXpPacket_vtbl
{
  void (__fastcall *~Packet)(Packet *this);
  MinecraftPacketIds (__fastcall *getId)(Packet *this);
  std::string *(__fastcall *getName)(Packet *this, std::string *result);
  void (__fastcall *write)(Packet *this, BinaryStream *);
  StreamReadResult (__fastcall *read)(Packet *this, ReadOnlyBinaryStream *);
  ExtendedStreamReadResult *(__fastcall *readExtended)(Packet *this, ExtendedStreamReadResult *result, ReadOnlyBinaryStream *);
  bool (__fastcall *disallowBatching)(Packet *this);
};

# `WebSocketPacketData`

struct __cppobj WebSocketPacketData
{
  std::string mIP;
};

# `WorkerPool`

struct __cppobj WorkerPool : Bedrock::EnableNonOwnerReferences
{
  const bool mAsync;
  std::vector<std::unique_ptr<BackgroundWorker>> mWorkers;
  std::string mName;
  BackgroundWorkerPerfInfo mPerfInfo;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mLastPerfInfoUpdate;
  Scheduler *mOwnerScheduler;
  std::mutex mSuspendLock;
  Bedrock::Threading::OSThreadPriority mPoolPriority;
  float mMinBacklogDurationSeconds;
  SpinLock mPendingWorkQueueLock;
  MovePriorityQueue<std::shared_ptr<BackgroundTaskBase>,BackgroundTaskBase::PendingComparer> mPendingWorkQueue;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mNextPendingWorkTime;
  BackgroundTaskQueue mTaskQueue;
};

# `WebviewObserver`

struct __cppobj WebviewObserver : Core::Observer<WebviewObserver,Core::SingleThreadedLock>
{
};

# `WebviewError`

const struct __cppobj __declspec(align(8)) WebviewError
{
  WebviewError::Type type;
  std::string message;
  int code;
};

# `WebviewDownloadInfo`

const struct __cppobj WebviewDownloadInfo
{
  std::string mContentDisposition;
  std::string mMimeType;
  std::string mOriginalURL;
  std::string mURL;
  unsigned int mId;
  std::string mSuggestedFileName;
  std::string mFullPath;
  __int64 mReceivedBytes;
  __int64 mTotalBytes;
  __int64 mCurrentSpeed;
  int mPercentComplete;
  __int64 mStartTime;
  __int64 mEndTime;
};

# `WebviewObserver_vtbl`

struct /*VFT*/ WebviewObserver_vtbl
{
  void (__fastcall *~Observer<WebviewObserver,Core::SingleThreadedLock>)(Core::Observer<WebviewObserver,Core::SingleThreadedLock> *this);
  void (__fastcall *_onSubjectDestroyed)(Core::Observer<WebviewObserver,Core::SingleThreadedLock> *this);
  void (__fastcall *onLoadingBegin)(WebviewObserver *this);
  void (__fastcall *onLoadingEnd)(WebviewObserver *this);
  void (__fastcall *onError)(WebviewObserver *this, const WebviewError *);
  void (__fastcall *onDownloadBegin)(WebviewObserver *this, const WebviewDownloadInfo *);
  void (__fastcall *onDownloadUpdate)(WebviewObserver *this, const WebviewDownloadInfo *);
  void (__fastcall *onDownloadComplete)(WebviewObserver *this, const WebviewDownloadInfo *);
  void (__fastcall *onDownloadCanceled)(WebviewObserver *this, const WebviewDownloadInfo *);
  void (__fastcall *onMessageRecieved)(WebviewObserver *this, const std::string *);
};

# `WorldSessionEndPoint`

struct __cppobj __declspec(align(8)) WorldSessionEndPoint : ContentLogEndPoint
{
  IMinecraftEventing *mEventing;
  bool mIsEnabled;
};

# `WorldSessionEndPoint_vtbl`

struct /*VFT*/ WorldSessionEndPoint_vtbl
{
  void (__fastcall *~LogEndPoint)(Bedrock::LogEndPoint *this);
  void (__fastcall *log)(Bedrock::LogEndPoint *this, const char *);
  void (__fastcall *flush)(Bedrock::LogEndPoint *this);
  void (__fastcall *setEnabled)(Bedrock::LogEndPoint *this, bool);
  bool (__fastcall *isEnabled)(Bedrock::LogEndPoint *this);
  void (__fastcall *log)(ContentLogEndPoint *this, const LogArea, const LogLevel, const char *);
};

# `WorldTemplateManager`

struct __cppobj WorldTemplateManager
{
  PackManifestFactory *mPackManifestFactory;
  const IContentKeyProvider *mKeyProvider;
  PackSourceFactory *mPackSourceFactory;
  const Core::FilePathManager *mFilePathManager;
  std::unique_ptr<PackSource> mLocalWorldSources;
  std::vector<std::unique_ptr<WorldTemplateInfo>> mWorldTemplates;
  std::vector<PackIdVersion> mLocalPremiumPackIds;
  std::mutex mInitializeMutex;
  std::atomic<bool> mInitialized;
  std::atomic<bool> mStorageDirectoryChangeRequest;
  WorldTemplatePackManifest mInvalidManifest;
  WorldTemplateInfo mInvalidWorldTemplate;
  std::unique_ptr<WorldTemplateManagerProxy> mProxy;
  std::unique_ptr<TaskGroup> mInitTaskGroup;
  std::function<bool __cdecl(std::unique_ptr<WorldTemplateInfo> const &,std::unique_ptr<WorldTemplateInfo> const &)> mSort;
};

# `WorldTemplatePackSource`

struct __cppobj __declspec(align(8)) WorldTemplatePackSource : DirectoryPackSource
{
  const WorldTemplateManager *mWorldTemplateManager;
  mce::UUID mWorldTemplateId;
  bool mHasValidPathSet;
};

# `WorldTemplatePackSource_vtbl`

struct /*VFT*/ WorldTemplatePackSource_vtbl
{
  void (__fastcall *~PackSource)(PackSource *this);
  void (__fastcall *forEachPackConst)(PackSource *this, std::function<void __cdecl(Pack const &)>);
  void (__fastcall *forEachPack)(PackSource *this, std::function<void __cdecl(Pack &)>);
  PackOrigin (__fastcall *getPackOrigin)(PackSource *this);
  PackType (__fastcall *getPackType)(PackSource *this);
  PackSourceReport *(__fastcall *load)(PackSource *this, PackSourceReport *result, PackManifestFactory *, const IContentKeyProvider *);
  void (__fastcall *addPackSource)(PackSource *this, PackSource *);
};

# `WorldPacksHistoryFile`

struct __cppobj WorldPacksHistoryFile
{
  std::vector<WorldPackHistory> mPacks;
};

# `WorldHistoryPackSource`

struct __cppobj __declspec(align(8)) WorldHistoryPackSource : PackSource
{
  Core::PathBuffer<std::string > mPathToHistoryFile;
  _BYTE mPackType[1];
  std::vector<std::unique_ptr<Pack>> mPacks;
  WorldPacksHistoryFile mWorldHistoryPacksFile;
  bool mDiscovered;
  bool mNeedsSaving;
};

# `WorldHistoryPackSource_vtbl`

struct /*VFT*/ WorldHistoryPackSource_vtbl
{
  void (__fastcall *~PackSource)(PackSource *this);
  void (__fastcall *forEachPackConst)(PackSource *this, std::function<void __cdecl(Pack const &)>);
  void (__fastcall *forEachPack)(PackSource *this, std::function<void __cdecl(Pack &)>);
  PackOrigin (__fastcall *getPackOrigin)(PackSource *this);
  PackType (__fastcall *getPackType)(PackSource *this);
  PackSourceReport *(__fastcall *load)(PackSource *this, PackSourceReport *result, PackManifestFactory *, const IContentKeyProvider *);
  void (__fastcall *addPackSource)(PackSource *this, PackSource *);
};

# `WorldTemplatePackManifest`

const struct __cppobj __declspec(align(8)) WorldTemplatePackManifest : PackManifest
{
  GameType mGameType;
};

# `WorldTemplatePackManifest_vtbl`

struct /*VFT*/ WorldTemplatePackManifest_vtbl
{
  void (__fastcall *~PackManifest)(PackManifest *this);
  std::unique_ptr<PackManifest> *(__fastcall *clone)(PackManifest *this, std::unique_ptr<PackManifest> *result);
};

# `WorldTemplateManagerProxyCallbacks`

const struct __cppobj WorldTemplateManagerProxyCallbacks
{
  std::function<int __cdecl(std::string const &)> mFindTemplateIndexWithName;
  std::function<WorldTemplateInfo const * __cdecl(int)> mGetTemplateInfo;
};

# `WorldTemplateManagerProxy`

struct __cppobj WorldTemplateManagerProxy
{
  const WorldTemplateManagerProxyCallbacks mCallbacks;
};

# `WorldListComponent`

struct __cppobj WorldListComponent : StoreUIComponent
{
  std::string mUpsellQueryName;
};

# `WorldListComponent_vtbl`

struct /*VFT*/ WorldListComponent_vtbl
{
  void (__fastcall *~StoreUIComponent)(StoreUIComponent *this);
  void (__fastcall *tick)(StoreUIComponent *this, ui::DirtyFlag *);
  bool (__fastcall *canRemove)(StoreUIComponent *this);
  int (__fastcall *getReadyCount)(StoreUIComponent *this);
  void (__fastcall *parseData)(StoreUIComponent *this, const struct web::json::value *);
};

# `WorldSeedModel`

struct __cppobj WorldSeedModel
{
  std::string mProductId;
  std::string mTitle;
  std::string mSeed;
  Core::PathBuffer<std::string > mImagePath;
};

# `WorldSeedCatalogModel`

struct __cppobj __declspec(align(8)) WorldSeedCatalogModel
{
  std::vector<WorldSeedModel> mWorldSeedModels;
  WorldSeedModel mInvalidWorldSeedModel;
  std::string mWorldSeedFilter;
  std::vector<WorldSeedCatalogModel::WorldSeedFilteredLookup> mFilteredWorldSeedModels;
  std::unique_ptr<ContentCatalogService> mContentCatalogService;
  std::shared_ptr<bool> mExistenceTracker;
  bool mRefresh;
};

# `WorldFileDownloadManager`

struct __cppobj WorldFileDownloadManager : FileDownloadManager
{
  const Core::PathBuffer<std::string > mCachePathRoot;
  gsl::not_null<Bedrock::NonOwnerPointer<FileArchiver> > mFileArchiver;
  LevelListCache *mLevelListCache;
  ExternalContentManager *mExternalContentManager;
  UserAuthentication *mUserAuthentication;
  bool mIdentityObtained;
  bool mDownloadDone;
  std::string mIdentity;
  Core::PathBuffer<std::string > mDownloadFilePath;
  std::string mRealmName;
  std::string mRealmVersionName;
  std::string mFileType;
  const IContentAccessibilityProvider *mAccessibilityProvider;
  const bool mAppendCopy;
  std::string mLevelId;
  std::shared_ptr<ImportContext> mContext;
};

# `WorldFileDownloadManager_vtbl`

struct /*VFT*/ WorldFileDownloadManager_vtbl
{
  void (__fastcall *~FileDownloadManager)(FileDownloadManager *this);
  void (__fastcall *update)(FileDownloadManager *this);
  void (__fastcall *cancelDownload)(FileDownloadManager *this);
  float (__fastcall *getDownloadProgress)(FileDownloadManager *this);
};

# `WeatherRenderer`

struct __cppobj WeatherRenderer : LevelListener, PlayerListener
{
  LocalPlayer *mLocalPlayer;
  std::shared_ptr<Options> mOptions;
  LevelRendererCamera *mLevelRendererCamera;
  std::shared_ptr<mce::Mesh> mParticleMesh;
  mce::TexturePtr mWeatherTexture;
  std::shared_ptr<mce::ClientTexture> mWeatherOcculusionTexture;
  std::shared_ptr<mce::ClientTexture> mBrightnessTexture;
  std::shared_ptr<mce::Image> mWeatherOcculusionImage;
  _BYTE mWeatherOcculusionTextureID[1];
  _BYTE mBrightnessTextureID[1];
  int m_nParticles;
  std::array<WeatherRenderObject::WeatherParameters,7> mParameters;
  std::array<WeatherRenderObject::WeatherParameters,7> mParametersDefaultValues;
  float fDensityRain;
  float fTargetDensityRain;
  float fDensitySnow;
  float fTargetDensitySnow;
  float m_fParticleBox;
  float m_fTime;
  bool mOcclusionDirty;
  bool mWeatherOcclusionTextureDirty;
  BlockPos mLastOcclusionPos;
  PerlinSimplexNoise mNoise;
  PerlinSimplexNoise mSnowNoise;
  std::array<std::array<WeatherRenderObject::RenderRuntimeSettings,10>,7> m_runtime;
  std::array<float,7> oPrecipitationAmount;
  std::array<float,7> precipitationAmount;
  std::array<float,7> mForcePrecipitationDensity;
  float mTargetFogLevel;
  float mFogLevel;
  mce::MaterialPtr rainMat;
  mce::MaterialPtr snowMat;
  mce::MaterialPtr planktonMat;
  mce::MaterialPtr redSporesMat;
  mce::MaterialPtr blueSporesMat;
  mce::MaterialPtr ashMat;
  mce::MaterialPtr whiteAshMat;
};

# `WebSocketCommunicator`

struct __cppobj __declspec(align(8)) WebSocketCommunicator
{
  WebSocketCommunicator_vtbl *__vftable /*VFT*/;
  Trigger mPostClosedSignal;
  WebSocketCommunicator::SocketType mSocketType;
  std::unique_ptr<RakWebSocket> mSocket;
  unsigned __int16 mPort;
  bool mEnabled;
  std::vector<unsigned char> mSerialized;
  bool mSerializedUnsent;
};

# `WebSocketCommunicator_vtbl`

struct /*VFT*/ WebSocketCommunicator_vtbl
{
  void (__fastcall *~WebSocketCommunicator)(WebSocketCommunicator *this);
  bool (__fastcall *shouldSerialize)(WebSocketCommunicator *this);
  void (__fastcall *onSerialize)(WebSocketCommunicator *this);
  void (__fastcall *onReceive)(WebSocketCommunicator *this, const RakWebSocketDataFrame *);
  void (__fastcall *onClose)(WebSocketCommunicator *this, CloseStatusCode, const std::string *);
  void (__fastcall *onConnected)(WebSocketCommunicator *this, const std::string *);
  void (__fastcall *onPostClosed)(WebSocketCommunicator *this);
};

# `WebSocketCommManager`

struct __cppobj WebSocketCommManager : AppPlatformListener, Bedrock::EnableNonOwnerReferences
{
  std::unordered_map<unsigned short,std::weak_ptr<WebSocketCommunicator>> mPortCommunicators;
  std::vector<std::weak_ptr<WebSocketCommunicator>> mCommunicators;
};

# `WebSocketCommManager_vtbl`

struct /*VFT*/ WebSocketCommManager_vtbl
{
  void (__fastcall *~AppPlatformListener)(AppPlatformListener *this);
  void (__fastcall *onLowMemory)(AppPlatformListener *this);
  void (__fastcall *onAppPaused)(AppPlatformListener *this);
  void (__fastcall *onAppUnpaused)(AppPlatformListener *this);
  void (__fastcall *onAppPreSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppResumed)(AppPlatformListener *this);
  void (__fastcall *onAppFocusLost)(AppPlatformListener *this);
  void (__fastcall *onAppFocusGained)(AppPlatformListener *this);
  void (__fastcall *onAppTerminated)(AppPlatformListener *this);
  void (__fastcall *onOperationModeChanged)(AppPlatformListener *this, const OperationMode);
  void (__fastcall *onPerformanceModeChanged)(AppPlatformListener *this, const bool);
  void (__fastcall *onPushNotificationReceived)(AppPlatformListener *this, const PushNotificationMessage *);
  void (__fastcall *onResizeBegin)(AppPlatformListener *this);
  void (__fastcall *onResizeEnd)(AppPlatformListener *this);
  void (__fastcall *onDeviceLost)(AppPlatformListener *this);
};

# `WebviewInterface`

struct __cppobj WebviewInterface : AppPlatformListener
{
  RectangleArea mRect;
  float mAlpha;
  std::string mUrl;
  bool mIsShown;
  bool mResizing;
  bool mIsLoaded;
  std::function<void __cdecl(std::string const &)> mMessageSender;
  std::unique_ptr<Core::Subject<WebviewObserver,Core::SingleThreadedLock>> mSubject;
};

# `WebviewInterface_vtbl`

struct /*VFT*/ WebviewInterface_vtbl
{
  void (__fastcall *~AppPlatformListener)(AppPlatformListener *this);
  void (__fastcall *onLowMemory)(AppPlatformListener *this);
  void (__fastcall *onAppPaused)(AppPlatformListener *this);
  void (__fastcall *onAppUnpaused)(AppPlatformListener *this);
  void (__fastcall *onAppPreSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppResumed)(AppPlatformListener *this);
  void (__fastcall *onAppFocusLost)(AppPlatformListener *this);
  void (__fastcall *onAppFocusGained)(AppPlatformListener *this);
  void (__fastcall *onAppTerminated)(AppPlatformListener *this);
  void (__fastcall *onOperationModeChanged)(AppPlatformListener *this, const OperationMode);
  void (__fastcall *onPerformanceModeChanged)(AppPlatformListener *this, const bool);
  void (__fastcall *onPushNotificationReceived)(AppPlatformListener *this, const PushNotificationMessage *);
  void (__fastcall *onResizeBegin)(AppPlatformListener *this);
  void (__fastcall *onResizeEnd)(AppPlatformListener *this);
  void (__fastcall *onDeviceLost)(AppPlatformListener *this);
  void (__fastcall *addObserver)(WebviewInterface *this, WebviewObserver *);
  void (__fastcall *clearObservers)(WebviewInterface *this);
  bool (__fastcall *isLoaded)(WebviewInterface *this);
  void (__fastcall *sendMessage)(WebviewInterface *this, const std::string *);
  void (__fastcall *setRect)(WebviewInterface *this, const RectangleArea *);
  void (__fastcall *setPropagatedAlpha)(WebviewInterface *this, float);
  void (__fastcall *setUrl)(WebviewInterface *this, const std::string *);
  void (__fastcall *setShowView)(WebviewInterface *this, bool);
};

# `WebviewSystem`

struct __cppobj WebviewSystem
{
  std::array<std::unordered_map<std::string,std::shared_ptr<WebviewInterface>>,2> mInterfaces;
  IMinecraftGame *mMinecraftGame;
  std::shared_ptr<Automation::AutomationSession> mAutomationSession;
};

# `WorldGenerator`

struct __cppobj WorldGenerator
{
  WorldGenerator_vtbl *__vftable /*VFT*/;
  std::unique_ptr<HardcodedSpawnAreaRegistry> mHardcodedSpawnTypes;
};

# `WorldGenerator_vtbl`

struct /*VFT*/ WorldGenerator_vtbl
{
  void (__fastcall *~WorldGenerator)(WorldGenerator *this);
  StructureFeatureType (__fastcall *getFeatureTypeAt)(WorldGenerator *this, const BlockPos *);
  bool (__fastcall *findNearestFeature)(WorldGenerator *this, StructureFeatureType, const BlockPos *, BlockPos *);
  void (__fastcall *prepareHeights)(WorldGenerator *this, BlockVolume *, const ChunkPos *, bool);
  BiomeArea *(__fastcall *getBiomeArea)(WorldGenerator *this, BiomeArea *result, const BoundingBox *, unsigned int);
  void (__fastcall *prepareAndComputeHeights)(WorldGenerator *this, BlockVolume *, const ChunkPos *, std::vector<short> *, bool, int);
  const Biome *(__fastcall *getBiomeAtPos)(WorldGenerator *this, int, int);
  int (__fastcall *getHeightAtPos)(WorldGenerator *this, int, int, int);
  BlockPos *(__fastcall *findSpawnPosition)(WorldGenerator *this, BlockPos *result);
  void (__fastcall *garbageCollectBlueprints)(WorldGenerator *this, buffer_span<ChunkPos>);
  void (__fastcall *debugRender)(WorldGenerator *this);
  void (__fastcall *addHardcodedSpawnAreas)(WorldGenerator *this, LevelChunk *);
};

# `Weather`

struct __cppobj Weather : LevelListener
{
  PerlinSimplexNoise mNoise;
  int mTick;
  float mORainLevel;
  float mRainLevel;
  float mTargetRainLevel;
  float mOLightningLevel;
  float mLightningLevel;
  float mTargetLightningLevel;
  float mFogLevel;
  int mSkyFlashTime;
  Dimension *mDimension;
};

# `WanderingTraderScheduler`

struct __cppobj WanderingTraderScheduler
{
  Level *mLevel;
  unsigned __int64 mTickToCheckIfSpawning;
  bool mSpawnWanderingTrader;
  int mDaysSinceLastSpawn;
  ActorUniqueID mWanderingTraderUUID;
};

# `WorldChangeTransaction::Data`

struct __cppobj WorldChangeTransaction::Data
{
  std::unordered_map<BlockPos,BlockChange> changes;
};

# `WeightedChoice<DefinitionTrigger>`

struct __cppobj __declspec(align(8)) WeightedChoice<DefinitionTrigger>
{
  DefinitionTrigger mValue;
  WeighedRandom::WeighedRandomItem mRandomItem;
};

# `WeightedChoices<DefinitionTrigger>`

struct __cppobj WeightedChoices<DefinitionTrigger>
{
  std::vector<WeightedChoice<DefinitionTrigger>> mChoices;
};

# `WaterMovementDescription`

struct __cppobj __declspec(align(8)) WaterMovementDescription : ComponentDescription
{
  float mDragFactor;
};

# `WaterMovementDescription_vtbl`

struct /*VFT*/ WaterMovementDescription_vtbl
{
  const char *(__fastcall *getJsonName)(Description *this);
  void (__fastcall *~Description)(Description *this);
  void (__fastcall *deserializeData)(Description *this, DeserializeDataParams);
  void (__fastcall *serializeData)(Description *this, Json::Value *);
};

# `Wireframe`

struct __cppobj Wireframe
{
  BlockPos mPos;
  BlockPos mBox;
  std::array<WireframeQuad,24> mQuadList;
};

# `WireframeQueue`

struct __cppobj WireframeQueue
{
  std::unordered_map<BlockPos,Wireframe> mQueue;
};

# `Webview::PlatformArguments`

struct __cppobj Webview::PlatformArguments
{
  std::function<void __cdecl(void)> dismissWebview;
  std::shared_ptr<ILessonProgressionService> lessonProgressionService;
};

# `WeakStorageSharePtr<PerlinSimplexNoise>`

struct __cppobj WeakStorageSharePtr<PerlinSimplexNoise>
{
  std::weak_ptr<PerlinSimplexNoise> mHandle;
};

# `WeakRefT<SharePtrRefTraits<PerlinSimplexNoise> >`

struct __cppobj WeakRefT<SharePtrRefTraits<PerlinSimplexNoise> > : WeakStorageSharePtr<PerlinSimplexNoise>
{
};

# `WebviewInterfaceOptions`

struct __cppobj WebviewInterfaceOptions
{
  bool createIfNotFound;
  _BYTE interfaceType[1];
  std::string interfaceKey;
};

# `WorldFileUploadManager`

struct __cppobj WorldFileUploadManager : FileUploadManager
{
  const Core::PathBuffer<std::string > mCachePathRoot;
  LevelListCache *mLevelListCache;
  const IContentAccessibilityProvider *mAccessibilityProvider;
};

# `WorldFileUploadManager_vtbl`

struct /*VFT*/ WorldFileUploadManager_vtbl
{
  void (__fastcall *~FileUploadManager)(FileUploadManager *this);
  float (__fastcall *getUploadProgress)(FileUploadManager *this);
  void (__fastcall *uploadFileToRealmStorage)(FileUploadManager *this, const std::string *, const Core::Path *, const std::string *);
};

# `WorldSection`

struct __cppobj WorldSection : PDPSection
{
  const StoreCatalogItem *mItem;
};

# `WorldSection_vtbl`

struct /*VFT*/ WorldSection_vtbl
{
  void (__fastcall *~PDPSection)(PDPSection *this);
  std::unique_ptr<ScreenController> *(__fastcall *makeScreenController)(PDPSection *this, std::unique_ptr<ScreenController> *result, std::shared_ptr<MainMenuScreenModel>);
};

# `WorldSeedCustom`

struct __cppobj WorldSeedCustom
{
  std::string mSeed;
};

# `WorldSeedDocument`

struct __cppobj WorldSeedDocument
{
  CommonDocument mCommon;
  WorldSeedCustom mCustom;
};

# `WorldSeedSearchResults`

const struct __cppobj WorldSeedSearchResults : CommonSearchResults
{
  std::vector<WorldSeedDocument> mDocuments;
};

# `WeighedRandom`

struct __cppobj WeighedRandom
{
};

# `WorldTemplateItem`

struct __cppobj __declspec(align(8)) WorldTemplateItem : ManifestContentItem
{
  std::string mWorldId;
  std::string mDate;
  GameType mGameType;
};

# `WorldTemplateItem_vtbl`

struct /*VFT*/ WorldTemplateItem_vtbl
{
  void (__fastcall *~ContentItem)(ContentItem *this);
};

# `WarpedForestMoodSoundPlayer`

struct __cppobj WarpedForestMoodSoundPlayer
{
};

# `WorldGenerationProgressHandler`

struct __cppobj WorldGenerationProgressHandler : ProgressHandler
{
  bool mCanceled;
  bool mLocalServer;
  std::function<void __cdecl(void)> mCallback;
};

# `WorldGenerationProgressHandler_vtbl`

struct /*VFT*/ WorldGenerationProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

# `WeaponItemComponent`

struct __cppobj WeaponItemComponent : ItemComponent
{
  DefinitionTrigger mOnHurtActor;
  DefinitionTrigger mOnHitActor;
  DefinitionTrigger mOnHitBlock;
};

# `WeaponItemComponent_vtbl`

struct /*VFT*/ WeaponItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

# `WearableItemComponent`

struct __cppobj __declspec(align(4)) WearableItemComponent : ItemComponent
{
  EquipmentSlot mEquipmentSlot;
  bool mIsDispensable;
};

# `WearableItemComponent_vtbl`

struct /*VFT*/ WearableItemComponent_vtbl
{
  void (__fastcall *~ItemComponent)(ItemComponent *this);
  bool (__fastcall *checkComponentDataForContentErrors)(ItemComponent *this);
  void (__fastcall *writeSettings)(ItemComponent *this);
  bool (__fastcall *useOn)(ItemComponent *this, ItemStack *, Actor *, const BlockPos *, unsigned __int8, const Vec3 *);
  bool (__fastcall *isNetworkComponent)(ItemComponent *this);
  std::unique_ptr<CompoundTag> *(__fastcall *buildNetworkTag)(ItemComponent *this, std::unique_ptr<CompoundTag> *result);
  void (__fastcall *initializeFromNetwork)(ItemComponent *this, const CompoundTag *);
};

# `WaitForLogoFinishStage`

struct __cppobj WaitForLogoFinishStage : BaseStage
{
};

# `WaitForLogoFinishStage_vtbl`

struct /*VFT*/ WaitForLogoFinishStage_vtbl
{
  void (__fastcall *~BaseStage)(BaseStage *this);
  void (__fastcall *onAwake)(BaseStage *this);
  void (__fastcall *onUpdate)(BaseStage *this);
  bool (__fastcall *ayncTask)(BaseStage *this);
};

# `WebviewSystem::_registerListeners::__l5::<lambda_c7c3dd2f0880099f3a4b730ab01286d8>`

struct __cppobj WebviewSystem::_registerListeners::__l5::<lambda_c7c3dd2f0880099f3a4b730ab01286d8>
{
  std::weak_ptr<WebviewInterface> weakInterface;
};

# `WebviewSystem::getInterface::__l8::<lambda_a5776f2afc713c36f65b673f9d507936>`

struct __cppobj WebviewSystem::getInterface::__l8::<lambda_a5776f2afc713c36f65b673f9d507936>
{
  IMinecraftGame *game;
};

# `WebViewRenderer`

struct __cppobj WebViewRenderer : MinecraftUICustomRenderer
{
  std::weak_ptr<WebviewInterface> mWebView;
};

# `WebViewRenderer_vtbl`

struct /*VFT*/ WebViewRenderer_vtbl
{
  void (__fastcall *~UICustomRenderer)(UICustomRenderer *this);
  void (__fastcall *preRenderSetup)(UICustomRenderer *this, UIRenderContext *);
  std::shared_ptr<UICustomRenderer> *(__fastcall *clone)(UICustomRenderer *this, std::shared_ptr<UICustomRenderer> *result);
  bool (__fastcall *update)(UICustomRenderer *this, IClientInstance *, UIControl *, const UIScene *);
  void (__fastcall *frameUpdate)(UICustomRenderer *this, UIFrameUpdateContext *, UIControl *);
  void (__fastcall *render)(UICustomRenderer *this, UIRenderContext *, IClientInstance *, UIControl *, int, RectangleArea *);
  UIBatchType (__fastcall *getBatchType)(UICustomRenderer *this);
  int (__fastcall *getCustomId)(UICustomRenderer *this);
  int (__fastcall *getNumRenderPasses)(UICustomRenderer *this);
  ResourceLocation *(__fastcall *getResourceLocation)(UICustomRenderer *this, ResourceLocation *result, int, int);
  UIMaterialType (__fastcall *getUIMaterialType)(UICustomRenderer *this, int);
  bool (__fastcall *getRequiresPreRenderSetup)(UICustomRenderer *this, int);
  void (__fastcall *onVisibilityChanged)(UICustomRenderer *this, bool);
  void (__fastcall *collectScreenEvents)(UICustomRenderer *this, std::queue<ScreenEvent> *);
  void (__fastcall *frameUpdate)(MinecraftUICustomRenderer *this, MinecraftUIFrameUpdateContext *, UIControl *);
  void (__fastcall *render)(MinecraftUICustomRenderer *this, MinecraftUIRenderContext *, IClientInstance *, UIControl *, int, RectangleArea *);
  void (__fastcall *preRenderSetup)(MinecraftUICustomRenderer *this, MinecraftUIRenderContext *);
};

# `WorldTemplatePurchaseScreenController`

struct __cppobj WorldTemplatePurchaseScreenController : MainMenuScreenController
{
  bool mWorldTemplateInstalled;
  bool mScrollButtonRelease;
  PanButtonState mPanState;
  float mUVx;
  const float mScrollSpeed;
  const StoreCatalogItem *mItem;
};

# `WorldTemplatePurchaseScreenController_vtbl`

struct /*VFT*/ WorldTemplatePurchaseScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WaitingHostStartGameProgressHandler`

struct __cppobj WaitingHostStartGameProgressHandler : EmptyProgressHandler
{
};

# `WaitingHostStartGameProgressHandler_vtbl`

struct /*VFT*/ WaitingHostStartGameProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

# `WorldCopyProgressHandler`

struct __cppobj WorldCopyProgressHandler : ProgressHandler
{
  std::string mLevelID;
  Core::PathBuffer<std::string > mNewWorldDir;
  std::future<int> mCopyingFuture;
  std::function<void __cdecl(LevelData &)> mSetDataCallback;
  std::function<void __cdecl(bool)> mOnCompleteCallback;
  std::atomic<float> mProgress;
  float mShownProgress;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStartTimestamp;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mLastTickTimestamp;
  std::unique_ptr<TaskGroup> mIOTaskGroup;
};

# `WorldCopyProgressHandler_vtbl`

struct /*VFT*/ WorldCopyProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

# `WorldProcessProgressHandler`

struct __cppobj WorldProcessProgressHandler : EmptyProgressHandler
{
  std::function<float __cdecl(void)> mOnTick;
  std::function<enum LoadingState __cdecl(void)> mGetLoadingStateCallback;
  float mProgress;
  WorldProcessProgressHandler::Type mType;
};

# `WorldProcessProgressHandler_vtbl`

struct /*VFT*/ WorldProcessProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

# `WorldVerificationProgressHandler`

struct __cppobj WorldVerificationProgressHandler : EmptyProgressHandler
{
  _BYTE mState[4];
  std::function<void __cdecl(enum WorldVerificationResult)> mCallback;
  std::unique_ptr<PackAccessStrategy> mLevelAccess;
  std::function<std::unique_ptr<PackAccessStrategy> __cdecl(void)> mCreateLevelAccess;
  std::unique_ptr<TaskGroup> mIOTaskGroup;
};

# `WorldVerificationProgressHandler_vtbl`

struct /*VFT*/ WorldVerificationProgressHandler_vtbl
{
  void (__fastcall *~ProgressHandler)(ProgressHandler *this);
  void (__fastcall *onStart)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *tick)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onCancel)(ProgressHandler *this, MinecraftScreenModel *);
  void (__fastcall *onExit)(ProgressHandler *this, MinecraftScreenModel *);
  LoadingState (__fastcall *getLoadingState)(ProgressHandler *this, MinecraftScreenModel *);
  float (__fastcall *getLoadingProgress)(ProgressHandler *this, MinecraftScreenModel *);
  std::string *(__fastcall *getProgressMessage)(ProgressHandler *this, std::string *result, MinecraftScreenModel *);
  void (__fastcall *addEventProperties)(ProgressHandler *this, std::unordered_map<std::string,std::string> *);
  std::string *(__fastcall *getTTSProgressMessage)(ProgressHandler *this, std::string *result);
  std::string *(__fastcall *getTitleText)(ProgressHandler *this, std::string *result);
  ProgressAnimation (__fastcall *showLoadingBar)(ProgressHandler *this);
};

# `WorldVerificationProgressHandler::onStart::__l2::<lambda_adb547aa2062cc1376b94f5e3560e9c0>`

struct __cppobj WorldVerificationProgressHandler::onStart::__l2::<lambda_adb547aa2062cc1376b94f5e3560e9c0>
{
  std::shared_ptr<bool> verificationResult;
  WorldVerificationProgressHandler *const __this;
  std::shared_ptr<gsl::final_action<std::function<void __cdecl(void)> > > finalCancel;
};

# `WorldVerificationProgressHandler::onStart::__l2::<lambda_4fdbaedc7006c3d7a5846f9954e28640>`

struct __cppobj WorldVerificationProgressHandler::onStart::__l2::<lambda_4fdbaedc7006c3d7a5846f9954e28640>
{
  WorldVerificationProgressHandler *const __this;
  std::shared_ptr<bool> verificationResult;
  std::shared_ptr<gsl::final_action<std::function<void __cdecl(void)> > > finalCancel;
};

# `WorldVerificationProgressHandler::onStart::__l2::<lambda_06100adbc30c35867a61be2f1a4502a8>`

struct __cppobj WorldVerificationProgressHandler::onStart::__l2::<lambda_06100adbc30c35867a61be2f1a4502a8>
{
  WorldVerificationProgressHandler *const __this;
};

# `WorldCopyProgressHandler::onStart::__l2::<lambda_35df25db3716e539e0ee1f9d82c604a8>`

struct __cppobj WorldCopyProgressHandler::onStart::__l2::<lambda_35df25db3716e539e0ee1f9d82c604a8>
{
  std::shared_ptr<std::promise<int> > promise;
  WorldCopyProgressHandler *const __this;
  MinecraftScreenModel *minecraftScreenModel;
};

# `WrittenBookItem`

struct __cppobj WrittenBookItem : Item
{
};

# `WorldTemplateUpsellObject`

struct __cppobj WorldTemplateUpsellObject
{
  std::unordered_map<std::string,std::shared_ptr<StoreVisualStyle>> mUpsellVisualStyle;
};

# `WorldSettingsScreenController`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController : SettingsScreenControllerBase, IWorldSettingsStorage, LevelLocationObserver
{
  SettingsScreenMode mSettingsMode;
  std::string mSeedString;
  std::string mRandomTickSpeedString;
  std::string mRespawnRadiusString;
  Core::PathBuffer<std::string > mWorldImagePath;
  LevelSummary mEditedLevel;
  LevelDataWrapper mLevelData;
  ExperimentStorage mOriginalExperiments;
  ContentManager *mContentManager;
  std::unique_ptr<DlcUIWrapper> mDlcUIWrapper;
  WorldMultiplayerLockState mMultiplayerState;
  std::unique_ptr<PlatformMultiplayerRestrictions> mPlatformMultiplayerRestrictions;
  PackManagerContentSource *mWorldContentSource;
  bool mLocalCheatsAllowed;
  int mLocalGameType;
  int mGameDifficulty;
  _BYTE mNetherType[1];
  SpawnSettings mSpawnSettings;
  bool mRefreshLevelData;
  bool mHackStatusVariableToTrackWorldCreationUntilWeFixInputBufferingOnUIStack;
  Realms::World mRealmWorld;
  const unsigned int TRIAL_SEED;
  bool mClassroomSettingsVisible;
  std::vector<int> mServerSimDistanceOptionValues;
  bool mHasRealms;
  std::vector<std::tuple<std::string,GameRule::Value>> mOriginalGameRuleValueCache;
  std::unique_ptr<ContentManagerContext> mContentManagerContext;
  std::unique_ptr<WorldSettingsScreenControllerProxy> mProxy;
  bool mChangeGameModeByWorld;
};

# `WorldMultiplayerLockState`

struct __cppobj WorldMultiplayerLockState : MultiplayerLockState
{
  LevelDataWrapper *mLevelData;
};

# `WorldMultiplayerLockState_vtbl`

struct /*VFT*/ WorldMultiplayerLockState_vtbl
{
  void (__fastcall *~MultiplayerLockState)(MultiplayerLockState *this);
  bool (__fastcall *isLocked)(MultiplayerLockState *this);
  void (__fastcall *setLockedByBehaviorPack)(MultiplayerLockState *this, bool);
  void (__fastcall *setLockedByResourcePack)(MultiplayerLockState *this, bool);
};

# `WorldSettingsScreenControllerProxyCallbacks`

const struct __cppobj WorldSettingsScreenControllerProxyCallbacks
{
  std::function<LevelData & __cdecl(void)> mGetLevelData;
  std::function<void __cdecl(std::function<void __cdecl(bool)>)> mCreateWorld;
  std::function<LevelSummary const & __cdecl(void)> mGetLevelSummary;
};

# `WorldSettingsScreenControllerProxy`

struct __cppobj WorldSettingsScreenControllerProxy
{
  const WorldSettingsScreenControllerProxyCallbacks mCallbacks;
};

# `WorldSettingsScreenController_vtbl`

struct /*VFT*/ WorldSettingsScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
  void (__fastcall *_registerControllerCallbacks)(WorldSettingsScreenController *this);
};

# `WorldContentItem`

struct __cppobj __declspec(align(8)) WorldContentItem : ContentItem
{
  std::string mWorldId;
  Core::PathBuffer<std::string > mIconPath;
  std::string mDate;
  __int64 mLastUsed;
  GameType mGameType;
};

# `WorldContentItem_vtbl`

struct /*VFT*/ WorldContentItem_vtbl
{
  void (__fastcall *~ContentItem)(ContentItem *this);
};

# `Win10TrialConversionScreenController`

struct __cppobj __declspec(align(8)) Win10TrialConversionScreenController : MinecraftScreenController
{
  bool mIsFirstTick;
};

# `Win10TrialConversionScreenController_vtbl`

struct /*VFT*/ Win10TrialConversionScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WorldConversionCompleteModel`

struct __cppobj WorldConversionCompleteModel : MainMenuScreenModel
{
  LocalWorldInfo mWorldInfo;
};

# `WorldConversionCompleteModel_vtbl`

struct /*VFT*/ WorldConversionCompleteModel_vtbl
{
  void (__fastcall *~IDlcBatcher)(IDlcBatcher *this);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<PackIdVersion> *);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<std::string> *);
  IDlcBatchModel *(__fastcall *getDlcBatchModel)(IDlcBatcher *this, const std::vector<DlcId> *);
};

# `WorldConversionCompleteScreenController`

struct __cppobj WorldConversionCompleteScreenController : MainMenuScreenController
{
  std::shared_ptr<WorldConversionCompleteModel> mWorldConversionCompleteModel;
  std::unique_ptr<DlcUIWrapper> mDlcUIWrapper;
  std::function<void __cdecl(void)> mCancelCallback;
};

# `WorldConversionCompleteScreenController_vtbl`

struct /*VFT*/ WorldConversionCompleteScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WorldConversionErrorReportScreenController`

struct __cppobj __declspec(align(4)) WorldConversionErrorReportScreenController : MainMenuScreenController
{
  std::unique_ptr<LegacyWorldInfo> mUploadedWorldInfo;
  std::shared_ptr<PlayScreenModel> mPlayScreenModel;
  _BYTE mErrorReason[4];
  bool mReportReasonDropDownActive;
  float mUploadProgressValue;
  bool mUploadFromFailedConversion;
};

# `WorldConversionErrorReportScreenController_vtbl`

struct /*VFT*/ WorldConversionErrorReportScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WorldSeedCatalogScreenController`

struct __cppobj WorldSeedCatalogScreenController : MainMenuScreenController
{
  std::function<void __cdecl(std::string const &,std::string const &,Core::Path const &)> mCloseCallback;
  std::string mFilter;
};

# `WorldSeedCatalogScreenController_vtbl`

struct /*VFT*/ WorldSeedCatalogScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WorldPackManagerContentSource`

struct __cppobj WorldPackManagerContentSource : PackManagerContentSource
{
  std::string mWorldId;
};

# `WorldPackManagerContentSource_vtbl`

struct /*VFT*/ WorldPackManagerContentSource_vtbl
{
  void (__fastcall *~ContentSource)(ContentSource *this);
  void (__fastcall *load)(ContentSource *this);
  void (__fastcall *generateItems)(ContentSource *this, std::vector<std::unique_ptr<ContentItem>> *);
  void (__fastcall *save)(ContentSource *this);
  void (__fastcall *deleteContentFiles)(ContentSource *this, std::vector<ContentItem const *>);
  void (__fastcall *postDeleteContent)(ContentSource *this, std::vector<ContentItem const *>);
};

# `WorldTemplatesScreenController`

struct __cppobj WorldTemplatesScreenController : MainMenuScreenController
{
  std::shared_ptr<PlayScreenModel> mPlayScreenModel;
  std::unique_ptr<DlcUIWrapper> mDlcUIWrapper;
  std::string mFilter;
  InvalidPacksFilterGroup mInvalidPacksFilter;
  std::vector<ResourceLocation> mInvalidPacks;
  std::vector<ResourceLocation> mLoadingPacks;
  std::vector<WorldTemplateInfo> mPremiumTemplates;
  std::vector<WorldTemplateInfo> mCustomTemplates;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mLocalTemplateUpdateTime;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mUpdateTime;
  CreateWorldOrRealm mType;
  bool mHideTopBar;
  std::unique_ptr<PlatformMultiplayerRestrictions> mPlatformMultiplayerRestrictions;
};

# `WorldTemplatesScreenController_vtbl`

struct /*VFT*/ WorldTemplatesScreenController_vtbl
{
  void (__fastcall *~IScreenController)(IScreenController *this);
  ui::DirtyFlag (__fastcall *tick)(IScreenController *this);
  ui::ViewRequest (__fastcall *handleEvent)(IScreenController *this, ScreenEvent *);
  std::optional<std::string > *(__fastcall *getRoute)(IScreenController *this, std::optional<std::string > *result);
  void (__fastcall *setScreenState)(IScreenController *this, const std::vector<std::pair<std::string,std::string >> *);
  void (__fastcall *onOpen)(ScreenController *this);
  void (__fastcall *onTerminate)(ScreenController *this);
  void (__fastcall *onInit)(ScreenController *this);
  void (__fastcall *onDelete)(ScreenController *this);
  bool (__fastcall *canExit)(ScreenController *this);
  ui::ViewRequest (__fastcall *tryExit)(ScreenController *this);
  bool (__fastcall *areControllerTabsEnabled)(ScreenController *this);
  void (__fastcall *onCreation)(ScreenController *this);
  void (__fastcall *logCreationTime)(ScreenController *this, const std::string *, long double, long double, unsigned __int8);
  void (__fastcall *onLeave)(ScreenController *this);
  void (__fastcall *leaveScreen)(ScreenController *this);
  ui::DirtyFlag (__fastcall *handleGameEventNotification)(ScreenController *this, ui::GameEventNotification);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  bool (__fastcall *bind)(ScreenController *this, const std::string *, unsigned int, int, const std::string *, unsigned int, const std::string *, UIPropertyBag *);
  void (__fastcall *handleLicenseChanged)(ScreenController *this);
  void (__fastcall *onDictationEvent)(ScreenController *this, const std::string *);
  void (__fastcall *setAssociatedBlockPos)(ScreenController *this, const BlockPos *);
  void (__fastcall *setAssociatedEntityUniqueID)(ScreenController *this, const ActorUniqueID);
  void (__fastcall *setSuspendInput)(ScreenController *this, bool);
  float (__fastcall *getCallbackInterval)(ScreenController *this);
  void (__fastcall *onRender)(ScreenController *this);
  void (__fastcall *addStaticScreenVars)(ScreenController *this, Json::Value *);
  std::string *(__fastcall *getAdditionalScreenInfo)(ScreenController *this, std::string *result);
  std::string *(__fastcall *getTelemetryOverride)(ScreenController *this, std::string *result);
  void (__fastcall *addEventProperties)(ScreenController *this, std::unordered_map<std::string,std::string> *);
  ui::SceneType (__fastcall *getSceneType)(ScreenController *this);
  int (__fastcall *getScreenVersion)(ScreenController *this);
  bool (__fastcall *screenHandlesGamepadMenuButton)(ScreenController *this);
  ScreenControllerProxy *(__fastcall *getProxy)(ScreenController *this);
  void (__fastcall *onEntered)(ScreenController *this);
  unsigned int (__fastcall *getNameId)(ScreenController *this, const std::string *);
  bool (__fastcall *verifySceneStack)(ScreenController *this, SceneStack *);
  bool (__fastcall *_doesScreenHaveExitBehavior)(ScreenController *this);
  bool (__fastcall *_isStillValid)(MinecraftScreenController *this);
  bool (__fastcall *_getGamepadHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getMixedHelperVisible)(MinecraftScreenController *this);
  bool (__fastcall *_getKeyboardHelperVisible)(MinecraftScreenController *this);
  std::string *(__fastcall *_getButtonADescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonBDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonXDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonYDescription)(MinecraftScreenController *this, std::string *result);
  std::string *(__fastcall *_getButtonKeyboardDescription)(MinecraftScreenController *this, std::string *result);
};

# `WorldTemplatesScreenControllerProxyCallbacks`

struct __cppobj WorldTemplatesScreenControllerProxyCallbacks
{
  std::function<void __cdecl(void)> mSelectWorldTab;
  std::function<void __cdecl(void)> mSelectRealmsTab;
  std::function<void __cdecl(void)> mForceUIUpdate;
  std::function<void __cdecl(PackIdVersion const &,std::function<void __cdecl(bool)>)> mCreateWorldTemplate;
};

# `WorldTemplatesScreenControllerProxy`

struct __cppobj WorldTemplatesScreenControllerProxy : ScreenControllerProxy
{
  const WorldTemplatesScreenControllerProxyCallbacks mCallbacks;
};

# `WorldTemplatesScreenControllerProxy_vtbl`

struct /*VFT*/ WorldTemplatesScreenControllerProxy_vtbl
{
  void (__fastcall *~ScreenControllerProxy)(ScreenControllerProxy *this);
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_15bde1405d93312a3df1be1be7dfd859>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_15bde1405d93312a3df1be1be7dfd859>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_15bde1405d93312a3df1be1be7dfd859>::()::__l2::<lambda_495f393510b454ef8563eed9a133ba94>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_15bde1405d93312a3df1be1be7dfd859>::()::__l2::<lambda_495f393510b454ef8563eed9a133ba94>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_a300d134aef25fdb0a42dc9c3988b555>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_a300d134aef25fdb0a42dc9c3988b555>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_a300d134aef25fdb0a42dc9c3988b555>::()::__l2::<lambda_c94db62633ec92a9edadf0c2e3fc2512>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_a300d134aef25fdb0a42dc9c3988b555>::()::__l2::<lambda_c94db62633ec92a9edadf0c2e3fc2512>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_e5341a64e09e4a69087242a289aef5ac>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_e5341a64e09e4a69087242a289aef5ac>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_f6e75f181340843b5bf04b989044f2f6>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_f6e75f181340843b5bf04b989044f2f6>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_4c59165e12e948b2f3dc267743cc4536>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_4c59165e12e948b2f3dc267743cc4536>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_fca24cd9080ea1c283bff39464b865aa>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_fca24cd9080ea1c283bff39464b865aa>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_fca24cd9080ea1c283bff39464b865aa>::()::__l10::<lambda_641b9c283e0e61c992dc2bbf06843bbe>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_fca24cd9080ea1c283bff39464b865aa>::()::__l10::<lambda_641b9c283e0e61c992dc2bbf06843bbe>
{
  std::weak_ptr<WorldTemplatesScreenController> weakThis;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_c82335fd1d8bab14ec8b416ff3685b1f>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_c82335fd1d8bab14ec8b416ff3685b1f>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_edcbed0e3f42203445918c7695c8684b>`

struct __cppobj WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_edcbed0e3f42203445918c7695c8684b>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_handleWorldTemplateClicked::__l16::<lambda_47b05781028e198ff8db060dc9c6a924>`

struct __cppobj WorldTemplatesScreenController::_handleWorldTemplateClicked::__l16::<lambda_47b05781028e198ff8db060dc9c6a924>
{
  WorldTemplatesScreenController *const __this;
  PackIdVersion packId;
};

# `WorldTemplatesScreenController::_handleWorldTemplateClicked::__l16::<lambda_47b05781028e198ff8db060dc9c6a924>::()::__l2::<lambda_759265847208c03bbcb92c4dc6bd0d62>`

struct __cppobj WorldTemplatesScreenController::_handleWorldTemplateClicked::__l16::<lambda_47b05781028e198ff8db060dc9c6a924>::()::__l2::<lambda_759265847208c03bbcb92c4dc6bd0d62>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_handleWorldTemplateClicked::__l12::<lambda_f396619481102bcab0a3babc671c4482>`

struct __cppobj WorldTemplatesScreenController::_handleWorldTemplateClicked::__l12::<lambda_f396619481102bcab0a3babc671c4482>
{
  WorldTemplatesScreenController *const __this;
  mce::UUID packId;
};

# `WorldTemplatesScreenController::_handleWorldTemplateClicked::__l5::<lambda_782bee5336780a230b726c9bcb2e02ae>`

struct __cppobj WorldTemplatesScreenController::_handleWorldTemplateClicked::__l5::<lambda_782bee5336780a230b726c9bcb2e02ae>
{
  WorldTemplatesScreenController *const __this;
  mce::UUID templateId;
};

# `WorldTemplatesScreenController::_handleWorldTemplateClicked::__l5::<lambda_782bee5336780a230b726c9bcb2e02ae>::()::__l5::<lambda_e4a9e7cbc2158babb6aeec6a29c907c6>`

struct __cppobj WorldTemplatesScreenController::_handleWorldTemplateClicked::__l5::<lambda_782bee5336780a230b726c9bcb2e02ae>::()::__l5::<lambda_e4a9e7cbc2158babb6aeec6a29c907c6>
{
  WorldTemplatesScreenController *const __this;
  mce::UUID templateId;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3a44d8b665c132244db1baef2c7cc727>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3a44d8b665c132244db1baef2c7cc727>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_34725ab0d67fbdb6fce6ca7d15065707>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_34725ab0d67fbdb6fce6ca7d15065707>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_78177a589e725e17b6fa389aa95d2782>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_78177a589e725e17b6fa389aa95d2782>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_640962ff5634875b9a3cf6cedbf2b519>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_640962ff5634875b9a3cf6cedbf2b519>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_9c7e4e430f4a3b9f6fd68397e190fed4>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_9c7e4e430f4a3b9f6fd68397e190fed4>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_5158863dc59cf21b2cba3808fc7ec56d>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_5158863dc59cf21b2cba3808fc7ec56d>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_87e074210e62266a96ba5b12589200bf>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_87e074210e62266a96ba5b12589200bf>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3065f6280db6f18182c91255e23e0385>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3065f6280db6f18182c91255e23e0385>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_ccb29b43b50a179721c770ace39c50bf>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_ccb29b43b50a179721c770ace39c50bf>
{
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_5cf5c0854560699179d82ac12551b8a5>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_5cf5c0854560699179d82ac12551b8a5>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_9f7134ba2ff0829ae09a4ad319837442>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_9f7134ba2ff0829ae09a4ad319837442>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0af617756eb4c002734a9f1054408fb5>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0af617756eb4c002734a9f1054408fb5>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_1de2306644fd10209b2c91a588e25a6e>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_1de2306644fd10209b2c91a588e25a6e>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3becea58401d5379d41574e872fd45a9>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3becea58401d5379d41574e872fd45a9>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_8fa673a600bac07a1bb2604ce1ca4bfb>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_8fa673a600bac07a1bb2604ce1ca4bfb>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0593823d0526b824701b58a2f62d676c>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0593823d0526b824701b58a2f62d676c>
{
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_e3b17f17831100dc456ba83db964d13d>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_e3b17f17831100dc456ba83db964d13d>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_08120abc77bc9e045600cb340b2edcda>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_08120abc77bc9e045600cb340b2edcda>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_b522aa0cb8d5a5a9c4b3b3bfbebe3a9d>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_b522aa0cb8d5a5a9c4b3b3bfbebe3a9d>
{
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_f0a8a9bbade2bb5c7812179588e32890>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_f0a8a9bbade2bb5c7812179588e32890>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_545a2c9e2a7ffdcf7f8d74b5c11fa6b4>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_545a2c9e2a7ffdcf7f8d74b5c11fa6b4>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_f309d3c05ecb534888d235334c559b34>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_f309d3c05ecb534888d235334c559b34>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_7a6deed5ed8b8737b1b5a41e86364d2d>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_7a6deed5ed8b8737b1b5a41e86364d2d>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3eb5427e76194db577d2873d3f4c9783>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_3eb5427e76194db577d2873d3f4c9783>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0159f45a942618d2fef863da4224d5e5>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_0159f45a942618d2fef863da4224d5e5>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_4f5a29197254e16b95a5c8c96bcc8221>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_4f5a29197254e16b95a5c8c96bcc8221>
{
};

# `WorldTemplatesScreenController::_registerBindings::__l2::<lambda_68799d5cc8a8f29afd3e49508ece1840>`

struct __cppobj WorldTemplatesScreenController::_registerBindings::__l2::<lambda_68799d5cc8a8f29afd3e49508ece1840>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::{ctor}::__l2::<lambda_db894f261925c9bcc60c9c041c5f1230>`

struct __cppobj WorldTemplatesScreenController::{ctor}::__l2::<lambda_db894f261925c9bcc60c9c041c5f1230>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::{ctor}::__l2::<lambda_37fb335652ba464f176dc5c3a1702881>`

struct __cppobj WorldTemplatesScreenController::{ctor}::__l2::<lambda_37fb335652ba464f176dc5c3a1702881>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::{ctor}::__l2::<lambda_642b3733ab42d31c075d1b6438f4de46>`

struct __cppobj WorldTemplatesScreenController::{ctor}::__l2::<lambda_642b3733ab42d31c075d1b6438f4de46>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldTemplatesScreenController::{ctor}::__l2::<lambda_90a7b1902042af3147a66f861f1dfa1f>`

struct __cppobj WorldTemplatesScreenController::{ctor}::__l2::<lambda_90a7b1902042af3147a66f861f1dfa1f>
{
  WorldTemplatesScreenController *const __this;
};

# `WorldSettingsScreenController::_displayLockedWorldPopup::__l2::<lambda_173ef6296c201b1292fcfbae130825f7>`

struct __cppobj WorldSettingsScreenController::_displayLockedWorldPopup::__l2::<lambda_173ef6296c201b1292fcfbae130825f7>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_confirmationUnlockTemplatedWorldOptionsDialog::__l2::<lambda_baf5f62973d04979dc29e0728b7ad771>`

struct __cppobj WorldSettingsScreenController::_confirmationUnlockTemplatedWorldOptionsDialog::__l2::<lambda_baf5f62973d04979dc29e0728b7ad771>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_chooseUGCLevelSeed::__l10::<lambda_2d67d20f34504dd6f79914336c234396>`

struct __cppobj WorldSettingsScreenController::_chooseUGCLevelSeed::__l10::<lambda_2d67d20f34504dd6f79914336c234396>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>
{
  WorldSettingsScreenController *const __this;
  PostCreateWorldAction postCreateWorldAction;
};

# `WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_d14c3a83ba7049c63e120071c60071ee>::()::__l8::<lambda_9142f0241868cd513e9ce82a1fc112d9>`

struct __cppobj WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_d14c3a83ba7049c63e120071c60071ee>::()::__l8::<lambda_9142f0241868cd513e9ce82a1fc112d9>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_e7b026eda446f274701718f9837342db>::()::__l5::<lambda_4c03a6c0ed8e907545d59f525edbd667>`

struct __cppobj WorldSettingsScreenController::_createWorld::__l50::<lambda_e7b026eda446f274701718f9837342db>::()::__l5::<lambda_4c03a6c0ed8e907545d59f525edbd667>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  LevelSettings levelSettings;
  const std::string levelId;
};

# `WorldSettingsScreenController::_createWorld::__l2::<lambda_87763a2d219bbe28dce3f352000fa863>`

struct __cppobj WorldSettingsScreenController::_createWorld::__l2::<lambda_87763a2d219bbe28dce3f352000fa863>
{
  WorldSettingsScreenController *const __this;
  bool *isLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_createWorldOnRealms::__l2::<lambda_99f78dbe45f864d7a33619e899f39dee>`

struct __cppobj WorldSettingsScreenController::_createWorldOnRealms::__l2::<lambda_99f78dbe45f864d7a33619e899f39dee>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_createWorldOnRealms::__l2::<lambda_99f78dbe45f864d7a33619e899f39dee>::()::__l5::<lambda_a191e661b70a838610d7fa22ab85031b>`

struct __cppobj WorldSettingsScreenController::_createWorldOnRealms::__l2::<lambda_99f78dbe45f864d7a33619e899f39dee>::()::__l5::<lambda_a191e661b70a838610d7fa22ab85031b>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>`

struct __cppobj WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>::()::__l2::<lambda_a85288b5e16bc814284b308b5d9f1ba7>`

struct __cppobj WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>::()::__l2::<lambda_a85288b5e16bc814284b308b5d9f1ba7>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>::()::__l2::<lambda_a85288b5e16bc814284b308b5d9f1ba7>::()::__l5::<lambda_c7aae57c9fc8c9a6e1f0804c317ad2a5>`

struct __cppobj WorldSettingsScreenController::_playWorldOnRealms::__l2::<lambda_712309b5bb90b5dc77e4338034b9eb52>::()::__l2::<lambda_a85288b5e16bc814284b308b5d9f1ba7>::()::__l5::<lambda_c7aae57c9fc8c9a6e1f0804c317ad2a5>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  Realms::World world;
};

# `WorldSettingsScreenController::_selectRealm::__l2::<lambda_9b881d973bcc00d75758c36dc09d0b2f>`

struct __cppobj WorldSettingsScreenController::_selectRealm::__l2::<lambda_9b881d973bcc00d75758c36dc09d0b2f>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  std::function<void __cdecl(Realms::World)> callback;
};

# `WorldSettingsScreenController::_selectRealm::__l2::<lambda_9b881d973bcc00d75758c36dc09d0b2f>::()::__l13::<lambda_42038c5869d685e8bfdea285465e0fea>`

struct __cppobj WorldSettingsScreenController::_selectRealm::__l2::<lambda_9b881d973bcc00d75758c36dc09d0b2f>::()::__l13::<lambda_42038c5869d685e8bfdea285465e0fea>
{
  std::function<void __cdecl(Realms::World)> callback;
  Realms::World world;
};

# `WorldSettingsScreenController::_setHasUserRealms::__l2::<lambda_16c7589638352e00aaeaaff961713c5e>`

struct __cppobj WorldSettingsScreenController::_setHasUserRealms::__l2::<lambda_16c7589638352e00aaeaaff961713c5e>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_playWorld::__l5::<lambda_8377b8a57cf65de5e597aea48859750f>`

struct __cppobj WorldSettingsScreenController::_playWorld::__l5::<lambda_8377b8a57cf65de5e597aea48859750f>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_playWorld::__l5::<lambda_8377b8a57cf65de5e597aea48859750f>::()::__l5::<lambda_b724450337eb0f57a543856da6c57667>`

struct __cppobj WorldSettingsScreenController::_playWorld::__l5::<lambda_8377b8a57cf65de5e597aea48859750f>::()::__l5::<lambda_b724450337eb0f57a543856da6c57667>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>::()::__l2::<lambda_6973b209eecf58a062dcf5a8f6c0e009>`

struct __cppobj WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>::()::__l2::<lambda_6973b209eecf58a062dcf5a8f6c0e009>
{
  std::vector<PackContentItem *> *modelList;
};

# `WorldSettingsScreenController::_showConfirmationNoCrossPlatformPlaySkinPopup::__l2::<lambda_2a90a3fabe1d8ae963be46b4effca371>`

struct __cppobj WorldSettingsScreenController::_showConfirmationNoCrossPlatformPlaySkinPopup::__l2::<lambda_2a90a3fabe1d8ae963be46b4effca371>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_setAllowCheats::__l2::<lambda_9c7eb6ec46d54dbb9bdf13645eee42cc>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setAllowCheats::__l2::<lambda_9c7eb6ec46d54dbb9bdf13645eee42cc>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  bool value;
};

# `WorldSettingsScreenController::_setWorldType::__l2::<lambda_f4dadbb0e07b0c2a05aa034f3695ede8>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setWorldType::__l2::<lambda_f4dadbb0e07b0c2a05aa034f3695ede8>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  int value;
};

# `WorldSettingsScreenController::_setDefaultPermissionLevel::__l2::<lambda_73dc612562d122327af7512de26e4d3a>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setDefaultPermissionLevel::__l2::<lambda_73dc612562d122327af7512de26e4d3a>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  PlayerPermissionLevel newPermission;
};

# `WorldSettingsScreenController::_setPlayerGameMode::__l2::<lambda_b368b09ffc004d6539b7f6e455e25abb>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setPlayerGameMode::__l2::<lambda_b368b09ffc004d6539b7f6e455e25abb>
{
  std::weak_ptr<MainMenuScreenModel> weakModel;
  int value;
};

# `WorldSettingsScreenController::_setWorldGameMode::__l2::<lambda_879e50cd05e3cdecd1e9f87bef463403>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setWorldGameMode::__l2::<lambda_879e50cd05e3cdecd1e9f87bef463403>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  int value;
};

# `WorldSettingsScreenController::_copyAndSetDataHelper::__l2::<lambda_4dfb27d400bac5924496852fbe1c0029>`

struct __cppobj WorldSettingsScreenController::_copyAndSetDataHelper::__l2::<lambda_4dfb27d400bac5924496852fbe1c0029>
{
  WorldSettingsScreenController *const __this;
  bool *bIsLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_setEducationFeaturesEnabled::__l15::<lambda_9082511de3fe49688c8050fc21a58fdc>`

struct __cppobj WorldSettingsScreenController::_setEducationFeaturesEnabled::__l15::<lambda_9082511de3fe49688c8050fc21a58fdc>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_setEducationFeaturesEnabled::__l15::<lambda_9082511de3fe49688c8050fc21a58fdc>::()::__l5::<lambda_2a99ebb72af9f461534a122213d3a47e>`

struct __cppobj WorldSettingsScreenController::_setEducationFeaturesEnabled::__l15::<lambda_9082511de3fe49688c8050fc21a58fdc>::()::__l5::<lambda_2a99ebb72af9f461534a122213d3a47e>
{
  std::shared_ptr<WorldSettingsScreenController> sharedThis;
};

# `WorldSettingsScreenController::_setEducationFeaturesEnabled::__l8::<lambda_c567241b6062bc2af1c596074b715b1a>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setEducationFeaturesEnabled::__l8::<lambda_c567241b6062bc2af1c596074b715b1a>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  bool value;
};

# `WorldSettingsScreenController::_setExperimentalToggleHelper::__l29::<lambda_b8512a3849e21e0d634b5d897a7ac42b>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setExperimentalToggleHelper::__l29::<lambda_b8512a3849e21e0d634b5d897a7ac42b>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  int experimentIndex;
};

# `WorldSettingsScreenController::_setExperimentalToggleHelper::__l29::<lambda_b8512a3849e21e0d634b5d897a7ac42b>::()::__l5::<lambda_5fb6a9080b91efb4decd6c22dabb9222>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_setExperimentalToggleHelper::__l29::<lambda_b8512a3849e21e0d634b5d897a7ac42b>::()::__l5::<lambda_5fb6a9080b91efb4decd6c22dabb9222>
{
  std::shared_ptr<WorldSettingsScreenController> sharedThis;
  int experimentIndex;
};

# `WorldSettingsScreenController::_setExperimentalToggleHelper::__l17::<lambda_5806fb615e5b3e68d177b796601ba6f5>`

struct __cppobj WorldSettingsScreenController::_setExperimentalToggleHelper::__l17::<lambda_5806fb615e5b3e68d177b796601ba6f5>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  bool value;
  int experimentIndex;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a9b1c7bd1a42b0183ad5c4347d03afa6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a9b1c7bd1a42b0183ad5c4347d03afa6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_97cd1bdcdd8f173df23e76c1437b4ee8>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_97cd1bdcdd8f173df23e76c1437b4ee8>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_75ddff90839059816e6769c8243cf02a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_75ddff90839059816e6769c8243cf02a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bd461f03d7da724edc2eab84ac906b19>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bd461f03d7da724edc2eab84ac906b19>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9e14c8efcde3698f2b6a072a15f3489e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9e14c8efcde3698f2b6a072a15f3489e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_069428437e140a84366ba552c78983e0>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_069428437e140a84366ba552c78983e0>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1f4d006b1d819de6bef51bec3646f442>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1f4d006b1d819de6bef51bec3646f442>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e8dbe4ce17a52c8db7f2ce26e3c57dac>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e8dbe4ce17a52c8db7f2ce26e3c57dac>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9c28e512f7fa1d661fa1b942e828b4b0>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9c28e512f7fa1d661fa1b942e828b4b0>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5c9af6e0f941cf4e38faf85d399da6e9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5c9af6e0f941cf4e38faf85d399da6e9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_29132fea63317dc9fd59cbab0a7ec59a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_29132fea63317dc9fd59cbab0a7ec59a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d0c85c6fa4c5bfc4056fa000cb77be94>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d0c85c6fa4c5bfc4056fa000cb77be94>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_01e301e1030a113416ce524e7982179e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_01e301e1030a113416ce524e7982179e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a58d8c13fd2543097860a6f98bfaff8f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a58d8c13fd2543097860a6f98bfaff8f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_66ab453e69415c374907047e67613160>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_66ab453e69415c374907047e67613160>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_317cdfd81e5c51c620f480cabb71349a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_317cdfd81e5c51c620f480cabb71349a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d0092b0ab1e33fb69cddf3f44fe18ff>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d0092b0ab1e33fb69cddf3f44fe18ff>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_20f926de56ff08ddcb32cd9b7dfa063b>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_20f926de56ff08ddcb32cd9b7dfa063b>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_94815f08471d0a0e9e544a3839a9ab4e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_94815f08471d0a0e9e544a3839a9ab4e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fc5f224f82f681a05a90590a28eadee5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fc5f224f82f681a05a90590a28eadee5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_497eed35761d8f849ff5ea63713830a6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_497eed35761d8f849ff5ea63713830a6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_647cebb51a755d8b0fae1d9b3f8ea8e4>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_647cebb51a755d8b0fae1d9b3f8ea8e4>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_37fe3c09cfc692b59e47abff4d82bf61>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_37fe3c09cfc692b59e47abff4d82bf61>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cfee2fc5f111d196b4c2a83cc6eaed69>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cfee2fc5f111d196b4c2a83cc6eaed69>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c61e4787d8683119f87b2ccebe30b06d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c61e4787d8683119f87b2ccebe30b06d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_34c24d778cf481469cad1d10d5805681>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_34c24d778cf481469cad1d10d5805681>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ee357b98516fc54492a4be3961fd8b40>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ee357b98516fc54492a4be3961fd8b40>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a4cd96df66181e4981b4856cabcf1047>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a4cd96df66181e4981b4856cabcf1047>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_eb1c0be5d7f04577a3dcaa5365f73f48>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_eb1c0be5d7f04577a3dcaa5365f73f48>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_27e9a14110c16faca08969520d2da584>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_27e9a14110c16faca08969520d2da584>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_21b091d0d9828b9535c828e18996f007>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_21b091d0d9828b9535c828e18996f007>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ef60c97fd4dda154065ae8f34ae1ae1a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ef60c97fd4dda154065ae8f34ae1ae1a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b04f73af0925f8ae0a2b01971b88a58d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b04f73af0925f8ae0a2b01971b88a58d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_21b091d0d9828b9535c828e18996f007>::()::__l13::<lambda_cea2f3513bb60944c8e5dff037d4f7b7>`

struct __cppobj __declspec(align(8)) WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_21b091d0d9828b9535c828e18996f007>::()::__l13::<lambda_cea2f3513bb60944c8e5dff037d4f7b7>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
  bool optionValue;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_e4eb26d9b2b962f04d5f3ab7d7d16d60>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_e4eb26d9b2b962f04d5f3ab7d7d16d60>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_5c88f7d711940d1280d900f5806cabe2>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_5c88f7d711940d1280d900f5806cabe2>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_03604204b4cf0d716d11f60159f95c20>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l15::<lambda_03604204b4cf0d716d11f60159f95c20>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a278e2e1a694beefac10aa16b4da47bc>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a278e2e1a694beefac10aa16b4da47bc>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_33473c4eaef04a3275ee53c726aaaec9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_33473c4eaef04a3275ee53c726aaaec9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5e0850e65c0b127647c36c30b42d25e4>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5e0850e65c0b127647c36c30b42d25e4>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5f103b5cccac53e92fdfbb8f4d442da7>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5f103b5cccac53e92fdfbb8f4d442da7>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_47ee35fce642f684aef6f5407318620f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_47ee35fce642f684aef6f5407318620f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d8fc7182575b3b94491e11831e311bfb>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d8fc7182575b3b94491e11831e311bfb>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_df1e611e209410e9ce90316ae4ec233e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_df1e611e209410e9ce90316ae4ec233e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_66d3db383d9c56d95f7923c17a35e97a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_66d3db383d9c56d95f7923c17a35e97a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ed920ffffcd732374c9abe9cc6e9bce0>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ed920ffffcd732374c9abe9cc6e9bce0>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e10bbcb710d317b0de664c2373e32dbf>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e10bbcb710d317b0de664c2373e32dbf>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_50c8ede2ecbcdb0ba1423d07b9d4e4c2>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_50c8ede2ecbcdb0ba1423d07b9d4e4c2>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_585072c5789292fe81b455a2ba912adb>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_585072c5789292fe81b455a2ba912adb>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5ba5cf56ec1f7bb6430f1189819c023b>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5ba5cf56ec1f7bb6430f1189819c023b>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bb26817896b01e0f875751728e4c811e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bb26817896b01e0f875751728e4c811e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_126c1679932ff9d308c2890ba4333cb1>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_126c1679932ff9d308c2890ba4333cb1>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_651e5326c9703d3fbecf91d502e77f0e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_651e5326c9703d3fbecf91d502e77f0e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_47cc643ea434e2dfba0d1e9dff562a96>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_47cc643ea434e2dfba0d1e9dff562a96>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_67e16d5c5632d31f450207126c793452>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_67e16d5c5632d31f450207126c793452>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_831d4e7dd37ffc2cb8f1fa23a1016469>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_831d4e7dd37ffc2cb8f1fa23a1016469>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_29fb3416196bd8afa142434591a87c09>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_29fb3416196bd8afa142434591a87c09>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_404bd20e38b4823c1b7e547885743f29>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_404bd20e38b4823c1b7e547885743f29>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d4283790f38b85accd8aec2ea564c2e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d4283790f38b85accd8aec2ea564c2e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_209d20244b9039ac29ea6dfe4a7b6be7>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_209d20244b9039ac29ea6dfe4a7b6be7>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0f90b2b3c4664eb05537fe2147ab1339>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0f90b2b3c4664eb05537fe2147ab1339>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c48451c649c487f88e8fb994fa3cdafe>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c48451c649c487f88e8fb994fa3cdafe>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0aecfd0c262fc82822b461b7171786b9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0aecfd0c262fc82822b461b7171786b9>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fef683e8577de250868c8598b6eba9be>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fef683e8577de250868c8598b6eba9be>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0aee489d0e72d71d1617f6c38d57d1db>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0aee489d0e72d71d1617f6c38d57d1db>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0efb31310e7f4443b6e5033db0c02338>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0efb31310e7f4443b6e5033db0c02338>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7336894dc59bda250e015b83cf1ce8f4>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7336894dc59bda250e015b83cf1ce8f4>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d840663cdc9d9e2ce83f159adacf2912>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d840663cdc9d9e2ce83f159adacf2912>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d840663cdc9d9e2ce83f159adacf2912>::()::__l2::<lambda_01df0300e3fa92315f32c57c3c6df548>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d840663cdc9d9e2ce83f159adacf2912>::()::__l2::<lambda_01df0300e3fa92315f32c57c3c6df548>
{
  WorldSettingsScreenController *const __this;
  bool *bIsLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d54fd7a9b4a898b2609765a36c56b6d5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d54fd7a9b4a898b2609765a36c56b6d5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d54fd7a9b4a898b2609765a36c56b6d5>::()::__l2::<lambda_46d244df85246862f16626fdd77698f8>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d54fd7a9b4a898b2609765a36c56b6d5>::()::__l2::<lambda_46d244df85246862f16626fdd77698f8>
{
  WorldSettingsScreenController *const __this;
  bool *bIsLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fda538f6873004a76f8dcb759f0804a5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fda538f6873004a76f8dcb759f0804a5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5ca0135431d752e2f4229fbfe1609756>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5ca0135431d752e2f4229fbfe1609756>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6cc24aae7cbb9a79258a46f147efb4f6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6cc24aae7cbb9a79258a46f147efb4f6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b6f41a7cd1ab61b2c71b9acd32c36066>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b6f41a7cd1ab61b2c71b9acd32c36066>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_eb3a4ffe1e7aff0bf9728f458c12efb7>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_eb3a4ffe1e7aff0bf9728f458c12efb7>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b07cb65dd847c989b87dfa719ce98d84>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_b07cb65dd847c989b87dfa719ce98d84>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d09c4de5994e161aeec4746bc2324bd5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d09c4de5994e161aeec4746bc2324bd5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bb93db77490767b4360430074ca13851>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_bb93db77490767b4360430074ca13851>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_95a9c587ccf7182755b52ca4485c2c3d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_95a9c587ccf7182755b52ca4485c2c3d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4440175289d9af1e3c2fd76dd878ae45>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4440175289d9af1e3c2fd76dd878ae45>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a1e386f19df9b7a3a187dfea37c85520>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a1e386f19df9b7a3a187dfea37c85520>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ebe510d4ffb1d33d14d2ab4fb6f0590d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ebe510d4ffb1d33d14d2ab4fb6f0590d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2868e8f902272b8e8dafdeac9bef03e1>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2868e8f902272b8e8dafdeac9bef03e1>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4527e80d4d628efc7ac61aafa7b82d1b>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4527e80d4d628efc7ac61aafa7b82d1b>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7db65d9ec647236da0b5ea6d41a63aaf>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7db65d9ec647236da0b5ea6d41a63aaf>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_41c7babd3648b9449da59dc163f95c9c>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_41c7babd3648b9449da59dc163f95c9c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e3c077c1604f4d81b175bbf403d4cffb>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e3c077c1604f4d81b175bbf403d4cffb>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f605b81d321a0c29886807762b0f6dc3>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f605b81d321a0c29886807762b0f6dc3>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_962c7e801d8f7e71d349ff2ec12380d5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_962c7e801d8f7e71d349ff2ec12380d5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5688f00791e45cf8c6028db8f0702b68>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5688f00791e45cf8c6028db8f0702b68>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2387ae3ae358c4f47fc2a124195ca4da>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2387ae3ae358c4f47fc2a124195ca4da>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cf2930661b765fc925326b6b3f458d67>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cf2930661b765fc925326b6b3f458d67>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1a44823211364edbeb82f97962d2e8d9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1a44823211364edbeb82f97962d2e8d9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6c5284ad89a6937fad5330a4e60e9e18>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6c5284ad89a6937fad5330a4e60e9e18>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ce3cb61dc903318a3acd4b7d5831a556>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ce3cb61dc903318a3acd4b7d5831a556>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f9d9d913e3833f175fffa44c9407dba6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f9d9d913e3833f175fffa44c9407dba6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5e05ee0cabf592aee7f55295e7de1882>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5e05ee0cabf592aee7f55295e7de1882>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_15fe9872207b9a142eef918ff6157c08>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_15fe9872207b9a142eef918ff6157c08>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ad71913b1578f6d0be792e883a26936f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ad71913b1578f6d0be792e883a26936f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c8938d0670402f384271d42fbca72564>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c8938d0670402f384271d42fbca72564>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2eb9b5d7dbce9dbd9a0603c1e05ac9ae>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2eb9b5d7dbce9dbd9a0603c1e05ac9ae>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_385a1f0a66a4dd89aae21c7d93104779>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_385a1f0a66a4dd89aae21c7d93104779>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_64be793e30d080e8e5f2d5c32464d953>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_64be793e30d080e8e5f2d5c32464d953>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7189624dc689dffdb80fac12c06296fc>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7189624dc689dffdb80fac12c06296fc>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a33df857a85686c62379af9f29984aeb>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a33df857a85686c62379af9f29984aeb>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c6ad0752b7ef35b8bee4fcfb02113c77>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c6ad0752b7ef35b8bee4fcfb02113c77>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_07802cec6e10babdda0526ddbea2e163>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_07802cec6e10babdda0526ddbea2e163>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_90b7f8b690a16261b8cfea74181d110d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_90b7f8b690a16261b8cfea74181d110d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fe7161c37ac2a9e33bd71b6b1190b536>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_fe7161c37ac2a9e33bd71b6b1190b536>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8c0118699bdbb6f4fcf4d2e51ad9934e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8c0118699bdbb6f4fcf4d2e51ad9934e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_367d91839b372628ed8c3657341a9765>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_367d91839b372628ed8c3657341a9765>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_67a76f7bb75741eb8d1f317bac73b033>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_67a76f7bb75741eb8d1f317bac73b033>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_60ae1e40f95d77aab623fafa6f275da2>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_60ae1e40f95d77aab623fafa6f275da2>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e3f6e3e116ed3093425aff2f195850a0>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e3f6e3e116ed3093425aff2f195850a0>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3bf367747e61d0f5d25f908c5ef7a3e6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3bf367747e61d0f5d25f908c5ef7a3e6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3e6454a35dc1d79fc2e9c046b0e98690>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3e6454a35dc1d79fc2e9c046b0e98690>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f24e3f6b803df5b090bc712c82571aa4>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f24e3f6b803df5b090bc712c82571aa4>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_43c730a24f99a50f373ce6e27ebfde03>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_43c730a24f99a50f373ce6e27ebfde03>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1ea1a1dbe70973a2d04a7ddbbd1fae59>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1ea1a1dbe70973a2d04a7ddbbd1fae59>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_929adcddd926865b63f270fe99256aec>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_929adcddd926865b63f270fe99256aec>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_dd7f44e2f200aee6941b1101fac66a6d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_dd7f44e2f200aee6941b1101fac66a6d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d1b02ce9ce382fd24de79fddfb268dec>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d1b02ce9ce382fd24de79fddfb268dec>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4ce09e71dcb2c9a7af1ef8d408ee8c41>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4ce09e71dcb2c9a7af1ef8d408ee8c41>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cccd8a710bda4755a0a012e8515c506b>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cccd8a710bda4755a0a012e8515c506b>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3705e1fba65a1a5fdfb8661217845105>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3705e1fba65a1a5fdfb8661217845105>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5f7c435ff9c92b0307ee3ccca323088f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_5f7c435ff9c92b0307ee3ccca323088f>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d763d0f843b508a1e2a52d8b095c6a4>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8d763d0f843b508a1e2a52d8b095c6a4>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f34b048860ee152ce3339738bff996c6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f34b048860ee152ce3339738bff996c6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8a46f1bd30158cc77e964376cf3ccc35>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8a46f1bd30158cc77e964376cf3ccc35>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_75273d6248e1e4eaaaad8d6dd1feb502>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_75273d6248e1e4eaaaad8d6dd1feb502>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6cb6259db67b9b73e652b39aac916368>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6cb6259db67b9b73e652b39aac916368>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c69739d69588c89a2c2fc19e0d5f2d2a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c69739d69588c89a2c2fc19e0d5f2d2a>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f0dd4396dc206f5fdaf9b1a7facd9f1d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f0dd4396dc206f5fdaf9b1a7facd9f1d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e7aaf83e88f053e1e5444c8234531ccf>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e7aaf83e88f053e1e5444c8234531ccf>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f03a98799be98402ee767846861e266e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f03a98799be98402ee767846861e266e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_68f77b1d57553dce45698ec537ee8918>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_68f77b1d57553dce45698ec537ee8918>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_addc7c7fe279a9ec35c8b1b86b0ac398>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_addc7c7fe279a9ec35c8b1b86b0ac398>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c31ecbe494fd3b64dfaf6a3aec45d2e7>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c31ecbe494fd3b64dfaf6a3aec45d2e7>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_469ebe707f8e998e0091da3a2410fa44>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_469ebe707f8e998e0091da3a2410fa44>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f29609223bd914412c1301361cfe201e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f29609223bd914412c1301361cfe201e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a2cd349981131edebc582baa8d6b7e3e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a2cd349981131edebc582baa8d6b7e3e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d1f31e92586e155c03e24d0febaca4d6>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d1f31e92586e155c03e24d0febaca4d6>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_83a22757c5c3caffb210a9ab1679acb0>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_83a22757c5c3caffb210a9ab1679acb0>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6035c83ceb639e76149c7a2f8cb43434>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6035c83ceb639e76149c7a2f8cb43434>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_727d152b7cc36041544d10d55eff631b>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_727d152b7cc36041544d10d55eff631b>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_76c15a6ed972783d17e3478a9862f004>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_76c15a6ed972783d17e3478a9862f004>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f59cc65fbb824fc2fa83ab1a7749873a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_f59cc65fbb824fc2fa83ab1a7749873a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0198360e90dd93939a702a2bb3393cb2>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0198360e90dd93939a702a2bb3393cb2>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_45d61ca986767db07f2cbdbe904e06d3>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_45d61ca986767db07f2cbdbe904e06d3>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4ef4a1812fe31b40ca53df2fabc2498a>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4ef4a1812fe31b40ca53df2fabc2498a>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_61ea0f0e69da3ea0c8b0411eb59a167e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_61ea0f0e69da3ea0c8b0411eb59a167e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_928eb7595140295b7d2f06478e842dda>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_928eb7595140295b7d2f06478e842dda>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a4f878c965ca0d44cdbce9cde5de5ad7>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a4f878c965ca0d44cdbce9cde5de5ad7>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4c12011deec111bbca7040c335e31a4f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4c12011deec111bbca7040c335e31a4f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ac52423691a3e5c5534ff689becf3909>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_ac52423691a3e5c5534ff689becf3909>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a103a6dce24b04ee918154b96ee4dd52>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a103a6dce24b04ee918154b96ee4dd52>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_30d766a64cda4137c607e19eed3205e9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_30d766a64cda4137c607e19eed3205e9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6b411a20c6c39dfe14a11298b33985d9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6b411a20c6c39dfe14a11298b33985d9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c1762ce9fb30eaa8f7a0aba0b2a5d968>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c1762ce9fb30eaa8f7a0aba0b2a5d968>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0491523e3d45864102be3876613d2493>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_0491523e3d45864102be3876613d2493>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7c39705f12add048eb75d57174042ae3>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_7c39705f12add048eb75d57174042ae3>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_623f18694e8ea5766a78095543322d17>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_623f18694e8ea5766a78095543322d17>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_62b4834540cc7d17b762e89a9f961495>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_62b4834540cc7d17b762e89a9f961495>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_60c2cffa0f463761fb3bf42cb213f6a1>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_60c2cffa0f463761fb3bf42cb213f6a1>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_46e234c439581f4bec4e6e589412fc78>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_46e234c439581f4bec4e6e589412fc78>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cbe0c0c126d7ffff4f55176d8562720e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cbe0c0c126d7ffff4f55176d8562720e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_50981d1fb2684334e45f37bb4b465a4f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_50981d1fb2684334e45f37bb4b465a4f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3767d6fd5072ccfe82b09cade980c15f>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_3767d6fd5072ccfe82b09cade980c15f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_536c971b1079124538a1f4399a3be33c>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_536c971b1079124538a1f4399a3be33c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6749075cb175cc5c22435ef262536760>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_6749075cb175cc5c22435ef262536760>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9ce381ccc4ddb25e1de73c5988c4a54c>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_9ce381ccc4ddb25e1de73c5988c4a54c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_11c0858cb65c8a7fb48aabe26d44f633>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_11c0858cb65c8a7fb48aabe26d44f633>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22ebe20099486c96261199cab9fccd40>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22ebe20099486c96261199cab9fccd40>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cc927440520adb50b885c3e1b83e79a1>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cc927440520adb50b885c3e1b83e79a1>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c2c7626a31bc5730bae96f374c38d8ce>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_c2c7626a31bc5730bae96f374c38d8ce>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_59420fd3fa39f2cf4dfaeb27ad9c59c9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_59420fd3fa39f2cf4dfaeb27ad9c59c9>
{
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cd28d7b96b21b060ac52e9c1332b6a11>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_cd28d7b96b21b060ac52e9c1332b6a11>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_97c0d1951bc0907a10345628d9ebff23>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_97c0d1951bc0907a10345628d9ebff23>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_05dd21f43eeb074fdf2000943a713030>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_05dd21f43eeb074fdf2000943a713030>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a85950d03e5c0cc23aa76ee2a26115a5>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a85950d03e5c0cc23aa76ee2a26115a5>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a85950d03e5c0cc23aa76ee2a26115a5>::()::__l2::<lambda_6c1aadeb2eb08c550d2e1a6a4d55ca22>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_a85950d03e5c0cc23aa76ee2a26115a5>::()::__l2::<lambda_6c1aadeb2eb08c550d2e1a6a4d55ca22>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_98e46a38f5913ad39a3493dfbd985cb9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_98e46a38f5913ad39a3493dfbd985cb9>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_98e46a38f5913ad39a3493dfbd985cb9>::()::__l2::<lambda_a9c2484c94a4b01538131ae3933ef2e9>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_98e46a38f5913ad39a3493dfbd985cb9>::()::__l2::<lambda_a9c2484c94a4b01538131ae3933ef2e9>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_f4f0cef7eec9a90b674b4994d928e01e>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_f4f0cef7eec9a90b674b4994d928e01e>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_f4f0cef7eec9a90b674b4994d928e01e>::()::__l2::<lambda_c623234de61f3ad40231e2c89fc8ed89>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_f4f0cef7eec9a90b674b4994d928e01e>::()::__l2::<lambda_c623234de61f3ad40231e2c89fc8ed89>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_ebacdcdf51655f2841adc0931a657034>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_ebacdcdf51655f2841adc0931a657034>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_ebacdcdf51655f2841adc0931a657034>::()::__l2::<lambda_648b9666402c10587197312f60397eb8>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l12::<lambda_ebacdcdf51655f2841adc0931a657034>::()::__l2::<lambda_648b9666402c10587197312f60397eb8>
{
  bool *bIsLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e99aad8a8cb5d1ad9bcd6235488ed359>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e99aad8a8cb5d1ad9bcd6235488ed359>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e99aad8a8cb5d1ad9bcd6235488ed359>::()::__l2::<lambda_a24cbd5b08bab682a143233efae0b1ef>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_e99aad8a8cb5d1ad9bcd6235488ed359>::()::__l2::<lambda_a24cbd5b08bab682a143233efae0b1ef>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22032b77ed683bc07260ec709d77b868>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22032b77ed683bc07260ec709d77b868>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22032b77ed683bc07260ec709d77b868>::()::__l2::<lambda_95d2c0361c069500f94544e8ec18e728>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_22032b77ed683bc07260ec709d77b868>::()::__l2::<lambda_95d2c0361c069500f94544e8ec18e728>
{
  bool *bIsLowDiskSpaceWarning;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l9::<lambda_c8972235332315f264d14cfe7208c55c>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l9::<lambda_c8972235332315f264d14cfe7208c55c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_registerControllerCallbacks::__l5::<lambda_12b910efcc907f22966b905fb1f55a5d>`

struct __cppobj WorldSettingsScreenController::_registerControllerCallbacks::__l5::<lambda_12b910efcc907f22966b905fb1f55a5d>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_80b2321e53826581beb1071e10571e26>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_80b2321e53826581beb1071e10571e26>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_147638930d667c3d9d9e372a17d82d53>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_147638930d667c3d9d9e372a17d82d53>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_f9725ff8e89cea173b6a73ed0d2ddf9c>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_f9725ff8e89cea173b6a73ed0d2ddf9c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_b6e95752c7053c2a309b4f6edc31ea46>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_b6e95752c7053c2a309b4f6edc31ea46>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_a7a51b7aad485a44225887ed9bcaebdd>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_a7a51b7aad485a44225887ed9bcaebdd>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_8b810c55c4a014348e28991c3b317af2>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_8b810c55c4a014348e28991c3b317af2>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_817e2a20b2371768dc9e38e644e78f40>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_817e2a20b2371768dc9e38e644e78f40>
{
  const std::string levelId;
};

# `WorldSettingsScreenController::onCreation::__l5::<lambda_ca6675bf90f93acd92276129fbf97baa>`

struct __cppobj WorldSettingsScreenController::onCreation::__l5::<lambda_ca6675bf90f93acd92276129fbf97baa>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_7f62f061decc588ffdb9ec37d0f5d70c>`

struct __cppobj WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_7f62f061decc588ffdb9ec37d0f5d70c>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_330dd4148f8e49bd2f366ba110ada07a>`

struct __cppobj WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_330dd4148f8e49bd2f366ba110ada07a>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_8c899aa7cdcbf96e76995cdad258b5f6>`

struct __cppobj WorldSeedCatalogScreenController::_registerEventHandlers::__l2::<lambda_8c899aa7cdcbf96e76995cdad258b5f6>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_70fda4f0e2a9b35defdc41f3860672b8>`

struct __cppobj WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_70fda4f0e2a9b35defdc41f3860672b8>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_97a50de5d13436a9a145efb630654e19>`

struct __cppobj WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_97a50de5d13436a9a145efb630654e19>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_5275789cc6851a076eb96b33f37f6a5d>`

struct __cppobj WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_5275789cc6851a076eb96b33f37f6a5d>
{
};

# `WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_3a178ee65270b35d8fdd3e9b22fd8ac6>`

struct __cppobj WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_3a178ee65270b35d8fdd3e9b22fd8ac6>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_bddd4a193e6c21aab0254b88583c6fa3>`

struct __cppobj WorldSeedCatalogScreenController::_registerBindings::__l2::<lambda_bddd4a193e6c21aab0254b88583c6fa3>
{
  WorldSeedCatalogScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_getWorldUploadCallback::__l2::<lambda_9c50100e0f4c952f08c7294be1a8f323>`

struct __cppobj WorldConversionErrorReportScreenController::_getWorldUploadCallback::__l2::<lambda_9c50100e0f4c952f08c7294be1a8f323>
{
  std::weak_ptr<WorldConversionErrorReportScreenController> weakThis;
};

# `WorldConversionErrorReportScreenController::_displayFailedModalDialog::__l2::<lambda_7020a731214a5bea4efb3c354e7628bf>`

struct __cppobj WorldConversionErrorReportScreenController::_displayFailedModalDialog::__l2::<lambda_7020a731214a5bea4efb3c354e7628bf>
{
  std::shared_ptr<MainMenuScreenModel> mainMenuScreenModel;
};

# `WorldConversionErrorReportScreenController::_displaySuccessModalDialog::__l2::<lambda_6c7dfca4f9e3423acd7c79542341d98a>`

struct __cppobj WorldConversionErrorReportScreenController::_displaySuccessModalDialog::__l2::<lambda_6c7dfca4f9e3423acd7c79542341d98a>
{
  std::shared_ptr<MainMenuScreenModel> mainMenuScreenModel;
};

# `WorldConversionErrorReportScreenController::_getUploadWorldProgressHandlerCallback::__l2::<lambda_e730659effc7b3eacfd445c2c8d92a4f>`

struct __cppobj WorldConversionErrorReportScreenController::_getUploadWorldProgressHandlerCallback::__l2::<lambda_e730659effc7b3eacfd445c2c8d92a4f>
{
  std::weak_ptr<WorldConversionErrorReportScreenController> weakThis;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l6::<lambda_4a2e2d1514893c895dad1a6b448d72ce>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l6::<lambda_4a2e2d1514893c895dad1a6b448d72ce>
{
  std::pair<std::string const ,enum WorldConversionError> blockTypePair;
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l6::<lambda_56d8ef9fb3b404920e10831aad83b718>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l6::<lambda_56d8ef9fb3b404920e10831aad83b718>
{
  std::pair<std::string const ,enum WorldConversionError> blockTypePair;
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_d00e8ccf29bdaa00f2c29b9aca415263>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_d00e8ccf29bdaa00f2c29b9aca415263>
{
  std::vector<std::string> reportReasonLabels;
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_9fdf36a97a3b3757e229caa41c47329e>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_9fdf36a97a3b3757e229caa41c47329e>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_8c4b34f9f02d81c18cbbf57048137b80>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_8c4b34f9f02d81c18cbbf57048137b80>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_d519c856aef87792b0b1240e1986b0fc>`

struct __cppobj WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_d519c856aef87792b0b1240e1986b0fc>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_88cdd74d6983e0473ad358c5f81da965>`

struct __cppobj WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_88cdd74d6983e0473ad358c5f81da965>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_d97ec8ac57029c194129d7069146b3f0>`

struct __cppobj WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_d97ec8ac57029c194129d7069146b3f0>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_5774579062ec37f5b072894874aa4438>`

struct __cppobj WorldConversionErrorReportScreenController::_registerEventHandlers::__l2::<lambda_5774579062ec37f5b072894874aa4438>
{
  WorldConversionErrorReportScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_52733647b5f6269c086bd4dddd014491>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_52733647b5f6269c086bd4dddd014491>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_215e3d83b0851f57cb2204cd6e849d2e>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_215e3d83b0851f57cb2204cd6e849d2e>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_3a83337278dd8274d483c1e7427a9b1d>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_3a83337278dd8274d483c1e7427a9b1d>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_d199389202dca0665a9ac706d7c9b671>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_d199389202dca0665a9ac706d7c9b671>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_c10fd5eda511e842fb6eaeaa9d571472>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_c10fd5eda511e842fb6eaeaa9d571472>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_889ef3bbfe9d338a9d3f739371fab2ea>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_889ef3bbfe9d338a9d3f739371fab2ea>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_f5f504abe66eb628f34780b8dbb099b7>`

struct __cppobj WorldConversionCompleteScreenController::_registerBindings::__l2::<lambda_f5f504abe66eb628f34780b8dbb099b7>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_12fd8005613e9ddaaab97bc4436425e0>`

struct __cppobj WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_12fd8005613e9ddaaab97bc4436425e0>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>`

struct __cppobj WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>::()::__l2::<lambda_afd3c81753a2c8c6b986ce899b6aa90d>`

struct __cppobj WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>::()::__l2::<lambda_afd3c81753a2c8c6b986ce899b6aa90d>
{
  WorldConversionCompleteScreenController *const __this;
};

# `WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>::()::__l2::<lambda_da46f07858092769524b05c0c6f1b5a3>`

struct __cppobj WorldConversionCompleteScreenController::_registerEventHandlers::__l2::<lambda_585683e59ebfa09717c834c8a306641a>::()::__l2::<lambda_da46f07858092769524b05c0c6f1b5a3>
{
  bool *bIsLowDiskSpaceWarning;
};

# `Win10TrialConversionScreenController::_registerEventHandlers::__l2::<lambda_6f2205835ad4631dd1f514e5672d8bd9>`

struct __cppobj Win10TrialConversionScreenController::_registerEventHandlers::__l2::<lambda_6f2205835ad4631dd1f514e5672d8bd9>
{
  Win10TrialConversionScreenController *const __this;
};

# `Win10TrialConversionScreenController::_registerEventHandlers::__l2::<lambda_96186c6b33c0eede867bb2391a620dbf>`

struct __cppobj Win10TrialConversionScreenController::_registerEventHandlers::__l2::<lambda_96186c6b33c0eede867bb2391a620dbf>
{
  Win10TrialConversionScreenController *const __this;
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_b257330c18e5fdd0cf43731a7af0118e>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_b257330c18e5fdd0cf43731a7af0118e>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_d194773f22374a6c44d7cf141127ccf9>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_d194773f22374a6c44d7cf141127ccf9>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_bda547947f1800c6322982c39a7877d4>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_bda547947f1800c6322982c39a7877d4>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_e0f2d0592b3fb41bc118876d989d0f63>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_e0f2d0592b3fb41bc118876d989d0f63>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_425c9b8bdc59f216ff74d69d76371682>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_425c9b8bdc59f216ff74d69d76371682>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_415fc44510e9d3eff63920b66d00e357>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_415fc44510e9d3eff63920b66d00e357>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_04b8e60f72610c5068727e80ef8682ae>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_04b8e60f72610c5068727e80ef8682ae>
{
};

# `Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_e6123690d3b2f7a0f0dff79314d3eaa2>`

struct __cppobj Win10TrialConversionScreenController::_registerBindings::__l2::<lambda_e6123690d3b2f7a0f0dff79314d3eaa2>
{
};

# `WorldSettingsScreenController::_copyWorld::__l5::<lambda_ef24be1b802a6ffbb2085a0ce919f7e4>`

struct __cppobj WorldSettingsScreenController::_copyWorld::__l5::<lambda_ef24be1b802a6ffbb2085a0ce919f7e4>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_getGameRuleUpdater::__l9::<lambda_646207347f11b4883efa6acf5cb74941>`

struct __cppobj WorldSettingsScreenController::_getGameRuleUpdater::__l9::<lambda_646207347f11b4883efa6acf5cb74941>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_getGameRuleUpdater::__l5::<lambda_cec60951b0b8e6e5b89a980631f238a4>`

struct __cppobj WorldSettingsScreenController::_getGameRuleUpdater::__l5::<lambda_cec60951b0b8e6e5b89a980631f238a4>
{
  LevelDataWrapper *levelData;
  std::shared_ptr<MainMenuScreenModel> screenModel;
};

# `WorldSettingsScreenController::_getGameRuleUpdater::__l9::<lambda_bb2ce8a351a41599f88a4c9a9364d86f>`

struct __cppobj WorldSettingsScreenController::_getGameRuleUpdater::__l9::<lambda_bb2ce8a351a41599f88a4c9a9364d86f>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_getGameRuleUpdater::__l5::<lambda_0ee59ad07c17d4128c3a2e060f1b0367>`

struct __cppobj WorldSettingsScreenController::_getGameRuleUpdater::__l5::<lambda_0ee59ad07c17d4128c3a2e060f1b0367>
{
  LevelDataWrapper *levelData;
  std::shared_ptr<MainMenuScreenModel> screenModel;
};

# `WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_d14c3a83ba7049c63e120071c60071ee>`

struct __cppobj WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_d14c3a83ba7049c63e120071c60071ee>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_1e2d16bb91ef845931d525c1688ad360>`

struct __cppobj WorldSettingsScreenController::_createWorld::__l54::<lambda_91cb956d0c149b4e25cebfb986f97dce>::()::__l4::<lambda_1e2d16bb91ef845931d525c1688ad360>
{
  std::weak_ptr<WorldSettingsScreenController> weakThis;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_5b78d27fd531620eaa7ea5bab5222b42>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_5b78d27fd531620eaa7ea5bab5222b42>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_a9295983da3a09027be9d3c3006da09c>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_a9295983da3a09027be9d3c3006da09c>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_96aac43d799a2be339d5ebbe98c82d18>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_96aac43d799a2be339d5ebbe98c82d18>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_init::__l2::<lambda_489ae611b76fd4a60a0c84a4d9432cef>`

struct __cppobj WorldSettingsScreenController::_init::__l2::<lambda_489ae611b76fd4a60a0c84a4d9432cef>
{
  WorldSettingsScreenController *const __this;
};

# `WritableBookItem`

struct __cppobj WritableBookItem : Item
{
};

# `WorldContentSource`

struct __cppobj WorldContentSource : ContentSource
{
  LevelListCache *mLevelListCache;
  std::vector<LevelSummary> mLevelSummaryList;
};

# `WorldContentSource_vtbl`

struct /*VFT*/ WorldContentSource_vtbl
{
  void (__fastcall *~ContentSource)(ContentSource *this);
  void (__fastcall *load)(ContentSource *this);
  void (__fastcall *generateItems)(ContentSource *this, std::vector<std::unique_ptr<ContentItem>> *);
  void (__fastcall *save)(ContentSource *this);
  void (__fastcall *deleteContentFiles)(ContentSource *this, std::vector<ContentItem const *>);
  void (__fastcall *postDeleteContent)(ContentSource *this, std::vector<ContentItem const *>);
};

# `WorldTemplateSource`

struct __cppobj WorldTemplateSource : ContentSource
{
  WorldTemplateManager *mWorldTemplaceManager;
};

# `WorldTemplateSource_vtbl`

struct /*VFT*/ WorldTemplateSource_vtbl
{
  void (__fastcall *~ContentSource)(ContentSource *this);
  void (__fastcall *load)(ContentSource *this);
  void (__fastcall *generateItems)(ContentSource *this, std::vector<std::unique_ptr<ContentItem>> *);
  void (__fastcall *save)(ContentSource *this);
  void (__fastcall *deleteContentFiles)(ContentSource *this, std::vector<ContentItem const *>);
  void (__fastcall *postDeleteContent)(ContentSource *this, std::vector<ContentItem const *>);
};

# `WorldSeedCatalogModel::fetch::__l2::<lambda_55fb1a16544d2a415662441120666ac9>`

struct __cppobj WorldSeedCatalogModel::fetch::__l2::<lambda_55fb1a16544d2a415662441120666ac9>
{
  WorldSeedCatalogModel *const __this;
  std::weak_ptr<bool> weakTracker;
};

# `WolfModel`

struct __cppobj __declspec(align(8)) WolfModel : Model
{
  mce::MaterialPtr mDefaultMaterial;
  ModelPart mHead;
  ModelPart mUpperBody;
  ModelPart mBody;
  ModelPart mLeg0;
  ModelPart mLeg1;
  ModelPart mLeg2;
  ModelPart mLeg3;
  ModelPart mTail;
  Vec3 mBaseBodyPosition;
  Vec3 mBaseUpperBodyPosition;
  Vec3 mBaseTailPosition;
  Vec3 mBaseLegPosition[4];
  float mBaseBodyRotationX;
  float mLegSize;
};

# `WolfModel_vtbl`

struct /*VFT*/ WolfModel_vtbl
{
  void (__fastcall *~AppPlatformListener)(AppPlatformListener *this);
  void (__fastcall *onLowMemory)(AppPlatformListener *this);
  void (__fastcall *onAppPaused)(AppPlatformListener *this);
  void (__fastcall *onAppUnpaused)(AppPlatformListener *this);
  void (__fastcall *onAppPreSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppSuspended)(AppPlatformListener *this);
  void (__fastcall *onAppResumed)(AppPlatformListener *this);
  void (__fastcall *onAppFocusLost)(AppPlatformListener *this);
  void (__fastcall *onAppFocusGained)(AppPlatformListener *this);
  void (__fastcall *onAppTerminated)(AppPlatformListener *this);
  void (__fastcall *onOperationModeChanged)(AppPlatformListener *this, const OperationMode);
  void (__fastcall *onPerformanceModeChanged)(AppPlatformListener *this, const bool);
  void (__fastcall *onPushNotificationReceived)(AppPlatformListener *this, const PushNotificationMessage *);
  void (__fastcall *onResizeBegin)(AppPlatformListener *this);
  void (__fastcall *onResizeEnd)(AppPlatformListener *this);
  void (__fastcall *onDeviceLost)(AppPlatformListener *this);
  void (__fastcall *clear)(Model *this);
  void (__fastcall *preDraw)(Model *this, ScreenContext *);
  void (__fastcall *postDraw)(Model *this, ScreenContext *);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, BaseActorRenderContext *);
  void (__fastcall *render)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *render)(Model *this, ScreenContext *);
  void (__fastcall *setupAnim)(Model *this);
  void (__fastcall *setupAnim)(Model *this, float, float, float, float, float, float);
  void (__fastcall *prepareMobModel)(Model *this, Mob *, float, float, float);
  Vec3 *(__fastcall *getLeashOffsetPosition)(Model *this, Vec3 *result, bool);
  void (__fastcall *renderAniModel)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  void (__fastcall *renderMod)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float);
  void (__fastcall *youngTransform)(Model *this, ScreenContext *, Actor *, float, float, float, float, float, float, MatrixStack::MatrixStackRef *);
  float (__fastcall *getHeightAdjustment)(Model *this);
  AABB *(__fastcall *buildAABB)(Model *this, AABB *result);
};

# `Wolf`

struct __cppobj __declspec(align(8)) Wolf : Animal
{
  float mShakeAnim;
  float mShakeAnimO;
  float mInterestedAngle;
  float mInterestedAngleO;
  bool mIsWet;
  bool mIsShaking;
};

# `WaterDropParticle`

struct __cppobj WaterDropParticle : Particle
{
};

# `WaterDropParticle_vtbl`

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

# `WaterWakeParticle`

struct __cppobj WaterWakeParticle : Particle
{
};

# `WaterWakeParticle_vtbl`

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

# `WitherBoss`

struct __cppobj __declspec(align(8)) WitherBoss : Monster
{
  int MAX_SHIELD_HEALTH;
  int mTimeBeforeMoving;
  int mShieldHealth;
  Vec2 mHeadRots[3];
  Vec2 mOldHeadRots[3];
  int mNextHeadUpdate[3];
  int mIdleHeadUpdates[3];
  int mDestroyBlocksTick;
  int mHealthThreshold;
  int mPhase;
  bool mWantsToExplode;
  bool mCharging;
  Vec3 mChargeDirection;
  int mChargeFrames;
  int mPreparingCharge;
  int mProjectileCounter;
  int mSpawningFrames;
  int mShieldFlicker;
  int mTimeTillNextShot;
  int mFireRate;
  float mSpinSpeed;
  float mOverlayAlpha;
  int mStunTimer;
  int mFramesTillMove;
  bool mWantsMove;
  bool mIsPathing;
  int mMaxHealth;
  int mNumSkeletons;
  int mMaxSkeletons;
  int mDyingFrames;
  int mMovementTime;
  int mHealthIntervals;
  int mLastHealthValue;
  int mDelayShot;
  int mTimeSinceLastShot;
  float mAttackRange;
  bool mSecondVolley;
  float mSwellAmount;
  float mOldSwellAmount;
  int mMainHeadAttackCountdown;
  std::unique_ptr<ActorDamageSource> mDeathSource;
  int mlastFiredHead;
};

# `WallConnectionTypeHash`

struct __cppobj WallConnectionTypeHash
{
};

# `WallBlock`

struct __cppobj WallBlock : BlockLegacy
{
};

# `WallBlock_vtbl`

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

# `WeakStorageSharePtr<FogDefinition>`

struct __cppobj WeakStorageSharePtr<FogDefinition>
{
  std::weak_ptr<FogDefinition> mHandle;
};

# `WorldsContainerMonitor`

struct __cppobj WorldsContainerMonitor : SaveContainer
{
  unsigned __int64 mRootPathPartCount;
};

# `WorldsContainerMonitor_vtbl`

struct /*VFT*/ WorldsContainerMonitor_vtbl
{
  void (__fastcall *~Observer<Core::FileStorageAreaObserver,Core::SingleThreadedLock>)(Core::Observer<Core::FileStorageAreaObserver,Core::SingleThreadedLock> *this);
  void (__fastcall *_onSubjectDestroyed)(Core::Observer<Core::FileStorageAreaObserver,Core::SingleThreadedLock> *this);
  void (__fastcall *_onBeginWrites)(Core::FileStorageAreaObserver *this);
  void (__fastcall *_onEndWrites)(Core::FileStorageAreaObserver *this);
  void (__fastcall *_onWriteFile)(Core::FileStorageAreaObserver *this, Core::Path);
  void (__fastcall *_onDeleteFile)(Core::FileStorageAreaObserver *this, Core::Path);
};

# `WorldFileDownloadManager::_importLevel::__l13::<lambda_f751d7d2807b10c0b06e3015f280143d>::()::__l16::<lambda_0521ceca8b4ab53cab58def0b71b2c99>`

struct __cppobj WorldFileDownloadManager::_importLevel::__l13::<lambda_f751d7d2807b10c0b06e3015f280143d>::()::__l16::<lambda_0521ceca8b4ab53cab58def0b71b2c99>
{
  std::shared_ptr<WorldFileDownloadManager> shared_this;
  std::string levelId;
};

# `WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_48272e6167ed70ed342755e0666be732>`

struct __cppobj WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_48272e6167ed70ed342755e0666be732>
{
  std::weak_ptr<WorldFileDownloadManager> weak_this;
};

# `WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_1fd7857a6c54915173786814bb19a325>`

struct __cppobj WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_1fd7857a6c54915173786814bb19a325>
{
  std::weak_ptr<WorldFileDownloadManager> weak_this;
};

# `WorldsContainerMonitor::_mountNewStorageAreaIfNecessary::__l16::<lambda_14fd8b899e5b2d10587392f1a8dbbf2e>`

struct __cppobj WorldsContainerMonitor::_mountNewStorageAreaIfNecessary::__l16::<lambda_14fd8b899e5b2d10587392f1a8dbbf2e>
{
  Core::PathBuffer<Core::StackString<char,1024> > *childRoot;
  bool *found;
};

# `WindowStateStorage`

struct __cppobj WindowStateStorage
{
  WindowStateStorage_vtbl *__vftable /*VFT*/;
};

# `WindowStateStorage_vtbl`

struct /*VFT*/ WindowStateStorage_vtbl
{
  void (__fastcall *~WindowStateStorage)(WindowStateStorage *this);
  void (__fastcall *writeRect)(WindowStateStorage *this, const tagRECT *);
  void (__fastcall *writeShowCommand)(WindowStateStorage *this, int);
  bool (__fastcall *readRect)(WindowStateStorage *this, tagRECT *);
  bool (__fastcall *readShowCommand)(WindowStateStorage *this, int *);
};

# `WindowStatePlatform`

struct __cppobj WindowStatePlatform
{
  WindowStatePlatform_vtbl *__vftable /*VFT*/;
};

# `WindowStatePlatform_vtbl`

struct /*VFT*/ WindowStatePlatform_vtbl
{
  void (__fastcall *~WindowStatePlatform)(WindowStatePlatform *this);
  bool (__fastcall *getWindowRect)(WindowStatePlatform *this, HWND__ *, tagRECT *);
  bool (__fastcall *getClientRect)(WindowStatePlatform *this, HWND__ *, tagRECT *);
  bool (__fastcall *getWindowShowCommand)(WindowStatePlatform *this, HWND__ *, int *);
  bool (__fastcall *getClosestMonitorRect)(WindowStatePlatform *this, const tagRECT *, tagRECT *);
  bool (__fastcall *getAdjustedWindowRect)(WindowStatePlatform *this, const tagRECT *, tagRECT *);
};

# `WindowState`

struct __cppobj WindowState
{
  tagRECT mRect;
  int mShowCommand;
  std::unique_ptr<WindowStateStorage> mStorage;
  std::unique_ptr<WindowStatePlatform> mPlatform;
};

# `Win32MockStore`

struct __cppobj Win32MockStore : Store
{
  bool mAvailable;
  const Core::PathBuffer<std::string > mFolderPath;
  MPMCQueue<std::function<void __cdecl(void)> > *mCallbackQueue;
  StoreListener *mListener;
};

# `Win32MockStore_vtbl`

struct /*VFT*/ Win32MockStore_vtbl
{
  void (__fastcall *~Store)(Store *this);
  bool (__fastcall *isReadyToMakePurchases)(Store *this);
  bool (__fastcall *requiresRestorePurchasesButton)(Store *this);
  bool (__fastcall *allowsSubscriptions)(Store *this);
  std::string *(__fastcall *getStoreId)(Store *this, std::string *result);
  std::string *(__fastcall *getCatalogPlatformId)(Store *this, std::string *result);
  std::string *(__fastcall *getProductSkuPrefix)(Store *this, std::string *result);
  std::string *(__fastcall *getRealmsSkuPrefix)(Store *this, std::string *result);
  void (__fastcall *queryProducts)(Store *this, const std::vector<ProductSku> *);
  bool (__fastcall *purchase)(Store *this, const ProductSku *, ProductType, const std::string *, PurchasePath);
  void (__fastcall *acknowledgePurchase)(Store *this, const PurchaseInfo *, ProductType);
  void (__fastcall *queryPurchases)(Store *this, bool);
  void (__fastcall *restorePurchases)(Store *this);
  bool (__fastcall *isTrial)(Store *this);
  void (__fastcall *purchaseGame)(Store *this, const TrialUpgradePurchaseTier);
  bool (__fastcall *isGameLicensed)(Store *this);
  bool (__fastcall *receivedLicenseResponse)(Store *this);
  bool (__fastcall *isIapSyncAvailable)(Store *this);
  ExtraLicenseData *(__fastcall *getExtraLicenseData)(Store *this, ExtraLicenseData *result);
  std::string *(__fastcall *getAppReceipt)(Store *this, std::string *result);
  void (__fastcall *registerLicenseChangeCallback)(Store *this, std::function<void __cdecl(void)>);
  void (__fastcall *handleLicenseChange)(Store *this);
  void (__fastcall *restoreFromCache)(Store *this, PurchaseCache *);
  void (__fastcall *getUserAccessTokenAsync)(Store *this, const std::string *, std::function<void __cdecl(bool,std::string)>);
  std::string *(__fastcall *getFullSKUWithMetadataFromProductSku)(Store *this, std::string *result, const std::string *);
  std::string *(__fastcall *getFullGameProductSku)(Store *this, std::string *result, const TrialUpgradePurchaseTier);
  std::string *(__fastcall *getLanguageCode)(Store *this, std::string *result);
  std::string *(__fastcall *getRegionCode)(Store *this, std::string *result);
  void (__fastcall *refreshLicenses)(Store *this);
  void (__fastcall *updateXUID)(Store *this, const std::string *);
  void (__fastcall *onNewPrimaryUser)(Store *this, const Social::User *);
  void (__fastcall *onPrimaryUserConnectedToPlatform)(Store *this, const Social::User *);
  void (__fastcall *getPurchases)(Store *this);
  void (__fastcall *showPlatformEmptyStoreDialog)(Store *this, std::function<void __cdecl(bool)> *);
  const std::string *(__fastcall *getPremiumCurrencyOfferType)(Store *this);
  const std::vector<std::string> *(__fastcall *getPremiumCurrencySkus)(Store *this, const std::vector<std::string> *result);
  const std::string *(__fastcall *buildRealmsProductSku)(Store *this, const std::string *result, RealmsOfferType, RealmsOfferPeriod, RealmsOfferTier, RealmsOfferNumber);
};

# `Win32MockStore::InternalPurchase`

struct __cppobj __declspec(align(8)) Win32MockStore::InternalPurchase
{
  PurchaseInfo mPurchaseInfo;
  Win32MockStore::InternalPurchase::Status mStatus;
};

# `Win32MockStore::queueCallback::__l2::<lambda_4bd9e036440313dbc9d78628fdef90ae>`

struct __cppobj Win32MockStore::queueCallback::__l2::<lambda_4bd9e036440313dbc9d78628fdef90ae>
{
  Win32MockStore *const __this;
  std::function<void __cdecl(void)> callback;
};

# `Win32MockStore::queryPurchases::__l2::<lambda_9555740a4bfcc25374d87f005227de88>::()::__l10::<lambda_20c22ae53a976337471525d14885bf37>`

struct __cppobj Win32MockStore::queryPurchases::__l2::<lambda_9555740a4bfcc25374d87f005227de88>::()::__l10::<lambda_20c22ae53a976337471525d14885bf37>
{
  Win32MockStore *const __this;
  std::vector<PurchaseInfo> purchases;
};

# `Win32MockStore::queryPurchases::__l2::<lambda_9555740a4bfcc25374d87f005227de88>::()::__l8::<lambda_9dc202012e4d967d94788c114e1d9341>`

struct __cppobj Win32MockStore::queryPurchases::__l2::<lambda_9555740a4bfcc25374d87f005227de88>::()::__l8::<lambda_9dc202012e4d967d94788c114e1d9341>
{
  Win32MockStore *const __this;
  std::vector<PurchaseInfo> purchases;
};

# `Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l16::<lambda_f1b77c2af1fadba670c5549db17c1dbc>`

struct __cppobj Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l16::<lambda_f1b77c2af1fadba670c5549db17c1dbc>
{
  Win32MockStore *const __this;
  ProductSku copyProductSku;
};

# `Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l12::<lambda_c1c13d46f968423ab0bd188928d0df00>`

struct __cppobj Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l12::<lambda_c1c13d46f968423ab0bd188928d0df00>
{
  Win32MockStore *const __this;
  ProductSku copyProductSku;
};

# `Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l8::<lambda_4ad834d00e2ddf102b4949675487a99d>`

struct __cppobj Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l8::<lambda_4ad834d00e2ddf102b4949675487a99d>
{
  Win32MockStore *const __this;
  PurchaseInfo purchaseInfo;
};

# `Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l5::<lambda_ff81cbfe8dfff71d4ca58aae4b44efad>`

struct __cppobj Win32MockStore::purchase::__l2::<lambda_f1d43e3ab29a1188144670d8afde9d92>::()::__l5::<lambda_ff81cbfe8dfff71d4ca58aae4b44efad>
{
  Win32MockStore *const __this;
  ProductSku copyProductSku;
};

# `Win32MockStore::queryProducts::__l32::<lambda_d383822b24b0b436bc631792543b357b>::()::__l2::<lambda_3b1328e6d8be1a7bd887d3339986e63f>`

struct __cppobj Win32MockStore::queryProducts::__l32::<lambda_d383822b24b0b436bc631792543b357b>::()::__l2::<lambda_3b1328e6d8be1a7bd887d3339986e63f>
{
  Win32MockStore *const __this;
};

# `Win32MockStore::queryProducts::__l16::<lambda_37bc422af1147e4e65918fa3a18eee9a>::()::__l2::<lambda_c0db4622f8f251ff15ba86c5e7c92606>`

struct __cppobj Win32MockStore::queryProducts::__l16::<lambda_37bc422af1147e4e65918fa3a18eee9a>::()::__l2::<lambda_c0db4622f8f251ff15ba86c5e7c92606>
{
  Win32MockStore *const __this;
  std::vector<ProductInfo> products;
};

# `Win32MockStore::{ctor}::__l2::<lambda_5788921cd14425edc78615d15494bd55>::()::__l9::<lambda_5adac260aebf6336ae74c10f72249c32>`

struct __cppobj Win32MockStore::{ctor}::__l2::<lambda_5788921cd14425edc78615d15494bd55>::()::__l9::<lambda_5adac260aebf6336ae74c10f72249c32>
{
  Win32MockStore *const __this;
  Win32MockStore::InternalPurchase internalPurchase;
};

# `WindowStatePlatformWin32`

struct __cppobj WindowStatePlatformWin32 : WindowStatePlatform
{
};

# `WindowStatePlatformWin32_vtbl`

struct /*VFT*/ WindowStatePlatformWin32_vtbl
{
  void (__fastcall *~WindowStatePlatform)(WindowStatePlatform *this);
  bool (__fastcall *getWindowRect)(WindowStatePlatform *this, HWND__ *, tagRECT *);
  bool (__fastcall *getClientRect)(WindowStatePlatform *this, HWND__ *, tagRECT *);
  bool (__fastcall *getWindowShowCommand)(WindowStatePlatform *this, HWND__ *, int *);
  bool (__fastcall *getClosestMonitorRect)(WindowStatePlatform *this, const tagRECT *, tagRECT *);
  bool (__fastcall *getAdjustedWindowRect)(WindowStatePlatform *this, const tagRECT *, tagRECT *);
};

# `WarpedFungusOnAStickItem`

struct __cppobj WarpedFungusOnAStickItem : Item
{
};

# `WeakRefT<SharePtrRefTraits<FogDefinition> >`

struct __cppobj WeakRefT<SharePtrRefTraits<FogDefinition> > : WeakStorageSharePtr<FogDefinition>
{
};

# `WallClimberPathNavigation`

struct __cppobj __declspec(align(8)) WallClimberPathNavigation : PathNavigation
{
  BlockPos mPathToPosition;
};

# `WallClimberPathNavigation_vtbl`

struct /*VFT*/ WallClimberPathNavigation_vtbl
{
  void (__fastcall *~PathNavigation)(PathNavigation *this);
  void (__fastcall *initializeInternal)(PathNavigation *this, Mob *, NavigationDescription *);
  void (__fastcall *tick)(PathNavigation *this, NavigationComponent *, Mob *);
  Vec3 *(__fastcall *getTempMobPos)(PathNavigation *this, Vec3 *result, const Mob *);
  std::unique_ptr<Path> *(__fastcall *createPath)(PathNavigation *this, std::unique_ptr<Path> *result, NavigationComponent *, Mob *, Actor *);
  std::unique_ptr<Path> *(__fastcall *createPath)(PathNavigation *this, std::unique_ptr<Path> *result, NavigationComponent *, Mob *, const Vec3 *);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, std::unique_ptr<Path>, float);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, Actor *, float);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, const Vec3 *, float);
  void (__fastcall *stop)(PathNavigation *this, NavigationComponent *, Mob *);
  bool (__fastcall *travel)(PathNavigation *this, NavigationComponent *, Mob *, float *, float *, float *);
  bool (__fastcall *canUpdatePath)(PathNavigation *this, const Mob *);
  void (__fastcall *updatePath)(PathNavigation *this, NavigationComponent *, Mob *);
};

# `WaterBoundPathNavigation`

struct __cppobj __declspec(align(8)) WaterBoundPathNavigation : PathNavigation
{
  bool mAllowRiverFollow;
  bool mFollowingRiver;
  int mHeadingTicks;
  float mCenteredThreshold;
  float mLookAheadDistance;
  float mMinDepth;
  float mMaxDepth;
  float mSteerDampening;
  float mTerrainAvoidDistance;
  float mXBodyRotation;
  float mYBodyRotation;
  float mZBodyRotation;
};

# `WaterBoundPathNavigation_vtbl`

struct /*VFT*/ WaterBoundPathNavigation_vtbl
{
  void (__fastcall *~PathNavigation)(PathNavigation *this);
  void (__fastcall *initializeInternal)(PathNavigation *this, Mob *, NavigationDescription *);
  void (__fastcall *tick)(PathNavigation *this, NavigationComponent *, Mob *);
  Vec3 *(__fastcall *getTempMobPos)(PathNavigation *this, Vec3 *result, const Mob *);
  std::unique_ptr<Path> *(__fastcall *createPath)(PathNavigation *this, std::unique_ptr<Path> *result, NavigationComponent *, Mob *, Actor *);
  std::unique_ptr<Path> *(__fastcall *createPath)(PathNavigation *this, std::unique_ptr<Path> *result, NavigationComponent *, Mob *, const Vec3 *);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, std::unique_ptr<Path>, float);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, Actor *, float);
  bool (__fastcall *moveTo)(PathNavigation *this, NavigationComponent *, Mob *, const Vec3 *, float);
  void (__fastcall *stop)(PathNavigation *this, NavigationComponent *, Mob *);
  bool (__fastcall *travel)(PathNavigation *this, NavigationComponent *, Mob *, float *, float *, float *);
  bool (__fastcall *canUpdatePath)(PathNavigation *this, const Mob *);
  void (__fastcall *updatePath)(PathNavigation *this, NavigationComponent *, Mob *);
};

# `WeightedChoice<float>`

struct __cppobj WeightedChoice<float>
{
  float mValue;
  WeighedRandom::WeighedRandomItem mRandomItem;
};

# `WeightChoiceEntry`

struct __cppobj WeightChoiceEntry
{
  float mValue;
  int mWeight;
};

# `WorldTemplateManager::deleteWorldTemplateFiles::__l2::<lambda_879ae5facc2a7645b4bef781f15f6e8b>`

struct __cppobj WorldTemplateManager::deleteWorldTemplateFiles::__l2::<lambda_879ae5facc2a7645b4bef781f15f6e8b>
{
};

# `WorldTemplateManager::sortWorldTemplates::__l2::<lambda_b611fc3d7207c313e3ad097dee8890a9>`

struct __cppobj WorldTemplateManager::sortWorldTemplates::__l2::<lambda_b611fc3d7207c313e3ad097dee8890a9>
{
};

# `WorldTemplateManager::populateWorldTemplates::__l2::<lambda_a8f01c0f99d7d727cedf75378286f27d>`

struct __cppobj WorldTemplateManager::populateWorldTemplates::__l2::<lambda_a8f01c0f99d7d727cedf75378286f27d>
{
  WorldTemplateManager *const __this;
};

# `WorldTemplateManager::_initialize::__l2::<lambda_da46403eef585604be7dcea1abb1850f>`

struct __cppobj WorldTemplateManager::_initialize::__l2::<lambda_da46403eef585604be7dcea1abb1850f>
{
  WorldTemplateManager *const __this;
};

# `WorldTemplateManager::_initialize::__l2::<lambda_8a8fa280401500a95dde7e6f66d98f11>`

struct __cppobj WorldTemplateManager::_initialize::__l2::<lambda_8a8fa280401500a95dde7e6f66d98f11>
{
  WorldTemplateManager *const __this;
};

# `WorldTemplateManager::_initialize::__l2::<lambda_a13fe90b17f2aab1a25ccf0bcb679bd7>`

struct __cppobj WorldTemplateManager::_initialize::__l2::<lambda_a13fe90b17f2aab1a25ccf0bcb679bd7>
{
  WorldTemplateManager *const __this;
};

# `WorldTemplateManager::{ctor}::__l5::<lambda_2233cedb99c86e6ea3d4023b62bb7714>`

struct __cppobj WorldTemplateManager::{ctor}::__l5::<lambda_2233cedb99c86e6ea3d4023b62bb7714>
{
  WorldTemplateManager *const __this;
};

# `WildcardCommandSelector<Actor>`

struct __cppobj WildcardCommandSelector<Actor> : CommandSelectorBase
{
};

# `WorldBuilderCommand`

struct __cppobj WorldBuilderCommand : Command
{
};

# `WorldBuilderCommand_vtbl`

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

# `WeatherCommand`

struct __cppobj __declspec(align(8)) WeatherCommand : Command
{
  WeatherCommand::WeatherRequest mRequest;
  WeatherCommand::WeatherType mType;
  int mDuration;
};

# `WeatherCommand_vtbl`

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

# `WSServerCommand`

struct __cppobj WSServerCommand : Command
{
  CommandRawText mServerIP;
};

# `WSServerCommand_vtbl`

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

# `WASDControlledDefinition`

struct __cppobj WASDControlledDefinition
{
};

# `WebSocketCommunicator::_setSocketType::__l35::<lambda_9200a0b4f0590b5c724210d777f36885>`

struct __cppobj WebSocketCommunicator::_setSocketType::__l35::<lambda_9200a0b4f0590b5c724210d777f36885>
{
  WebSocketCommunicator *const __this;
};

# `WebSocketCommunicator::_setSocketType::__l35::<lambda_c7fb2e7565f20c4ba57baf67d4895ec9>`

struct __cppobj WebSocketCommunicator::_setSocketType::__l35::<lambda_c7fb2e7565f20c4ba57baf67d4895ec9>
{
  WebSocketCommunicator *const __this;
};

# `WebSocketCommunicator::_setSocketType::__l35::<lambda_4605c10ca3f9755cf0a42d8b0713c209>`

struct __cppobj WebSocketCommunicator::_setSocketType::__l35::<lambda_4605c10ca3f9755cf0a42d8b0713c209>
{
  WebSocketCommunicator *const __this;
};

# `WaterAnimal`

struct __cppobj WaterAnimal : Mob
{
};

# `WalkAnimationSpeedDefinition`

struct __cppobj WalkAnimationSpeedDefinition
{
  float mValue;
};

# `WantsJockeyDefinition`

struct __cppobj WantsJockeyDefinition
{
};

# `WitherTargetHighestDamage`

struct __cppobj WitherTargetHighestDamage : TargetGoal
{
  WitherBoss *mWitherBoss;
  Mob *mTarget;
};

# `WitherTargetHighestDamage_vtbl`

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

# `WanderingTraderScheduler::_canWanderingTraderBeMoved::__l2::<lambda_420706ec78f9ef51480072bda79682b1>`

struct __cppobj WanderingTraderScheduler::_canWanderingTraderBeMoved::__l2::<lambda_420706ec78f9ef51480072bda79682b1>
{
  bool *isWanderingTraderNearAnyPlayer;
  const BlockPos *wanderingTraderPos;
};

# `WaitNode`

struct __cppobj WaitNode : BehaviorNode
{
  std::chrono::duration<__int64,std::ratio<1,1> > mDuration;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStart;
};

# `WaitNode_vtbl`

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

# `WaitDefinition`

struct __cppobj WaitDefinition : BehaviorDefinition
{
  int mDuration;
  std::string mDurationId;
};

# `WaitDefinition_vtbl`

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

# `WaitTicksNode`

struct __cppobj WaitTicksNode : BehaviorNode
{
  int mMaxTicks;
  int mCurrTicks;
};

# `WaitTicksNode_vtbl`

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

# `WaitTicksDefinition`

struct __cppobj WaitTicksDefinition : BehaviorDefinition
{
  int mTicks;
  std::string mTicksId;
};

# `WaitTicksDefinition_vtbl`

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

# `WitherBossSpawnUtilities::<lambda_c2ad78365cfbcde11b5d2eb5c63ceb17>`

struct __cppobj WitherBossSpawnUtilities::<lambda_c2ad78365cfbcde11b5d2eb5c63ceb17>
{
};

# `WitherBossSpawnUtilities::<lambda_9531a7d6547a6de40378d65926125801>`

struct __cppobj WitherBossSpawnUtilities::<lambda_9531a7d6547a6de40378d65926125801>
{
};

# `WitherDoNothingGoal`

struct __cppobj WitherDoNothingGoal : Goal
{
  WitherBoss *mWitherBoss;
};

# `WitherDoNothingGoal_vtbl`

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

# `WitherBoss::awardSpawnWitherAchievement::__l2::<lambda_af5e26c4282b05f2e97f46f370bbc414>`

struct __cppobj WitherBoss::awardSpawnWitherAchievement::__l2::<lambda_af5e26c4282b05f2e97f46f370bbc414>
{
  AABB *areaofeffect;
};

# `Witch`

struct __cppobj __declspec(align(8)) Witch : HumanoidMonster
{
  int mUsingTime;
};

# `WanderingTrader`

struct __cppobj __declspec(align(8)) WanderingTrader : Mob
{
  float mRaiseArmValue;
};

# `WitherSkull`

struct __cppobj __declspec(align(8)) WitherSkull : Fireball
{
  int mLifetime;
};

# `WitherSkull_vtbl`

struct /*VFT*/ WitherSkull_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  float (__fastcall *getInertia)(Fireball *this);
  void (__fastcall *onHit)(Fireball *this, const HitResult *);
  ParticleType (__fastcall *getTrailParticle)(Fireball *this);
  bool (__fastcall *shouldBurn)(Fireball *this);
};

# `WeaponRecipes`

struct __cppobj WeaponRecipes
{
};

# `WaterLilyBlockItem`

struct __cppobj WaterLilyBlockItem : BlockItem
{
};

# `WoodSlabBlockItem`

struct __cppobj WoodSlabBlockItem : DeprecatedSlabBlockItem
{
};

# `WeaponItem`

struct __cppobj WeaponItem : Item
{
  int mDamage;
  const Item::Tier mTier;
};

# `WorldGenClimateMappingAttributes::WeightedTemperatureCategory`

struct WorldGenClimateMappingAttributes::WeightedTemperatureCategory
{
  _BYTE mTemperature[1];
  unsigned int mWeight;
};

# `WorldGenMultiNoiseClimateAttributes`

struct __cppobj WorldGenMultiNoiseClimateAttributes
{
  float mTemperature;
  float mHumidity;
  float mAltitude;
  float mWeirdness;
  float mWeight;
};

# `WeightedBiomeAttributes<HillsTransformation>`

struct __cppobj WeightedBiomeAttributes<HillsTransformation>
{
  std::vector<std::pair<Biome *,unsigned int>> mBiomes;
};

# `WeightedBiomeAttributes<MutateBiomeTransformation>`

struct __cppobj WeightedBiomeAttributes<MutateBiomeTransformation>
{
  std::vector<std::pair<Biome *,unsigned int>> mBiomes;
};

# `WorldBlockTarget`

struct __cppobj WorldBlockTarget : IBlockWorldGenAPI
{
  BlockSource *mBlockSource;
};

# `WorldBlockTarget_vtbl`

struct /*VFT*/ WorldBlockTarget_vtbl
{
  void (__fastcall *~IBlockWorldGenAPI)(IBlockWorldGenAPI *this);
  const Block *(__fastcall *getBlock)(IBlockWorldGenAPI *this, const BlockPos *);
  bool (__fastcall *hasBiomeTag)(IBlockWorldGenAPI *this, unsigned __int64, const BlockPos *);
  bool (__fastcall *setBlock)(IBlockWorldGenAPI *this, const BlockPos *, const Block *, int);
  bool (__fastcall *apply)(IBlockWorldGenAPI *this);
  bool (__fastcall *placeStructure)(IBlockWorldGenAPI *this, const BlockPos *, StructureTemplate *, StructureSettings *);
  bool (__fastcall *mayPlace)(IBlockWorldGenAPI *this, const BlockPos *, const Block *);
  bool (__fastcall *canSurvive)(IBlockWorldGenAPI *this, const BlockPos *, const Block *);
  __int16 (__fastcall *getMaxHeight)(IBlockWorldGenAPI *this);
  __int16 (__fastcall *getMinHeight)(IBlockWorldGenAPI *this);
  bool (__fastcall *shimPlaceForOldFeatures)(IBlockWorldGenAPI *this, const Feature *, const BlockPos *, Random *);
  __int16 (__fastcall *getHeightmap)(IBlockWorldGenAPI *this, int, int);
  bool (__fastcall *isLegacyLevel)(IBlockWorldGenAPI *this);
};

# `WeakPtr<MicroBlock>`

struct __cppobj WeakPtr<MicroBlock>
{
  SharedCounter<MicroBlock> *pc;
};

# `WaterlilyBlock`

struct __cppobj WaterlilyBlock : BushBlock
{
};

# `WaterlilyBlock_vtbl`

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

# `WebBlock`

struct __cppobj WebBlock : BlockLegacy
{
};

# `WebBlock_vtbl`

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

# `WoolCarpetBlock`

struct __cppobj WoolCarpetBlock : BlockLegacy
{
};

# `WoolCarpetBlock_vtbl`

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

# `WorkbenchBlock`

struct __cppobj WorkbenchBlock : BlockLegacy
{
};

# `WorkbenchBlock_vtbl`

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

# `WoodButtonBlock`

struct __cppobj WoodButtonBlock : ButtonBlock
{
};

# `WoodButtonBlock_vtbl`

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

# `WeightedPressurePlateBlock`

struct __cppobj __declspec(align(8)) WeightedPressurePlateBlock : BasePressurePlateBlock
{
  const int maxWeight;
};

# `WeightedPressurePlateBlock_vtbl`

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

# `WoodSlabBlock`

struct __cppobj WoodSlabBlock : SlabBlock
{
};

# `WoodSlabBlock_vtbl`

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

# `WoodBlock`

struct __cppobj WoodBlock : RotatedPillarBlock
{
};

# `WoodBlock_vtbl`

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

# `WitherRoseBlock`

struct __cppobj WitherRoseBlock : FlowerBlock
{
};

# `WitherRoseBlock_vtbl`

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

# `WeepingVinesBlock`

struct __cppobj WeepingVinesBlock : BlockLegacy
{
};

# `WeepingVinesBlock_vtbl`

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

# `WeakPtr<AirBlock>`

struct __cppobj WeakPtr<AirBlock>
{
  SharedCounter<AirBlock> *pc;
};

# `WeakPtr<StoneBlock>`

struct __cppobj WeakPtr<StoneBlock>
{
  SharedCounter<StoneBlock> *pc;
};

# `WeakPtr<GrassBlock>`

struct __cppobj WeakPtr<GrassBlock>
{
  SharedCounter<GrassBlock> *pc;
};

# `WeakPtr<DirtBlock>`

struct __cppobj WeakPtr<DirtBlock>
{
  SharedCounter<DirtBlock> *pc;
};

# `WeakPtr<PlanksBlock>`

struct __cppobj WeakPtr<PlanksBlock>
{
  SharedCounter<PlanksBlock> *pc;
};

# `WeakPtr<Sapling>`

struct __cppobj WeakPtr<Sapling>
{
  SharedCounter<Sapling> *pc;
};

# `WeakPtr<BedrockBlock>`

struct __cppobj WeakPtr<BedrockBlock>
{
  SharedCounter<BedrockBlock> *pc;
};

# `WeakPtr<LiquidBlockDynamic>`

struct __cppobj WeakPtr<LiquidBlockDynamic>
{
  SharedCounter<LiquidBlockDynamic> *pc;
};

# `WeakPtr<LiquidBlockStatic>`

struct __cppobj WeakPtr<LiquidBlockStatic>
{
  SharedCounter<LiquidBlockStatic> *pc;
};

# `WeakPtr<SandBlock>`

struct __cppobj WeakPtr<SandBlock>
{
  SharedCounter<SandBlock> *pc;
};

# `WeakPtr<GravelBlock>`

struct __cppobj WeakPtr<GravelBlock>
{
  SharedCounter<GravelBlock> *pc;
};

# `WeakPtr<OreBlock>`

struct __cppobj WeakPtr<OreBlock>
{
  SharedCounter<OreBlock> *pc;
};

# `WeakPtr<OldLogBlock>`

struct __cppobj WeakPtr<OldLogBlock>
{
  SharedCounter<OldLogBlock> *pc;
};

# `WeakPtr<OldLeafBlock>`

struct __cppobj WeakPtr<OldLeafBlock>
{
  SharedCounter<OldLeafBlock> *pc;
};

# `WeakPtr<SpongeBlock>`

struct __cppobj WeakPtr<SpongeBlock>
{
  SharedCounter<SpongeBlock> *pc;
};

# `WeakPtr<GlassBlock>`

struct __cppobj WeakPtr<GlassBlock>
{
  SharedCounter<GlassBlock> *pc;
};

# `WeakPtr<DispenserBlock>`

struct __cppobj WeakPtr<DispenserBlock>
{
  SharedCounter<DispenserBlock> *pc;
};

# `WeakPtr<SandStoneBlock>`

struct __cppobj WeakPtr<SandStoneBlock>
{
  SharedCounter<SandStoneBlock> *pc;
};

# `WeakPtr<NoteBlock>`

struct __cppobj WeakPtr<NoteBlock>
{
  SharedCounter<NoteBlock> *pc;
};

# `WeakPtr<BedBlock>`

struct __cppobj WeakPtr<BedBlock>
{
  SharedCounter<BedBlock> *pc;
};

# `WeakPtr<PoweredRailBlock>`

struct __cppobj WeakPtr<PoweredRailBlock>
{
  SharedCounter<PoweredRailBlock> *pc;
};

# `WeakPtr<DetectorRailBlock>`

struct __cppobj WeakPtr<DetectorRailBlock>
{
  SharedCounter<DetectorRailBlock> *pc;
};

# `WeakPtr<PistonBlock>`

struct __cppobj WeakPtr<PistonBlock>
{
  SharedCounter<PistonBlock> *pc;
};

# `WeakPtr<WebBlock>`

struct __cppobj WeakPtr<WebBlock>
{
  SharedCounter<WebBlock> *pc;
};

# `WeakPtr<TallGrass>`

struct __cppobj WeakPtr<TallGrass>
{
  SharedCounter<TallGrass> *pc;
};

# `WeakPtr<DeadBush>`

struct __cppobj WeakPtr<DeadBush>
{
  SharedCounter<DeadBush> *pc;
};

# `WeakPtr<PistonArmBlock>`

struct __cppobj WeakPtr<PistonArmBlock>
{
  SharedCounter<PistonArmBlock> *pc;
};

# `WeakPtr<ClothBlock>`

struct __cppobj WeakPtr<ClothBlock>
{
  SharedCounter<ClothBlock> *pc;
};

# `WeakPtr<FlowerBlock>`

struct __cppobj WeakPtr<FlowerBlock>
{
  SharedCounter<FlowerBlock> *pc;
};

# `WeakPtr<MushroomBlock>`

struct __cppobj WeakPtr<MushroomBlock>
{
  SharedCounter<MushroomBlock> *pc;
};

# `WeakPtr<MetalBlock>`

struct __cppobj WeakPtr<MetalBlock>
{
  SharedCounter<MetalBlock> *pc;
};

# `WeakPtr<StoneSlabBlock>`

struct __cppobj WeakPtr<StoneSlabBlock>
{
  SharedCounter<StoneSlabBlock> *pc;
};

# `WeakPtr<TntBlock>`

struct __cppobj WeakPtr<TntBlock>
{
  SharedCounter<TntBlock> *pc;
};

# `WeakPtr<BookshelfBlock>`

struct __cppobj WeakPtr<BookshelfBlock>
{
  SharedCounter<BookshelfBlock> *pc;
};

# `WeakPtr<ObsidianBlock>`

struct __cppobj WeakPtr<ObsidianBlock>
{
  SharedCounter<ObsidianBlock> *pc;
};

# `WeakPtr<TorchBlock>`

struct __cppobj WeakPtr<TorchBlock>
{
  SharedCounter<TorchBlock> *pc;
};

# `WeakPtr<MobSpawnerBlock>`

struct __cppobj WeakPtr<MobSpawnerBlock>
{
  SharedCounter<MobSpawnerBlock> *pc;
};

# `WeakPtr<StairBlock>`

struct __cppobj WeakPtr<StairBlock>
{
  SharedCounter<StairBlock> *pc;
};

# `WeakPtr<ChestBlock>`

struct __cppobj WeakPtr<ChestBlock>
{
  SharedCounter<ChestBlock> *pc;
};

# `WeakPtr<RedStoneWireBlock>`

struct __cppobj WeakPtr<RedStoneWireBlock>
{
  SharedCounter<RedStoneWireBlock> *pc;
};

# `WeakPtr<WorkbenchBlock>`

struct __cppobj WeakPtr<WorkbenchBlock>
{
  SharedCounter<WorkbenchBlock> *pc;
};

# `WeakPtr<CropBlock>`

struct __cppobj WeakPtr<CropBlock>
{
  SharedCounter<CropBlock> *pc;
};

# `WeakPtr<FarmBlock>`

struct __cppobj WeakPtr<FarmBlock>
{
  SharedCounter<FarmBlock> *pc;
};

# `WeakPtr<FurnaceBlock>`

struct __cppobj WeakPtr<FurnaceBlock>
{
  SharedCounter<FurnaceBlock> *pc;
};

# `WeakPtr<SignBlock>`

struct __cppobj WeakPtr<SignBlock>
{
  SharedCounter<SignBlock> *pc;
};

# `WeakPtr<DoorBlock>`

struct __cppobj WeakPtr<DoorBlock>
{
  SharedCounter<DoorBlock> *pc;
};

# `WeakPtr<LadderBlock>`

struct __cppobj WeakPtr<LadderBlock>
{
  SharedCounter<LadderBlock> *pc;
};

# `WeakPtr<RailBlock>`

struct __cppobj WeakPtr<RailBlock>
{
  SharedCounter<RailBlock> *pc;
};

# `WeakPtr<LeverBlock>`

struct __cppobj WeakPtr<LeverBlock>
{
  SharedCounter<LeverBlock> *pc;
};

# `WeakPtr<PressurePlateBlock>`

struct __cppobj WeakPtr<PressurePlateBlock>
{
  SharedCounter<PressurePlateBlock> *pc;
};

# `WeakPtr<RedStoneOreBlock>`

struct __cppobj WeakPtr<RedStoneOreBlock>
{
  SharedCounter<RedStoneOreBlock> *pc;
};

# `WeakPtr<RedstoneTorchBlock>`

struct __cppobj WeakPtr<RedstoneTorchBlock>
{
  SharedCounter<RedstoneTorchBlock> *pc;
};

# `WeakPtr<StoneButtonBlock>`

struct __cppobj WeakPtr<StoneButtonBlock>
{
  SharedCounter<StoneButtonBlock> *pc;
};

# `WeakPtr<TopSnowBlock>`

struct __cppobj WeakPtr<TopSnowBlock>
{
  SharedCounter<TopSnowBlock> *pc;
};

# `WeakPtr<IceBlock>`

struct __cppobj WeakPtr<IceBlock>
{
  SharedCounter<IceBlock> *pc;
};

# `WeakPtr<SnowBlock>`

struct __cppobj WeakPtr<SnowBlock>
{
  SharedCounter<SnowBlock> *pc;
};

# `WeakPtr<CactusBlock>`

struct __cppobj WeakPtr<CactusBlock>
{
  SharedCounter<CactusBlock> *pc;
};

# `WeakPtr<ClayBlock>`

struct __cppobj WeakPtr<ClayBlock>
{
  SharedCounter<ClayBlock> *pc;
};

# `WeakPtr<ReedBlock>`

struct __cppobj WeakPtr<ReedBlock>
{
  SharedCounter<ReedBlock> *pc;
};

# `WeakPtr<JukeboxBlock>`

struct __cppobj WeakPtr<JukeboxBlock>
{
  SharedCounter<JukeboxBlock> *pc;
};

# `WeakPtr<FenceBlock>`

struct __cppobj WeakPtr<FenceBlock>
{
  SharedCounter<FenceBlock> *pc;
};

# `WeakPtr<PumpkinBlock>`

struct __cppobj WeakPtr<PumpkinBlock>
{
  SharedCounter<PumpkinBlock> *pc;
};

# `WeakPtr<NetherrackBlock>`

struct __cppobj WeakPtr<NetherrackBlock>
{
  SharedCounter<NetherrackBlock> *pc;
};

# `WeakPtr<SoulSandBlock>`

struct __cppobj WeakPtr<SoulSandBlock>
{
  SharedCounter<SoulSandBlock> *pc;
};

# `WeakPtr<LightGemBlock>`

struct __cppobj WeakPtr<LightGemBlock>
{
  SharedCounter<LightGemBlock> *pc;
};

# `WeakPtr<PortalBlock>`

struct __cppobj WeakPtr<PortalBlock>
{
  SharedCounter<PortalBlock> *pc;
};

# `WeakPtr<CakeBlock>`

struct __cppobj WeakPtr<CakeBlock>
{
  SharedCounter<CakeBlock> *pc;
};

# `WeakPtr<RepeaterBlock>`

struct __cppobj WeakPtr<RepeaterBlock>
{
  SharedCounter<RepeaterBlock> *pc;
};

# `WeakPtr<InvisibleBlock>`

struct __cppobj WeakPtr<InvisibleBlock>
{
  SharedCounter<InvisibleBlock> *pc;
};

# `WeakPtr<TrapDoorBlock>`

struct __cppobj WeakPtr<TrapDoorBlock>
{
  SharedCounter<TrapDoorBlock> *pc;
};

# `WeakPtr<MonsterEggBlock>`

struct __cppobj WeakPtr<MonsterEggBlock>
{
  SharedCounter<MonsterEggBlock> *pc;
};

# `WeakPtr<StoneBrickBlock>`

struct __cppobj WeakPtr<StoneBrickBlock>
{
  SharedCounter<StoneBrickBlock> *pc;
};

# `WeakPtr<HugeMushroomBlock>`

struct __cppobj WeakPtr<HugeMushroomBlock>
{
  SharedCounter<HugeMushroomBlock> *pc;
};

# `WeakPtr<ThinFenceBlock>`

struct __cppobj WeakPtr<ThinFenceBlock>
{
  SharedCounter<ThinFenceBlock> *pc;
};

# `WeakPtr<MelonBlock>`

struct __cppobj WeakPtr<MelonBlock>
{
  SharedCounter<MelonBlock> *pc;
};

# `WeakPtr<StemBlock>`

struct __cppobj WeakPtr<StemBlock>
{
  SharedCounter<StemBlock> *pc;
};

# `WeakPtr<VineBlock>`

struct __cppobj WeakPtr<VineBlock>
{
  SharedCounter<VineBlock> *pc;
};

# `WeakPtr<FenceGateBlock>`

struct __cppobj WeakPtr<FenceGateBlock>
{
  SharedCounter<FenceGateBlock> *pc;
};

# `WeakPtr<MyceliumBlock>`

struct __cppobj WeakPtr<MyceliumBlock>
{
  SharedCounter<MyceliumBlock> *pc;
};

# `WeakPtr<WaterlilyBlock>`

struct __cppobj WeakPtr<WaterlilyBlock>
{
  SharedCounter<WaterlilyBlock> *pc;
};

# `WeakPtr<NetherWartBlock>`

struct __cppobj WeakPtr<NetherWartBlock>
{
  SharedCounter<NetherWartBlock> *pc;
};

# `WeakPtr<EnchantingTableBlock>`

struct __cppobj WeakPtr<EnchantingTableBlock>
{
  SharedCounter<EnchantingTableBlock> *pc;
};

# `WeakPtr<BrewingStandBlock>`

struct __cppobj WeakPtr<BrewingStandBlock>
{
  SharedCounter<BrewingStandBlock> *pc;
};

# `WeakPtr<CauldronBlock>`

struct __cppobj WeakPtr<CauldronBlock>
{
  SharedCounter<CauldronBlock> *pc;
};

# `WeakPtr<EndPortalBlock>`

struct __cppobj WeakPtr<EndPortalBlock>
{
  SharedCounter<EndPortalBlock> *pc;
};

# `WeakPtr<EndPortalFrameBlock>`

struct __cppobj WeakPtr<EndPortalFrameBlock>
{
  SharedCounter<EndPortalFrameBlock> *pc;
};

# `WeakPtr<DragonEggBlock>`

struct __cppobj WeakPtr<DragonEggBlock>
{
  SharedCounter<DragonEggBlock> *pc;
};

# `WeakPtr<RedstoneLampBlock>`

struct __cppobj WeakPtr<RedstoneLampBlock>
{
  SharedCounter<RedstoneLampBlock> *pc;
};

# `WeakPtr<DropperBlock>`

struct __cppobj WeakPtr<DropperBlock>
{
  SharedCounter<DropperBlock> *pc;
};

# `WeakPtr<ActivatorRailBlock>`

struct __cppobj WeakPtr<ActivatorRailBlock>
{
  SharedCounter<ActivatorRailBlock> *pc;
};

# `WeakPtr<CocoaBlock>`

struct __cppobj WeakPtr<CocoaBlock>
{
  SharedCounter<CocoaBlock> *pc;
};

# `WeakPtr<EnderChestBlock>`

struct __cppobj WeakPtr<EnderChestBlock>
{
  SharedCounter<EnderChestBlock> *pc;
};

# `WeakPtr<TripWireHookBlock>`

struct __cppobj WeakPtr<TripWireHookBlock>
{
  SharedCounter<TripWireHookBlock> *pc;
};

# `WeakPtr<TripWireBlock>`

struct __cppobj WeakPtr<TripWireBlock>
{
  SharedCounter<TripWireBlock> *pc;
};

# `WeakPtr<CommandBlock>`

struct __cppobj WeakPtr<CommandBlock>
{
  SharedCounter<CommandBlock> *pc;
};

# `WeakPtr<BeaconBlock>`

struct __cppobj WeakPtr<BeaconBlock>
{
  SharedCounter<BeaconBlock> *pc;
};

# `WeakPtr<WallBlock>`

struct __cppobj WeakPtr<WallBlock>
{
  SharedCounter<WallBlock> *pc;
};

# `WeakPtr<FlowerPotBlock>`

struct __cppobj WeakPtr<FlowerPotBlock>
{
  SharedCounter<FlowerPotBlock> *pc;
};

# `WeakPtr<CarrotBlock>`

struct __cppobj WeakPtr<CarrotBlock>
{
  SharedCounter<CarrotBlock> *pc;
};

# `WeakPtr<PotatoBlock>`

struct __cppobj WeakPtr<PotatoBlock>
{
  SharedCounter<PotatoBlock> *pc;
};

# `WeakPtr<WoodButtonBlock>`

struct __cppobj WeakPtr<WoodButtonBlock>
{
  SharedCounter<WoodButtonBlock> *pc;
};

# `WeakPtr<SkullBlock>`

struct __cppobj WeakPtr<SkullBlock>
{
  SharedCounter<SkullBlock> *pc;
};

# `WeakPtr<AnvilBlock>`

struct __cppobj WeakPtr<AnvilBlock>
{
  SharedCounter<AnvilBlock> *pc;
};

# `WeakPtr<WeightedPressurePlateBlock>`

struct __cppobj WeakPtr<WeightedPressurePlateBlock>
{
  SharedCounter<WeightedPressurePlateBlock> *pc;
};

# `WeakPtr<ComparatorBlock>`

struct __cppobj WeakPtr<ComparatorBlock>
{
  SharedCounter<ComparatorBlock> *pc;
};

# `WeakPtr<DaylightDetectorBlock>`

struct __cppobj WeakPtr<DaylightDetectorBlock>
{
  SharedCounter<DaylightDetectorBlock> *pc;
};

# `WeakPtr<RedstoneBlock>`

struct __cppobj WeakPtr<RedstoneBlock>
{
  SharedCounter<RedstoneBlock> *pc;
};

# `WeakPtr<HopperBlock>`

struct __cppobj WeakPtr<HopperBlock>
{
  SharedCounter<HopperBlock> *pc;
};

# `WeakPtr<QuartzBlockBlock>`

struct __cppobj WeakPtr<QuartzBlockBlock>
{
  SharedCounter<QuartzBlockBlock> *pc;
};

# `WeakPtr<WoodSlabBlock>`

struct __cppobj WeakPtr<WoodSlabBlock>
{
  SharedCounter<WoodSlabBlock> *pc;
};

# `WeakPtr<ColoredBlock>`

struct __cppobj WeakPtr<ColoredBlock>
{
  SharedCounter<ColoredBlock> *pc;
};

# `WeakPtr<StainedGlassPaneBlock>`

struct __cppobj WeakPtr<StainedGlassPaneBlock>
{
  SharedCounter<StainedGlassPaneBlock> *pc;
};

# `WeakPtr<NewLeafBlock>`

struct __cppobj WeakPtr<NewLeafBlock>
{
  SharedCounter<NewLeafBlock> *pc;
};

# `WeakPtr<NewLogBlock>`

struct __cppobj WeakPtr<NewLogBlock>
{
  SharedCounter<NewLogBlock> *pc;
};

# `WeakPtr<SlimeBlock>`

struct __cppobj WeakPtr<SlimeBlock>
{
  SharedCounter<SlimeBlock> *pc;
};

# `WeakPtr<PrismarineBlock>`

struct __cppobj WeakPtr<PrismarineBlock>
{
  SharedCounter<PrismarineBlock> *pc;
};

# `WeakPtr<SeaLanternBlock>`

struct __cppobj WeakPtr<SeaLanternBlock>
{
  SharedCounter<SeaLanternBlock> *pc;
};

# `WeakPtr<HayBlockBlock>`

struct __cppobj WeakPtr<HayBlockBlock>
{
  SharedCounter<HayBlockBlock> *pc;
};

# `WeakPtr<WoolCarpetBlock>`

struct __cppobj WeakPtr<WoolCarpetBlock>
{
  SharedCounter<WoolCarpetBlock> *pc;
};

# `WeakPtr<DoublePlantBlock>`

struct __cppobj WeakPtr<DoublePlantBlock>
{
  SharedCounter<DoublePlantBlock> *pc;
};

# `WeakPtr<BannerBlock>`

struct __cppobj WeakPtr<BannerBlock>
{
  SharedCounter<BannerBlock> *pc;
};

# `WeakPtr<StoneSlabBlock2>`

struct __cppobj WeakPtr<StoneSlabBlock2>
{
  SharedCounter<StoneSlabBlock2> *pc;
};

# `WeakPtr<GrassPathBlock>`

struct __cppobj WeakPtr<GrassPathBlock>
{
  SharedCounter<GrassPathBlock> *pc;
};

# `WeakPtr<ItemFrameBlock>`

struct __cppobj WeakPtr<ItemFrameBlock>
{
  SharedCounter<ItemFrameBlock> *pc;
};

# `WeakPtr<ChorusFlowerBlock>`

struct __cppobj WeakPtr<ChorusFlowerBlock>
{
  SharedCounter<ChorusFlowerBlock> *pc;
};

# `WeakPtr<UndyedShulkerBoxBlock>`

struct __cppobj WeakPtr<UndyedShulkerBoxBlock>
{
  SharedCounter<UndyedShulkerBoxBlock> *pc;
};

# `WeakPtr<FrostedIceBlock>`

struct __cppobj WeakPtr<FrostedIceBlock>
{
  SharedCounter<FrostedIceBlock> *pc;
};

# `WeakPtr<EndRodBlock>`

struct __cppobj WeakPtr<EndRodBlock>
{
  SharedCounter<EndRodBlock> *pc;
};

# `WeakPtr<BorderBlock>`

struct __cppobj WeakPtr<BorderBlock>
{
  SharedCounter<BorderBlock> *pc;
};

# `WeakPtr<MagmaBlock>`

struct __cppobj WeakPtr<MagmaBlock>
{
  SharedCounter<MagmaBlock> *pc;
};

# `WeakPtr<RotatedPillarBlock>`

struct __cppobj WeakPtr<RotatedPillarBlock>
{
  SharedCounter<RotatedPillarBlock> *pc;
};

# `WeakPtr<StructureVoid>`

struct __cppobj WeakPtr<StructureVoid>
{
  SharedCounter<StructureVoid> *pc;
};

# `WeakPtr<ShulkerBoxBlock>`

struct __cppobj WeakPtr<ShulkerBoxBlock>
{
  SharedCounter<ShulkerBoxBlock> *pc;
};

# `WeakPtr<GlazedTerracottaBlock>`

struct __cppobj WeakPtr<GlazedTerracottaBlock>
{
  SharedCounter<GlazedTerracottaBlock> *pc;
};

# `WeakPtr<ConcreteBlock>`

struct __cppobj WeakPtr<ConcreteBlock>
{
  SharedCounter<ConcreteBlock> *pc;
};

# `WeakPtr<ConcretePowderBlock>`

struct __cppobj WeakPtr<ConcretePowderBlock>
{
  SharedCounter<ConcretePowderBlock> *pc;
};

# `WeakPtr<ChorusPlantBlock>`

struct __cppobj WeakPtr<ChorusPlantBlock>
{
  SharedCounter<ChorusPlantBlock> *pc;
};

# `WeakPtr<StainedGlassBlock>`

struct __cppobj WeakPtr<StainedGlassBlock>
{
  SharedCounter<StainedGlassBlock> *pc;
};

# `WeakPtr<CameraBlock>`

struct __cppobj WeakPtr<CameraBlock>
{
  SharedCounter<CameraBlock> *pc;
};

# `WeakPtr<PodzolBlock>`

struct __cppobj WeakPtr<PodzolBlock>
{
  SharedCounter<PodzolBlock> *pc;
};

# `WeakPtr<BeetrootBlock>`

struct __cppobj WeakPtr<BeetrootBlock>
{
  SharedCounter<BeetrootBlock> *pc;
};

# `WeakPtr<StonecutterBlock>`

struct __cppobj WeakPtr<StonecutterBlock>
{
  SharedCounter<StonecutterBlock> *pc;
};

# `WeakPtr<NetherReactorBlock>`

struct __cppobj WeakPtr<NetherReactorBlock>
{
  SharedCounter<NetherReactorBlock> *pc;
};

# `WeakPtr<MovingBlock>`

struct __cppobj WeakPtr<MovingBlock>
{
  SharedCounter<MovingBlock> *pc;
};

# `WeakPtr<ObserverBlock>`

struct __cppobj WeakPtr<ObserverBlock>
{
  SharedCounter<ObserverBlock> *pc;
};

# `WeakPtr<StructureBlock>`

struct __cppobj WeakPtr<StructureBlock>
{
  SharedCounter<StructureBlock> *pc;
};

# `WeakPtr<StrippedLogBlock>`

struct __cppobj WeakPtr<StrippedLogBlock>
{
  SharedCounter<StrippedLogBlock> *pc;
};

# `WeakPtr<BlueIceBlock>`

struct __cppobj WeakPtr<BlueIceBlock>
{
  SharedCounter<BlueIceBlock> *pc;
};

# `WeakPtr<FireBlock>`

struct __cppobj WeakPtr<FireBlock>
{
  SharedCounter<FireBlock> *pc;
};

# `WeakPtr<ChemistryTableBlock>`

struct __cppobj WeakPtr<ChemistryTableBlock>
{
  SharedCounter<ChemistryTableBlock> *pc;
};

# `WeakPtr<UnderwaterTorchBlock>`

struct __cppobj WeakPtr<UnderwaterTorchBlock>
{
  SharedCounter<UnderwaterTorchBlock> *pc;
};

# `WeakPtr<ChemicalHeatBlock>`

struct __cppobj WeakPtr<ChemicalHeatBlock>
{
  SharedCounter<ChemicalHeatBlock> *pc;
};

# `WeakPtr<ColoredTorchBlock>`

struct __cppobj WeakPtr<ColoredTorchBlock>
{
  SharedCounter<ColoredTorchBlock> *pc;
};

# `WeakPtr<ModBlock>`

struct __cppobj WeakPtr<ModBlock>
{
  SharedCounter<ModBlock> *pc;
};

# `WeakPtr<ElementBlock>`

struct __cppobj WeakPtr<ElementBlock>
{
  SharedCounter<ElementBlock> *pc;
};

# `WeakPtr<Coral>`

struct __cppobj WeakPtr<Coral>
{
  SharedCounter<Coral> *pc;
};

# `WeakPtr<CoralBlock>`

struct __cppobj WeakPtr<CoralBlock>
{
  SharedCounter<CoralBlock> *pc;
};

# `WeakPtr<CoralFan>`

struct __cppobj WeakPtr<CoralFan>
{
  SharedCounter<CoralFan> *pc;
};

# `WeakPtr<CoralFanHang>`

struct __cppobj WeakPtr<CoralFanHang>
{
  SharedCounter<CoralFanHang> *pc;
};

# `WeakPtr<KelpBlock>`

struct __cppobj WeakPtr<KelpBlock>
{
  SharedCounter<KelpBlock> *pc;
};

# `WeakPtr<DriedKelpBlock>`

struct __cppobj WeakPtr<DriedKelpBlock>
{
  SharedCounter<DriedKelpBlock> *pc;
};

# `WeakPtr<SeaGrass>`

struct __cppobj WeakPtr<SeaGrass>
{
  SharedCounter<SeaGrass> *pc;
};

# `WeakPtr<SeaPickle>`

struct __cppobj WeakPtr<SeaPickle>
{
  SharedCounter<SeaPickle> *pc;
};

# `WeakPtr<ConduitBlock>`

struct __cppobj WeakPtr<ConduitBlock>
{
  SharedCounter<ConduitBlock> *pc;
};

# `WeakPtr<BubbleColumnBlock>`

struct __cppobj WeakPtr<BubbleColumnBlock>
{
  SharedCounter<BubbleColumnBlock> *pc;
};

# `WeakPtr<TurtleEggBlock>`

struct __cppobj WeakPtr<TurtleEggBlock>
{
  SharedCounter<TurtleEggBlock> *pc;
};

# `WeakPtr<BarrierBlock>`

struct __cppobj WeakPtr<BarrierBlock>
{
  SharedCounter<BarrierBlock> *pc;
};

# `WeakPtr<ScaffoldingBlock>`

struct __cppobj WeakPtr<ScaffoldingBlock>
{
  SharedCounter<ScaffoldingBlock> *pc;
};

# `WeakPtr<BambooBlock>`

struct __cppobj WeakPtr<BambooBlock>
{
  SharedCounter<BambooBlock> *pc;
};

# `WeakPtr<BambooSapling>`

struct __cppobj WeakPtr<BambooSapling>
{
  SharedCounter<BambooSapling> *pc;
};

# `WeakPtr<StoneSlabBlock3>`

struct __cppobj WeakPtr<StoneSlabBlock3>
{
  SharedCounter<StoneSlabBlock3> *pc;
};

# `WeakPtr<StoneSlabBlock4>`

struct __cppobj WeakPtr<StoneSlabBlock4>
{
  SharedCounter<StoneSlabBlock4> *pc;
};

# `WeakPtr<LecternBlock>`

struct __cppobj WeakPtr<LecternBlock>
{
  SharedCounter<LecternBlock> *pc;
};

# `WeakPtr<GrindstoneBlock>`

struct __cppobj WeakPtr<GrindstoneBlock>
{
  SharedCounter<GrindstoneBlock> *pc;
};

# `WeakPtr<BlastFurnaceBlock>`

struct __cppobj WeakPtr<BlastFurnaceBlock>
{
  SharedCounter<BlastFurnaceBlock> *pc;
};

# `WeakPtr<SmokerBlock>`

struct __cppobj WeakPtr<SmokerBlock>
{
  SharedCounter<SmokerBlock> *pc;
};

# `WeakPtr<CartographyTableBlock>`

struct __cppobj WeakPtr<CartographyTableBlock>
{
  SharedCounter<CartographyTableBlock> *pc;
};

# `WeakPtr<SmithingTableBlock>`

struct __cppobj WeakPtr<SmithingTableBlock>
{
  SharedCounter<SmithingTableBlock> *pc;
};

# `WeakPtr<BarrelBlock>`

struct __cppobj WeakPtr<BarrelBlock>
{
  SharedCounter<BarrelBlock> *pc;
};

# `WeakPtr<LoomBlock>`

struct __cppobj WeakPtr<LoomBlock>
{
  SharedCounter<LoomBlock> *pc;
};

# `WeakPtr<BellBlock>`

struct __cppobj WeakPtr<BellBlock>
{
  SharedCounter<BellBlock> *pc;
};

# `WeakPtr<SweetBerryBushBlock>`

struct __cppobj WeakPtr<SweetBerryBushBlock>
{
  SharedCounter<SweetBerryBushBlock> *pc;
};

# `WeakPtr<LanternBlock>`

struct __cppobj WeakPtr<LanternBlock>
{
  SharedCounter<LanternBlock> *pc;
};

# `WeakPtr<CampfireBlock>`

struct __cppobj WeakPtr<CampfireBlock>
{
  SharedCounter<CampfireBlock> *pc;
};

# `WeakPtr<JigsawBlock>`

struct __cppobj WeakPtr<JigsawBlock>
{
  SharedCounter<JigsawBlock> *pc;
};

# `WeakPtr<WoodBlock>`

struct __cppobj WeakPtr<WoodBlock>
{
  SharedCounter<WoodBlock> *pc;
};

# `WeakPtr<ComposterBlock>`

struct __cppobj WeakPtr<ComposterBlock>
{
  SharedCounter<ComposterBlock> *pc;
};

# `WeakPtr<LightBlock>`

struct __cppobj WeakPtr<LightBlock>
{
  SharedCounter<LightBlock> *pc;
};

# `WeakPtr<WitherRoseBlock>`

struct __cppobj WeakPtr<WitherRoseBlock>
{
  SharedCounter<WitherRoseBlock> *pc;
};

# `WeakPtr<BeehiveBlock>`

struct __cppobj WeakPtr<BeehiveBlock>
{
  SharedCounter<BeehiveBlock> *pc;
};

# `WeakPtr<HoneyBlock>`

struct __cppobj WeakPtr<HoneyBlock>
{
  SharedCounter<HoneyBlock> *pc;
};

# `WeakPtr<HoneycombBlock>`

struct __cppobj WeakPtr<HoneycombBlock>
{
  SharedCounter<HoneycombBlock> *pc;
};

# `WeakPtr<LodestoneBlock>`

struct __cppobj WeakPtr<LodestoneBlock>
{
  SharedCounter<LodestoneBlock> *pc;
};

# `WeakPtr<FungusStem>`

struct __cppobj WeakPtr<FungusStem>
{
  SharedCounter<FungusStem> *pc;
};

# `WeakPtr<NetherFungusBlock>`

struct __cppobj WeakPtr<NetherFungusBlock>
{
  SharedCounter<NetherFungusBlock> *pc;
};

# `WeakPtr<WeepingVinesBlock>`

struct __cppobj WeakPtr<WeepingVinesBlock>
{
  SharedCounter<WeepingVinesBlock> *pc;
};

# `WeakPtr<NyliumBlock>`

struct __cppobj WeakPtr<NyliumBlock>
{
  SharedCounter<NyliumBlock> *pc;
};

# `WeakPtr<BlueFireBlock>`

struct __cppobj WeakPtr<BlueFireBlock>
{
  SharedCounter<BlueFireBlock> *pc;
};

# `WeakPtr<NetherSprouts>`

struct __cppobj WeakPtr<NetherSprouts>
{
  SharedCounter<NetherSprouts> *pc;
};

# `WeakPtr<TargetBlock>`

struct __cppobj WeakPtr<TargetBlock>
{
  SharedCounter<TargetBlock> *pc;
};

# `WeakPtr<SlabBlock>`

struct __cppobj WeakPtr<SlabBlock>
{
  SharedCounter<SlabBlock> *pc;
};

# `WeakPtr<SoulTorchBlock>`

struct __cppobj WeakPtr<SoulTorchBlock>
{
  SharedCounter<SoulTorchBlock> *pc;
};

# `WeakPtr<RespawnAnchorBlock>`

struct __cppobj WeakPtr<RespawnAnchorBlock>
{
  SharedCounter<RespawnAnchorBlock> *pc;
};

# `WeakPtr<GildedBlackstone>`

struct __cppobj WeakPtr<GildedBlackstone>
{
  SharedCounter<GildedBlackstone> *pc;
};

# `WeakPtr<ChainBlock>`

struct __cppobj WeakPtr<ChainBlock>
{
  SharedCounter<ChainBlock> *pc;
};

# `WeakPtr<TwistingVinesBlock>`

struct __cppobj WeakPtr<TwistingVinesBlock>
{
  SharedCounter<TwistingVinesBlock> *pc;
};

# `WeakPtr<CryingObsidianBlock>`

struct __cppobj WeakPtr<CryingObsidianBlock>
{
  SharedCounter<CryingObsidianBlock> *pc;
};

# `WorldLimitChunkSource`

struct __cppobj WorldLimitChunkSource : ChunkSource
{
  std::shared_ptr<LevelChunk> mInvisibleWallChunk;
  const Bounds mLimitArea;
};

# `WorldLimitChunkSource_vtbl`

struct /*VFT*/ WorldLimitChunkSource_vtbl
{
  void (__fastcall *~ChunkSource)(ChunkSource *this);
  void (__fastcall *shutdown)(ChunkSource *this);
  bool (__fastcall *isShutdownDone)(ChunkSource *this);
  std::shared_ptr<LevelChunk> *(__fastcall *getExistingChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *);
  std::shared_ptr<LevelChunk> *(__fastcall *getRandomChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, Random *);
  std::shared_ptr<LevelChunk> *(__fastcall *createNewChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *, ChunkSource::LoadMode);
  std::shared_ptr<LevelChunk> *(__fastcall *getOrLoadChunk)(ChunkSource *this, std::shared_ptr<LevelChunk> *result, const ChunkPos *, ChunkSource::LoadMode);
  bool (__fastcall *postProcess)(ChunkSource *this, ChunkViewSource *);
  void (__fastcall *checkAndReplaceChunk)(ChunkSource *this, ChunkViewSource *, LevelChunk *);
  void (__fastcall *loadChunk)(ChunkSource *this, LevelChunk *, bool);
  void (__fastcall *postProcessMobsAt)(ChunkSource *this, BlockSource *, int, int, Random *);
  bool (__fastcall *saveLiveChunk)(ChunkSource *this, LevelChunk *);
  void (__fastcall *hintDiscardBatchBegin)(ChunkSource *this);
  void (__fastcall *hintDiscardBatchEnd)(ChunkSource *this);
  void (__fastcall *acquireDiscarded)(ChunkSource *this, std::unique_ptr<LevelChunk,LevelChunkFinalDeleter>);
  void (__fastcall *compact)(ChunkSource *this);
  void (__fastcall *flushPendingWrites)(ChunkSource *this);
  bool (__fastcall *isWithinWorldLimit)(ChunkSource *this, const ChunkPos *);
  const std::unordered_map<ChunkPos,std::weak_ptr<LevelChunk>> *(__fastcall *getChunkMap)(ChunkSource *this);
  const std::unordered_map<ChunkPos,std::weak_ptr<LevelChunk>> *(__fastcall *getStorage)(ChunkSource *this);
  void (__fastcall *clearDeletedEntities)(ChunkSource *this);
  void (__fastcall *removeDimensionData)(ChunkSource *this, const std::unordered_set<AutomaticID<Dimension,int>> *);
  bool (__fastcall *hasChunk)(ChunkSource *this, const ChunkPos *, AutomaticID<Dimension,int>);
  bool (__fastcall *canCreateViews)(ChunkSource *this);
};

# `WorldLimitChunkSource::<lambda_ca0895c5722a4068e6fcf38e3cc23ee8>`

struct __cppobj WorldLimitChunkSource::<lambda_ca0895c5722a4068e6fcf38e3cc23ee8>
{
  const BlockPos center;
  int width;
  int depth;
};

# `WorldLimitChunkSource::<lambda_6b97e3e7c1a28fa09b62b35649295fb0>`

struct __cppobj WorldLimitChunkSource::<lambda_6b97e3e7c1a28fa09b62b35649295fb0>
{
  const BlockPos center;
  int width;
  int depth;
};

# `WeightedRandomFeature`

struct __cppobj WeightedRandomFeature : IFeature
{
  std::vector<WeightedRandomFeature::WeightedFeatureReference> mFeatureReferences;
};

# `WeightedRandomFeature_vtbl`

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

# `Weather::dispatchLightningLevelChange::__l5::<lambda_a30f71feefff81157af865ebc0652677>`

struct __cppobj Weather::dispatchLightningLevelChange::__l5::<lambda_a30f71feefff81157af865ebc0652677>
{
  float *oldLevel;
  float *newLevel;
};

# `Weather::dispatchRainLevelChange::__l5::<lambda_7d63d31f4055aaafa2a801580cc68df5>`

struct __cppobj Weather::dispatchRainLevelChange::__l5::<lambda_7d63d31f4055aaafa2a801580cc68df5>
{
  float *oldLevel;
  float *newLevel;
};

# `WorldBlockTarget::tryPlaceStructure::__l14::<lambda_cc6f2204c24e9d9e4932150363b12ba7>`

struct __cppobj WorldBlockTarget::tryPlaceStructure::__l14::<lambda_cc6f2204c24e9d9e4932150363b12ba7>
{
  const std::string *structureName;
  const BlockPos *pos;
  WorldBlockTarget *const __this;
  Biome *biome;
};

# `WeakPtr<CustomCropBlock>`

struct __cppobj WeakPtr<CustomCropBlock>
{
  SharedCounter<CustomCropBlock> *pc;
};

# `WalkState`

struct __cppobj WalkState : PetSleepWithOwnerState
{
};

# `WalkState_vtbl`

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

# `WorkGoal`

struct __cppobj WorkGoal : MoveToPOIGoal
{
  POIType mPOIType;
  int mGoalCooldownMax;
  int mCooldownTick;
  int mGoalActiveMax;
  int mActiveTick;
  int mSoundIntervalMin;
  int mSoundIntervalMax;
  int mSoundTick;
  int mSoundTickMax;
  bool mCanWorkInRain;
  bool mCanRainAtLocation;
  int mRainCheckCooldownTick;
  int mWorkInRainTolerance;
  const DefinitionTrigger mOnArrival;
  bool mHasEverReachedJobsite;
  LevelSoundEvent mSoundEvent;
};

# `WorkGoal_vtbl`

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

# `WitherRandomAttackPosGoal`

struct __cppobj __declspec(align(8)) WitherRandomAttackPosGoal : RandomStrollGoal
{
  bool mIsPathing;
};

# `WitherRandomAttackPosGoal_vtbl`

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

# `WoodlandMansionFeature`

struct __cppobj WoodlandMansionFeature : StructureFeature
{
  int mFeatureSpacing;
  int mMinFeatureSeparation;
  std::vector<int> mAllowedBiomes;
  OverworldGenerator *mLevelSource;
};

# `WoodlandMansionFeature_vtbl`

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

# `WaterlilyFeature`

struct __cppobj WaterlilyFeature : Feature
{
};

# `WaterlilyFeature_vtbl`

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

# `WeepingVinesClusterFeature`

struct __cppobj WeepingVinesClusterFeature : Feature
{
};

# `WeepingVinesClusterFeature_vtbl`

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

# `WoodlandMansionPieces::SimpleGrid`

struct __cppobj __declspec(align(8)) WoodlandMansionPieces::SimpleGrid
{
  std::vector<std::vector<int>> mGrid;
  int mWidth;
  int mHeight;
  int mValueIfOutside;
};

# `WoodlandMansionPieces`

struct __cppobj WoodlandMansionPieces
{
};

# `WoodlandMansionPieces::WoodlandMansionPiece`

struct __cppobj WoodlandMansionPieces::WoodlandMansionPiece : TemplateStructurePiece
{
  StructureManager *mStructureManager;
  std::string mTemplateName;
  Rotation mRotation;
  Mirror mMirror;
  BlockPos mPosition;
  std::vector<BlockPos> mVindicatorPositions;
  std::vector<BlockPos> mEvokerPositions;
};

# `WoodlandMansionPieces::WoodlandMansionPiece_vtbl`

struct /*VFT*/ WoodlandMansionPieces::WoodlandMansionPiece_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 *);
};

# `WoodlandMansionPieces::PlacementData`

struct __cppobj WoodlandMansionPieces::PlacementData
{
  Rotation mRotation;
  BlockPos mPosition;
  std::string mWallType;
};

# `WoodlandMansionPieces::MansionGrid`

struct __cppobj WoodlandMansionPieces::MansionGrid
{
  std::unique_ptr<WoodlandMansionPieces::SimpleGrid> mBaseGrid;
  std::unique_ptr<WoodlandMansionPieces::SimpleGrid> mThirdFloorGrid;
  std::vector<std::unique_ptr<WoodlandMansionPieces::SimpleGrid>> mFloorRooms;
  int mEntranceX;
  int mEntranceY;
  Random *mRandom;
};

# `WoodlandMansionPieces::FloorRoomCollection`

struct __cppobj WoodlandMansionPieces::FloorRoomCollection
{
  WoodlandMansionPieces::FloorRoomCollection_vtbl *__vftable /*VFT*/;
};

# `WoodlandMansionPieces::FloorRoomCollection_vtbl`

struct /*VFT*/ WoodlandMansionPieces::FloorRoomCollection_vtbl
{
  void (__fastcall *~FloorRoomCollection)(WoodlandMansionPieces::FloorRoomCollection *this);
  std::string *(__fastcall *get1x1)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x1Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x2SideEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2FrontEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
};

# `WoodlandMansionPieces::MansionPiecePlacer`

struct __cppobj WoodlandMansionPieces::MansionPiecePlacer
{
  StructureManager *mStructureManager;
  Random *mRandom;
  int mStartX;
  int mStartY;
};

# `WoodlandMansionPieces::FirstFloorRoomCollection`

struct __cppobj WoodlandMansionPieces::FirstFloorRoomCollection : WoodlandMansionPieces::FloorRoomCollection
{
};

# `WoodlandMansionPieces::FirstFloorRoomCollection_vtbl`

struct /*VFT*/ WoodlandMansionPieces::FirstFloorRoomCollection_vtbl
{
  void (__fastcall *~FloorRoomCollection)(WoodlandMansionPieces::FloorRoomCollection *this);
  std::string *(__fastcall *get1x1)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x1Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x2SideEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2FrontEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
};

# `WoodlandMansionPieces::SecondFloorRoomCollection`

struct __cppobj WoodlandMansionPieces::SecondFloorRoomCollection : WoodlandMansionPieces::FloorRoomCollection
{
};

# `WoodlandMansionPieces::SecondFloorRoomCollection_vtbl`

struct /*VFT*/ WoodlandMansionPieces::SecondFloorRoomCollection_vtbl
{
  void (__fastcall *~FloorRoomCollection)(WoodlandMansionPieces::FloorRoomCollection *this);
  std::string *(__fastcall *get1x1)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x1Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x2SideEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2FrontEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
};

# `WoodlandMansionPieces::ThirdFloorRoomCollection`

struct __cppobj WoodlandMansionPieces::ThirdFloorRoomCollection : WoodlandMansionPieces::SecondFloorRoomCollection
{
};

# `WoodlandMansionPieces::ThirdFloorRoomCollection_vtbl`

struct /*VFT*/ WoodlandMansionPieces::ThirdFloorRoomCollection_vtbl
{
  void (__fastcall *~FloorRoomCollection)(WoodlandMansionPieces::FloorRoomCollection *this);
  std::string *(__fastcall *get1x1)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x1Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get1x2SideEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2FrontEntrance)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *, bool);
  std::string *(__fastcall *get1x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
  std::string *(__fastcall *get2x2Secret)(WoodlandMansionPieces::FloorRoomCollection *this, std::string *result, Random *);
};

# `WoodlandMansionStart`

struct __cppobj WoodlandMansionStart : StructureStart
{
  Rotation mRotationGenerated;
  BlockPos mPositionGenerated;
};

# `WoodlandMansionStart_vtbl`

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

# `WeakPtr<EndGatewayBlock>`

struct __cppobj WeakPtr<EndGatewayBlock>
{
  SharedCounter<EndGatewayBlock> *pc;
};

# `WSAStartupSingleton`

struct __cppobj WSAStartupSingleton
{
};

# `WatchdogTimer`

struct __cppobj WatchdogTimer
{
  std::unique_ptr<TaskGroup> mTaskGroup;
  TaskStartInfoEx<void> mTaskStartInfo;
  const std::chrono::duration<__int64,std::ratio<1,1> > mTimeoutTimeSeconds;
  std::function<std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > __cdecl(void)> mTimeoutCallback;
  std::shared_ptr<Bedrock::Threading::IAsyncResult<void> > mCurrentTaskHandle;
  std::mutex mLock;
  bool mHasBeenTerminated;
  const std::chrono::duration<__int64,std::ratio<1,1> > mDeadlineSeconds;
  bool mAssertAfterDeadline;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mLastQueueTime;
};

# `WildcardString`

struct __cppobj WildcardString
{
  std::basic_regex<char,std::regex_traits<char> > mWildcardRegex;
};

# `WOFF2_TtcFontRec_`

struct WOFF2_TtcFontRec_
{
  unsigned int flavor;
  unsigned __int16 num_tables;
  wchar_t *table_indices;
};

# `WOFF2_HeaderRec_`

struct WOFF2_HeaderRec_
{
  unsigned int signature;
  unsigned int flavor;
  unsigned int length;
  unsigned __int16 num_tables;
  unsigned int totalSfntSize;
  unsigned int totalCompressedSize;
  unsigned int metaOffset;
  unsigned int metaLength;
  unsigned int metaOrigLength;
  unsigned int privOffset;
  unsigned int privLength;
  unsigned int uncompressed_size;
  unsigned int compressed_offset;
  unsigned int header_version;
  unsigned __int16 num_fonts;
  unsigned int actual_sfnt_size;
  WOFF2_TtcFontRec_ *ttc_fonts;
};

# `WOFF2_SubstreamRec_`

struct WOFF2_SubstreamRec_
{
  unsigned int start;
  unsigned int offset;
  unsigned int size;
};

# `WOFF2_TableRec_`

struct WOFF2_TableRec_
{
  unsigned __int8 FlagByte;
  unsigned int Tag;
  unsigned int dst_length;
  unsigned int TransformLength;
  unsigned int flags;
  unsigned int src_offset;
  unsigned int src_length;
  unsigned int dst_offset;
};

# `WOFF2_InfoRec_`

struct WOFF2_InfoRec_
{
  unsigned int header_checksum;
  unsigned __int16 num_glyphs;
  unsigned __int16 num_hmetrics;
  __int16 *x_mins;
  WOFF2_TableRec_ *glyf_table;
  WOFF2_TableRec_ *loca_table;
  WOFF2_TableRec_ *head_table;
};

# `WOFF2_PointRec_`

struct __declspec(align(4)) WOFF2_PointRec_
{
  int x;
  int y;
  unsigned __int8 on_curve;
};

# `WOFF_HeaderRec_`

struct WOFF_HeaderRec_
{
  unsigned int signature;
  unsigned int flavor;
  unsigned int length;
  unsigned __int16 num_tables;
  unsigned __int16 reserved;
  unsigned int totalSfntSize;
  unsigned __int16 majorVersion;
  unsigned __int16 minorVersion;
  unsigned int metaOffset;
  unsigned int metaLength;
  unsigned int metaOrigLength;
  unsigned int privOffset;
  unsigned int privLength;
};

# `WOFF_TableRec_`

struct WOFF_TableRec_
{
  unsigned int Tag;
  unsigned int Offset;
  unsigned int CompLength;
  unsigned int OrigLength;
  unsigned int CheckSum;
  unsigned int OrigOffset;
};

# `WinPE_RsrcDirRec_`

struct WinPE_RsrcDirRec_
{
  unsigned int characteristics;
  unsigned int time_date_stamp;
  unsigned __int16 major_version;
  unsigned __int16 minor_version;
  unsigned __int16 number_of_named_entries;
  unsigned __int16 number_of_id_entries;
};

# `WinNE_HeaderRec_`

struct WinNE_HeaderRec_
{
  unsigned __int16 magic;
  unsigned __int16 resource_tab_offset;
  unsigned __int16 rname_tab_offset;
};

# `WinPE_RsrcDataEntryRec_`

struct WinPE_RsrcDataEntryRec_
{
  unsigned int offset_to_data;
  unsigned int size;
  unsigned int code_page;
  unsigned int reserved;
};

# `WinMZ_HeaderRec_`

struct WinMZ_HeaderRec_
{
  unsigned __int16 magic;
  unsigned __int16 lfanew;
};

# `WinPE32_HeaderRec_`

struct WinPE32_HeaderRec_
{
  unsigned int magic;
  unsigned __int16 machine;
  unsigned __int16 number_of_sections;
  unsigned __int16 size_of_optional_header;
  unsigned __int16 magic32;
  unsigned int rsrc_virtual_address;
  unsigned int rsrc_size;
};

# `WinPE_RsrcDirEntryRec_`

struct WinPE_RsrcDirEntryRec_
{
  unsigned int name;
  unsigned int offset;
};

# `WinPE32_SectionRec_`

struct WinPE32_SectionRec_
{
  unsigned __int8 name[8];
  unsigned int virtual_address;
  unsigned int size_of_raw_data;
  unsigned int pointer_to_raw_data;
};

# `win32_stat`

struct __declspec(align(8)) win32_stat
{
  int st_dev;
  __int64 st_ino;
  unsigned __int16 st_mode;
  int st_nlink;
  int st_uid;
  int st_gid;
  int st_rdev;
  __int64 st_size;
  __int64 st_atime;
  int st_atime_nsec;
  __int64 st_mtime;
  int st_mtime_nsec;
  __int64 st_ctime;
  int st_ctime_nsec;
};

# `wrapperobject`

struct wrapperobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  PyWrapperDescrObject *descr;
  _object *self;
};

# `WebviewSystem::stopAllInterfaces::__l2::<lambda_3a4c860050098d599d26c9a999d0676f>`

struct __cppobj WebviewSystem::stopAllInterfaces::__l2::<lambda_3a4c860050098d599d26c9a999d0676f>
{
};

# `WorldSettingsScreenController::_setupDebugBindings::__l2::<lambda_8f89352fbf5cc34800c59e374fa9e6b8>::()::__l2::<lambda_af155410eb2e9bf8c8d2a7b9bfa0186b>`

struct __cppobj WorldSettingsScreenController::_setupDebugBindings::__l2::<lambda_8f89352fbf5cc34800c59e374fa9e6b8>::()::__l2::<lambda_af155410eb2e9bf8c8d2a7b9bfa0186b>
{
  const std::string biomeName;
};

# `WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>::()::__l2::<lambda_6973b209eecf58a062dcf5a8f6c0e009>::()::__l2::<lambda_07b2dfac0b360712c572b9d92376ecc9>`

struct __cppobj WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>::()::__l2::<lambda_6973b209eecf58a062dcf5a8f6c0e009>::()::__l2::<lambda_07b2dfac0b360712c572b9d92376ecc9>
{
  const Pack *pack;
};

# `WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_fc37ca303a3dee12b4879dd65fd37688>`

struct __cppobj WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_fc37ca303a3dee12b4879dd65fd37688>
{
};

# `WorldSettingsScreenController::_setEducationFeaturesEnabled::__l2::<lambda_eceb0d2a2b70652deff3613726ec2705>`

struct __cppobj WorldSettingsScreenController::_setEducationFeaturesEnabled::__l2::<lambda_eceb0d2a2b70652deff3613726ec2705>
{
  WorldSettingsScreenController *const __this;
};

# `WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>`

struct __cppobj WorldSettingsScreenController::_copyResourcePacks::__l2::<lambda_77c23766a702e13e7564f973f4740dba>
{
};

# `WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_a2aa772198d04e372ba0715d13d2b5fc>::()::__l2::Literal`

struct __cppobj WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_a2aa772198d04e372ba0715d13d2b5fc>::()::__l2::Literal
{
};

# `WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_f0c8d8c481a804394383788dc544e901>::()::__l2::Literal`

struct __cppobj WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_f0c8d8c481a804394383788dc544e901>::()::__l2::Literal
{
};

# `WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_a2aa772198d04e372ba0715d13d2b5fc>`

struct __cppobj WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_a2aa772198d04e372ba0715d13d2b5fc>
{
};

# `WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_f0c8d8c481a804394383788dc544e901>`

struct __cppobj WorldGenMolangQueries::hasBiomeTag::__l12::<lambda_f0c8d8c481a804394383788dc544e901>
{
};

# `WorldHistoryPackSource::_addPackFromHistoryPack::__l2::<lambda_3e7e5236275ed6a147030e7242c47483>`

struct __cppobj WorldHistoryPackSource::_addPackFromHistoryPack::__l2::<lambda_3e7e5236275ed6a147030e7242c47483>
{
  const WorldPackHistory *worldPackHistory;
};

# `WorldTemplateManager::_initialize::__l2::<lambda_8a8fa280401500a95dde7e6f66d98f11>::()::__l2::<lambda_f4b458f3f914c8ed06c3f7a49038e193>`

struct __cppobj WorldTemplateManager::_initialize::__l2::<lambda_8a8fa280401500a95dde7e6f66d98f11>::()::__l2::<lambda_f4b458f3f914c8ed06c3f7a49038e193>
{
  const std::string *name;
};

# `WorldPacksHistoryFile::addPack::__l2::<lambda_ecfe105020688bfff20d93a1f4ba3ac8>`

struct __cppobj WorldPacksHistoryFile::addPack::__l2::<lambda_ecfe105020688bfff20d93a1f4ba3ac8>
{
  const WorldPackHistory *newWorldPackHistory;
};

# `WorldPacksHistoryFile::setSourceUUIDForPackHistory::__l2::<lambda_f737c4b4e117d651b43d5f310d0b78dd>`

struct __cppobj WorldPacksHistoryFile::setSourceUUIDForPackHistory::__l2::<lambda_f737c4b4e117d651b43d5f310d0b78dd>
{
  const PackIdVersion *packId;
};

# `Wolf::normalTick::__l27::<lambda_9d95196b64d6e299c71a52f9701d2f9e>::()::__l2::Literal`

struct __cppobj Wolf::normalTick::__l27::<lambda_9d95196b64d6e299c71a52f9701d2f9e>::()::__l2::Literal
{
};

# `Wolf::normalTick::__l27::<lambda_9d95196b64d6e299c71a52f9701d2f9e>`

struct __cppobj Wolf::normalTick::__l27::<lambda_9d95196b64d6e299c71a52f9701d2f9e>
{
};

# `WitherBoss::aiStep::__l98::<lambda_164987513f89b64b76d1a47656cf4af9>::()::__l2::Literal`

struct __cppobj WitherBoss::aiStep::__l98::<lambda_164987513f89b64b76d1a47656cf4af9>::()::__l2::Literal
{
};

# `WitherBoss::canDestroy::__l2::<lambda_45f3aa83b04e47f6b55634ec5c3952c8>`

struct __cppobj WitherBoss::canDestroy::__l2::<lambda_45f3aa83b04e47f6b55634ec5c3952c8>
{
  const BlockLegacy *legacyBlock;
};

# `WitherBoss::aiStep::__l98::<lambda_164987513f89b64b76d1a47656cf4af9>`

struct __cppobj WitherBoss::aiStep::__l98::<lambda_164987513f89b64b76d1a47656cf4af9>
{
};

# `Witch::updateEntitySpecificMolangVariables::__l2::<lambda_874c48a305f442fcfd1d3e011e472379>::()::__l2::Literal`

struct __cppobj Witch::updateEntitySpecificMolangVariables::__l2::<lambda_874c48a305f442fcfd1d3e011e472379>::()::__l2::Literal
{
};

# `WanderingTrader::updateEntitySpecificMolangVariables::__l2::<lambda_3ea19f5d3c64bd22fceeb53dd0542d47>::()::__l2::Literal`

struct __cppobj WanderingTrader::updateEntitySpecificMolangVariables::__l2::<lambda_3ea19f5d3c64bd22fceeb53dd0542d47>::()::__l2::Literal
{
};

# `WanderingTrader::updateEntitySpecificMolangVariables::__l2::<lambda_3ea19f5d3c64bd22fceeb53dd0542d47>`

struct __cppobj WanderingTrader::updateEntitySpecificMolangVariables::__l2::<lambda_3ea19f5d3c64bd22fceeb53dd0542d47>
{
};

# `Witch::updateEntitySpecificMolangVariables::__l2::<lambda_874c48a305f442fcfd1d3e011e472379>`

struct __cppobj Witch::updateEntitySpecificMolangVariables::__l2::<lambda_874c48a305f442fcfd1d3e011e472379>
{
};

# `WorldGenerator::searchForBiome::__l2::<lambda_e3695b8e66caa573b0750988dc867b03>`

struct __cppobj WorldGenerator::searchForBiome::__l2::<lambda_e3695b8e66caa573b0750988dc867b03>
{
  const std::set<int> *biomes;
};

# `WanderingTrader_vtbl`

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

← V W~1 →

# W

# WorldInfo

# WorldSettingsScreenController::_createWorld::__l17::<lambda_30eacbc3767aa70fa725f906225512f7>

# WorldSeedCatalogModel::_filterWorldSeedModels::__l2::<lambda_1f94c8840b7eed1643578473f67d7bf3>

# WeatherRenderObject::WeatherParameters

# WeakPtr<Item>

# WorkerConfiguration

# WeakPtr<BlockLegacy>

# wrapperbase

# WideByteMask

# WeakRefT<EntityRefTraits>

# WeakStorageEntity

# WeakRefT<EntityRegistryRefTraits>

# WeakStorageSharePtr<EntityRegistry>

# WorldTemplateLevelData

# WorldTemplateInfo

# WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_ae66c086c4017b718f91abcd596e1644>

# WorldSettingsScreenController::_registerControllerCallbacks::__l5::<lambda_4619b5e0188b36fe9f50cb3bc06c281f>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1a9419c082bd732c9cdabe3db6e7c7d2>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4a4111f343976fe3e70a853f8071ff93>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8fa18923b3c9b0352921c8507355935e>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_df222c82b64efe052d4401ead3d855ac>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d27709ce8af69f27a742eebd131ebde2>

# WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2a0d82b796cc03ef7e9ca7fff726c49b>

# WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>

# WorldSettingsScreenController::_createWorld::__l50::<lambda_e7b026eda446f274701718f9837342db>

# WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>

# WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>::()::__l8::<lambda_448fe23cf5d2eb28baea85c687e5b921>

# WorldSettingsScreenController::_deleteWorld::__l5::<lambda_bc4423b008cb0436831c7091689d60da>

# WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>

# WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_4dfc45f582529d3ed727b3945c94bf27>

# WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_af9feea12623906003f5ce55a09ccef2>

# WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_edcbed0e3f42203445918c7695c8684b>::()::__l8::<lambda_bc73e247c820d38008e0a4e5693880f1>

# WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_c82335fd1d8bab14ec8b416ff3685b1f>::()::__l8::<lambda_21a21ae3b0985dfbe01e5b781fae38d9>

# WorldSeedCatalogModel::fetch::__l2::<lambda_55fb1a16544d2a415662441120666ac9>::()::__l9::<lambda_01c062cbc5d985f30c7ffd330cec1890>

# WorldSeedCatalogModel::WorldSeedFilteredLookup

# WebToken

# WeatherRenderObject

# WeatherRenderObject::RenderRuntimeSettings

# WeatherRenderObject::RuntimeValues

# WeakRefT<SharePtrRefTraits<FogDefinition const > >

# WeakStorageSharePtr<FogDefinition const >

# WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_1fd7857a6c54915173786814bb19a325>::()::__l5::<lambda_0afcd04c1373b2f5c9f5f644c8d1b5c7>

# WorldFileDownloadManager::_transformLevel::__l19::<lambda_d7071557326ed3291a542974045ff48b>

# WorldFileDownloadManager::_importLevel::__l13::<lambda_f751d7d2807b10c0b06e3015f280143d>

# WorldFileUploadManager::_uploadLocalWorldLevel::__l25::<lambda_af1791171d63bd6d3087491c8d97b837>

# WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>

# WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>

# WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>::()::__l8::<lambda_99eb832ba02257e8fca44c2455ddc9b7>

# WINDOWPLACEMENT

# WeakPtr<ActorPlacerItem>

# WeakPtr<ComponentItem>

# WeakPtr<MicroBlockItem>

# WeakPtr<BlockItem>

# WeightedChoices<float>

# WorldPackHistory

# WorldTemplateManager::postDeleteWorldTemplate::__l2::<lambda_0f606a778526b0f1aa838bcfccd6baae>

# WorldGenClimateMappingAttributes

# WeighedRandom::WeighedRandomItem

# WeakPtr<AirBlockItem>

# WeakPtr<ShovelItem>

# WeakPtr<PickaxeItem>

# WeakPtr<HatchetItem>

# WeakPtr<FlintAndSteelItem>

# WeakPtr<BowItem>

# WeakPtr<ArrowItem>

# WeakPtr<CoalItem>

# WeakPtr<WeaponItem>

# WeakPtr<BlockPlanterItem>

# WeakPtr<HoeItem>

# WeakPtr<ArmorItem>

# WeakPtr<ShieldItem>

# WeakPtr<HangingActorItem>

# WeakPtr<SignItem>

# WeakPtr<DoorItem>

# WeakPtr<BucketItem>

# WeakPtr<MinecartItem>

# WeakPtr<RedStoneDustItem>

# WeakPtr<SnowballItem>

# WeakPtr<BoatItem>

# `WorldInfo`

# `WorldSettingsScreenController::_createWorld::__l17::<lambda_30eacbc3767aa70fa725f906225512f7>`

# `WorldSeedCatalogModel::_filterWorldSeedModels::__l2::<lambda_1f94c8840b7eed1643578473f67d7bf3>`

# `WeatherRenderObject::WeatherParameters`

# `WeakPtr<Item>`

# `WorkerConfiguration`

# `WeakPtr<BlockLegacy>`

# `wrapperbase`

# `WideByteMask`

# `WeakRefT<EntityRefTraits>`

# `WeakStorageEntity`

# `WeakRefT<EntityRegistryRefTraits>`

# `WeakStorageSharePtr<EntityRegistry>`

# `WorldTemplateLevelData`

# `WorldTemplateInfo`

# `WorldConversionErrorReportScreenController::_registerReportReasonDropdown::__l2::<lambda_ae66c086c4017b718f91abcd596e1644>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l5::<lambda_4619b5e0188b36fe9f50cb3bc06c281f>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_1a9419c082bd732c9cdabe3db6e7c7d2>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_4a4111f343976fe3e70a853f8071ff93>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_8fa18923b3c9b0352921c8507355935e>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_df222c82b64efe052d4401ead3d855ac>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_d27709ce8af69f27a742eebd131ebde2>`

# `WorldSettingsScreenController::_registerControllerCallbacks::__l2::<lambda_2a0d82b796cc03ef7e9ca7fff726c49b>`

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>`

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_e7b026eda446f274701718f9837342db>`

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>`

# `WorldSettingsScreenController::_createWorld::__l50::<lambda_5b075de6973c3dbfbf70cd98c8dfe1e4>::()::__l5::<lambda_e3bbb1bb2655f0c3f80e9f1248f13d11>::()::__l8::<lambda_448fe23cf5d2eb28baea85c687e5b921>`

# `WorldSettingsScreenController::_deleteWorld::__l5::<lambda_bc4423b008cb0436831c7091689d60da>`

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>`

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_4dfc45f582529d3ed727b3945c94bf27>`

# `WorldTemplatesScreenController::_createWorldTemplate::__l5::<lambda_a351f87cfd4833c37d179f3469c13f63>::()::__l5::<lambda_af9feea12623906003f5ce55a09ccef2>`

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_edcbed0e3f42203445918c7695c8684b>::()::__l8::<lambda_bc73e247c820d38008e0a4e5693880f1>`

# `WorldTemplatesScreenController::_registerEventHandlers::__l2::<lambda_c82335fd1d8bab14ec8b416ff3685b1f>::()::__l8::<lambda_21a21ae3b0985dfbe01e5b781fae38d9>`

# `WorldSeedCatalogModel::fetch::__l2::<lambda_55fb1a16544d2a415662441120666ac9>::()::__l9::<lambda_01c062cbc5d985f30c7ffd330cec1890>`

# `WorldSeedCatalogModel::WorldSeedFilteredLookup`

# `WebToken`

# `WeatherRenderObject`

# `WeatherRenderObject::RenderRuntimeSettings`

# `WeatherRenderObject::RuntimeValues`

# `WeakRefT<SharePtrRefTraits<FogDefinition const > >`

# `WeakStorageSharePtr<FogDefinition const >`

# `WorldFileDownloadManager::downloadArchivedFile::__l2::<lambda_1fd7857a6c54915173786814bb19a325>::()::__l5::<lambda_0afcd04c1373b2f5c9f5f644c8d1b5c7>`

# `WorldFileDownloadManager::_transformLevel::__l19::<lambda_d7071557326ed3291a542974045ff48b>`

# `WorldFileDownloadManager::_importLevel::__l13::<lambda_f751d7d2807b10c0b06e3015f280143d>`

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l25::<lambda_af1791171d63bd6d3087491c8d97b837>`

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>`

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>`

# `WorldFileUploadManager::_uploadLocalWorldLevel::__l2::<lambda_cbed79c6109a3f718359bdd2758b2643>::()::__l5::<lambda_417fcad9225de40cd3be2c3c42b18e59>::()::__l8::<lambda_99eb832ba02257e8fca44c2455ddc9b7>`

# `WINDOWPLACEMENT`

# `WeakPtr<ActorPlacerItem>`

# `WeakPtr<ComponentItem>`

# `WeakPtr<MicroBlockItem>`

# `WeakPtr<BlockItem>`

# `WeightedChoices<float>`

# `WorldPackHistory`

# `WorldTemplateManager::postDeleteWorldTemplate::__l2::<lambda_0f606a778526b0f1aa838bcfccd6baae>`

# `WorldGenClimateMappingAttributes`

# `WeighedRandom::WeighedRandomItem`

# `WeakPtr<AirBlockItem>`

# `WeakPtr<ShovelItem>`

# `WeakPtr<PickaxeItem>`

# `WeakPtr<HatchetItem>`

# `WeakPtr<FlintAndSteelItem>`

# `WeakPtr<BowItem>`

# `WeakPtr<ArrowItem>`

# `WeakPtr<CoalItem>`

# `WeakPtr<WeaponItem>`

# `WeakPtr<BlockPlanterItem>`

# `WeakPtr<HoeItem>`

# `WeakPtr<ArmorItem>`

# `WeakPtr<ShieldItem>`

# `WeakPtr<HangingActorItem>`

# `WeakPtr<SignItem>`

# `WeakPtr<DoorItem>`

# `WeakPtr<BucketItem>`

# `WeakPtr<MinecartItem>`

# `WeakPtr<RedStoneDustItem>`

# `WeakPtr<SnowballItem>`

# `WeakPtr<BoatItem>`

# `WeakPtr<EnchantedBookItem>`