MiConfigureMemoryInsertion

NTSTATUS __stdcall MiConfigureMemoryInsertion(
        PHYSICAL_MEMORY_DESCRIPTOR **OutputNewPhysicalMemoryBlock,
        PHYSICAL_MEMORY_DESCRIPTOR *PhysicalMemoryBlock,
        _MI_MEMORY_NODE *MemoryNode){
  unsigned __int64 v3; 
  unsigned __int64 v5; 
  unsigned __int64 v7; 
  __int64 NumberOfRuns; 
  _PHYSICAL_MEMORY_RUN *v9; 
  unsigned __int64 v10; 
  __int64 v11; 
  __int64 v12; 
  unsigned __int64 v13; 
  unsigned __int64 v14; 
  unsigned __int64 *p_PageCount; 
  __int64 v16; 
  unsigned __int64 v17; 
  unsigned __int64 v18; 
  UINT64 v20; 
  char *Pool; 
  _PHYSICAL_MEMORY_RUN *Run; 
  PHYSICAL_MEMORY_DESCRIPTOR *v23; 
  unsigned int *v24; 
  _PHYSICAL_MEMORY_RUN *v25; 
  unsigned __int64 v26; 
  int v27; 
  unsigned __int64 v28; 
  unsigned __int64 BasePage; 
  unsigned __int64 PageCount; 
  __int64 v31; 
  int v32; 
  __int64 v34; 
  unsigned __int64 v35; 

  v3 = *(_QWORD *)&MemoryNode[1].List[4];
  v5 = *(_QWORD *)&MemoryNode->NodeNumber;
  *OutputNewPhysicalMemoryBlock = 0i64;
  v35 = v3;
  v7 = v3 + v5;
  NumberOfRuns = PhysicalMemoryBlock->NumberOfRuns;
  if( *(_QWORD *)MemoryNode->List )
    v9 = &PhysicalMemoryBlock->Run[NumberOfRuns];
  else
    v9 = 0i64;
  if( (int)NumberOfRuns + 1 < (unsigned int)NumberOfRuns )
    return -1073741670;
  v10 = PhysicalMemoryBlock->NumberOfRuns;
  v11 = 16i64 * (unsigned int)(NumberOfRuns - 1);
  v12 = v11 + 48;
  if( v9 )
    v12 = v11 + 8 * ((unsigned int)(NumberOfRuns + 1) + 6i64);
  v13 = 0i64;
  v34 = 1i64;
  v14 = 0i64;
  p_PageCount = &PhysicalMemoryBlock->Run[0].PageCount;
  v16 = 1i64;
  while( 1 )
  {
    v17 = *(p_PageCount - 1);
    if( *p_PageCount )
    {
      v18 = v17 + *p_PageCount;
      if( v5 >= v17 )
      {
        if( v5 < v18 )
          return -1073741800;
      }
      else if( v7 > v17 )
      {
        return -1073741800;
      }
      if( (v5 == v18 || v7 == v17)
        && (!v9
         || *((_DWORD *)&v9->BasePage + 2 * v13) == MemoryNode[1].PageCount
         && *((_DWORD *)&v9->BasePage + 2 * v13 + 1) == *(_DWORD *)&MemoryNode[1].NodeNumber) )
      {
        if( v16 == 1 )
        {
          v14 = v13;
          v16 = 0i64;
        }
        else
        {
          v16 = -1i64;
        }
        v34 = v16;
      }
    }
    if( ++v13 >= v10 )
      break;
    p_PageCount += 2;
  }
  v20 = 16 * v16 + v12;
  if( v9 )
    v20 += 8 * (v10 + v16);
  Pool = (char *)MiAllocatePool(64i64, v20, 0x20206D4Dui64);
  if( !Pool )
    return -1073741670;
  *(_QWORD *)Pool = &Irp;
  Run = PhysicalMemoryBlock->Run;
  *((_QWORD *)Pool + 1) = 1i64;
  v23 = (PHYSICAL_MEMORY_DESCRIPTOR *)(Pool + 16);
  *((_DWORD *)Pool + 4) = v16 + v10;
  v24 = (unsigned int *)&Pool[16 * (unsigned int)(v16 + v10) + 32];
  *((_QWORD *)Pool + 3) = v35 + PhysicalMemoryBlock->NumberOfPages;
  v25 = (_PHYSICAL_MEMORY_RUN *)(Pool + 32);
  if( v34 == -1 )
  {
    v26 = v14;
    memmove(v25, Run, 16 * v14 + 16);
    if( v9 )
      memmove(v24, v9, 8 * v14 + 8);
    v23->Run[v26].PageCount += v35 + *(unsigned __int64 *)((char *)&PhysicalMemoryBlock[1].NumberOfPages + v26 * 16);
    if( v14 + 2 != v10 )
    {
      v27 = v10 - v14;
      memmove((char *)&v23[1] + v26 * 16, &PhysicalMemoryBlock[1].Run[v26], 16 * v27 - 32);
      if( v9 )
        memmove(&v24[2 * v14 + 2], &v9[1].BasePage + v14, 8 * v27 - 16);
    }
  }
  else if( v34 )
  {
    v31 = 0i64;
    v32 = 0;
    do
    {
      if( !v32 && v35 + v5 <= Run->BasePage )
      {
        v25->BasePage = v5;
        v25->PageCount = v35;
        ++v25;
        if( v9 )
        {
          v24[1] = *(_DWORD *)&MemoryNode[1].NodeNumber;
          *v24 = MemoryNode[1].PageCount;
          v24 += 2;
        }
        v32 = 1;
      }
      *v25++ = *Run;
      if( v9 )
      {
        *(_QWORD *)v24 = *(&v9->BasePage + v31);
        v24 += 2;
      }
      ++v31;
      ++Run;
    }
    while( v31 != PhysicalMemoryBlock->NumberOfRuns );
    if( !v32 )
    {
      v25->BasePage = v5;
      v25->PageCount = v35;
      if( v9 )
      {
        v24[1] = *(_DWORD *)&MemoryNode[1].NodeNumber;
        *v24 = MemoryNode[1].PageCount;
      }
    }
  }
  else
  {
    memmove(v25, Run, 16 * v10);
    if( v9 )
      memmove(v24, v9, 8 * v10);
    v28 = v14;
    BasePage = PhysicalMemoryBlock->Run[v28].BasePage;
    PageCount = PhysicalMemoryBlock->Run[v28].PageCount;
    v23->Run[v28].PageCount += v35;
    if( v5 != BasePage + PageCount )
      v23->Run[v28].BasePage = v5;
  }
  *OutputNewPhysicalMemoryBlock = v23;
  return 0;
}

Referenced by: