# R

# `ResourcePackRepository`

Offset	Type	Name
0	(8) `Core::FilePathManager *`	mFilePathManager
8	(24) `std::vector<std::unique_ptr<ResourcePack>>`	mAllResourcePacks
32	(8) `std::unique_ptr<CompositePackSource>`	mPackSource
40	(8) `std::unique_ptr<CompositePackSource>`	mCachePackSource
48	(8) `std::unique_ptr<CompositePackSource>`	mWorldPackSource
56	(8) `std::unique_ptr<CompositePackSource>`	mPremiumWorldTemplatePackSource
64	(8) `std::unique_ptr<PackSourceReport>`	mPackSourceReport
72	(8) `ResourcePack *`	mVanillaPack
80	(8) `ResourcePack *`	mChemistryPack
88	(8) `ResourcePack *`	mChemistryServerPack
96	(24) `std::vector<ResourceLocation>`	mInvalidPackLocation
120	(24) `std::vector<ResourceLocation>`	mInvalidBehaviorPackLocation
144	(24) `std::vector<ResourceLocation>`	mInvalidResourcePackLocation
168	(24) `std::vector<ResourceLocation>`	mInvalidTemplatePackLocation
192	(8) `IMinecraftEventing *`	mEventing
200	(8) `PackManifestFactory *`	mManifestFactory
208	(8) `IContentAccessibilityProvider *`	mContentAccessibility
216	(32) `Core::HeapPathBuffer`	mCurrentWorldPath
248	(32) `Core::HeapPathBuffer`	mCurrentPremiumWorldTemplatePath
280	(56) `ContentKeyMap`	mTempCacheContentKeys
336	(4) `const int`	mKnownPacksFileVerison
344	(8) `std::unique_ptr<PackSettingsFactory>`	mPackSettingsFactory
352	(8) `PackSourceFactory *`	mPackSourceFactory
360	(24) `ResourcePackRepository::KnownPackContainer`	mCachedValidUserPacks
384	(24) `ResourcePackRepository::KnownPackContainer`	mCachedInvalidUserPacks
408	(48) `std::map<void ,std::function<void (ResourcePack )>>`	mRemoveResourcePackCallback
456	(8) `std::unique_ptr<TaskGroup>`	mInitTaskGroup
464	(40) `Bedrock::Threading::Mutex`	mInitializeMutex
504	(1) `std::atomic<bool>`	mInitialized
505	(1) `std::atomic<bool>`	mReloadUserPacksRequested
506	(1) `std::atomic<bool>`	mRefreshPacksRequested
512	(24) `ContentIdentity`	mCurrentPremiumWorldTemplateIdentity

# `ResourcePackRepository::KnownPackContainer`

Offset	Type	Name
0	(24) `std::vector<ResourcePackRepository::KnownPackInfo>`	mPacks

# `ResourceLocation`

Offset	Type	Name
0	(4) `ResourceFileSystem`	mFileSystem
8	(32) `Core::HeapPathBuffer`	mPath
40	(8) `HashType64`	mPathHash
48	(8) `size_t`	mFullHash

# `ResourceMetadata`

Offset	Type	Name
0	(24) `std::vector<std::string>`	mAuthors
24	(32) `std::string`	mUrl
56	(32) `std::string`	mLicense

# `ResourcePackStack`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ResourcePackStack
8	(24) `ResourcePackStack::PackInstanceStack`	mStack
32	(8) `std::unique_ptr<PackSourceReport>`	mPackSourceReport

# `ResourcePackStack::PackInstanceStack`

Offset	Type	Name
0	(24) `std::_Vector_base<PackInstance>`	baseclass_0

# `Random`

Offset	Type	Name
0	(2516) `Bedrock::Application::ThreadOwner<Core::Random>`	mRandom

# `Range<int,-1>::iterator`

Offset	Type	Name
0	(4) `int`	mIndex

# `Range<int,1>::iterator`

Offset	Type	Name
0	(4) `int`	mIndex

# `Range<unsigned int,1>::iterator`

Offset	Type	Name
0	(4) `unsigned int`	mIndex

# `RootLayer<LayerValues::Terrain>::LayerData`

Offset	Type	Name
0	(32) `LayerDetails::Storage`	baseclass_0
32	(16) `const LayerDetails::BufferAccessor<char>`	mParentArea
48	(16) `LayerDetails::BufferAccessor<LayerValues::Terrain>`	mResult

# `RootLayer<BiomeTemperatureCategory>::LayerData`

Offset	Type	Name
0	(32) `LayerDetails::Storage`	baseclass_0
32	(16) `const LayerDetails::BufferAccessor<char>`	mParentArea
48	(16) `LayerDetails::BufferAccessor<BiomeTemperatureCategory>`	mResult

# `Realms::RealmId`

Offset	Type	Name
0	(8) `NewType<long>`	baseclass_0

# `RaidBossComponent`

Offset	Type	Name
0	(16) `Weak<Village>`	mVillage
16	(8) `ActorUniqueID`	mOwnerID
24	(32) `std::string`	mName
56	(32) `std::string`	mProgress
88	(4) `int`	mPlayersRegistered
92	(1) `bool`	mWaveStarted
93	(1) `bool`	mRaidInProgress
94	(1) `bool`	mHealthBarVisible
96	(4) `float`	mHealthPercent
100	(28) `AABB`	mBossBarVisibleBounds
128	(8) `std::chrono::_V2::steady_clock::time_point`	mLastPlayerUpdate

# `RailActivatorComponent`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `RakNet::RakNetGUID`

Offset	Type	Name
0	(8) `uint64_t`	g
8	(2) `RakNet::SystemIndex`	systemIndex

# `ReadOnlyBinaryStream`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ReadOnlyBinaryStream
8	(8) `size_t`	mReadPointer
16	(32) `const std::string`	mOwnedBuffer
48	(8) `const std::string *`	mBuffer

# `Range<unsigned long,1>::iterator`

Offset	Type	Name
0	(8) `unsigned __int64`	mIndex

# `RakNet::RakNetStatistics`

Offset	Type	Name
0	(56) `uint64_t[7]`	valueOverLastSecond
56	(56) `uint64_t[7]`	runningTotal
112	(8) `RakNet::TimeUS`	connectionStartTime
120	(1) `bool`	isLimitedByCongestionControl
128	(8) `uint64_t`	BPSLimitByCongestionControl
136	(1) `bool`	isLimitedByOutgoingBandwidthLimit
144	(8) `uint64_t`	BPSLimitByOutgoingBandwidthLimit
152	(16) `unsigned int[4]`	messageInSendBuffer
168	(32) `double[4]`	bytesInSendBuffer
200	(4) `unsigned int`	messagesInResendBuffer
208	(8) `uint64_t`	bytesInResendBuffer
216	(4) `float`	packetlossLastSecond
220	(4) `float`	packetlossTotal

# `RakNet::SystemAddress`

Offset	Type	Name
0	(128) `RakNet::SystemAddress::$17DEBC484162A322D6AFC648B0CB992A`	address
128	(2) `unsigned __int16`	debugPort
130	(2) `RakNet::SystemIndex`	systemIndex

# `RakNet::SystemAddress::$17DEBC484162A322D6AFC648B0CB992A`

Offset	Type	Name
0	(128) `sockaddr_storage`	sa_stor
1	(28) `sockaddr_in6`	addr6
2	(16) `sockaddr_in`	addr4

# `RakNetInstance::_storeLocalIP::$7EF7C94BEAB75C6CEF4ADFB99B570420`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `RakNetInstance::NatConnectionInfo`

Offset	Type	Name
0	(136) `RakNet::SystemAddress`	remoteAddress
136	(4) `RakNet::TimeMS`	lastNatPingSendTime
140	(4) `uint32_t`	natPingSendCount
144	(1) `bool`	pongReceived

# `RakNet::BitStream`

Offset	Type	Name
0	(4) `RakNet::BitSize_t`	numberOfBitsUsed
4	(4) `RakNet::BitSize_t`	numberOfBitsAllocated
8	(4) `RakNet::BitSize_t`	readOffset
16	(8) `unsigned __int8 *`	data
24	(1) `bool`	copyData
25	(256) `unsigned __int8[256]`	stackData

# `RakNet::RakString`

Offset	Type	Name
0	(8) `RakNet::RakString::SharedString *`	sharedString

# `RakNetServerLocator::ScopeLock`

Offset	Type	Name
0	(8) `std::lock_guard<std::recursive_mutex>::mutex_type *`	_M_device

# `RakNet::SocketDescriptor`

Offset	Type	Name
0	(2) `unsigned __int16`	port
2	(32) `char[32]`	hostAddress
34	(2) `__int16`	socketFamily
36	(2) `unsigned __int16`	remotePortRakNetWasStartedOn_PS3_PSP2
40	(4) `int`	chromeInstance
44	(1) `bool`	blockingSocket
48	(4) `unsigned int`	extraSocketOptions

# `ResourcePackStackPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(24) `std::vector<PackInstanceId>`	mAddOnIdsAndVersions
64	(24) `std::vector<PackInstanceId>`	mTexturePackIdsAndVersions
88	(112) `BaseGameVersion`	mBaseGameVersion
200	(1) `bool`	mTexturePackRequired
201	(1) `bool`	mExperimental

# `Recipes::FurnaceRecipeKey`

Offset	Type	Name
0	(4) `int`	mID
8	(40) `Util::HashString`	mTag

# `ResourcePacksInfoPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(56) `ResourcePacksInfoData`	mData

# `ResourcePacksInfoData`

Offset	Type	Name
0	(1) `bool`	mTexturePackRequired
1	(1) `bool`	mHasScripts
2	(1) `bool`	mHasExceptions
8	(24) `std::vector<ResourcePackInfoData>`	mAddOnPacks
32	(24) `std::vector<ResourcePackInfoData>`	mTexturePacks

# `Recipe::ResultList`

Offset	Type	Name
0	(24) `std::_Vector_base<ItemInstance>`	baseclass_0

# `ResourceInformation`

Offset	Type	Name
0	(32) `std::string`	mDescription
32	(112) `SemVersion`	mVersion
144	(16) `mce::UUID`	mUUID
160	(4) `ResourceInformation::ResourceType`	mType
168	(32) `std::string`	mEntry

# `ResourceTaskCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<TaskResult ()>::_Invoker_type`	_M_invoker

# `ResourceMainThreadCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<void ()>::_Invoker_type`	_M_invoker

# `ResourcePack::Callback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<void (const Core::Path &)>::_Invoker_type`	_M_invoker

# `ResourcePackContents`

