/* 31937 */
struct SHPortalRoom::postProcess::$A4BF091F36AB25C4BAD93320DD623D59
{
const Block **endPortalEye;
const Block **endPortalNoEye;
};

/* 421255 */
struct SPSCQueue<BatchedNetworkPeer::DataCallback,512>
{
Lockless::WeakAtomic<SPSCQueue<BatchedNetworkPeer::DataCallback,512>::Block *> mFrontBlock;
char mCachelineFiller[56];
Lockless::WeakAtomic<SPSCQueue<BatchedNetworkPeer::DataCallback,512>::Block *> mTailBlock;
size_t mLargestBlockSize;
};

/* 421196 */
struct SPSCQueue<BatchedNetworkPeer::DataCallback,512>::Block
{
Lockless::WeakAtomic<unsigned long> front;
size_t localTail;
char cachelineFiller0[48];
Lockless::WeakAtomic<unsigned long> tail;
size_t localFront;
char cachelineFiller1[48];
Lockless::WeakAtomic<SPSCQueue<BatchedNetworkPeer::DataCallback,512>::Block *> next;
char *data;
const size_t sizeMask;
char *rawThis;
};

/* 3012 */
struct SaveTransactionManager
{
SaveTransactionManager::ShowIconFunction mShowIconFunction;
};

/* 34295 */
struct SavedData
{
int (**_vptr$SavedData)(void);
bool mDirty;
std::string mId;
};

/* 87726 */
struct SavedDataStorage
{
int (**_vptr$SavedDataStorage)(void);
LevelStorage *levelStorage;
std::unordered_map<std::string,SavedData *> savedDatas;
};

/* 412552 */
struct ScaffoldingClimberDefinition
{
__int8 gap0[1];
};

/* 58652 */
struct ScaleByAgeComponent
{
float mStartScale;
float mEndScale;
};

/* 107549 */
struct ScaleByAgeDefinition
{
float mStartScale;
float mEndScale;
};

/* 192991 */
struct ScatterParams
{
ScatterParams::CoordinateRange mX;
ScatterParams::CoordinateRange mZ;
ScatterParams::CoordinateRange mHeight;
ScatterParams::CoordinateEvaluationOrder mEvalOrder;
ScatterParams::ChanceInformation mScatterChance;
ExpressionNode mIterations;
};

/* 192995 */
struct ScatterParams::ChanceInformation
{
ExpressionNode mChancePercent;
int mNumerator;
int mDenominator;
};

/* 192992 */
struct ScatterParams::CoordinateRange
{
ExpressionNode mMinOrSingleValue;
ExpressionNode mMax;
uint32_t mGridStepCount;
ScatterParams::RandomDistributionType mDistribution;
};

/* 198707 */
struct ScatterParams::ScatteredPositions
{
RenderParams *mMolangParams;
Random *mRandom;
const ScatterParams *mScatterParams;
BlockPos mOrigin;
uint32_t mIterations;
};

/* 457571 */
struct ScatterParams::_getPos::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 457570 */
struct ScatterParams::initMolangParams::$7EF7C94BEAB75C6CEF4ADFB99B570420
{
__int8 gap0[1];
};

/* 81128 */
struct SceneFactory;

/* 81127 */
struct SceneStack;

/* 4391 */
struct Scheduler
{
uint32_t mTotalFrames;
uint32_t mStarvedFrames;
uint32_t mPromotionFrames;
uint32_t mTargetFPS;
uint32_t mEffectiveFPS;
uint32_t mFramesOverBound;
double mAverageCallbackDuration;
double mTotalCoroutineDuration;
size_t mTotalRunCoroutines;
double mCoroutineTimeLimit;
std::unique_ptr<WorkerPool> mCoroutinePool;
std::chrono::time_point<std::chrono::_V2::system_clock,std::chrono::duration<long,std::ratio<1,1000000000> > > mNextStarveCheckTime;
std::thread::id mThreadID;
};

/* 484341 */
struct Scheduler::ScopedChangeScheduler
{
BackgroundWorker *mParent;
};

/* 58798 */
struct SchedulerComponent
{
int mCurrentEventIndex;
};

/* 58854 */
struct SchedulerDefinition
{
std::vector<DefinitionTrigger> mTriggerDefs;
unsigned int mMinDelayTicks;
unsigned int mMaxDelayTicks;
};

/* 87060 */
struct ScopedAutoreleasePool
{
__int8 gap0[1];
};

/* 103054 */
struct ScopedProfileTag
{
__int8 gap0[1];
};

/* 80247 */
struct ScoreInfo
{
const Objective *mObjective;
bool mValid;
int mValue;
};

/* 80248 */
struct ScoreInfoRef
{
const Objective *mObjective;
bool mValid;
int *mValue;
};

/* 70049 */
struct ScorePacketInfo
{
ScoreboardId mScoreboardId;
std::string mObjectiveName;
int mScoreValue;
IdentityDefinition::Type mIdentityType;
PlayerScoreboardId mPlayerId;
ActorUniqueID mEntityId;
std::string mFakePlayerName;
};

/* 80249 */
struct Scoreboard
{
int (**_vptr$Scoreboard)(void);
CommandSoftEnumRegistry mRegistry;
std::unordered_map<std::string,DisplayObjective> mDisplayObjectives;
IdentityDictionary mIdentityDict;
std::unordered_map<ScoreboardId,ScoreboardIdentityRef> mIdentityRefs;
bool mShouldUpdateUI;
std::unordered_map<std::string,std::unique_ptr<Objective>> mObjectives;
std::unordered_map<std::string,std::unique_ptr<ObjectiveCriteria>> mCriteria;
};

/* 426836 */
struct ScoreboardCommand::InitProxy
{
Scoreboard *mScoreboard;
};

/* 426837 */
struct ScoreboardCommand::SetScoreOutput
{
int mSuccessCount;
int mFirstNewScore;
std::string mFirstSuccess;
};

/* 70050 */
struct ScoreboardId
{
int64_t mRawID;
IdentityDefinition *mIdentityDef;
};

/* 70103 */
struct ScoreboardIdentityPacketInfo
{
ScoreboardId mScoreboardId;
PlayerScoreboardId mPlayerId;
};

/* 80250 */
struct ScoreboardIdentityRef
{
uint32_t mObjectiveReferences;
ScoreboardId mScoreboardId;
};

/* 35042 */
struct ScreenshotOptions
{
bool mCropToRatio;
int mWidthRatio;
int mHeightRatio;
uint32_t mMaxWidth;
uint32_t mMaxHeight;
bool mRestrictScreenshotSize;
bool mApplySquareFrame;
Core::HeapPathBuffer mRequestedFileName;
Core::HeapPathBuffer mRequestedFilePath;
Core::HeapPathBuffer mRequestedExtension;
bool mReplaceImage;
bool mUseScreenshotsFolder;
bool mHideUI;
bool mLogRequest;
bool mWriteScreenshotToFile;
bool mIsSavegameScreenshot;
Core::HeapPathBuffer mOutFileName;
Core::HeapPathBuffer mOutFileDir;
Core::HeapPathBuffer mOutExtension;
};

/* 95649 */
struct ScriptApi::EMPTYObjectHandle
{
__int8 gap0[1];
};

/* 95734 */
struct ScriptApi::EventTracking
{
ScriptApi::ScriptObjectHandle mFunctionObject;
};

/* 95279 */
struct ScriptApi::JavaScriptErrorHandler;

/* 99153 */
struct ScriptApi::ScriptCallbackInterface
{
int (**_vptr$ScriptCallbackInterface)(void);
};

/* 99152 */
struct ScriptApi::ScriptFramework
{
int (**_vptr$ScriptFramework)(void);
std::unique_ptr<ScriptApi::ScriptLanguageInterface> mLanguageInterface;
std::vector<ScriptApi::ScriptSystemInfo> mScriptSystems;
std::unique_ptr<ScriptApi::ScriptReport> mScriptReportQueue;
};

