# CVE-2026-61346 — dxgmms2.sys patch diff

`dxgmms2.sys` 10.0.26100.8875 -> 10.0.26100.9168 (ghidriff).

## `VidMmiAddTriageData`  (modified)

```diff
--- VidMmiAddTriageData
+++ VidMmiAddTriageData
@@ -1,107 +1,99 @@
 

 /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* void __cdecl VidMmiAddTriageData(struct _KBUGCHECK_TRIAGE_DUMP_DATA * __ptr64,struct

+   _KTRIAGE_DUMP_DATA_ARRAY * __ptr64) */

 

 void __cdecl

 VidMmiAddTriageData(_KBUGCHECK_TRIAGE_DUMP_DATA *param_1,_KTRIAGE_DUMP_DATA_ARRAY *param_2)

 

 {

   uint uVar1;

-  byte bVar2;

-  char cVar3;

-  uint in_EAX;

+  char cVar2;

+  int iVar3;

   int iVar4;

-  longlong *unaff_RBX;

-  longlong lVar5;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  byte unaff_R12B;

-  longlong unaff_R13;

-  int unaff_R15D;

+  _LIST_ENTRY *p_Var5;

+  longlong lVar6;

   

-  bVar2 = (byte)(in_EAX >> 8) & (byte)in_EAX;

-  while( true ) {

-    if ((((bVar2 == 0) && ((in_EAX & 0x10) == 0)) && ((in_EAX & 4) == 0)) && ((in_EAX & 0x20) == 0))

-    {

-      iVar4 = KeAddTriageDumpDataBlock();

-      if (iVar4 < 0) {

-        WdLogSingleEntry3(3,unaff_RSI,0xafc0,(longlong)iVar4);

+  iVar4 = 4;

+  cVar2 = MmIsAddressValid(&VIDMM_GLOBAL::_AdapterListHead);

+  p_Var5 = __AdapterListHead;

+  if (cVar2 != '\0') {

+    for (; p_Var5 != &VIDMM_GLOBAL::_AdapterListHead; p_Var5 = *(_LIST_ENTRY **)p_Var5) {

+      if (p_Var5 == (_LIST_ENTRY *)0x0) {

+        return;

+      }

+      cVar2 = MmIsAddressValid(p_Var5);

+      if (cVar2 == '\0') {

+        return;

+      }

+      lVar6 = *(longlong *)(p_Var5 + -0xaee0);

+      if (lVar6 == 0) {

+        return;

+      }

+      cVar2 = MmIsAddressValid(lVar6);

+      if (cVar2 == '\0') {

+        return;

+      }

+      uVar1 = *(uint *)(lVar6 + 0x1bc);

+      if (((((uVar1 & 8) == 0) && ((uVar1 & 0x10) == 0)) && ((uVar1 & 4) == 0)) &&

+         ((uVar1 & 0x20) == 0)) {

+        iVar3 = KeAddTriageDumpDataBlock(param_2,p_Var5 + -0xaef8,0xafc0);

+        if (iVar3 < 0) {

+          WdLogSingleEntry3(3,p_Var5 + -0xaef8,0xafc0,(longlong)iVar3);

+          _WdLogGlobalForLineNumber = 0xc68;

+        }

+        uVar1 = *(uint *)(p_Var5 + -0xea8);

+        if (((uVar1 < 0x10001) && (lVar6 = *(longlong *)(p_Var5 + -0xeb0), lVar6 != 0)) &&

+           (iVar3 = KeAddTriageDumpDataBlock(param_2,lVar6,uVar1), iVar3 < 0)) {

+          WdLogSingleEntry3(3,lVar6,uVar1,(longlong)iVar3);

+          _WdLogGlobalForLineNumber = 0xc68;

+        }

+        iVar4 = iVar4 + -1;

+        if (iVar4 == 0) {

+          return;

+        }

+      }

+    }

+    if ((*(int *)(param_1 + 0x10) == 0x10e) && (*(int *)g_DxgMmsBugcheckExportIndex_exref == 1)) {

+      if (*(longlong *)(param_1 + 0x18) == 0x17) {

+        lVar6 = *(longlong *)(param_1 + 0x28);

+        if (lVar6 == 0) {

+          return;

+        }

+        cVar2 = MmIsAddressValid(lVar6);

+        if (cVar2 == '\0') {

+          return;

+        }

+        lVar6 = *(longlong *)(lVar6 + 0x18);

+        if (lVar6 == 0) {

+          return;

+        }

+        cVar2 = MmIsAddressValid(lVar6);

+        if (cVar2 == '\0') {

+          return;

+        }

+        lVar6 = *(longlong *)(lVar6 + 600);

+      }

+      else {

+        if (*(longlong *)(param_1 + 0x18) != 0x2d) {

+          return;

+        }

+        lVar6 = *(longlong *)(param_1 + 0x30);

+        if (lVar6 == 0) {

+          return;

+        }

+        cVar2 = MmIsAddressValid(lVar6);

+        if (cVar2 == '\0') {

+          return;

+        }

+        lVar6 = *(longlong *)(lVar6 + 0x3c0);

+      }

+      if ((lVar6 != 0) && (iVar4 = KeAddTriageDumpDataBlock(param_2,lVar6,8), iVar4 < 0)) {

+        WdLogSingleEntry3(3,lVar6,8,(longlong)iVar4);

         _WdLogGlobalForLineNumber = 0xc68;

       }

-      uVar1 = *(uint *)(unaff_RSI + 0xa050);

-      if (((uVar1 < 0x10001) && (lVar5 = *(longlong *)(unaff_RSI + 0xa048), lVar5 != 0)) &&

-         (iVar4 = KeAddTriageDumpDataBlock(), iVar4 < 0)) {

-        WdLogSingleEntry3(3,lVar5,uVar1,(longlong)iVar4);

-        _WdLogGlobalForLineNumber = 0xc68;

-      }

-      unaff_R15D = unaff_R15D + -1;

-      if (unaff_R15D == 0) {

-        return;

-      }

     }

-    unaff_RBX = (longlong *)*unaff_RBX;

-    if (unaff_RBX == (longlong *)unaff_R13) {

-      if (*(int *)(unaff_RDI + 0x10) != 0x10e) {

-        return;

-      }

-      if (*(int *)g_DxgMmsBugcheckExportIndex_exref != 1) {

-        return;

-      }

-      if (*(longlong *)(unaff_RDI + 0x18) == 0x17) {

-        lVar5 = *(longlong *)(unaff_RDI + 0x28);

-        if (lVar5 == 0) {

-          return;

-        }

-        cVar3 = MmIsAddressValid(lVar5);

-        if (cVar3 == '\0') {

-          return;

-        }

-        lVar5 = *(longlong *)(lVar5 + 0x18);

-        if (lVar5 == 0) {

-          return;

-        }

-        cVar3 = MmIsAddressValid(lVar5);

-        if (cVar3 == '\0') {

-          return;

-        }

-        lVar5 = *(longlong *)(lVar5 + 600);

-      }

-      else {

-        if (*(longlong *)(unaff_RDI + 0x18) != 0x2d) {

-          return;

-        }

-        lVar5 = *(longlong *)(unaff_RDI + 0x30);

-        if (lVar5 == 0) {

-          return;

-        }

-        cVar3 = MmIsAddressValid(lVar5);

-        if (cVar3 == '\0') {

-          return;

-        }

-        lVar5 = *(longlong *)(lVar5 + 0x3c0);

-      }

-      if ((lVar5 != 0) && (iVar4 = KeAddTriageDumpDataBlock(), iVar4 < 0)) {

-        WdLogSingleEntry3(3,lVar5);

-        _WdLogGlobalForLineNumber = 0xc68;

-      }

-      return;

-    }

-    if (unaff_RBX == (longlong *)0x0) {

-      return;

-    }

-    cVar3 = MmIsAddressValid(unaff_RBX);

-    if (cVar3 == '\0') {

-      return;

-    }

-    unaff_RSI = (longlong)(unaff_RBX + -0x15df);

-    lVar5 = unaff_RBX[-0x15dc];

-    if (lVar5 == 0) {

-      return;

-    }

-    cVar3 = MmIsAddressValid(lVar5);

-    if (cVar3 == '\0') break;

-    in_EAX = *(uint *)(lVar5 + 0x1bc);

-    bVar2 = unaff_R12B & (byte)in_EAX;

   }

   return;

 }
```