Offset	Type	Name
0	(4) `uint32_t`	mUIJson
4	(4) `uint32_t`	mUITextures
8	(4) `uint32_t`	mSound
12	(4) `uint32_t`	mBlockJson
16	(4) `uint32_t`	mBlockTextures
20	(4) `uint32_t`	mItemTextures
24	(4) `uint32_t`	mEntityTextures
28	(4) `uint32_t`	mModelGeometry
32	(4) `uint32_t`	mAnimations
36	(4) `uint32_t`	mMaterials
40	(4) `uint32_t`	mLanguages

# `ResourcePackRepository::KnownPackInfo`

Offset	Type	Name
0	(1) `bool`	mDiscoveredOnDisk
8	(56) `ResourceLocation`	mResourceLocation
64	(24) `std::vector<std::string>`	mPastHashes
88	(136) `PackIdVersion`	mIdentity

# `RemoveActorPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(8) `ActorUniqueID`	mEntityId

# `RotationDescription`

Offset	Type	Name
0	(8) `Description`	baseclass_0
8	(8) `Vec2`	mRot

# `Range<unsigned short,1>::iterator`

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

# `ResourcePackDataInfoPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(32) `std::string`	mResourceName
72	(4) `uint32_t`	mChunkSize
76	(4) `int`	mNbChunks
80	(8) `uint64_t`	mFileSize
88	(32) `std::string`	mFileHash
120	(1) `PackType`	mPackType
121	(1) `bool`	mIsPremium

# `ResourcePackChunkDataPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(32) `std::string`	mResourceName
72	(4) `int`	mChunkID
80	(8) `uint64_t`	mByteOffset
88	(24) `std::vector<unsigned char>`	mData

# `Range<short,1>::iterator`

Offset	Type	Name
0	(2) `__int16`	mIndex

# `RopeParams`

Offset	Type	Name
0	(4) `float`	mNodeDist
4	(4) `float`	mNodeSize
8	(4) `float`	mGravity
12	(4) `float`	mSlack
16	(4) `float`	mMaxTension
20	(4) `float`	mVelDamping
24	(4) `float`	mRelaxation
28	(4) `float`	mFriction
32	(12) `Vec3`	mStartPin
44	(12) `Vec3`	mEndPin
56	(8) `size_t`	mIterations
64	(8) `size_t`	mDestroyDelay
72	(4) `int`	mFlags
76	(4) `float`	mLength
80	(4) `float`	mOriginalNodeDist

# `RideableComponent`

Offset	Type	Name
0	(1) `IEntityComponent`	baseclass_0

# `RaidTriggerComponent`

Offset	Type	Name
0	(1) `IEntityComponent`	baseclass_0

# `RuntimeIdentifierDescription`

Offset	Type	Name
0	(8) `DefintionDescription`	baseclass_0
8	(32) `std::string`	mRuntimeId

# `Raid::ActorIDCollection`

Offset	Type	Name
0	(56) `std::unordered_set<ActorUniqueID>::_Hashtable`	_M_h

# `ReverseableIterator::Iterator`

Offset	Type	Name
0	(4) `int`	mI
4	(1) `bool`	mReversed

# `ResourcePackMergeStrategy`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ResourcePackMergeStrategy

# `RecipeIngredient`

Offset	Type	Name
0	(24) `ItemDescriptorCount`	baseclass_0

# `RecipeMap`

Offset	Type	Name
0	(48) `std::map<std::string,std::unique_ptr<Recipe>>::_Rep_type`	_M_t

# `Range<unsigned char,'_x01'>::iterator`

Offset	Type	Name
0	(1) `unsigned __int8`	mIndex

# `Recipes::addShapedRecipe::Map`

Offset	Type	Name
0	(48) `std::map<char,RecipeIngredient>::_Rep_type`	_M_t

# `Recipes::addShapedRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `Recipe::Ingredients`

Offset	Type	Name
0	(24) `std::_Vector_base<RecipeIngredient>`	baseclass_0

# `Recipes::TypeList`

Offset	Type	Name
0	(24) `std::_Vector_base<Recipes::Type>`	baseclass_0

# `RowList`

Offset	Type	Name
0	(24) `std::_Vector_base<std::string>`	baseclass_0

# `Recipes::addShapelessRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `RakDataInput`

Offset	Type	Name
0	(8) `BytesDataInput`	baseclass_0
8	(8) `RakNet::BitStream *`	mBitStream

# `RenderParams`

Offset	Type	Name
0	(8) `BaseActorRenderContext *`	mBaseActorRenderContext
8	(8) `MolangVariableMap *`	mVariables
16	(8) `AnimationComponent *`	mAnimationComponent
24	(8) `AnimationComponent *`	mRootAnimationComponent
32	(8) `DataDrivenModel *`	mRootModel
40	(8) `DataDrivenModel *`	mModel
48	(8) `Actor *`	mActor
56	(8) `BlockSource *`	mBlockSource
64	(8) `ActorRenderData *`	mActorRenderData
72	(4) `int32_t`	mVertexCount
76	(2) `uint16_t`	mSubRenderLayerIndex
80	(32) `std::function<float ()>`	mRandomFunction
112	(4) `float`	mCameraDistance
116	(32) `float[8]`	mParams
148	(4) `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8`	mFlags

# `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8`

Offset	Type	Name
0	(4) `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8::$7CDB70B13784CF5DCA20C1417F11D194`	_anon_0
1	(4) `uint32_t`	_data

# `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8::$7CDB70B13784CF5DCA20C1417F11D194`

Offset	Type	Name
0	(1) `__int8`	_bf_0

# `RoomDefinition`

Offset	Type	Name
0	(16) `std::enable_shared_from_this<RoomDefinition>`	baseclass_0
16	(4) `int`	mIndex
24	(24) `std::vector<std::shared_ptr<RoomDefinition>>`	mConnections
48	(40) `std::vector<bool>`	mHasOpening
88	(1) `bool`	mClaimed
89	(1) `bool`	mIsSource
92	(4) `int`	mScanIndex

# `RakDataOutput`

Offset	Type	Name
0	(8) `BytesDataOutput`	baseclass_0
8	(8) `RakNet::BitStream *`	mBitStream

# `RandomValueBounds`

Offset	Type	Name
0	(4) `float`	mMin
4	(4) `float`	mMax

# `RequeueAreaFunc`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<void (const ITickingArea &)>::_Invoker_type`	_M_invoker

# `RopeWave`

Offset	Type	Name
0	(12) `Vec3`	mForce
12	(4) `float`	mSpeed
16	(4) `float`	mDamping
24	(8) `size_t`	mCurNode
32	(4) `float`	mDistAlongNode
36	(4) `RopeWave::Direction`	mDir

# `RailMovementComponent`

Offset	Type	Name
0	(4) `float`	mMaxSpeed

# `ResourceSignature`

Offset	Type	Name
0	(56) `std::unordered_map<std::string,std::string>`	mSignatureFileContents

# `ResourcePackChunkRequestPacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(32) `std::string`	mResourceName
72	(4) `int`	mChunk

# `RegisteredTagFilter`

Offset	Type	Name
0	(8) `TagSetID`	mIncludeSet
8	(8) `TagSetID`	mExcludeSet

# `RuntimeLightingManager::RelightingChunkElement`

Offset	Type	Name
0	(4) `float`	mDist
8	(8) `ChunkPos`	mChunkPos
16	(8) `size_t`	mSubChunkIndex
24	(8) `std::vector<SubChunkLightUpdate> *`	mAlteredBlockList

# `RoleChecker::OnRoleAcquired`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<void (ADRole,const std::string &,const std::string &)>::_Invoker_type`	_M_invoker

# `RakNet::RNS2_SendParameters`

Offset	Type	Name
0	(8) `char *`	data
8	(4) `int`	length
16	(136) `RakNet::SystemAddress`	systemAddress
152	(4) `int`	ttl

# `RakNet::RNS2_BerkleyBindParameters`

Offset	Type	Name
0	(2) `unsigned __int16`	port
8	(8) `char *`	hostAddress
16	(2) `unsigned __int16`	addressFamily
20	(4) `int`	type
24	(4) `int`	protocol
28	(1) `bool`	nonBlockingSocket
32	(4) `int`	setBroadcast
36	(4) `int`	setIPHdrIncl
40	(4) `int`	doNotFragment
44	(4) `int`	pollingThreadPriority
48	(8) `RakNet::RNS2EventHandler *`	eventHandler
56	(2) `unsigned __int16`	remotePortRakNetWasStartedOn_PS3_PS4_PSP2

# `RakNet::AddressOrGUID`

Offset	Type	Name
0	(16) `RakNet::RakNetGUID`	rakNetGuid
16	(136) `RakNet::SystemAddress`	systemAddress

# `RakNet::SimpleMutex`

Offset	Type	Name
0	(40) `pthread_mutex_t`	hMutex

# `RakNet::uint24_t`

Offset	Type	Name
0	(4) `uint32_t`	val

# `RakNet::MessageNumberType`

Offset	Type	Name
0	(4) `uint32_t`	val

# `RakNet::OrderingIndexType`

Offset	Type	Name
0	(4) `uint32_t`	val

# `RakNet::InternalPacket`

Offset	Type	Name
0	(32) `RakNet::InternalPacketFixedSizeTransmissionHeader`	baseclass_0
32	(4) `RakNet::MessageNumberType`	messageInternalOrder
36	(1) `bool`	messageNumberAssigned
40	(8) `RakNet::TimeUS`	creationTime
48	(8) `RakNet::TimeUS`	nextActionTime
56	(8) `RakNet::TimeUS`	retransmissionTime
64	(4) `RakNet::BitSize_t`	headerLength
72	(8) `unsigned __int8 *`	data
80	(4) `RakNet::InternalPacket::AllocationScheme`	allocationScheme
88	(8) `RakNet::InternalPacketRefCountedData *`	refCountedData
96	(1) `unsigned __int8`	timesSent
100	(4) `PacketPriority`	priority
104	(4) `uint32_t`	sendReceiptSerial
112	(8) `RakNet::InternalPacket *`	resendPrev
120	(8) `RakNet::InternalPacket *`	resendNext
128	(8) `RakNet::InternalPacket *`	unreliablePrev
136	(8) `RakNet::InternalPacket *`	unreliableNext
144	(128) `unsigned __int8[128]`	stackData

# `RakNet::InternalPacketFixedSizeTransmissionHeader`

Offset	Type	Name
0	(4) `RakNet::MessageNumberType`	reliableMessageNumber
4	(4) `RakNet::OrderingIndexType`	orderingIndex
8	(4) `RakNet::OrderingIndexType`	sequencingIndex
12	(1) `unsigned __int8`	orderingChannel
14	(2) `RakNet::SplitPacketIdType`	splitPacketId
16	(4) `RakNet::SplitPacketIndexType`	splitPacketIndex
20	(4) `RakNet::SplitPacketIndexType`	splitPacketCount
24	(4) `RakNet::BitSize_t`	dataBitLength
28	(4) `PacketReliability`	reliability

# `RakNet::Packet`

Offset	Type	Name
0	(136) `RakNet::SystemAddress`	systemAddress
136	(16) `RakNet::RakNetGUID`	guid
152	(4) `unsigned int`	length
156	(4) `RakNet::BitSize_t`	bitSize
160	(8) `unsigned __int8 *`	data
168	(1) `bool`	deleteData
169	(1) `bool`	wasGeneratedLocally

# `RakNet::NetworkAdapter`

Offset	Type	Name
0	(4) `unsigned int`	attributeFlags
4	(4) `int`	interfaceIndex
8	(1) `bool`	isDisabled
16	(2856) `RakNet::SystemAddress[21]`	addresses

# `r_debug`

Offset	Type	Name
0	(4) `int`	r_version
8	(8) `link_map *`	r_map
16	(8) `Elf64_Addr`	r_brk
24	(4) `r_debug::$779A3ED0FCC279D8F3DE0A4A7B5F9A6A`	r_state
32	(8) `Elf64_Addr`	r_ldbase

# `ResourcePackListener`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ResourcePackListener

# `RakNet::RakNetRandom`

Offset	Type	Name
0	(2500) `unsigned int[625]`	state
2504	(8) `unsigned int *`	next
2512	(4) `int`	left

# `RakNet::RakString::SharedString`

Offset	Type	Name
0	(8) `RakNet::SimpleMutex *`	refCountMutex
8	(4) `unsigned int`	refCount
16	(8) `size_t`	bytesUsed
24	(8) `char *`	bigString
32	(8) `char *`	c_str
40	(100) `char[100]`	smallString

# `RakStringCleanup`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `Range<int,-1>`

Offset	Type	Name
0	(4) `const int`	mBeginIDX
4	(4) `const int`	mEndIDX

# `Range<int,1>`

Offset	Type	Name
0	(4) `const int`	mBeginIDX
4	(4) `const int`	mEndIDX

# `Range<unsigned int,1>`

Offset	Type	Name
0	(4) `const unsigned int`	mBeginIDX
4	(4) `const unsigned int`	mEndIDX

# `ResourceLoadManager`

Offset	Type	Name
0	(8) `Scheduler *`	mScheduler
8	(8) `WorkerPool *`	mWorkerPool
16	(48) `std::map<ResourceLoadType,std::unique_ptr<ResourceLoadManager::ResourceLoadTaskGroup>>`	mResourceLoadTaskGroups
64	(8) `size_t`	mAppSuspended

# `RakNetInstance::ConnectionCallbacks`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ConnectionCallbacks

# `RakNetInstance`

Offset	Type	Name
0	(8) `Connector`	baseclass_0
8	(8) `RakNetInstance::ConnectionCallbacks *`	mCallbacks
16	(152) `NetworkIdentifier`	mNATPunchServerId
168	(240) `Social::GameConnectionInfo`	mBackupGameConnection
408	(1) `bool`	mTryBackupConnection
416	(16) `UniqueRakPeer`	mRakPeer
432	(152) `NetworkIdentifier`	mServerId
584	(160) `Connector::NatPunchInfo`	mNatPunchInfo
744	(4) `RakNetInstance::NATState`	mNatState
752	(24) `std::vector<RakNetInstance::NatConnectionInfo>`	mNatList
776	(24) `RakPeerHelper`	mPeerHelper
800	(8) `RakPeerHelper::IPSupportInterface *`	mIPSupportInterface
808	(1) `bool`	mIsAwaitingNatClient
809	(1) `bool`	mIsServer
810	(1) `bool`	mIsDisconnecting
811	(1) `bool`	mConnectingToClient
816	(240) `Social::GameConnectionInfo`	mConnectedGameInfo
1056	(56) `std::unordered_map<NetworkIdentifier,std::weak_ptr<RakNetInstance::RakNetNetworkPeer>>`	mPeers
1112	(24) `std::vector<Connector::ConnectionStateListener *>`	mConnectionStateListeners
1136	(1) `bool`	mWasHostWhenSuspended
1140	(16) `ConnectionDefinition`	mPreviousConnectionDefinition
1160	(32) `std::string`	mResolvedIP
1192	(24) `std::vector<RakNetInstance::PingCallbackData>`	mPingTimeCallbacks

# `RakPeerHelper`

Offset	Type	Name
0	(4) `RakNet::StartupResult`	mResult
4	(8) `int[2]`	mConnectionIndices
12	(4) `uint16_t[2]`	mBoundPorts
16	(8) `RakPeerHelper::IPSupportInterface *`	mIPSupportInterface

# `Range<unsigned long,1>`

Offset	Type	Name
0	(8) `const unsigned __int64`	mBeginIDX
8	(8) `const unsigned __int64`	mEndIDX

# `RakPeerHelper::IPSupportInterface`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$IPSupportInterface

# `ResourcePackInfoData`

Offset	Type	Name
0	(136) `PackIdVersion`	mPackIdVersion
136	(8) `uint64_t`	mPackSize
144	(32) `std::string`	mContentKey
176	(32) `std::string`	mSubpackName
208	(24) `ContentIdentity`	mContentIdentity
232	(1) `bool`	mHasScripts
233	(1) `bool`	mHasExceptions

# `ResourceLoadManager::ResourceLoadTaskGroup`

Offset	Type	Name
0	(4) `ResourceLoadType`	mLoadType
8	(8) `std::unique_ptr<TaskGroup>`	mTaskGroup
16	(24) `std::vector<ResourceLoadType>`	mDependencies
40	(16) `ResourceLoadManager::TaskGroupState`	mTaskGroupState
56	(1) `bool`	mTaskGroupPaused

# `ResourceLoadManager::TaskGroupState`

Offset	Type	Name
0	(1) `bool`	mRunning
8	(8) `size_t`	mPaused

# `ResourcePath`

Offset	Type	Name
0	(32) `std::string`	mPackId
32	(32) `std::string`	mPath

# `Range<unsigned short,1>`

Offset	Type	Name
0	(2) `const unsigned __int16`	mBeginIDX
2	(2) `const unsigned __int16`	mEndIDX

# `Range<short,1>`

Offset	Type	Name
0	(2) `const __int16`	mBeginIDX
2	(2) `const __int16`	mEndIDX

# `RandomHoverGoal`

Offset	Type	Name
0	(16) `Goal`	baseclass_0
16	(8) `Mob *`	mMob
24	(4) `const float`	mSpeedModifier
28	(4) `const int`	mInterval
32	(4) `const float`	mXZDist
36	(4) `const float`	mYDist
40	(4) `float`	mYOffset
44	(8) `IntRange`	mHoverHeight
56	(8) `Unique<Path>`	mPath

# `Raid`

Offset	Type	Name
0	(4) `Raid::RaidState`	mCurrentRaidState
4	(1) `Raid::GroupNumberType`	mCurrentGroupNumber
5	(1) `Raid::GroupNumberType`	mNumGroupsInRaid
8	(8) `Tick`	mTicksInState
16	(4) `const Raid::DurationType`	mRaidPreparationTime
20	(4) `const Raid::DurationType`	mGroupCompleteDelay
24	(4) `Raid::DurationType`	mTicksUntilGroupComplete
28	(4) `const Raid::DurationType`	mLocationHelpDelay
32	(4) `Raid::DurationType`	mTicksUntilLocationHelp
36	(12) `Vec3`	mCurrentGroupSpawnPoint
48	(56) `Raid::ActorIDCollection`	mRaiders
104	(1) `Raid::RaiderCountType`	mNumRaidersSpawnedInCurrentGroup
105	(1) `const Raid::FailureCountType`	mAllowedSpawnFailures
106	(1) `Raid::FailureCountType`	mSpawnFailures
112	(32) `const Raid::PickSpawnPointCallback`	mPickSpawnPointCallback
144	(32) `const Raid::SpawnGroupCallback`	mSpawnGroupCallback
176	(32) `const Raid::DoesActorExistCallback`	mDoesActorExistCallback
208	(32) `Raid::NotificationCallback`	mOnSpawnPointChosenCallback
240	(32) `Raid::NotificationCallback`	mOnGroupSpawnedCallback
272	(32) `Raid::NotificationCallback`	mOnAwardRewardsCallback
304	(32) `Raid::NotificationCallback`	mOnHelpLocateRaidersCallback

# `Raid::PickSpawnPointCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<bool (unsigned long,Vec3 &)>::_Invoker_type`	_M_invoker

# `Raid::SpawnGroupCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<bool (unsigned long,Vec3,unsigned char,std::unordered_set<ActorUniqueID> &)>::_Invoker_type`	_M_invoker

# `Raid::DoesActorExistCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<bool (const ActorUniqueID &)>::_Invoker_type`	_M_invoker

# `Raid::NotificationCallback`

Offset	Type	Name
0	(24) `std::_Function_base`	baseclass_0
24	(8) `std::function<void (const Raid &)>::_Invoker_type`	_M_invoker

# `Rabbit::updateEntitySpecificMolangVariables::$7EF7C94BEAB75C6CEF4ADFB99B570420`

Offset	Type	Name
0	(1) `__int8[1]`	gap0

# `RespawnPacket`

Offset	Type	Name
0	(36) `Packet:288`	baseclass_0
36	(12) `Vec3`	mPos
48	(1) `PlayerRespawnState`	mState
56	(8) `ActorRuntimeID`	mRuntimeId

# `ReverseableIterator`

Offset	Type	Name
0	(4) `const int`	mStartValue
4	(4) `const int`	mEndValue
8	(1) `const bool`	mReversed

# `Recipes::Type`

Offset	Type	Name
0	(8) `Item *`	mItem
8	(8) `const Block *`	mBlock
16	(24) `RecipeIngredient`	mIngredient
40	(1) `char`	mC

# `Range<unsigned char,'_x01'>`

Offset	Type	Name
0	(1) `const unsigned __int8`	mBeginIDX
1	(1) `const unsigned __int8`	mEndIDX

# `ResourcePackManager`

Offset	Type	Name
0	(40) `ResourceLoader`	baseclass_0
40	(56) `std::unordered_set<ResourcePackListener *>`	mListeners
96	(8) `std::unique_ptr<ResourcePackStack>`	mAddonStack
104	(8) `std::unique_ptr<ResourcePackStack>`	mLevelStack
112	(8) `std::unique_ptr<ResourcePackStack>`	mGlobalStack
120	(8) `std::unique_ptr<ResourcePackStack>`	mTreatmentStack
128	(8) `std::unique_ptr<ResourcePackStack>`	mBaseGameStack
136	(8) `std::unique_ptr<ResourcePackStack>`	mFullStack
144	(8) `std::unique_ptr<PackSourceReport>`	mLoadingReport
152	(32) `std::string`	mLocaleCode
184	(1) `bool`	mInitializing
185	(1) `bool`	mPendingRestack
186	(1) `bool`	mUseGlobalPackStack
187	(1) `bool`	mExperimentalGameplay
192	(56) `SharedMutex`	mFullStackAccess
248	(8) `const ContentTierManager *`	mContentTierManager
256	(112) `SemVersion`	mFullStackMinEngineVersion

# `ResourceLoader`

Offset	Type	Name
0	(8) `int (**)(void)`	_vptr$ResourceLoader
8	(32) `std::function<Core::PathBuffer<std::string > ()>`	mGetPath

# `RopePoint`

Offset	Type	Name
0	(12) `Vec3`	mOldPos
12	(12) `Vec3`	mToNewPos

# `RopeNode`

Offset	Type	Name
0	(12) `Vec3`	mPos
12	(12) `Vec3`	mPrevPos
24	(1) `char`	mFrictionAxis

# `RopeAABB`

Offset	Type	Name
0	(28) `AABB`	mBB
28	(1) `bool`	mBlacklisted

# `RemoveObjectivePacket`

Offset	Type	Name
0	(40) `Packet`	baseclass_0
40	(32) `std::string`	mObjectiveName

# `RelativeFloat`

Offset	Type	Name
0	(4) `float`	mOffset
4	(1) `bool`	mRelative

# `RakNet::CCRakNetSlidingWindow`

Offset	Type	Name
0	(4) `uint32_t`	MAXIMUM_MTU_INCLUDING_UDP_HEADER
8	(8) `double`	cwnd
16	(8) `double`	ssThresh
24	(8) `CCTimeType`	oldestUnsentAck
32	(4) `DatagramSequenceNumberType`	nextDatagramSequenceNumber
36	(4) `DatagramSequenceNumberType`	nextCongestionControlBlock
40	(1) `bool`	backoffThisBlock
41	(1) `bool`	speedUpThisBlock
44	(4) `DatagramSequenceNumberType`	expectedNextSequenceNumber
48	(1) `bool`	_isContinuousSend
56	(8) `double`	lastRtt
64	(8) `double`	estimatedRTT
72	(8) `double`	deviationRtt

# `RakNet::ReliabilityLayer::DatagramHistoryNode`

Offset	Type	Name
0	(8) `RakNet::ReliabilityLayer::MessageNumberNode *`	head
8	(8) `CCTimeType`	timeSent

# `RakNet::BPSTracker::TimeAndValue2`

Offset	Type	Name
0	(8) `uint64_t`	value1
8	(8) `CCTimeType`	time

# `RealmsUnknownPackSource`

struct __cppobj RealmsUnknownPackSource : PackSource
{
  PackType mPackType;
  PackOrigin mPackOrigin;
  std::vector<std::unique_ptr<Pack>> mPacks;
  PackSourceReport mReport;
};

# `ResourcePack`

struct ResourcePack
{
  bool mHidden;
  bool mError;
  Pack *mPack;
  std::unique_ptr<PackAccessStrategy> mSubpackAccessStrategy;
  PackReport mPackReport;
  std::vector<std::unique_ptr<Pack>> mSubPacks;
  std::vector<std::unique_ptr<ResourcePack>> mSubResourcePacks;
  Core::HeapPathBuffer mIconPath;
  double mLoadTime;
  bool mIsBaseGamePack;
  bool mIsSlicePack;
  ResourceSignature mResourceSignature;
};

# `RakNet::TCPInterface`

struct RakNet::TCPInterface
{
  int (**_vptr$TCPInterface)(void);
  DataStructures::List<RakNet::PluginInterface2 *> messageHandlerList;
  RakNet::LocklessUint32_t isStarted;
  RakNet::LocklessUint32_t threadRunning;
  __TCPSOCKET__ listenSocket;
  unsigned __int16 listenPort;
  unsigned __int16 listenMaxIncomingConnections;
  unsigned __int16 listenSocketFamily;
  char *listenHostAddress;
  DataStructures::Queue<RakNet::Packet *> headPush;
  DataStructures::Queue<RakNet::Packet *> tailPush;
  RakNet::RemoteClient *remoteClients;
  int remoteClientsLength;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::Packet> incomingMessages;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::SystemAddress> newIncomingConnections;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::SystemAddress> lostConnections;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::SystemAddress> requestedCloseConnections;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::RemoteClient *> newRemoteClients;
  RakNet::SimpleMutex completedConnectionAttemptMutex;
  RakNet::SimpleMutex failedConnectionAttemptMutex;
  DataStructures::Queue<RakNet::SystemAddress> completedConnectionAttempts;
  DataStructures::Queue<RakNet::SystemAddress> failedConnectionAttempts;
  int threadPriority;
  DataStructures::List<int> blockingSocketList;
  RakNet::SimpleMutex blockingSocketListMutex;
};

# `ResetEventObj`

struct __attribute__((aligned(8))) ResetEventObj
{
  Bedrock::Threading::ConditionVariable mCondition;
  Bedrock::Threading::Mutex mMutex;
  std::atomic<bool> mSet;
  bool mAutoReset;
};

# `RaidBossSystem`

struct __cppobj RaidBossSystem : ITickingSystem
{
};

# `RailActivatorSystem`

struct __cppobj RailActivatorSystem : ITickingSystem
{
};

# `ReedsFeature`

struct __cppobj ReedsFeature : Feature
{
};

# `RoofTreeFeature`

struct __cppobj __attribute__((aligned(8))) RoofTreeFeature : TreeFeature
{
};

# `ReferencedPieceList`

typedef std::vector<StructurePiece *> ReferencedPieceList;

# `RuntimeLightingManager`

struct RuntimeLightingManager
{
  std::unordered_map<ChunkPos,RuntimeLightingManager::RuntimeLightingSubchunkList> mLevelChunksToLight;
  std::vector<RuntimeLightingManager::RelightingChunkElement> mListOfChunksToProcess;
  std::vector<BlockPos> mProcessedSubchunks;
  std::vector<BlockPos> mBrightnessChangedList;
  Dimension *mDimension;
  bool mWorkerScheduled;
  float mLightingTimeboxTime;
};

# `RegionHillsLayer`

struct __cppobj RegionHillsLayer : UnaryLayer<Biome *,Biome *>
{
  LayerPtr<LayerValues::RiverData> mRiverLayer;
  const BiomeRegistry *mBiomeRegistry;
};

# `RandomScatteredLargeFeature`

struct __cppobj RandomScatteredLargeFeature : StructureFeature
{
  std::vector<int> allowedBiomes;
  int mSpacing;
  int mMinSeparation;
};

# `RootLayer<LayerValues::Terrain>`

struct __cppobj RootLayer<LayerValues::Terrain> : Layer<LayerValues::Terrain>
{
};

# `RootLayer<BiomeTemperatureCategory>`

struct __cppobj RootLayer<BiomeTemperatureCategory> : Layer<BiomeTemperatureCategory>
{
};

# `Realms::Player`

struct __attribute__((aligned(8))) Realms::Player
{
  std::string name;
  std::string xuid;
  std::string realName;
  Social::UserPicturePath gamerpicLocation;
  bool isOperator;
  bool hasAccepted;
  bool isOnline;
  PlayerPermissionLevel permission;
};

# `Realms::World`

struct __attribute__((aligned(8))) Realms::World
{
  Realms::RealmId id;
  Realms::World::State state;
  std::string name;
  std::string description;
  std::string ownerXuid;
  std::string ownerName;
  std::string clubId;
  int daysLeft;
  bool expired;
  int maxPlayers;
  bool newWorld;
  int gameMode;
  bool gracePeriod;
  int difficulty;
  bool cheatsEnabled;
  bool full;
  bool isMember;
  bool texturePacksRequired;
  PlayerPermissionLevel defaultPermission;
  std::vector<Realms::Player> players;
  bool mValid;
};

# `reverse_iterator`

typedef std::reverse_iterator<std::_Bit_iterator> reverse_iterator;

# `reference`

typedef std::_Bit_reference reference;

# `RailActivatorDescription`

struct __cppobj __attribute__((aligned(4))) RailActivatorDescription : ComponentDescription
{
  DefinitionTrigger mOnActivate;
  DefinitionTrigger mOnDeactivate;
  bool mCheckBlockTypes;
  bool mTickCommandBlockOnActivate;
  bool mTickCommandBlockOnDeactivate;
  bool mEjectOnActivate;
  bool mEjectOnDeactivate;
};

# `ResourceLoadManager::LoadOrder`

struct ResourceLoadManager::LoadOrder
{
  __int8 gap0[1];
};

# `ResourcePackFileDownloaderManager`

struct __cppobj ResourcePackFileDownloaderManager : std::enable_shared_from_this<ResourcePackFileDownloaderManager>
{
  int (**_vptr$ResourcePackFileDownloaderManager)(void);
  PacketSender *mPacketSender;
  std::string mResourceName;
  std::string mFileHash;
  bool mChunkWriteSuccess;
  Core::HeapPathBuffer mZipFilePath;
  Core::HeapPathBuffer mResourcePath;
  FileChunkManager mChunkManager;
  std::function<void (bool,const Core::Path &)> mCompletionCallback;
  std::function<void (float)> mProgressCallback;
  MPMCQueue<std::function<void ()> > mCallbackQueue;
  TaskGroup *mIOTaskGroup;
};

# `ResourcePackFileUploadManager`

struct __cppobj ResourcePackFileUploadManager : FileUploadManager
{
  std::vector<Core::PathBuffer<std::string >> mZipPaths;
  std::vector<Core::PathBuffer<std::string >> mTempDirPaths;
};

# `RakNetServerLocator`

