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

`dxgmms2.sys` 10.0.26100.9711 -> 10.0.26100.9974 (ghidriff).

## `VidSchiAddPendingCommandToSyncPointList`  (modified)

```diff
--- VidSchiAddPendingCommandToSyncPointList
+++ VidSchiAddPendingCommandToSyncPointList
@@ -1,12 +1,277 @@
+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

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

+/* long __cdecl VidSchiAddPendingCommandToSyncPointList(struct _VIDSCH_DEVICE * __ptr64,struct

+   VIDMM_ALLOC * __ptr64,__int64,unsigned int,unsigned int,enum _VIDSCH_DEVICE_COMMAND_TYPE) */

 

 long __cdecl

 VidSchiAddPendingCommandToSyncPointList

           (_VIDSCH_DEVICE *param_1,VIDMM_ALLOC *param_2,__int64 param_3,uint param_4,uint param_5,

           _VIDSCH_DEVICE_COMMAND_TYPE param_6)

 

 {

-  long in_EAX;

+  _VIDSCH_CONTEXT_ID_PAIR *p_Var1;

+  longlong *plVar2;

+  undefined8 *puVar3;

+  code *pcVar4;

+  long lVar5;

+  _VIDSCH_DEVICE *this;

+  _VIDSCH_DEVICE *p_Var6;

+  ulonglong uVar7;

+  VIDSCH_HW_QUEUE_FENCE_PAIR *pVVar8;

+  void **ppvVar9;

+  __uint64 *p_Var10;

+  VIDMM_ALLOC *pVVar11;

+  _VIDSCH_DEVICE *p_Var12;

+  VIDSCH_HW_QUEUE_FENCE_PAIR *pVVar13;

+  uint uVar14;

+  VIDMM_ALLOC *pVVar15;

+  _VIDSCH_DEVICE *p_Var16;

+  __uint64 *p_Var17;

+  undefined1 *puVar18;

+  _VIDSCH_DEVICE *p_Var19;

+  _VIDSCH_DEVICE *p_Var20;

+  _VIDSCH_DEVICE *p_Var21;

+  _VIDSCH_DEVICE *p_Var22;

+  __uint64 *p_Var23;

+  longlong lVar24;

+  undefined1 auStackY_e8 [8];

+  undefined1 auStackY_e0 [24];

+  undefined1 *local_90;

+  undefined1 local_88 [16];

+  undefined4 local_78;

+  undefined1 *local_70;

+  undefined1 local_68 [16];

+  undefined4 local_58;

+  ulonglong local_50;

   

-  return in_EAX;

+  puVar18 = auStackY_e8;

+  local_50 = __security_cookie ^ (ulonglong)auStackY_e8;

+  pVVar8 = (VIDSCH_HW_QUEUE_FENCE_PAIR *)(ulonglong)param_5;

+  p_Var21 = (_VIDSCH_DEVICE *)0x0;

+  p_Var23 = (__uint64 *)(ulonglong)param_4;

+  p_Var12 = param_1;

+  pVVar15 = param_2;

+  if ((param_4 == 0) && (param_5 == 0)) {

+    *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+    pVVar15 = (VIDMM_ALLOC *)0x119;

+    p_Var12 = (_VIDSCH_DEVICE *)0x0;

+    WdLogSingleEntry5(0,0x119,0xd00,param_1);

+    _WdLogGlobalForLineNumber = 0x38a;

+  }

+  this = *(_VIDSCH_DEVICE **)(p_Var12 + 0x750);

+  p_Var16 = p_Var12 + 0x748;

+  if ((this == p_Var16) || (*(longlong *)(this + 0x10) != param_3)) {

+    uVar14 = 0x66616956;

+    this = operator_new(0xa8,0x66616956,0x40);

+    if (this == (_VIDSCH_DEVICE *)0x0) {

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0x1be8;

+    }

+    else {

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

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

+      *(longlong *)(this + 0x48) = 0;

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

+      *(__int64 *)(this + 0x10) = param_3;

+      p_Var6 = this + 0x88;

+      *(_VIDSCH_DEVICE **)(this + 0x90) = p_Var6;

+      *(_VIDSCH_DEVICE **)p_Var6 = p_Var6;

+      p_Var6 = this + 0x98;

+      *(_VIDSCH_DEVICE **)(this + 0xa0) = p_Var6;

+      *(_VIDSCH_DEVICE **)p_Var6 = p_Var6;

+      uVar7 = Feature_1390122298__private_IsEnabledDeviceUsageNoInline();

+      if ((int)uVar7 == 0) {

+        plVar2 = *(longlong **)(p_Var12 + 0x750);

+        if ((_VIDSCH_DEVICE *)*plVar2 == p_Var16) {

+          *(_VIDSCH_DEVICE **)this = p_Var16;

+          *(longlong **)(this + 8) = plVar2;

+          *plVar2 = (longlong)this;

+          *(_VIDSCH_DEVICE **)(p_Var12 + 0x750) = this;

+          goto LAB_0;

+        }

+        goto LAB_1;

+      }

+LAB_0:

+      param_3 = (__int64)NonPagedPoolZeroedArray<_VIDSCH_CONTEXT_ID_PAIR,2,895576406>::

+                         AllocateElements((NonPagedPoolZeroedArray<_VIDSCH_CONTEXT_ID_PAIR,2,895576406>

+                                           *)(this + 0x18),param_4);

+      uVar14 = param_5;

+      pVVar8 = NonPagedPoolZeroedArray<VIDSCH_HW_QUEUE_FENCE_PAIR,2,895576406>::AllocateElements

+                         ((NonPagedPoolZeroedArray<VIDSCH_HW_QUEUE_FENCE_PAIR,2,895576406> *)

+                          (this + 0x48),param_5);

+      puVar18 = auStackY_e8;

+      if (((_VIDSCH_CONTEXT_ID_PAIR *)param_3 != (_VIDSCH_CONTEXT_ID_PAIR *)0x0) &&

+         (puVar18 = auStackY_e8, pVVar8 != (VIDSCH_HW_QUEUE_FENCE_PAIR *)0x0)) {

+        uVar7 = Feature_1390122298__private_IsEnabledDeviceUsageNoInline();

+        if ((int)uVar7 != 0) {

+          plVar2 = *(longlong **)(p_Var12 + 0x750);

+          if ((_VIDSCH_DEVICE *)*plVar2 != p_Var16) goto LAB_1;

+          *(_VIDSCH_DEVICE **)this = p_Var16;

+          *(longlong **)(this + 8) = plVar2;

+          *plVar2 = (longlong)this;

+          *(_VIDSCH_DEVICE **)(p_Var12 + 0x750) = this;

+        }

+        p_Var12 = param_1 + 0x48;

+        p_Var6 = p_Var21;

+        for (p_Var16 = *(_VIDSCH_DEVICE **)p_Var12; p_Var16 != p_Var12;

+            p_Var16 = *(_VIDSCH_DEVICE **)p_Var16) {

+          p_Var20 = *(_VIDSCH_DEVICE **)(p_Var16 + 0x98);

+          p_Var19 = *(_VIDSCH_DEVICE **)(p_Var16 + 0x88);

+          p_Var22 = p_Var6;

+          if (p_Var19 < p_Var20) {

+            if (param_4 - 1 < (uint)p_Var6) {

+              *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+              p_Var16 = (_VIDSCH_DEVICE *)0x119;

+              WdLogSingleEntry5(0,0x119,0xd00);

+              _WdLogGlobalForLineNumber = 0x38a;

+              goto LAB_2;

+            }

+            p_Var22 = (_VIDSCH_DEVICE *)(ulonglong)((uint)p_Var6 + 1);

+            *(_VIDSCH_DEVICE **)(param_3 + (longlong)p_Var6 * 0x10 + 8) = p_Var20;

+            *(_VIDSCH_DEVICE **)(param_3 + (longlong)p_Var6 * 0x10) = p_Var16 + -0x18;

+          }

+          p_Var6 = p_Var22;

+        }

+        p_Var19 = param_1 + 0x58;

+        p_Var16 = *(_VIDSCH_DEVICE **)p_Var19;

+        p_Var6 = p_Var21;

+        if (p_Var16 != p_Var19) {

+          do {

+            p_Var21 = p_Var16 + 0x20;

+            for (p_Var20 = *(_VIDSCH_DEVICE **)p_Var21; p_Var20 != p_Var21;

+                p_Var20 = *(_VIDSCH_DEVICE **)p_Var20) {

+LAB_2:

+              p_Var12 = p_Var20 + -8;

+              if ((*(int *)(p_Var20 + 0x8c) != 0) &&

+                 ((p_Var22 = p_Var20 + 0x40, *(ulonglong *)(p_Var20 + 0x38) < *(ulonglong *)p_Var22

+                  || (*(ulonglong *)(p_Var20 + 0x50) < *(ulonglong *)(p_Var20 + 0x58))))) {

+                if (param_5 - 1 < (uint)p_Var6) {

+                  *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+                  pVVar15 = (VIDMM_ALLOC *)0x119;

+                  param_6 = WdLogSingleEntry5(0,0x119,0xd00,0);

+                  _WdLogGlobalForLineNumber = 0x38a;

+                  goto LAB_3;

+                }

+                pVVar13 = pVVar8 + ((ulonglong)p_Var6 & 0xffffffff) * 0x18 + 8;

+                lVar24 = 2;

+                do {

+                  uVar7 = *(ulonglong *)p_Var22;

+                  p_Var22 = p_Var22 + 0x18;

+                  *(ulonglong *)pVVar13 = uVar7;

+                  pVVar13 = pVVar13 + 8;

+                  lVar24 = lVar24 + -1;

+                } while (lVar24 != 0);

+                uVar7 = (ulonglong)p_Var6 & 0xffffffff;

+                p_Var6 = (_VIDSCH_DEVICE *)(ulonglong)((uint)p_Var6 + 1);

+                *(_VIDSCH_DEVICE **)(pVVar8 + uVar7 * 0x18) = p_Var12;

+              }

+            }

+            p_Var16 = *(_VIDSCH_DEVICE **)p_Var16;

+          } while (p_Var16 != p_Var19);

+        }

+        pVVar15 = param_2;

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

+          local_90 = (undefined1 *)0x0;

+          local_78 = 0;

+          local_70 = (undefined1 *)0x0;

+          local_58 = 0;

+          ppvVar9 = NonPagedPoolZeroedArray<void_const*___ptr64,2,1717659990>::AllocateElements

+                              ((NonPagedPoolZeroedArray<void_const*___ptr64,2,1717659990> *)

+                               &local_90,param_4);

+          p_Var17 = p_Var23;

+          p_Var10 = NonPagedPoolZeroedArray<unsigned___int64,2,1717659990>::AllocateElements

+                              ((NonPagedPoolZeroedArray<unsigned___int64,2,1717659990> *)&local_70,

+                               param_4);

+          if ((ppvVar9 != (void **)0x0) && (p_Var10 != (__uint64 *)0x0)) {

+            if (param_4 != 0) {

+              p_Var17 = p_Var10;

+              do {

+                p_Var12 = *(_VIDSCH_DEVICE **)param_3;

+                if ((*(_VIDSCH_DEVICE **)(p_Var12 + 0x38) == (_VIDSCH_DEVICE *)0x0) ||

+                   (p_Var21 = *(_VIDSCH_DEVICE **)(p_Var12 + 0x38),

+                   (*(uint *)(p_Var12 + 0x70) & 0x40) != 0)) {

+                  p_Var21 = p_Var12;

+                }

+                *(_VIDSCH_DEVICE **)(((longlong)ppvVar9 - (longlong)p_Var10) + (longlong)p_Var17) =

+                     p_Var21;

+                p_Var1 = (_VIDSCH_CONTEXT_ID_PAIR *)(param_3 + 8);

+                param_3 = param_3 + 0x10;

+                *p_Var17 = *(__uint64 *)p_Var1;

+                p_Var17 = p_Var17 + 1;

+                p_Var23 = (__uint64 *)((longlong)p_Var23 + -1);

+              } while (p_Var23 != (__uint64 *)0x0);

+            }

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

+              p_Var21 = *(_VIDSCH_DEVICE **)(param_1 + 8);

+              if (*(_VIDSCH_DEVICE **)(param_1 + 8) == (_VIDSCH_DEVICE *)0x0) {

+                p_Var21 = param_1;

+              }

+              McTemplateK0pxqPR2XR2_EtwWriteTransfer

+                        (p_Var10,p_Var17,p_Var12,p_Var21,*(longlong *)(this + 0x10),param_4,ppvVar9,

+                         p_Var10);

+            }

+          }

+          if ((local_70 != local_68) && (local_70 != (undefined1 *)0x0)) {

+            ExFreePoolWithTag(local_70,0);

+          }

+          local_70 = (undefined1 *)0x0;

+          local_58 = 0;

+          if ((local_90 != local_88) && (local_90 != (undefined1 *)0x0)) {

+            ExFreePoolWithTag(local_90,0);

+          }

+        }

+        goto LAB_5;

+      }

+LAB_6:

+      *(undefined8 *)(puVar18 + -8) = 0x140031adc;

+      uVar7 = Feature_1390122298__private_IsEnabledDeviceUsageNoInline();

+      if ((int)uVar7 == 0) {

+        *(undefined8 *)(puVar18 + -8) = 0x140031ae8;

+        operator_delete__((void *)param_3);

+        *(undefined8 *)(puVar18 + -8) = 0x140031af0;

+        operator_delete__(pVVar8);

+      }

+      *(undefined8 *)(puVar18 + -8) = 0x140031af8;

+      _VIDSCH_SYNC_POINT::_scalar_deleting_destructor_((_VIDSCH_SYNC_POINT *)this,uVar14);

+      *(undefined8 *)(puVar18 + -8) = 0x140031b04;

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0x1c05;

+    }

+    lVar5 = -0x3fffffe9;

+  }

+  else {

+LAB_5:

+    if (param_6 == 0) {

+      pVVar11 = pVVar15 + 0xd8;

+      this = this + 0x88;

+LAB_7:

+      uVar14 = (uint)pVVar15;

+      puVar3 = *(undefined8 **)(this + 8);

+      if ((_VIDSCH_DEVICE *)*puVar3 != this) {

+LAB_1:

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

+        (*pcVar4)(3);

+        puVar18 = auStackY_e0;

+        goto LAB_6;

+      }

+      *(_VIDSCH_DEVICE **)pVVar11 = this;

+      *(undefined8 **)(pVVar11 + 8) = puVar3;

+      *puVar3 = pVVar11;

+      *(VIDMM_ALLOC **)(this + 8) = pVVar11;

+    }

+    else {

+LAB_3:

+      if (param_6 == 3) {

+        pVVar11 = pVVar15 + 0xe8;

+        this = this + 0x98;

+        goto LAB_7;

+      }

+    }

+    lVar5 = 0;

+    puVar18 = auStackY_e8;

+  }

+  *(undefined8 *)(puVar18 + -8) = 0x140031b41;

+  return lVar5;

 }
```