/* 97714 */
struct ScriptApi::ScriptLanguageInterface
{
int (**_vptr$ScriptLanguageInterface)(void);
};

/* 99141 */
struct ScriptApi::ScriptReport
{
std::vector<std::shared_ptr<ScriptApi::ScriptReportItem>> mReportItems;
};

/* 95269 */
struct ScriptApi::ScriptReportItem
{
std::string mMessage;
ScriptApi::ScriptReportItemType mType;
std::unique_ptr<ScriptApi::JavaScriptErrorHandler> mErrorHandler;
};

/* 99227 */
struct ScriptApi::ScriptVersionInfo
{
int32_t mMajorVersion;
int32_t mMinVerssion;
};

/* 423896 */
struct ScriptApi::WORKAROUNDS::tempActorComponent
{
ActorUniqueID mID;
};

/* 424122 */
struct ScriptApi::WORKAROUNDS::tempLevelComponent
{
__int8 gap0[1];
};

/* 96379 */
struct ScriptBinderComponent
{
int (**_vptr$ScriptBinderComponent)(void);
};

/* 95815 */
struct ScriptBinderTemplate
{
int (**_vptr$ScriptBinderTemplate)(void);
};

/* 98718 */
struct ScriptBinderTemplateController
{
std::unordered_map<std::string,std::unique_ptr<ScriptBinderTemplate>> mTemplates;
};

/* 95647 */
struct ScriptCommandCallbackData
{
ScriptApi::ScriptObjectHandle mFunction;
std::string mCommand;
bool mCallbackReceived;
Json::Value mData;
};

/* 475676 */
struct ScriptCommandFactory
{
__int8 gap0[1];
};

/* 99171 */
struct ScriptEngine::ScriptQueueData
{
Core::HeapPathBuffer mScriptPath;
std::string mScriptName;
std::string mScriptContent;
std::string mPackID;
std::string mPackVersion;
uint64_t mScriptHash;
};

/* 99880 */
struct ScriptEngineWithContext<ScriptServerContext>::createEntity::$C3475C4D5343D48D4C7832305B127EAE
{
ScriptEngineWithContext<ScriptServerContext> *this;
ScriptApi::ScriptObjectHandle *entityHandle;
const std::string *templateName;
const ScriptApi::ScriptVersionInfo *info;
};

/* 96208 */
struct ScriptEventData
{
int (**_vptr$ScriptEventData)(void);
std::string mEventName;
};

/* 97518 */
struct ScriptEventListener
{
int (**_vptr$ScriptEventListener)(void);
};

/* 96427 */
struct ScriptObjectBinder
{
const std::string mTypeIdentifier;
unsigned int mComponentsInUse;
std::vector<std::unique_ptr<ScriptBinderComponent>> mComponents;
};

/* 99148 */
struct ScriptOnlyComponents<ScriptServerContext>
{
std::map<std::string,Json::Value> mScriptOnlyComponentDefs;
};

/* 97603 */
struct ScriptOnlyComponents<ScriptServerContext>::ScriptOnly
{
std::map<std::string,Json::Value> mLookup;
};

/* 99149 */
struct ScriptOnlyEventsData<ScriptServerContext>
{
std::map<std::string,Json::Value> mScriptOnlyEventsData;
};

/* 99151 */
struct ScriptQueries
{
entt::DefaultRegistry mRegistryView;
};

/* 423826 */
struct ScriptQueryComponent
{
std::unordered_set<std::string> mFilters;
ScriptQueryComponent::ViewType mType;
std::string mSpatialTag;
std::string mCoordinateTags[3];
};

/* 99139 */
struct ScriptServerContext
{
Level *mLevel;
Minecraft *mMinecraft;
PacketSender *mPacketSender;
entt::DefaultRegistry *mRegistry;
ScriptApi::ScriptReport *mScriptReport;
};