## `VIDMM_GLOBAL::Lock1`  (modified)

```diff
--- VIDMM_GLOBAL::Lock1
+++ VIDMM_GLOBAL::Lock1
@@ -1,2 +1,106 @@
-Failed to decompile dxgmms2.sys - .ProgramDB VIDMM_GLOBAL::Lock1 : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* public: long __cdecl VIDMM_GLOBAL::Lock1(struct VIDMM_ALLOC * __ptr64,unsigned long,void *

+   __ptr64 * __ptr64) __ptr64 */

+

+long __thiscall

+VIDMM_GLOBAL::Lock1(VIDMM_GLOBAL *this,VIDMM_ALLOC *param_1,ulong param_2,void **param_3)

+

+{

+  ulonglong uVar1;

+  long lVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  VIDMM_GLOBAL *this_00;

+  undefined8 uVar5;

+  VIDMM_ALLOC *pVVar6;

+  undefined4 in_register_00000084;

+  ulonglong uVar7;

+  wchar_t *pwVar8;

+  ulonglong uVar9;

+  

+  uVar7 = CONCAT44(in_register_00000084,param_2);

+  uVar5 = 0;

+  uVar1 = **(ulonglong **)param_1;

+  if (*g_IsInternalReleaseOrDbg_exref != (code)0x0) {

+    lVar3 = WdLogNewEntry5_WdTrace();

+    *(VIDMM_ALLOC **)(lVar3 + 0x18) = param_1;

+    *(ulonglong *)(lVar3 + 0x20) = (ulonglong)param_2;

+    _WdLogGlobalForLineNumber = 0x55f7;

+  }

+  *param_3 = (void *)0x0;

+  this_00 = this;

+  uVar4 = ValidateCommonLockParameters((longlong)this,(longlong *)param_1,uVar7);

+  if ((int)uVar4 < 0) {

+    return (int)uVar4;

+  }

+  uVar9 = (ulonglong)(param_2 & 0xffffffa7);

+  if (((param_2 >> 10 & 1) == 0) &&

+     (this_00 = (VIDMM_GLOBAL *)(ulonglong)**(uint **)(uVar1 + 0x188),

+     (**(uint **)(uVar1 + 0x188) & 8) != 0)) {

+    uVar5 = 1;

+    WdLogSingleEntry1(1,uVar1);

+    pwVar8 = L"Trying to lock a protected allocation with a non-protected lock. Alloc=0x%p";

+    _WdLogGlobalForLineNumber = 0x560f;

+    uVar9 = uVar1;

+  }

+  else if ((param_2 & 0xfffff800) == 0) {

+    if ((param_2 & 0x82) == 0) {

+LAB_0:

+      if ((param_2 & 0x81) == 0) {

+        if ((param_2 & 2) == 0) {

+          return -0x3fe1fefe;

+        }

+      }

+      else {

+        if ((param_2 >> 8 & 1) != 0) {

+          WdLogSingleEntry2(4,param_1,0xffffffffc01e0104);

+          _WdLogGlobalForLineNumber = 0x565e;

+          return -0x3fe1fefc;

+        }

+        WaitOnAllocForceSync(this_00,param_1);

+      }

+      uVar4 = 0;

+      pVVar6 = param_1;

+      lVar2 = LockCommon(this,param_1,false,0,param_3);

+      if (lVar2 < 0) {

+        return lVar2;

+      }

+      if ((DAT_1 & 1) == 0) {

+        return lVar2;

+      }

+      lVar3 = *(longlong *)(param_1 + 8);

+      if (lVar3 != 0) {

+        uVar5 = *(undefined8 *)(lVar3 + 0x18);

+      }

+      McTemplateK0ppqq_EtwWriteTransfer(lVar3,pVVar6,uVar4,uVar5);

+      return lVar2;

+    }

+    if (((*(uint *)(uVar1 + 0x18) & 0x40) == 0) && ((*(uint *)(uVar1 + 0x1c) & 0x200000) == 0)) {

+      uVar5 = 1;

+      WdLogSingleEntry0();

+      pwVar8 = L"NoSync can only be specified on allocation supported in an aperture segment.";

+      _WdLogGlobalForLineNumber = 0x5630;

+      uVar9 = 0x5630;

+    }

+    else {

+      if ((this[0x1b69] != (VIDMM_GLOBAL)0x0) ||

+         (this_00 = (VIDMM_GLOBAL *)(ulonglong)**(uint **)(uVar1 + 0x188),

+         (**(uint **)(uVar1 + 0x188) & 4) == 0)) goto LAB_0;

+      uVar5 = 1;

+      WdLogSingleEntry0();

+      pwVar8 = L"NoSync can not be specified on allocations using software cache coherency";

+      _WdLogGlobalForLineNumber = 0x563a;

+      uVar9 = 0x563a;

+    }

+  }

+  else {

+    uVar5 = 1;

+    WdLogSingleEntry1(1,uVar9);

+    pwVar8 = L"BeginCPUAcess() invalid flags specified: 0x%08X";

+    _WdLogGlobalForLineNumber = 0x5619;

+  }

+  DxgkLogInternalTriageEvent(uVar5,0x40000,uVar7,pwVar8,uVar9,0,0,0);

+  return -0x3ffffff3;

+}

+
```