## `VidSchiSetPriorityContext`  (modified)

```diff
--- VidSchiSetPriorityContext
+++ VidSchiSetPriorityContext
@@ -1,9 +1,116 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

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

 

-undefined8 VidSchiSetPriorityContext(_VIDSCH_CONTEXT *param_1,uint param_2)

+void VidSchiSetPriorityContext(_VIDSCH_CONTEXT *param_1,uint param_2)

 

 {

-  return 0x48000000;

+  uint uVar1;

+  int iVar2;

+  _VIDSCH_NODE *p_Var3;

+  longlong lVar4;

+  longlong lVar5;

+  longlong *plVar6;

+  code *pcVar7;

+  bool bVar8;

+  bool bVar9;

+  _VIDSCH_NODE *p_Var10;

+  __uint64 _Var11;

+  _VIDSCH_CONTEXT *p_Var12;

+  __uint64 local_res8;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  

+  p_Var3 = *(_VIDSCH_NODE **)(param_1 + 0x60);

+  bVar9 = false;

+  lVar4 = *(longlong *)(p_Var3 + 0x18);

+  local_48 = 0;

+  uStack_40 = 0;

+  local_38 = 0;

+  KeAcquireInStackQueuedSpinLock(lVar4 + 0x7c0,&local_48);

+  if (*(uint *)(param_1 + 400) != param_2) {

+    uVar1 = *(uint *)(param_1 + 0x194);

+    iVar2 = *(int *)(&gulPriorityToPriorityClass + (ulonglong)param_2 * 4);

+    *(undefined4 *)(param_1 + 0x194) =

+         *(undefined4 *)(&gulPublicPriorityToSchedulingPriority + (ulonglong)param_2 * 4);

+    *(uint *)(param_1 + 400) = param_2;

+    *(undefined8 *)(param_1 + 0x1d8) = *(undefined8 *)(lVar4 + 0xb40 + (longlong)iVar2 * 8);

+    *(undefined8 *)(param_1 + 0x1e0) = *(undefined8 *)(lVar4 + 0xb70 + (longlong)iVar2 * 8);

+    if ((*(uint *)(param_1 + 0xb8) & 2) == 0) {

+      *(undefined8 *)(param_1 + 0x1b8) = *(undefined8 *)(param_1 + 0x1d8);

+    }

+    if (uVar1 != *(uint *)(param_1 + 0x194)) {

+      bVar9 = true;

+      bVar8 = false;

+      if ((*(uint *)(param_1 + 0xb8) & 1) != 0) {

+        p_Var12 = param_1 + 8;

+        lVar5 = *(longlong *)p_Var12;

+        if ((*(_VIDSCH_CONTEXT **)(lVar5 + 8) != p_Var12) ||

+           (plVar6 = *(longlong **)(param_1 + 0x10), (_VIDSCH_CONTEXT *)*plVar6 != p_Var12)) {

+LAB_0:

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

+          (*pcVar7)(3);

+          pcVar7 = (code *)swi(3);

+          (*pcVar7)();

+          return;

+        }

+        *plVar6 = lVar5;

+        *(longlong **)(lVar5 + 8) = plVar6;

+        VidSchiUpdateReadyBitsInNewPriority(p_Var3,param_1);

+        p_Var10 = p_Var3 + ((ulonglong)*(uint *)(param_1 + 0x194) + 0x89) * 0x10;

+        plVar6 = *(longlong **)(p_Var10 + 8);

+        if ((_VIDSCH_NODE *)*plVar6 != p_Var10) goto LAB_0;

+        *(_VIDSCH_NODE **)p_Var12 = p_Var10;

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

+        *plVar6 = (longlong)p_Var12;

+        *(_VIDSCH_CONTEXT **)(p_Var10 + 8) = p_Var12;

+        bVar8 = true;

+        if (*(_VIDSCH_NODE **)(p_Var3 + ((ulonglong)uVar1 + 0x89) * 0x10) ==

+            p_Var3 + ((ulonglong)uVar1 + 0x89) * 0x10) {

+          *(uint *)(p_Var3 + 0x768) = *(uint *)(p_Var3 + 0x768) & ~(1 << ((byte)uVar1 & 0x1f));

+        }

+      }

+      if ((*(uint *)(param_1 + 0xb8) & 2) != 0) {

+        *(int *)(p_Var3 + (ulonglong)*(uint *)(param_1 + 0x194) * 4 + 0x770) =

+             *(int *)(p_Var3 + (ulonglong)*(uint *)(param_1 + 0x194) * 4 + 0x770) + 1;

+        if (*(int *)(p_Var3 + (ulonglong)*(uint *)(param_1 + 0x194) * 4 + 0x770) == 1) {

+          *(uint *)(p_Var3 + 0x76c) =

+               *(uint *)(p_Var3 + 0x76c) | 1 << ((byte)*(uint *)(param_1 + 0x194) & 0x1f);

+        }

+        p_Var10 = p_Var3 + (ulonglong)uVar1 * 4 + 0x770;

+        *(int *)p_Var10 = *(int *)p_Var10 + -1;

+        if (*(int *)p_Var10 == 0) {

+          *(uint *)(p_Var3 + 0x76c) = *(uint *)(p_Var3 + 0x76c) & ~(1 << ((byte)uVar1 & 0x1f));

+        }

+        bVar8 = true;

+        if (*(_VIDSCH_CONTEXT **)(p_Var3 + (ulonglong)*(uint *)(p_Var3 + 0x630) * 8 + 0x638) ==

+            param_1) {

+          local_res8 = 0;

+          _Var11 = KeQueryPerformanceCounter(&local_res8);

+          VidSchiStopExecutionTimeAtThisPriority(p_Var3,uVar1,_Var11,local_res8);

+          VidSchiStartExecutionTimeAtThisPriority(p_Var3,*(ulong *)(param_1 + 0x194),_Var11);

+        }

+      }

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

+        if ((*(_VIDSCH_CONTEXT **)(param_1 + 0x38) == (_VIDSCH_CONTEXT *)0x0) ||

+           (p_Var12 = *(_VIDSCH_CONTEXT **)(param_1 + 0x38), (*(uint *)(param_1 + 0x70) & 0x40) != 0

+           )) {

+          p_Var12 = param_1;

+        }

+        McTemplateK0pqqtttt_EtwWriteTransfer

+                  ((ulonglong)*(byte *)(lVar4 + 0x1b96),(ulonglong)*(byte *)(lVar4 + 0x1b98),

+                   (ulonglong)*(byte *)(lVar4 + 0x1b97),p_Var12);

+      }

+      if (bVar8) {

+        *(undefined8 *)(lVar4 + 0x5c8) = _DAT_2;

+        KeSetEvent(lVar4 + 0x5a8,0,0);

+      }

+    }

+  }

+  KeReleaseInStackQueuedSpinLock(&local_48);

+  if (bVar9) {

+    VidSchiNotifyContextPriorityChange((longlong)param_1);

+  }

+  return;

 }
```

## `VidSchiProcessHwQueuePageFaultedDpc`  (modified)

```diff
--- VidSchiProcessHwQueuePageFaultedDpc
+++ VidSchiProcessHwQueuePageFaultedDpc
@@ -1,10 +1,278 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void VidSchiProcessHwQueuePageFaultedDpc(longlong param_1,undefined8 param_2,undefined8 param_3)

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

+

+void VidSchiProcessHwQueuePageFaultedDpc

+               (longlong param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong lVar1;

+  longlong lVar2;

+  _tlgProvider_t *p_Var3;

+  code *pcVar4;

+  _DXGK_PAGE_FAULT_FLAGS _Var5;

+  uint uVar6;

+  char cVar7;

+  _GUID *p_Var8;

+  ulonglong uVar9;

+  longlong lVar10;

+  undefined8 uVar11;

+  longlong lVar12;

+  longlong lVar13;

+  _GUID *p_Var14;

+  _GUID *p_Var15;

+  undefined2 uVar16;

+  longlong lVar17;

+  undefined4 uVar18;

+  _GUID *p_Var19;

+  undefined4 local_res8 [2];

+  undefined4 local_res10 [2];

+  uint local_res18 [2];

+  undefined4 local_res20 [2];

+  undefined8 in_stack_fffffffffffffe18;

+  undefined8 in_stack_fffffffffffffe28;

+  undefined4 uVar20;

+  undefined8 local_158;

+  undefined8 local_150;

+  uint local_148;

+  int local_144;

+  undefined4 local_140;

+  undefined4 local_13c;

+  undefined4 local_138 [2];

+  undefined8 local_130;

+  longlong local_128;

+  undefined8 **local_120;

+  undefined8 **ppuStack_118;

+  undefined1 local_110;

+  undefined4 local_10c;

+  longlong local_108;

+  undefined8 local_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  undefined8 local_e8;

+  longlong lStack_e0;

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  ulonglong local_c8;

+  undefined8 uStack_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  longlong lStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  AcquireSpinLock local_78 [56];

+  

+  uVar20 = (undefined4)((ulonglong)in_stack_fffffffffffffe28 >> 0x20);

+  uVar18 = (undefined4)((ulonglong)in_stack_fffffffffffffe18 >> 0x20);

+  local_f8 = *(undefined8 *)(param_1 + 0x28);

+  uStack_f0 = *(undefined8 *)(param_1 + 0x30);

+  lVar1 = *(longlong *)(param_1 + 0x20);

+  local_e8 = *(undefined8 *)(param_1 + 0x38);

+  lStack_e0 = *(longlong *)(param_1 + 0x40);

+  local_d8 = *(undefined8 *)(param_1 + 0x48);

+  uStack_d0 = *(undefined8 *)(param_1 + 0x50);

+  local_c8 = *(ulonglong *)(param_1 + 0x58);

+  uStack_c0 = *(undefined8 *)(param_1 + 0x60);

+  local_b8 = local_f8;

+  uStack_b0 = uStack_f0;

+  local_a8 = local_e8;

+  lStack_a0 = lStack_e0;

+  local_98 = local_d8;

+  uStack_90 = uStack_d0;

+  local_88 = local_c8;

+  uStack_80 = uStack_c0;

+  ExpInterlockedPushEntrySList(lVar1 + 0x2d00,param_1);

+  uVar9 = local_c8;

+  _Var5 = (_DXGK_PAGE_FAULT_FLAGS)local_c8;

+  p_Var19 = (_GUID *)(longlong)(int)(_DXGK_PAGE_FAULT_FLAGS)local_c8;

+  lVar2 = *(longlong *)(lVar1 + 0x18);

+  local_res10[0] = 0;

+  VidSchiValidatePageFaultFlags((_DXGK_PAGE_FAULT_FLAGS)local_c8);

+  p_Var15 = (_GUID *)CONCAT71((int7)((ulonglong)param_4 >> 8),1);

+  AcquireSpinLock::AcquireSpinLock(local_78,(__uint64 *)(lVar2 + 0x7c0),true,true);

+  local_res20[0] = (undefined4)uStack_d0;

+  local_158 = 0;

+  ppuStack_118 = &local_120;

+  uVar6 = (uint)uStack_80;

+  lVar17 = 0;

+  local_res8[0] = 0;

+  lVar12 = 0;

+  local_120 = &local_120;

+  local_res18[0] = (uint)((ulonglong)uStack_d0 >> 0x20);

+  p_Var14 = (_GUID *)(ulonglong)local_res18[0];

+  lVar13 = 0;

+  local_150 = uStack_f0;

+  local_110 = 0;

+  local_10c = 2;

+  local_130 = local_e8;

+  local_128 = lVar2;

+  if (((ulonglong)p_Var19 & 2) == 0) {

+    lVar10 = *(longlong *)(*(longlong *)(lStack_a0 + 0x28) + 0x28);

+LAB_0:

+    lVar13 = *(longlong *)(lVar10 + 8);

+    p_Var15 = (_GUID *)0x0;

+    lVar12 = *(longlong *)(lVar13 + 0x28);

+    local_res10[0] = *(undefined4 *)(lVar13 + 200);

+    local_158 = *(undefined8 *)(lVar12 + 0xa60);

+    lVar17 = *(longlong *)(lVar12 + 0xa58);

+    local_res8[0] = *(undefined4 *)(lVar10 + 0x54);

+    *(uint *)(lVar13 + 0xdc) = local_res18[0];

+    p_Var14 = (_GUID *)&DAT_1;

+    *(undefined8 *)(lVar13 + 0xd0) = local_e8;

+    *(undefined4 *)(lVar13 + 0xd8) = local_res20[0];

+    *(_DXGK_PAGE_FAULT_FLAGS *)(lVar13 + 0xe0) = _Var5;

+    *(undefined8 *)(lVar13 + 0xe8) = uStack_f0;

+    *(uint *)(lVar13 + 0xe4) = (uint)uStack_80;

+    VidSchiMarkDeviceAsError

+              ((HwQueueStagingList *)&local_128,lVar13,&DAT_1,(undefined4 *)0x0);

+  }

+  else {

+    if ((uVar9 & 0x40) != 0) {

+      lVar10 = *(longlong *)(lStack_a0 + 8);

+      goto LAB_0;

+    }

+    if ((uVar9 & 0xc) == 0) {

+      *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+      p_Var14 = (_GUID *)0xd;

+      lVar10 = lStack_a0;

+      WdLogSingleEntry5(0,0x119,0xd,p_Var19,lStack_a0,uStack_b0);

+      uVar18 = (undefined4)((ulonglong)lVar10 >> 0x20);

+      _WdLogGlobalForLineNumber = 0x38a;

+      p_Var15 = p_Var19;

+    }

+    if ((char)uVar9 < '\0') {

+      local_158 = *(undefined8 *)(lStack_a0 + 0x28);

+      lVar17 = *(longlong *)(lStack_a0 + 0x60);

+      lVar12 = *(longlong *)(lStack_a0 + 0x18);

+    }

+  }

+  if (g_PageFaultDebugMode == 0) {

+    cVar7 = KdRefreshDebuggerNotPresent();

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

+      if (lVar12 == 0) {

+        uVar11 = 0;

+      }

+      else {

+        uVar11 = *(undefined8 *)(lVar12 + 0xa60);

+      }

+      DbgPrintEx(0x65,0,

+                 "\nThe GPU Scheduler detected a HW queue page fault at GPU VA 0x%I64X.\nWe broke into the debugger to allow a chance for debugging this issue.\nRun \"!dxgkdx.gpuva -a %d -p 0x%p -o %d 0x%I64X[ -h]\" command for more info.\nTo disable debug breaks on page fault, run \"?? dxgmms2!g_PageFaultDebugMode=1\" command,\nor \"ed 0x%p 1\"\n\n"

+                 ,local_150,CONCAT44(uVar18,(uint)*(ushort *)(lVar1 + 6)),uVar11,

+                 CONCAT44(uVar20,*(undefined4 *)(lVar2 + 4)),local_150,&g_PageFaultDebugMode);

+      pcVar4 = (code *)swi(3);

+      (*pcVar4)();

+      return;

+    }

+  }

+  if ((uVar9 & 4) == 0) {

+    if ((uVar9 & 8) == 0) {

+      uVar18 = 5;

+      goto LAB_2;

+    }

+    uVar18 = 4;

+    if (*(int *)(lVar1 + 0x86c) != 0) goto LAB_2;

+    p_Var14 = (_GUID *)(lVar1 + 0x874);

+    if (lVar17 == 0) {

+LAB_3:

+      *p_Var14 = (_GUID)0x0;

+    }

+    else {

+      lVar12 = 0xf;

+      p_Var15 = (_GUID *)(lVar17 - (longlong)p_Var14);

+      p_Var19 = p_Var14;

+      do {

+        if ((lVar12 == -0x7fffffef) || (p_Var15[(longlong)p_Var19] == (_GUID)0x0)) break;

+        *p_Var19 = p_Var15[(longlong)p_Var19];

+        p_Var19 = p_Var19 + 1;

+        lVar12 = lVar12 + -1;

+      } while (lVar12 != 0);

+      p_Var8 = p_Var19 + -1;

+      if (lVar12 != 0) {

+        p_Var8 = p_Var19;

+      }

+      *p_Var8 = (_GUID)0x0;

+      if (lVar12 == 0) goto LAB_3;

+    }

+    *(undefined4 *)(lVar1 + 0x884) = local_res8[0];

+    *(undefined8 *)(lVar1 + 0x888) = local_158;

+    *(undefined4 *)(lVar1 + 0x86c) = 1;

+    uVar9 = Feature_ProcessDebugBlobCollection__private_IsEnabledDeviceUsageNoInline();

+    if (((int)uVar9 != 0) && (uVar18 = 4, lVar13 != 0)) {

+      LOCK();

+      *(longlong *)(lVar13 + 0x18) = *(longlong *)(lVar13 + 0x18) + 1;

+      UNLOCK();

+      *(longlong *)(lVar1 + 0x590) = lVar13;

+    }

+    goto LAB_2;

+  }

+  if (*(int *)(lVar1 + 0x870) == 0) {

+    p_Var14 = (_GUID *)(lVar2 + 0xcc5);

+    if (lVar17 == 0) {

+LAB_4:

+      *p_Var14 = (_GUID)0x0;

+    }

+    else {

+      lVar12 = 0xf;

+      p_Var15 = (_GUID *)(lVar17 - (longlong)p_Var14);

+      p_Var19 = p_Var14;

+      do {

+        if ((lVar12 == -0x7fffffef) || (p_Var15[(longlong)p_Var19] == (_GUID)0x0)) break;

+        *p_Var19 = p_Var15[(longlong)p_Var19];

+        p_Var19 = p_Var19 + 1;

+        lVar12 = lVar12 + -1;

+      } while (lVar12 != 0);

+      p_Var8 = p_Var19 + -1;

+      if (lVar12 != 0) {

+        p_Var8 = p_Var19;

+      }

+      *p_Var8 = (_GUID)0x0;

+      if (lVar12 == 0) goto LAB_4;

+    }

+    *(undefined4 *)(lVar2 + 0xcd4) = local_res8[0];

+    *(undefined4 *)(lVar1 + 0x870) = 1;

+  }

+  uVar18 = 3;

+LAB_2:

+  uVar16 = 3;

+  if (5 < DAT_5) {

+    cVar7 = _tlgKeywordOn(0x140080048,0x400000000010);

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

+      p_Var3 = *(_tlgProvider_t **)(lVar2 + 0x10);

+      local_100 = local_158;

+      local_148 = uVar6 & 1;

+      local_158 = CONCAT44(local_158._4_4_,uVar18);

+      local_140 = local_88._4_4_;

+      local_13c = local_98._4_4_;

+      local_138[0] = (undefined4)local_98;

+      local_f8 = local_150;

+      local_e8 = local_b8;

+      local_150 = CONCAT44(local_150._4_4_,_Var5);

+      local_144 = (int)uVar6 >> 1;

+      local_d8 = *(undefined8 *)(p_Var3 + 0x7a0);

+      local_c8 = *(ulonglong *)(p_Var3 + 0x19c);

+      local_res8[0] = CONCAT22(local_res8[0]._2_2_,uVar16);

+      local_108 = lVar17;

+      _tlgWriteTemplate<long___cdecl(_tlgProvider_t_const*___ptr64,void_const*___ptr64,_GUID_const*___ptr64,_GUID_const*___ptr64,unsigned_int,_EVENT_DATA_DESCRIPTOR*___ptr64),&long___cdecl__tlgWriteTransfer_EtwWriteTransfer(struct__tlgProvider_t_const*___ptr64,void_const*___ptr64,struct__GUID_const*___ptr64,struct__GUID_const*___ptr64,unsigned_int,struct__EVENT_DATA_DESCRIPTOR*___ptr64),_GUID_const*___ptr64,_GUID_const*___ptr64>

+      ::

+      Write<_tlgWrapperByVal<2>,_tlgWrapperByVal<8>,_tlgWrapBuffer<_UNICODE_STRING>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapSz<char>,_tlgWrapperByVal<4>_>

+                (p_Var3,&DAT_6,p_Var14,p_Var15,(_tlgWrapperByVal<2> *)local_res8,

+                 (_tlgWrapperByVal<8> *)&local_c8,(_tlgWrapBuffer<_UNICODE_STRING> *)&local_d8,

+                 (_tlgWrapperByVal<4> *)&local_158,(_tlgWrapperByVal<8> *)&local_e8,

+                 (_tlgWrapperByVal<8> *)&local_130,(_tlgWrapperByVal<4> *)local_res20,

+                 (_tlgWrapperByVal<4> *)local_res18,(_tlgWrapperByVal<4> *)&local_150,

+                 (_tlgWrapperByVal<8> *)&local_f8,(_tlgWrapperByVal<4> *)local_138,

+                 (_tlgWrapperByVal<4> *)&local_13c,(_tlgWrapperByVal<4> *)&local_140,

+                 (_tlgWrapperByVal<4> *)&local_144,(_tlgWrapperByVal<4> *)&local_148,

+                 (_tlgWrapperByVal<8> *)&local_100,(_tlgWrapSz<char> *)&local_108,

+                 (_tlgWrapperByVal<4> *)local_res10);

+    }

+  }

+  *(undefined8 *)(lVar2 + 0x5c8) = _DAT_7;

+  KeSetEvent(lVar2 + 0x5a8,0,0);

+  HwQueueStagingList::~HwQueueStagingList((HwQueueStagingList *)&local_128);

+  AcquireSpinLock::Release(local_78);

+  return;

 }
```

## `VidSchiExecuteMmIoFlipAtPassiveLevel`  (modified)

```diff
--- VidSchiExecuteMmIoFlipAtPassiveLevel
+++ VidSchiResetEngine
@@ -1,391 +1,467 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

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

 

-void VidSchiExecuteMmIoFlipAtPassiveLevel(undefined8 *param_1)

+bool VidSchiResetEngine(_VIDSCH_NODE *param_1,undefined8 param_2)

 

 {

-  uint uVar1;

-  uint uVar2;

-  _VIDSCH_GLOBAL *p_Var3;

-  VIDSCH_FLIP_QUEUE *pVVar4;

-  _VIDSCH_PRESENT_INFO *p_Var5;

-  _VIDSCH_GLOBAL *p_Var6;

-  _VIDSCH_GLOBAL *p_Var7;

-  _VIDSCH_FLIP_STATUS _Var8;

-  bool bVar9;

-  long lVar10;

-  int iVar11;

-  _VIDSCH_GLOBAL *p_Var12;

-  uint uVar13;

-  uint uVar14;

-  _VIDSCH_GLOBAL *p_Var15;

-  AcquireSpinLock *this;

-  uint uVar16;

-  ulonglong uVar17;

-  _VIDSCH_FLIP_QUEUE_ENTRY *p_Var18;

-  ulonglong uVar19;

-  ulonglong uVar20;

-  longlong lVar21;

-  undefined8 uVar22;

-  longlong lVar23;

-  ulonglong uVar24;

-  undefined1 auStackY_aa8 [32];

-  byte local_a48 [4];

-  int local_a44;

-  _VIDSCH_FLIP_STATUS local_a40 [2];

-  _VIDSCH_FLIP_QUEUE_ENTRY *local_a38;

-  _VIDSCH_GLOBAL *local_a30;

-  uint ******local_a28;

-  uint ******ppppppuStack_a20;

-  uint local_a18;

-  uint local_a14;

-  uint local_a10;

-  int local_a08;

-  int local_a04;

-  _VIDSCH_GLOBAL *local_a00;

-  undefined8 ******local_9f8;

-  undefined8 ******ppppppuStack_9f0;

-  undefined1 local_9e8;

-  undefined4 local_9e4;

-  undefined8 local_9e0;

-  _VIDSCH_GLOBAL *local_9d8;

-  undefined8 local_9d0;

-  uint local_9c8;

-  undefined4 local_9c4;

-  VIDSCH_FLIP_QUEUE *local_9c0;

-  uint local_9b8;

-  undefined4 local_9b4;

-  undefined8 local_9b0;

-  undefined8 local_9a8;

-  undefined8 local_9a0;

-  undefined8 local_998;

-  undefined8 local_990;

-  int local_988 [4];

-  AcquireSpinLock local_978 [40];

-  AcquireSpinLock local_950 [40];

-  longlong local_928;

-  _DXGKARG_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY3 local_920 [4];

-  uint local_91c;

-  uint local_918;

-  undefined8 local_b8;

-  undefined8 uStack_b0;

-  undefined8 local_a8;

-  undefined8 uStack_a0;

+  _VIDSCH_NODE *p_Var1;

+  char *pcVar2;

+  uint *puVar3;

+  longlong lVar4;

+  _VIDSCH_CONTEXT *p_Var5;

+  longlong lVar6;

+  longlong lVar7;

+  _tlgProvider_t *p_Var8;

+  _TDR_RECOVERY_CONTEXT _Var9;

+  char cVar10;

+  undefined4 uVar11;

+  long lVar12;

+  longlong lVar13;

+  _TDR_RECOVERY_CONTEXT *p_Var14;

+  ulonglong uVar15;

+  __uint64 _Var16;

+  undefined8 uVar17;

+  longlong *plVar18;

+  _TDR_RECOVERY_CONTEXT *p_Var19;

+  char *pcVar20;

+  uint uVar21;

+  _TDR_RECOVERY_CONTEXT *p_Var22;

+  char *pcVar23;

+  undefined8 uVar24;

+  longlong *plVar25;

+  longlong lVar26;

+  _VIDSCH_NODE _Var27;

+  _TDR_RECOVERY_CONTEXT *p_Var28;

+  _GUID *p_Var29;

+  _GUID *p_Var30;

+  int iVar31;

+  undefined4 *_Dst;

+  bool bVar32;

+  undefined1 auStackY_1e8 [32];

+  char local_168 [2];

+  undefined2 local_166;

+  uint local_164;

+  int local_160;

+  undefined4 local_15c;

+  undefined4 local_158;

+  long local_154;

+  uint local_150;

+  uint local_14c;

+  undefined4 local_148;

+  undefined4 local_144;

+  undefined4 local_140 [2];

+  _GUID *local_138;

+  _VIDSCH_NODE *local_130;

+  longlong lStack_128;

+  _GUID *local_120;

+  undefined8 uStack_118;

+  _GUID *local_110;

+  _GUID *p_Stack_108;

+  undefined8 local_100;

+  _TDR_RECOVERY_CONTEXT *local_f8;

+  undefined8 local_f0;

+  undefined8 local_e8;

+  undefined8 local_e0;

+  undefined8 local_d8;

+  _TDR_RECOVERY_CONTEXT *local_d0;

+  undefined8 local_c8;

+  undefined8 local_c0;

+  _TDR_RECOVERY_CONTEXT *local_b8;

+  undefined8 local_b0;

+  _TDR_RECOVERY_CONTEXT *local_a8;

+  undefined8 local_a0;

   undefined8 local_98;

-  undefined1 local_88 [80];

-  ulonglong local_38;

+  undefined8 local_90;

+  undefined8 local_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  uint local_40;

+  uint local_3c;

+  uint local_38;

+  ulonglong local_30;

   

-  local_38 = __security_cookie ^ (ulonglong)auStackY_aa8;

-  p_Var3 = (_VIDSCH_GLOBAL *)*param_1;

-  local_a48[0] = *(byte *)(param_1 + 3);

-  uVar1 = *(uint *)((longlong)param_1 + 0xc);

-  uVar19 = (ulonglong)uVar1;

-  uVar2 = *(uint *)(param_1 + 1);

-  uVar24 = (ulonglong)uVar2;

-  if (*(int *)(p_Var3 + 0xcac) != 0) {

-    WdLogSingleEntry2(3,p_Var3,uVar19);

-    _WdLogGlobalForLineNumber = 0x104f;

-    return;

-  }

-  pVVar4 = (VIDSCH_FLIP_QUEUE *)param_1[2];

-  p_Var5 = *(_VIDSCH_PRESENT_INFO **)(p_Var3 + uVar19 * 8 + 0xd68);

-  lVar23 = uVar24 * 0x578;

-  p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

-  local_a38 = p_Var18;

-  memset(&local_928,0,0x870);

-  memset(local_88,0,0x50);

-  local_98 = 0;

-  local_988[0] = 0;

-  local_988[1] = 0;

-  local_988[2] = 0;

-  local_988[3] = 0;

-  local_b8 = 0;

-  uStack_b0 = 0;

-  local_a8 = 0;

-  uStack_a0 = 0;

-  AcquireSpinLock::AcquireSpinLock(local_978,(__uint64 *)(p_Var3 + 0x7c0),true,false);

-  uVar20 = uVar19;

-  VidSchiSetupMmIoFlipMultiPlaneOverlay3

-            (p_Var3,(longlong)p_Var18,uVar1,&local_928,local_a48[0],(longlong)local_88,local_988,

-             (undefined4 *)&local_b8);

-  AcquireSpinLock::Release(local_978);

-  local_91c = local_91c | 8;

-  lVar10 = ADAPTER_DISPLAY::DdiSetVidPnSourceAddressWithMultiPlaneOverlay3

-                     (*(ADAPTER_DISPLAY **)(*(longlong *)(local_928 + 0x10) + 0xc48),local_920);

-  if (lVar10 == -0x3ffffdd3) {

-    uVar13 = local_918 >> 1 & 1;

-    if (uVar13 != 0) {

-      if (Microsoft_Windows_DxgKrnlEnableBits < '\0') {

-        McTemplateK0pqqtq_EtwWriteTransfer

-                  ((ulonglong)uVar13,0xffffffffc000022d,uVar20,*(undefined8 *)(p_Var3 + 0x10));

-      }

-      AcquireSpinLock::AcquireSpinLock

-                ((AcquireSpinLock *)&local_9d8,(__uint64 *)(p_Var3 + 0x7c0),true,false);

-      ppppppuStack_a20 = (uint ******)&local_a28;

-      local_a28 = (uint ******)&local_a28;

-      local_a18 = local_a18 & 0xffffff00;

-      local_a14 = 2;

-      if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x10) == 0) {

-        uVar13 = (1 << ((byte)*(undefined4 *)(p_Var3 + 0x98) & 0x1f)) - 1;

-      }

-      else {

-        uVar13 = (**(uint **)(pVVar4 + lVar23 + 0x520) >> 10 | **(uint **)(pVVar4 + lVar23 + 0x520))

-                 & 0x3ff;

-      }

-      *(uint *)(p_Var5 + 0xcb4) = *(uint *)(p_Var5 + 0xcb4) & ~uVar13;

-      uVar13 = *(uint *)(pVVar4 + lVar23 + 0x4f8);

-      *(undefined4 *)(pVVar4 + lVar23 + 0x494) = 0xe;

-      uVar14 = (local_918 & 1) << 0x10;

-      *(uint *)(pVVar4 + lVar23 + 0x4f8) = uVar14 | uVar13 & 0xfffeffff;

-      uVar16 = (local_918 & 4) << 0xf;

-      *(uint *)(pVVar4 + lVar23 + 0x4f8) = uVar16 | uVar14 | uVar13 & 0xfffcffff;

-      *(uint *)(pVVar4 + lVar23 + 0x4f8) =

-           (local_918 & 8) << 0xf | uVar16 | uVar14 | uVar13 & 0xfff8ffff;

-      local_a30 = p_Var3;

-      VidSchiUpdateFlipQueueHistory(5,p_Var3,uVar1,pVVar4,uVar2);

-      if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x11 & 1) != 0) {

-        if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x12 & 1) == 0) {

-          *(_VIDSCH_FLIP_QUEUE_ENTRY **)(p_Var5 + 0x78) = p_Var18;

-        }

-        else {

-          *(_VIDSCH_FLIP_QUEUE_ENTRY **)(p_Var3 + 0xec8) = p_Var18;

-        }

-        if (pVVar4[0x50] != (VIDSCH_FLIP_QUEUE)0x0) {

-          if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x12 & 1) == 0) {

-            VidSchiCancelAndRequeueIndependentFlips(p_Var3,uVar1);

-          }

-          else {

-            uVar19 = 0;

-            p_Var18 = local_a38;

-            if (*(int *)(p_Var3 + 0x28) != 0) {

-              do {

-                if ((*(longlong *)(p_Var3 + uVar19 * 8 + 0xd68) != 0) &&

-                   (*(int *)(*(longlong *)(p_Var3 + uVar19 * 8 + 0xd68) + 0xcb0) != 0)) {

-                  VidSchiCancelAndRequeueIndependentFlips(p_Var3,(uint)uVar19);

-                }

-                uVar13 = (uint)uVar19 + 1;

-                uVar19 = (ulonglong)uVar13;

-                p_Var18 = local_a38;

-              } while (uVar13 < *(uint *)(p_Var3 + 0x28));

+  local_30 = __security_cookie ^ (ulonglong)auStackY_1e8;

+  uVar17 = *(undefined8 *)(param_1 + 0x40);

+  uVar24 = *(undefined8 *)(param_1 + 0xa8);

+  WdLogSingleEntry3(4,uVar24,uVar17,*(undefined8 *)(param_1 + 0x60));

+  lVar4 = *(longlong *)(param_1 + 0x18);

+  p_Var14 = (_TDR_RECOVERY_CONTEXT *)0x0;

+  _WdLogGlobalForLineNumber = 0x46c1;

+  if (*(int *)(param_1 + 0xbd4) != 0) {

+    LOCK();

+    *(int *)(lVar4 + 0x314) = *(int *)(lVar4 + 0x314) + 1;

+    UNLOCK();

+    LOCK();

+    p_Var1 = param_1 + 0xbd8;

+    iVar31 = *(int *)p_Var1;

+    *(int *)p_Var1 = *(int *)p_Var1 + 1;

+    UNLOCK();

+    if (iVar31 == 0) {

+      *(undefined8 *)(param_1 + 0xe8) = 0;

+      VidSchiSubmitPreemptionCommand((longlong)param_1,uVar24,uVar17);

+    }

+    else {

+      LOCK();

+      *(int *)(param_1 + 0xbd8) = *(int *)(param_1 + 0xbd8) + -1;

+      UNLOCK();

+      LOCK();

+      *(int *)(lVar4 + 0x314) = *(int *)(lVar4 + 0x314) + -1;

+      UNLOCK();

+    }

+  }

+  local_80 = 0;

+  uStack_78 = 0;

+  local_70 = 0;

+  KeAcquireInStackQueuedSpinLock(lVar4 + 0x7c0,&local_80);

+  local_168[1] = 0;

+  lStack_128 = 0;

+  local_100 = 0;

+  local_120 = (_GUID *)0x0;

+  uStack_118 = 0;

+  local_110 = (_GUID *)0x0;

+  p_Stack_108 = (_GUID *)0x0;

+  p_Var30 = (_GUID *)(ulonglong)*(uint *)(lVar4 + 0x20);

+  local_130 = param_1;

+  DpSynchronizeExecution(*(undefined8 *)(lVar4 + 0x18),VidSchiSetNodeResettingStateAtISR,&local_130)

+  ;

+  lVar13 = lStack_128;

+  p_Var29 = (_GUID *)0x70;

+  _Dst = (undefined4 *)((ulonglong)*(uint *)(param_1 + 0xc4) * 0x70 + *(longlong *)(param_1 + 0xb8))

+  ;

+  memset(_Dst,0,0x70);

+  *(uint *)(param_1 + 0xc4) = *(int *)(param_1 + 0xc0) - 1U & *(int *)(param_1 + 0xc4) + 1U;

+  if (lVar13 == 0) {

+    lVar13 = KeQueryPerformanceCounter(0);

+  }

+  *(longlong *)(_Dst + 2) = lVar13;

+  KeReleaseInStackQueuedSpinLock(&local_80);

+  KeFlushQueuedDpcs();

+  *_Dst = 6;

+  *(_GUID **)(_Dst + 4) = local_120;

+  *(undefined8 *)(_Dst + 6) = uStack_118;

+  *(_GUID **)(_Dst + 8) = local_110;

+  _Dst[0xc] = (uint)local_100;

+  _Dst[0xd] = local_100._4_4_;

+  if (((uint)local_100 == local_100._4_4_) && (*(int *)(param_1 + 0x86c) == 0)) {

+    if (*(int *)(param_1 + 0xbd4) != 0) {

+      p_Var30 = (_GUID *)(ulonglong)local_100._4_4_;

+      *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+      WdLogSingleEntry5(0,0x119,0x800);

+      _WdLogGlobalForLineNumber = 0x38a;

+    }

+    WdLogSingleEntry2(4,*(undefined8 *)(param_1 + 0x40),*(undefined8 *)(param_1 + 0x60));

+    bVar32 = true;

+    p_Stack_108 = local_120;

+    *(undefined1 *)((longlong)_Dst + 0x3d) = 0;

+    _WdLogGlobalForLineNumber = 0x470c;

+  }

+  else {

+    if (*(_VIDSCH_NODE **)(lVar4 + 0xcb8) == param_1) {

+      p_Var14 = (_TDR_RECOVERY_CONTEXT *)TdrCreateRecoveryContext();

+      *(_TDR_RECOVERY_CONTEXT **)(lVar4 + 0xcb0) = p_Var14;

+      if (p_Var14 != (_TDR_RECOVERY_CONTEXT *)0x0) {

+        p_Var14[0xb69] = (_TDR_RECOVERY_CONTEXT)0x1;

+        _Var27 = (_VIDSCH_NODE)0x0;

+        uVar15 = Feature_ProcessDebugBlobCollection__private_IsEnabledDeviceUsageNoInline();

+        if ((int)uVar15 != 0) {

+          _Var27 = param_1[0x86a];

+        }

+        if ((*(int *)(param_1 + 0x86c) == 0) || (uVar11 = 0xc, _Var27 != (_VIDSCH_NODE)0x0)) {

+          uVar11 = 6;

+        }

+        *(undefined4 *)(p_Var14 + 0x10) = uVar11;

+        *(longlong *)(p_Var14 + 8) = lVar4 + 0xcac;

+        *(undefined8 *)(p_Var14 + 0xaf0) = param_2;

+        lVar13 = *(longlong *)(lVar4 + 0x10);

+        *(longlong *)(p_Var14 + 0x20) = lVar13;

+        LOCK();

+        plVar25 = (longlong *)(lVar13 + 0x18);

+        *plVar25 = *plVar25 + 1;

+        UNLOCK();

+        *(undefined8 *)(p_Var14 + 0x28) = 0xffffffffffffffff;

+        *(undefined4 *)(p_Var14 + 0x90) = 0x11007;

+        uVar11 = DpiGetDriverVersion(*(undefined8 *)(*(longlong *)(p_Var14 + 0x20) + 0xd8));

+        *(undefined4 *)(p_Var14 + 0x94) = uVar11;

+        *(uint *)(p_Var14 + 0x38) = (uint)*(ushort *)(*(longlong *)(lVar4 + 0xcb8) + 4);

+        _Var16 = DXGADAPTER::GetDbgOwnerTag(*(DXGADAPTER **)(p_Var14 + 0x20));

+        *(__uint64 *)(p_Var14 + 0x68) = _Var16;

+        uVar15 = Feature_ProcessDebugBlobCollection__private_IsEnabledDeviceUsageNoInline();

+        if ((int)uVar15 != 0) {

+          uVar17 = TdrCreateProcessDebugBlobState();

+          *(undefined8 *)(p_Var14 + 0xb70) = uVar17;

+        }

+        if (*(int *)(p_Var14 + 0x10) == 6) {

+          local_68 = 0;

+          uStack_60 = 0;

+          local_48 = 0;

+          local_58 = 0;

+          uStack_50 = 0;

+          VidSchiCollectTdrPayloadEngineTimeout

+                    (param_1,(_DXGK_TDR_PAYLOAD_ENGINE_TIMEOUT *)&local_68);

+          p_Var29 = (_GUID *)0x28;

+          TdrCollectDbgInfoStage1(*(undefined8 *)(lVar4 + 0xcb0),1,0x28,&local_68);

+          p_Var5 = *(_VIDSCH_CONTEXT **)

+                    (param_1 + (ulonglong)*(uint *)(param_1 + 0x630) * 8 + 0x638);

+          if (p_Var5 != (_VIDSCH_CONTEXT *)0x0) {

+            if (p_Var5[0x38e] == (_VIDSCH_CONTEXT)0x0) {

+              WdLogSingleEntry1(3,p_Var5);

+              _WdLogGlobalForLineNumber = 0x46b3;

+            }

+            else {

+              VidSchiDecrementContextReference(p_Var5,1);

+              p_Var5[0x38e] = (_VIDSCH_CONTEXT)0x0;

             }

           }

         }

-      }

-      VidSchiKeepInterruptTargetEnabledForFlip(p_Var3,p_Var18,p_Var5);

-      if ((p_Var3[0x1b9d] != (_VIDSCH_GLOBAL)0x0) && (uVar2 != *(uint *)(pVVar4 + 0x40))) {

-        WdLogSingleEntry3(4,pVVar4,uVar24,*(uint *)(pVVar4 + 0x40));

-        _WdLogGlobalForLineNumber = 0x10d9;

-        *(uint *)(pVVar4 + 0x40) = uVar2;

-        VidSchiUpdateFlipQueueHistory(6,p_Var3,uVar1,pVVar4,uVar2);

-      }

-      HwQueueStagingList::~HwQueueStagingList((HwQueueStagingList *)&local_a30);

-      this = (AcquireSpinLock *)&local_9d8;

-      goto LAB_0;

-    }

-LAB_1:

-    *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

-    WdLogSingleEntry5(0,0x119,0xb);

-    _WdLogGlobalForLineNumber = 0x38a;

-  }

-  else if (lVar10 != 0) goto LAB_1;

-  AcquireSpinLock::AcquireSpinLock(local_950,(__uint64 *)(p_Var3 + 0x7c0),true,false);

-  ppppppuStack_9f0 = &local_9f8;

-  lVar21 = 0;

-  local_9e4 = 2;

-  local_9e8 = 0;

-  local_9f8 = &local_9f8;

-  uVar22 = 0x3ff;

-  uVar13 = 0x3ff;

-  local_a00 = p_Var3;

-  if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x1000) == 0) {

-    local_a28 = *(uint *******)(pVVar4 + lVar23 + 0x520);

-    uVar13 = *(uint *)local_a28;

-    uVar14 = uVar13 & 0x3ff;

-    uVar16 = 0;

-    if (p_Var3[0x9c] != (_VIDSCH_GLOBAL)0x0) {

-      uVar16 = uVar13 >> 10 & 0x3ff;

-    }

-    local_a08 = 0;

-    if (uVar14 != 0) {

-      for (; (uVar14 >> local_a08 & 1) == 0; local_a08 = local_a08 + 1) {

-      }

-    }

-    ppppppuStack_a20 = (uint ******)(CONCAT44(uVar16,uVar13) & 0xffffffff000003ff);

-    iVar11 = -1;

-    if (uVar14 != 0) {

-      iVar11 = local_a08;

-    }

-    local_a18 = 0;

-    local_a04 = 0;

-    if (uVar16 != 0) {

-      for (; (uVar16 >> local_a04 & 1) == 0; local_a04 = local_a04 + 1) {

-      }

-    }

-    local_a14 = (uint)(char)iVar11;

-    uVar20 = (ulonglong)local_a14;

-    iVar11 = -1;

-    if (uVar16 != 0) {

-      iVar11 = local_a04;

-    }

-    local_a10 = (uint)(char)iVar11;

-    uVar17 = (ulonglong)local_a10;

-    local_a30 = p_Var3;

-    bVar9 = VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::end

-                      ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

-    uVar13 = (uint)uVar22;

-    if (!bVar9) {

-      while( true ) {

-        if ((uint)uVar20 < (uint)uVar17) {

-          uVar17 = uVar20;

-        }

-        *(undefined8 *)

-         ((uVar17 & 0xffffffff) * 0x130 + 0x188 + *(longlong *)(p_Var3 + uVar19 * 8 + 0xd68)) =

-             *(undefined8 *)

-              ((ulonglong)

-               ((*(int *)(*(longlong *)(pVVar4 + lVar23 + 0x520) + 8) * 8 + 0xe0) * local_a18) +

-               0x18 + *(longlong *)(pVVar4 + lVar23 + 0x520));

-        VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::operator++

-                  ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

-        bVar9 = VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::end

-                          ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

-        uVar13 = (uint)uVar22;

-        lVar21 = 0;

-        if (bVar9) break;

-        uVar17 = (ulonglong)local_a10;

-        uVar20 = (ulonglong)local_a14;

-      }

-    }

-  }

-  if (p_Var3[0x3b] != SUB81(lVar21,0)) {

-    uVar22 = KeQueryPerformanceCounter(0);

-    *(undefined8 *)(pVVar4 + lVar23 + 0x5a8) = uVar22;

-    uVar13 = 0x3ff;

-    lVar21 = 0;

-  }

-  p_Var15 = *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x520);

-  if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x10) == 0) {

-    p_Var15 = (_VIDSCH_GLOBAL *)(ulonglong)*(uint *)(p_Var3 + 0x98);

-    uVar13 = (1 << ((byte)*(uint *)(p_Var3 + 0x98) & 0x1f)) - 1;

+        else {

+          VidSchiCollectTdrPayloadEnginePageFault(param_1,p_Var14);

+          p_Var29 = (_GUID *)0x0;

+          TdrCollectDbgInfoStage1(*(undefined8 *)(lVar4 + 0xcb0),1,0,0);

+        }

+      }

+    }

+    p_Var30 = (_GUID *)(ulonglong)*(ushort *)(param_1 + 4);

+    iVar31 = *(int *)(param_1 + 0x1fc) + 1;

+    local_38 = 0;

+    *(int *)(param_1 + 0x1fc) = iVar31;

+    plVar25 = *(longlong **)(lVar4 + 0x2b0);

+    bVar32 = *(uint *)(lVar4 + 0x2f8) <= (uint)*(ushort *)(param_1 + 4);

+    plVar18 = plVar25 + (longlong)p_Var30;

+    if (bVar32) {

+      plVar18 = plVar25;

+    }

+    local_3c = (uint)*(ushort *)(*plVar18 + 6);

+    if (!bVar32) {

+      plVar25 = plVar25 + (longlong)p_Var30;

+    }

+    local_40 = (uint)*(ushort *)(*plVar25 + 8);

+    if ((5 < DAT_0) && (cVar10 = _tlgKeywordOn(0x140080048,0x400000000010), cVar10 != '\0'))

+    {

+      local_f0 = *(undefined8 *)(param_1 + 0x60);

+      p_Var8 = *(_tlgProvider_t **)(lVar4 + 0x10);

+      local_88 = *(undefined8 *)(param_1 + 0x40);

+      local_e8 = *(undefined8 *)(param_1 + 0xa8);

+      local_15c = SUB84(p_Var30,0);

+      local_e0 = *(undefined8 *)(p_Var8 + 0x7a0);

+      local_d8 = *(undefined8 *)(p_Var8 + 0x19c);

+      local_160 = iVar31;

+      local_f8 = p_Var14;

+      _tlgWriteTemplate<long___cdecl(_tlgProvider_t_const*___ptr64,void_const*___ptr64,_GUID_const*___ptr64,_GUID_const*___ptr64,unsigned_int,_EVENT_DATA_DESCRIPTOR*___ptr64),&long___cdecl__tlgWriteTransfer_EtwWriteTransfer(struct__tlgProvider_t_const*___ptr64,void_const*___ptr64,struct__GUID_const*___ptr64,struct__GUID_const*___ptr64,unsigned_int,struct__EVENT_DATA_DESCRIPTOR*___ptr64),_GUID_const*___ptr64,_GUID_const*___ptr64>

+      ::

+      Write<_tlgWrapperByVal<8>,_tlgWrapBuffer<_UNICODE_STRING>,_tlgWrapperByVal<8>,_tlgWrapperByVal<8>,_tlgWrapperByVal<8>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>_>

+                (p_Var8,&DAT_1,p_Var29,p_Var30,(_tlgWrapperByVal<8> *)&local_d8,

+                 (_tlgWrapBuffer<_UNICODE_STRING> *)&local_e0,(_tlgWrapperByVal<8> *)&local_e8,

+                 (_tlgWrapperByVal<8> *)&local_88,(_tlgWrapperByVal<8> *)&local_f0,

+                 (_tlgWrapperByVal<8> *)&local_f8,(_tlgWrapperByVal<4> *)&local_15c,

+                 (_tlgWrapperByVal<4> *)&local_160);

+    }

+    lVar12 = ADAPTER_RENDER::DdiResetEngine

+                       (*(ADAPTER_RENDER **)(lVar4 + 8),(_DXGKARG_RESETENGINE *)&local_40);

+    bVar32 = lVar12 == 0;

+    if (bVar32) {

+      *(undefined4 *)(param_1 + 0x10) = 2;

+    }

+    *(undefined1 *)((longlong)_Dst + 0x3d) = 1;

+    _Dst[0xe] = lVar12;

+    if ((5 < DAT_0) && (cVar10 = _tlgKeywordOn(0x140080048,0x400000000010), cVar10 != '\0'))

+    {

+      local_158 = *(undefined4 *)(param_1 + 0x1fc);

+      p_Var8 = *(_tlgProvider_t **)(lVar4 + 0x10);

+      local_150 = local_38;

+      local_c8 = *(undefined8 *)(p_Var8 + 0x7a0);

+      local_c0 = *(undefined8 *)(p_Var8 + 0x19c);

+      local_154 = lVar12;

+      local_d0 = p_Var14;

+      _tlgWriteTemplate<long___cdecl(_tlgProvider_t_const*___ptr64,void_const*___ptr64,_GUID_const*___ptr64,_GUID_const*___ptr64,unsigned_int,_EVENT_DATA_DESCRIPTOR*___ptr64),&long___cdecl__tlgWriteTransfer_EtwWriteTransfer(struct__tlgProvider_t_const*___ptr64,void_const*___ptr64,struct__GUID_const*___ptr64,struct__GUID_const*___ptr64,unsigned_int,struct__EVENT_DATA_DESCRIPTOR*___ptr64),_GUID_const*___ptr64,_GUID_const*___ptr64>

+      ::

+      Write<_tlgWrapperByVal<8>,_tlgWrapBuffer<_UNICODE_STRING>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>_>

+                (p_Var8,&DAT_2,p_Var29,p_Var30,(_tlgWrapperByVal<8> *)&local_c0,

+                 (_tlgWrapBuffer<_UNICODE_STRING> *)&local_c8,(_tlgWrapperByVal<8> *)&local_d0,

+                 (_tlgWrapperByVal<4> *)&local_150,(_tlgWrapperByVal<4> *)&local_154,

+                 (_tlgWrapperByVal<4> *)&local_158);

+    }

+    *(ulonglong *)(_Dst + 10) = (ulonglong)local_38;

+    p_Var30 = (_GUID *)(ulonglong)local_38;

+    *(bool *)(_Dst + 0xf) = bVar32;

+    if (bVar32) {

+      if ((((local_110 < local_120) ||

+           (0x7fffffff < (ulonglong)((longlong)local_110 - (longlong)local_120))) ||

+          (0 < (int)((uint)local_120 - local_38))) || ((int)((int)local_110 - local_38) < 0)) {

+        *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+        WdLogSingleEntry5(0,0x119,10);

+        _WdLogGlobalForLineNumber = 0x38a;

+        goto LAB_3;

+      }

+      p_Var29 = local_120;

+      if (local_38 < (uint)local_120) {

+        p_Var29 = local_110;

+      }

+      p_Var30 = (_GUID *)((ulonglong)p_Var30 | (ulonglong)p_Var29 & 0xffffffff00000000);

+      p_Stack_108 = p_Var30;

+    }

+    else {

+LAB_3:

+      p_Stack_108 = local_110;

+    }

+    if (p_Var14 != (_TDR_RECOVERY_CONTEXT *)0x0) {

+      *(long *)(p_Var14 + 0xb00) = lVar12;

+    }

+  }

+  lVar13 = 0;

+  local_168[0] = '\0';

+  local_138 = (_GUID *)0x0;

+  if ((*(_VIDSCH_NODE **)(lVar4 + 0xcb8) == param_1) &&

+     (lVar13 = *(longlong *)(param_1 + (ulonglong)*(uint *)(param_1 + 0x630) * 8 + 0x638),

+     lVar13 != 0)) {

+    lVar6 = *(longlong *)(*(_GUID **)(lVar13 + 0x68) + 0x28);

+    if ((lVar6 != 0) && (local_138 = (_GUID *)0x0, *(longlong *)(lVar6 + 8) != 0)) {

+      local_138 = *(_GUID **)(lVar13 + 0x68);

+    }

+  }

+  VidSchiMarkDevicesInError((longlong *)&local_130,local_168,(longlong *)&local_138);

+  cVar10 = local_168[0];

+  if (p_Var14 == (_TDR_RECOVERY_CONTEXT *)0x0) goto LAB_4;

+  p_Var29 = local_138;

+  if (local_138 != (_GUID *)0x0) {

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

+    if (*(longlong *)(lVar6 + 8) != 0) {

+      p_Var28 = p_Var14 + 0xb05;

+      *(undefined8 *)(p_Var14 + 0xaf8) = *(undefined8 *)(*(longlong *)(lVar6 + 8) + 0x38);

+      lVar7 = *(longlong *)(lVar6 + 0xa58);

+      if (lVar7 == 0) {

+LAB_5:

+        *p_Var28 = (_TDR_RECOVERY_CONTEXT)0x0;

+      }

+      else {

+        lVar26 = 0xf;

+        p_Var22 = p_Var28;

+        do {

+          if ((lVar26 == -0x7fffffef) ||

+             (p_Var22[lVar7 - (longlong)p_Var28] == (_TDR_RECOVERY_CONTEXT)0x0)) break;

+          *p_Var22 = p_Var22[lVar7 - (longlong)p_Var28];

+          p_Var22 = p_Var22 + 1;

+          lVar26 = lVar26 + -1;

+        } while (lVar26 != 0);

+        p_Var19 = p_Var22 + -1;

+        if (lVar26 != 0) {

+          p_Var19 = p_Var22;

+        }

+        *p_Var19 = (_TDR_RECOVERY_CONTEXT)0x0;

+        if (lVar26 == 0) goto LAB_5;

+      }

+      if (lVar13 != 0) {

+        *(undefined4 *)(p_Var14 + 0xb14) = *(undefined4 *)(lVar13 + 0x8c);

+      }

+    }

+    if (((*(char *)(*(longlong *)(local_138 + 0x28) + 0xa48) == '\0') &&

+        ((*(uint *)(local_138 + 0x30) & 8) == 0)) && ((*(uint *)(local_138 + 0x30) & 1) == 0)) {

+      TdrHistoryUpdate(lVar6 + 0x28,p_Var14);

+      p_Var29 = (_GUID *)CONCAT71((int7)((ulonglong)p_Var29 >> 8),1);

+      _Var9 = (_TDR_RECOVERY_CONTEXT)TdrHistoryIsLimitExhausted(lVar6 + 0x28,p_Var14);

+      p_Var14[0xb04] = _Var9;

+      if (_Var9 != (_TDR_RECOVERY_CONTEXT)0x0) {

+        lVar13 = *(longlong *)(lVar6 + 0xa40);

+        p_Var29 = (_GUID *)(ulonglong)(*(uint *)(lVar4 + 4) >> 5);

+        uVar21 = *(uint *)(lVar4 + 4) & 0x1f;

+        puVar3 = (uint *)(lVar13 + (longlong)p_Var29 * 4);

+        *puVar3 = *puVar3 | 1 << (sbyte)uVar21;

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

+          McTemplateK0dp_EtwWriteTransfer

+                    ((ulonglong)uVar21,lVar13,p_Var29,*(undefined4 *)(lVar4 + 4));

+        }

+      }

+    }

+  }

+  TdrUpdateDbgReport(p_Var14,0);

+  TdrCollectDbgInfoStage2(p_Var14);

+  p_Var28 = (_TDR_RECOVERY_CONTEXT *)(param_1 + 0x874);

+  if (*p_Var28 == (_TDR_RECOVERY_CONTEXT)0x0) {

+    local_164 = *(uint *)(p_Var14 + 0xb14);

+    p_Var28 = p_Var14 + 0xb05;

   }

   else {

-    uVar13 = (*(uint *)p_Var15 >> 10 | *(uint *)p_Var15) & uVar13;

-  }

-  *(_D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE *)(p_Var5 + 0xcb4) =

-       *(_D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE *)(p_Var5 + 0xcb4) & ~uVar13;

-  if ((((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x20) != 0) &&

-      (*(longlong *)(pVVar4 + lVar23 + 0x508) != lVar21)) &&

-     ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x14 & 1) == 0)) {

-    SetIndependentFlipStage(p_Var18,~uVar13);

-    p_Var15 = p_Var3;

-    VidSchiPropagatePresentHistoryToken

-              ((longlong)p_Var3,*(DXGPRESENTHISTORYTOKENQUEUE **)(pVVar4 + lVar23 + 0x500),

-               *(_D3DKMT_PRESENTHISTORYTOKEN **)(pVVar4 + lVar23 + 0x508),true,

-               (bool)((byte)(*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 6) & 1),false,false,

-               *(longlong *)(pVVar4 + lVar23 + 0x510),*(longlong *)(pVVar4 + lVar23 + 0x520),0,

-               (ulonglong *)

-               (-(ulonglong)(*(longlong *)(pVVar4 + lVar23 + 0x5c0) != 0) &

-               (ulonglong)(pVVar4 + lVar23 + 0x5c0)),'\0');

-  }

-  local_a40[0] = 0;

-  VidSchiComputeFlipEntryStatusAfterFlip(p_Var15,(longlong)&local_928,local_a40);

-  VidSchiUpdateFlipTelemetryStats

-            (*(_VIDSCH_PROCESS **)(*(longlong *)(pVVar4 + lVar23 + 0x488) + 0x28),

-             (_VIDSCH_CALL_EXECUTE_FLIP *)&local_928,p_Var5);

-  _Var8 = local_a40[0];

-  VidSchiLogMmIoFlipMultiPlaneOverlay3

-            (p_Var3,(_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78),

-             (_VIDSCH_CALL_EXECUTE_FLIP *)&local_928,local_a40[0],*(uint *)(pVVar4 + lVar23 + 0x4a8)

-             ,*(__uint64 *)(pVVar4 + lVar23 + 0x598));

-  *(_VIDSCH_FLIP_STATUS *)(pVVar4 + lVar23 + 0x494) = _Var8;

-  if (_Var8 == 0xb) {

-    local_a44 = 0;

-    if ((*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) == 5) ||

-       (bVar9 = false, *(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) == 0xf

-       )) {

-      bVar9 = true;

-    }

-    if (bVar9) {

-      local_a38 = (_VIDSCH_FLIP_QUEUE_ENTRY *)((ulonglong)local_a38 & 0xffffffff00000000);

-      local_9b8 = uVar2 - 1 & 0x3f;

-      local_9e0 = 0;

-      local_9b0 = *(undefined8 *)(p_Var5 + 0xad40);

-      local_9a8 = *(undefined8 *)(p_Var5 + 0xad50);

-      local_9a0 = *(undefined8 *)(p_Var5 + 0xad48);

-      local_998 = *(undefined8 *)(p_Var5 + 0xad58);

-      local_a48[0] = 0;

-      local_9d0 = 0;

-      local_9c4 = 0;

-      local_9b4 = 0;

-      local_990 = 0;

-      local_9d8 = p_Var3;

-      local_9c8 = uVar1;

-      local_9c0 = pVVar4;

-      VidSchiProcessVsyncCompletedFlipEntry

-                ((HwQueueStagingList *)&local_a00,&local_9d8,(longlong)&local_9e0,(uint *)&local_a38

-                 ,&local_a44,local_a48);

-    }

-    p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

-    if (p_Var3[0x3b] != (_VIDSCH_GLOBAL)0x0) {

-      VidSchiUpdateHwPresentTimeForImmediateFlip(p_Var3,p_Var18,uVar1);

-    }

-    p_Var15 = *(_VIDSCH_GLOBAL **)(p_Var5 + 0xad58);

-    p_Var6 = *(_VIDSCH_GLOBAL **)(p_Var5 + 0xad50);

-    uVar22 = *(undefined8 *)(p_Var5 + 0xad40);

-    *(undefined8 *)(pVVar4 + lVar23 + 0x4f0) = *(undefined8 *)(p_Var5 + 0xad48);

-    p_Var12 = *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x5a0);

-    *(undefined8 *)(pVVar4 + lVar23 + 0x4e0) = uVar22;

-    p_Var7 = p_Var12;

-    if (p_Var12 == (_VIDSCH_GLOBAL *)0x0) {

-      p_Var12 = p_Var6;

-      p_Var7 = p_Var15;

-    }

-    *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x4e8) = p_Var7;

-    *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x4d0) = p_Var12;

-    VidSchiUnreferenceDisplayingAllocationsForThisEntry

-              ((HwQueueStagingList *)&local_a00,p_Var6,p_Var5,(longlong)p_Var18);

-    VidSchiReferenceDisplayingAllocationsForThisEntry

-              ((HwQueueStagingList *)&local_a00,(longlong)p_Var3,(longlong)p_Var5,(longlong)p_Var18)

-    ;

-    iVar11 = VidSchiCompleteFlipEntry

-                       ((HwQueueStagingList *)&local_a00,p_Var3,uVar1,pVVar4,uVar2,uVar2,0,

-                        (undefined1 *)0x0);

-    local_a44 = local_a44 + iVar11;

-  }

-  else {

-    p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

-    VidSchiIncrementPendingFlipsForFlipEntry(p_Var3,p_Var5,p_Var18);

-    if (p_Var3[0x3b] == (_VIDSCH_GLOBAL)0x0) {

-      *(undefined8 *)(pVVar4 + lVar23 + 0x4c8) = _DAT_2;

-    }

-  }

-  *(uint *)(pVVar4 + 0x48) = uVar2;

-  if ((*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) != 5) &&

-     (*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) != 0xf)) {

-    *(uint *)(pVVar4 + 0x44) = uVar2;

-  }

-  if ((uVar2 - *(int *)(pVVar4 + 0x40) & 0x3f) < 0x20) {

-    *(uint *)(pVVar4 + 0x40) = uVar2 + 1 & 0x3f;

-    VidSchiUpdateFlipQueueHistory(6,p_Var3,uVar1,pVVar4,uVar2 + 1 & 0x3f);

-  }

-  else {

-    WdLogSingleEntry3(4,pVVar4,uVar24,*(int *)(pVVar4 + 0x40));

-    _WdLogGlobalForLineNumber = 0x11c2;

-  }

-  if (p_Var3[0x3b] == (_VIDSCH_GLOBAL)0x0) {

-    *(undefined4 *)(pVVar4 + 0x70) = *(undefined4 *)(pVVar4 + lVar23 + 0x4a8);

-  }

-  else {

-    VidSchiSetNextFlipEarliestIdealTime(p_Var3,uVar1,pVVar4,p_Var18);

-  }

-  VIDMM_GLOBAL::NotifyOnFlip(*(VIDMM_GLOBAL **)(*(longlong *)(p_Var3 + 8) + 0x300));

-  *(int *)(*(longlong *)(p_Var3 + 0x108) + 0x328) =

-       *(int *)(*(longlong *)(p_Var3 + 0x108) + 0x328) + -1;

-  VidSchiUpdateFlipQueueHistory(1,p_Var3,uVar1,pVVar4,uVar2);

-  HwQueueStagingList::~HwQueueStagingList((HwQueueStagingList *)&local_a00);

-  this = local_950;

-LAB_0:

-  AcquireSpinLock::Release(this);

-  return;

+    local_164 = *(uint *)(param_1 + 0x884);

+  }

+  p_Var30 = (_GUID *)(ulonglong)local_164;

+  if ((5 < DAT_0) && (cVar10 = _tlgKeywordOn(0x140080048,0x400000000010), cVar10 != '\0')) {

+    local_14c = (uint)(byte)p_Var14[0xb04];

+    local_148 = *(undefined4 *)(param_1 + 0x86c);

+    p_Var8 = *(_tlgProvider_t **)(lVar4 + 0x10);

+    local_b0 = *(undefined8 *)(p_Var14 + 0xaf8);

+    local_144 = *(undefined4 *)(param_1 + 0x1fc);

+    local_140[0] = SUB84(p_Var30,0);

+    local_a0 = *(undefined8 *)(p_Var8 + 0x798);

+    local_98 = *(undefined8 *)(p_Var8 + 0x7a0);

+    local_90 = *(undefined8 *)(p_Var8 + 0x19c);

+    local_166 = 4;

+    local_b8 = p_Var28;

+    local_a8 = p_Var14;

+    _tlgWriteTemplate<long___cdecl(_tlgProvider_t_const*___ptr64,void_const*___ptr64,_GUID_const*___ptr64,_GUID_const*___ptr64,unsigned_int,_EVENT_DATA_DESCRIPTOR*___ptr64),&long___cdecl__tlgWriteTransfer_EtwWriteTransfer(struct__tlgProvider_t_const*___ptr64,void_const*___ptr64,struct__GUID_const*___ptr64,struct__GUID_const*___ptr64,unsigned_int,struct__EVENT_DATA_DESCRIPTOR*___ptr64),_GUID_const*___ptr64,_GUID_const*___ptr64>

+    ::

+    Write<_tlgWrapperByVal<2>,_tlgWrapperByVal<8>,_tlgWrapBuffer<_UNICODE_STRING>,_tlgWrapSz<unsigned_short>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapSz<char>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>_>

+              (p_Var8,&DAT_7,p_Var29,p_Var30,(_tlgWrapperByVal<2> *)&local_166,

+               (_tlgWrapperByVal<8> *)&local_90,(_tlgWrapBuffer<_UNICODE_STRING> *)&local_98,

+               (_tlgWrapSz<unsigned_short> *)&local_a0,(_tlgWrapperByVal<4> *)local_140,

+               (_tlgWrapperByVal<8> *)&local_a8,(_tlgWrapperByVal<4> *)&local_144,

+               (_tlgWrapperByVal<8> *)&local_b0,(_tlgWrapSz<char> *)&local_b8,

+               (_tlgWrapperByVal<4> *)&local_148,(_tlgWrapperByVal<4> *)&local_14c);

+  }

+  cVar10 = local_168[0];

+  if ((bVar32 == false) || (local_168[0] != '\0')) {

+    pcVar2 = (char *)(lVar4 + 0xcc5);

+    if (p_Var28 == (_TDR_RECOVERY_CONTEXT *)0x0) {

+LAB_8:

+      *pcVar2 = '\0';

+    }

+    else {

+      lVar13 = 0xf;

+      pcVar23 = pcVar2;

+      do {

+        if ((lVar13 == -0x7fffffef) || (pcVar23[(longlong)p_Var28 - (longlong)pcVar2] == '\0'))

+        break;

+        *pcVar23 = pcVar23[(longlong)p_Var28 - (longlong)pcVar2];

+        pcVar23 = pcVar23 + 1;

+        lVar13 = lVar13 + -1;

+      } while (lVar13 != 0);

+      pcVar20 = pcVar23 + -1;

+      if (lVar13 != 0) {

+        pcVar20 = pcVar23;

+      }

+      *pcVar20 = '\0';

+      if (lVar13 == 0) goto LAB_8;

+    }

+    *(uint *)(lVar4 + 0xcd4) = local_164;

+  }

+  TdrCompleteRecoveryContext(p_Var14,1);

+  *(undefined8 *)(lVar4 + 0xcb0) = 0;

+LAB_4:

+  if (bVar32 != false) {

+    *(undefined8 *)(param_1 + 0x1b8) = 0;

+    *(undefined4 *)(param_1 + 0x1f0) = 0;

+    VidSchiCompletePendingCommandInNodeHwQueue

+              ((longlong)param_1,(uint)p_Stack_108,(undefined8 *)0x0,(ulonglong)p_Var30);

+    *(_GUID **)(param_1 + 0x40) = p_Stack_108;

+    *(_GUID **)(param_1 + 0x48) = p_Stack_108;

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

+      *(undefined4 *)(param_1 + 0x884) = 0;

+      param_1[0x874] = (_VIDSCH_NODE)0x0;

+    }

+    else {

+      bVar32 = false;

+    }

+  }

+  RtlClearBitEx(lVar4 + 0x280,*(undefined2 *)(param_1 + 4));

+  *(undefined4 *)(param_1 + 0x10) = 0;

+  *(bool *)(_Dst + 0xf) = bVar32;

+  *(char *)((longlong)_Dst + 0x3e) = cVar10;

+  *(_GUID **)(_Dst + 10) = p_Stack_108;

+  return bVar32;

 }
```

## `VidSchiUpdateReadyBitsInNewPriority`  (modified)

```diff
--- VidSchiUpdateReadyBitsInNewPriority
+++ VidSchiUpdateReadyBitsInNewPriority
@@ -1,43 +1,22 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

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

+/* void __cdecl VidSchiUpdateReadyBitsInNewPriority(struct _VIDSCH_NODE * __ptr64,struct

+   _VIDSCH_CONTEXT * __ptr64) */

 

 void __cdecl VidSchiUpdateReadyBitsInNewPriority(_VIDSCH_NODE *param_1,_VIDSCH_CONTEXT *param_2)

 

 {

-  uint uVar1;

-  longlong lVar2;

-  longlong *unaff_RBX;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  undefined8 in_R8;

-  undefined8 uStack0000000000000040;

-  

-  lVar2 = PsGetCurrentProcess();

-  if ((*unaff_RBX == lVar2) || ((*(uint *)(unaff_RSI + 0x1c) & 0x2000) != 0)) {

-    if (((**(uint **)(unaff_RSI + 0x188) & 0x60000000) == 0x20000000) &&

-       (-1 < (char)*(undefined4 *)(unaff_RSI + 0x18))) {

-      uVar1 = *(uint *)(*(longlong *)(unaff_RBP + 0x18) + 0x1bc);

-      if (((((uVar1 & 0x10) == 0) && ((uVar1 & 8) == 0)) &&

-          (-1 < (char)*(undefined4 *)(*(longlong *)(unaff_RBP + 0x18) + 0x9bc))) &&

-         (unaff_RDI != *(longlong *)(unaff_RSI + 0x30))) {

-        WdLogSingleEntry0();

-        _WdLogGlobalForLineNumber = 0x142;

-        DxgkLogInternalTriageEvent

-                  (0,0x40000,in_R8,L"Only the owner of a shared allocation can lock it.",0x142,0,0,0

-                  );

-      }

+  if (*(_VIDSCH_NODE **)(param_1 + ((ulonglong)*(uint *)(param_2 + 0x194) + 0x89) * 0x10) ==

+      param_1 + ((ulonglong)*(uint *)(param_2 + 0x194) + 0x89) * 0x10) {

+    *(uint *)(param_1 + 0x768) =

+         *(uint *)(param_1 + 0x768) | 1 << ((byte)*(uint *)(param_2 + 0x194) & 0x1f);

+    if ((((*(byte *)(*(longlong *)(*(longlong *)(param_1 + 0x18) + 0x228) +

+                    ((longlong)(ulonglong)*(ushort *)(param_1 + 4) >> 3)) >>

+           ((ulonglong)*(ushort *)(param_1 + 4) & 7) & 1) == 0) &&

+        ((*(uint *)(param_1 + 0x76c) & -1 << ((byte)*(undefined4 *)(param_2 + 0x194) & 0x1f)) == 0))

+       && (*(int *)(param_1 + 0xbdc) == 0)) {

+      RtlSetBitEx(*(longlong *)(param_1 + 0x18) + 0x220);

     }

-  }

-  else {

-    WdLogSingleEntry0();

-    _WdLogGlobalForLineNumber = 0x132;

-    uStack0000000000000040 = 0;

-    (**(code **)(DxgCoreInterface_exref + 0x2c0))

-              (0,0x40000,0xffffffff,

-               L"Trying to lock a non-protected allocation in the wrong process context.",0x132);

   }

   return;

 }
```

## `DxgMmsDbgTriageDumpCallback`  (modified)

```diff
--- DxgMmsDbgTriageDumpCallback
+++ DxgMmsDbgTriageDumpCallback
@@ -1,29 +1,21 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-ulonglong DxgMmsDbgTriageDumpCallback

-                    (undefined8 param_1,undefined8 param_2,_KBUGCHECK_TRIAGE_DUMP_DATA *param_3)

+void DxgMmsDbgTriageDumpCallback

+               (undefined8 param_1,undefined8 param_2,_KBUGCHECK_TRIAGE_DUMP_DATA *param_3)

 

 {

-  int in_EAX;

-  ulonglong uVar1;

-  longlong unaff_RBX;

-  byte in_CF;

-  char in_SF;

-  char in_OF;

-  undefined2 uStack0000000000000054;

-  undefined2 uStack0000000000000056;

+  int iVar1;

   

-  if (in_OF != in_SF) {

-    uVar1 = (ulonglong)(in_EAX + 0x3fa35 + (uint)in_CF);

-    if (*(int *)(unaff_RBX + 4) != 0) {

-      uStack0000000000000054 = *(undefined2 *)(unaff_RBX + 8);

-      uStack0000000000000056 = *(undefined2 *)(unaff_RBX + 4);

-      uVar1 = RtlRecordFeatureUsage(&stack0x00000050,1);

+  if (((*(uint *)(param_3 + 8) & 1) != 0) && (DAT_0 != 0)) {

+    iVar1 = *(int *)(param_3 + 0x10);

+    if ((iVar1 == 0x10e) || (((iVar1 == 0x113 || (iVar1 == 0x116)) || (iVar1 == 0x119)))) {

+      DxgMmsAddTriageData(param_3);

     }

-    return uVar1;

+    if (((g_Feature_GraphicsKernel2606BugFixes_Enabled != false) &&

+        (*(int *)(param_3 + 0x10) == 0x19c)) && (*(longlong *)(param_3 + 0x18) == 0x50)) {

+      DxgMmsAddTriageData(param_3);

+    }

+    *(longlong *)param_3 = DAT_0;

   }

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  return;

 }
```

## `VidSchiNotifyReadyQueueAdded`  (modified)

```diff
--- VidSchiNotifyReadyQueueAdded
+++ VidSchiNotifyReadyQueueAdded
@@ -1,39 +1,43 @@
+

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

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

+/* void __cdecl VidSchiNotifyReadyQueueAdded(struct VIDSCH_HW_QUEUE * __ptr64) */

 

 void __cdecl VidSchiNotifyReadyQueueAdded(VIDSCH_HW_QUEUE *param_1)

 

 {

-  longlong *plVar1;

-  longlong *plVar2;

-  longlong lVar3;

-  longlong *plVar4;

-  code *pcVar5;

-  longlong unaff_RBX;

-  undefined1 *unaff_RDI;

-  undefined1 auStackX_20 [8];

-  undefined8 uStack0000000000000030;

+  longlong lVar1;

+  longlong lVar2;

+  code *pcVar3;

   

-  uStack0000000000000030 = 0;

-  KeAcquireInStackQueuedSpinLock(param_1 + 0xad68,(ulonglong)auStackX_20 & 0xffffffff);

-  plVar1 = (longlong *)(unaff_RBX + 0xad70);

-  plVar2 = (longlong *)*plVar1;

-  if (plVar2 == plVar1) {

-    KeReleaseInStackQueuedSpinLock(auStackX_20);

-    *unaff_RDI = 0;

+  lVar1 = *(longlong *)(*(longlong *)(param_1 + 0x28) + 0x10);

+  lVar2 = *(longlong *)(lVar1 + 0x18);

+  if ((*(int *)(lVar1 + 0x6c8) != -1) && (*(int *)(lVar2 + 0x44) != -1)) {

+    *(int *)(lVar1 + 0x6c8) = *(int *)(lVar1 + 0x6c8) + 1;

+    if (param_1[0x90] == (VIDSCH_HW_QUEUE)0x0) {

+      if (*(int *)(lVar1 + 0x6cc) == 0) {

+        LOCK();

+        *(undefined4 *)(lVar1 + 0x1f8) = 1;

+        UNLOCK();

+      }

+      *(int *)(lVar1 + 0x6cc) = *(int *)(lVar1 + 0x6cc) + 1;

+    }

+    *(int *)(lVar2 + 0x44) = *(int *)(lVar2 + 0x44) + 1;

+    if (((*(int *)(lVar1 + 0x6c8) == 1) && (*(int *)(lVar1 + 0x4088) != -1)) &&

+       (*(code **)(lVar2 + 0xcf0) != (code *)0x0)) {

+      (**(code **)(lVar2 + 0xcf0))(*(undefined8 *)(lVar2 + 0xd18));

+    }

+    if (*(int *)(lVar2 + 0x44) == 1) {

+      *(undefined8 *)(lVar2 + 0x5c8) = _DAT_0;

+      KeSetEvent(lVar2 + 0x5a8,0,0);

+    }

     return;

   }

-  lVar3 = *plVar2;

-  if (((longlong *)*(longlong *)(lVar3 + 8) == plVar2) &&

-     (plVar4 = (longlong *)plVar2[1], (longlong *)*plVar4 == plVar2)) {

-    *plVar4 = lVar3;

-    *(longlong **)(lVar3 + 8) = plVar4;

-    *unaff_RDI = (longlong *)*plVar1 != plVar1;

-    KeReleaseInStackQueuedSpinLock(auStackX_20);

-    return;

-  }

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

-  (*pcVar5)(3);

-  pcVar5 = (code *)swi(3);

-  (*pcVar5)();

+  *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+  WdLogSingleEntry5(0,0x119,0x7000,param_1,lVar1,0);

+  _WdLogGlobalForLineNumber = 0x38a;

+  pcVar3 = (code *)swi(3);

+  (*pcVar3)();

   return;

 }
```