/* 99142 */
struct ScriptTemplateFactory<ScriptServerContext>
{
ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::Entity> mEntities;
ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::Entity> mItemEntities;
ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::Component> mComponents;
ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::ReceivedEvent> mReceivedEvents;
ScriptTemplateFactory<ScriptServerContext>::HashedEntries mScriptEventDatas;
ScriptTemplateFactory<ScriptServerContext>::Entry<ScriptTemplateFactory<ScriptServerContext>::ReceivedEvent> mBroadcastEvent;
};

/* 95456 */
struct ScriptTemplateFactory<ScriptServerContext>::Component
{
int (**_vptr$Component)(void);
};

/* 95381 */
struct ScriptTemplateFactory<ScriptServerContext>::Entity
{
int (**_vptr$Entity)(void);
};

/* 99144 */
struct ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::Component>
{
std::unordered_map<unsigned long,std::shared_ptr<ScriptTemplateFactory<ScriptServerContext>::Component>> mTemplates;
};

/* 99143 */
struct ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::Entity>
{
std::unordered_map<unsigned long,std::shared_ptr<ScriptTemplateFactory<ScriptServerContext>::Entity>> mTemplates;
};

/* 99145 */
struct ScriptTemplateFactory<ScriptServerContext>::Entries<ScriptTemplateFactory<ScriptServerContext>::ReceivedEvent>
{
std::unordered_map<unsigned long,std::shared_ptr<ScriptTemplateFactory<ScriptServerContext>::ReceivedEvent>> mTemplates;
};

/* 99146 */
struct ScriptTemplateFactory<ScriptServerContext>::HashedEntries
{
std::unordered_set<unsigned long> mHashes;
};

/* 95540 */
struct ScriptTemplateFactory<ScriptServerContext>::ReceivedEvent
{
int (**_vptr$ReceivedEvent)(void);
};

/* 45324 */
struct SearchRequestTelemetry;

/* 34400 */
struct Seasons
{
Dimension *mDimension;
PerlinSimplexNoise mSnowNoise;
};

/* 55146 */
struct SeatDescription
{
Vec3 mPosition;
int mMinSeatCount;
int mMaxSeatCount;
float mSeatRotation;
bool mLockRiderRotation;
float mLockRiderRotationDegrees;
};

/* 479501 */
struct SecureStorage
{
int (**_vptr$SecureStorage)(void);
};

/* 90959 */
struct SelectorIterator<Actor>
{
CommandResultVector mTargets;
std::vector<Actor *>::iterator mIndex;
};

/* 33510 */
struct SelectorIterator<Player>
{
CommandResultVector mTargets;
std::vector<Actor *>::iterator mIndex;
};

/* 5623 */
struct SemVersion::any_version_constructor
{
__int8 gap0[1];
};

/* 88826 */
struct SendEventData
{
float minActivationRange;
float maxActivationRange;
int cooldownTime;
int castDuration;
float weight;
bool doCastingAnimation;
int particleColor;
ActorFilterGroup targetFilter;
LevelSoundEvent startSound;
std::vector<SendEventStage> stages;
};

/* 58948 */
struct SensingComponent
{
SensingComponent::ActorSet mSeen;
SensingComponent::ActorSet mUnseen;
};

/* 74272 */
struct SerializedPersonaPieceHandle
{
std::string mPieceId;
persona::PieceType mPieceType;
mce::UUID mPackId;
bool mIsDefaultPiece;
std::string mProductId;
};

/* 74239 */
struct SerializedSkin
{
std::string mId;
std::string fullId;
std::string mResourcePatch;
std::string mDefaultGeometryName;
mce::Image mSkinImage;
mce::Image mCapeImage;
std::vector<AnimatedImageData> mSkinAnimatedImages;
Json::Value mGeometryData;
Json::Value mGeometryDataMutable;
std::string mAnimationData;
std::string mCapeId;
bool mIsPremium;
bool mIsPersona;
bool mIsPersonaCapeOnClassicSkin;
TrustedSkinFlag mIsTrustedSkin;
std::vector<SerializedPersonaPieceHandle> mPersonaPieces;
std::string mArmSize;
std::unordered_map<persona::PieceType,TintMapColor> mPieceTintColors;
Color mSkinColor;
};