struct __cppobj RakNetServerLocator : ServerLocator
{
  std::unordered_map<std::string,std::string> originalAddresses;
  std::unordered_map<std::string,RakNetServerLocator::PingRateRecorder> pingTimeRecorders;
  std::unordered_map<std::string,std::string> guidCache;
  std::function<RakNet::RakNetGUID ()> mGetHostGUID;
  RakNetInstance *mRaknetInstance;
  UniqueRakPeer mFinderPeer;
  RakPeerHelper mFinderPeerHelper;
  std::vector<PingedCompatibleServer> mAvailableServers;
  bool mIsPingingForServers;
  const bool mIsServer;
  int mPingPort;
  int mPingPortv6;
  RakNet::TimeMS mLastPingTime;
  std::vector<std::string> mBroadcastAddresses;
  std::vector<std::string> mMulticastAddressesV6;
  std::queue<std::pair<AsynchronousIPResolver,int>> mPingQueue;
  std::function<void (bool)> mServerValidationCallback;
  std::string mServerWaitingToValidate;
  RakNet::TimeMS mLastPingToServerWaitingToValidateTime;
  Bedrock::Threading::RecursiveMutex mServerListLock;
};

# `ResourcePackTransmissionManager`

struct ResourcePackTransmissionManager
{
  std::unordered_map<unsigned long,std::unordered_map<std::string,std::shared_ptr<ResourcePackFileDownloaderManager>>> mResourceDownloadManagers;
  std::unordered_map<unsigned long,std::unordered_map<std::string,std::shared_ptr<ResourcePackFileUploadManager>>> mResourceUploadManagers;
  std::unordered_set<unsigned long> mRemovedResourceDownloadManagers;
  std::unordered_set<unsigned long> mRemovedResourceUploadManagers;
  std::unique_ptr<TaskGroup> mIOTaskGroup;
};

# `RakNet::RakPeerInterface`

struct RakNet::RakPeerInterface
{
  int (**_vptr$RakPeerInterface)(void);
};

# `ResourcePackClientResponsePacket`

struct __cppobj __attribute__((aligned(8))) ResourcePackClientResponsePacket : Packet
{
  std::set<std::string> mDownloadingPacks;
  ResourcePackResponse mResponse;
};

# `RiderJumpPacket`

struct __cppobj RiderJumpPacket : Packet:288
{
  int mJumpScale;
};

# `RemoveEntityPacket`

struct __cppobj RemoveEntityPacket : EntityServerPacket
{
};

# `RequestChunkRadiusPacket`

struct __cppobj RequestChunkRadiusPacket : Packet:288
{
  int mChunkRadius;
};

# `RakNetInstance::RakNetNetworkPeer`

struct __cppobj __attribute__((aligned(8))) RakNetInstance::RakNetNetworkPeer : NetworkPeer
{
  RakNet::RakPeerInterface *mRakPeer;
  NetworkIdentifier mId;
  std::string mSendBuffer;
  std::vector<std::string> mReadBuffers;
  int mApproximateMaxBps;
  int mLastPing;
  int mAveragePing;
};

# `RakNetInstance::PingCallbackData`

struct RakNetInstance::PingCallbackData
{
  std::string mAddress;
  std::function<void (unsigned int)> mAction;
};

# `RakNetServerLocator::PingRateRecorder`

struct __attribute__((aligned(8))) RakNetServerLocator::PingRateRecorder
{
  std::vector<unsigned long> mPingTimes;
  unsigned int mAveragingWindowSize;
  float mAverageTime;
  float mLastPingTime;
  RakNet::TimeMS mStartTime;
  unsigned int mPingTimesIndex;
  int mIpVersion;
  bool mPingStarted;
  bool mAveraging;
};

# `Recipe`

struct Recipe
{
  int (**_vptr$Recipe)(void);
  std::string mRecipeId;
  ItemPack mMyItems;
  mce::UUID mMyId;
  int mWidth;
  int mHeight;
  int mPriority;
  Recipe::Ingredients mMyIngredients;
  Util::HashString mTag;
};

# `Recipes`

struct Recipes
{
  ResourcePackManager *mResourcePackManager;
  std::map<Util::HashString,std::map<std::string,std::unique_ptr<Recipe>>> mRecipes;
  std::map<Recipes::FurnaceRecipeKey,ItemInstance> mFurnaceRecipes;
  bool mInitializing;
  std::map<ItemInstance,std::unordered_map<std::string,Recipe *>,SortItemInstanceIdAux,std::allocator<std::pair<const ItemInstance,std::unordered_map<std::string,Recipe *> > > > mRecipesByOutput;
  RecipeListenerList mListeners;
};

# `RecipeListenerList`

typedef std::vector<std::pair<std::weak_ptr<bool>,std::function<void ()> >> RecipeListenerList;

# `RepairItemRecipe`

struct __cppobj RepairItemRecipe : MultiRecipe
{
  Recipe::ResultList mResults;
};

# `ResourceLocationPair`

struct __attribute__((aligned(8))) ResourceLocationPair
{
  ResourceLocation mResourceLocation;
  PackIdVersion mPackId;
  int mPackPosition;
};

# `RandomThreadCheckManager`

struct __cppobj __attribute__((aligned(8))) RandomThreadCheckManager : AppPlatformListener
{
  std::atomic_uint mSuspendResumeIndex;
};

# `RopeSystem`

struct RopeSystem
{
  bool mWaveApplied;
  RopePoints mQueuedRenderPoints;
  RopePoints mRenderPoints;
  std::vector<RopeNode> mNodes;
  std::vector<AABBBucket> mColliderBuckets;
  std::vector<RopeWave> mWaves;
  RopeParams mParams;
  std::set<AABB,AABBPred,std::allocator<AABB> > mBlacklistedColliders;
  Vec3 mPrevStartPin;
  Vec3 mPrevEndPin;
  size_t mCutNode;
  size_t mCutRenderNode;
  size_t mMinNodes;
  size_t mCutTicks;
  ActorUniqueID mEndPinEntity;
  std::atomic_flag mTicking;
  Bedrock::Threading::Mutex mRenderMutex;
  bool mAbandonCollision;
  Vec3 mStartPin;
  Vec3 mEndPin;
  size_t mToCutNode;
};

# `RopePoints`

struct RopePoints
{
  size_t mSize;
  std::vector<RopePoint> mPoints;
};

# `RaidTriggerDescription`

struct __cppobj RaidTriggerDescription : ComponentDescription
{
  DefinitionTrigger mOnTriggered;
};

# `RideableDescription`

struct __cppobj __attribute__((aligned(8))) RideableDescription : ComponentDescription
{
  int mSeatCount;
  int mControllingSeat;
  bool mSkipInteractIfCrouching;
  std::vector<SeatDescription> mSeats;
  Util::hashStringSet mFamilyTypes;
  std::string mInteractText;
  bool mPullInEntities;
  bool mRiderCanPick;
};

# `RopePointsRef`

struct RopePointsRef
{
  const RopePoints *mPoints;
  Bedrock::Threading::Mutex *mPointMutex;
};

# `RemovedActorDamageByType`

struct __cppobj RemovedActorDamageByType : ActorDamageSource:96
{
  ActorType mEntityType;
};

# `Rabbit`

struct __cppobj Rabbit : Animal
{
  int mMoreCarrotTicks;
  int mCarrotsEaten;
};

# `RaiderCelebrationGoal`

struct __cppobj RaiderCelebrationGoal : Goal
{
  Mob *mMob;
  LevelSoundEvent mSoundEvent;
  FloatRange mSoundIntervalRange;
  FloatRange mJumpIntervalRange;
  int mNextJumpTickTimer;
  int mNextSoundTickTimer;
  int mDurationInTicks;
  int mRuntimeTicks;
  const DefinitionTrigger mOnEndEvent;
};

# `RunAroundLikeCrazyGoal`

struct __cppobj RunAroundLikeCrazyGoal : Goal
{
  Mob *mMob;
  float mSpeedModifier;
  Vec3 mPos;
};

# `RestrictSunGoal`

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

# `RestrictOpenDoorGoal`

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

# `RandomLookAroundGoal`

struct __cppobj RandomLookAroundGoal : Goal:96
{
  float mRelX;
  float mRelZ;
  int mTotalLookTime;
  int mMinLookTime;
  int mMaxLookTime;
  float mProbability;
  Mob *mMob;
};

# `RandomSitGoal`

struct __cppobj __attribute__((aligned(8))) RandomSitGoal : Goal
{
  Mob *mMob;
  const float mStartChance;
  const float mStopChance;
  uint64_t mCooldown;
  const int mSitCooldownTotal;
  const int mMinSitTick;
  int mCurrentSitTick;
};

# `RandomLookAroundAndSitGoal`

struct __cppobj __attribute__((aligned(8))) RandomLookAroundAndSitGoal : RandomLookAroundGoal
{
  int mMinLookCount;
  int mMaxLookCount;
  int mTotalLookCount;
};

# `RangedAttackGoal`

struct __cppobj __attribute__((aligned(8))) RangedAttackGoal : Goal
{
  Mob *mMob;
  TempEPtr<Actor> mTarget;
  int mAttackTime;
  float mSpeedModifier;
  int mSeeTime;
  int mAttackIntervalMin;
  int mAttackIntervalMax;
  float mAttackRadius;
  float mAttackRadiusSqr;
  float mFOV;
  bool mIsChargedAttack;
  int mChargeShootTrigger;
  int mChargeChargedTrigger;
  int mCharge;
  int mBurstShots;
  int mBurstShotsLeft;
  int mBurstInterval;
  int mBurstTime;
  bool mUsingChargedItem;
};

# `RandomBreachingGoal`

struct RandomBreachingGoal
{
  __int8 baseclass_0[68];
  int mCooldown;
  int mTimer;
  int mAttempts;
};

# `RandomStrollGoal`

struct __cppobj __attribute__((aligned(8))) RandomStrollGoal : Goal
{
  Mob *mMob;
  float mSpeed;
  int mXZDist;
  int mYDist;
  int mInterval;
  Vec3 mWantedPosition;
  BlockPos mChosenEndPos;
  bool mPathingInvalid;
  bool mReachedTarget;
};

# `RandomSwimmingGoal`

struct __cppobj __attribute__((aligned(8))) RandomSwimmingGoal : RandomStrollGoal
{
};

# `RandomFlyingGoal`

struct __attribute__((aligned(8))) RandomFlyingGoal
{
  __int8 baseclass_0[66];
  bool mCanLandOnTrees;
};

# `ReceiveLoveGoal`

struct __cppobj ReceiveLoveGoal : Goal
{
  VillagerBase *mVillager;
};

# `RollGoal`

struct __cppobj __attribute__((aligned(8))) RollGoal : Goal
{
  Mob *mMob;
  float mRollXd;
  float mRollZd;
  float mProbability;
};

# `RaidGardenGoal`

struct __cppobj RaidGardenGoal : BaseMoveToBlockGoal
{
  int mMaxToEat;
  int mEaten;
  int mEatDelay;
  int mHasEatenFillDelay;
  int mInitialEatDelay;
  int mEatTimer;
  int mHasEatenFillTimer;
  std::set<const Block *> mEatBlocks;
};

