Unreal Engine FName&GObjects

__int64 __fastcall FName::GetPlainNameString(_DWORD *a1, __int64 a2)
{
  __int64 v3; // rbx
  RTL_SRWLOCK *v4; // r8
  int v6; // [rsp+34h] [rbp+Ch]

  v3 = HIWORD(*a1);
  v6 = (unsigned __int16)*a1;
  if ( byte_143E54CA8 )
  {
    v4 = &stru_143E54CC0;
  }
  else
  {
    v4 = (RTL_SRWLOCK *)FNamePool::FNamePool((FNamePool *)&stru_143E54CC0); // NamePoolData
    byte_143E54CA8 = 1;
  }
  FNameEntry::GetPlainNameString((char *)v4[v3 + 2].Ptr + (unsigned int)(2 * v6), a2);
  return a2;
}

void UObjectBaseInit(void)
{
  // [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]

  FCompressedChunk::FCompressedChunk((FCompressedChunk *)v2);
  v6 = 0x200000;
  v5 = 0;
  v4 = 0;
  v3 = 0;
  v1[0] = 0i64;
  v1[1] = 0i64;
  v0 = FCommandLine::Get();
  if ( FParse::Value(v0, L"-filehostip=", (struct FString *)v1, 1) )
  {
    GCreateGCClusters = 0;
  }
  else
  {
...
...
  if ( v1[0] )
    FMemory::Free(v1[0]);
  GUObjectAllocator = v4;
  qword_143E6D1A0 = (__int64)FMemory::MallocPersistentAuxiliary(v4, 0);
  qword_143E6D1A8 = qword_143E6D1A0;
  qword_143E6D1B0 = qword_143E6D1A0;
  FUObjectArray::AllocateObjectPool((FUObjectArray *)&GUObjectArray, v6, v5, v3);
  InitAsyncThread();
  byte_143E6D374 = 1;
  sub_140D78570();
  TArray<float,TSizedDefaultAllocator<32>>::~TArray<float,TSizedDefaultAllocator<32>>(v2);
}

class FUObjectArray
....
private:

	//typedef TStaticIndirectArrayThreadSafeRead<UObjectBase, 8 * 1024 * 1024 /* Max 8M UObjects */, 16384 /* allocated in 64K/128K chunks */ > TUObjectArray;
	typedef FChunkedFixedUObjectArray TUObjectArray;

	// note these variables are left with the Obj prefix so they can be related to the historical GObj versions

	/** First index into objects array taken into account for GC.							*/
	int32 ObjFirstGCIndex;
	/** Index pointing to last object created in range disregarded for GC.					*/
	int32 ObjLastNonGCIndex;
	/** Maximum number of objects in the disregard for GC Pool */
	int32 MaxObjectsNotConsideredByGC;

	/** If true this is the intial load and we should load objects int the disregarded for GC range.	*/
	bool OpenForDisregardForGC;
	/** Array of all live objects.											*/
	TUObjectArray ObjObjects;
	/** Synchronization object for all live objects.											*/
	FCriticalSection ObjObjectsCritical;
	/** Available object indices.											*/
	TLockFreePointerListUnordered<int32, PLATFORM_CACHE_LINE_SIZE> ObjAvailableList;
#if UE_GC_TRACK_OBJ_AVAILABLE
	/** Available object index count.										*/
	FThreadSafeCounter ObjAvailableCount;
#endif

class FChunkedFixedUObjectArray
{
	enum
	{
		NumElementsPerChunk = 64 * 1024,
	};

	/** Master table to chunks of pointers **/
	FUObjectItem** Objects;
	/** If requested, a contiguous memory where all objects are allocated **/
	FUObjectItem* PreAllocatedObjects;
	/** Maximum number of elements **/
	int32 MaxElements;
	/** Number of elements we currently have **/
	int32 NumElements;
	/** Maximum number of chunks **/
	int32 MaxChunks;
	/** Number of chunks we currently have **/
	int32 NumChunks;
....

struct FUObjectItem
{
	// Pointer to the allocated object
	class UObjectBase* Object;
	// Internal flags
	int32 Flags;
	// UObject Owner Cluster Index
	int32 ClusterRootIndex;	
	// Weak Object Pointer Serial number associated with the object
	int32 SerialNumber;
...