/* 173180 */
struct SerializedSkin_0
{
std::string mId;
std::string fullId;
std::string mResourcePatch;
std::string mDefaultGeometryName;
mce::Image_0 mSkinImage;
mce::Image_0 mCapeImage;
std::vector<AnimatedImageData>_0 mSkinAnimatedImages;
Json::Value mGeometryData;
Json::Value mGeometryDataMutable;
std::string mAnimationData;
std::string mCapeId;
bool mIsPremium;
bool mIsPersona;
bool mIsPersonaCapeOnClassicSkin;
TrustedSkinFlag mIsTrustedSkin;
std::vector<SerializedPersonaPieceHandle> mPersonaPieces;
std::string mArmSize;
std::unordered_map<persona::PieceType,TintMapColor> mPieceTintColors;
Color mSkinColor;
};

/* 4257 */
struct ServerCommunicationInterface
{
std::unique_ptr<RakNet::TCPInterface> mTCPConnection;
RakNet::SystemAddress mHostAddress;
};

/* 87054 */
struct ServerInstance::initializeServer::$1AF53268373D8F94D8C5F1843C50C698
{
std::unordered_map<PackIdVersion,std::string> *packIdToContentKey;
ResourcePackRepository *resourcePackRepository;
};

/* 63710 */
struct ServerLocator
{
int (**_vptr$ServerLocator)(void);
};

/* 8550 */
struct ServerMetrics
{
int (**_vptr$ServerMetrics)(void);
};

/* 8105 */
struct ServerMetricsImpl::DataTransferred
{
uint64_t totalBytesReceived;
uint64_t totalBytesSent;
};

/* 73788 */
struct ServerNetworkHandler::Client
{
std::unique_ptr<ConnectionRequest> mPrimaryRequest;
std::unordered_map<unsigned char,std::unique_ptr<SubClientConnectionRequest>> mSubClientRequests;
};

/* 77491 */
struct ServerNetworkHandler::_getActiveAndInProgressPlayerCount::$0EBB06E09BB4D485483DF06B22BB4AE5
{
const ServerNetworkHandler *this;
mce::UUID *excludePlayer;
int *numPlayers;
};

/* 77489 */
struct ServerNetworkHandler::_onClientAuthenticated::$40782884DF021EB8A0B68AECF65B4504
{
ServerNetworkHandler *this;
};

/* 77437 */
struct ServerNetworkHandler::handle::$3CDCE61CA261A057C80CC046802E365C
{
ServerNetworkHandler *this;
const NetworkIdentifier *source;
std::set<std::string> *downloading;
};

/* 76956 */
struct ServerNetworkHandler::handle::$ED428D87CD11B947B517AB43C0D6E540
{
ServerNetworkHandler *this;
const NetworkIdentifier source;
};

/* 89356 */
struct ServerPlayer::NearbyActor
{
bool isAutonomous;
ServerPlayer::NearbyActor::State state;
Actor *tempActor;
};

/* 90647 */
struct ServerPlayer::recoverR5LostInventoryAndXP::$566869B8F3A3697DD8479CC05753D205
{
std::vector<BlockPos> chestPositions;
};

/* 294173 */
struct ServerScoreboard::unit_test_ctor_t
{
__int8 gap0[1];
};

/* 5585 */
struct ServiceLocator<AppConfigs>
{
__int8 gap0[1];
};

/* 5584 */
struct ServiceLocator<AppPlatform>
{
__int8 gap0[1];
};

/* 5586 */
struct ServiceLocator<ContentLog>
{
__int8 gap0[1];
};

/* 480120 */
struct ServiceLocator<Core::LoadTimeProfiler>
{
__int8 gap0[1];
};

/* 81171 */
struct ServiceLocator<EducationOptions>
{
__int8 gap0[1];
};

/* 77439 */
struct ServiceLocator<FeatureToggles>
{
__int8 gap0[1];
};

/* 45361 */
struct ServiceLocator<IMinecraftEventing>
{
__int8 gap0[1];
};

/* 64308 */
struct ServiceLocator<NetworkDebugManager>
{
__int8 gap0[1];
};