# `RandomStrollGoal:528`

struct __cppobj __attribute__((packed)) __attribute__((aligned(2))) RandomStrollGoal:528 : Goal
{
  Mob *mMob;
  float mSpeed;
  int mXZDist;
  int mYDist;
  int mInterval;
  Vec3 mWantedPosition;
  BlockPos mChosenEndPos;
  bool mPathingInvalid;
  bool mReachedTarget;
};

# `RandomPos`

struct RandomPos
{
  __int8 gap0[1];
};

# `RiverFollowingGoal`

struct __cppobj __attribute__((aligned(8))) RiverFollowingGoal : Goal
{
  Mob *mMob;
  Vec3 mHeading;
  float mLookAhead;
  float mSpeed;
};

# `RemoveOnHitSubcomponent`

struct __cppobj RemoveOnHitSubcomponent : OnHitSubcomponent
{
};

# `RapidFertilizerItem`

struct __cppobj __attribute__((aligned(8))) RapidFertilizerItem : FertilizerItem
{
};

# `RecordItem`

struct __cppobj RecordItem : Item
{
  LevelSoundEvent mSoundEvent;
  float mDuration;
};

# `RedStoneDustItem`

struct __cppobj RedStoneDustItem : Item
{
};

# `RecipeListener`

typedef std::pair<std::weak_ptr<bool>,std::function<void ()> > RecipeListener;

# `RiverTransformationAttributes`

typedef WeightedBiomeAttributes<RiverTransformation> RiverTransformationAttributes;

# `RepeaterBlock`

struct __cppobj __attribute__((aligned(8))) RepeaterBlock : DiodeBlock
{
};

# `RandomizableBlockActorFillingContainer`

struct __cppobj RandomizableBlockActorFillingContainer : RandomizableBlockActorContainerBase, FillingContainer
{
};

# `RandomizableBlockActorContainerBase`

struct __cppobj __attribute__((aligned(8))) RandomizableBlockActorContainerBase : BlockActor
{
  std::string mLootTable;
  int mLootTableSeed;
};

# `RandomizableBlockActorContainer`

struct __cppobj RandomizableBlockActorContainer : RandomizableBlockActorContainerBase, Container
{
};

# `RedStoneWireBlock`

struct __cppobj RedStoneWireBlock : BlockLegacy
{
};

# `RailBlock`

struct __cppobj __attribute__((aligned(8))) RailBlock : BaseRailBlock
{
};

# `RedStoneOreBlock`

struct __cppobj __attribute__((aligned(8))) RedStoneOreBlock : BlockLegacy
{
  bool mLit;
};

# `RedstoneTorchBlock`

struct __cppobj __attribute__((aligned(8))) RedstoneTorchBlock : TorchBlock
{
  bool mOn;
};

# `ReedBlock`

struct __cppobj ReedBlock : BlockLegacy
{
};

# `RedstoneLampBlock`

struct __cppobj __attribute__((aligned(8))) RedstoneLampBlock : BlockLegacy
{
  const bool mIsLit;
};

# `RedstoneBlock`

struct __cppobj RedstoneBlock : BlockLegacy
{
};

# `RotatedPillarBlock`

struct __cppobj RotatedPillarBlock : BlockLegacy
{
};

# `RuntimeLightingManager::RuntimeLightingSubchunkList`

struct RuntimeLightingManager::RuntimeLightingSubchunkList
{
  std::array<std::vector<SubChunkLightUpdate>,16> mAlteredSubchunkBlockList;
};

# `RandomAuxValueFunction`

struct __cppobj RandomAuxValueFunction : LootItemFunction
{
  RandomValueBounds mValues;
};

# `RandomBlockStateFunction`

struct __cppobj RandomBlockStateFunction : LootItemFunction
{
  RandomValueBounds mValues;
  std::string mBlockStateName;
};

# `RepeaterCapacitor`

struct __cppobj RepeaterCapacitor : CapacitorComponent:544
{
  RepeaterCapacitor::States mOnStates[5];
  int mInsertAt;
  bool mPowered;
  bool mNextPower;
  bool mLocked;
  int mPulseCount;
  bool mPulse;
  bool mNextPulse;
  CircuitComponentList mSideComponents;
};

# `RedstoneTorchCapacitor`

struct __cppobj __attribute__((aligned(8))) RedstoneTorchCapacitor : CapacitorComponent
{
  RedstoneTorchCapacitor *mNextOrder;
  int mSelfPowerCount;
  RedstoneTorchCapacitor::State mState[2];
  bool mCanReigniteFromBurnout;
};

# `RailMovementSystem`

struct __cppobj RailMovementSystem : ITickingSystem
{
};

# `RoleChecker`

struct RoleChecker
{
  std::weak_ptr<RoleCheckerCallback> mPendingCallback;
};

# `RoleCheckerCallback`

struct RoleCheckerCallback
{
  RoleChecker::OnRoleAcquired mCallback;
};

# `ReloadCommand`

struct __cppobj ReloadCommand : Command
{
};

# `ReplaceItemCommand`

struct __cppobj __attribute__((aligned(8))) ReplaceItemCommand : Command
{
  ReplaceItemCommand::TargetType mTargetType;
  ActorSelector mTargetEntity;
  CommandPosition mTargetBlock;
  BlockSlot mBlockSlot;
  EquipmentSlot mEquipmentSlot;
  int mSlotId;
  CommandItem mItem;
  int mAmount;
  int mData;
  Json::Value mComponents;
  bool mHaveComponents;
};

# `RailMovementDefinition`

struct RailMovementDefinition
{
  float mMaxSpeed;
};

# `RepeatUntilSuccessDefinition`

struct __cppobj RepeatUntilSuccessDefinition : DecoratorDefinition
{
  int mMaxNumberOfAttempts;
  std::string mMaxNumberOfAttemptsId;
};

# `RepeatUntilSuccessNode`

struct __cppobj RepeatUntilSuccessNode : BehaviorNode
{
  Unique<BehaviorNode> mActiveChild;
  int mMaxNumberOfAttempts;
  int mCurrentAttempt;
};

# `RepeatUntilFailureDefinition`

struct __cppobj RepeatUntilFailureDefinition : DecoratorDefinition
{
};

# `RepeatUntilFailureNode`

struct __cppobj RepeatUntilFailureNode : BehaviorNode
{
  Unique<BehaviorNode> mActiveChild;
};

# `RangedWeaponItem`

struct __cppobj RangedWeaponItem : Item
{
};

# `RegionFile`

struct RegionFile
{
  int (**_vptr$RegionFile)(void);
  Core::File mFile;
  Core::HeapPathBuffer mFileName;
  std::array<int,1024> mOffsets;
  std::array<int,1024> mEmptyChunk;
  RegionFile::FreeSectorMap mSectorFree;
};

# `RegionFile::FreeSectorMap`

typedef std::map<int,bool> RegionFile::FreeSectorMap;

# `RedstoneTorchCapacitor::State`

struct RedstoneTorchCapacitor::State
{
  bool mOn;
  bool mHalfFrame;
  bool mChanged;
};

# `RailMovement`

struct RailMovement
{
  __int8 gap0[1];
};

# `RakNet::RakPeer`

struct __cppobj __attribute__((aligned(8))) RakNet::RakPeer : RakNet::RakPeerInterface, RakNet::RNS2EventHandler
{
  volatile bool endThreads;
  volatile bool isMainLoopThreadActive;
  bool occasionalPing;
  unsigned int maximumNumberOfPeers;
  unsigned int maximumIncomingConnections;
  RakNet::BitStream offlinePingResponse;
  char incomingPassword[256];
  unsigned __int8 incomingPasswordLength;
  RakNet::RakPeer::RemoteSystemStruct *remoteSystemList;
  RakNet::RakPeer::RemoteSystemStruct **activeSystemList;
  unsigned int activeSystemListSize;
  RakNet::RemoteSystemIndex **remoteSystemLookup;
  DataStructures::MemoryPool<RakNet::RemoteSystemIndex> remoteSystemIndexPool;
  RakNet::SimpleMutex rakPeerMutexes[2];
  bool updateCycleIsRunning;
  unsigned int bytesSentPerSecond;
  unsigned int bytesReceivedPerSecond;
  unsigned int validationInteger;
  RakNet::SimpleMutex incomingQueueMutex;
  RakNet::SimpleMutex banListMutex;
  DataStructures::List<RakNet::RakPeer::BanStruct *> banList;
  DataStructures::List<RakNet::PluginInterface2 *> pluginListTS;
  DataStructures::List<RakNet::PluginInterface2 *> pluginListNTS;
  DataStructures::Queue<RakNet::RakPeer::RequestedConnectionStruct *> requestedConnectionQueue;
  RakNet::SimpleMutex requestedConnectionQueueMutex;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::RakPeer::BufferedCommandStruct> bufferedCommands;
  DataStructures::Queue<RakNet::RNS2RecvStruct *> bufferedPacketsFreePool;
  RakNet::SimpleMutex bufferedPacketsFreePoolMutex;
  DataStructures::Queue<RakNet::RNS2RecvStruct *> bufferedPacketsQueue;
  RakNet::SimpleMutex bufferedPacketsQueueMutex;
  DataStructures::ThreadsafeAllocatingQueue<RakNet::RakPeer::SocketQueryOutput> socketQueryOutput;
  RakNet::SimpleMutex securityExceptionMutex;
  int defaultMTUSize;
  bool trackFrequencyTable;
  DataStructures::List<RakNet::RakNetSocket2 *> socketList;
  RakNet::BitStream *replyFromTargetBS;
  RakNet::SystemAddress replyFromTargetPlayer;
  bool replyFromTargetBroadcast;
  RakNet::TimeMS defaultTimeoutTime;
  RakNet::RakNetGUID myGuid;
  unsigned int maxOutgoingBPS;
  bool allowConnectionResponseIPMigration;
  RakNet::SystemAddress firstExternalID;
  int splitMessageProgressInterval;
  RakNet::TimeMS unreliableTimeout;
  bool (*incomingDatagramEventHandler)(RakNet::RNS2RecvStruct *);
  DataStructures::List<RakNet::RakString> securityExceptionList;
  RakNet::SystemAddress ipList[21];
  RakNet::NetworkAdapter adapterList[11];
  bool allowInternalRouting;
  void (*userUpdateThreadPtr)(RakNet::RakPeerInterface *, void *);
  void *userUpdateThreadData;
  RakNet::SignaledEvent quitAndDataEvents;
  bool limitConnectionFrequencyFromTheSameIP;
  RakNet::SimpleMutex packetAllocationPoolMutex;
  DataStructures::MemoryPool<RakNet::Packet> packetAllocationPool;
  RakNet::SimpleMutex packetReturnMutex;
  DataStructures::Queue<RakNet::Packet *> packetReturnQueue;
  RakNet::SimpleMutex sendReceiptSerialMutex;
  uint32_t sendReceiptSerial;
};

# `RakNet::RNS2EventHandler`

struct RakNet::RNS2EventHandler
{
  int (**_vptr$RNS2EventHandler)(void);
};

# `RakNet::RakPeer::RemoteSystemStruct`

struct RakNet::RakPeer::RemoteSystemStruct
{
  bool isActive;
  RakNet::SystemAddress systemAddress;
  RakNet::SystemAddress myExternalSystemAddress;
  RakNet::SystemAddress theirInternalSystemAddress[20];
  RakNet::ReliabilityLayer reliabilityLayer;
  bool weInitiatedTheConnection;
  RakNet::RakPeer::PingAndClockDifferential pingAndClockDifferential[5];
  RakNet::Time pingAndClockDifferentialWriteIndex;
  unsigned __int16 lowestPing;
  RakNet::Time nextPingTime;
  RakNet::Time lastReliableSend;
  RakNet::Time connectionTime;
  RakNet::RakNetGUID guid;
  int MTUSize;
  RakNet::RakNetSocket2 *rakNetSocket;
  RakNet::SystemIndex remoteSystemIndex;
  RakNet::RakPeer::RemoteSystemStruct::ConnectMode connectMode;
};

# `RakNet::ReliabilityLayer`

struct RakNet::ReliabilityLayer
{
  DataStructures::Queue<RakNet::InternalPacket *> outputQueue;
  int splitMessageProgressInterval;
  CCTimeType unreliableTimeout;
  DataStructures::Queue<RakNet::ReliabilityLayer::DatagramHistoryNode> datagramHistory;
  DataStructures::MemoryPool<RakNet::ReliabilityLayer::MessageNumberNode> datagramHistoryMessagePool;
  DataStructures::List<RakNet::ReliabilityLayer::UnreliableWithAckReceiptNode> unreliableWithAckReceiptHistory;
  DatagramSequenceNumberType datagramHistoryPopCount;
  DataStructures::MemoryPool<RakNet::InternalPacket> internalPacketPool;
  RakNet::InternalPacket *resendBuffer[512];
  RakNet::InternalPacket *resendLinkedListHead;
  RakNet::InternalPacket *unreliableLinkedListHead;
  RakNet::TimeMS timeLastDatagramArrived;
  DataStructures::Heap<unsigned long,RakNet::InternalPacket *,false> outgoingPacketBuffer;
  RakNet::reliabilityHeapWeightType outgoingPacketBufferNextWeights[4];
  DataStructures::OrderedList<unsigned short,RakNet::SplitPacketChannel *,&RakNet::SplitPacketChannelComp> splitPacketChannelList;
  RakNet::MessageNumberType sendReliableMessageNumberIndex;
  RakNet::MessageNumberType internalOrderIndex;
  bool deadConnection;
  bool cheater;
  RakNet::SplitPacketIdType splitPacketId;
  RakNet::TimeMS timeoutTime;
  RakNet::RakNetStatistics statistics;
  RakNet::OrderingIndexType orderedWriteIndex[32];
  RakNet::OrderingIndexType sequencedWriteIndex[32];
  RakNet::OrderingIndexType orderedReadIndex[32];
  RakNet::OrderingIndexType highestSequencedReadIndex[32];
  DataStructures::Heap<unsigned long,RakNet::InternalPacket *,false> orderingHeaps[32];
  RakNet::OrderingIndexType heapIndexOffsets[32];
  DataStructures::Queue<bool> hasReceivedPacketQueue;
  DatagramSequenceNumberType receivedPacketsBaseIndex;
  bool resetReceivedPackets;
  CCTimeType lastUpdateTime;
  CCTimeType timeBetweenPackets;
  CCTimeType nextSendTime;
  CCTimeType ackPingSum;
  unsigned __int8 ackPingIndex;
  RakNet::RemoteSystemTimeType remoteSystemTime;
  CCTimeType nextAllowedThroughputSample;
  bool bandwidthExceededStatistic;
  __int64 throughputCapCountdown;
  unsigned int receivePacketCount;
  CCTimeType elapsedTimeSinceLastUpdate;
  CCTimeType nextAckTimeToSend;
  RakNet::CCRakNetSlidingWindow congestionManager;
  uint32_t unacknowledgedBytes;
  DataStructures::List<RakNet::InternalPacket *> packetsToSendThisUpdate;
  DataStructures::List<bool> packetsToDeallocThisUpdate;
  DataStructures::List<unsigned int> packetsToSendThisUpdateDatagramBoundaries;
  DataStructures::List<bool> datagramsToSendThisUpdateIsPair;
  DataStructures::List<unsigned int> datagramSizesInBytes;
  RakNet::BitSize_t datagramSizeSoFar;
  RakNet::BitSize_t allDatagramSizesSoFar;
  double totalUserDataBytesAcked;
  CCTimeType timeOfLastContinualSend;
  CCTimeType timeToNextUnreliableCull;
  DataStructures::RangeList<RakNet::uint24_t> incomingAcks;
  int countdownToNextPacketPair;
  DataStructures::RangeList<RakNet::uint24_t> acknowlegements;
  DataStructures::RangeList<RakNet::uint24_t> NAKs;
  bool remoteSystemNeedsBAndAS;
  DataStructures::MemoryPool<RakNet::InternalPacketRefCountedData> refCountedDataPool;
  RakNet::BPSTracker bpsMetrics[7];
  CCTimeType lastBpsClear;
};

# `RakNet::InternalPacketRefCountedData`

struct __attribute__((aligned(8))) RakNet::InternalPacketRefCountedData
{
  unsigned __int8 *sharedDataBlock;
  unsigned int refCount;
};

# `RakNet::ReliabilityLayer::UnreliableWithAckReceiptNode`

struct RakNet::ReliabilityLayer::UnreliableWithAckReceiptNode
{
  DatagramSequenceNumberType datagramNumber;
  uint32_t sendReceiptSerial;
  RakNet::TimeUS nextActionTime;
};

# `RakNet::SplitPacketChannel`

struct RakNet::SplitPacketChannel
{
  CCTimeType lastUpdateTime;
  RakNet::SortedSplittedPackets splitPacketList;
  RakNet::InternalPacket *firstPacket;
};

# `RakNet::BPSTracker`

struct RakNet::BPSTracker
{
  uint64_t total1;
  uint64_t lastSec1;
  DataStructures::Queue<RakNet::BPSTracker::TimeAndValue2> dataQueue;
};

# `RakNet::RakPeer::PingAndClockDifferential`

struct RakNet::RakPeer::PingAndClockDifferential
{
  unsigned __int16 pingTime;
  RakNet::Time clockDifferential;
};

# `RakNet::RakNetSocket2`

struct __attribute__((aligned(8))) RakNet::RakNetSocket2
{
  int (**_vptr$RakNetSocket2)(void);
  RakNet::RNS2EventHandler *eventHandler;
  RakNet::RNS2Type socketType;
  RakNet::SystemAddress boundAddress;
  unsigned int userConnectionSocketIndex;
};

# `RakNet::RemoteSystemIndex`

struct RakNet::RemoteSystemIndex
{
  unsigned int index;
  RakNet::RemoteSystemIndex *next;
};

# `RakNet::RakPeer::BanStruct`

struct __attribute__((aligned(8))) RakNet::RakPeer::BanStruct
{
  char *IP;
  RakNet::TimeMS timeout;
};

# `RakNet::PluginInterface2`

struct RakNet::PluginInterface2
{
  int (**_vptr$PluginInterface2)(void);
  RakNet::RakPeerInterface *rakPeerInterface;
  RakNet::TCPInterface *tcpInterface;
};

# `RakNet::RakPeer::RequestedConnectionStruct`

struct __attribute__((aligned(8))) RakNet::RakPeer::RequestedConnectionStruct
{
  RakNet::SystemAddress systemAddress;
  RakNet::Time nextRequestTime;
  unsigned __int8 requestsMade;
  char *data;
  unsigned __int16 dataLength;
  char outgoingPassword[256];
  unsigned __int8 outgoingPasswordLength;
  unsigned int socketIndex;
  unsigned int extraData;
  unsigned int sendConnectionAttemptCount;
  unsigned int timeBetweenSendConnectionAttemptsMS;
  RakNet::TimeMS timeoutTime;
  RakNet::PublicKeyMode publicKeyMode;
  RakNet::RakNetSocket2 *socket;
  RakNet::RakPeer::RequestedConnectionStruct::$FD3B22BB7AF8A0ABB9D04D1A9E595697 actionToTake;
};

# `RakNet::RakPeer::BufferedCommandStruct`

struct __attribute__((aligned(8))) RakNet::RakPeer::BufferedCommandStruct
{
  RakNet::BitSize_t numberOfBitsToSend;
  PacketPriority priority;
  PacketReliability reliability;
  char orderingChannel;
  RakNet::AddressOrGUID systemIdentifier;
  bool broadcast;
  RakNet::RakPeer::RemoteSystemStruct::ConnectMode connectionMode;
  RakNet::NetworkID networkID;
  bool blockingCommand;
  char *data;
  bool haveRakNetCloseSocket;
  unsigned int connectionSocketIndex;
  unsigned __int16 remotePortRakNetWasStartedOn_PS3;
  unsigned int extraSocketOptions;
  RakNet::RakNetSocket2 *socket;
  unsigned __int16 port;
  uint32_t receipt;
  RakNet::RakPeer::BufferedCommandStruct::$D8D77DCE4D37D1D6016B84EB664ECA65 command;
};

# `RakNet::RNS2RecvStruct`

struct RakNet::RNS2RecvStruct
{
  char data[1400];
  int bytesRead;
  RakNet::SystemAddress systemAddress;
  RakNet::TimeUS timeRead;
  RakNet::RakNetSocket2 *socket;
};

# `RakNet::RakPeer::SocketQueryOutput`

struct RakNet::RakPeer::SocketQueryOutput
{
  DataStructures::List<RakNet::RakNetSocket2 *> sockets;
};

# `RakNet::SignaledEvent`

struct __attribute__((aligned(8))) RakNet::SignaledEvent
{
  RakNet::SimpleMutex isSignaledMutex;
  bool isSignaled;
  pthread_condattr_t condAttr;
  pthread_cond_t eventList;
  pthread_mutex_t hMutex;
  pthread_mutexattr_t mutexAttr;
};

# `RakNet::ReliabilityLayer::MessageNumberNode`