## `VIDMM_CPU_HOST_APERTURE::MapRange`  (modified)

```diff
--- VIDMM_CPU_HOST_APERTURE::MapRange
+++ VIDMM_CPU_HOST_APERTURE::MapRange
@@ -1,2 +1,182 @@
-Failed to decompile dxgmms2.sys - .ProgramDB VIDMM_CPU_HOST_APERTURE::MapRange : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* public: long __cdecl VIDMM_CPU_HOST_APERTURE::MapRange(struct VIDMM_CPU_HOST_APERTURE_RANGE *

+   __ptr64,struct VIDMM_PHYSICAL_ALLOC * __ptr64,unsigned __int64,unsigned __int64) __ptr64 */

+

+long __thiscall

+VIDMM_CPU_HOST_APERTURE::MapRange

+          (VIDMM_CPU_HOST_APERTURE *this,VIDMM_CPU_HOST_APERTURE_RANGE *param_1,

+          VIDMM_PHYSICAL_ALLOC *param_2,__uint64 param_3,__uint64 param_4)

+

+{

+  VIDMM_CPU_HOST_APERTURE_RANGE *pVVar1;

+  ulonglong uVar2;

+  uint uVar3;

+  uint uVar4;

+  uint uVar5;

+  uint uVar6;

+  undefined8 uVar7;

+  code *pcVar8;

+  undefined1 auVar9 [16];

+  int iVar10;

+  __uint64 _Var11;

+  __uint64 *p_Var12;

+  ulonglong uVar13;

+  DXGADAPTER *pDVar14;

+  VIDMM_CPU_HOST_APERTURE *pVVar15;

+  longlong lVar16;

+  VIDMM_GLOBAL *pVVar17;

+  VIDMM_CPU_HOST_APERTURE_RANGE *pVVar18;

+  __uint64 *p_Var19;

+  undefined1 *puVar20;

+  ulonglong uVar21;

+  undefined1 auStack_88 [8];

+  undefined1 auStack_80 [24];

+  VIDMM_CPU_HOST_APERTURE_RANGE *local_68;

+  undefined8 local_60;

+  undefined8 local_58;

+  short local_50;

+  undefined2 local_4e;

+  undefined4 local_4c;

+  ulonglong local_48;

+  VIDMM_CPU_HOST_APERTURE_RANGE *local_40;

+  __uint64 *local_38;

+  

+  puVar20 = auStack_88;

+  pVVar1 = param_1 + 0x20;

+  pVVar15 = this;

+  pVVar18 = param_1;

+  if (*(int *)(param_1 + 0x20) != -1) {

+    *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+    param_3 = 0;

+    local_60 = 0;

+    pVVar15 = (VIDMM_CPU_HOST_APERTURE *)0x0;

+    pVVar18 = (VIDMM_CPU_HOST_APERTURE_RANGE *)&DAT_0;

+    local_68 = param_1;

+    WdLogSingleEntry5(0,0x10e,0x2c,this);

+    _WdLogGlobalForLineNumber = 0xc3;

+  }

+  uVar3 = *(uint *)(*(longlong *)(pVVar15 + 0x30) + 0x1a0);

+  uVar4 = *(uint *)(*(longlong *)(this + 0x28) + (ulonglong)*(uint *)(pVVar18 + 0x1c) * 4);

+  uVar21 = CONCAT44(0,uVar4);

+  auVar9._8_8_ = 0;

+  auVar9._0_8_ = uVar21;

+  _Var11 = SUB168(ZEXT816(8) * auVar9,0);

+  if (SUB168(ZEXT816(8) * auVar9,8) != 0) {

+    _Var11 = 0xffffffffffffffff;

+  }

+  p_Var12 = operator_new__(_Var11,0x36346956,0x102);

+  if (p_Var12 == (__uint64 *)0x0) {

+    WdLogSingleEntry0(3);

+    _WdLogGlobalForLineNumber = 699;

+    return -0x3fffffe9;

+  }

+  uVar5 = *(uint *)(param_1 + 0x18);

+  uVar6 = *(uint *)(param_1 + 0x1c);

+  for (pVVar18 = pVVar1; pVVar18 != pVVar1 + uVar21 * 4; pVVar18 = pVVar18 + 4) {

+    *(uint *)pVVar18 = uVar5;

+    if (uVar5 == uVar6) goto LAB_1;

+    uVar5 = *(uint *)(*(longlong *)(this + 0x28) + (ulonglong)uVar5 * 4);

+  }

+  *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+  param_3 = 0;

+  local_60 = 0;

+  local_68 = param_1;

+  WdLogSingleEntry5(0,0x10e,0x2f,this);

+  _WdLogGlobalForLineNumber = 0xc3;

+LAB_1:

+  _Var11 = param_3 / uVar3;

+  uVar2 = uVar21 + _Var11;

+  if (_Var11 < uVar2) {

+    p_Var19 = p_Var12;

+    if (7 < uVar21) {

+      uVar13 = _Var11;

+      do {

+        *p_Var19 = uVar13;

+        p_Var19[1] = uVar13 + 1;

+        p_Var19[2] = uVar13 + 2;

+        p_Var19[3] = uVar13 + 3;

+        _Var11 = uVar13 + 8;

+        p_Var19[4] = uVar13 + 4;

+        p_Var19[5] = uVar13 + 5;

+        p_Var19[6] = uVar13 + 6;

+        p_Var19[7] = uVar13 + 7;

+        p_Var19 = p_Var19 + 8;

+        uVar13 = _Var11;

+      } while (_Var11 < uVar2 - (uVar4 & 7));

+      if (uVar2 <= _Var11) goto LAB_2;

+    }

+    do {

+      *p_Var19 = _Var11;

+      p_Var19 = p_Var19 + 1;

+      _Var11 = _Var11 + 1;

+    } while (_Var11 < uVar2);

+  }

+LAB_2:

+  local_58 = 0;

+  local_4c = 0;

+  if (*(longlong *)param_2 != 0) {

+    local_58 = *(undefined8 *)(*(longlong *)(*(longlong *)param_2 + 0x188) + 0x30);

+  }

+  lVar16 = *(longlong *)(this + 0x30);

+  if ((*(uint *)(lVar16 + 0x68) & 0x1000) == 0) {

+    local_50 = *(short *)(lVar16 + 0x28) + 1;

+  }

+  else {

+    local_50 = 0;

+  }

+  local_4e = *(undefined2 *)(lVar16 + 0x1a4);

+  local_48 = uVar21;

+  local_40 = pVVar1;

+  local_38 = p_Var12;

+  iVar10 = ADAPTER_RENDER::DdiMapCpuHostAperture

+                     (*(ADAPTER_RENDER **)

+                       (*(longlong *)(*(longlong *)(lVar16 + 0x18) + 0x18) + 0xc50),

+                      (_DXGKARG_MAPCPUHOSTAPERTURE *)&local_58);

+  lVar16 = *(longlong *)this;

+  if (*(VIDMM_CPU_HOST_APERTURE **)(lVar16 + 8) != this) {

+    lVar16 = 3;

+    pcVar8 = (code *)swi(0x29);

+    iVar10 = (*pcVar8)();

+    puVar20 = auStack_80;

+  }

+  *(longlong *)param_1 = lVar16;

+  *(VIDMM_CPU_HOST_APERTURE **)(param_1 + 8) = this;

+  *(VIDMM_CPU_HOST_APERTURE_RANGE **)(lVar16 + 8) = param_1;

+  *(VIDMM_CPU_HOST_APERTURE_RANGE **)this = param_1;

+  pVVar17 = *(VIDMM_GLOBAL **)(this + 0x30);

+  if (iVar10 < 0) {

+    *(undefined8 *)(puVar20 + -8) = 0x1400ae051;

+    pDVar14 = VIDMM_GLOBAL::DxgAdapter(pVVar17);

+    *(undefined8 *)(puVar20 + -8) = 0x1400ae059;

+    pDVar14 = VIDMM_GLOBAL::DxgAdapter((VIDMM_GLOBAL *)pDVar14);

+    uVar7 = *(undefined8 *)param_2;

+    *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+    pVVar17 = (VIDMM_GLOBAL *)0x0;

+    *(DXGADAPTER **)(puVar20 + 0x28) = pDVar14;

+    *(undefined8 *)(puVar20 + 0x20) = uVar7;

+    *(undefined8 *)(puVar20 + -8) = 0x1400ae089;

+    WdLogSingleEntry5(0,0x10e,0x2d,this);

+    _WdLogGlobalForLineNumber = 0xc3;

+  }

+  if ((*(longlong *)(*(longlong *)(pVVar17 + 0x18) + 0xa068) != 0) &&

+     (p_Var19 = p_Var12, uVar4 != 0)) {

+    do {

+      lVar16 = *(longlong *)(this + 0x30);

+      _Var11 = *p_Var19;

+      *(undefined8 *)(puVar20 + 0x28) = 0;

+      pVVar17 = *(VIDMM_GLOBAL **)(lVar16 + 0x18);

+      *(undefined4 *)(puVar20 + 0x20) = 2;

+      *(undefined8 *)(puVar20 + -8) = 0x1400ae0d8;

+      VIDMM_GLOBAL::RecordPageMappingHistory

+                (pVVar17,(uint)*(ushort *)(puVar20 + 0x38),_Var11,1,

+                 *(VIDMM_PAGE_HISTORY_TYPE *)(puVar20 + 0x20),*(__uint64 *)(puVar20 + 0x28));

+      uVar21 = uVar21 - 1;

+      p_Var19 = p_Var19 + 1;

+    } while (uVar21 != 0);

+  }

+  *(undefined8 *)(puVar20 + -8) = 0x1400ae0ea;

+  operator_delete__(p_Var12);

+  return 0;

+}

+
```