## `VidSchiExecuteMmIoFlipAtPassiveLevel`  (modified)

```diff
--- VidSchiExecuteMmIoFlipAtPassiveLevel
+++ VidSchiExecuteMmIoFlipAtPassiveLevel
@@ -1,11 +1,391 @@
+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

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

 

 void VidSchiExecuteMmIoFlipAtPassiveLevel(undefined8 *param_1)

 

 {

-  code *pcVar1;

+  uint uVar1;

+  uint uVar2;

+  _VIDSCH_GLOBAL *p_Var3;

+  VIDSCH_FLIP_QUEUE *pVVar4;

+  _VIDSCH_PRESENT_INFO *p_Var5;

+  _VIDSCH_GLOBAL *p_Var6;

+  _VIDSCH_GLOBAL *p_Var7;

+  _VIDSCH_FLIP_STATUS _Var8;

+  bool bVar9;

+  long lVar10;

+  int iVar11;

+  _VIDSCH_GLOBAL *p_Var12;

+  uint uVar13;

+  uint uVar14;

+  _VIDSCH_GLOBAL *p_Var15;

+  AcquireSpinLock *this;

+  uint uVar16;

+  ulonglong uVar17;

+  _VIDSCH_FLIP_QUEUE_ENTRY *p_Var18;

+  ulonglong uVar19;

+  ulonglong uVar20;

+  longlong lVar21;

+  undefined8 uVar22;

+  longlong lVar23;

+  ulonglong uVar24;

+  undefined1 auStackY_aa8 [32];

+  byte local_a48 [4];

+  int local_a44;

+  _VIDSCH_FLIP_STATUS local_a40 [2];

+  _VIDSCH_FLIP_QUEUE_ENTRY *local_a38;

+  _VIDSCH_GLOBAL *local_a30;

+  uint ******local_a28;

+  uint ******ppppppuStack_a20;

+  uint local_a18;

+  uint local_a14;

+  uint local_a10;

+  int local_a08;

+  int local_a04;

+  _VIDSCH_GLOBAL *local_a00;

+  undefined8 ******local_9f8;

+  undefined8 ******ppppppuStack_9f0;

+  undefined1 local_9e8;

+  undefined4 local_9e4;

+  undefined8 local_9e0;

+  _VIDSCH_GLOBAL *local_9d8;

+  undefined8 local_9d0;

+  uint local_9c8;

+  undefined4 local_9c4;

+  VIDSCH_FLIP_QUEUE *local_9c0;

+  uint local_9b8;

+  undefined4 local_9b4;

+  undefined8 local_9b0;

+  undefined8 local_9a8;

+  undefined8 local_9a0;

+  undefined8 local_998;

+  undefined8 local_990;

+  int local_988 [4];

+  AcquireSpinLock local_978 [40];

+  AcquireSpinLock local_950 [40];

+  longlong local_928;

+  _DXGKARG_SETVIDPNSOURCEADDRESSWITHMULTIPLANEOVERLAY3 local_920 [4];

+  uint local_91c;

+  uint local_918;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined1 local_88 [80];

+  ulonglong local_38;

   

-  pcVar1 = (code *)swi(3);

-  (*pcVar1)();

+  local_38 = __security_cookie ^ (ulonglong)auStackY_aa8;

+  p_Var3 = (_VIDSCH_GLOBAL *)*param_1;

+  local_a48[0] = *(byte *)(param_1 + 3);

+  uVar1 = *(uint *)((longlong)param_1 + 0xc);

+  uVar19 = (ulonglong)uVar1;

+  uVar2 = *(uint *)(param_1 + 1);

+  uVar24 = (ulonglong)uVar2;

+  if (*(int *)(p_Var3 + 0xcac) != 0) {

+    WdLogSingleEntry2(3,p_Var3,uVar19);

+    _WdLogGlobalForLineNumber = 0x104f;

+    return;

+  }

+  pVVar4 = (VIDSCH_FLIP_QUEUE *)param_1[2];

+  p_Var5 = *(_VIDSCH_PRESENT_INFO **)(p_Var3 + uVar19 * 8 + 0xd68);

+  lVar23 = uVar24 * 0x578;

+  p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

+  local_a38 = p_Var18;

+  memset(&local_928,0,0x870);

+  memset(local_88,0,0x50);

+  local_98 = 0;

+  local_988[0] = 0;

+  local_988[1] = 0;

+  local_988[2] = 0;

+  local_988[3] = 0;

+  local_b8 = 0;

+  uStack_b0 = 0;

+  local_a8 = 0;

+  uStack_a0 = 0;

+  AcquireSpinLock::AcquireSpinLock(local_978,(__uint64 *)(p_Var3 + 0x7c0),true,false);

+  uVar20 = uVar19;

+  VidSchiSetupMmIoFlipMultiPlaneOverlay3

+            (p_Var3,(longlong)p_Var18,uVar1,&local_928,local_a48[0],(longlong)local_88,local_988,

+             (undefined4 *)&local_b8);

+  AcquireSpinLock::Release(local_978);

+  local_91c = local_91c | 8;

+  lVar10 = ADAPTER_DISPLAY::DdiSetVidPnSourceAddressWithMultiPlaneOverlay3

+                     (*(ADAPTER_DISPLAY **)(*(longlong *)(local_928 + 0x10) + 0xc48),local_920);

+  if (lVar10 == -0x3ffffdd3) {

+    uVar13 = local_918 >> 1 & 1;

+    if (uVar13 != 0) {

+      if (Microsoft_Windows_DxgKrnlEnableBits < '\0') {

+        McTemplateK0pqqtq_EtwWriteTransfer

+                  ((ulonglong)uVar13,0xffffffffc000022d,uVar20,*(undefined8 *)(p_Var3 + 0x10));

+      }

+      AcquireSpinLock::AcquireSpinLock

+                ((AcquireSpinLock *)&local_9d8,(__uint64 *)(p_Var3 + 0x7c0),true,false);

+      ppppppuStack_a20 = (uint ******)&local_a28;

+      local_a28 = (uint ******)&local_a28;

+      local_a18 = local_a18 & 0xffffff00;

+      local_a14 = 2;

+      if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x10) == 0) {

+        uVar13 = (1 << ((byte)*(undefined4 *)(p_Var3 + 0x98) & 0x1f)) - 1;

+      }

+      else {

+        uVar13 = (**(uint **)(pVVar4 + lVar23 + 0x520) >> 10 | **(uint **)(pVVar4 + lVar23 + 0x520))

+                 & 0x3ff;

+      }

+      *(uint *)(p_Var5 + 0xcb4) = *(uint *)(p_Var5 + 0xcb4) & ~uVar13;

+      uVar13 = *(uint *)(pVVar4 + lVar23 + 0x4f8);

+      *(undefined4 *)(pVVar4 + lVar23 + 0x494) = 0xe;

+      uVar14 = (local_918 & 1) << 0x10;

+      *(uint *)(pVVar4 + lVar23 + 0x4f8) = uVar14 | uVar13 & 0xfffeffff;

+      uVar16 = (local_918 & 4) << 0xf;

+      *(uint *)(pVVar4 + lVar23 + 0x4f8) = uVar16 | uVar14 | uVar13 & 0xfffcffff;

+      *(uint *)(pVVar4 + lVar23 + 0x4f8) =

+           (local_918 & 8) << 0xf | uVar16 | uVar14 | uVar13 & 0xfff8ffff;

+      local_a30 = p_Var3;

+      VidSchiUpdateFlipQueueHistory(5,p_Var3,uVar1,pVVar4,uVar2);

+      if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x11 & 1) != 0) {

+        if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x12 & 1) == 0) {

+          *(_VIDSCH_FLIP_QUEUE_ENTRY **)(p_Var5 + 0x78) = p_Var18;

+        }

+        else {

+          *(_VIDSCH_FLIP_QUEUE_ENTRY **)(p_Var3 + 0xec8) = p_Var18;

+        }

+        if (pVVar4[0x50] != (VIDSCH_FLIP_QUEUE)0x0) {

+          if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x12 & 1) == 0) {

+            VidSchiCancelAndRequeueIndependentFlips(p_Var3,uVar1);

+          }

+          else {

+            uVar19 = 0;

+            p_Var18 = local_a38;

+            if (*(int *)(p_Var3 + 0x28) != 0) {

+              do {

+                if ((*(longlong *)(p_Var3 + uVar19 * 8 + 0xd68) != 0) &&

+                   (*(int *)(*(longlong *)(p_Var3 + uVar19 * 8 + 0xd68) + 0xcb0) != 0)) {

+                  VidSchiCancelAndRequeueIndependentFlips(p_Var3,(uint)uVar19);

+                }

+                uVar13 = (uint)uVar19 + 1;

+                uVar19 = (ulonglong)uVar13;

+                p_Var18 = local_a38;

+              } while (uVar13 < *(uint *)(p_Var3 + 0x28));

+            }

+          }

+        }

+      }

+      VidSchiKeepInterruptTargetEnabledForFlip(p_Var3,p_Var18,p_Var5);

+      if ((p_Var3[0x1b9d] != (_VIDSCH_GLOBAL)0x0) && (uVar2 != *(uint *)(pVVar4 + 0x40))) {

+        WdLogSingleEntry3(4,pVVar4,uVar24,*(uint *)(pVVar4 + 0x40));

+        _WdLogGlobalForLineNumber = 0x10d9;

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

+        VidSchiUpdateFlipQueueHistory(6,p_Var3,uVar1,pVVar4,uVar2);

+      }

+      HwQueueStagingList::~HwQueueStagingList((HwQueueStagingList *)&local_a30);

+      this = (AcquireSpinLock *)&local_9d8;

+      goto LAB_0;

+    }

+LAB_1:

+    *(undefined4 *)g_DxgMmsBugcheckExportIndex_exref = 1;

+    WdLogSingleEntry5(0,0x119,0xb);

+    _WdLogGlobalForLineNumber = 0x38a;

+  }

+  else if (lVar10 != 0) goto LAB_1;

+  AcquireSpinLock::AcquireSpinLock(local_950,(__uint64 *)(p_Var3 + 0x7c0),true,false);

+  ppppppuStack_9f0 = &local_9f8;

+  lVar21 = 0;

+  local_9e4 = 2;

+  local_9e8 = 0;

+  local_9f8 = &local_9f8;

+  uVar22 = 0x3ff;

+  uVar13 = 0x3ff;

+  local_a00 = p_Var3;

+  if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x1000) == 0) {

+    local_a28 = *(uint *******)(pVVar4 + lVar23 + 0x520);

+    uVar13 = *(uint *)local_a28;

+    uVar14 = uVar13 & 0x3ff;

+    uVar16 = 0;

+    if (p_Var3[0x9c] != (_VIDSCH_GLOBAL)0x0) {

+      uVar16 = uVar13 >> 10 & 0x3ff;

+    }

+    local_a08 = 0;

+    if (uVar14 != 0) {

+      for (; (uVar14 >> local_a08 & 1) == 0; local_a08 = local_a08 + 1) {

+      }

+    }

+    ppppppuStack_a20 = (uint ******)(CONCAT44(uVar16,uVar13) & 0xffffffff000003ff);

+    iVar11 = -1;

+    if (uVar14 != 0) {

+      iVar11 = local_a08;

+    }

+    local_a18 = 0;

+    local_a04 = 0;

+    if (uVar16 != 0) {

+      for (; (uVar16 >> local_a04 & 1) == 0; local_a04 = local_a04 + 1) {

+      }

+    }

+    local_a14 = (uint)(char)iVar11;

+    uVar20 = (ulonglong)local_a14;

+    iVar11 = -1;

+    if (uVar16 != 0) {

+      iVar11 = local_a04;

+    }

+    local_a10 = (uint)(char)iVar11;

+    uVar17 = (ulonglong)local_a10;

+    local_a30 = p_Var3;

+    bVar9 = VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::end

+                      ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

+    uVar13 = (uint)uVar22;

+    if (!bVar9) {

+      while( true ) {

+        if ((uint)uVar20 < (uint)uVar17) {

+          uVar17 = uVar20;

+        }

+        *(undefined8 *)

+         ((uVar17 & 0xffffffff) * 0x130 + 0x188 + *(longlong *)(p_Var3 + uVar19 * 8 + 0xd68)) =

+             *(undefined8 *)

+              ((ulonglong)

+               ((*(int *)(*(longlong *)(pVVar4 + lVar23 + 0x520) + 8) * 8 + 0xe0) * local_a18) +

+               0x18 + *(longlong *)(pVVar4 + lVar23 + 0x520));

+        VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::operator++

+                  ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

+        bVar9 = VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR::end

+                          ((VIDSCH_FLIP_MULTIPLANE_OVERLAY_ITERATOR *)&local_a30);

+        uVar13 = (uint)uVar22;

+        lVar21 = 0;

+        if (bVar9) break;

+        uVar17 = (ulonglong)local_a10;

+        uVar20 = (ulonglong)local_a14;

+      }

+    }

+  }

+  if (p_Var3[0x3b] != SUB81(lVar21,0)) {

+    uVar22 = KeQueryPerformanceCounter(0);

+    *(undefined8 *)(pVVar4 + lVar23 + 0x5a8) = uVar22;

+    uVar13 = 0x3ff;

+    lVar21 = 0;

+  }

+  p_Var15 = *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x520);

+  if ((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x10) == 0) {

+    p_Var15 = (_VIDSCH_GLOBAL *)(ulonglong)*(uint *)(p_Var3 + 0x98);

+    uVar13 = (1 << ((byte)*(uint *)(p_Var3 + 0x98) & 0x1f)) - 1;

+  }

+  else {

+    uVar13 = (*(uint *)p_Var15 >> 10 | *(uint *)p_Var15) & uVar13;

+  }

+  *(_D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE *)(p_Var5 + 0xcb4) =

+       *(_D3DKMT_FLIPMODEL_INDEPENDENT_FLIP_STAGE *)(p_Var5 + 0xcb4) & ~uVar13;

+  if ((((*(uint *)(pVVar4 + lVar23 + 0x4f8) & 0x20) != 0) &&

+      (*(longlong *)(pVVar4 + lVar23 + 0x508) != lVar21)) &&

+     ((*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 0x14 & 1) == 0)) {

+    SetIndependentFlipStage(p_Var18,~uVar13);

+    p_Var15 = p_Var3;

+    VidSchiPropagatePresentHistoryToken

+              ((longlong)p_Var3,*(DXGPRESENTHISTORYTOKENQUEUE **)(pVVar4 + lVar23 + 0x500),

+               *(_D3DKMT_PRESENTHISTORYTOKEN **)(pVVar4 + lVar23 + 0x508),true,

+               (bool)((byte)(*(uint *)(pVVar4 + lVar23 + 0x4f8) >> 6) & 1),false,false,

+               *(longlong *)(pVVar4 + lVar23 + 0x510),*(longlong *)(pVVar4 + lVar23 + 0x520),0,

+               (ulonglong *)

+               (-(ulonglong)(*(longlong *)(pVVar4 + lVar23 + 0x5c0) != 0) &

+               (ulonglong)(pVVar4 + lVar23 + 0x5c0)),'\0');

+  }

+  local_a40[0] = 0;

+  VidSchiComputeFlipEntryStatusAfterFlip(p_Var15,(longlong)&local_928,local_a40);

+  VidSchiUpdateFlipTelemetryStats

+            (*(_VIDSCH_PROCESS **)(*(longlong *)(pVVar4 + lVar23 + 0x488) + 0x28),

+             (_VIDSCH_CALL_EXECUTE_FLIP *)&local_928,p_Var5);

+  _Var8 = local_a40[0];

+  VidSchiLogMmIoFlipMultiPlaneOverlay3

+            (p_Var3,(_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78),

+             (_VIDSCH_CALL_EXECUTE_FLIP *)&local_928,local_a40[0],*(uint *)(pVVar4 + lVar23 + 0x4a8)

+             ,*(__uint64 *)(pVVar4 + lVar23 + 0x598));

+  *(_VIDSCH_FLIP_STATUS *)(pVVar4 + lVar23 + 0x494) = _Var8;

+  if (_Var8 == 0xb) {

+    local_a44 = 0;

+    if ((*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) == 5) ||

+       (bVar9 = false, *(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) == 0xf

+       )) {

+      bVar9 = true;

+    }

+    if (bVar9) {

+      local_a38 = (_VIDSCH_FLIP_QUEUE_ENTRY *)((ulonglong)local_a38 & 0xffffffff00000000);

+      local_9b8 = uVar2 - 1 & 0x3f;

+      local_9e0 = 0;

+      local_9b0 = *(undefined8 *)(p_Var5 + 0xad40);

+      local_9a8 = *(undefined8 *)(p_Var5 + 0xad50);

+      local_9a0 = *(undefined8 *)(p_Var5 + 0xad48);

+      local_998 = *(undefined8 *)(p_Var5 + 0xad58);

+      local_a48[0] = 0;

+      local_9d0 = 0;

+      local_9c4 = 0;

+      local_9b4 = 0;

+      local_990 = 0;

+      local_9d8 = p_Var3;

+      local_9c8 = uVar1;

+      local_9c0 = pVVar4;

+      VidSchiProcessVsyncCompletedFlipEntry

+                ((HwQueueStagingList *)&local_a00,&local_9d8,(longlong)&local_9e0,(uint *)&local_a38

+                 ,&local_a44,local_a48);

+    }

+    p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

+    if (p_Var3[0x3b] != (_VIDSCH_GLOBAL)0x0) {

+      VidSchiUpdateHwPresentTimeForImmediateFlip(p_Var3,p_Var18,uVar1);

+    }

+    p_Var15 = *(_VIDSCH_GLOBAL **)(p_Var5 + 0xad58);

+    p_Var6 = *(_VIDSCH_GLOBAL **)(p_Var5 + 0xad50);

+    uVar22 = *(undefined8 *)(p_Var5 + 0xad40);

+    *(undefined8 *)(pVVar4 + lVar23 + 0x4f0) = *(undefined8 *)(p_Var5 + 0xad48);

+    p_Var12 = *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x5a0);

+    *(undefined8 *)(pVVar4 + lVar23 + 0x4e0) = uVar22;

+    p_Var7 = p_Var12;

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

+      p_Var12 = p_Var6;

+      p_Var7 = p_Var15;

+    }

+    *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x4e8) = p_Var7;

+    *(_VIDSCH_GLOBAL **)(pVVar4 + lVar23 + 0x4d0) = p_Var12;

+    VidSchiUnreferenceDisplayingAllocationsForThisEntry

+              ((HwQueueStagingList *)&local_a00,p_Var6,p_Var5,(longlong)p_Var18);

+    VidSchiReferenceDisplayingAllocationsForThisEntry

+              ((HwQueueStagingList *)&local_a00,(longlong)p_Var3,(longlong)p_Var5,(longlong)p_Var18)

+    ;

+    iVar11 = VidSchiCompleteFlipEntry

+                       ((HwQueueStagingList *)&local_a00,p_Var3,uVar1,pVVar4,uVar2,uVar2,0,

+                        (undefined1 *)0x0);

+    local_a44 = local_a44 + iVar11;

+  }

+  else {

+    p_Var18 = (_VIDSCH_FLIP_QUEUE_ENTRY *)(pVVar4 + lVar23 + 0x78);

+    VidSchiIncrementPendingFlipsForFlipEntry(p_Var3,p_Var5,p_Var18);

+    if (p_Var3[0x3b] == (_VIDSCH_GLOBAL)0x0) {

+      *(undefined8 *)(pVVar4 + lVar23 + 0x4c8) = _DAT_2;

+    }

+  }

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

+  if ((*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) != 5) &&

+     (*(int *)(pVVar4 + (ulonglong)*(uint *)(pVVar4 + 0x44) * 0x578 + 0x494) != 0xf)) {

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

+  }

+  if ((uVar2 - *(int *)(pVVar4 + 0x40) & 0x3f) < 0x20) {

+    *(uint *)(pVVar4 + 0x40) = uVar2 + 1 & 0x3f;

+    VidSchiUpdateFlipQueueHistory(6,p_Var3,uVar1,pVVar4,uVar2 + 1 & 0x3f);

+  }

+  else {

+    WdLogSingleEntry3(4,pVVar4,uVar24,*(int *)(pVVar4 + 0x40));

+    _WdLogGlobalForLineNumber = 0x11c2;

+  }

+  if (p_Var3[0x3b] == (_VIDSCH_GLOBAL)0x0) {

+    *(undefined4 *)(pVVar4 + 0x70) = *(undefined4 *)(pVVar4 + lVar23 + 0x4a8);

+  }

+  else {

+    VidSchiSetNextFlipEarliestIdealTime(p_Var3,uVar1,pVVar4,p_Var18);

+  }

+  VIDMM_GLOBAL::NotifyOnFlip(*(VIDMM_GLOBAL **)(*(longlong *)(p_Var3 + 8) + 0x300));

+  *(int *)(*(longlong *)(p_Var3 + 0x108) + 0x328) =

+       *(int *)(*(longlong *)(p_Var3 + 0x108) + 0x328) + -1;

+  VidSchiUpdateFlipQueueHistory(1,p_Var3,uVar1,pVVar4,uVar2);

+  HwQueueStagingList::~HwQueueStagingList((HwQueueStagingList *)&local_a00);

+  this = local_950;

+LAB_0:

+  AcquireSpinLock::Release(this);

   return;

 }
```