struct RakNet::ReliabilityLayer::MessageNumberNode
{
  DatagramSequenceNumberType messageNumber;
  RakNet::ReliabilityLayer::MessageNumberNode *next;
};

# `RakNet::RNS2_Berkley`

struct __cppobj __attribute__((aligned(4))) RakNet::RNS2_Berkley : RakNet::IRNS2_Berkley:1312
{
  RakNet::RNS2Socket rns2Socket;
  RakNet::RNS2_BerkleyBindParameters binding;
  RakNet::LocklessUint32_t isRecvFromLoopThreadActive;
  volatile bool endThreads;
};

# `RakNet::RakThread`

struct RakNet::RakThread
{
  __int8 gap0[1];
};

# `RakNet::SortedSplittedPackets`

struct __attribute__((aligned(8))) RakNet::SortedSplittedPackets
{
  RakNet::InternalPacket **data;
  unsigned int allocation_size;
  unsigned int addedPacketsCount;
  RakNet::SplitPacketIdType packetId;
};

# `RakNet::SocketLayer`

struct RakNet::SocketLayer
{
  __int8 gap0[1];
};

# `RakNet::StringCompressor`

struct RakNet::StringCompressor
{
  DataStructures::Map<int,RakNet::HuffmanEncodingTree *,&DataStructures::defaultMapKeyComparison> huffmanEncodingTrees;
};

# `RakNet::HuffmanEncodingTree`

struct RakNet::HuffmanEncodingTree
{
  HuffmanEncodingTreeNode *root;
  RakNet::HuffmanEncodingTree::CharacterEncoding encodingTable[256];
};

# `RakNet::HuffmanEncodingTree::CharacterEncoding`

struct __attribute__((aligned(8))) RakNet::HuffmanEncodingTree::CharacterEncoding
{
  unsigned __int8 *encoding;
  unsigned __int16 bitLength;
};

# `RakNet::StringTable`

struct RakNet::StringTable
{
  DataStructures::OrderedList<char *,StrAndBool,&RakNet::StrAndBoolComp> orderedStringList;
};

# `RakNet::LocklessUint32_t`

struct RakNet::LocklessUint32_t
{
  volatile uint32_t value;
};

# `RakNet::RemoteClient`

struct RakNet::RemoteClient
{
  __TCPSOCKET__ socket;
  RakNet::SystemAddress systemAddress;
  DataStructures::ByteQueue outgoingData;
  bool isActive;
  RakNet::SimpleMutex outgoingDataMutex;
  RakNet::SimpleMutex isActiveMutex;
};

# `RakNet::TCPInterface::ThisPtrPlusSysAddr`

struct __attribute__((aligned(8))) RakNet::TCPInterface::ThisPtrPlusSysAddr
{
  RakNet::TCPInterface *tcpInterface;
  RakNet::SystemAddress systemAddress;
  bool useSSL;
  char bindAddress[64];
  unsigned __int16 socketFamily;
};

# `RakNet::IRNS2_Berkley`

struct __cppobj RakNet::IRNS2_Berkley : RakNet::RakNetSocket2
{
};

# `RakNet::RakNetSocket2:1312`

struct __attribute__((packed)) __attribute__((aligned(4))) RakNet::RakNetSocket2:1312
{
  int (**_vptr$RakNetSocket2)(void);
  RakNet::RNS2EventHandler *eventHandler;
  RakNet::RNS2Type socketType;
  _BYTE gap14[4];
  RakNet::SystemAddress boundAddress;
  unsigned int userConnectionSocketIndex;
};

# `RakNet::IRNS2_Berkley:1312`

struct __cppobj RakNet::IRNS2_Berkley:1312 : RakNet::RakNetSocket2:1312
{
};

# `RakNet::RNS2_Windows_Linux_360`

struct RakNet::RNS2_Windows_Linux_360
{
  __int8 gap0[1];
};

# `RakNet::RakNetSocket2Allocator`

struct RakNet::RakNetSocket2Allocator
{
  __int8 gap0[1];
};

# `RakNet::RNS2_Linux`

struct __cppobj __attribute__((aligned(4))) RakNet::RNS2_Linux : RakNet::RNS2_Berkley
{
};

# `ResourceUtil`

struct ResourceUtil
{
  __int8 gap0[1];
};

# `RateLimiter`

struct RateLimiter
{
  const size_t mLimit;
  const std::chrono::seconds mTimeIntervalSeconds;
  std::vector<std::chrono::time_point<std::chrono::_V2::steady_clock,std::chrono::duration<long,std::ratio<1,1000000000> > >> mInstances;
};

← Q S →

# R

# ResourcePackRepository

# ResourcePackRepository::KnownPackContainer

# ResourceLocation

# ResourceMetadata

# ResourcePackStack

# ResourcePackStack::PackInstanceStack

# Random

# Range<int,-1>::iterator

# Range<int,1>::iterator

# Range<unsigned int,1>::iterator

# RootLayer<LayerValues::Terrain>::LayerData

# RootLayer<BiomeTemperatureCategory>::LayerData

# Realms::RealmId

# RaidBossComponent

# RailActivatorComponent

# RakNet::RakNetGUID

# ReadOnlyBinaryStream

# Range<unsigned long,1>::iterator

# RakNet::RakNetStatistics

# RakNet::SystemAddress

# RakNet::SystemAddress::$17DEBC484162A322D6AFC648B0CB992A

# RakNetInstance::_storeLocalIP::$7EF7C94BEAB75C6CEF4ADFB99B570420

# RakNetInstance::NatConnectionInfo

# RakNet::BitStream

# RakNet::RakString

# RakNetServerLocator::ScopeLock

# RakNet::SocketDescriptor

# ResourcePackStackPacket

# Recipes::FurnaceRecipeKey

# ResourcePacksInfoPacket

# ResourcePacksInfoData

# Recipe::ResultList

# ResourceInformation

# ResourceTaskCallback

# ResourceMainThreadCallback

# ResourcePack::Callback

# ResourcePackContents

# ResourcePackRepository::KnownPackInfo

# RemoveActorPacket

# RotationDescription

# Range<unsigned short,1>::iterator

# ResourcePackDataInfoPacket

# ResourcePackChunkDataPacket

# Range<short,1>::iterator

# RopeParams

# RideableComponent

# RaidTriggerComponent

# RuntimeIdentifierDescription

# Raid::ActorIDCollection

# ReverseableIterator::Iterator

# ResourcePackMergeStrategy

# RecipeIngredient

# RecipeMap

# Range<unsigned char,'_x01'>::iterator

# Recipes::addShapedRecipe::Map

# Recipes::addShapedRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420

# Recipe::Ingredients

# Recipes::TypeList

# RowList

# Recipes::addShapelessRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420

# RakDataInput

# RenderParams

# RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8

# RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8::$7CDB70B13784CF5DCA20C1417F11D194

# RoomDefinition

# RakDataOutput

# RandomValueBounds

# RequeueAreaFunc

# RopeWave

# RailMovementComponent

# ResourceSignature

# ResourcePackChunkRequestPacket

# RegisteredTagFilter

# RuntimeLightingManager::RelightingChunkElement

# RoleChecker::OnRoleAcquired

# RakNet::RNS2_SendParameters

# RakNet::RNS2_BerkleyBindParameters

# RakNet::AddressOrGUID

# RakNet::SimpleMutex

# `ResourcePackRepository`

# `ResourcePackRepository::KnownPackContainer`

# `ResourceLocation`

# `ResourceMetadata`

# `ResourcePackStack`

# `ResourcePackStack::PackInstanceStack`

# `Random`

# `Range<int,-1>::iterator`

# `Range<int,1>::iterator`

# `Range<unsigned int,1>::iterator`

# `RootLayer<LayerValues::Terrain>::LayerData`

# `RootLayer<BiomeTemperatureCategory>::LayerData`

# `Realms::RealmId`

# `RaidBossComponent`

# `RailActivatorComponent`

# `RakNet::RakNetGUID`

# `ReadOnlyBinaryStream`

# `Range<unsigned long,1>::iterator`

# `RakNet::RakNetStatistics`

# `RakNet::SystemAddress`

# `RakNet::SystemAddress::$17DEBC484162A322D6AFC648B0CB992A`

# `RakNetInstance::_storeLocalIP::$7EF7C94BEAB75C6CEF4ADFB99B570420`

# `RakNetInstance::NatConnectionInfo`

# `RakNet::BitStream`

# `RakNet::RakString`

# `RakNetServerLocator::ScopeLock`

# `RakNet::SocketDescriptor`

# `ResourcePackStackPacket`

# `Recipes::FurnaceRecipeKey`

# `ResourcePacksInfoPacket`

# `ResourcePacksInfoData`

# `Recipe::ResultList`

# `ResourceInformation`

# `ResourceTaskCallback`

# `ResourceMainThreadCallback`

# `ResourcePack::Callback`

# `ResourcePackContents`

# `ResourcePackRepository::KnownPackInfo`

# `RemoveActorPacket`

# `RotationDescription`

# `Range<unsigned short,1>::iterator`

# `ResourcePackDataInfoPacket`

# `ResourcePackChunkDataPacket`

# `Range<short,1>::iterator`

# `RopeParams`

# `RideableComponent`

# `RaidTriggerComponent`

# `RuntimeIdentifierDescription`

# `Raid::ActorIDCollection`

# `ReverseableIterator::Iterator`

# `ResourcePackMergeStrategy`

# `RecipeIngredient`

# `RecipeMap`

# `Range<unsigned char,'_x01'>::iterator`

# `Recipes::addShapedRecipe::Map`

# `Recipes::addShapedRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420`

# `Recipe::Ingredients`

# `Recipes::TypeList`

# `RowList`

# `Recipes::addShapelessRecipe::$7EF7C94BEAB75C6CEF4ADFB99B570420`

# `RakDataInput`

# `RenderParams`

# `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8`

# `RenderParams::$3D9EB0E7A2790D70080124A37CC6ABC8::$7CDB70B13784CF5DCA20C1417F11D194`

# `RoomDefinition`

# `RakDataOutput`

# `RandomValueBounds`

# `RequeueAreaFunc`

# `RopeWave`

# `RailMovementComponent`

# `ResourceSignature`

# `ResourcePackChunkRequestPacket`

# `RegisteredTagFilter`

# `RuntimeLightingManager::RelightingChunkElement`

# `RoleChecker::OnRoleAcquired`

# `RakNet::RNS2_SendParameters`

# `RakNet::RNS2_BerkleyBindParameters`

# `RakNet::AddressOrGUID`

# `RakNet::SimpleMutex`

# `RakNet::uint24_t`