/* 82679 */
struct ServiceLocator<PackManifest::CapabilityRegistry>
{
__int8 gap0[1];
};

/* 87055 */
struct ServiceLocator<ServerInstance>
{
__int8 gap0[1];
};

/* 480590 */
struct ServiceOverrider<bool (*)(const char *,const char *,const char *,bool,int,const char *,const char *,bool)>
{
ThreadLocal<bool (**)(const char *,const char *,const char *,bool,int,const char *,const char *,bool)> mService;
bool (**mDefaultService)(const char *, const char *, const char *, bool, int, const char *, const char *, bool);
};

/* 191523 */
struct SharePtrRefTraits<PerlinSimplexNoise>
{
__int8 gap0[1];
};

/* 417212 */
struct Shareable
{
int itemId;
int itemAux;
int wantAmount;
int surplusAmount;
int maxAmount;
int craftIntoItem;
int craftIntoItemAux;
int itemPriority;
};

/* 116674 */
struct ShareableDefinition
{
std::vector<Shareable> mItems;
bool mShareAllItems;
int mAllItemWantAmount;
int mAllItemSurplusAmount;
int mAllItemMaxAmount;
};

/* 174643 */
struct SharedAmplifiers
{
__int8 gap0[1];
};

/* 174606 */
struct SharedAttributes
{
__int8 gap0[1];
};

/* 174644 */
struct SharedBuffs
{
__int8 gap0[1];
};

/* 251389 */
struct SharedCounter<ActivatorRailBlock>
{
ActivatorRailBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 250879 */
struct SharedCounter<AirBlock>
{
AirBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 180756 */
struct SharedCounter<AirBlockItem>
{
AirBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251440 */
struct SharedCounter<AnvilBlock>
{
AnvilBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183817 */
struct SharedCounter<ArmorItem>
{
ArmorItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183950 */
struct SharedCounter<ArmorStandItem>
{
ArmorStandItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183797 */
struct SharedCounter<ArrowItem>
{
ArrowItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184012 */
struct SharedCounter<AuxDataBlockItem>
{
AuxDataBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183996 */
struct SharedCounter<BalloonItem>
{
BalloonItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251696 */
struct SharedCounter<BambooBlock>
{
BambooBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184057 */
struct SharedCounter<BambooBlockItem>
{
BambooBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251700 */
struct SharedCounter<BambooSapling>
{
BambooSapling *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251511 */
struct SharedCounter<BannerBlock>
{
BannerBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183965 */
struct SharedCounter<BannerItem>
{
BannerItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183973 */
struct SharedCounter<BannerPatternItem>
{
BannerPatternItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251731 */
struct SharedCounter<BarrelBlock>
{
BarrelBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251688 */
struct SharedCounter<BarrierBlock>
{
BarrierBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251412 */
struct SharedCounter<BeaconBlock>
{
BeaconBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251128 */
struct SharedCounter<BedBlock>
{
BedBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183876 */
struct SharedCounter<BedItem>
{
BedItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251076 */
struct SharedCounter<BedrockBlock>
{
BedrockBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251774 */
struct SharedCounter<BeehiveBlock>
{
BeehiveBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251591 */
struct SharedCounter<BeetrootBlock>
{
BeetrootBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251739 */
struct SharedCounter<BellBlock>
{
BellBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184065 */
struct SharedCounter<BellBlockItem>
{
BellBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251719 */
struct SharedCounter<BlastFurnaceBlock>
{
BlastFurnaceBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 182765 */
struct SharedCounter<BlockItem>
{
BlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 13208 */
struct SharedCounter<BlockLegacy>
{
BlockLegacy *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183809 */
struct SharedCounter<BlockPlanterItem>
{
BlockPlanterItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251619 */
struct SharedCounter<BlueIceBlock>
{
BlueIceBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183851 */
struct SharedCounter<BoatItem>
{
BoatItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251181 */
struct SharedCounter<BookshelfBlock>
{
BookshelfBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183894 */
struct SharedCounter<BottleItem>
{
BottleItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183793 */
struct SharedCounter<BowItem>
{
BowItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251362 */
struct SharedCounter<BrewingStandBlock>
{
BrewingStandBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251680 */
struct SharedCounter<BubbleColumnBlock>
{
BubbleColumnBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183835 */
struct SharedCounter<BucketItem>
{
BucketItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251267 */
struct SharedCounter<CactusBlock>
{
CactusBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251302 */
struct SharedCounter<CakeBlock>
{
CakeBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251583 */
struct SharedCounter<CameraBlock>
{
CameraBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183979 */
struct SharedCounter<CameraItem>
{
CameraItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251751 */
struct SharedCounter<CampfireBlock>
{
CampfireBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251424 */
struct SharedCounter<CarrotBlock>
{
CarrotBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183928 */
struct SharedCounter<CarrotOnAStickItem>
{
CarrotOnAStickItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251727 */
struct SharedCounter<CartographyTableBlock>
{
CartographyTableBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251366 */
struct SharedCounter<CauldronBlock>
{
CauldronBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251633 */
struct SharedCounter<ChemicalHeatBlock>
{
ChemicalHeatBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184069 */
struct SharedCounter<ChemistryAuxDataBlockItem>
{
ChemistryAuxDataBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183990 */
struct SharedCounter<ChemistryItem>
{
ChemistryItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251626 */
struct SharedCounter<ChemistryTableBlock>
{
ChemistryTableBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251200 */
struct SharedCounter<ChestBlock>
{
ChestBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251527 */
struct SharedCounter<ChorusFlowerBlock>
{
ChorusFlowerBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251575 */
struct SharedCounter<ChorusPlantBlock>
{
ChorusPlantBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251271 */
struct SharedCounter<ClayBlock>
{
ClayBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183870 */
struct SharedCounter<ClockItem>
{
ClockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251158 */
struct SharedCounter<ClothBlock>
{
ClothBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184016 */
struct SharedCounter<ClothBlockItem>
{
ClothBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183801 */
struct SharedCounter<CoalItem>
{
CoalItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251393 */
struct SharedCounter<CocoaBlock>
{
CocoaBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251471 */
struct SharedCounter<ColoredBlock>
{
ColoredBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251637 */
struct SharedCounter<ColoredTorchBlock>
{
ColoredTorchBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251409 */
struct SharedCounter<CommandBlock>
{
CommandBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251448 */
struct SharedCounter<ComparatorBlock>
{
ComparatorBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183863 */
struct SharedCounter<CompassItem>
{
CompassItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251763 */
struct SharedCounter<ComposterBlock>
{
ComposterBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183983 */
struct SharedCounter<CompoundItem>
{
CompoundItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251567 */
struct SharedCounter<ConcreteBlock>
{
ConcreteBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251571 */
struct SharedCounter<ConcretePowderBlock>
{
ConcretePowderBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251676 */
struct SharedCounter<ConduitBlock>
{
ConduitBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251644 */
struct SharedCounter<Coral>
{
Coral *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251648 */
struct SharedCounter<CoralBlock>
{
CoralBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251652 */
struct SharedCounter<CoralFan>
{
CoralFan *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 184025 */
struct SharedCounter<CoralFanBlockItem>
{
CoralFanBlockItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251656 */
struct SharedCounter<CoralFanHang>
{
CoralFanHang *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251211 */
struct SharedCounter<CropBlock>
{
CropBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 183969 */
struct SharedCounter<CrossbowItem>
{
CrossbowItem *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251452 */
struct SharedCounter<DaylightDetectorBlock>
{
DaylightDetectorBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251150 */
struct SharedCounter<DeadBush>
{
DeadBush *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251135 */
struct SharedCounter<DetectorRailBlock>
{
DetectorRailBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251064 */
struct SharedCounter<DirtBlock>
{
DirtBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};

/* 251116 */
struct SharedCounter<DispenserBlock>
{
DispenserBlock *ptr;
std::atomic<int> share_count;
std::atomic<int> weak_count;
};