## `DXGAUTOPUSHLOCKSHARED::DXGAUTOPUSHLOCKSHARED`  (modified)

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

+void __cdecl VidSchiNotifyReadyQueueAdded(VIDSCH_HW_QUEUE *param_1)

+

+{

+  longlong *plVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  longlong unaff_RBX;

+  undefined1 *unaff_RDI;

+  undefined1 auStackX_20 [8];

+  undefined8 uStack0000000000000030;

+  

+  uStack0000000000000030 = 0;

+  KeAcquireInStackQueuedSpinLock(param_1 + 0xad68,(ulonglong)auStackX_20 & 0xffffffff);

+  plVar1 = (longlong *)(unaff_RBX + 0xad70);

+  plVar2 = (longlong *)*plVar1;

+  if (plVar2 == plVar1) {

+    KeReleaseInStackQueuedSpinLock(auStackX_20);

+    *unaff_RDI = 0;

+    return;

+  }

+  lVar3 = *plVar2;

+  if (((longlong *)*(longlong *)(lVar3 + 8) == plVar2) &&

+     (plVar4 = (longlong *)plVar2[1], (longlong *)*plVar4 == plVar2)) {

+    *plVar4 = lVar3;

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

+    *unaff_RDI = (longlong *)*plVar1 != plVar1;

+    KeReleaseInStackQueuedSpinLock(auStackX_20);

+    return;

+  }

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

+  (*pcVar5)(3);

+  pcVar5 = (code *)swi(3);

+  (*pcVar5)();

+  return;

+}

+
```

## `NTOSKRNL.EXE::ExReleasePushLockExclusiveEx`  (modified)

```diff
--- NTOSKRNL.EXE::ExReleasePushLockExclusiveEx calling
+++ NTOSKRNL.EXE::ExReleasePushLockExclusiveEx calling
@@ -37,0 +38 @@
+VIDMM_GLOBAL::HandlePromotionCandidates
```

## `NTOSKRNL.EXE::ExAllocatePool2`  (modified)

```diff
--- NTOSKRNL.EXE::ExAllocatePool2 calling
+++ NTOSKRNL.EXE::ExAllocatePool2 calling
@@ -4,0 +5,2 @@
+NonPagedPoolZeroedArray<VIDSCH_HW_QUEUE_FENCE_PAIR,2,895576406>::AllocateElements
+NonPagedPoolZeroedArray<_VIDSCH_CONTEXT_ID_PAIR,2,895576406>::AllocateElements
@@ -8,0 +11 @@
+NonPagedPoolZeroedArray<unsigned___int64,2,1717659990>::AllocateElements
@@ -11,0 +15 @@
+NonPagedPoolZeroedArray<void_const*___ptr64,2,1717659990>::AllocateElements
@@ -39 +42,0 @@
-VidSchiAddPendingCommandToSyncPointList
```