## `VIDMM_GLOBAL::Init`  (modified)

```diff
--- VIDMM_GLOBAL::Init
+++ VIDMM_GLOBAL::Init
@@ -1,2 +1,539 @@
-Failed to decompile dxgmms2.sys - .ProgramDB VIDMM_GLOBAL::Init : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* public: long __cdecl VIDMM_GLOBAL::Init(class ADAPTER_RENDER * __ptr64,unsigned long,unsigned

+   int) __ptr64 */

+

+long __thiscall

+VIDMM_GLOBAL::Init(VIDMM_GLOBAL *this,ADAPTER_RENDER *param_1,ulong param_2,uint param_3)

+

+{

+  ushort uVar1;

+  uint uVar2;

+  longlong lVar3;

+  VIDMM_PHYSICAL_ADAPTER *pVVar4;

+  code *pcVar5;

+  undefined1 auVar6 [16];

+  char cVar7;

+  uchar uVar8;

+  byte bVar9;

+  uint uVar10;

+  int iVar11;

+  undefined8 uVar12;

+  __uint64 _Var13;

+  void *pvVar14;

+  void *pvVar15;

+  longlong lVar16;

+  DXGADAPTER_GPUMMUCAPS *pDVar17;

+  undefined8 uVar18;

+  ulonglong *puVar19;

+  ulonglong *puVar20;

+  CVirtualAddressAllocator *pCVar21;

+  CVirtualAddressAllocator *pCVar22;

+  VIDMM_GLOBAL VVar23;

+  undefined8 uVar24;

+  ulonglong uVar25;

+  _LIST_ENTRY *p_Var26;

+  byte bVar27;

+  byte bVar28;

+  ulonglong uVar29;

+  _func_long___uint64___uint64_void_ptr *p_Var30;

+  ushort uVar31;

+  undefined1 *puVar32;

+  VIDMM_GLOBAL *pVVar33;

+  DXGK_POOL_FLAGS DVar34;

+  void *pvVar35;

+  wchar_t *pwVar36;

+  VIDMM_PARTITION *pVVar37;

+  wchar_t *pwVar38;

+  wchar_t *pwVar39;

+  ulonglong *puVar40;

+  ushort uVar41;

+  uint uVar42;

+  DXGK_PHYSICALADAPTERINFO *pDVar43;

+  VIDMM_PARTITION *pVVar44;

+  VIDMM_PARTITION *this_00;

+  bool bVar45;

+  undefined1 auStackY_e8 [8];

+  undefined1 auStackY_e0 [24];

+  uint local_98 [2];

+  longlong local_90;

+  undefined8 local_88;

+  longlong local_80;

+  undefined4 local_78;

+  wchar_t local_68 [8];

+  DXGAUTOEXPUSHLOCKSHARED local_58 [32];

+  

+  puVar32 = auStackY_e8;

+  *(ADAPTER_RENDER **)(this + 0x10) = param_1;

+  pVVar33 = this + 0x9fe9;

+  lVar3 = *(longlong *)(param_1 + 0x10);

+  uVar10 = 0;

+  *(longlong *)(this + 0x18) = lVar3;

+  *(ulong *)(this + 0x20) = param_2;

+  DAT_0 = DAT_0 | (byte)(*(uint *)(lVar3 + 0x1bc) >> 9) & 1;

+  lVar3 = *(longlong *)(this + 0x18);

+  if (0x5fff < param_2) {

+    *pVVar33 = (VIDMM_GLOBAL)((byte)*pVVar33 | 2);

+  }

+  cVar7 = DxgkpIsDrtEnabled();

+  lVar16 = *(longlong *)(this + 0x18);

+  VVar23 = (VIDMM_GLOBAL)((cVar7 << 6 ^ (byte)*pVVar33) & 0x40 ^ (byte)*pVVar33);

+  *pVVar33 = VVar23;

+  bVar27 = (*(char *)(lVar16 + 0x13d0) << 5 ^ (byte)VVar23) & 0x20 ^ (byte)VVar23;

+  *pVVar33 = (VIDMM_GLOBAL)((bVar27 >> 1 ^ bVar27) & 0x10 ^ bVar27);

+  uVar42 = *(uint *)(lVar16 + 0x128);

+  *(uint *)(this + 0x1b20) = uVar42;

+  if (0x40 < uVar42) {

+    uVar18 = 1;

+    WdLogSingleEntry1(1,0x40);

+    pwVar38 = L"Total number of engine on logical adapter can\'t exceed %I64d";

+    uVar12 = 0x40;

+    _WdLogGlobalForLineNumber = 0x573;

+LAB_1:

+    DxgkLogInternalTriageEvent(uVar18,0x40000,lVar16,pwVar38,uVar12,0,0,0);

+    return -0x3ffffff3;

+  }

+  uVar1 = *(ushort *)(this + 0x1b20);

+  _Var13 = SUB168(ZEXT816(8) * ZEXT216(uVar1),0);

+  if (SUB168(ZEXT816(8) * ZEXT216(uVar1),8) != 0) {

+    _Var13 = 0xffffffffffffffff;

+  }

+  pvVar14 = operator_new__(_Var13,0x30356956,0x40);

+  pvVar35 = (void *)0x0;

+  *(void **)(this + 0x9d28) = pvVar14;

+  if (pvVar14 == (void *)0x0) {

+    LOCK();

+    _DAT_2 = _DAT_2 + 1;

+    UNLOCK();

+    WdLogSingleEntry0();

+    uVar12 = 0x57c;

+    pwVar38 = L"Couldn\'t allocate VIDMM_PHYSICAL_ADAPTER array.\n";

+LAB_3:

+    _WdLogGlobalForLineNumber = (undefined4)uVar12;

+    DxgkLogInternalTriageEvent(0,0x40001,pvVar35,pwVar38,uVar12,0,0,0);

+    return -0x3fffffe9;

+  }

+  for (uVar31 = 0; lVar16 = 0, uVar31 < uVar1; uVar31 = uVar31 + 1) {

+    pvVar15 = operator_new(0x6c0,0x30356956,0x40);

+    pvVar35 = (void *)0x0;

+    pvVar14 = pvVar35;

+    if (pvVar15 != (void *)0x0) {

+      *(VIDMM_GLOBAL **)((longlong)pvVar15 + 0x30) = this;

+      *(ushort *)((longlong)pvVar15 + 0x38) = uVar31;

+      lVar16 = (longlong)pvVar15 + 0x678;

+      *(longlong *)((longlong)pvVar15 + 0x680) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      lVar16 = (longlong)pvVar15 + 0x688;

+      *(longlong *)((longlong)pvVar15 + 0x690) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      lVar16 = (longlong)pvVar15 + 0x698;

+      *(longlong *)((longlong)pvVar15 + 0x6a0) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      lVar16 = (longlong)pvVar15 + 0x6a8;

+      *(longlong *)((longlong)pvVar15 + 0x6b0) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      lVar16 = (longlong)pvVar15 + 0x1f8;

+      *(undefined4 *)((longlong)pvVar15 + 0x6b8) = 0;

+      *(longlong *)((longlong)pvVar15 + 0x200) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      lVar16 = (longlong)pvVar15 + 0x208;

+      *(longlong *)((longlong)pvVar15 + 0x210) = lVar16;

+      *(longlong *)lVar16 = lVar16;

+      pvVar14 = pvVar15;

+    }

+    *(void **)(*(longlong *)(this + 0x9d28) + (ulonglong)uVar31 * 8) = pvVar14;

+    if (*(longlong *)(*(longlong *)(this + 0x9d28) + (ulonglong)uVar31 * 8) == 0) {

+      LOCK();

+      _DAT_4 = _DAT_4 + 1;

+      UNLOCK();

+      WdLogSingleEntry0();

+      uVar12 = 0x585;

+      pwVar38 = L"Couldn\'t allocate VIDMM_PHYSICAL_ADAPTER.\n";

+      goto LAB_3;

+    }

+  }

+  if ((*(uint *)(lVar3 + 0x9bc) & 0x20) != 0) {

+    local_98[0] = 0;

+    VVar23 = (VIDMM_GLOBAL)

+             (((byte)(*(uint *)(lVar3 + 0x9bc) >> 5) ^ (byte)this[0x9fe8]) & 2 ^ (byte)this[0x9fe8])

+    ;

+    this[0x9fe8] = VVar23;

+    this[0x9fe8] = (VIDMM_GLOBAL)

+                   (((byte)(*(uint *)(lVar3 + 0x9bc) >> 2) ^ (byte)VVar23) & 0x20 ^ (byte)VVar23);

+    SysMmQueryIommuState

+              (*(SYSMM_ADAPTER **)(*(longlong *)(this + 0x18) + 0xe0),(SYSMM_IOMMU_STATE *)local_98)

+    ;

+    this[0x9fe8] = (VIDMM_GLOBAL)(((byte)(local_98[0] >> 2) & 1) << 2 | (byte)this[0x9fe8] & 0xfb);

+    uVar8 = DXGADAPTER::IsGpuVaIoMmuGlobalSupported(*(DXGADAPTER **)(this + 0x18));

+    VVar23 = this[0x9fe8];

+    bVar27 = -(uVar8 != '\0') & 8;

+    bVar28 = -(bVar27 != 0 || ((byte)VVar23 & 6) != 0) & 0x10;

+    this[0x9fe8] = (VIDMM_GLOBAL)(bVar28 | bVar27 | (byte)VVar23 & 0xe7);

+    if (((byte)VVar23 & 0x20) != 0) {

+      if ((((__Config >> 5 & 1) == 0) && ((*(uint *)(*(longlong *)(this + 0x18) + 0x1bc) & 4) == 0))

+         && ((*(uint *)(*(longlong *)(this + 0x18) + 0x1bc) & 8) == 0)) {

+        bVar9 = 0x40;

+      }

+      else {

+        bVar9 = 0;

+      }

+      this[0x9fe8] = (VIDMM_GLOBAL)(bVar28 | bVar27 | (byte)VVar23 & 0xa7 | bVar9);

+    }

+    if ((0x5016 < param_2) || ((__Config & 0x100) != 0)) {

+      this[0x9fe9] = (VIDMM_GLOBAL)((byte)this[0x9fe9] | 1);

+    }

+  }

+  if (((byte)this[0x9fe8] & 0xc) == 0) {

+    if ((param_3 & 1) != 0) {

+      this[0x9cab] = (VIDMM_GLOBAL)0x1;

+      this[0x9cad] = (VIDMM_GLOBAL)0x1;

+      this[0x9cd8] = (VIDMM_GLOBAL)0x1;

+    }

+    if ((param_3 & 2) != 0) {

+      if ((*(uint *)(lVar3 + 0x9bc) & 0x4000) == 0) {

+        WdLogSingleEntry0();

+        uVar18 = 0;

+        pwVar38 = 

+        L"DMA remapping requires the driver to support the MapAperture2 paging buffer command";

+        uVar12 = 0x5b6;

+        _WdLogGlobalForLineNumber = 0x5b6;

+        goto LAB_1;

+      }

+      this[0x9cac] = (VIDMM_GLOBAL)0x1;

+    }

+  }

+  this[0x11d8] = (VIDMM_GLOBAL)(~(byte)(*(uint *)(lVar3 + 0x9b8) >> 5) & 1);

+  uVar41 = 0;

+  this[0x9fe9] = (VIDMM_GLOBAL)

+                 (((char)(*(uint *)(lVar3 + 0x9bc) >> 0xe) << 3 ^ (byte)this[0x9fe9]) & 8 ^

+                 (byte)this[0x9fe9]);

+  for (uVar31 = 0; uVar31 < uVar1; uVar31 = uVar31 + 1) {

+    uVar29 = (ulonglong)uVar31;

+    pDVar43 = (DXGK_PHYSICALADAPTERINFO *)

+              (uVar29 * 0x158 + *(longlong *)(*(longlong *)(this + 0x18) + 0xbc8));

+    pDVar17 = ADAPTER_RENDER::GetGpuMmuCaps(*(ADAPTER_RENDER **)(this + 0x10),(uint)uVar31);

+    pVVar4 = *(VIDMM_PHYSICAL_ADAPTER **)(*(longlong *)(this + 0x9d28) + uVar29 * 8);

+    uVar10 = VIDMM_PHYSICAL_ADAPTER::Initialize(pVVar4,pDVar43,(_DXGK_GPUMMUCAPS *)pDVar17);

+    if ((int)uVar10 < 0) goto LAB_5;

+    *(int *)(this + 0xe78) = *(int *)(this + 0xe78) + *(int *)(pVVar4 + 0x40);

+    if (pDVar17 != (DXGADAPTER_GPUMMUCAPS *)0x0) {

+      this[0x9ca9] = (VIDMM_GLOBAL)((byte)this[0x9ca9] & ~(byte)pDVar17[0x14] & 1);

+    }

+    this[0x9fe9] = (VIDMM_GLOBAL)

+                   (((char)(*(uint *)(pDVar43 + 0x10) >> 5) << 2 | (byte)this[0x9fe9]) & 4 ^

+                   (byte)this[0x9fe9] & 0xfb);

+  }

+  if (DAT_6 == 2) {

+    VVar23 = (VIDMM_GLOBAL)((byte)(*(uint *)(*(longlong *)(this + 0x18) + 0x9ac) >> 2) & 1);

+  }

+  else {

+    VVar23 = (VIDMM_GLOBAL)(DAT_6 == 1);

+  }

+  this[0x1ba8] = VVar23;

+  *(undefined8 *)(this + 0xae90) = DAT_7;

+  uVar42 = DAT_8;

+  if (DAT_8 != 0) {

+    _Var13 = SUB168(ZEXT816(0x168) * ZEXT416(DAT_8),0);

+    if (SUB168(ZEXT816(0x168) * ZEXT416(DAT_8),8) != 0) {

+      _Var13 = 0xffffffffffffffff;

+    }

+    pvVar14 = operator_new__(_Var13,0x6d4d6956,0x40);

+    *(void **)(this + 0x1e80) = pvVar14;

+    if (pvVar14 != (void *)0x0) {

+      *(uint *)(this + 0x1e78) = uVar42;

+      *(undefined8 *)(this + 0x1e88) = 0;

+    }

+  }

+  *(undefined8 *)(this + 0x1b28) = 0;

+  uVar12 = 0x102;

+  pwVar38 = operator_new__(0x208,0x4b677844,0x102);

+  if (pwVar38 == (wchar_t *)0x0) {

+    LOCK();

+    _DAT_9 = _DAT_9 + 1;

+    UNLOCK();

+    uVar24 = 6;

+    WdLogSingleEntry0();

+    uVar18 = 0x613;

+    pwVar38 = L"Failed to create naming string for CreateGpuPerformanceCounterSetAdapterMemory";

+LAB_10:

+    _WdLogGlobalForLineNumber = (undefined4)uVar18;

+    DxgkLogInternalTriageEvent(uVar24,0x40001,uVar12,pwVar38,uVar18,0,0,0);

+    uVar10 = 0xc0000017;

+  }

+  else {

+    for (; uVar41 < uVar1; uVar41 = uVar41 + 1) {

+      pwVar36 = L"luid_0x%08X_0x%08X_phys_%u";

+      local_90 = *(longlong *)(*(longlong *)(this + 0x9d28) + (ulonglong)uVar41 * 8);

+      local_68[0] = L'\0';

+      local_68[1] = L'\0';

+      local_68[2] = L'\0';

+      local_68[3] = L'\0';

+      local_68[4] = L'\0';

+      local_68[5] = L'\0';

+      local_68[6] = L'\0';

+      local_68[7] = L'\0';

+      uVar10 = RtlStringCbPrintfW(pwVar38,0x208,L"luid_0x%08X_0x%08X_phys_%u",

+                                  (ulonglong)*(uint *)(*(longlong *)(param_1 + 0x10) + 0x1a0));

+      if ((int)uVar10 < 0) {

+        uVar18 = 1;

+        WdLogSingleEntry0();

+        uVar12 = 0x627;

+        pwVar39 = L"Failed to create naming string for CreateGpuPerformanceCounterSetAdapterMemory";

+        uVar24 = 0x40000;

+LAB_11:

+        _WdLogGlobalForLineNumber = (undefined4)uVar12;

+        DxgkLogInternalTriageEvent(uVar18,uVar24,pwVar36,pwVar39,uVar12,0,0,0);

+        break;

+      }

+      RtlInitUnicodeString(local_68,pwVar38);

+      pwVar36 = local_68;

+      local_80 = local_90;

+      local_78 = 0x6c0;

+      uVar10 = PcwCreateInstance(local_90 + 0x668,GpuPerformanceCounterSetAdapterMemory,pwVar36,1);

+      if ((int)uVar10 < 0) {

+        LOCK();

+        _DAT_9 = _DAT_9 + 1;

+        UNLOCK();

+        uVar18 = 6;

+        WdLogSingleEntry0();

+        uVar12 = 0x62f;

+        pwVar39 = L"Failed to create CreateGpuPerformanceCounterSetAdapterMemory";

+        uVar24 = 0x40001;

+        goto LAB_11;

+      }

+    }

+    puVar40 = (ulonglong *)0x0;

+    operator_delete__(pwVar38);

+    if ((int)uVar10 < 0) goto LAB_5;

+    uVar29 = DAT_12 + *(longlong *)(this + 0xad88);

+    this[0x9ca8] = (VIDMM_GLOBAL)(uVar29 < *(ulonglong *)(*(longlong *)(this + 0x18) + 0xbe8));

+    if (((byte)this[0x9fe8] & 0x10) != 0) {

+      uVar25 = CONCAT44(0,DAT_13);

+      if (DAT_13 != 0) {

+        uVar12 = 0x100;

+        if (GpuVaPagingHistoryFreEnabled == false) {

+          auVar6._8_8_ = 0;

+          auVar6._0_8_ = uVar25;

+          uVar29 = SUB168(ZEXT816(0x18) * auVar6,0);

+          if (SUB168(ZEXT816(0x18) * auVar6,8) != 0) {

+            uVar29 = 0xffffffffffffffff;

+          }

+          _Var13 = uVar29 + 8;

+          if (0xfffffffffffffff7 < uVar29) {

+            _Var13 = 0xffffffffffffffff;

+          }

+          puVar19 = operator_new__(_Var13,0x32356956,0x100);

+          puVar20 = puVar40;

+          if (puVar19 != (ulonglong *)0x0) {

+            *puVar19 = uVar25;

+            puVar20 = puVar19 + 1;

+          }

+          *(ulonglong **)(this + 0xa020) = puVar20;

+          if (puVar20 == (ulonglong *)0x0) {

+            LOCK();

+            _DAT_14 = _DAT_14 + 1;

+            UNLOCK();

+            uVar24 = 6;

+            WdLogSingleEntry0();

+            uVar18 = 0x65b;

+            pwVar38 = L"Failed to allocate _VaPagingHistory";

+            goto LAB_10;

+          }

+        }

+        else {

+          DVar34 = 0x100;

+          if (DAT_13 < 0x10001) {

+            DVar34 = 0x40;

+          }

+          DXGK_LOG::Initialize

+                    ((DXGK_LOG *)(this + 0xa048),(uint)uVar29,DVar34,(ulonglong)DAT_13,

+                     (ulonglong)DAT_15);

+        }

+        _Var13 = SUB168(ZEXT816(0x30) * ZEXT416(DAT_16),0);

+        uVar12 = 0x100;

+        if (SUB168(ZEXT816(0x30) * ZEXT416(DAT_16),8) != 0) {

+          _Var13 = 0xffffffffffffffff;

+        }

+        pvVar14 = operator_new__(_Var13,0x32356956,0x100);

+        *(void **)(this + 0xa068) = pvVar14;

+        if (pvVar14 == (void *)0x0) {

+          LOCK();

+          _DAT_14 = _DAT_14 + 1;

+          UNLOCK();

+          uVar24 = 6;

+          WdLogSingleEntry0();

+          uVar18 = 0x664;

+          pwVar38 = L"Failed to allocate _PageMappingHistoryEntry";

+          goto LAB_10;

+        }

+      }

+      this[0x9fe8] = (VIDMM_GLOBAL)((byte)this[0x9fe8] & 0x7e);

+      *(undefined4 *)(this + 0x9fe4) = 0;

+      uVar10 = 0;

+      while (uVar42 = (uint)puVar40, uVar42 < uVar1) {

+        pDVar43 = (DXGK_PHYSICALADAPTERINFO *)

+                  ((longlong)puVar40 * 0x158 + *(longlong *)(*(longlong *)(this + 0x18) + 0xbc8));

+        pDVar17 = ADAPTER_RENDER::GetGpuMmuCaps(*(ADAPTER_RENDER **)(this + 0x10),uVar42);

+        pVVar4 = *(VIDMM_PHYSICAL_ADAPTER **)(*(longlong *)(this + 0x9d28) + (longlong)puVar40 * 8);

+        uVar10 = VIDMM_PHYSICAL_ADAPTER::InitializeGpuVaState(pVVar4,this,uVar42,pDVar17,pDVar43);

+        if ((int)uVar10 < 0) goto LAB_5;

+        uVar2 = *(uint *)(pVVar4 + 0x6c);

+        uVar10 = *(uint *)(this + 0x9fe4);

+        if (*(uint *)(this + 0x9fe4) < uVar2) {

+          *(uint *)(this + 0x9fe4) = uVar2;

+          uVar10 = uVar2;

+        }

+        if (*(int *)(pVVar4 + 0x1d4) == 1) {

+          this[0x9fe8] = (VIDMM_GLOBAL)((byte)this[0x9fe8] | 0x80);

+        }

+        if ((*(uint *)pDVar17 & 0x40) != 0) {

+          this[0x9fe8] = (VIDMM_GLOBAL)((byte)this[0x9fe8] | 1);

+        }

+        puVar40 = (ulonglong *)(ulonglong)(uVar42 + 1);

+      }

+      iVar11 = DAT_17;

+      if (param_2 < 0x5023) {

+        iVar11 = 0x1000 << ((byte)uVar10 & 0x1f);

+      }

+      *(int *)(this + 0xa01c) = iVar11;

+      uVar10 = VIDMM_PAGING_PROCESS::CreateVaAllocator((VIDMM_PAGING_PROCESS *)(this + 0x9dc0),this)

+      ;

+      if ((int)uVar10 < 0) goto LAB_5;

+    }

+    uVar8 = DXGADAPTER::IsGpuVaIoMmuGlobalSupported(*(DXGADAPTER **)(this + 0x18));

+    if (uVar8 == '\0') {

+LAB_18:

+      KeInitializeTimer(this + 0xaf08);

+      pVVar33 = this;

+      KeInitializeThreadedDpc(this + 0xaf50,VidMmDelayedEvictionDpc);

+      uVar10 = CreateWorkerThread(this);

+      uVar29 = (ulonglong)uVar10;

+      if (-1 < (int)uVar10) {

+        DXGAUTOEXPUSHLOCKSHARED::DXGAUTOEXPUSHLOCKSHARED(local_58,&VIDMM_PARTITION::_PartitionLock);

+        pCVar22 = __PartitionTree;

+        this_00 = (VIDMM_PARTITION *)(CVirtualAddressAllocator *)0x0;

+        while (pCVar21 = pCVar22, pCVar21 != (CVirtualAddressAllocator *)0x0) {

+          this_00 = (VIDMM_PARTITION *)pCVar21;

+          pCVar22 = *(CVirtualAddressAllocator **)pCVar21;

+        }

+        do {

+          if (this_00 == (VIDMM_PARTITION *)0x0) {

+            DXGAUTOEXPUSHLOCK::~DXGAUTOEXPUSHLOCK((DXGAUTOEXPUSHLOCK *)local_58);

+            *(undefined8 *)(this + 0x1ea0) = _DAT_19;

+            *(undefined8 *)(this + 0x1ea8) = _DAT_19;

+            DXGAUTOEXPUSHLOCKEXCLUSIVE::DXGAUTOEXPUSHLOCKEXCLUSIVE

+                      ((DXGAUTOEXPUSHLOCKEXCLUSIVE *)&local_80,&_AdapterListLock);

+            p_Var26 = &_AdapterListHead;

+            pVVar33 = this + 0xaef8;

+            if (*(_LIST_ENTRY **)DAT_20 != &_AdapterListHead) {

+              p_Var26 = (_LIST_ENTRY *)0x3;

+              pcVar5 = (code *)swi(0x29);

+              DAT_20 = (VIDMM_GLOBAL *)(*pcVar5)();

+              puVar32 = auStackY_e0;

+            }

+            *(_LIST_ENTRY **)pVVar33 = p_Var26;

+            *(VIDMM_GLOBAL **)(this + 0xaf00) = DAT_20;

+            *(VIDMM_GLOBAL **)DAT_20 = pVVar33;

+            *(undefined8 *)(puVar32 + -8) = 0x140093dc1;

+            DAT_20 = pVVar33;

+            DXGAUTOEXPUSHLOCK::~DXGAUTOEXPUSHLOCK((DXGAUTOEXPUSHLOCK *)&local_80);

+            return (long)uVar29;

+          }

+          uVar10 = VIDMM_PARTITION::EnsureAdapter(this_00,this);

+          uVar29 = (ulonglong)(int)uVar10;

+          if ((int)uVar10 < 0) {

+            uVar12 = 1;

+            pVVar37 = this_00;

+            WdLogSingleEntry3(1,this,this_00,uVar29);

+            _WdLogGlobalForLineNumber = 0x6e2;

+            DxgkLogInternalTriageEvent

+                      (uVar12,0x40000,pVVar37,

+                       L"Failed to initialize adapter info for partition. VidMmGlobal=0x%p, VidMmPartition=0x%p, Status=0x%.8x"

+                       ,this,this_00,uVar29,0);

+            DXGAUTOEXPUSHLOCK::~DXGAUTOEXPUSHLOCK((DXGAUTOEXPUSHLOCK *)local_58);

+            goto LAB_5;

+          }

+          pVVar37 = *(VIDMM_PARTITION **)(this_00 + 8);

+          pVVar44 = this_00;

+          if (pVVar37 == (VIDMM_PARTITION *)0x0) {

+            do {

+              this_00 = (VIDMM_PARTITION *)(*(ulonglong *)(pVVar44 + 0x10) & 0xfffffffffffffffc);

+              if (this_00 == (VIDMM_PARTITION *)0x0) break;

+              bVar45 = *(VIDMM_PARTITION **)this_00 != pVVar44;

+              pVVar44 = this_00;

+            } while (bVar45);

+          }

+          else {

+            this_00 = pVVar37;

+            for (pVVar37 = *(VIDMM_PARTITION **)pVVar37; pVVar37 != (VIDMM_PARTITION *)0x0;

+                pVVar37 = *(VIDMM_PARTITION **)pVVar37) {

+              this_00 = pVVar37;

+            }

+          }

+        } while( true );

+      }

+      uVar18 = 1;

+      WdLogSingleEntry0();

+      uVar12 = 0x6ce;

+      pwVar38 = L"Failed to start the worker thread";

+      _WdLogGlobalForLineNumber = 0x6ce;

+    }

+    else {

+      uVar12 = 0x100;

+      pCVar21 = operator_new(0x98,0x4b677844,0x100);

+      pCVar22 = (CVirtualAddressAllocator *)0x0;

+      if (pCVar21 != (CVirtualAddressAllocator *)0x0) {

+        pCVar22 = (CVirtualAddressAllocator *)

+                  CVirtualAddressAllocator::CVirtualAddressAllocator(pCVar21);

+      }

+      *(CVirtualAddressAllocator **)(this + 0xadd8) = pCVar22;

+      if (pCVar22 == (CVirtualAddressAllocator *)0x0) {

+        LOCK();

+        _DAT_21 = _DAT_21 + 1;

+        UNLOCK();

+        uVar24 = 6;

+        WdLogSingleEntry0();

+        uVar18 = 0x6a5;

+        pwVar38 = L"Failed to allocate CVirtualAddressAllocator";

+        goto LAB_10;

+      }

+      pVVar33 = (VIDMM_GLOBAL *)(ulonglong)*(uint *)(this + 0xa01c);

+      p_Var30 = (_func_long___uint64___uint64_void_ptr *)

+                (1L << ((byte)*(undefined4 *)(this + 0x9fe0) & 0x3f));

+      uVar10 = CVirtualAddressAllocator::InitializeVaAllocator

+                         (pCVar22,(__uint64)p_Var30,*(uint *)(this + 0xa01c),this,

+                          (VIDMM_PROCESS *)0x0);

+      if ((int)uVar10 < 0) {

+        uVar18 = 1;

+        WdLogSingleEntry1(1,*(undefined8 *)(this + 0xadd8));

+        uVar12 = *(undefined8 *)(this + 0xadd8);

+        pwVar38 = 

+        L"Failed to initialize CVirtualAddressAllocator for GpuVaIoMmuGlobal, _pGpuVaIoMmuAllocator=0x%p"

+        ;

+        _WdLogGlobalForLineNumber = 0x6ad;

+      }

+      else {

+        pVVar33 = (VIDMM_GLOBAL *)&local_90;

+        local_90 = *(longlong *)(this + 0xadd8);

+        local_88 = 0;

+        SysMmIterateHardwareReservedRanges

+                  (*(SYSMM_ADAPTER **)(*(longlong *)(this + 0x18) + 0xe0),p_Var30,pVVar33);

+        uVar10 = (uint)local_88;

+        if (-1 < (int)(uint)local_88) goto LAB_18;

+        uVar18 = 1;

+        WdLogSingleEntry1(1,*(undefined8 *)(*(longlong *)(this + 0x18) + 0xe0));

+        pwVar38 = 

+        L"Failed to initialize hardware reserved ranges for GpuVaIoMmuGlobal. SysMmAdapter=0x%p";

+        _WdLogGlobalForLineNumber = 0x6bd;

+        uVar12 = *(undefined8 *)(*(longlong *)(this + 0x18) + 0xe0);

+      }

+    }

+    DxgkLogInternalTriageEvent(uVar18,0x40000,pVVar33,pwVar38,uVar12,0,0,0);

+  }

+LAB_5:

+  VIDMM_PAGING_PROCESS::DestroyPagingProcess((VIDMM_PAGING_PROCESS *)(this + 0x9dc0));

+  operator_delete__(*(void **)(this + 0x1b28));

+  *(undefined8 *)(this + 0x1b28) = 0;

+  return uVar10;

+}

+
```
