# CVE-2026-125137 — dxgkrnl.sys patch diff

`dxgkrnl.sys` 10.0.26100.9818 -> 10.0.26100.9974 (ghidriff).

## `DpiAcquirePostDisplayInfoFromBgfx`  (modified)

```diff
--- DpiAcquirePostDisplayInfoFromBgfx
+++ DpiAcquirePostDisplayInfoFromBgfx
@@ -1,192 +1,148 @@
 

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

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

 

-long DpiAcquirePostDisplayInfoFromBgfx(uint param_1,undefined8 param_2,uint param_3,int param_4)

+int DpiAcquirePostDisplayInfoFromBgfx(undefined8 *param_1,char param_2,char param_3)

 

 {

-  longlong lVar1;

-  ADAPTER_DISPLAY *pAVar2;

-  int iVar3;

-  uchar uVar4;

-  int iVar5;

-  long lVar6;

-  _D3DKMT_VIDPNSOURCEOWNER_TYPE _Var7;

-  long lVar8;

-  uint uVar9;

-  uint *unaff_RBX;

-  DXGADAPTERSTOPRESETLOCKSHARED *unaff_RBP;

-  uint unaff_ESI;

-  DXGADAPTER *unaff_RDI;

-  uint uVar10;

-  int in_R10D;

-  uint uVar11;

-  int unaff_R12D;

-  ushort unaff_R13W;

-  undefined4 unaff_R14D;

-  DXGDEVICE *unaff_R15;

-  undefined4 unaff_XMM6_Da;

-  undefined4 unaff_XMM6_Db;

-  undefined4 unaff_XMM6_Dc;

-  undefined4 unaff_XMM6_Dd;

-  undefined4 uStack0000000000000050;

-  undefined4 uStack0000000000000054;

-  int iStack0000000000000058;

-  undefined4 uStack000000000000005c;

-  DXGCONTEXT *in_stack_00000060;

-  undefined8 in_stack_00000068;

-  undefined4 uStack0000000000000070;

-  undefined4 uStack0000000000000074;

-  undefined8 *in_stack_00000078;

+  bool bVar1;

+  int iVar2;

+  longlong lVar3;

+  longlong lVar4;

+  char cVar5;

+  ulonglong uVar6;

+  char cVar7;

+  char cVar8;

+  undefined1 auStack_a8 [32];

+  char local_88 [4];

+  int local_84;

+  longlong local_80;

+  ulonglong uStack_78;

+  longlong local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  ulonglong uStack_58;

+  undefined8 local_50;

+  undefined8 uStack_48;

+  undefined8 local_40;

+  undefined8 uStack_38;

+  ulonglong local_30;

   

-  iVar5 = iStack0000000000000058;

-  uVar11 = *(uint *)(unaff_RBP + 0x644);

-  if (-1 < (int)uVar11) {

-    uVar9 = *(uint *)(unaff_RBP + 0x64c);

-    if ((((int)uVar11 <= (int)uVar9) && (param_1 <= *unaff_RBX)) && (uVar9 <= unaff_RBX[1])) {

-      if (uVar11 < uVar9) {

-        lVar1 = *(longlong *)(unaff_RBP + 0x650);

-        do {

-          if (param_3 < param_1) {

-            do {

-              iVar3 = param_3 * 3;

-              param_3 = param_3 + 1;

-              uVar10 = uVar11 * unaff_RBX[2] + iVar3;

-              uVar9 = param_4 * 4;

-              param_4 = param_4 + 1;

-              *(uint *)((ulonglong)uVar9 + (ulonglong)(uint)(in_R10D * iStack0000000000000058) +

-                       *(longlong *)(unaff_RBP + -0x58)) =

-                   (uint)CONCAT21(CONCAT11(*(undefined1 *)((ulonglong)(uVar10 + 2) + lVar1),

-                                           *(undefined1 *)((ulonglong)(uVar10 + 1) + lVar1)),

-                                  *(undefined1 *)((ulonglong)uVar10 + lVar1));

-              param_1 = *(uint *)(unaff_RBP + 0x648);

-            } while (param_3 < param_1);

-            param_4 = *(int *)(unaff_RBP + 0x630);

-            uVar9 = *(uint *)(unaff_RBP + 0x64c);

-            param_3 = *(uint *)(unaff_RBP + 0x640);

-          }

-          in_R10D = in_R10D + 1;

-          uVar11 = uVar11 + 1;

-        } while (uVar11 < uVar9);

-        unaff_XMM6_Da = *(undefined4 *)(unaff_RBP + 0x630);

-        unaff_XMM6_Db = *(undefined4 *)(unaff_RBP + 0x634);

-        unaff_XMM6_Dc = *(undefined4 *)(unaff_RBP + 0x638);

-        unaff_XMM6_Dd = *(undefined4 *)(unaff_RBP + 0x63c);

-        unaff_RDI = *(DXGADAPTER **)(unaff_RBP + 0x660);

-        unaff_ESI = in_stack_00000068._4_4_;

+  local_30 = __security_cookie ^ (ulonglong)auStack_a8;

+  cVar8 = '\0';

+  cVar5 = '\0';

+  local_50 = 0;

+  uStack_48 = 0;

+  local_40 = 0;

+  uStack_38 = 0;

+  local_80 = 0;

+  uStack_78 = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_60 = 0;

+  uStack_58 = 0;

+  if (((((param_3 != '\0') && (DAT_0 != 0)) &&

+       (lVar3 = *(longlong *)(DAT_0 + 0x40), lVar3 != 0)) &&

+      ((*(int *)(lVar3 + 0x10) == 0x74727044 && (*(int *)(lVar3 + 0x14) == 2)))) &&

+     (cVar8 = *(char *)(lVar3 + 0xb1d), cVar8 != '\0')) {

+    cVar5 = *(char *)(lVar3 + 0xb1e);

+  }

+  local_88[0] = param_2;

+  local_84 = ZwQuerySystemInformation(0x7e,&local_50,0x20);

+  bVar1 = false;

+  if (-1 < local_84) {

+    bVar1 = true;

+    *(undefined4 *)(param_1 + 3) = 0xffffffff;

+    *(undefined4 *)((longlong)param_1 + 0x1c) = 0;

+    param_1[2] = local_50;

+    *(uint *)((longlong)param_1 + 4) = uStack_48._4_4_;

+    *(uint *)param_1 = (uint)uStack_48;

+    uStack_68 = CONCAT44((uint)uStack_48,uStack_48._4_4_);

+    local_60 = CONCAT44(local_60._4_4_,(int)local_40);

+    if ((int)uStack_38 == 3) {

+      *(undefined4 *)((longlong)param_1 + 0xc) = 0x14;

+      iVar2 = (int)local_40 * 3;

+      local_60 = CONCAT44(4,(int)local_40);

+LAB_1:

+      *(int *)(param_1 + 1) = iVar2;

+    }

+    else {

+      if ((int)uStack_38 == 4) {

+        *(undefined4 *)((longlong)param_1 + 0xc) = 0x16;

+        iVar2 = (int)local_40 * 4;

+        local_60 = CONCAT44(5,(int)local_40);

+        goto LAB_1;

       }

-      if (*(longlong *)(unaff_R15 + 0x768) == *(longlong *)(*(longlong *)(unaff_R15 + 0x10) + 0x10))

-      {

-        memset(unaff_RBP + 0x50,0,0x5e0);

-        uStack0000000000000054 = 0;

-        if (CONCAT44(uStack0000000000000074,uStack0000000000000070) != 0) {

-          uStack0000000000000054 =

-               *(undefined4 *)(CONCAT44(uStack0000000000000074,uStack0000000000000070) + 0x18);

-          *(longlong *)(unaff_RBP + 0x50) = (longlong)&stack0x00000050 + 4;

+      bVar1 = false;

+    }

+    iVar2 = ZwQuerySystemInformation(0x9c,param_1 + 4,0x80,0);

+    if (iVar2 < 0) {

+      memset(param_1 + 4,0,0x80);

+      WdLogSingleEntry1(3);

+      _WdLogGlobalForLineNumber = 0xaa1;

+    }

+  }

+  if (local_88[0] == '\0') goto LAB_2;

+  cVar7 = '\0';

+  local_88[0] = '\0';

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

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

+      lVar3 = 0;

+      lVar4 = 0;

+      if (bVar1) {

+        iVar2 = RtlCheckRegistryKey(0);

+        uVar6 = (ulonglong)(uint)(*(int *)(param_1 + 1) * *(int *)((longlong)param_1 + 4));

+        if (-1 < iVar2) goto LAB_3;

+        lVar3 = ExAllocatePool2(0x40,uVar6,0x74727044);

+        lVar4 = ExAllocatePool2(0x40,0x20,0x74727044);

+        if ((lVar3 == 0) || (lVar4 == 0)) goto LAB_3;

+        KeInitializeSpinLock(lVar4 + 0x18);

+        if ((cVar8 == '\0') ||

+           ((3000 < (uint)uStack_48 ||

+            (uStack_58 = uStack_58 & 0xffffffffffffff00, 2000 < uStack_48._4_4_)))) {

+          uStack_58 = CONCAT71(uStack_58._1_7_,1);

         }

-        *(uint *)(unaff_RBP + 0xb0) = *(uint *)(unaff_RBP + 0xb0) | 1;

-        *(undefined4 *)(unaff_RBP + 0x58) = *(undefined4 *)(in_stack_00000060 + 0x18);

-        *(DXGADAPTERSTOPRESETLOCKSHARED **)(unaff_RBP + 0xa0) = unaff_RBP + 0x650;

-        *(undefined4 *)(unaff_RBP + 0x6c) = uStack0000000000000050;

-        *(undefined4 *)(unaff_RBP + 0x70) = uStack000000000000005c;

-        *(undefined4 *)(unaff_RBP + 0x78) = unaff_XMM6_Da;

-        *(undefined4 *)(unaff_RBP + 0x7c) = unaff_XMM6_Db;

-        *(undefined4 *)(unaff_RBP + 0x80) = unaff_XMM6_Dc;

-        *(undefined4 *)(unaff_RBP + 0x84) = unaff_XMM6_Dd;

-        *(undefined4 *)(unaff_RBP + 0x98) = 1;

-        *(undefined4 *)(unaff_RBP + 0x88) = unaff_XMM6_Da;

-        *(undefined4 *)(unaff_RBP + 0x8c) = unaff_XMM6_Db;

-        *(undefined4 *)(unaff_RBP + 0x90) = unaff_XMM6_Dc;

-        *(undefined4 *)(unaff_RBP + 0x94) = unaff_XMM6_Dd;

-        *(undefined4 *)(unaff_RBP + 0x650) = unaff_XMM6_Da;

-        *(undefined4 *)(unaff_RBP + 0x654) = unaff_XMM6_Db;

-        *(undefined4 *)(unaff_RBP + 0x658) = unaff_XMM6_Dc;

-        *(undefined4 *)(unaff_RBP + 0x65c) = unaff_XMM6_Dd;

-        iVar5 = DXGCONTEXT::PresentFromCdd

-                          (in_stack_00000060,(_D3DKMT_SUBMITPRESENTTOHWQUEUE *)(unaff_RBP + 0x50),

-                           unaff_ESI,(COREDEVICEACCESS *)(unaff_RBP + 0x670),unaff_RBP,

-                           &stack0x00000060);

-        if (-1 < iVar5) {

-          if ((**(uint **)(unaff_RDI + 0xbd8) & 0x10) != 0) {

-            PresentQualcommPanelRefreshWorkaround(in_stack_00000060,unaff_RDI,unaff_ESI);

-          }

-          goto LAB_0;

+        local_80 = lVar3;

+        uStack_78 = uVar6;

+        local_70 = lVar4;

+        iVar2 = InbvSetVirtualFrameBuffer(&local_80);

+        if (iVar2 < 0) goto LAB_3;

+        DxgDetermineBootImageMode(param_1,&local_80,0,local_88);

+        cVar7 = local_88[0];

+      }

+      else {

+LAB_3:

+        DxgDetermineBootImageMode(param_1,0,0,0);

+      }

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

+        InbvNotifyDisplayOwnershipChange(0);

+        if (lVar3 != 0) {

+          ExFreePoolWithTag(lVar3);

+        }

+        if (lVar4 != 0) {

+          ExFreePoolWithTag(lVar4);

         }

       }

-      else {

-        pAVar2 = *(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48);

-        *(undefined4 *)(unaff_RBP + -0x3c) = 0;

-        *(undefined4 *)(unaff_RBP + -0x14) = 0;

-        *(undefined8 *)(unaff_RBP + -8) = 0;

-        ADAPTER_DISPLAY::GetCurrentOrientation(pAVar2,unaff_ESI,1);

-        pAVar2 = *(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48);

-        *(undefined4 *)(unaff_RBP + -0x28) = 0;

-        *(undefined4 *)(unaff_RBP + -0x24) = 0;

-        *(undefined8 *)(unaff_RBP + -0x20) = 0;

-        *(undefined8 *)(unaff_RBP + -0x38) = *(undefined8 *)(unaff_RBP + -0x58);

-        *(DXGADAPTERSTOPRESETLOCKSHARED **)(unaff_RBP + -0x10) = unaff_RBP + 0x630;

-        *(uint *)(unaff_RBP + -0x40) = unaff_ESI;

-        *(undefined4 *)(unaff_RBP + -0x30) = unaff_R14D;

-        *(int *)(unaff_RBP + -0x2c) = iVar5;

-        *(undefined4 *)(unaff_RBP + -0x18) = 1;

-        iVar5 = ADAPTER_DISPLAY::PresentDisplayOnlyCdd

-                          (pAVar2,(_DXGKARG_PRESENT_DISPLAYONLY *)(unaff_RBP + -0x40));

-        if (-1 < iVar5) goto LAB_0;

-      }

-      WdLogSingleEntry1(2,(longlong)iVar5);

-      _WdLogGlobalForLineNumber = 0x1455;

-      DxgkLogInternalTriageEvent

-                (0,0x40000,0xffffffff,

-                 L"PresentCddShadowBuffer: PresentFromCdd failed. Status = 0x%I64x",(longlong)iVar5)

-      ;

-      goto LAB_0;

+      goto LAB_2;

     }

   }

-  if (DAT_1 != '\0') {

-    DxgCreateLiveDumpWithWdLogs

-              (0x193,0x809,*unaff_RBX << 0x10 | unaff_RBX[1] & 0xffff,

-               unaff_R12D << 0x10 | (uint)unaff_R13W,0);

-    DAT_1 = '\0';

-  }

-LAB_0:

-  uStack0000000000000070 = *(undefined4 *)(unaff_R15 + 0x1d4);

-  in_stack_00000078 = (undefined8 *)&stack0x00000050;

-  uStack0000000000000074 = 1;

-  lVar6 = DXGDEVICE::Unlock(unaff_R15,(_D3DKMT_UNLOCK *)&stack0x00000070,'\0');

-  uVar4 = DXGADAPTER::UsingSetTimingsFromVidPn(unaff_RDI);

-  if (uVar4 != '\0') {

-    _Var7 = ADAPTER_DISPLAY::GetVidPnSourceOwnerType

-                      (*(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48),unaff_ESI);

-    if (_Var7 == 0) {

-      uVar4 = ADAPTER_DISPLAY::IsVidPnSourceActive

-                        (*(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48),unaff_ESI);

-      if (uVar4 != '\0') {

-        uVar4 = ADAPTER_DISPLAY::IsVidPnSourceVisible

-                          (*(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48),unaff_ESI);

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

-          lVar8 = ADAPTER_DISPLAY::PresentCddPrimary

-                            (*(ADAPTER_DISPLAY **)(unaff_RDI + 0xc48),in_stack_00000060,unaff_ESI,

-                             (COREDEVICEACCESS *)(unaff_RBP + 0x670));

-          if (lVar8 < 0) {

-            WdLogSingleEntry2(2,in_stack_00000060,(longlong)lVar8);

-            _WdLogGlobalForLineNumber = 0x1471;

-            DxgkLogInternalTriageEvent

-                      (0,0x40000,0xffffffff,

-                       L"PresentFromCdd failed to present the newly created Cdd Primary (Status = 0x%I64x)."

-                       ,in_stack_00000060);

-          }

-        }

-      }

+  else {

+    DxgDetermineBootImageMode(param_1,0,cVar5,local_88);

+    if (local_88[0] != '\0') {

+      iVar2 = InbvSetVirtualFrameBuffer(0);

+      if (-1 < iVar2) goto LAB_2;

     }

   }

-  COREDEVICEACCESS::~COREDEVICEACCESS((COREDEVICEACCESS *)(unaff_RBP + 0x670));

-  DXGADAPTERSTOPRESETLOCKSHARED::Release(unaff_RBP);

-  DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

-  ::

-  ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

-            ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

-              *)(unaff_RBP + 0x18));

-  DXGDEVICEACCESSLOCKEXCLUSIVECDD::Release((DXGDEVICEACCESSLOCKEXCLUSIVECDD *)(unaff_RBP + -0x80));

-  return lVar6;

+  InbvNotifyDisplayOwnershipChange(0);

+LAB_2:

+  if (!bVar1) {

+    *param_1 = 0;

+    param_1[1] = 0;

+    param_1[2] = 0;

+    param_1[3] = 0;

+    *(undefined4 *)(param_1 + 3) = 0xffffffff;

+    memset(param_1 + 4,0,0x80);

+  }

+  return local_84;

 }
```

## `DxgkCreateAllocationInternal`  (modified)

```diff
--- DxgkCreateAllocationInternal
+++ DxgkCreateAllocationInternal
@@ -1,106 +1,456 @@
 

-/* WARNING: Instruction at (ram,0x000140301689) overlaps instruction at (ram,0x000140301688)

-    */

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

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

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

+/* long __cdecl DxgkCreateAllocationInternal(struct _D3DKMT_CREATEALLOCATION * __ptr64,unsigned

+   __int64 * __ptr64) */

 

 long __cdecl DxgkCreateAllocationInternal(_D3DKMT_CREATEALLOCATION *param_1,__uint64 *param_2)

 

 {

-  longlong *plVar1;

-  byte bVar2;

-  byte bVar3;

-  undefined4 uVar4;

-  undefined4 uVar5;

-  longlong lVar6;

-  undefined8 uVar7;

-  long in_EAX;

-  uint uVar8;

-  void *pvVar9;

-  void *extraout_RAX;

-  longlong unaff_RBX;

-  DXGDEVICESYNCOBJECT *this;

-  undefined8 *puVar10;

-  DXGPAGINGQUEUE *unaff_RDI;

-  char cVar11;

-  int iVar12;

-  undefined8 unaff_R12;

-  DXGPAGINGQUEUE *unaff_R14;

-  undefined4 uStack0000000000000028;

-  uint uStack0000000000000038;

-  uint uStack0000000000000040;

-  undefined4 uStack0000000000000048;

-  int iStack0000000000000058;

+  uint *puVar1;

+  uint uVar2;

+  bool bVar3;

+  char cVar4;

+  long lVar5;

+  int iVar6;

+  uint uVar7;

+  DXGPROCESS *pDVar8;

+  __uint64 _Var9;

+  longlong lVar10;

+  _D3DKMT_CREATEALLOCATION *p_Var11;

+  _D3DKMDT_STANDARDALLOCATION_TYPE _Var12;

+  uint uVar13;

+  ulonglong uVar14;

+  ulonglong uVar15;

+  DXGDEVICE *this;

+  undefined8 in_R8;

+  DXGDEVICE **ppDVar16;

+  wchar_t *pwVar17;

+  ulonglong uVar18;

+  ulonglong uVar19;

+  undefined1 auStackY_298 [32];

+  undefined4 local_210 [2];

+  undefined8 local_208;

+  char local_200;

+  char local_1f8;

+  DXGDEVICEBYHANDLE local_1f0 [8];

+  long local_1e8;

+  DXGPROCESS *local_1e0;

+  DXGPROCESS *local_1d8;

+  __uint64 *local_1d0;

+  uint local_1c8 [4];

+  undefined8 local_1b8;

+  ulonglong uStack_1b0;

+  undefined8 local_1a8;

+  undefined8 uStack_1a0;

+  undefined8 local_198;

+  undefined8 uStack_190;

+  longlong local_188;

+  ulonglong uStack_180;

+  undefined8 local_178;

+  DXGDEVICE *local_168;

+  void *local_160;

+  DXGDEVICE *local_158;

+  DXGDEVICELOCKONAPPROPRIATETHREADMODEL local_150 [16];

+  DXGADAPTERSTOPRESETLOCKSHARED local_140 [24];

+  DXGHANDLETABLELOCKEXCLUSIVE local_128 [24];

+  undefined4 local_110;

+  undefined8 local_10c;

+  undefined4 local_104;

+  undefined8 local_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  undefined8 local_e8;

+  COREDEVICEACCESS local_d8 [160];

+  ulonglong local_38;

   

-  if (param_1 == (_D3DKMT_CREATEALLOCATION *)0x0) {

-    do {

-      if (unaff_RDI == (DXGPAGINGQUEUE *)0x0) break;

-      DXGPAGINGQUEUE::DestroyCoreState(unaff_RDI,(COREDEVICEACCESS *)param_2);

-      unaff_RDI = *(DXGPAGINGQUEUE **)unaff_RDI;

-    } while (unaff_RDI != unaff_R14);

-    for (this = *(DXGDEVICESYNCOBJECT **)(unaff_RBX + 0x220);

-        (this != (DXGDEVICESYNCOBJECT *)(unaff_RBX + 0x220) && (this != (DXGDEVICESYNCOBJECT *)0x0))

-        ; this = *(DXGDEVICESYNCOBJECT **)this) {

-      DXGDEVICESYNCOBJECT::DestroyCoreState(this);

+  local_38 = __security_cookie ^ (ulonglong)auStackY_298;

+  local_210[0] = 0xffffffff;

+  uVar15 = 0;

+  local_208 = 0;

+  local_1d0 = param_2;

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

+    local_200 = '\0';

+  }

+  else {

+    local_200 = '\x01';

+    local_210[0] = 0x7d3;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,in_R8,0x7d3);

     }

-    if (*(longlong *)(unaff_RBX + 0x790) != 0) {

-      (**(code **)(*(longlong *)(*(longlong *)(*(longlong *)(unaff_RBX + 0x10) + 0x2e0) + 8) + 0x270

-                  ))();

-      *(undefined8 *)(unaff_RBX + 0x790) = unaff_R12;

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_210,0x7d3);

+  bVar3 = false;

+  pDVar8 = DXGPROCESS::GetCurrent();

+  local_1d8 = pDVar8;

+  cVar4 = PsGetCurrentThreadPreviousMode();

+  local_1f8 = cVar4;

+  if (pDVar8 == (DXGPROCESS *)0x0) {

+    WdLogSingleEntry1(2,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0x2342;

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Invalid process context, returning 0x%I64x");

+    goto LAB_2;

+  }

+  memset(&local_1b8,0,0x48);

+  local_f8 = 0;

+  uStack_f0 = 0;

+  local_e8 = 0;

+  if (cVar4 == '\x01') {

+    p_Var11 = param_1;

+    if (*(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref <= param_1) {

+      p_Var11 = *(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref;

     }

-    for (puVar10 = *(undefined8 **)(unaff_RBX + 0x1f0);

-        (puVar10 != (undefined8 *)(unaff_RBX + 0x1f0) && (puVar10 != (undefined8 *)0x0));

-        puVar10 = (undefined8 *)*puVar10) {

-      func_0x000140302328(puVar10);

+    RtlCopyVolatileMemory(&local_1b8,p_Var11,0x48);

+  }

+  else {

+    local_1b8 = *(ulonglong *)param_1;

+    uStack_1b0 = *(ulonglong *)(param_1 + 8);

+    local_1a8 = *(undefined8 *)(param_1 + 0x10);

+    uStack_1a0 = *(undefined8 *)(param_1 + 0x18);

+    local_198 = *(undefined8 *)(param_1 + 0x20);

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

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

+    uStack_180 = *(ulonglong *)(param_1 + 0x38);

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

+  }

+  local_168 = (DXGDEVICE *)0x0;

+  ppDVar16 = &local_168;

+  DXGDEVICEBYHANDLE::DXGDEVICEBYHANDLE(local_1f0,(uint)local_1b8,pDVar8,ppDVar16);

+  this = local_168;

+  uVar13 = (uint)ppDVar16;

+  local_158 = local_168;

+  if (local_168 == (DXGDEVICE *)0x0) {

+    WdLogSingleEntry2(2,local_1b8 & 0xffffffff,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0x236c;

+    pwVar17 = L"Invalid hDevice (0x%I64x) specified, returning 0x%I64x";

+LAB_3:

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar17);

+  }

+  else {

+    if (((uint)uStack_180 >> 0x14 & 1) != 0) {

+      if ((uStack_180 & 0x10000) == 0) {

+        if (g_OSTestSigningEnabled != '\0') goto LAB_4;

+        WdLogSingleEntry0(2);

+        _WdLogGlobalForLineNumber = 0x237a;

+        pwVar17 = L"NoKmdAccess can be used only with testsigning";

+      }

+      else {

+        WdLogSingleEntry0(2);

+        _WdLogGlobalForLineNumber = 0x2375;

+        pwVar17 = L"NoKmdAccess cannot be used with StandardAllocation";

+      }

+      goto LAB_3;

     }

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

-    if (*(longlong *)(unaff_RBX + 0x268) != 0) {

-      func_0x000140301eb4(*plVar1);

-      *(undefined8 *)(unaff_RBX + 0x268) = unaff_R12;

-    }

-    if (*(longlong *)(unaff_RBX + 0x318) != 0) {

-      (**(code **)(*(longlong *)(*(longlong *)(*plVar1 + 0x2f8) + 8) + 0x178))();

-      *(undefined8 *)(unaff_RBX + 0x318) = unaff_R12;

-    }

-    if (*(longlong *)(unaff_RBX + 800) != 0) {

-      (**(code **)(*(longlong *)(*(longlong *)(*plVar1 + 0x2e0) + 8) + 0x78))();

-      *(undefined8 *)(unaff_RBX + 800) = unaff_R12;

-    }

-    pvVar9 = (void *)func_0x000140301a94();

-    cVar11 = (char)unaff_R12;

-    if (*(char *)(unaff_RBX + 0x77e) != cVar11) {

-      pvVar9 = (void *)func_0x000140301cb4(*(undefined8 *)(unaff_RBX + 0x28),*plVar1);

-      *(char *)(unaff_RBX + 0x77e) = cVar11;

-    }

-    iVar12 = (int)unaff_R12;

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

-      uVar8 = DXGPROCESS::GetHostProcess(*(DXGPROCESS **)(unaff_RBX + 0x28));

-      DXG_GUEST_VIRTUALGPU_VMBUS::VmBusSendDestroyDevice

-                ((DXG_GUEST_VIRTUALGPU_VMBUS *)

-                 (*(longlong *)(*(longlong *)(unaff_RBX + 0x10) + 0x10) + 0x1258),uVar8,

-                 *(uint *)(unaff_RBX + 0x1d8));

-      *(int *)(unaff_RBX + 0x1d8) = iVar12;

-      pvVar9 = extraout_RAX;

-    }

-    if (bTracingEnabled != cVar11) {

-      uVar4 = *(undefined4 *)(unaff_RBX + 0x1d4);

-      bVar2 = *(byte *)(unaff_RBX + 0x77a);

-      bVar3 = *(byte *)(unaff_RBX + 0x779);

-      uVar5 = *(undefined4 *)(unaff_RBX + 0x1d0);

-      pvVar9 = DXGPROCESS::GetProcessID(*(DXGPROCESS **)(unaff_RBX + 0x28));

-      lVar6 = *(longlong *)(unaff_RBX + 0x10);

-      uVar7 = *(undefined8 *)(lVar6 + 0x10);

-      if ((DAT_0 & 8) != 0) {

-        uStack0000000000000040 = (uint)bVar2;

-        uStack0000000000000038 = (uint)bVar3;

-        uStack0000000000000028 = uVar5;

-        uStack0000000000000048 = uVar4;

-        iStack0000000000000058 = iVar12;

-        pvVar9 = (void *)McTemplateK0ppqpttqpqp_EtwWriteTransfer

-                                   (lVar6,&EventDestroyDevice,uVar7,pvVar9,uVar7);

+LAB_4:

+    if (uStack_190._4_4_ < 0x682ab) {

+      if (((*(uint *)(pDVar8 + 0x198) & 0x100) == 0) &&

+         (((((uStack_180 & 8) != 0 || (((uint)uStack_180 >> 8 & 1) != 0)) ||

+           (((uint)uStack_180 >> 0xc & 1) != 0)) || (((uint)uStack_180 >> 9 & 1) != 0)))) {

+        WdLogSingleEntry2(3,local_168,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0x2395;

+      }

+      else if ((((uStack_180 & 0x20) == 0) || ((uStack_180 & 0x10000) != 0)) ||

+              ((*(uint *)(pDVar8 + 0x198) & 0x100) != 0)) {

+        if (((uint)uStack_180 >> 0x11 & 1) == 0) {

+          if ((uStack_180 & 0x10000) != 0) goto LAB_5;

+        }

+        else {

+          if ((uStack_180 & 0x10000) == 0) {

+            WdLogSingleEntry2(3,local_168,0xffffffffc000000d);

+            _WdLogGlobalForLineNumber = 0x23af;

+            goto LAB_6;

+          }

+LAB_5:

+          local_1e8 = ValidateStandardAllocationParams

+                                ((_D3DKMT_CREATEALLOCATION *)&local_1b8,

+                                 (_D3DKMT_CREATESTANDARDALLOCATION *)&local_f8,cVar4 == '\x01');

+          if (local_1e8 < 0) goto LAB_7;

+        }

+        if ((((uint)uStack_180 & 2) == 0) || (((uint)uStack_180 & 1) != 0)) {

+          if ((local_1b8._4_4_ != 0) || (uStack_190._4_4_ != 0)) {

+            DXGDEVICELOCKONAPPROPRIATETHREADMODEL::DXGDEVICELOCKONAPPROPRIATETHREADMODEL

+                      (local_150,this);

+            DXGADAPTERSTOPRESETLOCKSHARED::DXGADAPTERSTOPRESETLOCKSHARED

+                      (local_140,*(DXGADAPTER **)(*(longlong *)(this + 0x10) + 0x10),'\x01');

+            COREDEVICEACCESS::COREDEVICEACCESS(local_d8,this,2,uVar13,false);

+            local_1e8 = COREDEVICEACCESS::AcquireShared(local_d8,(char *)0x0);

+            if (local_1e8 < 0) {

+              WdLogSingleEntry2(3,this,(longlong)local_1e8);

+              _WdLogGlobalForLineNumber = 0x23e3;

+              COREDEVICEACCESS::~COREDEVICEACCESS(local_d8);

+              DXGADAPTERSTOPRESETLOCKSHARED::Release(local_140);

+              DXGDEVICELOCKONAPPROPRIATETHREADMODEL::~DXGDEVICELOCKONAPPROPRIATETHREADMODEL

+                        (local_150);

+LAB_7:

+              DXGDEVICEBYHANDLE::~DXGDEVICEBYHANDLE(local_1f0);

+              DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_210);

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

+                return local_1e8;

+              }

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

+                return local_1e8;

+              }

+              McTemplateK0q_EtwWriteTransfer();

+              return local_1e8;

+            }

+            _Var9 = SUB168(ZEXT816(8) * ZEXT416(uStack_190._4_4_),0);

+            if (SUB168(ZEXT816(8) * ZEXT416(uStack_190._4_4_),8) != 0) {

+              _Var9 = 0xffffffffffffffff;

+            }

+            _Var12 = 0x4b677844;

+            local_1e0 = operator_new__(_Var9,0x4b677844,0x100);

+            if (local_1e0 == (DXGPROCESS *)0x0) {

+              WdLogSingleEntry3(6,this,uStack_190._4_4_,0xffffffffc0000017);

+              _WdLogGlobalForLineNumber = 0x23f0;

+              DxgkLogInternalTriageEvent

+                        (0,0x40001,0xffffffff,

+                         L"Device 0x%I64x: Out of memory allocating destroy handle table with 0x%I64x elements, returning 0x%I64x"

+                        );

+              COREDEVICEACCESS::~COREDEVICEACCESS(local_d8);

+              DXGADAPTERSTOPRESETLOCKSHARED::Release(local_140);

+              DXGDEVICELOCKONAPPROPRIATETHREADMODEL::~DXGDEVICELOCKONAPPROPRIATETHREADMODEL

+                        (local_150);

+              DXGDEVICEBYHANDLE::~DXGDEVICEBYHANDLE(local_1f0);

+              DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_210);

+              if ((local_200 != '\0') && ((DAT_1 & 1) != 0)) {

+                McTemplateK0q_EtwWriteTransfer();

+              }

+              return -0x3fffffe9;

+            }

+            OutputDuplCleanUpPendingList(this);

+            uStack_1b0 = uStack_1b0 & 0xffffffff00000000;

+            local_1b8 = local_1b8 & 0xffffffff00000000;

+            local_160 = (void *)0x0;

+            local_1c8[0] = 0;

+            if ((uStack_180 & 0x10000) != 0) {

+              if (*(int *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0xbd4) < 2000) {

+                WdLogSingleEntry2(2,this,0xffffffffc000000d);

+                _WdLogGlobalForLineNumber = 0x2408;

+                DxgkLogInternalTriageEvent

+                          (0,0x40000,0xffffffff,

+                           L"Device 0x%I64x: Creating StandardAllocation only supported on WDDM2.0+, returning 0x%I64x"

+                          );

+                COREDEVICEACCESS::~COREDEVICEACCESS(local_d8);

+                DXGADAPTERSTOPRESETLOCKSHARED::Release(local_140);

+                DXGDEVICELOCKONAPPROPRIATETHREADMODEL::~DXGDEVICELOCKONAPPROPRIATETHREADMODEL

+                          (local_150);

+                goto LAB_6;

+              }

+              local_100 = 0;

+              local_110 = (undefined4)uStack_f0;

+              local_10c = 1;

+              local_104 = 7;

+              lVar5 = DXGDEVICE::GetStandardAllocationDriverData

+                                (this,_Var12,&local_110,local_1c8,&local_160);

+              if (lVar5 < 0) goto LAB_8;

+            }

+            lVar5 = DXGDEVICE::CreateAllocation

+                              (this,(_D3DKMT_CREATEALLOCATION *)&local_1b8,cVar4 == '\x01','\0',

+                               (_DXGSHAREDALLOCOBJECT *)0x0,(_D3DKM_CREATESTANDARDALLOCATION *)0x0,

+                               local_d8,0,(_EPROCESS *)0x0,(uint *)0x0,(__uint64 *)0x0,local_1d0,

+                               (_D3DKMT_CREATESTANDARDALLOCATION *)&local_f8,local_160,local_1c8[0])

+            ;

+            local_1e8 = lVar5;

+            if (-1 < lVar5) {

+              bVar3 = true;

+              iVar6 = Feature_1677956409__private_IsEnabledDeviceUsageNoInline();

+              if ((iVar6 != 0) && (local_1b8._4_4_ == 0)) {

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

+                uVar14 = uVar15;

+                if (uStack_190._4_4_ != 0) {

+                  do {

+                    if (lVar10 == 0) break;

+                    *(longlong *)(local_1e0 + uVar14 * 8) = lVar10;

+                    lVar10 = *(longlong *)(lVar10 + 0x40);

+                    uVar13 = (int)uVar14 + 1;

+                    uVar14 = (ulonglong)uVar13;

+                  } while (uVar13 < uStack_190._4_4_);

+                }

+              }

+            }

+            if (local_1f8 == '\x01') {

+              p_Var11 = param_1 + 4;

+              if (*(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref <= param_1 + 4) {

+                p_Var11 = *(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref;

+              }

+              RtlCopyVolatileMemory(p_Var11,(void *)((longlong)&local_1b8 + 4),4);

+              p_Var11 = param_1 + 8;

+              if (*(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref <= param_1 + 8) {

+                p_Var11 = *(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref;

+              }

+              RtlCopyVolatileMemory(p_Var11,&uStack_1b0,4);

+              p_Var11 = param_1 + 0x38;

+              if (*(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref <= param_1 + 0x38) {

+                p_Var11 = *(_D3DKMT_CREATEALLOCATION **)MmUserProbeAddress_exref;

+              }

+              RtlCopyVolatileMemory(p_Var11,&uStack_180,4);

+            }

+            else {

+              *(uint *)(param_1 + 4) = local_1b8._4_4_;

+              *(undefined4 *)(param_1 + 8) = (undefined4)uStack_1b0;

+              *(uint *)(param_1 + 0x38) = (uint)uStack_180;

+            }

+            if ((lVar5 < 0) && (bVar3)) {

+              uVar18 = 0;

+              local_1d0 = (__uint64 *)0x0;

+              local_1d8 = (DXGPROCESS *)0x0;

+              DXGHANDLETABLELOCKEXCLUSIVE::DXGHANDLETABLELOCKEXCLUSIVE(local_128,pDVar8);

+              uVar14 = (ulonglong)local_1b8._4_4_;

+              if (local_1b8._4_4_ == 0) {

+                iVar6 = Feature_1677956409__private_IsEnabledDeviceUsageNoInline();

+                uVar19 = (ulonglong)uStack_190._4_4_;

+                if (iVar6 == 0) {

+                  uVar14 = uVar15;

+                  if (uStack_190._4_4_ != 0) {

+                    do {

+                      uVar13 = *(uint *)(local_188 + uVar14 * 0x60);

+                      uVar7 = uVar13 >> 6 & 0xffffff;

+                      uVar18 = uVar15;

+                      if (uVar7 < *(uint *)(pDVar8 + 0x128)) {

+                        uVar2 = *(uint *)(*(longlong *)(pDVar8 + 0x118) + 8 +

+                                         (ulonglong)uVar7 * 0x10);

+                        if (((((byte)(uVar13 >> 0x19) & 0x60) == ((byte)uVar2 & 0x60)) &&

+                            ((uVar2 & 0x2000) == 0)) && ((uVar2 & 0x1f) != 0)) {

+                          if ((uVar2 & 0x1f) == 5) {

+                            uVar18 = *(ulonglong *)

+                                      (*(longlong *)(pDVar8 + 0x118) + (ulonglong)uVar7 * 0x10);

+                          }

+                          else {

+                            WdLogSingleEntry0(2);

+                            _WdLogGlobalForLineNumber = 0x13e;

+                            DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch")

+                            ;

+                          }

+                        }

+                      }

+                      *(ulonglong *)(local_1e0 + uVar14 * 8) = uVar18;

+                      if (uVar18 == 0) {

+                        WdLogSingleEntry0(1);

+                        _WdLogGlobalForLineNumber = 0x24a7;

+                        DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pAllocList[Idx] != NULL");

+                      }

+                      uVar13 = *(uint *)(uVar14 * 0x60 + local_188);

+                      uVar7 = uVar13 >> 6 & 0xffffff;

+                      if (uVar7 < *(uint *)(pDVar8 + 0x128)) {

+                        uVar7 = *(uint *)(*(longlong *)(pDVar8 + 0x118) + 8 +

+                                         (ulonglong)uVar7 * 0x10);

+                        if (((((byte)(uVar13 >> 0x19) & 0x60) == ((byte)uVar7 & 0x60)) &&

+                            ((uVar7 & 0x2000) == 0)) && ((uVar7 & 0x1f) != 0)) {

+                          puVar1 = (uint *)(*(longlong *)(pDVar8 + 0x118) + 8 +

+                                           ((ulonglong)(uVar13 >> 6) & 0xffffff) * 0x10);

+                          *puVar1 = *puVar1 | 0x2000;

+                        }

+                      }

+                      uVar13 = (int)uVar14 + 1;

+                      uVar19 = (ulonglong)uStack_190._4_4_;

+                      this = local_158;

+                      uVar14 = (ulonglong)uVar13;

+                    } while (uVar13 < uStack_190._4_4_);

+                  }

+                }

+                else if (uStack_190._4_4_ != 0) {

+                  do {

+                    uVar19 = (ulonglong)uStack_190._4_4_;

+                    if (*(longlong *)(local_1e0 + uVar15 * 8) == 0) break;

+                    uVar13 = *(uint *)(*(longlong *)(local_1e0 + uVar15 * 8) + 0x10);

+                    uVar7 = uVar13 >> 6 & 0xffffff;

+                    if (uVar7 < *(uint *)(pDVar8 + 0x128)) {

+                      uVar7 = *(uint *)(*(longlong *)(pDVar8 + 0x118) + 8 + (ulonglong)uVar7 * 0x10)

+                      ;

+                      if (((((byte)(uVar13 >> 0x19) & 0x60) == ((byte)uVar7 & 0x60)) &&

+                          ((uVar7 & 0x2000) == 0)) && ((uVar7 & 0x1f) != 0)) {

+                        puVar1 = (uint *)(*(longlong *)(pDVar8 + 0x118) + 8 +

+                                         ((ulonglong)(uVar13 >> 6) & 0xffffff) * 0x10);

+                        *puVar1 = *puVar1 | 0x2000;

+                      }

+                    }

+                    uVar19 = (ulonglong)uStack_190._4_4_;

+                    uVar13 = (int)uVar15 + 1;

+                    uVar15 = (ulonglong)uVar13;

+                  } while (uVar13 < uStack_190._4_4_);

+                }

+                local_1d8 = local_1e0;

+              }

+              else {

+                uVar13 = local_1b8._4_4_ >> 6 & 0xffffff;

+                if (uVar13 < *(uint *)(pDVar8 + 0x128)) {

+                  uVar7 = *(uint *)(*(longlong *)(pDVar8 + 0x118) + 8 + (ulonglong)uVar13 * 0x10);

+                  if (((((byte)(local_1b8 >> 0x39) & 0x60) != ((byte)uVar7 & 0x60)) ||

+                      ((uVar7 & 0x2000) != 0)) || ((uVar7 & 0x1f) == 0)) goto LAB_9;

+                  if ((uVar7 & 0x1f) != 4) {

+                    WdLogSingleEntry0(2);

+                    _WdLogGlobalForLineNumber = 0x13e;

+                    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch");

+                    uVar14 = local_1b8 >> 0x20;

+                    goto LAB_9;

+                  }

+                  local_1d0 = *(__uint64 **)

+                               (*(longlong *)(pDVar8 + 0x118) + (ulonglong)uVar13 * 0x10);

+                }

+                else {

+LAB_9:

+                  local_1d0 = (__uint64 *)0x0;

+                }

+                uVar19 = uVar15;

+                if ((local_1d0 != (__uint64 *)0x0) &&

+                   (uVar13 = (uint)(uVar14 >> 6) & 0xffffff, uVar19 = uVar18,

+                   uVar13 < *(uint *)(pDVar8 + 0x128))) {

+                  uVar13 = *(uint *)(*(longlong *)(pDVar8 + 0x118) + 8 + (ulonglong)uVar13 * 0x10);

+                  if ((((byte)(uVar14 >> 0x19) & 0x60) == ((byte)uVar13 & 0x60)) &&

+                     (((uVar13 & 0x2000) == 0 && ((uVar13 & 0x1f) != 0)))) {

+                    puVar1 = (uint *)(*(longlong *)(pDVar8 + 0x118) + 8 +

+                                     (uVar14 >> 6 & 0xffffff) * 0x10);

+                    *puVar1 = *puVar1 | 0x2000;

+                  }

+                }

+              }

+              DXGHANDLETABLELOCKEXCLUSIVE::~DXGHANDLETABLELOCKEXCLUSIVE(local_128);

+              DXGDEVICE::DestroyAllocationInternal(this,uVar19,local_1d8,local_1d0);

+              lVar5 = local_1e8;

+            }

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_1e0);

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_160);

+LAB_8:

+            COREDEVICEACCESS::~COREDEVICEACCESS(local_d8);

+            DXGADAPTERSTOPRESETLOCKSHARED::Release(local_140);

+            DXGDEVICELOCKONAPPROPRIATETHREADMODEL::~DXGDEVICELOCKONAPPROPRIATETHREADMODEL(local_150)

+            ;

+            DXGDEVICEBYHANDLE::~DXGDEVICEBYHANDLE(local_1f0);

+            DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_210);

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

+              return lVar5;

+            }

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

+              return lVar5;

+            }

+            McTemplateK0q_EtwWriteTransfer();

+            return lVar5;

+          }

+          WdLogSingleEntry2(3,this,0xffffffffc000000d);

+          _WdLogGlobalForLineNumber = 0x23d0;

+        }

+        else {

+          WdLogSingleEntry2(3,this,0xffffffffc000000d);

+          _WdLogGlobalForLineNumber = 0x23c5;

+        }

+      }

+      else {

+        WdLogSingleEntry2(3,local_168,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0x23a3;

       }

     }

-    in_EAX = (long)pvVar9;

-  }

-  return in_EAX;

+    else {

+      WdLogSingleEntry3(3,local_168,uStack_190._4_4_,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0x2387;

+    }

+  }

+LAB_6:

+  DXGDEVICEBYHANDLE::~DXGDEVICEBYHANDLE(local_1f0);

+LAB_2:

+  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_210);

+  if ((local_200 != '\0') && ((DAT_1 & 1) != 0)) {

+    McTemplateK0q_EtwWriteTransfer();

+  }

+  return -0x3ffffff3;

 }
```

## `CapturePresentMultiPlaneOverlayArgs3`  (modified)

```diff
--- CapturePresentMultiPlaneOverlayArgs3
+++ CapturePresentMultiPlaneOverlayArgs3
@@ -1,39 +1,507 @@
 

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

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

+/* long __cdecl CapturePresentMultiPlaneOverlayArgs3(struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY3

+   const * __ptr64,struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 * __ptr64,struct

+   _D3DKMT_MULTIPLANE_OVERLAY3 * __ptr64 * __ptr64 * __ptr64,struct _D3DKMT_MULTIPLANE_OVERLAY3 *

+   __ptr64 * __ptr64,struct _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 * __ptr64 * __ptr64,struct

+   tagRECT * __ptr64 * __ptr64 * __ptr64,unsigned int * __ptr64 * __ptr64,unsigned int * __ptr64 *

+   __ptr64,unsigned char * __ptr64 * __ptr64,struct _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *

+   __ptr64 * __ptr64) */

 

 long __cdecl

 CapturePresentMultiPlaneOverlayArgs3

           (_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *param_1,_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *param_2

           ,_D3DKMT_MULTIPLANE_OVERLAY3 ***param_3,_D3DKMT_MULTIPLANE_OVERLAY3 **param_4,

           _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 **param_5,tagRECT ***param_6,uint **param_7,

           uint **param_8,uchar **param_9,_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION **param_10)

 

 {

-  long lVar1;

-  ulonglong in_RAX;

-  char *pcVar2;

+  void *pvVar1;

+  _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *p_Var2;

   uint uVar3;

-  longlong unaff_RBX;

-  uint unaff_R14D;

-  char in_stack_00000060;

-  uint in_stack_0000008c;

+  undefined8 *puVar4;

+  void *pvVar5;

+  undefined1 auVar6 [16];

+  undefined4 uVar7;

+  undefined4 uVar8;

+  undefined4 uVar9;

+  uchar *_Dst;

+  _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *p_Var10;

+  int iVar11;

+  _D3DKMT_MULTIPLANE_OVERLAY3 **_Dst_00;

+  undefined8 uVar12;

+  _D3DKMT_MULTIPLANE_OVERLAY3 *p_Var13;

+  _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *p_Var14;

+  tagRECT **pptVar15;

+  uint *_Dst_01;

+  __uint64 _Var16;

+  uint *puVar17;

+  __uint64 _Var18;

+  tagRECT *ptVar19;

+  _D3DKMT_MULTIPLANE_OVERLAY3 *p_Var20;

+  uint uVar21;

+  tagRECT **pptVar22;

+  ulonglong uVar23;

+  size_t sVar24;

+  wchar_t *pwVar25;

+  longlong lVar26;

+  ulonglong uVar27;

+  undefined8 uVar28;

+  undefined8 local_f8;

+  uint *puStack_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  _D3DKMT_MULTIPLANE_OVERLAY3 **local_d8;

+  _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *p_Stack_d0;

+  undefined8 local_c8;

+  ulonglong uStack_c0;

+  uchar *local_b8;

+  undefined8 uStack_b0;

+  uint local_a8;

+  uint *local_a0;

+  _D3DKMT_MULTIPLANE_OVERLAY3 **local_98;

+  _D3DKMT_MULTIPLANE_OVERLAY3 *local_90;

+  _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *local_88;

+  uint *puStack_80;

+  uint *local_78;

+  uchar *puStack_70;

+  tagRECT **local_68;

+  _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *p_Stack_60;

+  uint local_58;

+  _D3DKMT_MULTIPLANE_OVERLAY3 **local_48;

   

-  pcVar2 = (char *)(in_RAX & 0xffffffffffffff84);

-  *pcVar2 = *pcVar2 + (char)pcVar2;

-  *(char *)(unaff_RBX + 0x80248c) = *(char *)(unaff_RBX + 0x80248c) + (char)param_1;

-  *pcVar2 = *pcVar2 + (char)pcVar2;

-  lVar1 = func_0x0001402c54b0();

-  uVar3 = unaff_R14D;

-  if (unaff_R14D < in_stack_0000008c) {

-    do {

-      ObfDereferenceObject(*(undefined8 *)(&stack0x000000d0 + (ulonglong)uVar3 * 8));

-      uVar3 = uVar3 + 1;

-    } while (uVar3 < in_stack_0000008c);

-  }

-  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)&param_10);

-  if ((in_stack_00000060 != (char)unaff_R14D) && ((DAT_0 & 1) != 0)) {

-    McTemplateK0q_EtwWriteTransfer();

-  }

-  return lVar1;

+  local_f8 = 0;

+  puStack_f0 = (void *)0x0;

+  local_e8 = 0;

+  uStack_e0 = 0;

+  local_d8 = (void *)0x0;

+  p_Stack_d0 = (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0;

+  local_c8 = 0;

+  uStack_c0 = 0;

+  local_b8 = (void *)0x0;

+  uStack_b0 = 0;

+  if ((int)DAT_0 < 0) {

+    iVar11 = Feature_3355956539__private_IsEnabledDeviceUsageNoInline();

+    LOCK();

+    if (DAT_0 == 0xffffffff) {

+      DAT_0 = (uint)(iVar11 != 0);

+    }

+    UNLOCK();

+  }

+  _Var18 = 0xffffffffffffffff;

+  uVar27 = 0;

+  if ((int)DAT_0 < 1) {

+    if (*(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 **)MmUserProbeAddress_exref <= param_1) {

+      param_1 = *(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 **)MmUserProbeAddress_exref;

+    }

+    RtlCopyVolatileMemory(&local_f8,param_1,0x50);

+  }

+  else {

+    local_f8 = *(ulonglong *)param_1;

+    puStack_f0 = *(uint **)(param_1 + 8);

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

+    uStack_e0 = *(ulonglong *)(param_1 + 0x18);

+    local_d8 = *(_D3DKMT_MULTIPLANE_OVERLAY3 ***)(param_1 + 0x20);

+    p_Stack_d0 = *(_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION **)(param_1 + 0x28);

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

+    uStack_c0 = *(ulonglong *)(param_1 + 0x38);

+    local_b8 = *(uchar **)(param_1 + 0x40);

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

+  }

+  uVar21 = uStack_e0._4_4_;

+  uVar23 = CONCAT44(0,uStack_e0._4_4_);

+  if (9 < uStack_e0._4_4_ - 1) {

+    uVar12 = PsGetCurrentProcess();

+    WdLogSingleEntry3(2,uStack_e0._4_4_,0xffffffffc000000d,uVar12);

+    _WdLogGlobalForLineNumber = 0x9cc;

+    uVar28 = PsGetCurrentProcess();

+    uVar27 = uStack_e0 >> 0x20;

+    uVar12 = 0xffffffffc000000d;

+    pwVar25 = 

+    L"Presenting multi plane overlay plane count (0x%I64x) is invalid, returing 0x%I64x at 0x%I64x";

+LAB_1:

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar25,uVar27,uVar12,uVar28,0,0);

+    return -0x3ffffff3;

+  }

+  if (0x3f < local_f8._4_4_ - 1) {

+    uVar12 = PsGetCurrentProcess();

+    WdLogSingleEntry2(2,0xffffffffc000000d,uVar12);

+    _WdLogGlobalForLineNumber = 0x9d5;

+    uVar12 = PsGetCurrentProcess();

+    uVar28 = 0;

+    uVar27 = 0xffffffffc000000d;

+    pwVar25 = L"Invalid ContextCount, returing 0x%I64x at 0x%I64x";

+    goto LAB_1;

+  }

+  local_90 = (_D3DKMT_MULTIPLANE_OVERLAY3 *)0x0;

+  local_88 = (_D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *)0x0;

+  puStack_80 = (uint *)0x0;

+  local_78 = (uint *)0x0;

+  puStack_70 = (uchar *)0x0;

+  local_68 = (tagRECT **)0x0;

+  p_Stack_60 = (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0;

+  local_58 = uStack_e0._4_4_;

+  auVar6._8_8_ = 0;

+  auVar6._0_8_ = uVar23;

+  _Var16 = SUB168(ZEXT816(8) * auVar6,0);

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

+    _Var16 = _Var18;

+  }

+  _Dst_00 = operator_new__(_Var16,0x4b677844,0x100);

+  local_98 = _Dst_00;

+  local_48 = _Dst_00;

+  if (_Dst_00 == (_D3DKMT_MULTIPLANE_OVERLAY3 **)0x0) {

+    uVar12 = PsGetCurrentProcess();

+    WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+    _WdLogGlobalForLineNumber = 0xa0e;

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+LAB_2:

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+LAB_3:

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+    pptVar15 = (tagRECT **)0x0;

+  }

+  else {

+    _Var16 = SUB168(ZEXT816(0x50) * ZEXT416(uStack_e0._4_4_),0);

+    if (SUB168(ZEXT816(0x50) * ZEXT416(uStack_e0._4_4_),8) != 0) {

+      _Var16 = _Var18;

+    }

+    p_Var13 = operator_new__(_Var16,0x4b677844,0x100);

+    local_90 = p_Var13;

+    if (p_Var13 == (_D3DKMT_MULTIPLANE_OVERLAY3 *)0x0) {

+      uVar12 = PsGetCurrentProcess();

+      WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+      _WdLogGlobalForLineNumber = 0xa18;

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+      goto LAB_2;

+    }

+    _Var16 = SUB168(ZEXT816(0x58) * ZEXT416(uStack_e0._4_4_),0);

+    if (SUB168(ZEXT816(0x58) * ZEXT416(uStack_e0._4_4_),8) != 0) {

+      _Var16 = _Var18;

+    }

+    p_Var14 = operator_new__(_Var16,0x4b677844,0x100);

+    local_88 = p_Var14;

+    if (p_Var14 == (_D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *)0x0) {

+      uVar12 = PsGetCurrentProcess();

+      WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+      _WdLogGlobalForLineNumber = 0xa22;

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+      goto LAB_3;

+    }

+    _Var16 = SUB168(ZEXT816(8) * ZEXT416(uStack_e0._4_4_),0);

+    if (SUB168(ZEXT816(8) * ZEXT416(uStack_e0._4_4_),8) != 0) {

+      _Var16 = _Var18;

+    }

+    pptVar15 = operator_new__(_Var16,0x4b677844,0x100);

+    local_68 = pptVar15;

+    if (pptVar15 == (tagRECT **)0x0) {

+      uVar12 = PsGetCurrentProcess();

+      WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+      _WdLogGlobalForLineNumber = 0xa2c;

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var14);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+    }

+    else {

+      _Var16 = SUB168(ZEXT816(4) * ZEXT416(local_f8._4_4_),0);

+      if (SUB168(ZEXT816(4) * ZEXT416(local_f8._4_4_),8) != 0) {

+        _Var16 = _Var18;

+      }

+      _Dst_01 = operator_new__(_Var16,0x4b677844,0x100);

+      puStack_80 = _Dst_01;

+      if (_Dst_01 == (uint *)0x0) {

+        uVar12 = PsGetCurrentProcess();

+        WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+        _WdLogGlobalForLineNumber = 0xa36;

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var14);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+        pptVar22 = pptVar15;

+        if (uVar21 != 0) {

+          do {

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar22);

+            uVar23 = uVar23 - 1;

+            pptVar22 = pptVar22 + 1;

+          } while (uVar23 != 0);

+        }

+      }

+      else {

+        auVar6 = ZEXT816(4) * ZEXT416(local_f8._4_4_ * uStack_e0._4_4_);

+        _Var16 = auVar6._0_8_;

+        if (auVar6._8_8_ != 0) {

+          _Var16 = _Var18;

+        }

+        puVar17 = operator_new__(_Var16,0x4b677844,0x100);

+        local_a0 = puVar17;

+        local_78 = puVar17;

+        if (puVar17 != (uint *)0x0) {

+          if (((local_b8 == (void *)0x0) || ((int)uStack_c0 == 0)) ||

+             (puStack_70 = operator_new__(uStack_c0 & 0xffffffff,0x4b677844,0x100),

+             puStack_70 != (uchar *)0x0)) {

+            _Dst = puStack_70;

+            if ((p_Stack_d0 != (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0) &&

+               (p_Stack_60 = operator_new(0x28,0x4b677844,0x100),

+               p_Stack_60 == (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0)) {

+              uVar12 = PsGetCurrentProcess();

+              WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+              _WdLogGlobalForLineNumber = 0xa59;

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var14);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_01);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puVar17);

+              pptVar22 = pptVar15;

+              if (uVar21 != 0) {

+                do {

+                  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar22);

+                  uVar23 = uVar23 - 1;

+                  pptVar22 = pptVar22 + 1;

+                } while (uVar23 != 0);

+              }

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+              return -0x3fffffe9;

+            }

+            p_Var10 = p_Stack_60;

+            sVar24 = (uStack_e0 >> 0x20) * 8;

+            pvVar1 = (void *)((longlong)local_d8 + sVar24);

+            if ((pvVar1 < local_d8) || (*(void **)MmUserProbeAddress_exref < pvVar1)) {

+              **(undefined1 **)MmUserProbeAddress_exref = 0;

+            }

+            memmove(_Dst_00,local_d8,sVar24);

+            sVar24 = (local_f8 >> 0x20) * 4;

+            pvVar1 = (void *)(sVar24 + (longlong)puStack_f0);

+            if ((pvVar1 < puStack_f0) || (*(void **)MmUserProbeAddress_exref < pvVar1)) {

+              **(undefined1 **)MmUserProbeAddress_exref = 0;

+            }

+            memmove(_Dst_01,puStack_f0,sVar24);

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

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

+                pvVar1 = (void *)((longlong)local_b8 + (uStack_c0 & 0xffffffff));

+                if ((pvVar1 < local_b8) || (*(void **)MmUserProbeAddress_exref < pvVar1)) {

+                  **(undefined1 **)MmUserProbeAddress_exref = 0;

+                }

+                memmove(_Dst,local_b8,uStack_c0 & 0xffffffff);

+              }

+            }

+            if (p_Stack_d0 != (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0) {

+              if (((undefined8 *)((longlong)p_Stack_d0 + 0x28) < p_Stack_d0) ||

+                 (*(undefined8 **)MmUserProbeAddress_exref <

+                  (undefined8 *)((longlong)p_Stack_d0 + 0x28))) {

+                **(undefined1 **)MmUserProbeAddress_exref = 0;

+              }

+              uVar12 = *(undefined8 *)((longlong)p_Stack_d0 + 8);

+              *(undefined8 *)p_Var10 = *(undefined8 *)p_Stack_d0;

+              *(undefined8 *)(p_Var10 + 8) = uVar12;

+              uVar12 = *(undefined8 *)((longlong)p_Stack_d0 + 0x18);

+              *(undefined8 *)(p_Var10 + 0x10) = *(undefined8 *)((longlong)p_Stack_d0 + 0x10);

+              *(undefined8 *)(p_Var10 + 0x18) = uVar12;

+              *(undefined8 *)(p_Var10 + 0x20) = *(undefined8 *)((longlong)p_Stack_d0 + 0x20);

+            }

+            local_a8 = 0;

+            uVar23 = uVar27;

+            while( true ) {

+              uVar21 = (uint)uVar23;

+              if (uStack_e0._4_4_ <= uVar21) {

+                local_b8 = _Dst;

+                p_Stack_d0 = p_Var10;

+                if (uStack_e0._4_4_ != 0) {

+                  do {

+                    p_Var20 = p_Var13 + uVar27 * 0x50;

+                    _Dst_00[uVar27] = p_Var20;

+                    *(_D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 **)(p_Var20 + 0x30) =

+                         p_Var14 + uVar27 * 0x58;

+                    *(uint **)(p_Var20 + 0x18) = puVar17 + (int)uVar27 * local_f8._4_4_;

+                    uVar21 = (int)uVar27 + 1;

+                    uVar27 = (ulonglong)uVar21;

+                  } while (uVar21 < uStack_e0._4_4_);

+                }

+                *(ulonglong *)param_2 = local_f8;

+                *(uint **)(param_2 + 8) = _Dst_01;

+                *(undefined8 *)(param_2 + 0x10) = local_e8;

+                *(ulonglong *)(param_2 + 0x18) = uStack_e0;

+                *(_D3DKMT_MULTIPLANE_OVERLAY3 ***)(param_2 + 0x20) = _Dst_00;

+                *(_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION **)(param_2 + 0x28) = p_Var10;

+                *(undefined8 *)(param_2 + 0x30) = local_c8;

+                *(ulonglong *)(param_2 + 0x38) = uStack_c0;

+                *(uchar **)(param_2 + 0x40) = _Dst;

+                *(undefined8 *)(param_2 + 0x48) = uStack_b0;

+                *param_3 = _Dst_00;

+                *param_4 = p_Var13;

+                *param_5 = p_Var14;

+                *param_6 = pptVar15;

+                *param_7 = _Dst_01;

+                *param_8 = puVar17;

+                *param_9 = _Dst;

+                *param_10 = p_Var10;

+                puStack_f0 = _Dst_01;

+                local_d8 = _Dst_00;

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+                return 0;

+              }

+              p_Var20 = _Dst_00[uVar23];

+              if ((p_Var20 + 0x50 < p_Var20) ||

+                 (*(_D3DKMT_MULTIPLANE_OVERLAY3 **)MmUserProbeAddress_exref < p_Var20 + 0x50)) {

+                **(undefined1 **)MmUserProbeAddress_exref = 0;

+              }

+              uVar12 = *(undefined8 *)(p_Var20 + 8);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50) = *(undefined8 *)p_Var20;

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 8) = uVar12;

+              uVar12 = *(undefined8 *)(p_Var20 + 0x18);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x10) = *(undefined8 *)(p_Var20 + 0x10);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x10 + 8) = uVar12;

+              uVar12 = *(undefined8 *)(p_Var20 + 0x28);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x20) = *(undefined8 *)(p_Var20 + 0x20);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x20 + 8) = uVar12;

+              uVar12 = *(undefined8 *)(p_Var20 + 0x38);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x30) = *(undefined8 *)(p_Var20 + 0x30);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x30 + 8) = uVar12;

+              uVar12 = *(undefined8 *)(p_Var20 + 0x48);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x40) = *(undefined8 *)(p_Var20 + 0x40);

+              *(undefined8 *)(p_Var13 + uVar23 * 0x50 + 0x40 + 8) = uVar12;

+              puVar4 = *(undefined8 **)(p_Var13 + uVar23 * 0x50 + 0x30);

+              lVar26 = uVar23 * 0x58;

+              if ((puVar4 + 0xb < puVar4) ||

+                 (*(undefined8 **)MmUserProbeAddress_exref < puVar4 + 0xb)) {

+                **(undefined1 **)MmUserProbeAddress_exref = 0;

+              }

+              uVar12 = puVar4[1];

+              *(undefined8 *)(p_Var14 + lVar26) = *puVar4;

+              *(undefined8 *)(p_Var14 + lVar26 + 8) = uVar12;

+              uVar12 = puVar4[3];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x10) = puVar4[2];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x10 + 8) = uVar12;

+              uVar12 = puVar4[5];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x20) = puVar4[4];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x20 + 8) = uVar12;

+              uVar12 = puVar4[7];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x30) = puVar4[6];

+              *(undefined8 *)(p_Var14 + lVar26 + 0x30 + 8) = uVar12;

+              uVar7 = *(undefined4 *)((longlong)puVar4 + 0x44);

+              uVar8 = *(undefined4 *)(puVar4 + 9);

+              uVar9 = *(undefined4 *)((longlong)puVar4 + 0x4c);

+              p_Var2 = p_Var14 + lVar26 + 0x40;

+              *(undefined4 *)p_Var2 = *(undefined4 *)(puVar4 + 8);

+              *(undefined4 *)(p_Var2 + 4) = uVar7;

+              *(undefined4 *)(p_Var2 + 8) = uVar8;

+              *(undefined4 *)(p_Var2 + 0xc) = uVar9;

+              *(undefined8 *)(p_Var14 + lVar26 + 0x50) = puVar4[10];

+              if (0xfff < *(uint *)(p_Var14 + lVar26 + 0x3c)) {

+                WdLogSingleEntry3(2,*(undefined4 *)(p_Var14 + uVar23 * 0x58 + 0x3c),uVar23,

+                                  0xffffffffc000000d);

+                _WdLogGlobalForLineNumber = 0xa88;

+                DxgkLogInternalTriageEvent

+                          (0,0x40000,0xffffffff,

+                           L"Invalid DirtyRectCount:%u on plane %u, returing 0x%I64x",

+                           *(undefined4 *)(p_Var14 + lVar26 + 0x3c),uVar23,0xffffffffc000000d,0,0);

+                `CapturePresentMultiPlaneOverlayArgs3'::__l2::_AUTO::~_AUTO(&local_98);

+                return -0x3ffffff3;

+              }

+              _Var18 = SUB168(ZEXT816(0x10) * ZEXT416(*(uint *)(p_Var14 + uVar23 * 0x58 + 0x3c)),0);

+              if (SUB168(ZEXT816(0x10) * ZEXT416(*(uint *)(p_Var14 + uVar23 * 0x58 + 0x3c)),8) != 0)

+              {

+                _Var18 = 0xffffffffffffffff;

+              }

+              ptVar19 = operator_new__(_Var18,0x4b677844,0x100);

+              pptVar15[uVar23] = ptVar19;

+              if (ptVar19 == (tagRECT *)0x0) {

+                uVar12 = PsGetCurrentProcess();

+                WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+                _WdLogGlobalForLineNumber = 0xa92;

+                `CapturePresentMultiPlaneOverlayArgs3'::__l2::_AUTO::~_AUTO(&local_98);

+                return -0x3fffffe9;

+              }

+              uVar3 = *(uint *)(p_Var14 + lVar26 + 0x3c);

+              pvVar5 = *(void **)(p_Var14 + lVar26 + 0x40);

+              ptVar19 = pptVar15[uVar23];

+              pvVar1 = (void *)((longlong)pvVar5 + (ulonglong)uVar3 * 0x10);

+              if ((pvVar1 < pvVar5) || (*(void **)MmUserProbeAddress_exref < pvVar1)) {

+                **(undefined1 **)MmUserProbeAddress_exref = 0;

+              }

+              memmove(ptVar19,pvVar5,(ulonglong)uVar3 * 0x10);

+              puVar17 = local_a0;

+              *(tagRECT **)(p_Var14 + uVar23 * 0x58 + 0x40) = pptVar15[uVar23];

+              uVar3 = *(uint *)(p_Var13 + uVar23 * 0x50 + 0x10);

+              if (local_f8._4_4_ < uVar3) break;

+              if (uVar3 != 0) {

+                pvVar5 = *(void **)(p_Var13 + uVar23 * 0x50 + 0x18);

+                pvVar1 = (void *)((longlong)pvVar5 + (ulonglong)uVar3 * 4);

+                if ((pvVar1 < pvVar5) || (*(void **)MmUserProbeAddress_exref < pvVar1)) {

+                  **(undefined1 **)MmUserProbeAddress_exref = 0;

+                }

+                memmove(local_a0 + uVar21 * local_f8._4_4_,pvVar5,(ulonglong)uVar3 * 4);

+              }

+              local_a8 = uVar21 + 1;

+              uVar23 = (ulonglong)local_a8;

+              _Dst_00 = local_48;

+            }

+            uVar12 = PsGetCurrentProcess();

+            WdLogSingleEntry2(2,0xffffffffc000000d,uVar12);

+            _WdLogGlobalForLineNumber = 0xa9c;

+            uVar12 = PsGetCurrentProcess();

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,L"Invalid AllocationCount, returing 0x%I64x at 0x%I64x",

+                       0xffffffffc000000d,uVar12,0,0,0);

+            `CapturePresentMultiPlaneOverlayArgs3'::__l2::_AUTO::~_AUTO(&local_98);

+            return -0x3ffffff3;

+          }

+          uVar12 = PsGetCurrentProcess();

+          WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+          _WdLogGlobalForLineNumber = 0xa4c;

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var14);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_01);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puVar17);

+          pptVar22 = pptVar15;

+          if (uVar21 != 0) {

+            do {

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar22);

+              uVar23 = uVar23 - 1;

+              pptVar22 = pptVar22 + 1;

+            } while (uVar23 != 0);

+          }

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+          goto LAB_4;

+        }

+        uVar12 = PsGetCurrentProcess();

+        WdLogSingleEntry2(3,0xffffffffc0000017,uVar12);

+        _WdLogGlobalForLineNumber = 0xa40;

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_00);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var13);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Var14);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(_Dst_01);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+        pptVar22 = pptVar15;

+        if (uVar21 != 0) {

+          do {

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar22);

+            uVar23 = uVar23 - 1;

+            pptVar22 = pptVar22 + 1;

+          } while (uVar23 != 0);

+        }

+      }

+    }

+  }

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+LAB_4:

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete((void *)0x0);

+  return -0x3fffffe9;

 }
```

## `NtGdiDdDDIPresentMultiPlaneOverlay3`  (modified)

```diff
--- NtGdiDdDDIPresentMultiPlaneOverlay3
+++ NtGdiDdDDIPresentMultiPlaneOverlay3
@@ -1,34 +1,937 @@
 

-undefined8 NtGdiDdDDIPresentMultiPlaneOverlay3(void)

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

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

+

+int NtGdiDdDDIPresentMultiPlaneOverlay3

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

 

 {

   longlong lVar1;

-  longlong unaff_RBP;

-  byte unaff_SIL;

-  undefined8 unaff_R14;

-  undefined4 in_stack_00000070;

+  undefined1 auVar2 [16];

+  DXGCONTEXT *pDVar3;

+  uchar uVar4;

+  int iVar5;

+  long lVar6;

+  uint uVar7;

+  DXGPROCESS *pDVar8;

+  undefined8 uVar9;

+  _D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *p_Var10;

+  DXGCONTEXT *pDVar11;

+  DISPLAY_SOURCE *pDVar12;

+  uint uVar13;

+  tagRECT **pptVar14;

+  tagRECT **pptVar15;

+  ulonglong uVar16;

+  undefined8 *puVar17;

+  wchar_t *pwVar18;

+  DXGCONTEXT *pDVar19;

+  undefined1 auStackY_338 [32];

+  int local_2d8 [2];

+  undefined4 local_2d0 [2];

+  undefined8 local_2c8;

+  undefined8 *local_2c0;

+  int *local_2b8;

+  _D3DKMT_MULTIPLANE_OVERLAY3 **local_2a8;

+  _D3DKMT_MULTIPLANE_OVERLAY3 *p_Stack_2a0;

+  _D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *local_298;

+  tagRECT **pptStack_290;

+  uint *local_288;

+  uint *puStack_280;

+  uchar *local_278;

+  _D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *p_Stack_270;

+  uint local_268;

+  longlong local_258;

+  int local_250;

+  DXGCONTEXT **local_248;

+  DXGCONTEXT *local_240 [4];

+  uint local_220;

+  _D3DDDI_HDR_METADATA_TYPE local_218;

+  uint local_214;

+  DXGCONTEXTBYHANDLE local_210 [16];

+  DXGCONTEXT *local_200;

+  undefined8 local_1f8;

+  uint *puStack_1f0;

+  ulonglong local_1e8;

+  undefined8 uStack_1e0;

+  undefined8 local_1d8;

+  undefined8 uStack_1d0;

+  undefined4 local_1c8;

+  _D3DDDI_HDR_METADATA_TYPE _Stack_1c4;

+  undefined8 uStack_1c0;

+  uchar *local_1b8;

+  undefined8 uStack_1b0;

+  uint local_1a8;

+  uchar *local_1a0;

+  undefined8 local_198;

+  longlong local_190;

+  undefined1 local_188;

+  longlong local_178;

+  long local_170;

+  uint local_16c;

+  longlong local_168 [6];

+  char local_138;

+  DXGHANDLETABLELOCKSHARED local_130 [24];

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined8 local_108;

+  undefined8 uStack_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  COREDEVICEACCESS local_c8 [160];

+  ulonglong local_28;

   

-  DXGPOINTERARRAYORDEREDACQUIRE<DXGSYNCOBJECT,&void___cdecl_AcquireSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),&void___cdecl_ReleaseSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),2>

-  ::

-  ~DXGPOINTERARRAYORDEREDACQUIRE<DXGSYNCOBJECT,&void___cdecl_AcquireSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),&void___cdecl_ReleaseSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),2>

-            ((DXGPOINTERARRAYORDEREDACQUIRE<DXGSYNCOBJECT,&void___cdecl_AcquireSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),&void___cdecl_ReleaseSyncObjectMutex(class_DXGSYNCOBJECT*___ptr64),2>

-              *)(ulonglong)((int)unaff_RBP - 0x18));

-  lVar1 = *(longlong *)(unaff_RBP + -0x78);

-  if ((lVar1 != unaff_RBP + -0x70) && (lVar1 != 0)) {

-    ExFreePoolWithTag(lVar1,0);

-  }

-  lVar1 = *(longlong *)(unaff_RBP + -0x48);

-  *(undefined8 *)(unaff_RBP + -0x78) = unaff_R14;

-  *(int *)(unaff_RBP + -0x50) = (int)unaff_R14;

-  if ((lVar1 != unaff_RBP + -0x40) && (lVar1 != 0)) {

-    ExFreePoolWithTag(lVar1,0);

-  }

-  *(undefined8 *)(unaff_RBP + -0x48) = unaff_R14;

-  *(int *)(unaff_RBP + -0x20) = (int)unaff_R14;

-  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)&stack0x00000070);

-  if ((*(char *)(unaff_RBP + -0x80) != (char)unaff_R14) && ((DAT_0 & unaff_SIL) != 0)) {

+                    /* 0x422f60  239  NtGdiDdDDIPresentMultiPlaneOverlay3 */

+  local_28 = __security_cookie ^ (ulonglong)auStackY_338;

+  local_2d8[0] = -0x3ffffff3;

+  local_1f8 = 0;

+  puStack_1f0 = (uint *)0x0;

+  local_1e8 = 0;

+  uStack_1e0 = 0;

+  local_1d8 = 0;

+  uStack_1d0 = 0;

+  local_1c8 = 0;

+  _Stack_1c4 = 0;

+  uStack_1c0 = 0;

+  local_1b8 = (uchar *)0x0;

+  uStack_1b0 = 0;

+  pDVar19 = (DXGCONTEXT *)0x0;

+  local_2c8 = 0;

+  local_2d0[0] = 0x874;

+  local_2c0 = &local_1f8;

+  local_2b8 = local_2d8;

+  if ((((byte)DAT_0 & 2) != 0) && ((DAT_1401617c2 & 1) != 0)) {

+    McTemplateK0q_EtwWriteTransfer(0,&EventProfilerEnter,param_3,0x874);

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_2d0,0x874);

+  pDVar8 = DXGPROCESS::GetCurrent();

+  if (param_1 == (_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *)0x0) {

+    local_2d8[0] = -0x3ffffff3;

+    uVar9 = PsGetCurrentProcess();

+    WdLogSingleEntry2(2,(longlong)local_2d8[0],uVar9);

+    _WdLogGlobalForLineNumber = 0xaf0;

+    PsGetCurrentProcess();

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Presenting multi plane overlay from unexpected process 0x%I64x 0x%I64x");

+    iVar5 = local_2d8[0];

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_2d0);

+    if (((byte)DAT_0 & 2) == 0) {

+      return iVar5;

+    }

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

+      McTemplateK0qqqqdqqq_EtwWriteTransfer(&DxgkControlGuid_Context);

+    }

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

+      return iVar5;

+    }

     McTemplateK0q_EtwWriteTransfer();

-  }

-  return 0xc000000d;

+    return iVar5;

+  }

+  local_118 = 0;

+  uStack_110 = 0;

+  local_108 = 0;

+  uStack_100 = 0;

+  local_f8 = 0;

+  uStack_f0 = 0;

+  local_e8 = 0;

+  uStack_e0 = 0;

+  local_d8 = 0;

+  uStack_d0 = 0;

+  if ((int)DAT_3 < 0) {

+    iVar5 = Feature_3355956539__private_IsEnabledDeviceUsageNoInline();

+    LOCK();

+    if (DAT_3 == 0xffffffff) {

+      DAT_3 = (uint)(iVar5 != 0);

+    }

+    UNLOCK();

+  }

+  if ((int)DAT_3 < 1) {

+    p_Var10 = param_1 + 0x1c;

+    if (*(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 **)MmUserProbeAddress_exref <= param_1 + 0x1c) {

+      p_Var10 = *(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 **)MmUserProbeAddress_exref;

+    }

+    local_268 = *(uint *)p_Var10;

+  }

+  else {

+    RtlCopyFromUser(&local_118,param_1,0x50);

+    local_268 = uStack_100._4_4_;

+  }

+  local_2a8 = (_D3DKMT_MULTIPLANE_OVERLAY3 **)0x0;

+  p_Stack_2a0 = (_D3DKMT_MULTIPLANE_OVERLAY3 *)0x0;

+  local_298 = (_D3DKMT_MULTIPLANE_OVERLAY_ATTRIBUTES3 *)0x0;

+  pptStack_290 = (tagRECT **)0x0;

+  local_288 = (uint *)0x0;

+  puStack_280 = (uint *)0x0;

+  local_278 = (uchar *)0x0;

+  p_Stack_270 = (_D3DKMT_MULTIPLANE_OVERLAY_POST_COMPOSITION *)0x0;

+  local_1a8 = local_268;

+  if ((int)DAT_3 < 0) {

+    iVar5 = Feature_3355956539__private_IsEnabledDeviceUsageNoInline();

+    LOCK();

+    if (DAT_3 == 0xffffffff) {

+      DAT_3 = (uint)(iVar5 != 0);

+    }

+    UNLOCK();

+  }

+  p_Var10 = (_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *)&local_118;

+  if ((int)DAT_3 < 1) {

+    p_Var10 = param_1;

+  }

+  local_2d8[0] = CapturePresentMultiPlaneOverlayArgs3

+                           (p_Var10,(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *)&local_1f8,&local_2a8,

+                            &p_Stack_2a0,&local_298,&pptStack_290,&local_288,&puStack_280,&local_278

+                            ,&p_Stack_270);

+  if (local_2d8[0] < 0) {

+    uVar9 = PsGetCurrentProcess();

+    WdLogSingleEntry2(2,(longlong)local_2d8[0],uVar9);

+    _WdLogGlobalForLineNumber = 0xb65;

+    PsGetCurrentProcess();

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Failed to capture multi plane overlay parameters 0x%I64x 0x%I64x");

+    iVar5 = local_2d8[0];

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_4;

+  }

+  if (uStack_1e0._4_4_ == 0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xb69;

+    DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"Present.PresentPlaneCount > 0");

+  }

+  if (10 < uStack_1e0._4_4_) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xb6a;

+    DxgkLogInternalTriageEvent

+              (0,0x40002,0xffffffff,L"Present.PresentPlaneCount <= DXGK_MAX_MPO_PLANES_PER_SOURCE");

+  }

+  if (local_1f8._4_4_ == 0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xb6b;

+    DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"Present.ContextCount > 0");

+  }

+  if (0x40 < local_1f8._4_4_) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xb6c;

+    DxgkLogInternalTriageEvent

+              (0,0x40002,0xffffffff,L"Present.ContextCount <= D3DDDI_MAX_BROADCAST_CONTEXT");

+  }

+  if (0xf < (uint)local_1e8) {

+    local_2d8[0] = -0x3ffffff3;

+    WdLogSingleEntry2(2,local_1e8 & 0xffffffff,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0xb74;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Invalid VidPnSoureId 0x%I64x specified in DxgkPresentMultiPlaneOverlay2, returning 0x%I64x"

+              );

+    iVar5 = local_2d8[0];

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_4;

+  }

+  if ((_Stack_1c4 == 0) && (local_1b8 == (uchar *)0x0)) {

+    local_214 = 0;

+    local_218 = 0;

+    local_1a0 = (uchar *)0x0;

+    lVar6 = AllocateAndPopulateHDRMetadataFromDisplay

+                      ((_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *)&local_1f8,&local_1a0,&local_218,

+                       &local_214);

+    if (lVar6 != 0) goto LAB_5;

+    local_1b8 = local_1a0;

+    _Stack_1c4 = local_218;

+    uStack_1c0 = CONCAT44(uStack_1c0._4_4_,local_214);

+    uStack_1e0 = uStack_1e0 | 0x80;

+    uVar13 = local_214;

+  }

+  else {

+LAB_5:

+    uVar13 = (uint)uStack_1c0;

+  }

+  if (_Stack_1c4 != 0) {

+    if (_Stack_1c4 != 1) {

+      if (_Stack_1c4 != 2) {

+        local_2d8[0] = -0x3ffffff3;

+        WdLogSingleEntry2(2,(longlong)(int)_Stack_1c4,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0xbc5;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,

+                   L"Invalid HDR metadata type 0x%I64x specified, returning 0x%I64x");

+        iVar5 = local_2d8[0];

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+        pptVar15 = pptStack_290;

+        if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+          uVar16 = (ulonglong)local_268;

+          pptVar14 = pptStack_290;

+          do {

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+            pptVar14 = pptVar14 + 1;

+            uVar16 = uVar16 - 1;

+          } while (uVar16 != 0);

+        }

+        goto LAB_4;

+      }

+      if ((uVar13 != 0) && (uVar13 != 0x48)) {

+        local_2d8[0] = -0x3ffffff3;

+        WdLogSingleEntry2(2,uVar13,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0xbb2;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,

+                   L"Invalid HDR metadata size 0x%I64x specified with D3DDDI_HDR_METADATA_TYPE_HDR10PLUS, returning 0x%I64x"

+                  );

+        iVar5 = local_2d8[0];

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+        pptVar15 = pptStack_290;

+        if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+          uVar16 = (ulonglong)local_268;

+          pptVar14 = pptStack_290;

+          do {

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+            pptVar14 = pptVar14 + 1;

+            uVar16 = uVar16 - 1;

+          } while (uVar16 != 0);

+        }

+        goto LAB_4;

+      }

+      if (local_1b8 == (uchar *)0x0) {

+LAB_6:

+        if (uVar13 == 0) goto LAB_7;

+      }

+      else if (uVar13 != 0) {

+        if (local_1b8 != (uchar *)0x0) goto LAB_7;

+        goto LAB_6;

+      }

+      local_2d8[0] = -0x3ffffff3;

+      WdLogSingleEntry2(2,uVar13,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xbbc;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"Invalid HDR metadata size 0x%I64x specified with D3DDDI_HDR_METADATA_TYPE_HDR10PLUS, returning 0x%I64x"

+                );

+      iVar5 = local_2d8[0];

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+      pptVar15 = pptStack_290;

+      if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+        uVar16 = (ulonglong)local_268;

+        pptVar14 = pptStack_290;

+        do {

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+          pptVar14 = pptVar14 + 1;

+          uVar16 = uVar16 - 1;

+        } while (uVar16 != 0);

+      }

+      goto LAB_4;

+    }

+    if ((uVar13 != 0) && (uVar13 != 0x1c)) {

+      local_2d8[0] = -0x3ffffff3;

+      WdLogSingleEntry2(2,uVar13,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xb9c;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"Invalid HDR metadata size 0x%I64x specified with D3DDDI_HDR_METADATA_TYPE_HDR10, returning 0x%I64x"

+                );

+      iVar5 = local_2d8[0];

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+      pptVar15 = pptStack_290;

+      if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+        uVar16 = (ulonglong)local_268;

+        pptVar14 = pptStack_290;

+        do {

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+          pptVar14 = pptVar14 + 1;

+          uVar16 = uVar16 - 1;

+        } while (uVar16 != 0);

+      }

+      goto LAB_4;

+    }

+    if (local_1b8 == (uchar *)0x0) {

+LAB_8:

+      if (uVar13 == 0) goto LAB_7;

+    }

+    else if (uVar13 != 0) {

+      if (local_1b8 != (uchar *)0x0) goto LAB_7;

+      goto LAB_8;

+    }

+    local_2d8[0] = -0x3ffffff3;

+    WdLogSingleEntry2(2,uVar13,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0xba6;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Invalid HDR metadata size 0x%I64x specified with D3DDDI_HDR_METADATA_TYPE_HDR10, returning 0x%I64x"

+              );

+    iVar5 = local_2d8[0];

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_4;

+  }

+  if ((uVar13 != 0) || (local_1b8 != (uchar *)0x0)) {

+    local_2d8[0] = -0x3ffffff3;

+    WdLogSingleEntry1(2,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0xb90;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Non-NULL HDR metadata specified with D3DDDI_HDR_METADATA_TYPE_NONE, returning 0x%I64x"

+              );

+    iVar5 = local_2d8[0];

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_4;

+  }

+LAB_7:

+  local_200 = (DXGCONTEXT *)0x0;

+  pwVar18 = (wchar_t *)&local_200;

+  DXGCONTEXTBYHANDLE::DXGCONTEXTBYHANDLE

+            (local_210,*puStack_1f0,pDVar8,(DXGCONTEXT **)pwVar18,false,true);

+  pDVar3 = local_200;

+  if (local_200 == (DXGCONTEXT *)0x0) {

+    local_2d8[0] = -0x3ffffff3;

+    uVar13 = *puStack_1f0;

+    uVar9 = PsGetCurrentProcess();

+    WdLogSingleEntry3(3,(longlong)local_2d8[0],uVar9,uVar13);

+    iVar5 = local_2d8[0];

+    _WdLogGlobalForLineNumber = 0xbd2;

+    DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_4;

+  }

+  if ((*(uint *)(*(longlong *)(*(longlong *)(*(DXGDEVICE **)(local_200 + 0x10) + 0x10) + 0x10) +

+                3000) >> 3 & 1) != 0) {

+    WdLogSingleEntry1(2,*puStack_1f0);

+    _WdLogGlobalForLineNumber = 0xbd8;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,L"Present is not supported on MCDM adapter context 0x%I64x");

+    DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_9;

+  }

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

+    WdLogSingleEntry0(3);

+    _WdLogGlobalForLineNumber = 0xbde;

+    DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+    goto LAB_9;

+  }

+  DXGDEVICEACCESSLOCKEXCLUSIVE::DXGDEVICEACCESSLOCKEXCLUSIVE

+            ((DXGDEVICEACCESSLOCKEXCLUSIVE *)&local_258,*(DXGDEVICE **)(local_200 + 0x10));

+  uVar13 = local_1f8._4_4_;

+  uVar16 = CONCAT44(0,local_1f8._4_4_);

+  local_248 = (DXGCONTEXT **)0x0;

+  local_220 = 0;

+  if (local_1f8._4_4_ < 5) {

+    local_248 = local_240;

+    if (local_1f8._4_4_ != 0) {

+      memset(local_240,0,uVar16 << 3);

+    }

+LAB_10:

+    local_220 = uVar13;

+  }

+  else {

+    auVar2._8_8_ = 0;

+    auVar2._0_8_ = uVar16;

+    if (7 < SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar2,0)) {

+      local_248 = (DXGCONTEXT **)ExAllocatePool2(0x100,uVar16 * 8,0x4b677844);

+      goto LAB_10;

+    }

+  }

+  if (local_248 == (DXGCONTEXT **)0x0) {

+    WdLogSingleEntry0(3);

+    _WdLogGlobalForLineNumber = 0xbe8;

+    if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+      ExFreePoolWithTag(local_248,0);

+    }

+    local_248 = (DXGCONTEXT **)0x0;

+    local_220 = 0;

+    if ((local_258 != 0) && (local_250 != 0)) {

+      ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+      KeLeaveCriticalRegion();

+    }

+    DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+  }

+  else {

+    *local_248 = pDVar3;

+    DXGHANDLETABLELOCKSHARED::DXGHANDLETABLELOCKSHARED(local_130,pDVar8);

+    uVar7 = (uint)pwVar18;

+    uVar13 = 1;

+    if (1 < local_1f8._4_4_) {

+      do {

+        uVar16 = (ulonglong)uVar13;

+        uVar7 = puStack_1f0[uVar16] >> 6 & 0xffffff;

+        pDVar11 = pDVar19;

+        if (uVar7 < *(uint *)(pDVar8 + 0x128)) {

+          puVar17 = (undefined8 *)((ulonglong)uVar7 * 0x10 + *(longlong *)(pDVar8 + 0x118));

+          uVar7 = *(uint *)(puVar17 + 1);

+          if (((((byte)(puStack_1f0[uVar16] >> 0x19) & 0x60) == ((byte)uVar7 & 0x60)) &&

+              ((uVar7 >> 0xd & 1) == 0)) && ((uVar7 & 0x1f) != 0)) {

+            if ((uVar7 & 0x1f) == 7) {

+              pDVar11 = (DXGCONTEXT *)*puVar17;

+            }

+            else {

+              WdLogSingleEntry0(2);

+              _WdLogGlobalForLineNumber = 0x13e;

+              pwVar18 = L"Handle type mismatch";

+              DxgkLogInternalTriageEvent(0,0x40000,0xffffffff);

+            }

+          }

+        }

+        uVar7 = (uint)pwVar18;

+        local_248[uVar16] = pDVar11;

+        pDVar11 = local_248[uVar16];

+        if (((pDVar11 == (DXGCONTEXT *)0x0) || ((*(uint *)(pDVar11 + 0x188) & 8) != 0)) ||

+           (*(longlong *)(pDVar11 + 0x10) != *(longlong *)(pDVar3 + 0x10))) {

+          WdLogSingleEntry4(2,pDVar3,puStack_1f0[uVar16],uVar16);

+          _WdLogGlobalForLineNumber = 0xc0c;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"0x%I64x failed with invalid broadcast context 0x%I64x at index %I64d returning 0x%I64x"

+                    );

+          DXGHANDLETABLELOCKEXCLUSIVE::~DXGHANDLETABLELOCKEXCLUSIVE

+                    ((DXGHANDLETABLELOCKEXCLUSIVE *)local_130);

+          if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+            ExFreePoolWithTag(local_248,0);

+          }

+          local_248 = (DXGCONTEXT **)0x0;

+          local_220 = 0;

+          if ((local_258 != 0) && (local_250 != 0)) {

+            ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+            KeLeaveCriticalRegion();

+          }

+          DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+          pptVar15 = pptStack_290;

+          if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+            uVar16 = (ulonglong)local_268;

+            pptVar14 = pptStack_290;

+            do {

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+              pptVar14 = pptVar14 + 1;

+              uVar16 = uVar16 - 1;

+            } while (uVar16 != 0);

+          }

+          goto LAB_9;

+        }

+        uVar13 = uVar13 + 1;

+      } while (uVar13 < local_1f8._4_4_);

+    }

+    DXGHANDLETABLELOCKEXCLUSIVE::~DXGHANDLETABLELOCKEXCLUSIVE

+              ((DXGHANDLETABLELOCKEXCLUSIVE *)local_130);

+    DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+    ::

+    DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+              ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                *)local_168,local_248,local_220,(uchar)uVar7,'\x01');

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

+      lVar1 = *(longlong *)(*(longlong *)(*(longlong *)(pDVar3 + 0x10) + 0x10) + 0x10);

+      LOCK();

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

+      UNLOCK();

+      local_198 = 0xffffffffffffffff;

+      local_190 = lVar1;

+      KeEnterCriticalRegion();

+      ExAcquirePushLockSharedEx(lVar1 + 0x88,0);

+      LOCK();

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

+      UNLOCK();

+      local_188 = 1;

+      COREDEVICEACCESS::COREDEVICEACCESS(local_c8,*(DXGDEVICE **)(pDVar3 + 0x10),1,uVar7,false);

+      local_2d8[0] = COREDEVICEACCESS::AcquireShared(local_c8,(char *)0x0);

+      if (local_2d8[0] < 0) {

+        uVar9 = PsGetCurrentProcess();

+        WdLogSingleEntry2(3,(longlong)local_2d8[0],uVar9);

+        iVar5 = local_2d8[0];

+        _WdLogGlobalForLineNumber = 0xc33;

+        COREDEVICEACCESS::~COREDEVICEACCESS(local_c8);

+        DXGADAPTERSTOPRESETLOCKSHARED::Release((DXGADAPTERSTOPRESETLOCKSHARED *)&local_198);

+        DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+        ::

+        ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                  ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                    *)local_168);

+        if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+          ExFreePoolWithTag(local_248,0);

+        }

+        local_248 = (DXGCONTEXT **)0x0;

+        local_220 = 0;

+        if ((local_258 != 0) && (local_250 != 0)) {

+          ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+          KeLeaveCriticalRegion();

+        }

+        DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+        pptVar15 = pptStack_290;

+        if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+          uVar16 = (ulonglong)local_268;

+          pptVar14 = pptStack_290;

+          do {

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+            pptVar14 = pptVar14 + 1;

+            uVar16 = uVar16 - 1;

+          } while (uVar16 != 0);

+        }

+      }

+      else {

+        lVar1 = *(longlong *)(*(DXGDEVICE **)(pDVar3 + 0x10) + 0x768);

+        if (lVar1 == 0) {

+          local_2d8[0] = -0x3ffffff3;

+          WdLogSingleEntry1(2,0xffffffffc000000d);

+          _WdLogGlobalForLineNumber = 0xc3b;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"PresentMultiPlaneOverlay called on a render only adapter, returning 0x%I64x")

+          ;

+          iVar5 = local_2d8[0];

+          COREDEVICEACCESS::~COREDEVICEACCESS(local_c8);

+          DXGADAPTERSTOPRESETLOCKSHARED::Release((DXGADAPTERSTOPRESETLOCKSHARED *)&local_198);

+          DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+          ::

+          ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                    ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                      *)local_168);

+          if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+            ExFreePoolWithTag(local_248,0);

+          }

+          local_248 = (DXGCONTEXT **)0x0;

+          local_220 = 0;

+          if ((local_258 != 0) && (local_250 != 0)) {

+            ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+            KeLeaveCriticalRegion();

+          }

+          DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+          pptVar15 = pptStack_290;

+          if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+            uVar16 = (ulonglong)local_268;

+            pptVar14 = pptStack_290;

+            do {

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+              pptVar14 = pptVar14 + 1;

+              uVar16 = uVar16 - 1;

+            } while (uVar16 != 0);

+          }

+        }

+        else {

+          if ((*(uint *)(pDVar8 + 0x198) >> 2 & 1) == 0) {

+            uVar4 = ADAPTER_DISPLAY::IsVidPnSourceOwner

+                              (*(ADAPTER_DISPLAY **)(lVar1 + 0xc48),*(DXGDEVICE **)(pDVar3 + 0x10),

+                               (uint)local_1e8);

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

+              local_2d8[0] = -0x3fffffde;

+              uVar9 = PsGetCurrentProcess();

+              WdLogSingleEntry2(2,(longlong)local_2d8[0],uVar9);

+              _WdLogGlobalForLineNumber = 0xc4a;

+              PsGetCurrentProcess();

+              DxgkLogInternalTriageEvent

+                        (0,0x40000,0xffffffff,

+                         L"Presenting multi plane overlay is only supported from the DWM process 0x%I64x 0x%I64x"

+                        );

+              iVar5 = local_2d8[0];

+              COREDEVICEACCESS::~COREDEVICEACCESS(local_c8);

+              DXGADAPTERSTOPRESETLOCKSHARED::Release((DXGADAPTERSTOPRESETLOCKSHARED *)&local_198);

+              DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+              ::

+              ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                        ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                          *)local_168);

+              if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+                ExFreePoolWithTag(local_248,0);

+              }

+              local_248 = (DXGCONTEXT **)0x0;

+              local_220 = 0;

+              if ((local_258 != 0) && (local_250 != 0)) {

+                ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+                KeLeaveCriticalRegion();

+              }

+              DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+              pptVar15 = pptStack_290;

+              if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+                uVar16 = (ulonglong)local_268;

+                pptVar14 = pptStack_290;

+                do {

+                  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+                  pptVar14 = pptVar14 + 1;

+                  uVar16 = uVar16 - 1;

+                } while (uVar16 != 0);

+              }

+              goto LAB_4;

+            }

+          }

+          local_2d8[0] = DXGCONTEXT::PresentMultiPlaneOverlay3

+                                   (local_200,(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *)&local_1f8,

+                                    local_c8,local_248);

+          if (local_2d8[0] == -0x3fe1fefa) {

+            DXGDEVICE::CloseInternalCddPrimaryHandle(*(DXGDEVICE **)(pDVar3 + 0x10),local_c8);

+          }

+          iVar5 = local_2d8[0];

+          lVar1 = _DAT_11;

+          uVar13 = KeQueryTimeIncrement();

+          pDVar12 = (DISPLAY_SOURCE *)

+                    ((ulonglong)*(uint *)(param_1 + 0x10) * 0xfb8 +

+                    *(longlong *)

+                     (*(longlong *)(*(longlong *)(*(longlong *)(local_200 + 0x10) + 0x768) + 0xc48)

+                     + 0x80));

+          if (pDVar12 != (DISPLAY_SOURCE *)0x0) {

+            local_170 = iVar5;

+            local_178 = (ulonglong)uVar13 * lVar1;

+            local_16c = *(uint *)(pDVar8 + 0x198) >> 2 & 1 | *(uint *)(param_1 + 0x18) >> 9 & 2;

+            DISPLAY_SOURCE::RecordPresentDiagHistory(pDVar12,&local_178);

+          }

+          COREDEVICEACCESS::~COREDEVICEACCESS(local_c8);

+          DXGADAPTERSTOPRESETLOCKSHARED::Release((DXGADAPTERSTOPRESETLOCKSHARED *)&local_198);

+          DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+          ::

+          ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                    ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                      *)local_168);

+          if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+            ExFreePoolWithTag(local_248,0);

+          }

+          local_248 = (DXGCONTEXT **)0x0;

+          local_220 = 0;

+          if ((local_258 != 0) && (local_250 != 0)) {

+            ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+            KeLeaveCriticalRegion();

+          }

+          pDVar8 = DXGPROCESS::GetCurrent();

+          DXGWORKQUEUE::FlushQueue((DXGWORKQUEUE *)(*(longlong *)(pDVar8 + 0x40) + 0x68));

+          iVar5 = local_2d8[0];

+          DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+          pptVar15 = pptStack_290;

+          if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+            uVar16 = (ulonglong)local_268;

+            pptVar14 = pptStack_290;

+            do {

+              DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+              pptVar14 = pptVar14 + 1;

+              uVar16 = uVar16 - 1;

+            } while (uVar16 != 0);

+          }

+        }

+      }

+LAB_4:

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_288);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puStack_280);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_278);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_270);

+      DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_2d0);

+      if (((byte)DAT_0 & 2) != 0) {

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

+          McTemplateK0qqqqdqqq_EtwWriteTransfer(&DxgkControlGuid_Context);

+        }

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

+          McTemplateK0q_EtwWriteTransfer();

+        }

+      }

+      return iVar5;

+    }

+    if (local_168[0] != 0) {

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0xc20;

+      DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+      ::

+      ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                  *)local_168);

+      if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+        ExFreePoolWithTag(local_248,0);

+      }

+      local_248 = (DXGCONTEXT **)0x0;

+      local_220 = 0;

+      if ((local_258 != 0) && (local_250 != 0)) {

+        ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+        KeLeaveCriticalRegion();

+      }

+      DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+      pptVar15 = pptStack_290;

+      if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+        uVar16 = (ulonglong)local_268;

+        pptVar14 = pptStack_290;

+        do {

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+          pptVar14 = pptVar14 + 1;

+          uVar16 = uVar16 - 1;

+        } while (uVar16 != 0);

+      }

+LAB_9:

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_288);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puStack_280);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_278);

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_270);

+      DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_2d0);

+      if (((byte)DAT_0 & 2) != 0) {

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

+          McTemplateK0qqqqdqqq_EtwWriteTransfer(&DxgkControlGuid_Context);

+        }

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

+          McTemplateK0q_EtwWriteTransfer();

+        }

+      }

+      return -0x3ffffff3;

+    }

+    WdLogSingleEntry0(3);

+    _WdLogGlobalForLineNumber = 0xc1b;

+    DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+    ::

+    ~DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+              ((DXGPOINTERARRAYORDEREDACQUIRE<DXGCONTEXT,&void___cdecl_AcquireContextLock(class_DXGCONTEXT*___ptr64),&void___cdecl_ReleaseContextLock(class_DXGCONTEXT*___ptr64),4>

+                *)local_168);

+    if ((local_248 != local_240) && (local_248 != (DXGCONTEXT **)0x0)) {

+      ExFreePoolWithTag(local_248,0);

+    }

+    local_248 = (DXGCONTEXT **)0x0;

+    local_220 = 0;

+    if ((local_258 != 0) && (local_250 != 0)) {

+      ExReleaseResourceLite(*(undefined8 *)(local_258 + 0x88));

+      KeLeaveCriticalRegion();

+    }

+    DXGCONTEXTBYHANDLE::~DXGCONTEXTBYHANDLE(local_210);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_2a0);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_298);

+    pptVar15 = pptStack_290;

+    if ((pptStack_290 != (tagRECT **)0x0) && (local_268 != 0)) {

+      uVar16 = (ulonglong)local_268;

+      pptVar14 = pptStack_290;

+      do {

+        DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*pptVar14);

+        pptVar14 = pptVar14 + 1;

+        uVar16 = uVar16 - 1;

+      } while (uVar16 != 0);

+    }

+  }

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pptVar15);

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_288);

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puStack_280);

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_278);

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(p_Stack_270);

+  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_2d0);

+  if (((byte)DAT_0 & 2) != 0) {

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

+      McTemplateK0qqqqdqqq_EtwWriteTransfer(&DxgkControlGuid_Context);

+    }

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

+      McTemplateK0q_EtwWriteTransfer();

+    }

+  }

+  return -0x3fffffe9;

 }
```

## `DpiInitializeGlobalState`  (modified)

```diff
--- DpiInitializeGlobalState
+++ DpiInitializeGlobalState
@@ -1,199 +1,663 @@
 

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

-/* WARNING: Instruction at (ram,0x000140437a8e) overlaps instruction at (ram,0x000140437a89)

-    */

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

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

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

 

-void DpiInitializeGlobalState(undefined8 param_1,char *param_2,longlong param_3,longlong param_4)

+ulonglong DpiInitializeGlobalState(void)

 

 {

-  undefined2 uVar1;

-  char cVar2;

-  char cVar6;

-  int in_EAX;

-  uint uVar3;

-  char cVar7;

-  int *piVar4;

-  char *pcVar5;

-  char cVar8;

-  char cVar9;

-  undefined6 uVar10;

-  char cVar11;

-  char cVar12;

-  char unaff_BL;

-  char unaff_BH;

-  undefined6 unaff_0000001a;

-  char unaff_SPL;

-  char unaff_BPL;

-  undefined1 *unaff_RSI;

-  char *pcVar13;

-  undefined1 *unaff_RDI;

-  undefined4 *puVar14;

-  char cVar15;

-  undefined7 uVar16;

-  longlong in_R10;

-  longlong in_R11;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  longlong unaff_R15;

-  bool bVar17;

+  longlong lVar1;

+  bool bVar2;

+  bool bVar3;

+  char cVar4;

+  int iVar5;

+  uint uVar6;

+  long lVar7;

+  longlong *plVar8;

+  longlong *plVar9;

+  DISPLAY_MUX_MGR *pDVar10;

+  longlong *plVar11;

+  ulonglong uVar12;

+  DISPLAY_MUX_MGR *this;

+  undefined4 extraout_XMM0_Da;

+  undefined1 auStackY_4b8 [32];

+  int local_478;

+  int local_474;

+  int local_470;

+  uint local_46c;

+  int local_468;

+  int local_464;

+  int local_460;

+  int local_45c;

+  int local_458;

+  int local_454;

+  undefined8 local_450;

+  undefined4 local_448;

+  undefined4 local_444;

+  undefined4 local_440;

+  undefined4 local_43c;

+  int local_438 [2];

+  undefined8 local_430;

+  undefined8 uStack_428;

+  undefined4 local_420 [2];

+  undefined8 local_418;

+  wchar_t *local_410;

+  undefined8 local_408;

+  wchar_t *local_400;

+  undefined8 local_3f8;

+  wchar_t *local_3f0;

+  undefined4 local_3e8;

+  undefined4 local_3e4;

+  undefined8 local_3e0;

+  undefined8 *local_3d8;

+  undefined4 local_3d0;

+  undefined4 local_3cc;

+  undefined8 local_3c8;

+  undefined8 uStack_3c0;

+  undefined8 local_3b8;

+  undefined8 uStack_3b0;

+  undefined8 local_3a8;

+  undefined4 local_3a0;

+  wchar_t *local_398;

+  int *local_390;

+  undefined4 local_388;

+  int *local_380;

+  undefined4 local_378;

+  undefined8 local_370;

+  undefined4 local_368;

+  undefined8 local_360;

+  undefined8 local_358;

+  undefined8 uStack_350;

+  undefined8 local_348;

+  undefined8 uStack_340;

+  undefined8 local_338;

+  undefined4 local_330;

+  wchar_t *local_328;

+  int *local_320;

+  undefined4 local_318;

+  int *local_310;

+  undefined4 local_308;

+  undefined8 local_300;

+  undefined4 local_2f8;

+  undefined8 local_2f0;

+  undefined8 local_2e8;

+  undefined8 uStack_2e0;

+  undefined8 local_2d8;

+  undefined8 uStack_2d0;

+  undefined8 local_2c8;

+  undefined4 local_2c0;

+  wchar_t *local_2b8;

+  undefined4 *local_2b0;

+  undefined4 local_2a8;

+  undefined4 *local_2a0;

+  undefined4 local_298;

+  undefined8 local_290;

+  undefined4 local_288;

+  wchar_t *local_280;

+  int *local_278;

+  undefined4 local_270;

+  int *local_268;

+  undefined4 local_260;

+  undefined8 local_258;

+  undefined4 local_250;

+  wchar_t *local_248;

+  int *local_240;

+  undefined4 local_238;

+  int *local_230;

+  undefined4 local_228;

+  undefined8 local_220;

+  undefined4 local_218;

+  undefined8 local_210;

+  undefined8 local_208;

+  undefined8 uStack_200;

+  undefined8 local_1f8;

+  undefined8 uStack_1f0;

+  undefined8 local_1e8;

+  undefined4 local_1e0;

+  wchar_t *local_1d8;

+  uint *local_1d0;

+  undefined4 local_1c8;

+  uint *local_1c0;

+  undefined4 local_1b8;

+  undefined8 local_1b0;

+  undefined4 local_1a8;

+  wchar_t *local_1a0;

+  int *local_198;

+  undefined4 local_190;

+  int *local_188;

+  undefined4 local_180;

+  undefined8 local_178;

+  undefined4 local_170;

+  wchar_t *local_168;

+  int *local_160;

+  undefined4 local_158;

+  int *local_150;

+  undefined4 local_148;

+  undefined8 local_140;

+  undefined4 local_138;

+  undefined8 local_130;

+  undefined8 local_128;

+  undefined8 uStack_120;

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined8 local_108;

+  undefined4 local_100;

+  wchar_t *local_f8;

+  int *local_f0;

+  undefined4 local_e8;

+  int *local_e0;

+  undefined4 local_d8;

+  undefined8 local_d0;

+  undefined4 local_c8;

+  wchar_t *local_c0;

+  int *local_b8;

+  undefined4 local_b0;

+  int *local_a8;

+  undefined4 local_a0;

+  undefined8 local_98;

+  undefined4 local_90;

+  wchar_t *local_88;

+  int *local_80;

+  undefined4 local_78;

+  int *local_70;

+  undefined4 local_68;

+  undefined8 local_60;

+  undefined4 local_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  ulonglong local_28;

   

-  uVar16 = (undefined7)((ulonglong)param_3 >> 8);

-  cVar12 = (char)((ulonglong)param_2 >> 8);

-  cVar11 = (char)param_2;

-  uVar10 = (undefined6)((ulonglong)param_1 >> 0x10);

-  cVar9 = (char)((ulonglong)param_1 >> 8);

-  cVar8 = (char)param_1;

-  uVar3 = in_EAX + 0xaeffbc5e;

-  cVar2 = (char)uVar3;

-  cVar6 = (char)unaff_RDI;

-  cRama2950043a2720043 = cVar2;

-  *(char *)(in_R10 + -0x17ffbc5e) = *(char *)(in_R10 + -0x17ffbc5e) + cVar6;

-  cRama3330043a30c0043 = cVar2;

-  *(char *)(unaff_R14 + -0x5d) = *(char *)(unaff_R14 + -0x5d) + cVar11;

-  *(char *)(unaff_R13 + -0x5d) = *(char *)(unaff_R13 + -0x5d) + cVar6;

-  *(char *)(param_3 + -0x35ffbc5d) = *(char *)(param_3 + -0x35ffbc5d) + unaff_BPL;

-  uRama4210043a3f60043 = uVar3;

-  *(char *)(param_4 + -0x5c) = *(char *)(param_4 + -0x5c) + cVar11;

-  *(char *)(in_R11 + -0x5c) = *(char *)(in_R11 + -0x5c) + cVar6;

-  *(char *)(in_R10 + -0x2affbc5c) = *(char *)(in_R10 + -0x2affbc5c) + unaff_BPL;

-  *unaff_RDI = *unaff_RSI;

-  cVar15 = (char)param_3 + (char)(unaff_RDI + 1);

-  unaff_RDI[1] = unaff_RSI[1];

-  cRam000000016843bdb2 = cRam000000016843bdb2 + cVar8;

-  puVar14 = (undefined4 *)(unaff_RDI + 6);

-  pcVar13 = unaff_RSI + 6;

-  *(undefined4 *)(unaff_RDI + 2) = *(undefined4 *)(unaff_RSI + 2);

-  pcVar5 = (char *)(unaff_R13 + -0x45ffbc82);

-  cVar6 = *pcVar5;

-  *pcVar5 = *pcVar5 + unaff_BL;

-  if (*pcVar5 == '\0' || SCARRY1(cVar6,unaff_BL) != *pcVar5 < '\0') {

-    pcVar5 = (char *)(CONCAT71(uVar16,cVar15) + 0x43 + CONCAT71(uVar16,cVar15) * 4);

-    *pcVar5 = *pcVar5 + unaff_BPL;

-    pcVar5 = (char *)(CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + -0x5b);

-    *pcVar5 = *pcVar5 + cVar8;

-code_r0x000140437a62:

-    pcVar5 = (char *)(CONCAT71(uVar16,cVar15) + -0x5b);

-    *pcVar5 = *pcVar5 + unaff_SPL;

-code_r0x000140437a66:

-    *(char *)(param_4 + -0x5b) = *(char *)(param_4 + -0x5b) + (char)pcVar13;

+  local_28 = __security_cookie ^ (ulonglong)auStackY_4b8;

+  this = (DISPLAY_MUX_MGR *)0x0;

+  local_408 = 0x3c003a;

+  local_3e4 = 0;

+  local_3cc = 0;

+  local_400 = L"Kernel-OneCore-DeviceFamilyID";

+  local_450 = 0;

+  local_440 = 0;

+  local_43c = 0;

+  local_444 = 0;

+  local_448 = 0;

+  local_3b8 = 0;

+  uStack_3b0 = 0;

+  bVar2 = false;

+  local_430 = 0;

+  uStack_428 = 0;

+  iVar5 = ZwQueryLicenseValue(&local_408,&local_444,&DAT_0,4);

+  if (iVar5 < 0) {

+    WdLogSingleEntry1(2,(longlong)iVar5);

+    _WdLogGlobalForLineNumber = 0x10ff;

+    DAT_0 = 3;

+  }

+  local_3f8 = 0x260024;

+  local_3f0 = L"Kernel-ProductInfo";

+  iVar5 = ZwQueryLicenseValue(&local_3f8,&local_444,&DAT_1,4);

+  if (iVar5 < 0) {

+    WdLogSingleEntry1(2,(longlong)iVar5);

+    _WdLogGlobalForLineNumber = 0x110f;

+    DAT_1 = 0;

+  }

+  iVar5 = RtlCheckRegistryKey(2,L"GraphicsDrivers\\DisableUSWC");

+  if (-1 < iVar5) {

+    DAT_2 = 1;

+  }

+  g_bDMgrIsSetupRunning = DMgrIsSetupRunning();

+  if (g_bDMgrIsSetupRunning == '\x01') {

+    DAT_3 = 1;

+  }

+  cVar4 = ExIsSoftBoot();

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

+    DpiKsrRestore();

+  }

+  DAT_4 = 0x1c44;

+  local_2a8 = 0x4000004;

+  local_270 = 0x4000004;

+  local_238 = 0x4000004;

+  local_2b8 = L"MiracastDefaultRtspPort";

+  local_478 = 0;

+  local_2b0 = &DAT_4;

+  local_2a0 = &DAT_4;

+  local_474 = 500000;

+  local_280 = L"PlatformSupportMiracast";

+  local_278 = &local_478;

+  local_2c8 = 0;

+  local_268 = &local_478;

+  local_248 = L"SuspendAdapterTimerPeriod";

+  local_240 = &local_474;

+  local_230 = &local_474;

+  local_2c0 = 0x120;

+  local_298 = 4;

+  local_290 = 0;

+  local_288 = 0x120;

+  local_260 = 4;

+  local_258 = 0;

+  local_250 = 0x120;

+  local_228 = 4;

+  local_220 = 0;

+  local_218 = 0;

+  local_210 = 0;

+  local_208 = 0;

+  uStack_200 = 0;

+  local_1f8 = 0;

+  uStack_1f0 = 0;

+  iVar5 = RtlQueryRegistryValuesEx(2,L"GraphicsDrivers",&local_2c8,0);

+  if ((((iVar5 < 0) || (DAT_4 == 0)) && (DAT_4 = 0x1c44, iVar5 < 0)) ||

+     (DAT_5 = 1, local_478 == 0)) {

+    DAT_5 = 0;

+  }

+  local_470 = 0;

+  DAT_6 = (longlong)-local_474;

+  local_3a8 = 0;

+  local_398 = L"SupportMultipleIntegratedDisplays";

+  local_390 = &local_470;

+  local_3a0 = 0x120;

+  local_380 = &local_470;

+  local_388 = 0x4000004;

+  local_378 = 4;

+  local_370 = 0;

+  local_368 = 0;

+  local_360 = 0;

+  local_358 = 0;

+  uStack_350 = 0;

+  local_348 = 0;

+  uStack_340 = 0;

+  iVar5 = RtlQueryRegistryValuesEx(2,L"GraphicsDrivers",&local_3a8,0);

+  DAT_7 = -1 < iVar5 && local_470 != 0;

+  local_46c = 0;

+  local_1c8 = 0x4000004;

+  local_190 = 0x4000004;

+  local_1d8 = L"HwSchMode";

+  local_1d0 = &local_46c;

+  local_158 = 0x4000004;

+  local_1c0 = &local_46c;

+  local_464 = 1;

+  local_468 = 0;

+  local_1a0 = L"HwSchOverrideBlockList";

+  local_198 = &local_464;

+  local_1e8 = 0;

+  local_188 = &local_464;

+  local_168 = L"HwSchTreatExperimentalAsStable";

+  local_160 = &local_468;

+  local_150 = &local_468;

+  local_1e0 = 0x120;

+  local_1b8 = 4;

+  local_1b0 = 0;

+  local_1a8 = 0x120;

+  local_180 = 4;

+  local_178 = 0;

+  local_170 = 0x120;

+  local_148 = 4;

+  local_140 = 0;

+  local_138 = 0;

+  local_130 = 0;

+  local_128 = 0;

+  uStack_120 = 0;

+  local_118 = 0;

+  uStack_110 = 0;

+  iVar5 = RtlQueryRegistryValuesEx(2,L"GraphicsDrivers",&local_1e8,0);

+  if ((iVar5 < 0) || (2 < local_46c)) {

+    DAT_8 = 0;

+    if (-1 < iVar5) goto LAB_9;

+LAB_10:

+    DAT_11 = 1;

   }

   else {

-    bVar17 = SCARRY1(cVar9,cVar8);

-    cVar9 = cVar9 + cVar8;

-    if (cVar9 == '\0' || bVar17 != cVar9 < '\0') {

-      *(char *)(in_R11 + -0x5b) = *(char *)(in_R11 + -0x5b) + cVar8;

-      goto code_r0x000140437a62;

+    DAT_8 = local_46c;

+LAB_9:

+    DAT_12 = local_468 != 0;

+    DAT_11 = 0;

+    if (local_464 != 0) goto LAB_10;

+  }

+  local_458 = 0;

+  local_460 = -1;

+  local_45c = -1;

+  local_108 = 0;

+  local_e8 = 0x4000004;

+  local_b0 = 0x4000004;

+  local_f8 = L"EnableBasicDisplayFallback";

+  local_f0 = &local_460;

+  local_78 = 0x4000004;

+  local_e0 = &local_460;

+  local_100 = 0x120;

+  local_c0 = L"DisableBasicDisplayFallback";

+  local_b8 = &local_45c;

+  local_a8 = &local_45c;

+  local_88 = L"ForcePreserveBootDisplay";

+  local_80 = &local_458;

+  local_70 = &local_458;

+  local_d8 = 4;

+  local_d0 = 0;

+  local_c8 = 0x120;

+  local_a0 = 4;

+  local_98 = 0;

+  local_90 = 0x120;

+  local_68 = 4;

+  local_60 = 0;

+  local_58 = 0;

+  local_50 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_38 = 0;

+  uStack_30 = 0;

+  iVar5 = RtlQueryRegistryValuesEx(2,L"GraphicsDrivers\\BasicDisplay",&local_108,0);

+  if (-1 < iVar5) {

+    if ((local_460 != 1) && (local_45c == 1)) {

+      DAT_13 = 1;

     }

-    cVar7 = (char)(uVar3 >> 8);

-    uVar1 = (undefined2)(uVar3 >> 0x10);

-    cVar6 = cVar7 + cVar9;

-    uVar3 = CONCAT22(uVar1,CONCAT11(cVar6,cVar2));

-    if (cVar6 == '\0' || SCARRY1(cVar7,cVar9) != cVar6 < '\0') goto code_r0x000140437a62;

-    cVar7 = *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8));

-    *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) =

-         *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) + cVar2;

-    if (*(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) != '\0' &&

-        SCARRY1(cVar7,cVar2) == *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) < '\0')

-    goto code_r0x000140437a66;

-    cVar7 = *pcVar13;

-    *pcVar13 = *pcVar13 + unaff_BL;

-    if (*pcVar13 == '\0' || SCARRY1(cVar7,unaff_BL) != *pcVar13 < '\0') {

-      cVar7 = *pcVar13;

-      *pcVar13 = *pcVar13 + cVar12;

-      if (*pcVar13 == '\0' || SCARRY1(cVar7,cVar12) != *pcVar13 < '\0') {

-        unaff_RSI[0x85] = unaff_RSI[0x85] + cVar8;

-        *(char *)(param_4 + 0x7f) = *(char *)(param_4 + 0x7f) + unaff_BPL;

-        pcVar5 = (char *)(CONCAT71(uVar16,cVar15) + -0x5effbc81);

-        cVar7 = *pcVar5;

-        *pcVar5 = *pcVar5 + cVar8;

-        if (*pcVar5 == '\0' || SCARRY1(cVar7,cVar8) != *pcVar5 < '\0') {

-          pcVar5 = (char *)((ulonglong)uVar3 - 0x34ffbc81);

-          cVar7 = *pcVar5;

-          *pcVar5 = *pcVar5 + cVar12;

-          if (*pcVar5 == '\0' || SCARRY1(cVar7,cVar12) != *pcVar5 < '\0') {

-            cVar7 = cVar6 + unaff_BL;

-            uVar3 = CONCAT22(uVar1,CONCAT11(cVar7,cVar2));

-            if (cVar7 == '\0' || SCARRY1(cVar6,unaff_BL) != cVar7 < '\0') {

-              bVar17 = SCARRY1(cVar8,cVar9);

-              cVar8 = cVar8 + cVar9;

-              if (cVar8 == '\0' || bVar17 != cVar8 < '\0') {

-                bVar17 = SCARRY1(unaff_BH,unaff_BH);

-                unaff_BH = unaff_BH * '\x02';

-                if (unaff_BH != '\0' && bVar17 == unaff_BH < '\0') goto code_r0x000140437a92;

-                *pcVar13 = *pcVar13 + cVar11;

-                *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-                     *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + '?';

-                *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-                     *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + 'S';

-                *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-                     *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + 'l';

-                *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-                     *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + 'K';

-                *puVar14 = *(undefined4 *)pcVar13;

-                pcVar13 = unaff_RSI + 10;

-                puVar14 = (undefined4 *)(unaff_RDI + 10);

-                goto code_r0x000140437a62;

+    DAT_14 = local_458 == 1;

+  }

+  local_454 = 0;

+  local_338 = 0;

+  local_328 = L"ForceBddFallbackOnly";

+  local_320 = &local_454;

+  local_330 = 0x120;

+  local_310 = &local_454;

+  local_318 = 0x4000004;

+  local_308 = 4;

+  local_300 = 0;

+  local_2f8 = 0;

+  local_2f0 = 0;

+  local_2e8 = 0;

+  uStack_2e0 = 0;

+  local_2d8 = 0;

+  uStack_2d0 = 0;

+  iVar5 = RtlQueryRegistryValuesEx(2,L"GraphicsDrivers",&local_338,0);

+  if (-1 < iVar5) {

+    DAT_15 = local_454 != 0;

+  }

+  RtlInitUnicodeString

+            (&local_430,L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Video\\");

+  local_3d8 = &local_430;

+  local_3e8 = 0x30;

+  local_3e0 = 0;

+  local_3d0 = 0x240;

+  local_3c8 = 0;

+  uStack_3c0 = 0;

+  iVar5 = ZwCreateKey(&local_450,0xc,&local_3e8);

+  if (iVar5 < 0) {

+    if (iVar5 != -0x3fffffcb) {

+      WdLogSingleEntry1(2,(longlong)iVar5);

+      _WdLogGlobalForLineNumber = 0x11fa;

+    }

+  }

+  else {

+    ZwClose(local_450);

+  }

+  RtlInitUnicodeString

+            (&local_430,L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\GraphicsDrivers")

+  ;

+  local_3d8 = &local_430;

+  local_3e8 = 0x30;

+  local_3e0 = 0;

+  local_3d0 = 0x240;

+  local_3c8 = 0;

+  uStack_3c0 = 0;

+  iVar5 = ZwOpenKey(&local_450,0x40000000,&local_3e8);

+  uVar12 = (ulonglong)iVar5;

+  bVar3 = bVar2;

+  if (iVar5 < 0) {

+    WdLogSingleEntry1(2,uVar12);

+    _WdLogGlobalForLineNumber = 0x1213;

+  }

+  else {

+    local_440 = 0x11007;

+    RtlInitUnicodeString(&local_430,L"DxgKrnlVersion");

+    iVar5 = ZwSetValueKey(local_450,&local_430,0,4);

+    uVar12 = (ulonglong)iVar5;

+    if (iVar5 < 0) {

+      ZwClose(local_450);

+      WdLogSingleEntry1(2,uVar12);

+      _WdLogGlobalForLineNumber = 0x1229;

+    }

+    else {

+      local_43c = 0x5013;

+      RtlInitUnicodeString(&local_430,L"MinDxgKrnlVersion");

+      iVar5 = ZwSetValueKey(local_450,&local_430,0,4);

+      uVar12 = (ulonglong)iVar5;

+      ZwClose(local_450);

+      if (iVar5 < 0) {

+        WdLogSingleEntry1(2,uVar12);

+        _WdLogGlobalForLineNumber = 0x123f;

+      }

+      else {

+        _DpGlobals = 0;

+        DAT_16 = 0;

+        plVar8 = (longlong *)MmGetPhysicalMemoryRanges();

+        if (plVar8 == (longlong *)0x0) {

+          uVar12 = 0xffffffffc000009a;

+          WdLogSingleEntry1(6,0xffffffffc000009a);

+          _WdLogGlobalForLineNumber = 0x1257;

+        }

+        else {

+          plVar9 = plVar8 + 1;

+          lVar1 = *plVar9;

+          plVar11 = plVar8;

+          pDVar10 = this;

+          while (lVar1 != 0) {

+            _DpGlobals = _DpGlobals + lVar1;

+            if (DAT_16 < *plVar11 + *plVar9) {

+              DAT_16 = *plVar11 + *plVar9;

+            }

+            pDVar10 = (DISPLAY_MUX_MGR *)(ulonglong)((int)pDVar10 + 1);

+            plVar11 = plVar8 + (longlong)pDVar10 * 2;

+            plVar9 = plVar11 + 1;

+            lVar1 = *plVar9;

+          }

+          ExFreePoolWithTag(plVar8,0);

+          DAT_17 = ExAllocatePool2(0x40,0x38,0x74727044);

+          if (DAT_17 == 0) {

+            uVar12 = 0xc0000017;

+            WdLogSingleEntry1(6,0xffffffffc0000017);

+            _WdLogGlobalForLineNumber = 0x1283;

+          }

+          else {

+            KeInitializeMutex(DAT_17,0);

+            _DAT_18 = 0;

+            DAT_19 = &DAT_140162d48;

+            DAT_20 = &DAT_20;

+            KeInitializeEvent(&DAT_21,0,0);

+            DAT_22 = 0;

+            ExInitializeNPagedLookasideList(&DAT_23,0,0,0x200);

+            bVar3 = true;

+            DAT_24 = ExAllocatePool2(0x40,0x38,0x74727044);

+            if (DAT_24 == 0) {

+              uVar12 = 0xc0000017;

+              WdLogSingleEntry1(6,0xffffffffc0000017);

+              _WdLogGlobalForLineNumber = 0x12b1;

+            }

+            else {

+              KeInitializeMutex(DAT_24,0);

+              DAT_25 = 0;

+              DAT_26 = &DAT_140162fa0;

+              DAT_27 = &DAT_27;

+              KeInitializeTimerEx(&DAT_28,1);

+              KeInitializeDpc(&DAT_29,DpiPdoPollingDpc,0);

+              DAT_30 = IoAllocateWorkItem(g_pDriverObject);

+              if (DAT_30 == 0) {

+                uVar12 = 0xc0000017;

+                WdLogSingleEntry1(6,0xffffffffc0000017);

+                _WdLogGlobalForLineNumber = 0x12c3;

+              }

+              else {

+                ExInitializeNPagedLookasideList(&DAT_31,0,0,0x200);

+                DAT_32 = 0;

+                bVar2 = true;

+                KeInitializeMutex(&DAT_33,0);

+                local_438[0] = 2;

+                DAT_34 = &DAT_1401631b0;

+                DAT_35 = &DAT_35;

+                local_420[0] = 4;

+                iVar5 = (**(code **)(HalDispatchTable_exref + 8))(9,4,local_438,local_420);

+                if ((iVar5 < 0) || (DAT_36 = 1, local_438[0] == 2)) {

+                  DAT_36 = 0;

+                }

+                DAT_37 = 0xffffffff;

+                DAT_38 = 0;

+                KeInitializeSpinLock(&DAT_39);

+                DAT_40 = &DAT_1401631d0;

+                DAT_41 = &DAT_41;

+                DAT_42 = 0;

+                DAT_43 = &DAT_1401631e0;

+                _DAT_44 = &DAT_44;

+                iVar5 = IoRegisterPlugPlayNotification

+                                  (2,1,&GUID_DEVINTERFACE_UMDF_MIRACAST_DIVICE_ARRIVAL);

+                uVar12 = (ulonglong)iVar5;

+                if (iVar5 < 0) {

+                  WdLogSingleEntry1(2,uVar12);

+                  _WdLogGlobalForLineNumber = 0x130e;

+                  DAT_45 = 0;

+                }

+                else {

+                  local_418 = 0x860084;

+                  local_410 = 

+                  L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\GraphicsDrivers";

+                  iVar5 = Feature_Servicing_GraphicsKernel_FeatureInterfaceExtensions__private_IsEnabledDeviceUsageNoInline

+                                    ();

+                  if (iVar5 == 0) {

+                    uVar6 = DxgkCreateFeatureDatabase

+                                      ((_UNICODE_STRING *)&local_418,

+                                       (_DXGKDDI_FEATURE_INTERFACE *)0x0,true,false,

+                                       (DXGK_FEATURE_DATABASE **)&DAT_46);

+                  }

+                  else {

+                    uVar6 = DxgkCreateFeatureDatabase_2

+                                      ((_UNICODE_STRING *)&local_418,

+                                       (_DXGKDDI_FEATURE_INTERFACE_2 *)0x0,true,false,

+                                       (DXGK_FEATURE_DATABASE **)&DAT_46);

+                  }

+                  uVar12 = (ulonglong)uVar6;

+                  if ((int)uVar6 < 0) {

+                    WdLogSingleEntry1(2,(longlong)(int)uVar6);

+                    _WdLogGlobalForLineNumber = 0x1324;

+                  }

+                  else {

+                    DAT_47 = 0;

+                    DAT_48 = &DAT_140162ee0;

+                    DAT_49 = &DAT_49;

+                    _DAT_50 = 0;

+                    _DAT_51 = 0;

+                    _DAT_52 = 1;

+                    _DAT_53 = 0;

+                    _DAT_54 = 0;

+                    KeInitializeEvent(&DAT_55,1,0);

+                    KeInitializeEvent(&DAT_56,0,1);

+                    DAT_57 = 0;

+                    KeInitializeMutex(&DAT_58,0);

+                    DAT_59 = &DAT_140163320;

+                    DAT_60 = &DAT_60;

+                    DpiIndirectDisplayInitialStartTracker();

+                    DAT_61 = 0;

+                    DAT_62 = 1;

+                    DAT_63 = 0;

+                    pDVar10 = operator_new(0x168,0x4b677844,0x100);

+                    if (pDVar10 != (DISPLAY_MUX_MGR *)0x0) {

+                      *(undefined4 *)(pDVar10 + 0x34) = 0xffffffff;

+                      *(undefined8 *)(pDVar10 + 0x18) = 0;

+                      *(undefined8 *)(pDVar10 + 0x20) = 0;

+                      *(undefined4 *)(pDVar10 + 0x30) = 0;

+                      *(undefined4 *)(pDVar10 + 0x38) = 1;

+                      *(undefined8 *)(pDVar10 + 0x40) = 0;

+                      *(undefined8 *)(pDVar10 + 0x48) = 0;

+                      *(undefined8 *)(pDVar10 + 0x58) = 0;

+                      *pDVar10 = (DISPLAY_MUX_MGR)0x0;

+                      *(undefined4 *)(pDVar10 + 4) = 1;

+                      pDVar10[8] = (DISPLAY_MUX_MGR)0x0;

+                      *(undefined4 *)(pDVar10 + 0xc) = 1;

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

+                      *(undefined4 *)(pDVar10 + 0x50) = 0;

+                      pDVar10[0x54] = (DISPLAY_MUX_MGR)0x0;

+                      *(undefined8 *)(pDVar10 + 0x60) = 0;

+                      *(undefined8 *)(pDVar10 + 0x68) = 0;

+                      pDVar10[0x70] = (DISPLAY_MUX_MGR)0x0;

+                      *(undefined8 *)(pDVar10 + 0x74) = 0;

+                      *(undefined8 *)(pDVar10 + 0x7c) = 0;

+                      *(undefined4 *)(pDVar10 + 0x84) = 0;

+                      *(undefined8 *)(pDVar10 + 0x88) = 0;

+                      *(undefined4 *)(pDVar10 + 0x90) = 0;

+                      pDVar10[0x94] = (DISPLAY_MUX_MGR)0x0;

+                      memset(pDVar10 + 0x95,0,0xd1);

+                      this = pDVar10;

+                    }

+                    DAT_64 = this;

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

+                      WdLogSingleEntry0(2);

+                      _WdLogGlobalForLineNumber = 0x134e;

+                      uVar12 = 0xc0000017;

+                    }

+                    else {

+                      lVar7 = DISPLAY_MUX_MGR::Init(this);

+                      uVar12 = (ulonglong)lVar7;

+                      if (lVar7 < 0) {

+                        WdLogSingleEntry1(2,uVar12);

+                        _WdLogGlobalForLineNumber = 0x1355;

+                      }

+                      else {

+                        iVar5 = Feature_ForceConnectionDetectionOnDcToAc__private_IsEnabledDeviceUsageNoInline

+                                          ();

+                        if (iVar5 != 0) {

+                          KeInitializeMutex(&DAT_65,0);

+                        }

+                        lVar7 = DpiCreateNtObjectTypes();

+                        uVar12 = (ulonglong)lVar7;

+                        if (-1 < lVar7) {

+                          iVar5 = Feature_ForceMonitorDetectionOnUsbTunnelStateChange__private_IsEnabledDeviceUsageNoInline

+                                            ();

+                          if (iVar5 != 0) {

+                            iVar5 = ExSubscribeWnfStateChange

+                                              (&DAT_66,&WNF_USB_USB4_DP_TUNNEL_CREATED,1,0);

+                            if (iVar5 < 0) {

+                              MicrosoftTelemetryAssertTriggeredArgsMsgKM

+                                        (extraout_XMM0_Da,iVar5,0,

+                                         "Failed to subscribe USB tunneling state change WNF notification."

+                                        );

+                              WdLogSingleEntry1(2,(longlong)iVar5);

+                              _WdLogGlobalForLineNumber = 0x138d;

+                              DAT_66 = 0;

+                            }

+                          }

+                          goto LAB_67;

+                        }

+                        WdLogSingleEntry1(2,uVar12);

+                        _WdLogGlobalForLineNumber = 0x1365;

+                      }

+                    }

+                  }

+                }

               }

             }

-            else {

-              *(char *)(unaff_R14 + -0x7f) = *(char *)(unaff_R14 + -0x7f) + cVar11;

-            }

-            pcVar5 = (char *)(CONCAT71(uVar16,cVar15) + CONCAT71(uVar16,cVar15));

-            *pcVar5 = *pcVar5 + unaff_SPL;

-            goto code_r0x000140437a92;

           }

-          *(char *)CONCAT71(uVar16,cVar15) = *(char *)CONCAT71(uVar16,cVar15) + cVar8;

-        }

-        else {

-          cVar15 = cVar15 + cVar11;

         }

       }

-      else {

-        *(char *)(in_R11 + 0x7f0043a5) = *(char *)(in_R11 + 0x7f0043a5) + unaff_BL;

-        *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-             *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + -0x60;

-        *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-             *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + -0x44;

-      }

     }

   }

-  *(char *)(param_4 + -0x64ffbc5b) = *(char *)(param_4 + -0x64ffbc5b) + (char)uVar3;

-  *puVar14 = *(undefined4 *)pcVar13;

-  *(char *)(unaff_R15 + -0x80) = *(char *)(unaff_R15 + -0x80) + (char)puVar14 + '\x04';

-  pcVar5 = (char *)(CONCAT71(uVar16,cVar15) + -0x43ffbc80);

-  *pcVar5 = *pcVar5 + unaff_SPL;

-  *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + -0x30;

-  *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + -0x17;

-  *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + '\b';

-  *(int *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(int *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + 0x438156;

-  uVar3 = uVar3 & 0xffffff00;

-code_r0x000140437a92:

-  uVar3 = uVar3 & 0x28002700;

-  piVar4 = (int *)(ulonglong)uVar3;

-  *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) =

-       *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) + cVar9;

-  *param_2 = *param_2 + cVar9;

-  *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(char *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) + cVar9;

-  *(char *)((longlong)piVar4 * 2) = *(char *)((longlong)piVar4 * 2) + cVar9;

-  *(char *)piVar4 = (char)*piVar4;

-  *piVar4 = *piVar4 + uVar3;

-  pcVar5 = (char *)(ulonglong)(uVar3 + 0xd0ffd200);

-  *pcVar5 = *pcVar5 + cVar12;

-  *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) =

-       *(char *)CONCAT62(uVar10,CONCAT11(cVar9,cVar8)) + cVar12;

-  *param_2 = *param_2;

-  *(undefined1 *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL)) =

-       *(undefined1 *)CONCAT62(unaff_0000001a,CONCAT11(unaff_BH,unaff_BL));

-  *param_2 = *param_2 + cVar12;

-  *(undefined1 *)((longlong)pcVar5 * 2) = *(undefined1 *)((longlong)pcVar5 * 2);

-  pcVar5 = (char *)((ulonglong)(uVar3 + 0x3ffd800) * 2);

-  *pcVar5 = *pcVar5 + cVar12;

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

-  halt_baddata();

+  iVar5 = Feature_ForceMonitorDetectionOnUsbTunnelStateChange__private_IsEnabledDeviceUsageNoInline

+                    ();

+  if ((iVar5 != 0) && (DAT_66 != 0)) {

+    ExUnsubscribeWnfStateChange();

+    DAT_66 = 0;

+  }

+  if (DAT_30 != 0) {

+    IoFreeWorkItem();

+  }

+  if (bVar2) {

+    ExDeleteNPagedLookasideList(&DAT_31);

+  }

+  if (DAT_24 != 0) {

+    ExFreePoolWithTag(DAT_24,0);

+    DAT_24 = 0;

+  }

+  if (bVar3) {

+    ExDeleteNPagedLookasideList(&DAT_23);

+  }

+  if (DAT_17 != 0) {

+    ExFreePoolWithTag(DAT_17,0);

+    DAT_17 = 0;

+  }

+LAB_67:

+  RtlFreeUnicodeString(&local_3b8);

+  return uVar12 & 0xffffffff;

 }
```

## `DpiClaimPersistedMemoryBlock`  (modified)

```diff
--- DpiClaimPersistedMemoryBlock
+++ DpiClaimPersistedMemoryBlock
@@ -1,13 +1,197 @@
 

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

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

+/* long __cdecl DpiClaimPersistedMemoryBlock(struct _FDO_CONTEXT * __ptr64,unsigned __int64,struct

+   _GUID const * __ptr64) */

 

 long __cdecl DpiClaimPersistedMemoryBlock(_FDO_CONTEXT *param_1,__uint64 param_2,_GUID *param_3)

 

 {

-  int *unaff_RDI;

+  longlong lVar1;

+  ulonglong uVar2;

+  int iVar3;

+  uint uVar4;

+  longlong lVar5;

+  longlong lVar6;

+  undefined8 *puVar7;

+  ulonglong uVar8;

+  uint uVar9;

+  ulonglong uVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  ulonglong uVar13;

+  uint local_res20 [2];

+  int *piVar14;

+  ulonglong uVar15;

+  undefined4 uVar16;

+  uint *puVar17;

+  int local_68;

+  uint local_64 [3];

+  undefined8 local_58;

+  undefined8 *local_50;

+  int local_48;

+  undefined4 local_44;

+  longlong local_40;

   

-  *unaff_RDI = *unaff_RDI + -1;

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

-  halt_baddata();

+  local_res20[0] = 0;

+  piVar14 = &local_68;

+  local_64[0] = 0;

+  local_68 = 0;

+  lVar5 = 0;

+  KsrQueryMetadata(param_3,param_2,0,0,piVar14);

+  if (local_68 == 0) {

+LAB_0:

+    uVar15 = (ulonglong)piVar14 & 0xffffffff00000000;

+    iVar3 = KsrClaimPersistedMemory(param_3,param_2,0,0,uVar15,local_res20);

+    uVar16 = (undefined4)(uVar15 >> 0x20);

+    if ((((iVar3 + 0x80000000U & 0x80000000) == 0) && (iVar3 != -0x3fffffdd)) ||

+       (local_res20[0] == 0)) {

+      uVar4 = 0xc000000d;

+      WdLogSingleEntry1(2,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0x272;

+    }

+    else {

+      lVar6 = ExAllocatePool2(0x100,(ulonglong)local_res20[0] << 3,0x74727044);

+      if (lVar6 == 0) {

+        uVar4 = 0xc0000017;

+        WdLogSingleEntry1(2,0xffffffffc0000017);

+        _WdLogGlobalForLineNumber = 0x27c;

+      }

+      else {

+        puVar17 = local_64;

+        uVar15 = CONCAT44(uVar16,1);

+        uVar4 = KsrClaimPersistedMemory(param_3,param_2,lVar6,local_res20[0],uVar15,puVar17);

+        uVar16 = (undefined4)((ulonglong)puVar17 >> 0x20);

+        if (((int)uVar4 < 0) || (local_res20[0] != local_64[0])) {

+          WdLogSingleEntry1(2,(longlong)(int)uVar4);

+          _WdLogGlobalForLineNumber = 0x28b;

+          goto LAB_1;

+        }

+        uVar13 = 0;

+        uVar8 = 0;

+        if (local_res20[0] == 0) {

+LAB_2:

+          uVar4 = 0xc000000d;

+          WdLogSingleEntry1(2,0xffffffffc000000d);

+          _WdLogGlobalForLineNumber = 0x29c;

+        }

+        else {

+          do {

+            lVar1 = uVar8 * 8;

+            uVar9 = (int)uVar8 + 1;

+            uVar8 = (ulonglong)uVar9;

+            uVar13 = uVar13 + (*(ulonglong *)(lVar6 + lVar1) >> 0x28) * 0x1000;

+          } while (uVar9 < local_res20[0]);

+          if (uVar13 == 0) goto LAB_2;

+          puVar7 = (undefined8 *)

+                   ExAllocatePool2(0x40,uVar13 + 0x30,

+                                   (-(uint)(param_1 != (_FDO_CONTEXT *)0x0) & 0x7000000) +

+                                   0x6d727044);

+          if (puVar7 == (undefined8 *)0x0) {

+            uVar4 = 0xc0000017;

+            WdLogSingleEntry1(2,0xffffffffc0000017);

+            _WdLogGlobalForLineNumber = 0x2a7;

+          }

+          else {

+            *puVar7 = 0;

+            puVar7[4] = 0;

+            *(undefined4 *)((longlong)puVar7 + 0x2c) = 0;

+            *(int *)(puVar7 + 5) = (int)uVar13;

+            *(short *)(puVar7 + 1) = ((short)(uVar13 + 0xfff >> 0xc) + 6) * 8;

+            *(undefined2 *)((longlong)puVar7 + 10) = 2;

+            if (local_res20[0] != 0) {

+              uVar12 = 0;

+              uVar8 = 0;

+              do {

+                uVar2 = *(ulonglong *)(lVar6 + uVar8 * 8);

+                uVar11 = 0;

+                uVar10 = uVar2 >> 0x28;

+                if (uVar10 != 0) {

+                  do {

+                    lVar1 = uVar11 + (uVar2 & 0xffffffffff);

+                    uVar11 = (ulonglong)((int)uVar11 + 1);

+                    puVar7[uVar12 + 6] = lVar1;

+                    uVar12 = (ulonglong)((int)uVar12 + 1);

+                  } while (uVar11 < uVar10);

+                }

+                uVar9 = (int)uVar8 + 1;

+                uVar8 = (ulonglong)uVar9;

+              } while (uVar9 < local_res20[0]);

+            }

+            if (param_1 == (_FDO_CONTEXT *)0x0) {

+              if (DAT_3 == (uint *)0x0) {

+                if ((*(byte *)((longlong)puVar7 + 10) & 5) == 0) {

+                  DAT_3 =

+                       (uint *)MmMapLockedPagesSpecifyCache

+                                         (puVar7,0,1,0,uVar15 & 0xffffffff00000000,

+                                          CONCAT44(uVar16,0x40000010));

+                }

+                else {

+                  DAT_3 = (uint *)puVar7[3];

+                }

+                if (DAT_3 == (uint *)0x0) {

+                  uVar4 = 0xc0000001;

+                  WdLogSingleEntry1(2,0xffffffffc0000001);

+                  _WdLogGlobalForLineNumber = 0x2c9;

+                }

+                else if (uVar13 < *DAT_3) {

+                  uVar4 = 0xc000000d;

+                  MmUnmapLockedPages(DAT_3,puVar7);

+                  DAT_3 = (uint *)0x0;

+                }

+                else {

+                  *(undefined8 **)(DAT_3 + 4) = puVar7;

+                  puVar7 = (undefined8 *)0x0;

+                }

+              }

+              else {

+                uVar4 = 0xc0000001;

+              }

+              if (puVar7 != (undefined8 *)0x0) {

+LAB_4:

+                MmFreePagesFromMdl(puVar7);

+                ExFreePoolWithTag(puVar7,0);

+              }

+            }

+            else {

+              local_58 = 0;

+              local_44 = 0;

+              local_48 = local_68;

+              local_50 = puVar7;

+              local_40 = lVar5;

+              uVar4 = DpiDxgkDdiRestoreMemoryForHotUpdate

+                                (param_1,(_DXGKARG_RESTOREMEMORYFORHOTUPDATE *)&local_58);

+              if ((int)uVar4 < 0) {

+                WdLogSingleEntry1(2,(longlong)(int)uVar4);

+                _WdLogGlobalForLineNumber = 0x2ea;

+                goto LAB_4;

+              }

+            }

+          }

+        }

+LAB_1:

+        ExFreePoolWithTag(lVar6,0);

+      }

+    }

+    if (lVar5 == 0) goto LAB_5;

+  }

+  else {

+    lVar5 = ExAllocatePool2(0x100,local_68,0x64727044);

+    if (lVar5 == 0) {

+      WdLogSingleEntry1(2,0xffffffffc0000017);

+      _WdLogGlobalForLineNumber = 0x255;

+      goto LAB_0;

+    }

+    piVar14 = &local_68;

+    uVar4 = KsrQueryMetadata(param_3,param_2,lVar5,local_68,piVar14);

+    if (-1 < (int)uVar4) goto LAB_0;

+    WdLogSingleEntry1(2,(longlong)(int)uVar4);

+    _WdLogGlobalForLineNumber = 0x25f;

+  }

+  ExFreePoolWithTag(lVar5,0);

+LAB_5:

+  if (DAT_3 != (uint *)0x0) {

+    DAT_3[6] = uVar4;

+  }

+  return uVar4;

 }
```

## `DpiIndirectCbForceDisplaySwitch`  (modified)

```diff
--- DpiIndirectCbForceDisplaySwitch
+++ DpiIndirectCbForceDisplaySwitch
@@ -1,13 +1,51 @@
 

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

-

-void DpiIndirectCbForceDisplaySwitch(void)

+int DpiIndirectCbForceDisplaySwitch(longlong param_1)

 

 {

-  int *unaff_RDI;

+  int iVar1;

+  int iVar2;

+  undefined8 *puVar3;

+  longlong lVar4;

+  CDisplayScenarioContextScope local_18 [8];

+  undefined8 local_10;

   

-  *unaff_RDI = *unaff_RDI + -1;

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

-  halt_baddata();

+  if ((((param_1 == 0) || (lVar4 = *(longlong *)(param_1 + 0x40), lVar4 == 0)) ||

+      (*(int *)(lVar4 + 0x10) != 0x74727044)) ||

+     ((*(int *)(lVar4 + 0x14) != 2 || (*(char *)(lVar4 + 0x486) == '\0')))) {

+    return -0x3ffffff3;

+  }

+  local_18[0] = (CDisplayScenarioContextScope)0x0;

+  CDisplayScenarioContextScope::ContextScopeConstructor(local_18,(_GUID *)0x0,0x38,0);

+  iVar1 = Feature_IddCxForceDisplaySwitchInvalidatesModeCache__private_IsEnabledDeviceUsageNoInline

+                    ();

+  if (iVar1 == 0) {

+    iVar1 = DxgkRequestAsyncDisplaySwitchCallout(0,local_10,*(undefined8 *)(lVar4 + 0x1700));

+  }

+  else {

+    iVar1 = DxgkRequestAsyncDisplaySwitchCallout(0,local_10,*(undefined8 *)(lVar4 + 0x1700));

+    if (-1 < iVar1) {

+      iVar2 = Feature_IddCx_Fix_UseFdoForModeCacheWorkItem__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 == 0) {

+        puVar3 = operator_new(8,0x74727044,0x100);

+        if (puVar3 == (undefined8 *)0x0) goto LAB_0;

+        *puVar3 = 0;

+        *puVar3 = *(undefined8 *)(lVar4 + 0xa88);

+        lVar4 = IoAllocateWorkItem(g_pDriverObject);

+        if (lVar4 == 0) {

+          DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puVar3);

+          goto LAB_0;

+        }

+      }

+      else {

+        lVar4 = IoAllocateWorkItem(*(undefined8 *)(lVar4 + 0x18));

+        if (lVar4 == 0) goto LAB_0;

+        puVar3 = (undefined8 *)0x0;

+      }

+      IoQueueWorkItemEx(lVar4,DpiIndirectInvalidateModeListCacheWorker,1,puVar3);

+    }

+  }

+LAB_0:

+  CDisplayScenarioContextScope::~CDisplayScenarioContextScope(local_18);

+  return iVar1;

 }
```

## `CapturePresentMultiPlaneOverlayArgs`  (modified)

```diff
--- CapturePresentMultiPlaneOverlayArgs
+++ CapturePresentMultiPlaneOverlayArgs
@@ -1,22 +1,161 @@
 

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

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

+/* long __cdecl CapturePresentMultiPlaneOverlayArgs(struct D3DKMT_PRESENT_MULTIPLANE_OVERLAY const *

+   __ptr64,struct D3DKMT_PRESENT_MULTIPLANE_OVERLAY * __ptr64,struct D3DKMT_MULTIPLANE_OVERLAY *

+   __ptr64 * __ptr64,struct tagRECT * __ptr64 * __ptr64) */

 

 long __cdecl

 CapturePresentMultiPlaneOverlayArgs

           (D3DKMT_PRESENT_MULTIPLANE_OVERLAY *param_1,D3DKMT_PRESENT_MULTIPLANE_OVERLAY *param_2,

           D3DKMT_MULTIPLANE_OVERLAY **param_3,tagRECT **param_4)

 

 {

-  long unaff_EDI;

-  char unaff_R14B;

-  char in_stack_00000060;

+  undefined4 uVar1;

+  undefined4 uVar2;

+  undefined4 uVar3;

+  undefined8 *puVar4;

+  int iVar5;

+  __uint64 _Var6;

+  D3DKMT_MULTIPLANE_OVERLAY *_Dst;

+  undefined8 uVar7;

+  undefined8 *puVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  D3DKMT_PRESENT_MULTIPLANE_OVERLAY *pDVar11;

+  size_t _Size;

+  uint uVar12;

+  undefined1 auStack_1c8 [32];

+  ulonglong local_1a8;

+  undefined8 local_1a0;

+  undefined8 local_198;

+  undefined8 local_190;

+  undefined8 local_188;

+  D3DKMT_MULTIPLANE_OVERLAY *local_178;

+  undefined8 local_170;

+  undefined8 local_168 [35];

+  uint local_50;

+  D3DKMT_MULTIPLANE_OVERLAY *local_48;

+  ulonglong local_38;

   

-  DxgkLogInternalTriageEvent();

-  COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)&stack0x00000070);

-  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)&stack0x00000050);

-  if ((in_stack_00000060 != unaff_R14B) && ((DAT_0 & 1) != 0)) {

-    McTemplateK0q_EtwWriteTransfer();

+  local_38 = __security_cookie ^ (ulonglong)auStack_1c8;

+  memset(local_168,0,0x130);

+  iVar5 = IsMSRC110351_Enabled();

+  if (iVar5 == 0) {

+    if (*(D3DKMT_PRESENT_MULTIPLANE_OVERLAY **)MmUserProbeAddress_exref <= param_1) {

+      param_1 = *(D3DKMT_PRESENT_MULTIPLANE_OVERLAY **)MmUserProbeAddress_exref;

+    }

+    RtlCopyVolatileMemory(local_168,param_1,0x130);

   }

-  return unaff_EDI;

+  else {

+    RtlCopyFromUser(local_168,param_1);

+  }

+  if (local_50 - 1 < 7) {

+    uVar9 = (ulonglong)local_50 * 0x78;

+    _Size = 0xffffffff;

+    if (uVar9 < 0x100000000) {

+      _Size = uVar9 & 0xffffffff;

+    }

+    uVar12 = -(uint)(0xffffffff < uVar9) & 0xc0000095;

+    if (uVar9 < 0x100000000) {

+      local_170 = 0;

+      _Var6 = SUB168(ZEXT816(0x78) * ZEXT416(local_50),0);

+      if (SUB168(ZEXT816(0x78) * ZEXT416(local_50),8) != 0) {

+        _Var6 = 0xffffffffffffffff;

+      }

+      _Dst = operator_new__(_Var6,0x4b677844,0x100);

+      local_178 = _Dst;

+      if (_Dst == (D3DKMT_MULTIPLANE_OVERLAY *)0x0) {

+        uVar7 = PsGetCurrentProcess();

+        uVar12 = 0xc0000017;

+        WdLogSingleEntry2(3,0xffffffffc0000017,uVar7);

+        _WdLogGlobalForLineNumber = 0x73;

+        `CapturePresentMultiPlaneOverlayArgs2'::__l2::_AUTO::~_AUTO(&local_178);

+      }

+      else {

+        if (((void *)((longlong)local_48 + _Size) < local_48) ||

+           (*(void **)MmUserProbeAddress_exref < (void *)((longlong)local_48 + _Size))) {

+          **(undefined1 **)MmUserProbeAddress_exref = 0;

+        }

+        memmove(_Dst,local_48,_Size);

+        local_48 = _Dst;

+        lVar10 = 2;

+        puVar4 = local_168;

+        do {

+          pDVar11 = param_2;

+          puVar8 = puVar4;

+          uVar7 = puVar8[1];

+          *(undefined8 *)pDVar11 = *puVar8;

+          *(undefined8 *)(pDVar11 + 8) = uVar7;

+          uVar7 = puVar8[3];

+          *(undefined8 *)(pDVar11 + 0x10) = puVar8[2];

+          *(undefined8 *)(pDVar11 + 0x18) = uVar7;

+          uVar7 = puVar8[5];

+          *(undefined8 *)(pDVar11 + 0x20) = puVar8[4];

+          *(undefined8 *)(pDVar11 + 0x28) = uVar7;

+          uVar7 = puVar8[7];

+          *(undefined8 *)(pDVar11 + 0x30) = puVar8[6];

+          *(undefined8 *)(pDVar11 + 0x38) = uVar7;

+          uVar7 = puVar8[9];

+          *(undefined8 *)(pDVar11 + 0x40) = puVar8[8];

+          *(undefined8 *)(pDVar11 + 0x48) = uVar7;

+          uVar7 = puVar8[0xb];

+          *(undefined8 *)(pDVar11 + 0x50) = puVar8[10];

+          *(undefined8 *)(pDVar11 + 0x58) = uVar7;

+          uVar7 = puVar8[0xd];

+          *(undefined8 *)(pDVar11 + 0x60) = puVar8[0xc];

+          *(undefined8 *)(pDVar11 + 0x68) = uVar7;

+          uVar7 = puVar8[0xf];

+          *(undefined8 *)(pDVar11 + 0x70) = puVar8[0xe];

+          *(undefined8 *)(pDVar11 + 0x78) = uVar7;

+          lVar10 = lVar10 + -1;

+          puVar4 = puVar8 + 0x10;

+          param_2 = pDVar11 + 0x80;

+        } while (lVar10 != 0);

+        uVar7 = puVar8[0x11];

+        *(undefined8 *)(pDVar11 + 0x80) = puVar8[0x10];

+        *(undefined8 *)(pDVar11 + 0x88) = uVar7;

+        uVar1 = *(undefined4 *)((longlong)puVar8 + 0x94);

+        uVar2 = *(undefined4 *)(puVar8 + 0x13);

+        uVar3 = *(undefined4 *)((longlong)puVar8 + 0x9c);

+        *(undefined4 *)(pDVar11 + 0x90) = *(undefined4 *)(puVar8 + 0x12);

+        *(undefined4 *)(pDVar11 + 0x94) = uVar1;

+        *(undefined4 *)(pDVar11 + 0x98) = uVar2;

+        *(undefined4 *)(pDVar11 + 0x9c) = uVar3;

+        uVar1 = *(undefined4 *)((longlong)puVar8 + 0xa4);

+        uVar2 = *(undefined4 *)(puVar8 + 0x15);

+        uVar3 = *(undefined4 *)((longlong)puVar8 + 0xac);

+        *(undefined4 *)(pDVar11 + 0xa0) = *(undefined4 *)(puVar8 + 0x14);

+        *(undefined4 *)(pDVar11 + 0xa4) = uVar1;

+        *(undefined4 *)(pDVar11 + 0xa8) = uVar2;

+        *(undefined4 *)(pDVar11 + 0xac) = uVar3;

+        *param_3 = _Dst;

+        *param_4 = (tagRECT *)0x0;

+        local_178 = (D3DKMT_MULTIPLANE_OVERLAY *)0x0;

+        `CapturePresentMultiPlaneOverlayArgs2'::__l2::_AUTO::~_AUTO(&local_178);

+        uVar12 = 0;

+      }

+    }

+    else {

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0x5b;

+    }

+  }

+  else {

+    uVar7 = PsGetCurrentProcess();

+    uVar12 = 0xc000000d;

+    WdLogSingleEntry3(2,local_50,0xffffffffc000000d,uVar7);

+    _WdLogGlobalForLineNumber = 0x51;

+    local_198 = PsGetCurrentProcess();

+    local_1a8 = (ulonglong)local_50;

+    local_188 = 0;

+    local_190 = 0;

+    local_1a0 = 0xffffffffc000000d;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Presenting multi plane overlay plane count (0x%I64x) is invalid, returing 0x%I64x at 0x%I64x"

+              );

+  }

+  return uVar12;

 }
```

## `CapturePresentMultiPlaneOverlayArgs2`  (modified)

```diff
--- CapturePresentMultiPlaneOverlayArgs2
+++ CapturePresentMultiPlaneOverlayArgs2
@@ -1,18 +1,161 @@
 

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

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

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

+/* long __cdecl CapturePresentMultiPlaneOverlayArgs2(struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY2

+   const * __ptr64,struct _D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 * __ptr64,struct

+   _D3DKMT_MULTIPLANE_OVERLAY2 * __ptr64 * __ptr64,struct tagRECT * __ptr64 * __ptr64) */

 

 long __cdecl

 CapturePresentMultiPlaneOverlayArgs2

           (_D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 *param_1,_D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 *param_2

           ,_D3DKMT_MULTIPLANE_OVERLAY2 **param_3,tagRECT **param_4)

 

 {

-  char *pcVar1;

-  longlong unaff_RBP;

+  undefined4 uVar1;

+  undefined4 uVar2;

+  undefined4 uVar3;

+  undefined8 *puVar4;

+  int iVar5;

+  __uint64 _Var6;

+  _D3DKMT_MULTIPLANE_OVERLAY2 *_Dst;

+  undefined8 uVar7;

+  undefined8 *puVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  _D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 *p_Var11;

+  size_t _Size;

+  uint uVar12;

+  undefined1 auStack_1c8 [32];

+  ulonglong local_1a8;

+  undefined8 local_1a0;

+  undefined8 local_198;

+  undefined8 local_190;

+  undefined8 local_188;

+  _D3DKMT_MULTIPLANE_OVERLAY2 *local_178;

+  undefined8 local_170;

+  undefined8 local_168 [35];

+  uint local_4c;

+  _D3DKMT_MULTIPLANE_OVERLAY2 *local_48;

+  ulonglong local_38;

   

-  pcVar1 = (char *)(unaff_RBP + 0xd + (longlong)param_1 * 4);

-  *pcVar1 = *pcVar1 + (char)param_1;

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

-  halt_baddata();

+  local_38 = __security_cookie ^ (ulonglong)auStack_1c8;

+  memset(local_168,0,0x130);

+  iVar5 = IsMSRC110351_Enabled();

+  if (iVar5 == 0) {

+    if (*(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 **)MmUserProbeAddress_exref <= param_1) {

+      param_1 = *(_D3DKMT_PRESENT_MULTIPLANE_OVERLAY2 **)MmUserProbeAddress_exref;

+    }

+    RtlCopyVolatileMemory(local_168,param_1,0x130);

+  }

+  else {

+    RtlCopyFromUser(local_168,param_1);

+  }

+  if (local_4c - 1 < 7) {

+    uVar9 = (ulonglong)local_4c * 0x78;

+    _Size = 0xffffffff;

+    if (uVar9 < 0x100000000) {

+      _Size = uVar9 & 0xffffffff;

+    }

+    uVar12 = -(uint)(0xffffffff < uVar9) & 0xc0000095;

+    if (uVar9 < 0x100000000) {

+      local_170 = 0;

+      _Var6 = SUB168(ZEXT816(0x78) * ZEXT416(local_4c),0);

+      if (SUB168(ZEXT816(0x78) * ZEXT416(local_4c),8) != 0) {

+        _Var6 = 0xffffffffffffffff;

+      }

+      _Dst = operator_new__(_Var6,0x4b677844,0x100);

+      local_178 = _Dst;

+      if (_Dst == (_D3DKMT_MULTIPLANE_OVERLAY2 *)0x0) {

+        uVar7 = PsGetCurrentProcess();

+        uVar12 = 0xc0000017;

+        WdLogSingleEntry2(3,0xffffffffc0000017,uVar7);

+        _WdLogGlobalForLineNumber = 0xed;

+        `CapturePresentMultiPlaneOverlayArgs2'::__l2::_AUTO::~_AUTO(&local_178);

+      }

+      else {

+        if (((void *)((longlong)local_48 + _Size) < local_48) ||

+           (*(void **)MmUserProbeAddress_exref < (void *)((longlong)local_48 + _Size))) {

+          **(undefined1 **)MmUserProbeAddress_exref = 0;

+        }

+        memmove(_Dst,local_48,_Size);

+        local_48 = _Dst;

+        lVar10 = 2;

+        puVar4 = local_168;

+        do {

+          p_Var11 = param_2;

+          puVar8 = puVar4;

+          uVar7 = puVar8[1];

+          *(undefined8 *)p_Var11 = *puVar8;

+          *(undefined8 *)(p_Var11 + 8) = uVar7;

+          uVar7 = puVar8[3];

+          *(undefined8 *)(p_Var11 + 0x10) = puVar8[2];

+          *(undefined8 *)(p_Var11 + 0x18) = uVar7;

+          uVar7 = puVar8[5];

+          *(undefined8 *)(p_Var11 + 0x20) = puVar8[4];

+          *(undefined8 *)(p_Var11 + 0x28) = uVar7;

+          uVar7 = puVar8[7];

+          *(undefined8 *)(p_Var11 + 0x30) = puVar8[6];

+          *(undefined8 *)(p_Var11 + 0x38) = uVar7;

+          uVar7 = puVar8[9];

+          *(undefined8 *)(p_Var11 + 0x40) = puVar8[8];

+          *(undefined8 *)(p_Var11 + 0x48) = uVar7;

+          uVar7 = puVar8[0xb];

+          *(undefined8 *)(p_Var11 + 0x50) = puVar8[10];

+          *(undefined8 *)(p_Var11 + 0x58) = uVar7;

+          uVar7 = puVar8[0xd];

+          *(undefined8 *)(p_Var11 + 0x60) = puVar8[0xc];

+          *(undefined8 *)(p_Var11 + 0x68) = uVar7;

+          uVar7 = puVar8[0xf];

+          *(undefined8 *)(p_Var11 + 0x70) = puVar8[0xe];

+          *(undefined8 *)(p_Var11 + 0x78) = uVar7;

+          lVar10 = lVar10 + -1;

+          puVar4 = puVar8 + 0x10;

+          param_2 = p_Var11 + 0x80;

+        } while (lVar10 != 0);

+        uVar7 = puVar8[0x11];

+        *(undefined8 *)(p_Var11 + 0x80) = puVar8[0x10];

+        *(undefined8 *)(p_Var11 + 0x88) = uVar7;

+        uVar1 = *(undefined4 *)((longlong)puVar8 + 0x94);

+        uVar2 = *(undefined4 *)(puVar8 + 0x13);

+        uVar3 = *(undefined4 *)((longlong)puVar8 + 0x9c);

+        *(undefined4 *)(p_Var11 + 0x90) = *(undefined4 *)(puVar8 + 0x12);

+        *(undefined4 *)(p_Var11 + 0x94) = uVar1;

+        *(undefined4 *)(p_Var11 + 0x98) = uVar2;

+        *(undefined4 *)(p_Var11 + 0x9c) = uVar3;

+        uVar1 = *(undefined4 *)((longlong)puVar8 + 0xa4);

+        uVar2 = *(undefined4 *)(puVar8 + 0x15);

+        uVar3 = *(undefined4 *)((longlong)puVar8 + 0xac);

+        *(undefined4 *)(p_Var11 + 0xa0) = *(undefined4 *)(puVar8 + 0x14);

+        *(undefined4 *)(p_Var11 + 0xa4) = uVar1;

+        *(undefined4 *)(p_Var11 + 0xa8) = uVar2;

+        *(undefined4 *)(p_Var11 + 0xac) = uVar3;

+        *param_3 = _Dst;

+        *param_4 = (tagRECT *)0x0;

+        local_178 = (_D3DKMT_MULTIPLANE_OVERLAY2 *)0x0;

+        `CapturePresentMultiPlaneOverlayArgs2'::__l2::_AUTO::~_AUTO(&local_178);

+        uVar12 = 0;

+      }

+    }

+    else {

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0xd5;

+    }

+  }

+  else {

+    uVar7 = PsGetCurrentProcess();

+    uVar12 = 0xc000000d;

+    WdLogSingleEntry3(2,local_4c,0xffffffffc000000d,uVar7);

+    _WdLogGlobalForLineNumber = 0xcb;

+    local_198 = PsGetCurrentProcess();

+    local_1a8 = (ulonglong)local_4c;

+    local_188 = 0;

+    local_190 = 0;

+    local_1a0 = 0xffffffffc000000d;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Presenting multi plane overlay plane count (0x%I64x) is invalid, returing 0x%I64x at 0x%I64x"

+              );

+  }

+  return uVar12;

 }
```

## `BmlPreparePathOrderAndVidPn`  (modified)

```diff
--- BmlPreparePathOrderAndVidPn
+++ BmlPreparePathOrderAndVidPn
@@ -1,16 +1,780 @@
 

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

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

+/* long __cdecl BmlPreparePathOrderAndVidPn(struct BML_VIDPN_PATH_ORDER * __ptr64 * __ptr64,class

+   DMMVIDPN * __ptr64,struct D3DKMT_GETPATHSMODALITY const * __ptr64,unsigned short,unsigned

+   short,enum DXGK_DIAG_CCD_BML_ORIGIN,unsigned int) */

 

 long __cdecl

 BmlPreparePathOrderAndVidPn

           (BML_VIDPN_PATH_ORDER **param_1,DMMVIDPN *param_2,D3DKMT_GETPATHSMODALITY *param_3,

           ushort param_4,ushort param_5,DXGK_DIAG_CCD_BML_ORIGIN param_6,uint param_7)

 

 {

-  byte *unaff_RDI;

+  DMMVIDPNTOPOLOGY *pDVar1;

+  VIDPN_MGR *pVVar2;

+  ulonglong *puVar3;

+  byte *pbVar4;

+  HDXGMONITOR__ *pHVar5;

+  uchar uVar6;

+  char cVar7;

+  bool bVar8;

+  BML_VIDPN_PATH_ORDER BVar9;

+  BML_VIDPN_PATH_ORDER BVar10;

+  long lVar11;

+  int iVar12;

+  _D3DKMDT_VIDPN_PRESENT_PATH_SCALING _Var13;

+  _D3DKMDT_VIDPN_PRESENT_PATH_ROTATION _Var14;

+  _D3DKMDT_VIDPN_PRESENT_PATH_ROTATION _Var15;

+  _D3DKMT_VIDPNSOURCEOWNER_TYPE _Var16;

+  BML_VIDPN_PATH_ORDER *pBVar17;

+  SESSION_VIEW *pSVar18;

+  DMMVIDPNPRESENTPATH *pDVar19;

+  longlong lVar20;

+  DMMVIDPNSOURCEMODESET *pDVar21;

+  DMMVIDPNSOURCEMODESET *pDVar22;

+  __uint64 _Var23;

+  ulonglong uVar24;

+  undefined2 uVar25;

+  _D3DKMDT_VIDPN_PRESENT_PATH_IMPORTANCE _Var26;

+  BML_VIDPN_PATH_ORDER *pBVar27;

+  uint uVar28;

+  ADAPTER_DISPLAY *pAVar29;

+  longlong lVar30;

+  void *pvVar31;

+  _DISPLAYCONFIG_HDR_PIXEL_FORMAT _Var32;

+  DMMVIDPN *pDVar33;

+  ulonglong uVar34;

+  undefined8 uVar35;

+  IMonitorDescriptor *pIVar36;

+  ushort uVar37;

+  uint *puVar38;

+  byte bVar39;

+  ulonglong uVar40;

+  uint uVar41;

+  byte bVar42;

+  _D3DKMDT_VIDPN_PRESENT_PATH_IMPORTANCE _Var43;

+  uint uVar44;

+  D3DKMT_GETPATHSMODALITY *pDVar45;

+  uchar local_res8;

+  bool local_res18 [8];

+  ushort local_res20;

+  bool local_258;

+  bool local_257;

+  bool local_256;

+  bool local_255;

+  _DISPLAYCONFIG_HDR_PIXEL_FORMAT local_254;

+  uint local_250;

+  void *local_248;

+  undefined8 local_240;

+  uint local_234;

+  uint local_230 [2];

+  undefined8 local_228;

+  VIDPN_MGR *local_220;

+  ADAPTER_DISPLAY *local_218;

+  uint local_210;

+  uint local_20c;

+  uint local_208;

+  undefined4 local_204;

+  DMMVIDPNTOPOLOGY *local_200;

+  DMMVIDPNSOURCEMODESET *local_1f8;

+  HDXGMONITOR__ *local_1f0;

+  DMMVIDPNSOURCEMODESET *local_1e8;

+  undefined8 local_1e0;

+  DMMVIDPNSOURCEMODESET *local_1d8;

+  longlong local_1d0 [3];

+  undefined1 local_1b8 [8];

+  int local_1b0;

   

-  *unaff_RDI = *unaff_RDI >> 5 | *unaff_RDI << 3;

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

-  halt_baddata();

+  local_res20 = param_4;

+  pBVar17 = operator_new__((ulonglong)*(ushort *)(param_3 + 0x14) * 0x78 + 0x10,0x63644356,0x100);

+  *param_1 = pBVar17;

+  if (pBVar17 == (BML_VIDPN_PATH_ORDER *)0x0) {

+    WdLogSingleEntry2(6,param_3,*(undefined2 *)(param_3 + 0x14));

+    lVar11 = -0x3fffff66;

+    _WdLogGlobalForLineNumber = 0x1099;

+  }

+  else {

+    pVVar2 = *(VIDPN_MGR **)(param_2 + 0x30);

+    local_220 = pVVar2;

+    if (*(longlong *)(pVVar2 + 8) == 0) {

+      WdLogSingleEntry0(1);

+      pBVar17 = *param_1;

+      _WdLogGlobalForLineNumber = 0x44;

+    }

+    pAVar29 = *(ADAPTER_DISPLAY **)(pVVar2 + 8);

+    pvVar31 = *(void **)(pAVar29 + 0x10);

+    if (((*(char *)(*(longlong *)((longlong)pvVar31 + 0xc48) + 0x121) != '\0') &&

+        (*(char *)(*(longlong *)((longlong)pvVar31 + 0xc48) + 0x122) != '\0')) ||

+       (local_res8 = '\0',

+       0x4002 < *(uint *)(*(longlong *)

+                           (*(longlong *)(*(longlong *)((longlong)pvVar31 + 0xd8) + 0x40) + 0x28) +

+                         0x1c))) {

+      local_res8 = '\x01';

+    }

+    local_248 = pvVar31;

+    local_218 = pAVar29;

+    if (*(longlong *)((longlong)pvVar31 + 0xc50) == 0) {

+      uVar44 = ADAPTER_DISPLAY::GetDisplayOnlyDriverUseSmallestMode(pAVar29);

+      uVar41 = *(uint *)(*param_1 + 8);

+      *(uint *)(*param_1 + 8) = (uVar41 ^ uVar44) & 1 ^ uVar41;

+      iVar12 = ADAPTER_DISPLAY::GetDisplayOnlyDriverUseRawModes(pAVar29);

+      *(uint *)(*param_1 + 8) = -(uint)(iVar12 != 0) & 4 | *(uint *)(*param_1 + 8) & 0xfffffffb;

+      iVar12 = ADAPTER_DISPLAY::GetDisplayOnlyDriverIgnoreMonitorFreqCheck(pAVar29);

+      *(uint *)(*param_1 + 8) = -(uint)(iVar12 != 0) & 8 | *(uint *)(*param_1 + 8) & 0xfffffff7;

+    }

+    else {

+      *(uint *)(pBVar17 + 8) = *(uint *)(pBVar17 + 8) & 0xfffffffe;

+      *(uint *)(*param_1 + 8) = *(uint *)(*param_1 + 8) & 0xfffffffb;

+      *(uint *)(*param_1 + 8) = *(uint *)(*param_1 + 8) & 0xfffffff7;

+    }

+    uVar34 = 0;

+    pBVar17 = *param_1;

+    uVar6 = ADAPTER_DISPLAY::ForceIHVScaling(pAVar29);

+    *(uint *)(pBVar17 + 8) = -(uint)(uVar6 != '\0') & 2 | *(uint *)(pBVar17 + 8) & 0xfffffffd;

+    local_254 = ADAPTER_DISPLAY::GetPreferredHdrPixelFormat(pAVar29);

+    uVar24 = uVar34 & 0xffffffff;

+    *(uint *)(*param_1 + 8) = *(uint *)(*param_1 + 8) & 0xf;

+    **param_1 = SUB81(uVar34,0);

+    *(uint *)(*param_1 + 4) = param_7;

+    if ((ushort)uVar34 < *(ushort *)(param_3 + 0x14)) {

+      do {

+        pDVar45 = param_3 + uVar24 * 0x128 + 0x38;

+        if ((*(ulonglong *)pDVar45 & 0x4000000000000) == 0) {

+          WdLogSingleEntry0(1);

+          uVar34 = 0;

+          _WdLogGlobalForLineNumber = 0x10cc;

+        }

+        if ((*(int *)(pDVar45 + 0x10) == *(int *)((longlong)pvVar31 + 0x19c)) &&

+           (*(int *)(pDVar45 + 0x14) == *(int *)((longlong)pvVar31 + 0x1a0))) {

+          if ((*(ulonglong *)pDVar45 & 0x700000000000) != 0x700000000000) {

+            WdLogSingleEntry2(2,uVar24,param_3);

+            _WdLogGlobalForLineNumber = 0x10d8;

+            return -0x3ffffff3;

+          }

+          pBVar17 = *param_1;

+          lVar30 = (ulonglong)(byte)*pBVar17 * 0x78;

+          *(undefined8 *)(pBVar17 + lVar30 + 0x34) = 0;

+          *(ushort *)(pBVar17 + lVar30 + 0x46) = param_5;

+          *(D3DKMT_GETPATHSMODALITY **)(pBVar17 + lVar30 + 0x10) = pDVar45;

+          *(short *)(pBVar17 + lVar30 + 0x20) = (short)uVar24;

+          uVar37 = (ushort)uVar34;

+          *(ushort *)(pBVar17 + lVar30 + 0x40) = uVar37;

+          *(ushort *)(pBVar17 + lVar30 + 0x44) = uVar37;

+          *(ushort *)(pBVar17 + lVar30 + 0x42) = param_4;

+          *(int *)(pBVar17 + lVar30 + 0x3c) = (int)uVar34;

+          *(int *)(pBVar17 + lVar30 + 0x7c) = (int)uVar34;

+          *(undefined8 *)(pBVar17 + lVar30 + 0x48) = 0;

+          *(undefined8 *)(pBVar17 + lVar30 + 0x48 + 8) = 0;

+          *(undefined8 *)(pBVar17 + lVar30 + 0x58) = 0;

+          *(undefined8 *)(pBVar17 + lVar30 + 0x58 + 8) = 0;

+          *(undefined4 *)(pBVar17 + lVar30 + 0x68) = 0;

+          if (param_6 == 2) {

+            pSVar18 = ADAPTER_DISPLAY::GetSessionViewOwner(local_218,*(uint *)(pDVar45 + 0x18));

+            uVar34 = 0;

+            if ((pSVar18 != (SESSION_VIEW *)0x0) && (1 < *(uint *)(pSVar18 + 0x28))) {

+              pBVar17[lVar30 + 0x84] = (BML_VIDPN_PATH_ORDER)((byte)pBVar17[lVar30 + 0x84] | 1);

+            }

+          }

+          else {

+            uVar40 = uVar34 & 0xffffffff;

+            param_4 = local_res20;

+            if (uVar37 < *(ushort *)(param_3 + 0x14)) {

+              do {

+                local_200 = (DMMVIDPNTOPOLOGY *)(uVar40 * 0x128);

+                if ((*(ulonglong *)(param_3 + (longlong)local_200 + 0x38) & 0x4000000000000) == 0) {

+                  WdLogSingleEntry0(1);

+                  _WdLogGlobalForLineNumber = 0x1103;

+                }

+                if (((int)uVar40 != (int)uVar24) &&

+                   (*(int *)(param_3 + (longlong)local_200 + 0xf0) == *(int *)(pDVar45 + 0xb8))) {

+                  pBVar17[lVar30 + 0x84] = (BML_VIDPN_PATH_ORDER)((byte)pBVar17[lVar30 + 0x84] | 1);

+                }

+                uVar41 = (int)uVar40 + 1;

+                uVar40 = (ulonglong)uVar41;

+              } while (uVar41 < *(ushort *)(param_3 + 0x14));

+              uVar34 = 0;

+              param_4 = local_res20;

+            }

+          }

+          **param_1 = (BML_VIDPN_PATH_ORDER)((char)**param_1 + '\x01');

+          pvVar31 = local_248;

+        }

+        uVar41 = (int)uVar24 + 1;

+        uVar24 = (ulonglong)uVar41;

+      } while (uVar41 < *(ushort *)(param_3 + 0x14));

+    }

+    pVVar2 = local_220;

+    pBVar17 = *param_1;

+    pDVar1 = (DMMVIDPNTOPOLOGY *)(param_2 + 0x60);

+    uVar24 = uVar34 & 0xffffffff;

+    BVar10 = (BML_VIDPN_PATH_ORDER)0x0;

+    local_200 = pDVar1;

+    if (*pBVar17 != (BML_VIDPN_PATH_ORDER)0x0) {

+      do {

+        _Var43 = (int)uVar24 + 1;

+        _Var26 = _Var43;

+        if (0x20 < (int)_Var43) {

+          WdLogSingleEntry2(1,pBVar17,uVar24);

+          _Var26 = 0x20;

+          _WdLogGlobalForLineNumber = 0x1159;

+        }

+        pBVar17 = *param_1;

+        lVar30 = uVar24 * 0x78;

+        lVar11 = VIDPN_MGR::AddPathToVidPnTopology

+                           (pVVar2,pDVar1,*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18),

+                            *(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),_Var26,

+                            *(ushort *)(pBVar17 + lVar30 + 0x20),'\x01',2);

+        uVar34 = 0;

+        if (lVar11 < 0) {

+          lVar20 = WdLogNewEntry5_WdTrace();

+          *(ulonglong *)(lVar20 + 0x18) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18);

+          *(ulonglong *)(lVar20 + 0x20) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c);

+          *(DMMVIDPNTOPOLOGY **)(lVar20 + 0x28) = pDVar1;

+          *(longlong *)(lVar20 + 0x30) = (longlong)lVar11;

+          _WdLogGlobalForLineNumber = 0x116d;

+          return lVar11;

+        }

+        pBVar17 = *param_1;

+        uVar24 = (ulonglong)_Var43;

+        BVar10 = *pBVar17;

+      } while (_Var43 < (byte)BVar10);

+    }

+    local_250 = (uint)uVar34;

+    uVar24 = uVar34 & 0xffffffff;

+    BVar9 = (BML_VIDPN_PATH_ORDER)0x0;

+    if (BVar10 != (BML_VIDPN_PATH_ORDER)0x0) {

+      do {

+        lVar30 = uVar24 * 0x78;

+        if ((**(ulonglong **)(pBVar17 + lVar30 + 0x10) >> 0x32 & 1) == 0) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x117e;

+        }

+        lVar20 = *(longlong *)(pBVar17 + lVar30 + 0x10);

+        pDVar19 = DMMVIDPNTOPOLOGY::FindPath

+                            (local_200,*(uint *)(lVar20 + 0x18),*(uint *)(lVar20 + 0x1c));

+        local_240 = pDVar19;

+        if (*(char *)(lVar20 + 0x81) != '\0') {

+          lVar20 = WdLogNewEntry5_WdTrace();

+          *(ulonglong *)(lVar20 + 0x18) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18);

+          *(ulonglong *)(lVar20 + 0x20) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c);

+          *(longlong *)(lVar20 + 0x28) =

+               (longlong)*(int *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x14);

+          *(ulonglong *)(lVar20 + 0x30) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x10);

+          _WdLogGlobalForLineNumber = 0x118a;

+          uVar34 = **(ulonglong **)(pBVar17 + lVar30 + 0x10);

+          if (((uVar34 >> 0x11 & 1) == 0) &&

+             (((~((uint)(*(ulonglong **)(pBVar17 + lVar30 + 0x10))[1] >> 8) ^ ~(uint)(uVar34 >> 8))

+              & 1) != 0)) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x1197;

+            DxgkLogInternalTriageEvent

+                      (0,0x40002,0xffffffff,

+                       L"((pPathInfo->pPathModality->FixedFlags & D3DKMT_PATHMODALITY_DESCRIPTOR_SMI_FIXED) == 0) == ((pPathInfo->pPathModality->Flags & D3DKMT_PATHMODALITY_DESCRIPTOR_SMI_VALID) == 0)"

+                       ,0x1197,0,0,0,0);

+          }

+        }

+        local_1e8 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(pDVar19 + 0x58));

+        iVar12 = BmlFillPreferredMonitorMode

+                           (*param_1,uVar24,*(undefined8 *)(*(longlong *)(pDVar19 + 0x60) + 0x60));

+        uVar44 = 0;

+        uVar41 = 0;

+        if (iVar12 < 0) {

+          lVar20 = WdLogNewEntry5_WdTrace();

+          *(ulonglong *)(lVar20 + 0x18) =

+               (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18);

+          uVar41 = *(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c);

+          *(DMMVIDPNTOPOLOGY **)(lVar20 + 0x28) = local_200;

+          *(ulonglong *)(lVar20 + 0x20) = (ulonglong)uVar41;

+          *(longlong *)(lVar20 + 0x30) = (longlong)iVar12;

+          _WdLogGlobalForLineNumber = 0x11b3;

+          *(undefined4 *)(*param_1 + lVar30 + 0x34) = 0;

+          *(undefined4 *)(*param_1 + lVar30 + 0x38) = 0;

+          auto_rc<DMMVIDPNSOURCEMODESET>::reset

+                    ((auto_rc<DMMVIDPNSOURCEMODESET> *)&local_1e8,(DMMVIDPNSOURCEMODESET *)0x0);

+          return iVar12;

+        }

+        if ((**(ulonglong **)(pBVar17 + lVar30 + 0x10) >> 0x2a & 1) == 0) {

+LAB_0:

+          _Var13 = VIDPN_MGR::GetAdapterDefaultScaling(local_220);

+LAB_1:

+          *(_D3DKMDT_VIDPN_PRESENT_PATH_SCALING *)(pBVar17 + lVar30 + 0x18) = _Var13;

+        }

+        else {

+          iVar12 = (int)(*(ulonglong **)(pBVar17 + lVar30 + 0x10))[0x11];

+          if ((((iVar12 != 1) && (iVar12 != 2)) && (iVar12 != 3)) &&

+             ((iVar12 != 4 && (iVar12 != 5)))) {

+            if (iVar12 == 0xfd) goto LAB_0;

+            if (iVar12 != 0xff) {

+              _Var13 = VIDPN_MGR::GetAdapterDefaultScaling(local_220);

+              *(_D3DKMDT_VIDPN_PRESENT_PATH_SCALING *)(pBVar17 + lVar30 + 0x18) = _Var13;

+              WdLogSingleEntry4(3,(longlong)(int)_Var13,*param_1,uVar24,

+                                (longlong)*(int *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x88));

+              _WdLogGlobalForLineNumber = 0x11e0;

+              goto LAB_2;

+            }

+            if (0x450 < *(int *)(*(longlong *)(local_218 + 0x10) + 0xbd4)) goto LAB_0;

+            _Var13 = 0xff;

+            goto LAB_1;

+          }

+          *(int *)(pBVar17 + lVar30 + 0x18) = iVar12;

+        }

+LAB_2:

+        Feature_BrokeredDisplays_RotMgr__private_ReportDeviceUsage();

+        if ((**(uint **)(pBVar17 + lVar30 + 0x10) >> 9 & 1) == 0) {

+          _Var15 = BmlGetRecommendedRotation(*param_1,(uint)uVar24,local_res8);

+LAB_3:

+          *(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)(pBVar17 + lVar30 + 0x1c) = _Var15;

+        }

+        else {

+          _Var15 = (*(uint **)(pBVar17 + lVar30 + 0x10))[0x21];

+          _Var14 = D3DKMDT_VPPR_GET_CONTENT_ROTATION(_Var15);

+          if (((_Var14 != 1) && (_Var14 != 2)) && ((_Var14 != 3 && (_Var14 != 4)))) {

+            WdLogSingleEntry3(3,*param_1,uVar24,(longlong)(int)_Var15);

+            _WdLogGlobalForLineNumber = 0x127d;

+LAB_4:

+            _Var15 = 1;

+            goto LAB_3;

+          }

+          _Var14 = D3DKMDT_VPPR_GET_OFFSET_ROTATION(_Var15);

+          if (_Var14 == 1) {

+            local_210 = 0;

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

+              pBVar27 = *param_1;

+              cVar7 = BmlIsSecondaryHardwareClonePath(pBVar27,uVar24,&local_210);

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

+                _Var14 = *(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)

+                          (*(longlong *)(pBVar27 + (ulonglong)local_210 * 0x78 + 0x10) + 0x84);

+                if ((_Var14 - 1 < 0x10) && (_Var15 - 1 < 0x10)) {

+                  uVar28 = (_Var15 - _Var14) + 4 & 0x80000003;

+                  if ((int)uVar28 < 0) {

+                    uVar28 = (uVar28 - 1 | 0xfffffffc) + 1;

+                  }

+                  _Var15 = D3DKMDT_VPPR_CONVERT_ROTATION_GIVEN_OFFSET(_Var14,uVar28 + 1);

+                }

+                else {

+                  _Var15 = 0xff;

+                }

+              }

+            }

+          }

+          else {

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

+              WdLogSingleEntry3(3,*param_1,uVar24,(longlong)(int)_Var15);

+              _WdLogGlobalForLineNumber = 0x1273;

+              goto LAB_4;

+            }

+            cVar7 = BmlIsSecondaryHardwareClonePath(*param_1,uVar24,0);

+            _Var15 = *(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)

+                      (*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x84);

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

+              WdLogSingleEntry3(1,*param_1,uVar24,(longlong)(int)_Var15);

+              _WdLogGlobalForLineNumber = 0x1268;

+              _Var15 = D3DKMDT_VPPR_GET_CONTENT_ROTATION

+                                 (*(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)

+                                   (*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x84));

+              goto LAB_3;

+            }

+          }

+          *(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)(pBVar17 + lVar30 + 0x1c) = _Var15;

+        }

+        puVar38 = *(uint **)(pBVar17 + lVar30 + 0x10);

+        if ((*(char *)((longlong)puVar38 + 0x81) != '\0') && ((*puVar38 >> 0x11 & 1) != 0)) {

+          _Var15 = D3DKMDT_VPPR_GET_CONTENT_ROTATION(_Var15);

+          if ((_Var15 - 2 & 0xfffffffd) == 0) {

+            *(uint *)(pBVar17 + lVar30 + 0x6c) = puVar38[0x27];

+            uVar28 = puVar38[0x26];

+          }

+          else {

+            *(uint *)(pBVar17 + lVar30 + 0x6c) = puVar38[0x26];

+            uVar28 = puVar38[0x27];

+          }

+          *(uint *)(pBVar17 + lVar30 + 0x70) = uVar28;

+          pBVar17[lVar30 + 0x7c] = (BML_VIDPN_PATH_ORDER)((byte)pBVar17[lVar30 + 0x7c] | 1);

+        }

+        local_256 = false;

+        lVar11 = MonitorIsBoostRefreshRateEnabledByDefault(local_248,puVar38[7],&local_256);

+        if (lVar11 < 0) {

+          lVar20 = *(longlong *)(pBVar17 + lVar30 + 0x10);

+          WdLogSingleEntry3(2,*(undefined4 *)(lVar20 + 0x1c),(longlong)*(int *)(lVar20 + 0x14),

+                            *(undefined4 *)(lVar20 + 0x10));

+          _WdLogGlobalForLineNumber = 0x12a4;

+          local_256 = false;

+        }

+        *(uint *)(pBVar17 + lVar30 + 0x80) =

+             *(uint *)(pBVar17 + lVar30 + 0x80) & 0xfffffffe | (uint)(local_256 != false);

+        cVar7 = BmlIsSecondaryHardwareClonePath(*param_1,uVar24,0);

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

+          *(undefined2 *)(pBVar17 + lVar30 + 0x42) = 0;

+        }

+        local_257 = false;

+        bVar42 = 0;

+        local_res18[0] = false;

+        local_255 = false;

+        local_258 = false;

+        local_1f0 = (HDXGMONITOR__ *)0x0;

+        local_234 = 0;

+        lVar11 = MonitorGetMonitorHandle

+                           (local_248,*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                            '\x01',BmlPreparePathOrderAndVidPn,&local_1f0);

+        pHVar5 = local_1f0;

+        bVar39 = 0;

+        if (-1 < lVar11) {

+          lVar11 = MonitorIsMonitorAndLinkHDRCapable

+                             (local_1f0,(MONITOR_AND_LINK_HDR_CAPS *)&local_234,

+                              (MonitorAndLinkHDRIncapableReason *)0x0);

+          uVar41 = local_234;

+          if (lVar11 < 0) {

+            local_234 = 0;

+            WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                              param_2,(longlong)lVar11);

+            _WdLogGlobalForLineNumber = 0x12d3;

+            uVar41 = uVar44;

+          }

+          lVar11 = MonitorIsHdrEnabled(pHVar5,local_res18);

+          bVar42 = local_res18[0];

+          if (lVar11 < 0) {

+            local_res18[0] = false;

+            WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                              param_2,(longlong)lVar11);

+            _WdLogGlobalForLineNumber = 0x12e1;

+            bVar42 = 0;

+          }

+          pDVar19 = local_240;

+          if ((bVar42 != 0) &&

+             (bVar8 = DMMVIDPNPRESENTPATH::IsHdrAllowedOnVidPnPath(local_240), !bVar8)) {

+            lVar20 = WdLogNewEntry5_WdTrace();

+            *(ulonglong *)(lVar20 + 0x18) =

+                 (ulonglong)*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c);

+            *(DMMVIDPNPRESENTPATH **)(lVar20 + 0x20) = pDVar19;

+            bVar42 = 0;

+            local_res18[0] = false;

+            _WdLogGlobalForLineNumber = 0x12ec;

+          }

+          pDVar33 = (DMMVIDPN *)0x0;

+          lVar11 = MonitorIsMonitorAndDriverWCGCapable

+                             (pHVar5,&local_257,(MonitorAndLinkWCGIncapableReason *)0x0);

+          if (lVar11 < 0) {

+            uVar44 = 0;

+            local_257 = false;

+            pDVar33 = param_2;

+            WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                              param_2,(longlong)lVar11);

+            _WdLogGlobalForLineNumber = 0x12fb;

+          }

+          else {

+            uVar44 = (uint)local_257;

+          }

+          lVar11 = MonitorIsWcgEnabled(pHVar5,&local_255);

+          if (lVar11 < 0) {

+            uVar44 = 0;

+            local_257 = false;

+            pDVar33 = param_2;

+            WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                              param_2,(longlong)lVar11);

+            _WdLogGlobalForLineNumber = 0x1305;

+          }

+          iVar12 = Feature_SdrHighBpcPreference__private_IsEnabledDeviceUsageNoInline();

+          if (iVar12 != 0) {

+            if (pHVar5 == (HDXGMONITOR__ *)0x0) {

+              uVar35 = 0xffffffffc000000d;

+            }

+            else {

+              MONITOR_MGR::AcquireMonitorShared((HDXGMONITOR__ *)local_1d0);

+              if (local_1d0[0] != 0) {

+                local_20c = 0;

+                iVar12 = DpiIsFeatureEnabled(*(undefined8 *)((longlong)local_248 + 0xd8),0x2e,0,

+                                             &local_20c);

+                if ((iVar12 < 0) || (local_258 = true, (local_20c & 0x10000) == 0)) {

+                  local_258 = false;

+                }

+                uVar35 = 0x164;

+                memset(local_1b8,0,0x164);

+                DpiGetAdapterMdmSupport(*(undefined8 *)((longlong)local_248 + 0xd8));

+                pDVar33 = (DMMVIDPN *)CONCAT71((int7)((ulonglong)uVar35 >> 8),local_1b0 == 1);

+                pIVar36 = (IMonitorDescriptor *)0x0;

+                if (*(longlong *)(local_1d0[0] + 0xd8) != 0) {

+                  pIVar36 = *(IMonitorDescriptor **)(*(longlong *)(local_1d0[0] + 0xd8) + 0xa0);

+                }

+                local_258 = DxgMonitor::MonitorColorState::ShouldPreferHighBpcInSdr

+                                      (*(MonitorColorState **)(local_1d0[0] + 0xe0),local_258,

+                                       local_1b0 == 1,pIVar36);

+                CONST_MONITOR_REF_LOCK_ACCESSOR::~CONST_MONITOR_REF_LOCK_ACCESSOR

+                          ((CONST_MONITOR_REF_LOCK_ACCESSOR *)local_1d0);

+                goto LAB_5;

+              }

+              WdLogSingleEntry1(2,0xffffffffc0000225);

+              _WdLogGlobalForLineNumber = 0x1564;

+              CONST_MONITOR_REF_LOCK_ACCESSOR::~CONST_MONITOR_REF_LOCK_ACCESSOR

+                        ((CONST_MONITOR_REF_LOCK_ACCESSOR *)local_1d0);

+              uVar35 = 0xffffffffc0000225;

+            }

+            local_258 = false;

+            pDVar33 = param_2;

+            WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c),

+                              param_2,uVar35);

+            _WdLogGlobalForLineNumber = 0x1316;

+          }

+LAB_5:

+          MonitorReleaseMonitorHandle(local_248,pHVar5,pDVar33);

+          bVar39 = local_255;

+        }

+        *(uint *)(pBVar17 + lVar30 + 0x74) = uVar41;

+        *(undefined4 *)(pBVar17 + lVar30 + 0x78) = 0;

+        pBVar17[lVar30 + 0x84] =

+             (BML_VIDPN_PATH_ORDER)

+             ((((local_258 << 2 | (byte)uVar44 & 1) * '\x02' | bVar39 & 1) * '\x02' | bVar42 & 1) *

+              '\x02' | (byte)pBVar17[lVar30 + 0x84] & 0xd1);

+        _Var16 = ADAPTER_DISPLAY::GetVidPnSourceOwnerType

+                           (*(ADAPTER_DISPLAY **)((longlong)local_248 + 0xc48),

+                            *(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18));

+        if (((_Var16 == 1) ||

+            (_Var16 = ADAPTER_DISPLAY::GetVidPnSourceOwnerType

+                                (*(ADAPTER_DISPLAY **)((longlong)local_248 + 0xc48),

+                                 *(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18)),

+            _Var16 == 0)) && (((byte)pBVar17[lVar30 + 0x84] & 1) == 0)) {

+          if ((bVar42 == 0) || ((uVar41 & 1) == 0)) {

+            if ((bVar39 != 0) && (((byte)uVar44 != 0 && (local_254 == 2)))) {

+              *(undefined4 *)(pBVar17 + lVar30 + 0x78) = 3;

+            }

+          }

+          else {

+            *(_DISPLAYCONFIG_HDR_PIXEL_FORMAT *)(pBVar17 + lVar30 + 0x78) = local_254;

+          }

+        }

+        if ((param_7 & 0x20000000) != 0) {

+          *(undefined4 *)(pBVar17 + lVar30 + 0x78) = 0;

+        }

+        pBVar17[lVar30 + 0x84] =

+             (BML_VIDPN_PATH_ORDER)

+             (-(*(int *)(pBVar17 + lVar30 + 0x78) != 0) & 0x10U |

+             (byte)pBVar17[lVar30 + 0x84] & 0xef);

+        auto_rc<DMMVIDPNSOURCEMODESET>::reset

+                  ((auto_rc<DMMVIDPNSOURCEMODESET> *)&local_1e8,(DMMVIDPNSOURCEMODESET *)0x0);

+        pBVar17 = *param_1;

+        local_250 = local_250 + 1;

+        uVar24 = (ulonglong)local_250;

+        BVar9 = *pBVar17;

+      } while (local_250 < (byte)BVar9);

+      uVar34 = 0;

+    }

+    uVar41 = (uint)uVar34;

+    local_248 = (void *)CONCAT44(local_248._4_4_,uVar41);

+    uVar34 = uVar34 & 0xffffffff;

+    BVar10 = (BML_VIDPN_PATH_ORDER)0x0;

+    if (BVar9 != (BML_VIDPN_PATH_ORDER)0x0) {

+      do {

+        _Var32 = (_DISPLAYCONFIG_HDR_PIXEL_FORMAT)uVar34;

+        pAVar29 = (ADAPTER_DISPLAY *)(uVar34 * 0x78);

+        local_218 = pAVar29;

+        cVar7 = BmlIsSecondaryHardwareClonePath(pBVar17,uVar34,0);

+        uVar24 = 0;

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

+          pBVar27 = *param_1;

+          local_240 = (DMMVIDPNPRESENTPATH *)0x0;

+          uVar40 = uVar24;

+          local_254 = _Var32;

+          if (_Var32 < (byte)*pBVar27) {

+            do {

+              _Var32 = (_DISPLAYCONFIG_HDR_PIXEL_FORMAT)uVar34;

+              lVar30 = uVar34 * 0x78;

+              if (*(int *)(*(longlong *)(pBVar27 + lVar30 + 0x10) + 0x18) ==

+                  *(int *)(*(longlong *)(pAVar29 + 0x10 + (longlong)pBVar17) + 0x18)) {

+                pDVar19 = *(DMMVIDPNPRESENTPATH **)(pBVar27 + lVar30 + 0x2c);

+                local_228 = pDVar19;

+                if ((local_res8 == '\0') ||

+                   (_Var15 = D3DKMDT_VPPR_GET_OFFSET_ROTATION

+                                       (*(_D3DKMDT_VIDPN_PRESENT_PATH_ROTATION *)

+                                         (pBVar27 + lVar30 + 0x1c)), (_Var15 - 2 & 0xfffffffd) != 0)

+                   ) {

+                  uVar41 = local_228._4_4_;

+                  local_250 = (uint)local_228;

+                }

+                else {

+                  uVar41 = (uint)local_228;

+                  local_250 = local_228._4_4_;

+                  local_228 = (DMMVIDPNPRESENTPATH *)CONCAT44((uint)local_228,local_228._4_4_);

+                  pDVar19 = local_228;

+                }

+                if ((local_250 == 0) || (uVar41 == 0)) {

+                  WdLogSingleEntry0(1);

+                  _WdLogGlobalForLineNumber = 0x1368;

+                  _Var32 = local_254;

+                }

+                pAVar29 = local_218;

+                if (((uint)uVar24 == 0) || ((uint)uVar40 == 0)) {

+                  uVar24 = (ulonglong)pDVar19 & 0xffffffff;

+                  uVar40 = (ulonglong)pDVar19 >> 0x20;

+                  local_240 = pDVar19;

+                }

+                else {

+                  if (local_250 < (uint)uVar24) {

+                    uVar24 = (ulonglong)local_250;

+                  }

+                  local_240 = (DMMVIDPNPRESENTPATH *)CONCAT44(local_240._4_4_,(int)uVar24);

+                  if (uVar41 < (uint)uVar40) {

+                    uVar40 = (ulonglong)uVar41;

+                    local_240 = (DMMVIDPNPRESENTPATH *)CONCAT44(uVar41,(int)uVar24);

+                  }

+                }

+              }

+              pBVar27 = *param_1;

+              local_254 = _Var32 + 1;

+              uVar34 = (ulonglong)local_254;

+            } while (local_254 < (byte)*pBVar27);

+            _Var32 = (_DISPLAYCONFIG_HDR_PIXEL_FORMAT)local_248;

+          }

+          *(DMMVIDPNPRESENTPATH **)(pAVar29 + 0x24 + (longlong)pBVar17) = local_240;

+          iVar12 = BmlGetScaledAspectRatio

+                             ((_D3DKMDT_2DREGION *)(pAVar29 + 0x34 + (longlong)pBVar17));

+          *(int *)(pAVar29 + 0x3c + (longlong)pBVar17) = iVar12;

+        }

+        uVar41 = 0;

+        pBVar17 = *param_1;

+        uVar44 = _Var32 + 1;

+        uVar34 = (ulonglong)uVar44;

+        local_248 = (void *)CONCAT44(local_248._4_4_,uVar44);

+        BVar10 = *pBVar17;

+      } while (uVar44 < (byte)BVar10);

+    }

+    if (BVar10 != (BML_VIDPN_PATH_ORDER)0x0) {

+      do {

+        uVar24 = (ulonglong)uVar41;

+        lVar30 = uVar24 * 0x78;

+        pDVar19 = DMMVIDPNTOPOLOGY::FindPath

+                            (local_200,*(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18),

+                             *(uint *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x1c));

+        pDVar21 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(pDVar19 + 0x58));

+        uVar34 = *(ulonglong *)(*(uint **)(pBVar17 + lVar30 + 0x10) + 2);

+        local_1d8 = pDVar21;

+        if ((uVar34 & 0x18001820b8f) == 0) {

+LAB_6:

+          uVar6 = DMMVIDPNPRESENTPATH::IsFunctional(pDVar19);

+          uVar34 = 0;

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

+            pBVar27 = *param_1;

+            if (*pBVar27 != (BML_VIDPN_PATH_ORDER)0x0) {

+              do {

+                if (*(int *)(*(longlong *)(pBVar27 + uVar34 * 0x78 + 0x10) + 0x18) ==

+                    *(int *)(*(longlong *)(pBVar17 + lVar30 + 0x10) + 0x18)) {

+                  *(undefined2 *)(pBVar27 + uVar34 * 0x78 + 0x42) = 0;

+                }

+                pBVar27 = *param_1;

+                uVar44 = (int)uVar34 + 1;

+                uVar34 = (ulonglong)uVar44;

+              } while (uVar44 < (byte)*pBVar27);

+            }

+            *(undefined2 *)(pBVar17 + lVar30 + 0x46) = 0;

+          }

+        }

+        else {

+          if ((((**(uint **)(pBVar17 + lVar30 + 0x10) >> 8 & 1) == 0) || ((uVar34 >> 8 & 1) == 0))

+             || (cVar7 = BmlIsSecondaryHardwareClonePath(*param_1,uVar24,0), cVar7 != '\0')) {

+            WdLogSingleEntry2(3,*param_1,uVar24);

+            _WdLogGlobalForLineNumber = 0x142e;

+            goto LAB_6;

+          }

+          local_230[0] = 0xffffffff;

+          iVar12 = BmlGetNextBestSourceMode

+                             (*param_1,param_2,uVar24 & 0xffff,pDVar21,0xffffffff,local_230);

+          if (-1 < iVar12) {

+            lVar11 = VIDPN_MGR::PinVidPnSourceMode(local_220,pDVar21,local_230[0],true);

+            uVar35 = 0;

+            if (lVar11 < 0) {

+              lVar30 = *(longlong *)(pBVar17 + lVar30 + 0x10);

+              DxgkLogCodePointPacket

+                        (0x15,*(undefined4 *)(lVar30 + 0x60),*(undefined4 *)(lVar30 + 100),

+                         *(undefined4 *)(lVar30 + 0x74),*(undefined8 *)(lVar30 + 0x10));

+              WdLogSingleEntry4(3,(longlong)lVar11,*param_1,param_2,uVar24);

+              _WdLogGlobalForLineNumber = 0x13d5;

+              goto LAB_7;

+            }

+            *(undefined2 *)(pBVar17 + lVar30 + 0x42) = 0;

+            pDVar22 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(pDVar19 + 0x60));

+            pbVar4 = *(byte **)(pBVar17 + lVar30 + 0x10);

+            local_1f8 = pDVar22;

+            if ((((*pbVar4 & 0x87) == 0x87) && ((pbVar4[8] & 0x87) == 0x87)) &&

+               ((*(int *)(pbVar4 + 0x38) != (int)uVar35 && (*(int *)(pbVar4 + 0x34) != (int)uVar35))

+               )) {

+              local_208 = 0xffffffff;

+              local_204 = 1;

+              local_1e0 = uVar35;

+              iVar12 = BmlGetNextBestTargetMode

+                                 (*param_1,param_2,uVar24 & 0xffff,pDVar22,pDVar21,0xffffffff,

+                                  &local_208,&local_1e0,&local_204);

+              if (iVar12 < 0) {

+                lVar30 = *(longlong *)(pBVar17 + lVar30 + 0x10);

+                uVar35 = *(undefined8 *)(lVar30 + 0x10);

+                _Var23 = DivideAndRound((ulonglong)*(uint *)(lVar30 + 0x34),

+                                        (ulonglong)*(uint *)(lVar30 + 0x38));

+                DxgkLogCodePointPacket

+                          (0x14,*(undefined4 *)(lVar30 + 0x2c),*(undefined4 *)(lVar30 + 0x30),_Var23

+                           ,uVar35);

+                WdLogSingleEntry3(3,*param_1,param_2,uVar24);

+                _WdLogGlobalForLineNumber = 0x1401;

+                auto_rc<DMMVIDPNTARGETMODESET>::reset

+                          ((auto_rc<DMMVIDPNTARGETMODESET> *)&local_1f8,(DMMVIDPNTARGETMODESET *)0x0

+                          );

+                goto LAB_8;

+              }

+              lVar11 = VIDPN_MGR::PinVidPnTargetMode

+                                 (local_220,(DMMVIDPNTARGETMODESET *)pDVar22,local_208,true);

+              if (lVar11 < 0) {

+                lVar30 = *(longlong *)(pBVar17 + lVar30 + 0x10);

+                uVar35 = *(undefined8 *)(lVar30 + 0x10);

+                _Var23 = DivideAndRound((ulonglong)*(uint *)(lVar30 + 0x34),

+                                        (ulonglong)*(uint *)(lVar30 + 0x38));

+                DxgkLogCodePointPacket

+                          (0x16,*(undefined4 *)(lVar30 + 0x2c),*(undefined4 *)(lVar30 + 0x30),_Var23

+                           ,uVar35);

+                WdLogSingleEntry4(3,(longlong)lVar11,*param_1,param_2,uVar24);

+                _WdLogGlobalForLineNumber = 0x1415;

+                auto_rc<DMMVIDPNTARGETMODESET>::reset

+                          ((auto_rc<DMMVIDPNTARGETMODESET> *)&local_1f8,(DMMVIDPNTARGETMODESET *)0x0

+                          );

+                goto LAB_7;

+              }

+              lVar20 = *(longlong *)(pDVar22 + 0x90);

+              *(undefined8 *)(lVar20 + 0x98) = local_1e0;

+              *(undefined4 *)(lVar20 + 0xa0) = local_204;

+              uVar25 = 0;

+            }

+            else {

+              uVar25 = 0xffff;

+            }

+            *(undefined2 *)(pBVar17 + lVar30 + 0x46) = uVar25;

+            auto_rc<DMMVIDPNTARGETMODESET>::reset

+                      ((auto_rc<DMMVIDPNTARGETMODESET> *)&local_1f8,(DMMVIDPNTARGETMODESET *)0x0);

+            goto LAB_6;

+          }

+          puVar3 = *(ulonglong **)(pBVar17 + lVar30 + 0x10);

+          if ((*puVar3 >> 0x36 & 1) == 0) {

+            DxgkLogCodePointPacket

+                      (0x13,(int)puVar3[0xc],*(undefined4 *)((longlong)puVar3 + 100),

+                       *(undefined4 *)((longlong)puVar3 + 0x74),puVar3[2]);

+            WdLogSingleEntry4(3,*param_1,param_2,uVar24,local_230[0]);

+            _WdLogGlobalForLineNumber = 0x13c0;

+LAB_8:

+            lVar11 = -0x3fe1fcfa;

+LAB_7:

+            auto_rc<DMMVIDPNSOURCEMODESET>::reset

+                      ((auto_rc<DMMVIDPNSOURCEMODESET> *)&local_1d8,(DMMVIDPNSOURCEMODESET *)0x0);

+            return lVar11;

+          }

+          puVar3[1] = puVar3[1] & 0xfffffffffffffe78;

+        }

+        auto_rc<DMMVIDPNSOURCEMODESET>::reset

+                  ((auto_rc<DMMVIDPNSOURCEMODESET> *)&local_1d8,(DMMVIDPNSOURCEMODESET *)0x0);

+        pBVar17 = *param_1;

+        uVar41 = uVar41 + 1;

+      } while (uVar41 < (byte)*pBVar17);

+    }

+    lVar11 = 0;

+  }

+  return lVar11;

 }
```

## `NtGdiDdDDIUnOrderedPresentSwapChain`  (modified)

```diff
--- NtGdiDdDDIUnOrderedPresentSwapChain
+++ NtGdiDdDDIUnOrderedPresentSwapChain
@@ -1,19 +1,202 @@
 

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

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

 

-undefined8 NtGdiDdDDIUnOrderedPresentSwapChain(void)

+ulonglong NtGdiDdDDIUnOrderedPresentSwapChain(void *param_1,undefined8 param_2,undefined8 param_3)

 

 {

-  char *in_RAX;

-  bool bVar1;

-  DXGSWAPCHAIN *unaff_RBX;

+  DXGSWAPCHAIN *pDVar1;

+  undefined8 *puVar2;

+  int iVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  bool bVar6;

+  undefined1 auStack_1d8 [32];

+  undefined8 **local_1b8;

+  undefined8 local_1b0;

+  undefined8 local_1a8;

+  undefined8 local_1a0;

+  undefined8 local_198;

+  undefined4 local_188 [2];

+  undefined8 local_180;

+  char local_178;

+  undefined8 *local_170;

+  DXGDEVICE *local_168;

+  undefined8 *local_160;

+  undefined8 local_158;

+  undefined8 uStack_150;

+  undefined8 local_148;

+  undefined8 uStack_140;

+  undefined8 local_138;

+  undefined8 uStack_130;

+  undefined8 local_128;

+  DXGSWAPCHAINLOCKWITHDEVICE local_118 [128];

+  DXGSWAPCHAINLOCKWITHDEVICE local_98 [128];

+  ulonglong local_18;

   

-  *in_RAX = *in_RAX + (char)in_RAX;

-  bVar1 = false;

-  _WdLogGlobalForLineNumber = 0x103c;

-  DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Invalid process context",0x103c);

-  DXGSWAPCHAIN::MarkAbandoned(unaff_RBX,bVar1);

-  return 0xc000000d;

+                    /* 0x2078f0  293  NtGdiDdDDIUnOrderedPresentSwapChain */

+  local_18 = __security_cookie ^ (ulonglong)auStack_1d8;

+  local_188[0] = 0xffffffff;

+  local_180 = 0;

+  bVar6 = false;

+  if (((byte)DAT_0 & 2) == 0) {

+    local_178 = '\0';

+  }

+  else {

+    local_178 = '\x01';

+    local_188[0] = 0x89a;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,param_3,0x89a);

+    }

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_188,0x89a);

+  local_158 = 0;

+  uStack_150 = 0;

+  local_148 = 0;

+  uStack_140 = 0;

+  local_138 = 0;

+  uStack_130 = 0;

+  local_128 = 0;

+  if (*(void **)MmUserProbeAddress_exref <= param_1) {

+    param_1 = *(void **)MmUserProbeAddress_exref;

+  }

+  RtlCopyVolatileMemory(&local_158,param_1,0x38);

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

+    WdLogSingleEntry0(2);

+    _WdLogGlobalForLineNumber = 0x4b4;

+    local_198 = 0;

+    local_1a0 = 0;

+    local_1a8 = 0;

+    local_1b0 = 0;

+    local_1b8 = (undefined8 **)0x4b4;

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"UnOrderedPresent is not allowed for consumer")

+    ;

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+    if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = 0xc000000d;

+  }

+  else {

+    iVar3 = Feature_317184312__private_IsEnabledDeviceUsageNoInline();

+    local_1b0 = 0;

+    if (iVar3 == 0) {

+      local_170 = (undefined8 *)0x0;

+      local_1b8 = &local_170;

+      iVar3 = ObReferenceObjectByHandle(local_158,0x20000,g_pDxgkSharedSwapChainObjectType,1);

+      puVar2 = local_170;

+      uVar5 = (ulonglong)iVar3;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_158,uVar5);

+        _WdLogGlobalForLineNumber = 0x4fa;

+      }

+      else {

+        pDVar1 = (DXGSWAPCHAIN *)*local_170;

+        local_168 = (DXGDEVICE *)0x0;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE(local_118,pDVar1,true,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar6 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_118,&local_168,true,bVar6);

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

+          if (*(int *)(pDVar1 + 0xe8) == 0) {

+            WdLogSingleEntry0(2);

+            _WdLogGlobalForLineNumber = 0x51c;

+            local_198 = 0;

+            local_1a0 = 0;

+            local_1a8 = 0;

+            local_1b0 = 0;

+            local_1b8 = (undefined8 **)0x51c;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"DxgkUnOrderedPresentSwapChain is not allowed for sequential swapchains");

+            DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_118);

+            DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+            if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+              McTemplateK0q_EtwWriteTransfer();

+            }

+            return 0xc00000bb;

+          }

+          uVar4 = DXGSWAPCHAIN::UnOrderedPresent

+                            ((DXGSWAPCHAIN *)*puVar2,(_D3DKMT_UNORDEREDPRESENTSWAPCHAIN *)&local_158

+                            );

+        }

+        uVar5 = (ulonglong)uVar4;

+        ObfDereferenceObject(puVar2);

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

+          local_198 = CONCAT44(local_198._4_4_,uStack_130._4_4_);

+          local_1a0 = CONCAT44(local_1a0._4_4_,(undefined4)uStack_130);

+          local_1a8 = local_138;

+          local_1b0 = CONCAT44(local_1b0._4_4_,(int)uStack_150);

+          local_1b8 = (undefined8 **)CONCAT44(local_1b8._4_4_,uVar4);

+          McTemplateK0pqqpqq_EtwWriteTransfer();

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_118);

+      }

+    }

+    else {

+      local_160 = (undefined8 *)0x0;

+      local_1b8 = &local_160;

+      iVar3 = ObReferenceObjectByHandle();

+      puVar2 = local_160;

+      uVar5 = (ulonglong)iVar3;

+      local_170 = local_160;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_158,uVar5);

+        _WdLogGlobalForLineNumber = 0x4c5;

+      }

+      else {

+        pDVar1 = (DXGSWAPCHAIN *)*local_160;

+        local_168 = (DXGDEVICE *)0x0;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE(local_98,pDVar1,true,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar6 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_98,&local_168,true,bVar6);

+        uVar5 = (ulonglong)uVar4;

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

+          if (*(int *)(pDVar1 + 0xe8) == 0) {

+            WdLogSingleEntry0(2);

+            _WdLogGlobalForLineNumber = 0x4e7;

+            local_198 = 0;

+            local_1a0 = 0;

+            local_1a8 = 0;

+            local_1b0 = 0;

+            local_1b8 = (undefined8 **)0x4e7;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"DxgkUnOrderedPresentSwapChain is not allowed for sequential swapchains");

+            uVar5 = 0xc00000bb;

+          }

+          else {

+            uVar4 = DXGSWAPCHAIN::UnOrderedPresent

+                              ((DXGSWAPCHAIN *)*puVar2,

+                               (_D3DKMT_UNORDEREDPRESENTSWAPCHAIN *)&local_158);

+            uVar5 = (ulonglong)uVar4;

+          }

+        }

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

+          local_198 = CONCAT44(local_198._4_4_,uStack_130._4_4_);

+          local_1a0 = CONCAT44(local_1a0._4_4_,(undefined4)uStack_130);

+          local_1a8 = local_138;

+          local_1b0 = CONCAT44(local_1b0._4_4_,(int)uStack_150);

+          local_1b8 = (undefined8 **)CONCAT44(local_1b8._4_4_,(int)uVar5);

+          McTemplateK0pqqpqq_EtwWriteTransfer();

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_98);

+      }

+      NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>::

+      ~NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>

+                ((NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64> *)&local_170);

+    }

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+    if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = uVar5 & 0xffffffff;

+  }

+  return uVar5;

 }
```

## `SmmMapContiguousRangeToIommu`  (modified)

```diff
--- SmmMapContiguousRangeToIommu
+++ SmmMapContiguousRangeToIommu
@@ -1,66 +1,73 @@
 

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

+/* long __cdecl SmmMapContiguousRangeToIommu(struct SYSMM_IOMMU * __ptr64,unsigned __int64,unsigned

+   __int64,unsigned __int64,bool) */

 

 long __cdecl

 SmmMapContiguousRangeToIommu

           (SYSMM_IOMMU *param_1,__uint64 param_2,__uint64 param_3,__uint64 param_4,bool param_5)

 

 {

-  undefined4 uVar1;

-  ulong uVar2;

-  uint uVar3;

-  DXGGLOBAL *pDVar4;

-  longlong unaff_RBP;

-  longlong *unaff_RDI;

-  char cVar5;

-  longlong unaff_R15;

-  ulonglong uStack0000000000000030;

-  undefined4 uStack0000000000000038;

-  undefined4 uStack0000000000000040;

-  undefined4 uStack0000000000000048;

+  long lVar1;

+  uint uVar2;

+  _MDL *p_Var3;

+  _MDL *p_Var4;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  __uint64 _Var7;

+  ulonglong uVar8;

+  ulonglong uVar9;

+  undefined8 local_68;

+  undefined4 local_60;

+  undefined8 local_48;

+  undefined8 local_40;

+  longlong local_38;

   

-  KePulseEvent(param_1,0);

-  if (*unaff_RDI != unaff_R15) {

-    pDVar4 = DXGGLOBAL::GetGlobal();

-    HOSTVMMONITORMAPPING::TriggerRemoteVsync

-              ((HOSTVMMONITORMAPPING *)(pDVar4 + 0x4a8a0),

-               *(undefined8 *)(*(longlong *)(*(longlong *)(*unaff_RDI + 0x58) + 0x10) + 0x19c),

-               *(undefined4 *)((longlong)unaff_RDI + 0x104),0);

-  }

-  cVar5 = (char)unaff_R15;

-  if ((unaff_RDI[0x32] != unaff_R15) && (*(uint *)(unaff_RDI + 0x33) <= *(uint *)(unaff_RDI + 0x3b))

-     ) {

-    if ((bTracingEnabled != cVar5) && ((DAT_0 & 1) != 0)) {

-      McTemplateK0q_EtwWriteTransfer();

+  uVar5 = 0;

+  uVar6 = param_4 >> 0xc;

+  p_Var3 = (_MDL *)MmCreateMdl(0,0,param_4);

+  if (p_Var3 == (_MDL *)0x0) {

+    local_68 = 0;

+    local_60 = 0x38;

+    local_48 = 0;

+    local_40 = 0x1000;

+    _Var7 = param_2;

+    uVar9 = uVar5;

+    for (uVar8 = uVar5; lVar1 = (long)uVar9, uVar8 < (uVar6 & 0xffffffff); uVar8 = uVar8 + 1) {

+      local_38 = uVar8 + param_3;

+      uVar2 = SmmMapMdlToIommu(param_1,-(ulonglong)(param_2 != 0) & _Var7,(_MDL *)&local_68,param_5)

+      ;

+      uVar9 = (ulonglong)uVar2;

+      if ((int)uVar2 < 0) {

+        uVar6 = param_2;

+        if (uVar8 == 0) {

+          return uVar2;

+        }

+        do {

+          local_38 = uVar5 + param_3;

+          SmmUnmapMdlFromIommu(param_1,-(ulonglong)(param_2 != 0) & uVar6,(_MDL *)&local_68,param_5)

+          ;

+          uVar5 = uVar5 + 1;

+          uVar6 = uVar6 + 0x1000;

+        } while (uVar5 < uVar8);

+        return uVar2;

+      }

+      _Var7 = _Var7 + 0x1000;

     }

-    KeSetEvent(unaff_RDI[0x32],0,0);

-  }

-  DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)(unaff_RBP + -0x19));

-  if (((int)unaff_RDI[0x11] != 2) && ((*(uint *)(unaff_RDI + 0x86) & 2) != 0)) {

-    (**(code **)(*(longlong *)unaff_RDI[0x10] + 0x30))();

-  }

-  uVar1 = *(undefined4 *)((longlong)unaff_RDI + 0x19c);

-  if (*unaff_RDI == 0) {

-    *(int *)((longlong)unaff_RDI + 0x19c) = (int)unaff_R15;

-    uStack0000000000000030 = 0;

   }

   else {

-    uVar2 = DXGADAPTER::NumberOfVSyncWaiter

-                      (*(DXGADAPTER **)(*(longlong *)(*unaff_RDI + 0x58) + 0x10),

-                       *(uint *)(unaff_RDI + 0x20));

-    uVar3 = uVar2 + (int)unaff_RDI[0x17a];

-    uStack0000000000000030 = (ulonglong)uVar3;

-    *(uint *)((longlong)unaff_RDI + 0x19c) = uVar3;

+    p_Var4 = p_Var3 + 0x30;

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

+      uVar6 = uVar6 & 0xffffffff;

+      do {

+        *(__uint64 *)p_Var4 = param_3;

+        param_3 = param_3 + 1;

+        p_Var4 = p_Var4 + 8;

+        uVar6 = uVar6 - 1;

+      } while (uVar6 != 0);

+    }

+    lVar1 = SmmMapMdlToIommu(param_1,param_2,p_Var3,param_5);

+    ExFreePoolWithTag(p_Var3,0);

   }

-  if (bTracingEnabled != cVar5) {

-    uStack0000000000000030 = KeQueryPerformanceCounter(0);

-    if ((bTracingEnabled != cVar5) && (Microsoft_Windows_DxgKrnlEnableBits < '\0')) {

-      uStack0000000000000048 = (undefined4)unaff_RDI[0x34];

-      uStack0000000000000040 = *(undefined4 *)((longlong)unaff_RDI + 0x19c);

-      uStack0000000000000038 = uVar1;

-      uStack0000000000000030 = McTemplateK0xqqiqqq_EtwWriteTransfer();

-    }

-  }

-  return (long)uStack0000000000000030;

+  return lVar1;

 }
```

## `DpiPdoHandleChildConnectionChange`  (modified)

```diff
--- DpiPdoHandleChildConnectionChange
+++ DpiPdoHandleChildConnectionChange
@@ -1,359 +1,200 @@
 

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

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

 

 ulonglong DpiPdoHandleChildConnectionChange

-                    (longlong param_1,ulong param_2,ulong *param_3,int *param_4)

+                    (longlong param_1,uint param_2,undefined4 param_3,byte param_4,

+                    undefined1 param_5,char param_6,undefined8 param_7,char param_8,

+                    undefined8 param_9,uchar *param_10,_DXGK_DISPLAY_SCENARIO_CONTEXT *param_11)

 

 {

-  longlong lVar1;

-  longlong *plVar2;

+  uint uVar1;

+  longlong lVar2;

   uchar uVar3;

-  uint uVar4;

-  int iVar5;

-  int iVar6;

-  ulonglong uVar7;

+  int iVar4;

+  long lVar5;

+  uint uVar6;

+  longlong lVar7;

   longlong lVar8;

-  longlong lVar9;

+  byte bVar9;

   ulonglong uVar10;

-  undefined8 *puVar11;

-  longlong lVar12;

-  undefined8 *puVar13;

-  longlong *plVar14;

-  ulonglong uVar15;

-  char in_stack_00000060;

-  _DXGK_DISPLAY_SCENARIO_CONTEXT *in_stack_00000068;

-  undefined1 auStackY_100 [32];

-  MONITOR_EVENT MVar16;

-  _DXGK_DISPLAY_SCENARIO_CONTEXT *in_stack_ffffffffffffff20;

-  uint uStack_b0;

-  longlong lStack_98;

-  int aiStack_80 [2];

-  longlong lStack_78;

-  ulong *puStack_70;

-  longlong lStack_68;

-  longlong lStack_60;

-  undefined8 local_58;

-  undefined8 uStack_50;

-  undefined8 uStack_48;

-  undefined8 uStack_40;

-  undefined8 uStack_38;

-  undefined8 uStack_30;

-  undefined8 uStack_28;

-  ulonglong uStack_20;

+  byte bVar11;

+  bool bVar12;

+  undefined1 auStackY_268 [32];

+  undefined4 local_1e8;

+  undefined4 local_1e4;

+  undefined8 local_1e0;

+  undefined8 local_1d8;

+  undefined8 uStack_1d0;

+  undefined8 local_1c8;

+  undefined4 local_1c0;

+  undefined4 local_1bc;

+  undefined4 local_1b8;

+  uint local_1b4;

+  uint local_1b0;

+  uint local_1ac;

+  undefined8 local_1a8;

+  undefined4 local_198;

+  undefined4 local_194;

+  undefined8 local_190;

+  undefined8 local_188;

+  undefined8 uStack_180;

+  undefined8 local_178;

+  undefined8 local_170;

+  undefined4 local_168;

+  uint local_164;

+  undefined8 local_160;

+  undefined8 local_158;

+  undefined1 local_148 [28];

+  int local_12c;

+  ulonglong local_58;

   

-  uStack_20 = __security_cookie ^ (ulonglong)auStackY_100;

-  lVar1 = *(longlong *)(param_1 + 0x40);

-  uVar7 = 0;

-  uStack_30 = 0;

-  uStack_28 = 0;

-  uStack_b0 = 0;

-  lStack_98 = 0;

-  lStack_68 = 0;

-  puStack_70 = param_3;

-  if (*(int *)(lVar1 + 0xe24) != -1) {

-    in_stack_ffffffffffffff20 = (_DXGK_DISPLAY_SCENARIO_CONTEXT *)0x0;

-    KeWaitForSingleObject(&DAT_0,0,0,0);

-  }

-  if (*param_4 < 2) {

-    iVar6 = Feature_Usb4PerAdapterPowerQueue__private_IsEnabledDeviceUsageNoInline();

-    if (iVar6 == 0) {

-      MonitorFlushUsb4PowerOnWorkQueue();

-    }

-    in_stack_00000060 = '\x01';

-    uVar15 = uVar7;

+  local_58 = __security_cookie ^ (ulonglong)auStackY_268;

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

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

+    local_1bc = 0;

+    local_1c0 = 0;

+    local_1c8 = 0;

+    local_1e0 = 0;

+    local_1b4 = *(uint *)(lVar2 + 0x18) & 0xffff00 | 1;

+    local_1a8 = *(undefined8 *)(lVar2 + 0xa88);

+    local_1e8 = 0x1e;

+    local_1e4 = 0x48;

+    local_1d8 = 0;

+    uStack_1d0 = 0;

+    local_1b8 = 0x27;

+    local_1b0 = param_2;

+    local_1ac = (uint)param_4;

+    DxgkWriteDiagEntry((_DXGK_DIAG_HEADER *)&local_1e8,*(__uint64 *)(lVar2 + 0x1700));

+  }

+  lVar7 = DpiFdoGetChildDescriptor(lVar2,param_2);

+  if (lVar7 == 0) {

+    uVar10 = 0xffffffffc000000e;

+    WdLogSingleEntry1(2,0xffffffffc000000e);

+    _WdLogGlobalForLineNumber = 0x1238;

+    goto LAB_0;

+  }

+  lVar8 = *(longlong *)(lVar7 + 0x30);

+  bVar9 = param_4;

+  if (lVar8 == 0) {

+    bVar11 = 0;

   }

   else {

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,1);

-    uVar4 = DpiAcquireCoreSyncAccessSafe(param_1,1);

-    if (-1 < (int)uVar4) {

-      DxgkReportMonitorPowerRapidHpdTriggerEvent(*(undefined8 *)(lVar1 + 0xfc0),1);

-      MonitorEnableDisableMonitor

-                (*(void **)(lVar1 + 0xfc0),param_2,puStack_70,'\0',

-                 (MONITOR_EVENT)in_stack_ffffffffffffff20,1,in_stack_00000068);

-      DpiReleaseCoreSyncAccessSafe(param_1,1);

-    }

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,0x80000001,uVar4,&uStack_30);

-    uVar15 = (ulonglong)uVar4;

-  }

-  KeEnterCriticalRegion();

-  if (*(char *)(lVar1 + 0x1e4) != '\0') {

-    DpiCheckForOutstandingD3Requests(lVar1);

-  }

-  ExAcquireResourceSharedLite(*(undefined8 *)(lVar1 + 0xa8),1);

-  iVar6 = *(int *)(lVar1 + 0xec);

-  if ((iVar6 == 2) ||

-     (((*(int *)(lVar1 + 0xf0) == 2 && ((iVar6 - 3U & 0xfffffffc) == 0)) && (iVar6 != 4)))) {

-    iVar6 = Feature_Usb4PerAdapterPowerQueue__private_IsEnabledDeviceUsageNoInline();

-    if (iVar6 != 0) {

-      MonitorGetUsb4PowerFlushEvent(&lStack_78);

-      if (lStack_78 != 0) {

-        if (*(char *)(lVar1 + 0x1e4) != '\0') {

-          DpiEnableD3Requests(*(undefined8 *)(lVar1 + 0x18));

-        }

-        ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0xa8));

-        KeLeaveCriticalRegion();

-        in_stack_ffffffffffffff20 = (_DXGK_DISPLAY_SCENARIO_CONTEXT *)0x0;

-        KeWaitForSingleObject(lStack_78,0,0,0);

-        KeEnterCriticalRegion();

-        if (*(char *)(lVar1 + 0x1e4) != '\0') {

-          DpiCheckForOutstandingD3Requests(lVar1);

-        }

-        ExAcquireResourceSharedLite(*(undefined8 *)(lVar1 + 0xa8),1);

-        iVar6 = *(int *)(lVar1 + 0xec);

-        if ((iVar6 != 2) &&

-           (((*(int *)(lVar1 + 0xf0) != 2 || ((iVar6 - 3U & 0xfffffffc) != 0)) || (iVar6 == 4)))) {

-          if (*(char *)(lVar1 + 0x1e4) != '\0') {

-            DpiEnableD3Requests(*(undefined8 *)(lVar1 + 0x18));

-          }

-          ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0xa8));

-          KeLeaveCriticalRegion();

-          wil::details::

-          unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-          ::

-          ~unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-                    ((unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-                      *)&lStack_78);

-          goto LAB_1;

+    uVar3 = IsInternalVideoOutput(*(_D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY *)(lVar7 + 4));

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

+      bVar11 = 1;

+    }

+    else {

+      lVar8 = *(longlong *)(lVar8 + 0x40);

+      if (*(byte *)(lVar7 + 0x42) != param_4) {

+        Feature_BrokeredDisplays_ConsoleSessions__private_IsEnabledPreCheck();

+        memset(local_148,0,0xe8);

+        iVar4 = ZwPowerInformation(8,0,0,local_148);

+        if (iVar4 < 0) {

+          bVar12 = false;

+          WdLogSingleEntry1(2,(longlong)iVar4);

+          _WdLogGlobalForLineNumber = 0x1278;

+        }

+        else {

+          uVar3 = DISPLAY_MUX_MGR::IsSwitchInProgress(DAT_1);

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

+            bVar12 = local_12c != 0;

+          }

+          else {

+            bVar12 = false;

+          }

+        }

+        if (param_4 == 0) {

+          iVar4 = Feature_DisplayMux_PostGA_BugBundle_3__private_IsEnabledDeviceUsageNoInline();

+          if ((iVar4 != 0) && (bVar12 != false)) {

+            local_190 = 0;

+            local_158 = *(undefined8 *)(lVar2 + 0xa88);

+            local_170 = 0;

+            local_178 = 0;

+            local_160 = 0;

+            local_198 = 0x1e;

+            local_194 = 0x48;

+            local_188 = 0;

+            uStack_180 = 0;

+            local_168 = 0x8e;

+            local_164 = param_2;

+            DxgkWriteDiagEntry((_DXGK_DIAG_HEADER *)&local_198,*(__uint64 *)(lVar2 + 0x1700));

+          }

+          lVar5 = MonitorRemovePhysicalMonitor

+                            (*(void **)(lVar2 + 0xfc0),param_2,bVar12,param_10,param_11);

+          uVar10 = (ulonglong)lVar5;

+          if (lVar5 < 0) {

+            WdLogSingleEntry1(2,uVar10);

+            _WdLogGlobalForLineNumber = 0x12e1;

+            goto LAB_0;

+          }

+          if (((bVar12 == false) && (*(char *)(lVar8 + 0x3b0) != '\0')) &&

+             (iVar4 = DpiPdoSetMonitorDriverInterfaceState(*(undefined8 *)(lVar7 + 0x30),0),

+             iVar4 < 0)) {

+            WdLogSingleEntry1(3,(longlong)iVar4);

+            _WdLogGlobalForLineNumber = 0x12f2;

+          }

+        }

+        else {

+          lVar5 = MonitorCreatePhysicalMonitor

+                            (*(void **)(lVar2 + 0xfc0),param_2,*(_DEVICE_OBJECT **)(lVar7 + 0x30),

+                             '\x01',param_4,(_DXGK_CONNECTION_USB4_INFO *)0x0,param_10,param_11);

+          uVar10 = (ulonglong)lVar5;

+          if (lVar5 < 0) {

+            WdLogSingleEntry1(2,uVar10);

+            _WdLogGlobalForLineNumber = 0x129e;

+            goto LAB_0;

+          }

+          if (*(char *)(lVar8 + 0x3b0) != '\0') {

+            MonitorNotifyDeviceNodeReady

+                      (*(void **)(lVar2 + 0xfc0),param_2,*(_DEVICE_OBJECT **)(lVar7 + 0x30));

+            iVar4 = DpiPdoSetMonitorDriverInterfaceState(*(undefined8 *)(lVar7 + 0x30),1);

+            if (iVar4 < 0) {

+              WdLogSingleEntry1(3,(longlong)iVar4);

+              _WdLogGlobalForLineNumber = 0x12bc;

+            }

+          }

         }

       }

-      wil::details::

-      unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-      ::

-      ~unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-                ((unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

-                  *)&lStack_78);

-    }

-    if ((*(char *)(lVar1 + 0xe41) != '\0') && (*param_4 == 1)) {

-      DisplayLogSetMonitorPowerStage(in_stack_00000068,2,0,&uStack_30);

-      DpiFdoInvalidateChildRelations(param_1,6,in_stack_00000068);

-      DisplayLogSetMonitorPowerStage(in_stack_00000068,0x80000002,0,&uStack_30);

-    }

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,4,0,&uStack_30);

-    KeEnterCriticalRegion();

-    ExAcquireResourceSharedLite(lVar1 + 0xd70,1);

-    if ((in_stack_00000060 != '\0') && (*(uint *)(lVar1 + 0xed8) != 0)) {

-      lStack_98 = ExAllocatePool2(0x40,(ulonglong)*(uint *)(lVar1 + 0xed8) * 0x38,0x74727044);

-      if (lStack_98 == 0) {

-        WdLogSingleEntry1(6,0);

-        _WdLogGlobalForLineNumber = 0x2f3b;

+      bVar11 = 1;

+      bVar9 = 1;

+    }

+  }

+  *(byte *)(lVar7 + 0x42) = param_4;

+  if (bVar9 != 0) {

+    MonitorCancelSkippedDepartures(*(void **)(lVar2 + 0xfc0),param_2);

+  }

+  if ((bVar11 == bVar9) && ((bVar9 == 0 || (param_6 == '\0')))) {

+    uVar10 = 0;

+  }

+  else {

+    *(byte *)(lVar7 + 0x41) = bVar9;

+    if (bVar9 == 0) {

+      uVar6 = DpiPdoRemovePdo(param_1,lVar7,1,param_10);

+    }

+    else {

+      uVar6 = DpiPdoAddPdo(param_1,lVar7,param_3,param_5);

+    }

+    uVar10 = (ulonglong)uVar6;

+    if (((-1 < (int)uVar6) && (uVar6 != 0x40000000)) && (uVar6 != 0x80)) {

+      uVar6 = *(uint *)(lVar2 + 0xec4);

+      do {

+        LOCK();

+        uVar1 = *(uint *)(lVar2 + 0xec4);

+        bVar12 = uVar6 == uVar1;

+        if (bVar12) {

+          *(uint *)(lVar2 + 0xec4) = uVar6 | 1;

+          uVar1 = uVar6;

+        }

+        uVar6 = uVar1;

+        UNLOCK();

+      } while (!bVar12);

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

+        IoInvalidateDeviceRelations(*(undefined8 *)(lVar2 + 0x98),0);

       }

-      lStack_68 = lStack_98 + (ulonglong)*(uint *)(lVar1 + 0xed8) * 8;

-    }

-    plVar14 = *(longlong **)(lVar1 + 0xe10);

-    if (plVar14 != (longlong *)(lVar1 + 0xe10)) {

-      do {

-        plVar2 = (longlong *)*plVar14;

-        if ((int)plVar14[-4] == 1) {

-          if (*puStack_70 == 0xffffffff) {

-LAB_2:

-            if (plVar14[2] != 0) {

-              lVar12 = *(longlong *)(plVar14[2] + 0x40);

-              lVar8 = IoGetAttachedDeviceReference();

-              if (lVar8 == 0) {

-                uVar15 = 0xc0000001;

-                WdLogSingleEntry1(2,0xffffffffc0000001);

-                _WdLogGlobalForLineNumber = 0x2fe7;

-              }

-              else {

-                uStack_48 = 0;

-                local_58 = 0;

-                uStack_50 = 0;

-                uStack_40 = 0;

-                uStack_38 = 0;

-                KeInitializeEvent(&local_58,0,0);

-                aiStack_80[0] = *param_4;

-                in_stack_ffffffffffffff20 = (_DXGK_DISPLAY_SCENARIO_CONTEXT *)0x0;

-                lVar9 = IoBuildDeviceIoControlRequest(0x23242f,lVar8,aiStack_80,4);

-                if (lVar9 == 0) {

-                  uVar15 = 0xc000009a;

-                  WdLogSingleEntry1(6);

-                  _WdLogGlobalForLineNumber = 0x2fd6;

-                }

-                else {

-                  *(undefined4 *)(lVar9 + 0x30) = 0xc00000bb;

-                  uVar4 = IofCallDriver(lVar8);

-                  if (uVar4 == 0x103) {

-                    in_stack_ffffffffffffff20 = (_DXGK_DISPLAY_SCENARIO_CONTEXT *)0x0;

-                    KeWaitForSingleObject(&local_58,0,0,0);

-                    uVar4 = (uint)uStack_40;

-                  }

-                  uVar15 = (ulonglong)uVar4;

-                  if ((int)uVar4 < 0) {

-                    KeEnterCriticalRegion();

-                    if (*(char *)(lVar12 + 0x1e4) != '\0') {

-                      DpiCheckForOutstandingD3Requests(lVar12);

-                    }

-                    ExAcquireResourceExclusiveLite(*(undefined8 *)(lVar12 + 0xa8),1);

-                    uVar4 = DpiPdoSetDevicePower(plVar14[2],*param_4,0);

-                    uVar15 = (ulonglong)uVar4;

-                    if (*(char *)(lVar12 + 0x1e4) != '\0') {

-                      DpiEnableD3Requests(*(undefined8 *)(lVar12 + 0x18));

-                    }

-                    ExReleaseResourceLite(*(undefined8 *)(lVar12 + 0xa8));

-                    KeLeaveCriticalRegion();

-                  }

-                  else if (lStack_98 != 0) {

-                    ObfReferenceObject(*(undefined8 *)(lVar12 + 0x18));

-                    if (*param_4 == 1) {

-                      lVar12 = lVar12 + 0x3f0;

-                    }

-                    else {

-                      lVar12 = lVar12 + 0x3d8;

-                    }

-                    *(longlong *)(lStack_98 + uVar7 * 8) = lVar12;

-                    uVar7 = (ulonglong)((int)uVar7 + 1);

-                  }

-                }

-                ObfDereferenceObject();

-              }

-            }

-            *(int *)((longlong)plVar14 + 0x24) = *param_4;

-          }

-          else {

-            uVar10 = 0;

-            if (param_2 != 0) {

-              do {

-                if (puStack_70[uVar10] == *(ulong *)(plVar14 + -1)) break;

-                uVar4 = (int)uVar10 + 1;

-                uVar10 = (ulonglong)uVar4;

-              } while (uVar4 < param_2);

-              if ((uint)uVar10 < param_2) goto LAB_2;

-            }

-          }

-        }

-        plVar14 = plVar2;

-      } while (plVar2 != (longlong *)(lVar1 + 0xe10));

-      uStack_b0 = (uint)uVar7;

-    }

-    ExReleaseResourceLite(lVar1 + 0xd70);

-    KeLeaveCriticalRegion();

-    if (*(char *)(lVar1 + 0x1e4) != '\0') {

-      DpiEnableD3Requests(*(undefined8 *)(lVar1 + 0x18));

-    }

-    ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0xa8));

-    KeLeaveCriticalRegion();

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

-      iVar6 = 10;

-      lVar12 = uVar7 * -1000000;

-      do {

-        uVar10 = 0;

-        iVar6 = iVar6 + -1;

-        do {

-          uVar4 = (uint)uVar7;

-          if (0x40 < uVar4) {

-            uVar7 = 0x40;

-          }

-          in_stack_ffffffffffffff20 =

-               (_DXGK_DISPLAY_SCENARIO_CONTEXT *)

-               ((ulonglong)in_stack_ffffffffffffff20 & 0xffffffffffffff00);

-          lStack_60 = lVar12;

-          iVar5 = KeWaitForMultipleObjects(uVar7,lStack_98 + uVar10 * 8,0,0);

-          uVar15 = (ulonglong)iVar5;

-          if (iVar5 == 0x102) {

-            if (iVar6 == 0) {

-              WdLogSingleEntry1(2,0x102);

-              _WdLogGlobalForLineNumber = 0x3039;

-            }

-            else {

-              WdLogSingleEntry1(3,0x102);

-              _WdLogGlobalForLineNumber = 0x302d;

-            }

-          }

-          else if (iVar5 != 0) {

-            DisplayLogSetMonitorPowerStage(in_stack_00000068,0x80000004,iVar5,&uStack_30);

-            WdLogSingleEntry1(2,uVar15);

-            _WdLogGlobalForLineNumber = 0x3042;

-            goto LAB_3;

-          }

-          uVar10 = (ulonglong)(uint)((int)uVar10 + (int)uVar7);

-          uVar4 = uVar4 - (int)uVar7;

-          uVar7 = (ulonglong)uVar4;

-        } while (uVar4 != 0);

-      } while ((iVar5 == 0x102) && (uVar7 = (ulonglong)uStack_b0, iVar6 != 0));

-    }

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,0x80000004,uVar15 & 0xffffffff,&uStack_30);

-  }

-  else {

-    if (*(char *)(lVar1 + 0x1e4) != '\0') {

-      DpiEnableD3Requests(*(undefined8 *)(lVar1 + 0x18));

-    }

-    ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0xa8));

-    KeLeaveCriticalRegion();

-  }

-LAB_1:

-  if (*param_4 == 1) {

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,8);

-    KeEnterCriticalRegion();

-    if (*(char *)(lVar1 + 0x1e4) != '\0') {

-      DpiCheckForOutstandingD3Requests(lVar1);

-    }

-    ExAcquireResourceSharedLite(*(undefined8 *)(lVar1 + 0xa8),1);

-    KeEnterCriticalRegion();

-    ExAcquireResourceSharedLite(lVar1 + 0xd70,1);

-    iVar6 = DpiAcquireCoreSyncAccessSafe(param_1,1);

-    uVar15 = (ulonglong)iVar6;

-    if (iVar6 < 0) {

-      WdLogSingleEntry1(4,uVar15);

-      _WdLogGlobalForLineNumber = 0x30d1;

-    }

-    else {

-      puVar11 = *(undefined8 **)(lVar1 + 0xe10);

-      while (puVar13 = puVar11, MVar16 = (MONITOR_EVENT)in_stack_ffffffffffffff20,

-            puVar13 != (undefined8 *)(lVar1 + 0xe10)) {

-        puVar11 = (undefined8 *)*puVar13;

-        uVar3 = IsInternalVideoOutput

-                          (*(_D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY *)((longlong)puVar13 + -0x1c));

-        if ((uVar3 != '\0') && (*(char *)((longlong)puVar13 + 0x22) == '\0')) {

-          in_stack_ffffffffffffff20 = in_stack_00000068;

-          MonitorRemovePhysicalMonitor

-                    (*(void **)(lVar1 + 0xfc0),*(uint *)(puVar13 + -1),'\0',(uchar *)0x0,

-                     in_stack_00000068);

-          lVar12 = puVar13[2];

-          if ((lVar12 != 0) &&

-             ((*(longlong *)(lVar12 + 0x40) != 0 &&

-              (*(char *)(*(longlong *)(lVar12 + 0x40) + 0x3b0) != '\0')))) {

-            iVar6 = DpiPdoSetMonitorDriverInterfaceState(lVar12,0);

-            uVar15 = (ulonglong)iVar6;

-            if (iVar6 < 0) {

-              WdLogSingleEntry1(3,uVar15);

-              _WdLogGlobalForLineNumber = 0x30a7;

-            }

-          }

-        }

-      }

-      DxgkReportMonitorPowerRapidHpdTriggerEvent(*(undefined8 *)(lVar1 + 0xfc0),0);

-      MonitorEnableDisableMonitor

-                (*(void **)(lVar1 + 0xfc0),param_2,puStack_70,'\x01',MVar16,0,in_stack_00000068);

-      DpiReleaseCoreSyncAccessSafe(param_1,1);

-    }

-    DisplayLogSetMonitorPowerStage(in_stack_00000068,0x80000008,uVar15 & 0xffffffff,&uStack_30);

-    ExReleaseResourceLite(lVar1 + 0xd70);

-    KeLeaveCriticalRegion();

-    if (*(char *)(lVar1 + 0x1e4) != '\0') {

-      DpiEnableD3Requests(*(undefined8 *)(lVar1 + 0x18));

-    }

-    ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0xa8));

-    KeLeaveCriticalRegion();

-  }

-LAB_3:

-  if (lStack_98 != 0) {

-    uVar7 = (ulonglong)uStack_b0;

-    if (uStack_b0 != 0) {

-      plVar14 = (longlong *)(lStack_98 + uVar7 * 8);

-      do {

-        plVar14 = plVar14 + -1;

-        puVar11 = (undefined8 *)(*plVar14 + -0x3d8);

-        if (*param_4 != 1) {

-          puVar11 = (undefined8 *)(*plVar14 + -0x3c0);

-        }

-        ObfDereferenceObject(*puVar11);

-        uVar4 = (int)uVar7 - 1;

-        uVar7 = (ulonglong)uVar4;

-      } while (uVar4 != 0);

-    }

-    ExFreePoolWithTag(lStack_98,0);

-  }

-  return uVar15 & 0xffffffff;

+    }

+  }

+LAB_0:

+  return uVar10 & 0xffffffff;

 }
```

## `NtGdiDdDDIRemoveSurfaceFromSwapChain`  (modified)

```diff
--- NtGdiDdDDIRemoveSurfaceFromSwapChain
+++ NtGdiDdDDIRemoveSurfaceFromSwapChain
@@ -1,65 +1,160 @@
 

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

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

 

-long NtGdiDdDDIRemoveSurfaceFromSwapChain(longlong param_1,undefined8 param_2)

+ulonglong NtGdiDdDDIRemoveSurfaceFromSwapChain(void *param_1,undefined8 param_2,undefined8 param_3)

 

 {

-  char *pcVar1;

-  int iVar2;

-  long lVar3;

-  bool bVar4;

-  longlong unaff_RBP;

-  undefined4 unaff_ESI;

-  longlong unaff_RDI;

-  uint unaff_R12D;

-  DXGSWAPCHAIN *unaff_R14;

-  longlong unaff_R15;

-  uint in_stack_00000050;

-  undefined8 in_stack_00000058;

-  int in_stack_000001d0;

+  DXGSWAPCHAIN *pDVar1;

+  DXGDEVICE *pDVar2;

+  int iVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  bool bVar6;

+  undefined4 uVar7;

+  undefined1 auStack_1b8 [32];

+  DXGDEVICE **local_198;

+  undefined8 local_190;

+  undefined8 local_188;

+  undefined8 local_180;

+  undefined8 local_178;

+  DXGDEVICE *local_168;

+  undefined4 local_160 [2];

+  undefined8 local_158;

+  char local_150;

+  DXGDEVICE *local_148;

+  undefined8 local_140;

+  ulonglong uStack_138;

+  undefined8 local_130;

+  undefined8 uStack_128;

+  DXGSWAPCHAINLOCKWITHDEVICE local_118 [128];

+  DXGSWAPCHAINLOCKWITHDEVICE local_98 [128];

+  ulonglong local_18;

   

-  pcVar1 = (char *)(param_1 + 0x62 + unaff_RDI);

-  *pcVar1 = *pcVar1 + (char)param_1;

-  *(byte *)(unaff_RBP + 0x49) = *(byte *)(unaff_RBP + 0x49) | (byte)((ulonglong)param_2 >> 8);

-  WdLogSingleEntry0(unaff_ESI);

-  _WdLogGlobalForLineNumber = 0xfe3;

-  DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pClientInfo->pTempDevice",0xfe3);

-  iVar2 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

-  if (((iVar2 != 0) && (*(char *)(unaff_RDI + 0x2c) != (char)unaff_R12D)) &&

-     (in_stack_000001d0 == 0)) {

-    WdLogSingleEntry0(unaff_ESI);

-    _WdLogGlobalForLineNumber = 0xfe6;

-    DxgkLogInternalTriageEvent

-              (0,0x40002,0xffffffff,L"!pClientInfo->bUserModeFences || IddPresent",0xfe6);

-  }

-  if (*(longlong *)(*(DXGDEVICE **)(unaff_RDI + 8) + 0x28) == 0) {

-    WdLogSingleEntry0(2);

-    bVar4 = false;

-    _WdLogGlobalForLineNumber = 0xfed;

-    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Invalid process context",0xfed);

-    DXGSWAPCHAIN::MarkAbandoned(unaff_R14,bVar4);

-    lVar3 = -0x3ffffff3;

+                    /* 0x2074b0  260  NtGdiDdDDIRemoveSurfaceFromSwapChain */

+  local_18 = __security_cookie ^ (ulonglong)auStack_1b8;

+  local_160[0] = 0xffffffff;

+  local_158 = 0;

+  bVar6 = false;

+  if (((byte)DAT_0 & 2) == 0) {

+    local_150 = '\0';

   }

   else {

-    in_stack_00000050 = unaff_R12D;

-    DXGDEVICE::GetContexts(*(DXGDEVICE **)(unaff_RDI + 8),&stack0x00000050,(uint *)&stack0x00000060)

-    ;

-    if (in_stack_00000050 == unaff_R12D) {

-      WdLogSingleEntry2(2);

-      _WdLogGlobalForLineNumber = 0xffa;

-      DxgkLogInternalTriageEvent

-                (0,0x40000,0xffffffff,

-                 L"Swapchain 0x%I64x Failed to get context count for device 0x%I64x");

-      lVar3 = -0x3fffffff;

+    local_150 = '\x01';

+    local_160[0] = 0x898;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,param_3,0x898);

+    }

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_160,0x898);

+  local_140 = 0;

+  uStack_138 = 0;

+  local_130 = 0;

+  uStack_128 = 0;

+  if (*(void **)MmUserProbeAddress_exref <= param_1) {

+    param_1 = *(void **)MmUserProbeAddress_exref;

+  }

+  RtlCopyVolatileMemory(&local_140,param_1,0x20);

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

+    WdLogSingleEntry0(2);

+    _WdLogGlobalForLineNumber = 0x42f;

+    local_178 = 0;

+    local_180 = 0;

+    local_188 = 0;

+    local_190 = 0;

+    local_198 = (DXGDEVICE **)0x42f;

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"RemoveSurface is not allowed for consumer");

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_160);

+    if ((local_150 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = 0xc000000d;

+  }

+  else {

+    iVar3 = Feature_317184312__private_IsEnabledDeviceUsageNoInline();

+    local_190 = 0;

+    if (iVar3 == 0) {

+      local_148 = (DXGDEVICE *)0x0;

+      local_198 = &local_148;

+      iVar3 = ObReferenceObjectByHandle(local_140,0x20000,g_pDxgkSharedSwapChainObjectType,1);

+      pDVar2 = local_148;

+      uVar5 = (ulonglong)iVar3;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_140,uVar5);

+        _WdLogGlobalForLineNumber = 0x46d;

+      }

+      else {

+        pDVar1 = *(DXGSWAPCHAIN **)local_148;

+        local_168 = (DXGDEVICE *)0x0;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE(local_98,pDVar1,true,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar6 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_98,&local_168,true,bVar6);

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

+          uVar4 = DXGSWAPCHAIN::RemoveSurface

+                            (*(DXGSWAPCHAIN **)pDVar2,

+                             (_D3DKMT_REMOVESURFACEFROMSWAPCHAIN *)&local_140);

+        }

+        uVar5 = (ulonglong)uVar4;

+        uVar7 = ObfDereferenceObject(pDVar2);

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

+          local_180 = CONCAT44(local_180._4_4_,(undefined4)uStack_128);

+          local_188 = local_130;

+          local_190 = CONCAT44(local_190._4_4_,(int)uStack_138);

+          local_198 = (DXGDEVICE **)CONCAT44(local_198._4_4_,uVar4);

+          McTemplateK0pqqpq_EtwWriteTransfer(uVar7,&EventIndirectSwapChainRemoveSurface);

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_98);

+      }

     }

     else {

-      Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

-      lVar3 = SignalSynchronizationObjectInternal

-                        (1,(longlong)*(int *)(unaff_RDI + 0x1c) * 0x30 + 0x50 + unaff_R15,unaff_R12D

-                         ,in_stack_00000050,&stack0x00000060);

+      local_168 = (DXGDEVICE *)0x0;

+      local_198 = &local_168;

+      iVar3 = ObReferenceObjectByHandle();

+      pDVar2 = local_168;

+      uVar5 = (ulonglong)iVar3;

+      local_148 = local_168;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_140,uVar5);

+        _WdLogGlobalForLineNumber = 0x440;

+      }

+      else {

+        pDVar1 = *(DXGSWAPCHAIN **)local_168;

+        local_168 = (DXGDEVICE *)0x0;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE(local_118,pDVar1,true,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar6 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_118,&local_168,true,bVar6);

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

+          uVar4 = DXGSWAPCHAIN::RemoveSurface

+                            (*(DXGSWAPCHAIN **)pDVar2,

+                             (_D3DKMT_REMOVESURFACEFROMSWAPCHAIN *)&local_140);

+        }

+        uVar5 = (ulonglong)uVar4;

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

+          local_180 = CONCAT44(local_180._4_4_,(undefined4)uStack_128);

+          local_188 = local_130;

+          local_190 = CONCAT44(local_190._4_4_,(int)uStack_138);

+          local_198 = (DXGDEVICE **)CONCAT44(local_198._4_4_,uVar4);

+          McTemplateK0pqqpq_EtwWriteTransfer

+                    (uStack_138 & 0xffffffff,&EventIndirectSwapChainRemoveSurface);

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_118);

+      }

+      NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>::

+      ~NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>

+                ((NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64> *)&local_148);

     }

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_160);

+    if ((local_150 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = uVar5 & 0xffffffff;

   }

-  return lVar3;

+  return uVar5;

 }
```

## `DpiCleanUpGlobalState`  (modified)

```diff
--- DpiCleanUpGlobalState
+++ DpiCleanUpGlobalState
@@ -1,143 +1,42 @@
 

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

-

-undefined8 DpiCleanUpGlobalState(ulonglong param_1,undefined8 param_2,longlong param_3)

+void DpiCleanUpGlobalState(void)

 

 {

-  longlong lVar1;

-  ushort uVar2;

-  short sVar3;

-  short sVar4;

-  longlong lVar5;

-  ulonglong uVar6;

-  undefined8 uVar7;

-  __uint64 _Var8;

-  void *pvVar9;

-  short *psVar10;

-  ulonglong uVar11;

-  int iVar12;

-  longlong lVar13;

-  uint uVar15;

-  ulonglong unaff_RBX;

-  uint uVar16;

-  ulonglong unaff_RBP;

-  int *piVar17;

-  ushort *unaff_RDI;

-  undefined8 *puVar18;

-  uint *unaff_R12;

-  int unaff_R13D;

-  ulonglong uVar19;

-  undefined8 *unaff_R15;

-  ulonglong uVar20;

-  ushort *puStackX_20;

-  undefined8 *in_stack_00000038;

-  uint *in_stack_00000040;

-  longlong lVar14;

+  DISPLAY_MUX_MGR *pDVar1;

+  int iVar2;

   

-  if ((int)unaff_RBX != 0) {

-    uVar20 = unaff_RBX & 0xffffffff;

-    do {

-      uVar2 = *unaff_RDI;

-      uVar19 = param_1 & 0xffffffff;

-      lVar5 = *(longlong *)(unaff_RDI + 4);

-      uVar11 = param_1;

-      if ((ulonglong)uVar2 != 0) {

-        do {

-          lVar1 = param_1 + lVar5;

-          lVar13 = -1;

-          do {

-            lVar14 = lVar13;

-            lVar13 = lVar14 + 1;

-          } while (*(short *)(lVar1 + lVar13 * 2) != (short)uVar11);

-          iVar12 = (int)lVar13;

-          unaff_RDI = puStackX_20;

-          uVar20 = unaff_RBX;

-          if (iVar12 == 0) break;

-          uVar6 = uVar11 & 0xff;

-          uVar11 = uVar11 & 0xffffffff;

-          uVar16 = (uint)unaff_RBP;

-          if (uVar16 == 0) {

-LAB_0:

-            if (uVar16 < 0x1e) {

-              *(longlong *)(&stack0x000000d0 + unaff_RBP * 8) = lVar1;

-              *(int *)(&stack0x00000050 + unaff_RBP * 4) = (int)lVar14 + 2;

-              unaff_RBP = (ulonglong)(uVar16 + (int)param_3);

-              unaff_R13D = unaff_R13D + 1 + iVar12;

-            }

-          }

-          else {

-            puVar18 = (undefined8 *)&stack0x000000d0;

-            do {

-              if ((char)uVar6 != '\0') goto LAB_1;

-              psVar10 = (short *)*puVar18;

-              lVar13 = lVar1 - (longlong)psVar10;

-              do {

-                sVar3 = *psVar10;

-                sVar4 = *(short *)((longlong)psVar10 + lVar13);

-                if (sVar3 != sVar4) break;

-                psVar10 = psVar10 + 1;

-              } while (sVar4 != 0);

-              param_3 = 1;

-              if (sVar3 == sVar4) {

-                uVar6 = 1;

-              }

-              uVar15 = (int)uVar11 + 1;

-              uVar11 = (ulonglong)uVar15;

-              puVar18 = puVar18 + 1;

-            } while (uVar15 < uVar16);

-            if ((char)uVar6 == '\0') goto LAB_0;

-          }

-LAB_1:

-          uVar11 = 0;

-          uVar19 = (ulonglong)(uint)((int)uVar19 + 1 + iVar12);

-          param_1 = uVar19 * 2;

-        } while (param_1 < uVar2);

-      }

-      unaff_RDI = unaff_RDI + 8;

-      uVar20 = uVar20 - param_3;

-      param_1 = uVar11;

-      unaff_R12 = in_stack_00000040;

-      unaff_R15 = in_stack_00000038;

-      puStackX_20 = unaff_RDI;

-      unaff_RBX = uVar20;

-    } while (uVar20 != 0);

+  KeCancelTimer(&DAT_0);

+  DpiPdoPollingWorkItem(g_pDriverObject,1);

+  KeFlushQueuedDpcs();

+  if (DAT_1 != 0) {

+    IoFreeWorkItem();

   }

-  uVar16 = unaff_R13D + 1;

-  if (uVar16 < 64000) {

-    _Var8 = SUB168(ZEXT816(2) * ZEXT416(uVar16),0);

-    if (SUB168(ZEXT816(2) * ZEXT416(uVar16),8) != 0) {

-      _Var8 = 0xffffffffffffffff;

-    }

-    pvVar9 = operator_new__(_Var8,0x4b677844,0x100);

-    if (pvVar9 == (void *)0x0) {

-      uVar7 = 0xc0000017;

-    }

-    else {

-      uVar20 = 0;

-      if ((int)unaff_RBP != 0) {

-        piVar17 = (int *)&stack0x00000050;

-        puVar18 = (undefined8 *)&stack0x000000d0;

-        do {

-          iVar12 = (int)uVar20;

-          if (uVar16 - iVar12 != 0) {

-            RtlStringCchCopyW((ushort *)((longlong)pvVar9 + uVar20 * 2),(ulonglong)(uVar16 - iVar12)

-                              ,(ushort *)*puVar18);

-            uVar20 = (ulonglong)(uint)(iVar12 + *piVar17);

-          }

-          puVar18 = puVar18 + 1;

-          piVar17 = piVar17 + 1;

-          unaff_RBP = unaff_RBP - 1;

-        } while (unaff_RBP != 0);

-      }

-      *(undefined2 *)((longlong)pvVar9 + uVar20 * 2) = 0;

-      uVar7 = 0;

-      *unaff_R15 = pvVar9;

-      *unaff_R12 = uVar16;

-    }

+  iVar2 = Feature_ForceMonitorDetectionOnUsbTunnelStateChange__private_IsEnabledDeviceUsageNoInline

+                    ();

+  if ((iVar2 != 0) && (DAT_2 != 0)) {

+    ExUnsubscribeWnfStateChange();

+    DAT_2 = 0;

   }

-  else {

-    uVar7 = 0xc00000bb;

+  ExDeleteNPagedLookasideList(&DAT_3);

+  if (DAT_4 != 0) {

+    ExFreePoolWithTag(DAT_4,0);

+    DAT_4 = 0;

   }

-  return uVar7;

+  ExDeleteNPagedLookasideList(&DAT_5);

+  if (DAT_6 != 0) {

+    ExFreePoolWithTag(DAT_6,0);

+    DAT_6 = 0;

+  }

+  if (DAT_7 != 0) {

+    IoUnregisterPlugPlayNotificationEx();

+    DAT_7 = 0;

+  }

+  pDVar1 = DAT_8;

+  if (DAT_8 != (DISPLAY_MUX_MGR *)0x0) {

+    DISPLAY_MUX_MGR::~DISPLAY_MUX_MGR(DAT_8);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pDVar1);

+    DAT_8 = (DISPLAY_MUX_MGR *)0x0;

+  }

+  return;

 }
```

## `WriteDxgDiagnosticsEvent`  (modified)

```diff
--- WriteDxgDiagnosticsEvent
+++ WriteDxgDiagnosticsEvent
@@ -1,10 +1,217 @@
 

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

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

+/* void __cdecl WriteDxgDiagnosticsEvent(struct _DXGK_DIAG_HEADER * __ptr64) */

 

 void __cdecl WriteDxgDiagnosticsEvent(_DXGK_DIAG_HEADER *param_1)

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  int iVar2;

+  wchar_t *pwVar3;

+  bool bVar4;

+  

+  iVar2 = *(int *)param_1;

+  lVar1 = (longlong)iVar2;

+  if (iVar2 < 0x1f) {

+    if (iVar2 == 0x1e) {

+      WriteDxgDiagnosticsEvent_CODE_POINT_ADAPTERLUID(param_1);

+      return;

+    }

+    if (iVar2 < 0xf) {

+      if (iVar2 != 0xe) {

+        if (iVar2 < 8) {

+          if (iVar2 != 7) {

+            if (iVar2 == 0) {

+              WdLogSingleEntry1(1,0);

+              pwVar3 = L"DXGK_DIAG_TYPE_NONE (0x%lx), being logged but it never should";

+              _WdLogGlobalForLineNumber = 0x5a3;

+              goto LAB_0;

+            }

+            if (iVar2 != 1) {

+              if (iVar2 == 2) {

+                WriteDxgDiagnosticsEvent_HPD(param_1);

+                return;

+              }

+              if (iVar2 == 3) {

+                WriteDxgDiagnosticsEvent_DISPLAYCHANGE_ORIGIN(param_1);

+                return;

+              }

+              if (iVar2 == 4) {

+                WriteDxgDiagnosticsEvent_USER_CDS(param_1);

+                return;

+              }

+              if (iVar2 == 5) {

+                WriteDxgDiagnosticsEvent_DRV_CDS(param_1);

+                return;

+              }

+              if (iVar2 == 6) {

+                WriteDxgDiagnosticsEvent_CODE_POINT(param_1);

+                return;

+              }

+              goto LAB_1;

+            }

+          }

+        }

+        else {

+          if (iVar2 == 8) {

+            WriteDxgDiagnosticsEvent_MONITOR_MGR(param_1);

+            return;

+          }

+          if (iVar2 == 9) {

+            WriteDxgDiagnosticsEvent_CCD_CONNECTEDSET_NOT_FOUND(param_1);

+            return;

+          }

+          if (iVar2 == 10) goto LAB_2;

+          if ((iVar2 != 0xb) && (iVar2 = iVar2 + -0xc, iVar2 != 0)) goto LAB_3;

+        }

+      }

+    }

+    else if (iVar2 < 0x17) {

+      if (iVar2 != 0x16) {

+        if (iVar2 == 0xf) {

+          WriteDxgDiagnosticsEvent_OUTPUTDUPL(param_1);

+          return;

+        }

+        if (iVar2 == 0x10) {

+          WriteDxgDiagnosticsEvent_MONITOR_BRIGHTNESS(param_1);

+          return;

+        }

+        if (iVar2 != 0x11) {

+          if (iVar2 == 0x12) {

+            WriteDxgDiagnosticsEvent_MIRACAST_SESSION_START_DONE(param_1);

+            return;

+          }

+          if (iVar2 == 0x13) {

+            WriteDxgDiagnosticsEvent_MIRACAST_SESSION_START(param_1);

+            return;

+          }

+          bVar4 = iVar2 == 0x15;

+LAB_4:

+          if (!bVar4) goto LAB_1;

+        }

+      }

+    }

+    else if (iVar2 != 0x17) {

+      if (iVar2 == 0x18) {

+        WriteDxgDiagnosticsEvent_MIRACAST_SESSION_START_DONE_EX2(param_1);

+        return;

+      }

+      if (iVar2 == 0x19) {

+        WriteDxgDiagnosticsEvent_MONITOR_BRIGHTNESS_EX(param_1);

+        return;

+      }

+      if ((iVar2 == 0x1b) || (iVar2 == 0x1c)) goto LAB_2;

+      if (iVar2 == 0x1d) {

+        WriteDxgDiagnosticsEvent_MESSAGE_PACKET(param_1);

+        return;

+      }

+      goto LAB_1;

+    }

+  }

+  else {

+    if (0x2e < iVar2) {

+      if (iVar2 < 0x36) {

+        if (iVar2 == 0x35) {

+          return;

+        }

+        if (iVar2 == 0x2f) {

+          WriteDxgDiagnosticsEvent_SDC(param_1);

+          return;

+        }

+        if (iVar2 == 0x30) {

+          WriteDxgDiagnosticsEvent_QDC(param_1);

+          return;

+        }

+        if (iVar2 == 0x31) {

+          WriteDxgDiagnosticsEvent_CCD_DATABASE_ACCESS(param_1);

+          return;

+        }

+        if (iVar2 == 0x32) {

+          WriteDxgDiagnosticsEvent_BML_PACKET(param_1);

+          return;

+        }

+        iVar2 = iVar2 + -0x33;

+        if (iVar2 == 0) goto LAB_2;

+      }

+      else {

+        if (iVar2 == 0x36) {

+          return;

+        }

+        if (iVar2 == 0x37) {

+          return;

+        }

+        if (iVar2 == 0x38) {

+          return;

+        }

+        if (iVar2 == 0x39) {

+          return;

+        }

+        iVar2 = iVar2 + -0x3a;

+        if (iVar2 == 0) {

+          return;

+        }

+      }

+      if (iVar2 == 1) {

+        return;

+      }

+LAB_1:

+      WdLogSingleEntry1(1,lVar1);

+      pwVar3 = L"Unrecognized diag type 0x%lx, being logged";

+      _WdLogGlobalForLineNumber = 0x69a;

+      goto LAB_0;

+    }

+    if (iVar2 != 0x2e) {

+      if (0x27 < iVar2) {

+        if (iVar2 == 0x28) {

+          WriteDxgDiagnosticsEvent_MONITOR_BRIGHTNESS3(param_1);

+          return;

+        }

+        if (iVar2 == 0x29) {

+          WriteDxgDiagnosticsEvent_ADAPTER_START2(param_1);

+          return;

+        }

+        if (iVar2 == 0x2a) {

+LAB_2:

+          WdLogSingleEntry1(3,lVar1);

+          _WdLogGlobalForLineNumber = 0x669;

+          return;

+        }

+        if (iVar2 == 0x2b) {

+          WriteDxgDiagnosticsEvent_SDCDesktopCheckFailPacket(param_1);

+          return;

+        }

+        if (iVar2 == 0x2c) goto LAB_2;

+        if (iVar2 == 0x2d) {

+          WriteDxgDiagnosticsEvent_SetTimingsFromVidPnSourceMasksPacket(param_1);

+          return;

+        }

+        goto LAB_1;

+      }

+      if ((((iVar2 != 0x27) && (iVar2 != 0x1f)) && (iVar2 != 0x20)) && (iVar2 != 0x21)) {

+        if (iVar2 == 0x22) {

+          WriteDxgDiagnosticsEvent_DRIVER_RECOMMEND_VIDPN(param_1);

+          return;

+        }

+        if (iVar2 == 0x24) {

+          WriteDxgDiagnosticsEvent_FUNCTIONALIZE_PACKET(param_1);

+          return;

+        }

+        iVar2 = iVar2 + -0x25;

+        if (iVar2 == 0) {

+          WriteDxgDiagnosticsEvent_COMMIT_VIDPN_FAILED(param_1);

+          return;

+        }

+LAB_3:

+        bVar4 = iVar2 == 1;

+        goto LAB_4;

+      }

+    }

+  }

+  WdLogSingleEntry1(1,lVar1);

+  pwVar3 = L"Obsolete diag type 0x%lx, being logged";

+  _WdLogGlobalForLineNumber = 0x654;

+LAB_0:

+  DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,pwVar3,(longlong)*(int *)param_1,0,0,0,0);

+  return;

 }
```

## `DxgkDestroyAllocationInternal`  (modified)

```diff
--- DxgkDestroyAllocationInternal
+++ DxgkDestroyAllocationInternal
@@ -1,10 +1,902 @@
 

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

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

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

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

+/* long __cdecl DxgkDestroyAllocationInternal(class DXGPROCESS * __ptr64,class DXGDEVICE *

+   __ptr64,unsigned int * __ptr64,class DXGALLOCATION * __ptr64 * __ptr64,unsigned int,unsigned int

+   const * __ptr64 & __ptr64,unsigned int,struct _D3DDDICB_DESTROYALLOCATION2FLAGS,unsigned int

+   const * __ptr64,struct _DXGK_DISPLAY_SCENARIO_CONTEXT * __ptr64,unsigned char) */

 

-long __cdecl DxgkDestroyAllocationInternal(void)

+long __cdecl

+DxgkDestroyAllocationInternal

+          (DXGPROCESS *param_1,DXGDEVICE *param_2,undefined4 *param_3,DXGALLOCATION **param_4,

+          uint param_5,undefined8 *param_6,uint param_7,uint param_8,longlong param_9,

+          _DXGK_DISPLAY_SCENARIO_CONTEXT *param_10,char param_11)

 

 {

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

-  halt_baddata();

+  DXGALLOCATION *pDVar1;

+  DXGADAPTER *this;

+  longlong lVar2;

+  DXGDODPRESENT *this_00;

+  bool bVar3;

+  DXGPROCESS *pDVar4;

+  uchar uVar5;

+  bool bVar6;

+  char cVar7;

+  long lVar8;

+  int iVar9;

+  DXGALLOCATION *pDVar10;

+  DXGGLOBAL *pDVar11;

+  DXGSESSIONDATA *pDVar12;

+  DXGDEVICE *pDVar13;

+  code *pcVar14;

+  char cVar15;

+  uint uVar16;

+  ulonglong uVar17;

+  uint uVar18;

+  longlong lVar19;

+  DXGRESOURCE *pDVar20;

+  DXGADAPTER *pDVar21;

+  void *_Src;

+  uint *puVar22;

+  wchar_t *pwVar23;

+  ADAPTER_DISPLAY *this_01;

+  uint uVar24;

+  ulonglong uVar25;

+  DXGALLOCATION **ppDVar26;

+  undefined4 uVar27;

+  undefined1 auStackY_458 [32];

+  DXGSESSIONMODECHANGELOCK local_407;

+  char local_406;

+  char local_405;

+  char local_404;

+  char local_403;

+  char local_402;

+  byte local_401;

+  uchar local_400 [4];

+  uint local_3fc;

+  longlong local_3f8;

+  DXGDEVICE *local_3f0;

+  DXGRESOURCE *local_3e8;

+  DXGRESOURCE *local_3e0;

+  DXGALLOCATION *local_3d8;

+  DXGALLOCATION **local_3d0;

+  DXGADAPTER *local_3c8;

+  uint local_3c0;

+  _DXGK_DISPLAY_SCENARIO_CONTEXT *local_3b8;

+  DXGPROCESS *local_3b0;

+  undefined8 uStack_3a8;

+  DXGPROCESSCOPYPROTECTIONMUTEX local_3a0 [16];

+  DXGDEVICE *local_390;

+  longlong local_388;

+  DXGAUTOMUTEX local_380 [16];

+  DXGAUTOMUTEX local_370 [16];

+  DXGAUTOMUTEX local_360 [16];

+  undefined8 local_350;

+  undefined8 uStack_348;

+  ulonglong local_338;

+  DXGPROCESS *local_330;

+  undefined8 local_328;

+  undefined8 uStack_320;

+  undefined8 local_318;

+  undefined8 uStack_310;

+  undefined8 local_308;

+  undefined8 uStack_300;

+  undefined8 local_2f8;

+  undefined8 uStack_2f0;

+  undefined8 local_2e8;

+  undefined8 uStack_2e0;

+  undefined8 local_2d8;

+  undefined8 uStack_2d0;

+  undefined8 local_2c8;

+  undefined8 uStack_2c0;

+  undefined8 local_2b8;

+  undefined8 uStack_2b0;

+  undefined8 local_2a8;

+  undefined8 uStack_2a0;

+  undefined8 local_298;

+  undefined8 uStack_290;

+  undefined8 local_288;

+  undefined8 uStack_280;

+  undefined8 local_278;

+  undefined8 uStack_270;

+  undefined8 local_268;

+  undefined8 uStack_260;

+  undefined8 local_258;

+  undefined8 uStack_250;

+  undefined8 local_248;

+  undefined8 uStack_240;

+  undefined8 local_238;

+  undefined8 uStack_230;

+  undefined8 local_228;

+  undefined8 uStack_220;

+  undefined8 local_218;

+  undefined8 uStack_210;

+  undefined8 local_208;

+  undefined8 uStack_200;

+  undefined8 local_1f8;

+  undefined8 uStack_1f0;

+  undefined8 local_1e8;

+  undefined8 uStack_1e0;

+  undefined8 local_1d8;

+  undefined8 uStack_1d0;

+  undefined8 local_1c8;

+  undefined8 uStack_1c0;

+  undefined8 local_1b8;

+  undefined8 uStack_1b0;

+  undefined8 local_1a8;

+  undefined8 uStack_1a0;

+  uint local_198;

+  COREDEVICEACCESS local_188 [8];

+  COREACCESS local_180 [16];

+  longlong local_170;

+  COREACCESS local_140 [72];

+  char local_f8;

+  COREDEVICEACCESS local_e8 [160];

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStackY_458;

+  local_3b8 = param_10;

+  local_3d0 = param_4;

+  local_3b0 = param_1;

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

+    if (param_7 != 0) {

+      param_9 = param_9 - (longlong)param_3;

+      uVar17 = (ulonglong)param_7;

+      do {

+        *param_3 = *(undefined4 *)(param_9 + (longlong)param_3);

+        param_3 = param_3 + 1;

+        uVar17 = uVar17 - 1;

+      } while (uVar17 != 0);

+    }

+  }

+  else {

+    local_3c0 = 0;

+    uVar17 = 0;

+    while ((uint)uVar17 < param_7) {

+      _Src = (void *)(uVar17 * 4 + param_9);

+      if (*(void **)MmUserProbeAddress_exref <= _Src) {

+        _Src = *(void **)MmUserProbeAddress_exref;

+      }

+      RtlCopyVolatileMemory(param_3 + uVar17,_Src,4);

+      local_3c0 = (uint)uVar17 + 1;

+      uVar17 = (ulonglong)local_3c0;

+    }

+    *param_6 = param_3;

+  }

+  uVar17 = 0;

+  local_3e8 = (DXGRESOURCE *)0x0;

+  puVar22 = (uint *)*param_6;

+  lVar8 = ValidateDestroyAllocation(local_3b0,param_2,param_5,puVar22,param_7,local_3d0,&local_3e8);

+  if (lVar8 == 0xff) {

+    return 0;

+  }

+  if (lVar8 < 0) {

+    WdLogSingleEntry2(3,param_2,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0x26a5;

+    return -0x3ffffff3;

+  }

+  lVar19 = *(longlong *)(param_2 + 0x768);

+  bVar3 = false;

+  local_3f8 = lVar19;

+  iVar9 = Feature_CheckTransitionalPrimaryAfterDeviceLock__private_IsEnabledDeviceUsageNoInline();

+  uVar18 = (uint)puVar22;

+  if ((iVar9 == 0) && ((int)param_8 < 0)) {

+    pDVar13 = param_2;

+    COREDEVICEACCESS::COREDEVICEACCESS(local_e8,param_2,2,uVar18,false);

+    COREDEVICEACCESS::AcquireSharedUncheck(local_e8,(char *)pDVar13);

+    pDVar20 = local_3e8;

+    uVar18 = (uint)puVar22;

+    if (((0x1fff < *(int *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xac8)) ||

+        (*(char *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xbf4) != '\0')) &&

+       ((*(int *)(param_2 + 0x1d0) == 1 && (lVar19 = local_3f8, local_3e8 != (DXGRESOURCE *)0x0))))

+    {

+      DXGAUTOMUTEX::DXGAUTOMUTEX(local_380,(DXGFASTMUTEX *)(local_3e8 + 0x50),'\0');

+      DXGAUTOMUTEX::Acquire(local_380);

+      uVar18 = (uint)puVar22;

+      bVar3 = true;

+      for (pDVar1 = *(DXGALLOCATION **)(pDVar20 + 0x18); pDVar1 != (DXGALLOCATION *)0x0;

+          pDVar1 = *(DXGALLOCATION **)(pDVar1 + 0x40)) {

+        if ((((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 1) == 0) ||

+            (*(longlong *)(param_2 + 0x768) != *(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10)))

+           || (pDVar10 = DXGDEVICE::GetDisplayedPrimary

+                                   (param_2,*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf),

+              pDVar1 == pDVar10)) {

+          bVar3 = false;

+        }

+        uVar18 = (uint)puVar22;

+      }

+      DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_380);

+      lVar19 = local_3f8;

+    }

+    COREDEVICEACCESS::~COREDEVICEACCESS(local_e8);

+  }

+  pDVar4 = local_3b0;

+  local_338 = uVar17;

+  if (lVar19 != 0) {

+    local_338 = *(ulonglong *)(lVar19 + 0xc48);

+  }

+  local_330 = local_3b0;

+  local_198 = 0;

+  if (local_338 != 0) {

+    local_198 = *(uint *)(local_338 + 0x60);

+  }

+  local_198 = local_198 * 8;

+  local_328 = 0;

+  uStack_320 = 0;

+  local_318 = 0;

+  uStack_310 = 0;

+  local_308 = 0;

+  uStack_300 = 0;

+  local_2f8 = 0;

+  uStack_2f0 = 0;

+  local_2e8 = 0;

+  uStack_2e0 = 0;

+  local_2d8 = 0;

+  uStack_2d0 = 0;

+  local_2c8 = 0;

+  uStack_2c0 = 0;

+  local_2b8 = 0;

+  uStack_2b0 = 0;

+  local_2a8 = 0;

+  uStack_2a0 = 0;

+  local_298 = 0;

+  uStack_290 = 0;

+  local_288 = 0;

+  uStack_280 = 0;

+  local_278 = 0;

+  uStack_270 = 0;

+  local_268 = 0;

+  uStack_260 = 0;

+  local_258 = 0;

+  uStack_250 = 0;

+  local_248 = 0;

+  uStack_240 = 0;

+  local_238 = 0;

+  uStack_230 = 0;

+  local_228 = 0;

+  uStack_220 = 0;

+  local_218 = 0;

+  uStack_210 = 0;

+  local_208 = 0;

+  uStack_200 = 0;

+  local_1f8 = 0;

+  uStack_1f0 = 0;

+  local_1e8 = 0;

+  uStack_1e0 = 0;

+  local_1d8 = 0;

+  uStack_1d0 = 0;

+  local_1c8 = 0;

+  uStack_1c0 = 0;

+  local_1b8 = 0;

+  uStack_1b0 = 0;

+  local_1a8 = 0;

+  uStack_1a0 = 0;

+  this = *(DXGADAPTER **)(*(longlong *)(param_2 + 0x10) + 0x10);

+  LOCK();

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

+  UNLOCK();

+  pDVar21 = this + 0x88;

+  local_3c8 = this;

+  KeEnterCriticalRegion();

+  ExAcquirePushLockSharedEx(pDVar21,0);

+  LOCK();

+  *(int *)(this + 0x98) = *(int *)(this + 0x98) + 1;

+  UNLOCK();

+  pDVar13 = param_2;

+  COREDEVICEACCESS::COREDEVICEACCESS(local_188,param_2,2,uVar18,false);

+  COREDEVICEACCESS::AcquireSharedUncheck(local_188,(char *)pDVar13);

+  if (*(int *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 200) == 4) {

+    WdLogSingleEntry1(4,param_2);

+    _WdLogGlobalForLineNumber = 0x26ec;

+    COREDEVICEACCESS::~COREDEVICEACCESS(local_188);

+    LOCK();

+    *(int *)(this + 0x98) = *(int *)(this + 0x98) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(pDVar21,0);

+    KeLeaveCriticalRegion();

+    DXGADAPTER::ReleaseReference(this,0xffffffffffffffff);

+    uVar18 = local_198;

+    if ((local_198 & 4) != 0) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x10e;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"(FALSE == m_u.s.bStateSaved)");

+    }

+    pDVar4 = local_330;

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

+      (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+                (*(undefined8 *)(local_338 + 0x10),uVar18 >> 3);

+      uVar18 = uVar18 & 0xfffffffd;

+    }

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

+      return 0;

+    }

+    pDVar11 = DXGGLOBAL::GetGlobal();

+    pDVar12 = DXGGLOBAL::GetSessionData(pDVar11);

+    pcVar14 = *(code **)(*(longlong *)(pDVar4 + 0x58) + 0xb8);

+    goto LAB_0;

+  }

+  if (*(int *)(param_2 + 0x260) == 4) {

+    uVar27 = WdLogSingleEntry1(4,param_2);

+    _WdLogGlobalForLineNumber = 0x26f1;

+    DxgkDestroyClientAllocation(uVar27,param_2,param_7,local_3d0);

+    COREDEVICEACCESS::~COREDEVICEACCESS(local_188);

+    LOCK();

+    *(int *)(this + 0x98) = *(int *)(this + 0x98) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(pDVar21,0);

+    KeLeaveCriticalRegion();

+    DXGADAPTER::ReleaseReference(this,0xffffffffffffffff);

+    uVar18 = local_198;

+    if ((local_198 & 4) != 0) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x10e;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"(FALSE == m_u.s.bStateSaved)");

+    }

+    pDVar4 = local_330;

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

+      (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+                (*(undefined8 *)(local_338 + 0x10),uVar18 >> 3);

+      uVar18 = uVar18 & 0xfffffffd;

+    }

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

+      return 0;

+    }

+    pDVar11 = DXGGLOBAL::GetGlobal();

+    pDVar12 = DXGGLOBAL::GetSessionData(pDVar11);

+    pcVar14 = *(code **)(*(longlong *)(pDVar4 + 0x58) + 0xb8);

+    goto LAB_0;

+  }

+  if (*(uint *)(*(longlong *)

+                 (*(longlong *)

+                   (*(longlong *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xd8) + 0x40

+                   ) + 0x28) + 0x1c) < 0x5015) {

+    param_8 = param_8 & 0xfffffffe;

+  }

+  iVar9 = Feature_CheckTransitionalPrimaryAfterDeviceLock__private_IsEnabledDeviceUsageNoInline();

+  pDVar20 = local_3e8;

+  if ((((iVar9 == 0) || (-1 < (int)param_8)) ||

+      ((*(int *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xac8) < 0x2000 &&

+       (*(char *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xbf4) == '\0')))) ||

+     (*(int *)(param_2 + 0x1d0) != 1)) {

+    local_3e0 = local_3e8;

+  }

+  else {

+    local_3e0 = local_3e8;

+    if (local_3e8 != (DXGRESOURCE *)0x0) {

+      DXGAUTOMUTEX::DXGAUTOMUTEX(local_370,(DXGFASTMUTEX *)(local_3e8 + 0x50),'\0');

+      DXGAUTOMUTEX::Acquire(local_370);

+      bVar3 = true;

+      for (pDVar1 = *(DXGALLOCATION **)(pDVar20 + 0x18); pDVar1 != (DXGALLOCATION *)0x0;

+          pDVar1 = *(DXGALLOCATION **)(pDVar1 + 0x40)) {

+        if ((((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 1) == 0) ||

+            (*(longlong *)(param_2 + 0x768) != *(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10)))

+           || (pDVar10 = DXGDEVICE::GetDisplayedPrimary

+                                   (param_2,*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf),

+              pDVar1 == pDVar10)) {

+          bVar3 = false;

+        }

+      }

+      DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_370);

+    }

+  }

+  pDVar20 = local_3e0;

+  local_403 = '\0';

+  local_402 = '\0';

+  local_406 = '\0';

+  local_404 = '\0';

+  local_405 = '\0';

+  local_3fc = 0;

+  local_3d8 = (DXGALLOCATION *)0x0;

+  uVar18 = 0xffffffff;

+  DXGSESSIONMODECHANGELOCK::DXGSESSIONMODECHANGELOCK(&local_407);

+  local_390 = (DXGDEVICE *)0x0;

+  local_3f0 = (DXGDEVICE *)0x0;

+  DXGPROCESSCOPYPROTECTIONMUTEX::DXGPROCESSCOPYPROTECTIONMUTEX(local_3a0,pDVar4);

+  lVar19 = *(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10);

+  local_388 = lVar19;

+  if (pDVar20 == (DXGRESOURCE *)0x0) {

+    uVar25 = uVar17;

+    ppDVar26 = local_3d0;

+    uVar16 = 0;

+    if (param_7 != 0) {

+      do {

+        pDVar1 = *ppDVar26;

+        if (pDVar1 == (DXGALLOCATION *)0x0) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x2758;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pCurrentAlloc != NULL");

+        }

+        if (*(DXGDEVICE **)(pDVar1 + 8) != param_2) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x2759;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pCurrentAlloc->m_pDevice == pDevice");

+        }

+        if ((*(int *)(local_388 + 0x1a4) == 0x4d4f4351) &&

+           ((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 8) != 0)) {

+          local_403 = '\x01';

+          bVar6 = DXGDEVICE::IsDisplayedPrimary

+                            (param_2,*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf,pDVar1);

+          pDVar20 = local_3e0;

+          uVar16 = local_3fc;

+          if (bVar6) {

+            local_402 = '\x01';

+            local_406 = '\x01';

+            local_405 = local_3d8 != (DXGALLOCATION *)0x0;

+            uVar18 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf;

+            local_3fc = local_3fc | 1 << (sbyte)uVar18;

+            uVar16 = local_3fc;

+            local_3d8 = pDVar1;

+          }

+          break;

+        }

+        uVar16 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4);

+        if (((uVar16 & 1) != 0) &&

+           ((((char)*(uint *)(param_2 + (ulonglong)(uVar16 >> 6 & 0xf) * 4 + 0x4d8) != '\0' &&

+             ((*(int *)(param_2 + 0x1d0) != 1 ||

+              ((*(uint *)(param_2 + (ulonglong)(uVar16 >> 6 & 0xf) * 4 + 0x4d8) >> 8 & 1) != 0))))

+            || ((*(ADAPTER_DISPLAY **)(local_388 + 0xc48) != (ADAPTER_DISPLAY *)0x0 &&

+                (uVar5 = ADAPTER_DISPLAY::IsVidPnSourceVisible

+                                   (*(ADAPTER_DISPLAY **)(local_388 + 0xc48),uVar16 >> 6 & 0xf),

+                uVar5 == '\0')))))) {

+          local_406 = '\x01';

+          local_405 = local_3d8 != (DXGALLOCATION *)0x0;

+          uVar18 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf;

+          local_3fc = local_3fc | 1 << (sbyte)uVar18;

+          local_3d8 = pDVar1;

+        }

+        uVar24 = (int)uVar25 + 1;

+        pDVar20 = local_3e0;

+        uVar25 = (ulonglong)uVar24;

+        ppDVar26 = ppDVar26 + 1;

+        uVar16 = local_3fc;

+      } while (uVar24 < param_7);

+    }

+  }

+  else {

+    if (*(DXGDEVICE **)(pDVar20 + 8) != param_2) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x272e;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pResource->m_pDevice == pDevice");

+    }

+    DXGAUTOMUTEX::DXGAUTOMUTEX(local_360,(DXGFASTMUTEX *)(pDVar20 + 0x50),'\0');

+    DXGAUTOMUTEX::Acquire(local_360);

+    for (pDVar1 = *(DXGALLOCATION **)(pDVar20 + 0x18); pDVar1 != (DXGALLOCATION *)0x0;

+        pDVar1 = *(DXGALLOCATION **)(pDVar1 + 0x40)) {

+      uVar16 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4);

+      if (1 < (uVar16 >> 0xd & 1) + (uVar16 >> 1 & 1) + (uVar16 & 1)) {

+        WdLogSingleEntry0(1);

+        _WdLogGlobalForLineNumber = 0x273a;

+        DxgkLogInternalTriageEvent

+                  (0,0x40002,0xffffffff,

+                   L"(pCurrentAlloc->m_pAllocation->m_Primary ? 1 : 0) + (pCurrentAlloc->m_pAllocation->m_CddPrimary ? 1 : 0) + (pCurrentAlloc->m_pAllocation->m_DirectFlip ? 1 : 0) <= 1"

+                  );

+      }

+      if ((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 1) != 0) {

+        uVar16 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf;

+        if (((((char)*(uint *)(param_2 + (ulonglong)uVar16 * 4 + 0x4d8) != '\0') &&

+             ((*(int *)(param_2 + 0x1d0) != 1 ||

+              ((*(uint *)(param_2 + (ulonglong)uVar16 * 4 + 0x4d8) >> 8 & 1) != 0)))) ||

+            ((lVar19 != 0 &&

+             ((*(ADAPTER_DISPLAY **)(lVar19 + 0xc48) != (ADAPTER_DISPLAY *)0x0 &&

+              (uVar5 = ADAPTER_DISPLAY::IsVidPnSourceVisible

+                                 (*(ADAPTER_DISPLAY **)(lVar19 + 0xc48),uVar16), uVar5 == '\0'))))))

+           && (!bVar3)) {

+          local_406 = '\x01';

+          uVar18 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf;

+          local_3fc = 1 << (sbyte)uVar18;

+          local_405 = '\0';

+          local_3d8 = pDVar1;

+          break;

+        }

+      }

+      if ((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 2) != 0) {

+        local_404 = '\x01';

+        break;

+      }

+    }

+    DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_360);

+    pDVar20 = local_3e0;

+    uVar16 = local_3fc;

+  }

+  cVar15 = '\0';

+  if ((*(uint *)(local_3b0 + 0x198) >> 8 & 1) == 0) {

+    cVar15 = local_406;

+  }

+  WdLogSingleEntry5(8,cVar15);

+  lVar19 = local_3f8;

+  _WdLogGlobalForLineNumber = 0x278a;

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

+    if (bVar3) {

+      ADAPTER_DISPLAY::DisableTransitionalPrimaryAllocations

+                (*(ADAPTER_DISPLAY **)(local_3f8 + 0xc48),param_2,

+                 *(DXGALLOCATION **)(pDVar20 + 0x18),local_188);

+    }

+  }

+  else {

+    if ((local_3f8 == 0) || (*(longlong *)(local_3f8 + 0xc48) == 0)) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x278f;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff);

+    }

+    COREDEVICEACCESS::Release(local_188);

+    LOCK();

+    *(int *)(local_3c8 + 0x98) = *(int *)(local_3c8 + 0x98) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(local_3c8 + 0x88,0);

+    KeLeaveCriticalRegion();

+    DXGADAPTER::ReleaseReference(local_3c8,0xffffffffffffffff);

+    lVar2 = *(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10);

+    if (*(int *)(lVar2 + 0xbd4) < 0x899) {

+      if (*(char *)(lVar2 + 0xd1) == '\0') {

+        local_3b0 = (DXGPROCESS *)0x0;

+        uStack_3a8 = 0;

+        DXGPUSHLOCK::AcquireExclusive((DXGPUSHLOCK *)(param_2 + 0x110));

+        local_3b0 = (DXGPROCESS *)CONCAT44(local_3b0._4_4_,3);

+        iVar9 = (**(code **)(*(longlong *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x2e0) + 8)

+                            + 0x88))(*(undefined8 *)(param_2 + 800),&local_3b0);

+        if (iVar9 < 0) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x16f8;

+          DxgkLogInternalTriageEvent(0,0x40002);

+        }

+        *(undefined8 *)(param_2 + 0x118) = 0;

+        ExReleasePushLockExclusiveEx(param_2 + 0x110,0);

+        KeLeaveCriticalRegion();

+      }

+      else {

+        DXG_GUEST_VIRTUALGPU_VMBUS::VmBusSendFlushDevice

+                  ((DXG_GUEST_VIRTUALGPU_VMBUS *)(lVar2 + 0x1258),param_2,5);

+      }

+    }

+    else {

+      uVar24 = uVar18;

+      if ((uVar16 & uVar16 - 1) != 0) {

+        uVar24 = 0xfffffffd;

+      }

+      DXGDEVICE::FlushScheduler(param_2,5,uVar24,true);

+    }

+    MANAGEDPRIMARIESTRACKER::AcquireWin32kDwmStateAndPDevLocks

+              ((MANAGEDPRIMARIESTRACKER *)&local_338);

+    iVar9 = DxgkAcquireSessionModeChangeLock(1);

+    local_407 = (DXGSESSIONMODECHANGELOCK)((byte)((uint)iVar9 >> 0x1f) ^ 1);

+    if (iVar9 < 0) {

+      WdLogSingleEntry1(2,(longlong)iVar9);

+      _WdLogGlobalForLineNumber = 0x27cd;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"Failed to acquire session mode change lock exclusively (Status = 0x%I64x)");

+      DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_3a0);

+      DXGSESSIONMODECHANGELOCK::ReleaseModeChangeLock(&local_407);

+      COREDEVICEACCESS::~COREDEVICEACCESS(local_188);

+      uVar18 = local_198;

+      if ((local_198 & 4) != 0) {

+        WdLogSingleEntry0(1);

+        _WdLogGlobalForLineNumber = 0x10e;

+        DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"(FALSE == m_u.s.bStateSaved)");

+      }

+      pDVar4 = local_330;

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

+        (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+                  (*(undefined8 *)(local_338 + 0x10),uVar18 >> 3);

+        uVar18 = uVar18 & 0xfffffffd;

+      }

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

+        pDVar11 = DXGGLOBAL::GetGlobal();

+        pDVar12 = DXGGLOBAL::GetSessionData(pDVar11);

+        (**(code **)(*(longlong *)(pDVar4 + 0x58) + 0xb8))();

+        local_198 = uVar18 & 0xfffffffe;

+        *(undefined8 *)(pDVar12 + 0x4b48) = 0;

+        ExReleasePushLockExclusiveEx(pDVar12 + 0x4b40,0);

+        KeLeaveCriticalRegion();

+        return iVar9;

+      }

+      return iVar9;

+    }

+    pwVar23 = (wchar_t *)0x0;

+    iVar9 = DxgkGetCddDeviceAndContextForCurrentSession(lVar19 + 0x19c,&local_3f0);

+    if (iVar9 < 0) {

+      WdLogSingleEntry1(4,(longlong)iVar9);

+      _WdLogGlobalForLineNumber = 0x27dd;

+    }

+    pDVar13 = local_3f0;

+    if (local_3f0 != (DXGDEVICE *)0x0) {

+      if (*(longlong *)(local_3f0 + 0x10) == *(longlong *)(param_2 + 0x10)) {

+        if (local_3f0 != (DXGDEVICE *)0x0) {

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

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x27e6;

+            pwVar23 = 

+            L"(pCddDevice == NULL) || (pCddDevice->GetRenderCore() == pDevice->GetRenderCore())";

+            DxgkLogInternalTriageEvent(0,0x40002);

+          }

+          if (pDVar13 != (DXGDEVICE *)0x0) {

+            pDVar13[0x7a1] = (DXGDEVICE)0x1;

+            DXGAUTOMUTEX::Acquire((DXGAUTOMUTEX *)local_3a0);

+          }

+        }

+      }

+      else {

+        local_3f0 = (DXGDEVICE *)0x0;

+      }

+    }

+    pDVar21 = local_3c8;

+    LOCK();

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

+    UNLOCK();

+    KeEnterCriticalRegion();

+    ExAcquirePushLockSharedEx(pDVar21 + 0x88,0);

+    LOCK();

+    *(int *)(pDVar21 + 0x98) = *(int *)(pDVar21 + 0x98) + 1;

+    UNLOCK();

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

+      COREACCESS::AcquireExclusive(local_140,2,0,(char *)pwVar23);

+    }

+    COREACCESS::AcquireExclusive(local_180,2,0,(char *)pwVar23);

+    uVar16 = local_3fc;

+    if (*(int *)(param_2 + 0x260) == 4) {

+      WdLogSingleEntry1(4,param_2);

+      pDVar13 = local_3f0;

+      _WdLogGlobalForLineNumber = 0x2800;

+      if (local_3f0 != (DXGDEVICE *)0x0) {

+        DXGAUTOMUTEX::Release((DXGAUTOMUTEX *)local_3a0);

+        pDVar13[0x7a1] = (DXGDEVICE)0x0;

+        LOCK();

+        pDVar13 = pDVar13 + 0x40;

+        lVar19 = *(longlong *)pDVar13;

+        *(longlong *)pDVar13 = *(longlong *)pDVar13 + -1;

+        UNLOCK();

+        if (lVar19 == 1) {

+          ADAPTER_RENDER::DestroyDeviceNoLocks(*(ADAPTER_RENDER **)(local_3f0 + 0x10),local_3f0);

+        }

+      }

+      DxgkDestroyClientAllocation();

+      DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_3a0);

+      DXGSESSIONMODECHANGELOCK::ReleaseModeChangeLock(&local_407);

+      COREDEVICEACCESS::~COREDEVICEACCESS(local_188);

+      LOCK();

+      *(int *)(pDVar21 + 0x98) = *(int *)(pDVar21 + 0x98) + -1;

+      UNLOCK();

+      ExReleasePushLockSharedEx(pDVar21 + 0x88,0);

+      KeLeaveCriticalRegion();

+      DXGADAPTER::ReleaseReference(pDVar21,0xffffffffffffffff);

+      uVar18 = local_198;

+      if ((local_198 & 4) != 0) {

+        WdLogSingleEntry0(1);

+        _WdLogGlobalForLineNumber = 0x10e;

+        DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"(FALSE == m_u.s.bStateSaved)");

+      }

+      pDVar4 = local_330;

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

+        (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+                  (*(undefined8 *)(local_338 + 0x10),uVar18 >> 3);

+        uVar18 = uVar18 & 0xfffffffd;

+      }

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

+        return 0;

+      }

+      pDVar11 = DXGGLOBAL::GetGlobal();

+      pDVar12 = DXGGLOBAL::GetSessionData(pDVar11);

+      pcVar14 = *(code **)(*(longlong *)(pDVar4 + 0x58) + 0xb8);

+      goto LAB_0;

+    }

+    MANAGEDPRIMARIESTRACKER::SaveManagedPrimaryState

+              ((MANAGEDPRIMARIESTRACKER *)&local_338,param_2,local_3fc);

+    pDVar1 = local_3d8;

+    lVar19 = local_3f8;

+    if (*(longlong *)(param_2 + 0x768) == *(longlong *)(*(ADAPTER_RENDER **)(param_2 + 0x10) + 0x10)

+       ) {

+      if ((uVar16 & uVar16 - 1) == 0) {

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

+          pDVar13 = ADAPTER_DISPLAY::GetVidPnSourceOwner

+                              (*(ADAPTER_DISPLAY **)(local_3f8 + 0xc48),

+                               *(uint *)(*(longlong *)(local_3d8 + 0x30) + 4) >> 6 & 0xf);

+          if ((pDVar13 == (DXGDEVICE *)0x0) || (pDVar13 == param_2)) {

+            this_01 = *(ADAPTER_DISPLAY **)(lVar19 + 0xc48);

+            uVar16 = *(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf;

+            pDVar21 = *(DXGADAPTER **)(this_01 + 0x10);

+            if (*(longlong *)(pDVar21 + 0xc50) != 0) {

+              if ((*(int *)(pDVar21 + 0xac8) < 0x2300) &&

+                 ((pDVar21[0xc04] == (DXGADAPTER)0x0 ||

+                  (uVar5 = DXGADAPTER::UsingSetTimingsFromVidPn(pDVar21), uVar5 == '\0')))) {

+                if (*(int *)(pDVar21 + 0xbd4) != 0x898) goto LAB_1;

+                uVar5 = '\0';

+              }

+              else {

+                uVar5 = '\x01';

+              }

+              ADAPTER_DISPLAY::DisableMPOPlanes(this_01,uVar16,uVar5);

+            }

+          }

+LAB_1:

+          if ((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) & 1) == 0) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x2857;

+            DxgkLogInternalTriageEvent

+                      (0,0x40002,0xffffffff,L"PrimaryAllocation->m_pAllocation->m_Primary");

+          }

+          if ((*(uint *)(*(longlong *)(pDVar1 + 0x30) + 4) >> 6 & 0xf) != uVar18) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x2858;

+            DxgkLogInternalTriageEvent

+                      (0,0x40002,0xffffffff,

+                       L"PrimaryAllocation->m_pAllocation->m_VidPnSourceId == VidpnSourceInvolved");

+          }

+          ADAPTER_DISPLAY::DisablePrimaryAllocation

+                    (*(ADAPTER_DISPLAY **)(lVar19 + 0xc48),param_2,pDVar1);

+        }

+        else {

+          if (uVar18 == 0xffffffff) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x283c;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff);

+          }

+          ADAPTER_DISPLAY::DisablePrimaryOnDevice

+                    (*(ADAPTER_DISPLAY **)(local_3f8 + 0xc48),param_2,uVar18,'\0');

+        }

+      }

+      else {

+        ADAPTER_DISPLAY::DisableAllPrimaries

+                  (*(ADAPTER_DISPLAY **)(local_3f8 + 0xc48),*(ADAPTER_RENDER **)(param_2 + 0x10));

+      }

+    }

+    local_390 = local_3f0;

+    pDVar20 = local_3e8;

+    lVar19 = local_3f8;

+  }

+  if ((local_404 != '\0') || (pDVar13 = local_390, local_403 != '\0')) {

+    if ((SystemReserved1[0xf] != *(void **)(local_170 + 0xb8)) &&

+       (cVar7 = ExIsResourceAcquiredExclusiveLite(*(undefined8 *)(local_170 + 0xa8)), cVar7 == '\0')

+       ) {

+      COREDEVICEACCESS::Release(local_188);

+    }

+    if ((local_402 != '\0') &&

+       (lVar8 = ADAPTER_DISPLAY::SetVidPnSourceVisibility

+                          (*(ADAPTER_DISPLAY **)(lVar19 + 0xc48),uVar18,'\0',0x10,'\0'), lVar8 < 0))

+    {

+      WdLogSingleEntry2(2,uVar18,(longlong)lVar8);

+      _WdLogGlobalForLineNumber = 0x2879;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"SetVidPnSourceVisibility(0x%I64x) failed with status 0x%I64x");

+    }

+    if (*(char *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0xd1) == '\0') {

+      local_350 = 0;

+      uStack_348 = 0;

+      DXGPUSHLOCK::AcquireExclusive((DXGPUSHLOCK *)(param_2 + 0x110));

+      local_350 = CONCAT44(local_350._4_4_,5);

+      iVar9 = (**(code **)(*(longlong *)(*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x2e0) + 8) +

+                          0x88))(*(undefined8 *)(param_2 + 800),&local_350,0xfffffffd,0);

+      if (iVar9 < 0) {

+        WdLogSingleEntry0(1);

+        _WdLogGlobalForLineNumber = 0x16f8;

+        DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"NT_SUCCESS(FlushStatus)");

+      }

+      *(undefined8 *)(param_2 + 0x118) = 0;

+      pDVar13 = (DXGDEVICE *)0x0;

+      ExReleasePushLockExclusiveEx(param_2 + 0x110);

+      KeLeaveCriticalRegion();

+    }

+    else {

+      pDVar13 = param_2;

+      DXG_GUEST_VIRTUALGPU_VMBUS::VmBusSendFlushDevice

+                ((DXG_GUEST_VIRTUALGPU_VMBUS *)

+                 (*(longlong *)(*(longlong *)(param_2 + 0x10) + 0x10) + 0x1258),param_2,6);

+    }

+    if ((SystemReserved1[0xf] != *(void **)(local_170 + 0xb8)) &&

+       (cVar7 = ExIsResourceAcquiredExclusiveLite(*(undefined8 *)(local_170 + 0xa8)), cVar7 == '\0')

+       ) {

+      COREDEVICEACCESS::AcquireSharedUncheck(local_188,(char *)pDVar13);

+    }

+    pDVar20 = local_3e8;

+    pDVar13 = local_3f0;

+    if (((lVar19 != 0) && (*(longlong *)(lVar19 + 0xc50) == 0)) &&

+       (this_00 = *(DXGDODPRESENT **)(*(longlong *)(lVar19 + 0xc48) + 0x1d0),

+       this_00 != (DXGDODPRESENT *)0x0)) {

+      DXGDODPRESENT::Flush(this_00);

+      pDVar20 = local_3e8;

+      pDVar13 = local_3f0;

+    }

+  }

+  DXGDEVICE::DestroyAllocationInternal(param_2,param_7,local_3d0,pDVar20);

+  if ((local_404 != '\0') && (*(int *)(param_2 + 0x770) != 0)) {

+    do {

+      if ((*(longlong *)(param_2 + uVar17 * 8 + 0x298) != 0) &&

+         (param_2[uVar17 + 0x288] != (DXGDEVICE)0x0)) {

+        DXGDEVICE::DestroyAllocationInternal(param_2,0,0);

+        param_2[uVar17 + 0x288] = (DXGDEVICE)0x0;

+      }

+      uVar18 = (int)uVar17 + 1;

+      uVar17 = (ulonglong)uVar18;

+    } while (uVar18 < *(uint *)(param_2 + 0x770));

+  }

+  local_401 = 0;

+  local_400[0] = '\0';

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

+LAB_2:

+    bVar3 = true;

+    uVar18 = local_198;

+  }

+  else {

+    if (pDVar13 != (DXGDEVICE *)0x0) {

+      ADAPTER_DISPLAY::EnsureGdiOutput

+                (*(ADAPTER_DISPLAY **)(local_3f8 + 0xc48),pDVar13,local_188,&local_401,local_400,

+                 local_3b8);

+    }

+    MANAGEDPRIMARIESTRACKER::RestoreManagedPrimaryState

+              ((MANAGEDPRIMARIESTRACKER *)&local_338,(uint)local_401);

+    if (pDVar13 == (DXGDEVICE *)0x0) goto LAB_2;

+    COREDEVICEACCESS::Release(local_188);

+    pDVar21 = local_3c8;

+    LOCK();

+    *(int *)(local_3c8 + 0x98) = *(int *)(local_3c8 + 0x98) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(local_3c8 + 0x88,0);

+    KeLeaveCriticalRegion();

+    DXGADAPTER::ReleaseReference(pDVar21,0xffffffffffffffff);

+    pDVar13 = local_3f0;

+    bVar3 = false;

+    DXGAUTOMUTEX::Release((DXGAUTOMUTEX *)local_3a0);

+    pDVar13[0x7a1] = (DXGDEVICE)0x0;

+    LOCK();

+    pDVar13 = pDVar13 + 0x40;

+    lVar19 = *(longlong *)pDVar13;

+    *(longlong *)pDVar13 = *(longlong *)pDVar13 + -1;

+    UNLOCK();

+    if (lVar19 == 1) {

+      ADAPTER_RENDER::DestroyDeviceNoLocks(*(ADAPTER_RENDER **)(local_3f0 + 0x10),local_3f0);

+    }

+    if (local_407 != (DXGSESSIONMODECHANGELOCK)0x0) {

+      local_407 = (DXGSESSIONMODECHANGELOCK)0x0;

+      DxgkReleaseSessionModeChangeLock();

+    }

+    uVar18 = local_198;

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

+      (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+                (*(undefined8 *)(local_338 + 0x10),local_198 >> 3);

+      local_198 = uVar18 & 0xfffffffd;

+    }

+    uVar18 = local_198;

+    if (((local_401 != 0) && (local_400[0] != '\0')) &&

+       (*(longlong *)(*(longlong *)(param_2 + 0x28) + 0x58) != 0)) {

+      (**(code **)(*(longlong *)(*(longlong *)(param_2 + 0x28) + 0x58) + 0xd8))();

+    }

+  }

+  DXGDISPLAYSTATEMUTEX::~DXGDISPLAYSTATEMUTEX((DXGDISPLAYSTATEMUTEX *)local_3a0);

+  DXGSESSIONMODECHANGELOCK::ReleaseModeChangeLock(&local_407);

+  COREDEVICEACCESS::~COREDEVICEACCESS(local_188);

+  pDVar21 = local_3c8;

+  if (bVar3) {

+    LOCK();

+    *(int *)(local_3c8 + 0x98) = *(int *)(local_3c8 + 0x98) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(local_3c8 + 0x88,0);

+    KeLeaveCriticalRegion();

+    DXGADAPTER::ReleaseReference(pDVar21,0xffffffffffffffff);

+    uVar18 = local_198;

+  }

+  if ((uVar18 & 4) != 0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x10e;

+    DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"(FALSE == m_u.s.bStateSaved)");

+  }

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

+    (**(code **)(*(longlong *)(local_330 + 0x58) + 200))

+              (*(undefined8 *)(local_338 + 0x10),uVar18 >> 3);

+    uVar18 = uVar18 & 0xfffffffd;

+  }

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

+    return 0;

+  }

+  pDVar11 = DXGGLOBAL::GetGlobal();

+  pDVar12 = DXGGLOBAL::GetSessionData(pDVar11);

+  pcVar14 = *(code **)(*(longlong *)(local_330 + 0x58) + 0xb8);

+LAB_0:

+  (*pcVar14)();

+  local_198 = uVar18 & 0xfffffffe;

+  *(undefined8 *)(pDVar12 + 0x4b48) = 0;

+  ExReleasePushLockExclusiveEx(pDVar12 + 0x4b40,0);

+  KeLeaveCriticalRegion();

+  return 0;

 }
```

## `CheckFeatureOSSupport`  (modified)

```diff
--- CheckFeatureOSSupport
+++ CheckFeatureOSSupport
@@ -1,12 +1,61 @@
 

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

-

-undefined8 CheckFeatureOSSupport(void)

+bool CheckFeatureOSSupport(undefined8 param_1,longlong param_2,uint param_3)

 

 {

-  WdLogSingleEntry0();

-  _WdLogGlobalForLineNumber = 0x727;

-  DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Iommu interface does not support Pasid",0x727);

-  return 0xc00000bb;

+  int iVar1;

+  bool bVar2;

+  

+  if (param_3 < 0x10000005) {

+    if (param_3 == 0x10000004) {

+      return true;

+    }

+    if ((param_3 == 0x20) || (param_3 == 0x25)) {

+      return false;

+    }

+    if (param_3 == 0x29) {

+      return true;

+    }

+    if (param_3 == 0x2d) {

+      iVar1 = Feature_ProcessDebugBlobCollection__private_IsEnabledDeviceUsageNoInline();

+    }

+    else if (param_3 == 0x2e) {

+      iVar1 = Feature_PanelBufferControl__private_IsEnabledDeviceUsageNoInline();

+    }

+    else {

+      if (param_3 != 0x31) {

+        bVar2 = param_3 == 0x10000003;

+        goto LAB_0;

+      }

+      iVar1 = Feature_TargetProperties__private_IsEnabledDeviceUsageNoInline();

+    }

+  }

+  else {

+    if (param_3 == 0x10000005) {

+      return true;

+    }

+    if (param_3 == 0x10000006) {

+      iVar1 = Feature_Servicing_GraphicsKernel_ReadOnlyExistingSysMem__private_IsEnabledDeviceUsageNoInline

+                        ();

+    }

+    else {

+      if (param_3 != 0x20000001) {

+        if (param_3 == 0x30000001) {

+          return true;

+        }

+        if (param_3 == 0x30000011) {

+          return true;

+        }

+        bVar2 = param_3 == 0x30000012;

+LAB_0:

+        if (bVar2) {

+          return true;

+        }

+        return (bool)(*(byte *)(param_2 + 4) & 1);

+      }

+      iVar1 = Feature_Servicing_GraphicsKernel_CpuHostApertureFixes__private_IsEnabledDeviceUsageNoInline

+                        ();

+    }

+  }

+  return iVar1 != 0;

 }
```

## `DpiIndirectInvalidateModeListCacheWorker`  (modified)

```diff
--- DpiIndirectInvalidateModeListCacheWorker
+++ DpiIndirectInvalidateModeListCacheWorker
@@ -1,15 +1,79 @@
 

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

+/* void __cdecl DpiIndirectInvalidateModeListCacheWorker(struct _DEVICE_OBJECT * __ptr64,void *

+   __ptr64,struct _IO_WORKITEM * __ptr64) */

 

 void __cdecl

 DpiIndirectInvalidateModeListCacheWorker

           (_DEVICE_OBJECT *param_1,void *param_2,_IO_WORKITEM *param_3)

 

 {

-  int *unaff_RDI;

+  _COMMON_PNP_CONTEXT *p_Var1;

+  _FDO_CONTEXT *p_Var2;

+  int iVar3;

+  long lVar4;

+  AUTO_REMOVE_LOCK *this;

+  undefined1 uVar5;

+  undefined1 in_R9B;

+  _FDO_CONTEXT *local_res20;

+  undefined1 in_stack_ffffffffffffffa8;

+  undefined8 local_48;

+  undefined2 local_40;

+  undefined1 local_3e;

+  _COMMON_PNP_CONTEXT *local_38;

+  ulonglong uStack_30;

+  undefined8 local_28;

+  undefined1 local_20;

+  _IO_WORKITEM *p_Var6;

   

-  *unaff_RDI = *unaff_RDI + -1;

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

-  halt_baddata();

+  p_Var6 = param_3;

+  iVar3 = Feature_IddCx_Fix_UseFdoForModeCacheWorkItem__private_IsEnabledDeviceUsageNoInline();

+  uVar5 = SUB81(p_Var6,0);

+  if (iVar3 == 0) {

+    if (param_2 == (void *)0x0) goto LAB_0;

+    uStack_30 = *(ulonglong *)param_2;

+    local_28 = 0;

+    local_48 = 0;

+    local_40 = 0;

+    local_res20 = (_FDO_CONTEXT *)0x0;

+    local_38 = (_COMMON_PNP_CONTEXT *)0x1;

+    local_20 = 0;

+    local_3e = 0;

+    lVar4 = DpiIndirectGetMiniport

+                      ((DXGK_MINIPORT_FILTER *)&local_38,(AUTO_REMOVE_LOCK *)&local_28,

+                       (AUTO_PNPPOWER_LOCK *)&local_48,&local_res20);

+    p_Var2 = local_res20;

+    if (-1 < lVar4) {

+      if (*(longlong *)(local_res20 + 0xfc0) != 0) {

+        DxgkAcquireAdapterCoreSync(*(longlong *)(local_res20 + 0xfc0),2);

+        DxgkInvalidateVidPnDisplayModeListCache(*(undefined8 *)(p_Var2 + 0xfc0));

+        DxgkReleaseAdapterCoreSync(*(undefined8 *)(p_Var2 + 0xfc0),2);

+      }

+    }

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(param_2);

+    AUTO_PNPPOWER_LOCK::Release((AUTO_PNPPOWER_LOCK *)&local_48);

+    this = (AUTO_REMOVE_LOCK *)&local_28;

+  }

+  else {

+    p_Var1 = *(_COMMON_PNP_CONTEXT **)(param_1 + 0x40);

+    uStack_30 = uStack_30 & 0xffffffffffffff00;

+    local_38 = p_Var1;

+    lVar4 = AUTO_REMOVE_LOCK::Acquire((AUTO_REMOVE_LOCK *)&local_38);

+    if (-1 < lVar4) {

+      AUTO_PNPPOWER_LOCK::AUTO_PNPPOWER_LOCK

+                ((AUTO_PNPPOWER_LOCK *)&local_28,p_Var1,(bool)uVar5,(bool)in_R9B,

+                 (bool)in_stack_ffffffffffffffa8);

+      if (*(longlong *)(p_Var1 + 0xfc0) != 0) {

+        DxgkAcquireAdapterCoreSync(*(longlong *)(p_Var1 + 0xfc0),2);

+        DxgkInvalidateVidPnDisplayModeListCache(*(undefined8 *)(p_Var1 + 0xfc0));

+        DxgkReleaseAdapterCoreSync(*(undefined8 *)(p_Var1 + 0xfc0),2);

+      }

+      AUTO_PNPPOWER_LOCK::Release((AUTO_PNPPOWER_LOCK *)&local_28);

+    }

+    this = (AUTO_REMOVE_LOCK *)&local_38;

+  }

+  AUTO_REMOVE_LOCK::Release(this);

+LAB_0:

+  IoFreeWorkItem(param_3);

+  return;

 }
```

## `ConfigureFeatureDefaults`  (modified)

```diff
--- ConfigureFeatureDefaults
+++ ConfigureFeatureDefaults
@@ -1,22 +1,153 @@
 

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

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

-

-undefined4 ConfigureFeatureDefaults(void)

+ulonglong ConfigureFeatureDefaults

+                    (longlong param_1,uint param_2,undefined2 *param_3,undefined4 *param_4)

 

 {

-  undefined4 in_EAX;

-  longlong unaff_RBX;

-  undefined4 unaff_EDI;

-  longlong in_stack_00000070;

+  char cVar1;

+  int iVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  undefined8 uVar5;

+  byte bVar6;

+  undefined1 uVar7;

+  undefined2 uVar8;

   

-  _WdLogGlobalForLineNumber = in_EAX;

-  DxgkLogInternalTriageEvent(0,0x40002);

-  (**(code **)(unaff_RBX + 0x148))();

-  if (in_stack_00000070 != 0) {

-    SmmAssignDomain();

-    SmmIommuDeleteDomain(in_stack_00000070);

+  uVar7 = (undefined1)((ulonglong)param_1 >> 8);

+  *param_4 = 0;

+  *(undefined2 *)(param_4 + 1) = 0;

+  *(undefined2 *)param_4 = *param_3;

+  uVar8 = param_3[1];

+  *(byte *)(param_4 + 1) = *(byte *)(param_4 + 1) & 0xfd;

+  *(undefined2 *)((longlong)param_4 + 2) = uVar8;

+  iVar2 = Feature_Servicing_GraphicsKernel_FeatureInterfaceExtensions__private_IsEnabledDeviceUsageNoInline

+                    ();

+  bVar6 = *(byte *)(param_4 + 1);

+  if (iVar2 == 0) {

+    bVar6 = (bVar6 ^ *(byte *)(param_3 + 2)) & 1 ^ bVar6;

+    uVar4 = 0x30000008;

+    *(byte *)(param_4 + 1) = bVar6;

+    if (param_2 < 0x30000009) {

+      if (param_2 == 0x30000008) {

+LAB_0:

+        uVar4 = (ulonglong)*(uint *)(param_1 + 0x3e0) & 0xffffffffffffff02;

+        cVar1 = (char)uVar4;

+        *(ushort *)((longlong)param_4 + 2) =

+             ((CONCAT11(uVar7,bVar6) - CONCAT11(uVar7,bVar6)) - (ushort)(cVar1 != '\0') & 0xfffd) +

+             8;

+        return CONCAT71((int7)(uVar4 >> 8),-cVar1);

+      }

+      if ((param_2 != 0x20) && (param_2 != 0x25)) {

+        if (param_2 == 0x29) {

+LAB_1:

+          bVar6 = bVar6 | 1;

+          goto LAB_2;

+        }

+        if (param_2 == 0x2e) {

+          uVar5 = Feature_PanelBufferControl__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          if ((param_2 == 0x10000003) || (param_2 == 0x10000004)) goto LAB_1;

+          if (param_2 == 0x10000006) {

+            uVar5 = Feature_Servicing_GraphicsKernel_ReadOnlyExistingSysMem__private_IsEnabledDeviceUsageNoInline

+                              ();

+          }

+          else {

+            if (param_2 != 0x20000001) {

+              return 0x30000008;

+            }

+            uVar5 = Feature_Servicing_GraphicsKernel_CpuHostApertureFixes__private_IsEnabledDeviceUsageNoInline

+                              ();

+          }

+        }

+        bVar6 = (int)uVar5 != 0;

+        uVar4 = CONCAT71((int7)((ulonglong)uVar5 >> 8),*(undefined1 *)(param_4 + 1)) &

+                0xfffffffffffffffe;

+        goto LAB_3;

+      }

+    }

+    else {

+      if (param_2 != 0x30000009) {

+        if ((param_2 != 0x3000000a) && (param_2 != 0x3000000b)) goto LAB_4;

+        goto LAB_5;

+      }

+LAB_6:

+      uVar4 = (ulonglong)*(uint *)(param_1 + 0x3e0);

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

+        return uVar4;

+      }

+    }

   }

-  return unaff_EDI;

+  else {

+    bVar6 = (*(byte *)(param_3 + 2) >> 1 ^ bVar6) & 1 ^ bVar6;

+    uVar4 = 0x3000000b;

+    *(byte *)(param_4 + 1) = bVar6;

+    if (0x3000000b < param_2) {

+LAB_4:

+      if (param_2 == 0x3000000c) {

+        uVar3 = CONCAT31((uint3)(*(uint *)(param_1 + 0x3e0) >> 9),

+                         ~(byte)(*(uint *)(param_1 + 0x3e0) >> 1));

+      }

+      else {

+        if (param_2 != 0x3000000d) {

+          if (param_2 == 0x3000000e) {

+            uVar4 = (ulonglong)*(uint *)(param_1 + 0x3e0);

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

+              uVar8 = 5;

+            }

+            else {

+              *(undefined2 *)param_4 = 9;

+              uVar8 = 10;

+            }

+          }

+          else {

+            uVar8 = 5;

+            if (param_2 == 0x3000000f) {

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

+                *(undefined2 *)((longlong)param_4 + 2) = 5;

+              }

+            }

+            else if (param_2 != 0x30000010) {

+              return uVar4;

+            }

+            uVar4 = (ulonglong)*(uint *)(param_1 + 0x3e0);

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

+              return uVar4;

+            }

+          }

+          *(undefined2 *)((longlong)param_4 + 2) = uVar8;

+          return uVar4;

+        }

+        uVar3 = *(uint *)(param_1 + 0x3e0) >> 1;

+      }

+      bVar6 = ((byte)uVar3 ^ bVar6) & 1 ^ bVar6;

+      *(byte *)(param_4 + 1) = bVar6;

+      return (ulonglong)CONCAT31((int3)(uVar3 >> 8),bVar6);

+    }

+    if (param_2 != 0x3000000b) {

+      if (param_2 == 0) {

+        uVar4 = CONCAT71(0x300000,DAT_7 != 1);

+        bVar6 = bVar6 & 0xfe;

+LAB_3:

+        bVar6 = bVar6 | (byte)uVar4;

+        goto LAB_2;

+      }

+      if (param_2 == 0x10000005) goto LAB_1;

+      if (param_2 == 0x30000008) goto LAB_0;

+      if (param_2 == 0x30000009) goto LAB_6;

+      if (param_2 != 0x3000000a) {

+        return 0x3000000b;

+      }

+    }

+LAB_5:

+    uVar4 = (ulonglong)*(uint *)(param_1 + 0x3e0);

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

+      return uVar4;

+    }

+    *(undefined2 *)((longlong)param_4 + 2) = 6;

+  }

+  bVar6 = bVar6 & 0xfe;

+LAB_2:

+  *(byte *)(param_4 + 1) = bVar6;

+  return uVar4;

 }
```

## `NtGdiDdDDIAddSurfaceToSwapChain`  (modified)

```diff
--- NtGdiDdDDIAddSurfaceToSwapChain
+++ NtGdiDdDDIAddSurfaceToSwapChain
@@ -1,15 +1,188 @@
 

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

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

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

 

-void NtGdiDdDDIAddSurfaceToSwapChain(undefined8 param_1,undefined2 param_2)

+ulonglong NtGdiDdDDIAddSurfaceToSwapChain(void *param_1,undefined8 param_2,undefined8 param_3)

 

 {

-  undefined4 uVar1;

-  undefined4 *unaff_RDI;

+  DXGSWAPCHAIN *pDVar1;

+  DXGDEVICE *pDVar2;

+  int iVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  void *pvVar6;

+  bool bVar7;

+  undefined4 uVar8;

+  undefined1 auStackY_1d8 [32];

+  undefined4 local_188 [2];

+  undefined8 local_180;

+  char local_178;

+  DXGDEVICE *local_170;

+  DXGDEVICE *local_168;

+  undefined8 local_160;

+  undefined8 uStack_158;

+  void *local_150;

+  uint auStack_148 [2];

+  DXGSWAPCHAIN *local_140;

+  DXGDEVICE *local_138;

+  void *local_130;

+  DXGSWAPCHAINLOCKWITHDEVICE local_128 [128];

+  DXGSWAPCHAINLOCKWITHDEVICE local_a8 [128];

+  ulonglong local_28;

   

-  uVar1 = in(param_2);

-  *unaff_RDI = uVar1;

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

-  halt_baddata();

+                    /* 0x206280  123  NtGdiDdDDIAddSurfaceToSwapChain */

+  local_28 = __security_cookie ^ (ulonglong)auStackY_1d8;

+  local_188[0] = 0xffffffff;

+  local_180 = 0;

+  bVar7 = false;

+  local_130 = param_1;

+  if (((byte)DAT_0 & 2) == 0) {

+    local_178 = '\0';

+  }

+  else {

+    local_178 = '\x01';

+    local_188[0] = 0x898;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,param_3,0x898);

+    }

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_188,0x898);

+  local_160 = 0;

+  uStack_158 = 0;

+  local_150 = (void *)0x0;

+  auStack_148[0] = 0;

+  auStack_148[1] = 0;

+  pvVar6 = param_1;

+  if (*(void **)MmUserProbeAddress_exref <= param_1) {

+    pvVar6 = *(void **)MmUserProbeAddress_exref;

+  }

+  RtlCopyVolatileMemory(&local_160,pvVar6,0x20);

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

+    WdLogSingleEntry0(2);

+    _WdLogGlobalForLineNumber = 0x37e;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,L"DxgkAddSurfaceToSwapChain is not allowed for consumer");

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+    if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = 0xc000000d;

+  }

+  else {

+    iVar3 = Feature_317184312__private_IsEnabledDeviceUsageNoInline();

+    local_170 = (DXGDEVICE *)0x0;

+    if (iVar3 == 0) {

+      iVar3 = ObReferenceObjectByHandle(local_160,0x20000,g_pDxgkSharedSwapChainObjectType,1);

+      pDVar2 = local_170;

+      uVar5 = (ulonglong)iVar3;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_160,uVar5);

+        _WdLogGlobalForLineNumber = 0x3d2;

+      }

+      else {

+        pDVar1 = *(DXGSWAPCHAIN **)local_170;

+        local_168 = (DXGDEVICE *)0x0;

+        local_140 = pDVar1;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE

+                  (local_128,pDVar1,(int)uStack_158 != 0,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar7 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_128,&local_168,true,bVar7);

+        uVar5 = (ulonglong)uVar4;

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

+          if (*(int *)(pDVar1 + 0xe8) == 0) {

+            WdLogSingleEntry0(2);

+            _WdLogGlobalForLineNumber = 0x402;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"DxgkAddSurfaceToSwapChain is not allowed for sequential swapchains");

+            DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_128);

+            DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+            if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+              McTemplateK0q_EtwWriteTransfer();

+            }

+            return 0xc00000bb;

+          }

+          uVar4 = DXGSWAPCHAIN::AddSurface

+                            (*(DXGSWAPCHAIN **)pDVar2,local_168,(int)uStack_158,local_150,

+                             auStack_148);

+          uVar5 = (ulonglong)uVar4;

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

+            pvVar6 = (void *)((longlong)param_1 + 0x18U);

+            if (*(void **)MmUserProbeAddress_exref <= (void *)((longlong)param_1 + 0x18U)) {

+              pvVar6 = *(void **)MmUserProbeAddress_exref;

+            }

+            RtlCopyVolatileMemory(pvVar6,auStack_148,4);

+          }

+        }

+        uVar8 = ObfDereferenceObject(pDVar2);

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

+          McTemplateK0pqqpq_EtwWriteTransfer(uVar8,&EventIndirectSwapChainAddSurface);

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_128);

+      }

+    }

+    else {

+      iVar3 = ObReferenceObjectByHandle();

+      pDVar2 = local_170;

+      uVar5 = (ulonglong)iVar3;

+      local_168 = local_170;

+      if (iVar3 < 0) {

+        WdLogSingleEntry2(3,local_160,uVar5);

+        _WdLogGlobalForLineNumber = 0x38f;

+      }

+      else {

+        pDVar1 = *(DXGSWAPCHAIN **)local_170;

+        local_138 = (DXGDEVICE *)0x0;

+        local_140 = pDVar1;

+        DXGSWAPCHAINLOCKWITHDEVICE::DXGSWAPCHAINLOCKWITHDEVICE

+                  (local_a8,pDVar1,(int)uStack_158 != 0,'\x01');

+        iVar3 = Feature_IdSwapChainUserModeSync__private_IsEnabledDeviceUsageNoInline();

+        if (iVar3 != 0) {

+          bVar7 = *(int *)(pDVar1 + 0xec) != 0;

+        }

+        uVar4 = DXGSWAPCHAINLOCKWITHDEVICE::Acquire(local_a8,&local_138,true,bVar7);

+        uVar5 = (ulonglong)uVar4;

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

+          if (*(int *)(pDVar1 + 0xe8) == 0) {

+            WdLogSingleEntry0(2);

+            _WdLogGlobalForLineNumber = 0x3bf;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"DxgkAddSurfaceToSwapChain is not allowed for sequential swapchains");

+            uVar5 = 0xc00000bb;

+          }

+          else {

+            uVar4 = DXGSWAPCHAIN::AddSurface

+                              (*(DXGSWAPCHAIN **)pDVar2,local_138,(int)uStack_158,local_150,

+                               auStack_148);

+            uVar5 = (ulonglong)uVar4;

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

+              pvVar6 = (void *)((longlong)param_1 + 0x18U);

+              if (*(void **)MmUserProbeAddress_exref <= (void *)((longlong)param_1 + 0x18U)) {

+                pvVar6 = *(void **)MmUserProbeAddress_exref;

+              }

+              RtlCopyVolatileMemory(pvVar6,auStack_148,4);

+            }

+          }

+        }

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

+          McTemplateK0pqqpq_EtwWriteTransfer();

+        }

+        DXGSWAPCHAINLOCKWITHDEVICE::~DXGSWAPCHAINLOCKWITHDEVICE(local_a8);

+      }

+      NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>::

+      ~NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64>

+                ((NT_OBJECT_REFERENCE<DXGSWAPCHAIN_CONTAINER*___ptr64> *)&local_168);

+    }

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_188);

+    if ((local_178 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    uVar5 = uVar5 & 0xffffffff;

+  }

+  return uVar5;

 }
```

## `NtGdiDdDDICheckExclusiveOwnership`  (modified)

```diff
--- NtGdiDdDDICheckExclusiveOwnership
+++ NtGdiDdDDICheckExclusiveOwnership
@@ -1,205 +1,33 @@
 

-/* WARNING: Instruction at (ram,0x00014036ca61) overlaps instruction at (ram,0x00014036ca60)

-    */

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

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

-

-VIDPN_MGR * NtGdiDdDDICheckExclusiveOwnership(void)

+uchar NtGdiDdDDICheckExclusiveOwnership(undefined8 param_1,undefined8 param_2,undefined8 param_3)

 

 {

-  ulonglong uVar1;

-  int in_EAX;

-  uint uVar2;

-  long lVar3;

-  int iVar4;

-  DMMVIDEOPRESENTTARGET *pDVar5;

-  longlong lVar6;

-  DXGADAPTER *pDVar7;

-  longlong lVar8;

-  DXGADAPTER *pDVar9;

-  DXGDIAGNOSTICS *this;

-  AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION> *this_00;

-  wchar_t *pwVar10;

-  _func_long_void_ptr_uint_void_ptr_MONITOR_EVENT___uint64__DMM_VIDPN_MONITOR_TYPE__DXGK_DISPLAY_SCENARIO_CONTEXT_ptr

-  *p_Var11;

-  undefined8 unaff_RBX;

-  DMMVIDEOPRESENTTARGETSET *this_01;

-  longlong unaff_RBP;

-  VIDPN_MGR *unaff_RSI;

-  DMMVIDEOPRESENTTARGET *unaff_RDI;

-  HDXGMONITOREVENT__ *pHVar12;

-  HDXGMONITOREVENT__ *pHVar13;

-  undefined4 unaff_R13D;

-  HDXGMONITOREVENT__ *unaff_R14;

-  HDXGMONITOREVENT__ *pHVar14;

-  void *in_stack_00000040;

-  uint in_stack_00000048;

-  VIDPN_MGR *in_stack_00000050;

-  undefined8 in_stack_00000068;

-  longlong in_stack_00000070;

+  uchar uVar1;

+  DXGGLOBAL *this;

+  undefined4 local_28 [2];

+  undefined8 local_20;

+  char local_18;

   

-  this_01 = (DMMVIDEOPRESENTTARGETSET *)

-            CONCAT62((int6)((ulonglong)unaff_RBX >> 0x10),

-                     CONCAT11((char)((ulonglong)unaff_RBX >> 8) + (char)in_EAX,(char)unaff_RBX));

-  uVar2 = in_EAX - 0x20b62b;

-  *(char *)(ulonglong)uVar2 = *(char *)(ulonglong)uVar2 + (char)uVar2;

-  while (unaff_RDI = DMMVIDEOPRESENTTARGETSET::GetNextTarget(this_01,unaff_RDI),

-        unaff_RDI != (DMMVIDEOPRESENTTARGET *)0x0) {

-    if (*(int *)(unaff_RDI + 0x7c) == -1) {

-      WdLogSingleEntry1(3,*(undefined4 *)(unaff_RDI + 0x18));

-      _WdLogGlobalForLineNumber = 0x1dc;

+                    /* 0x36a080  127  NtGdiDdDDICheckExclusiveOwnership */

+  local_28[0] = 0xffffffff;

+  local_20 = 0;

+  if (((byte)DAT_0 & 2) == 0) {

+    local_18 = '\0';

+  }

+  else {

+    local_18 = '\x01';

+    local_28[0] = 0x7ff;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,param_3,0x7ff);

     }

   }

-  this_00 = (AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION> *)&stack0x00000078;

-  DMM::AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>::

-  ~AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>(this_00);

-  in_stack_00000070 = unaff_RBP + 0x30;

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x30),L"Targ",4);

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x38),L"etFo",4);

-  *(undefined ***)(unaff_RBP + -0x50) =

-       &DMM::AutoBuffer<_DMM_VIDPNPATHANDTARGETMODESET_SERIALIZATION>::_vftable__for__SetElement__;

-  in_stack_00000068 = 0x30002e;

-  *(undefined ***)(unaff_RBP + -0x38) =

-       &DMM::AutoBuffer<_DMM_VIDEOPRESENTTARGETSET_SERIALIZATION>::

-        _vftable__for__NonReferenceCounted__;

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x50),L"ityL",4);

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x58),L"ist",4);

-  *(HDXGMONITOREVENT__ **)(unaff_RBP + -0x30) = unaff_R14;

-  *(HDXGMONITOREVENT__ **)(unaff_RBP + -0x28) = unaff_R14;

-  *(undefined8 *)(unaff_RBP + -0x48) = 0;

-  *(undefined8 *)(unaff_RBP + -0x40) = 0;

-  *(undefined8 *)(unaff_RBP + -0x20) = 0x100;

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x40),L"rceP",4);

-  builtin_wcsncpy((wchar_t *)(unaff_RBP + 0x48),L"rior",4);

-  lVar3 = VIDPN_MGR::_ReadTargetPriorityList

-                    ((VIDPN_MGR *)this_00,in_stack_00000040,(_UNICODE_STRING *)&stack0x00000068,

-                     (AutoBuffer<unsigned_int> *)(unaff_RBP + -0x50));

-  if (lVar3 < 0) {

-    if (lVar3 != -0x3ffffddb) {

-      pDVar9 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-      WdLogSingleEntry2(unaff_R13D,pDVar9,(longlong)lVar3);

-      _WdLogGlobalForLineNumber = 0x222;

-      *(long *)(unaff_RSI + 0x60) = lVar3;

-      ZwClose(in_stack_00000040);

-      DMM::AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>::

-      ~AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>

-                ((AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION> *)(unaff_RBP + -0x50));

-      if (this_01 == (DMMVIDEOPRESENTTARGETSET *)0x0) {

-        return unaff_RSI;

-      }

-      ReferenceCounted::Release((ReferenceCounted *)(this_01 + 0x40));

-      return unaff_RSI;

-    }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_28,0x7ff);

+  this = DXGGLOBAL::GetGlobal();

+  uVar1 = DXGGLOBAL::CheckExclusiveOwnership(this);

+  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_28);

+  if ((local_18 != '\0') && ((DAT_1 & 1) != 0)) {

+    McTemplateK0q_EtwWriteTransfer();

   }

-  else {

-    uVar1 = *(ulonglong *)(unaff_RBP + -0x28);

-    if (uVar1 == 0) {

-      WdLogSingleEntry0(1);

-      _WdLogGlobalForLineNumber = 0x1fb;

-    }

-    pHVar14 = (HDXGMONITOREVENT__ *)(uVar1 >> 2);

-    if (pHVar14 != (HDXGMONITOREVENT__ *)0x0) {

-      lVar8 = *(longlong *)(unaff_RBP + -0x30);

-      pHVar12 = unaff_R14;

-      pHVar13 = (HDXGMONITOREVENT__ *)((ulonglong)unaff_R14 & 0xffffffff);

-      do {

-        pDVar5 = DMMVIDEOPRESENTTARGETSET::GetTargetById

-                           (this_01,*(uint *)(lVar8 + (longlong)pHVar12 * 4));

-        if (pDVar5 == (DMMVIDEOPRESENTTARGET *)0x0) {

-          WdLogSingleEntry2(3,*(undefined4 *)(lVar8 + (longlong)pHVar12 * 4),pHVar12);

-          _WdLogGlobalForLineNumber = 0x206;

-        }

-        else if (*(int *)(pDVar5 + 0x80) == -1) {

-          *(int *)(pDVar5 + 0x80) = (int)pHVar13;

-          lVar6 = WdLogNewEntry5_WdTrace();

-          *(HDXGMONITOREVENT__ **)(lVar6 + 0x18) = pHVar12;

-          *(ulonglong *)(lVar6 + 0x20) = (ulonglong)*(uint *)(pDVar5 + 0x18);

-          _WdLogGlobalForLineNumber = 0x219;

-        }

-        else {

-          WdLogSingleEntry1(2,*(undefined4 *)(pDVar5 + 0x18));

-          _WdLogGlobalForLineNumber = 0x20f;

-        }

-        pHVar12 = (HDXGMONITOREVENT__ *)(ulonglong)((int)pHVar13 + 1);

-        unaff_RSI = in_stack_00000050;

-        pHVar13 = pHVar12;

-      } while (pHVar12 < pHVar14);

-    }

-  }

-  DMM::AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>::

-  ~AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION>

-            ((AutoBuffer<_DMM_COMMITVIDPNREQUESTSET_SERIALIZATION> *)(unaff_RBP + -0x50));

-  ZwClose(in_stack_00000040);

-  in_stack_00000048 = 0xffffffff;

-  pDVar7 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-  pDVar9 = (DXGADAPTER *)&stack0x00000048;

-  pwVar10 = L"DefaultSimulatedTarget";

-  iVar4 = DpiReadPnpRegistryValue

-                    (*(undefined8 *)(pDVar7 + 0xd8),L"DefaultSimulatedTarget",pDVar9,4,1);

-  uVar2 = in_stack_00000048;

-  if ((iVar4 < 0) ||

-     (p_Var11 = (_func_long_void_ptr_uint_void_ptr_MONITOR_EVENT___uint64__DMM_VIDPN_MONITOR_TYPE__DXGK_DISPLAY_SCENARIO_CONTEXT_ptr

-                 *)(ulonglong)in_stack_00000048, in_stack_00000048 == 0xffffffff)) {

-    lVar8 = WdLogNewEntry5_WdTrace();

-    pDVar7 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-    *(DXGADAPTER **)(lVar8 + 0x18) = pDVar7;

-    _WdLogGlobalForLineNumber = 0x250;

-  }

-  else {

-    pwVar10 = (wchar_t *)(ulonglong)in_stack_00000048;

-    pDVar5 = DMMVIDEOPRESENTTARGETSET::GetTargetById(this_01,in_stack_00000048);

-    if (pDVar5 == (DMMVIDEOPRESENTTARGET *)0x0) {

-      pDVar9 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-      WdLogSingleEntry2(2);

-      _WdLogGlobalForLineNumber = 0x249;

-      pwVar10 = (wchar_t *)p_Var11;

-    }

-    else {

-      lVar8 = WdLogNewEntry5_WdTrace();

-      *(_func_long_void_ptr_uint_void_ptr_MONITOR_EVENT___uint64__DMM_VIDPN_MONITOR_TYPE__DXGK_DISPLAY_SCENARIO_CONTEXT_ptr

-        **)(lVar8 + 0x18) = p_Var11;

-      pDVar7 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-      *(DXGADAPTER **)(lVar8 + 0x20) = pDVar7;

-      _WdLogGlobalForLineNumber = 0x240;

-      *(uint *)(unaff_RSI + 0x224) = uVar2;

-    }

-  }

-  if (this_01 != (DMMVIDEOPRESENTTARGETSET *)0x0) {

-    ReferenceCounted::Release((ReferenceCounted *)(this_01 + 0x40));

-  }

-  lVar3 = VIDPN_MGR::_InitializeDmmClientInterfaces(unaff_RSI);

-  if (lVar3 < 0) {

-    pDVar9 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-    WdLogSingleEntry1(2,pDVar9);

-    _WdLogGlobalForLineNumber = 0x25e;

-  }

-  else {

-    if (*(HDXGMONITOREVENT__ **)(unaff_RSI + 8) == unaff_R14) {

-      WdLogSingleEntry0(1);

-      _WdLogGlobalForLineNumber = 0x44;

-    }

-    lVar3 = MonitorRegisterMonitorEventCallback

-                      (*(ADAPTER_DISPLAY **)(unaff_RSI + 8),

-                       (_func_long_void_ptr_uint_void_ptr_MONITOR_EVENT___uint64__DMM_VIDPN_MONITOR_TYPE__DXGK_DISPLAY_SCENARIO_CONTEXT_ptr

-                        *)pwVar10,pDVar9,(HDXGMONITOREVENT__ **)(unaff_RSI + 0x210));

-    if (-1 < lVar3) {

-      if (*(HDXGMONITOREVENT__ **)(unaff_RSI + 0x210) == unaff_R14) {

-        WdLogSingleEntry0(1);

-        _WdLogGlobalForLineNumber = 0x278;

-      }

-      this = operator_new(0x70,0x4e506456,0x100);

-      if (this != (DXGDIAGNOSTICS *)0x0) {

-        unaff_R14 = (HDXGMONITOREVENT__ *)DXGDIAGNOSTICS::DXGDIAGNOSTICS(this,0x8000,1,0x100,300);

-      }

-      *(HDXGMONITOREVENT__ **)(unaff_RSI + 0x230) = unaff_R14;

-      *(undefined4 *)(unaff_RSI + 0x68) = 2;

-      return unaff_RSI;

-    }

-    pDVar9 = VIDPN_MGR::GetContainingAdapter(unaff_RSI);

-    WdLogSingleEntry1(2,pDVar9);

-    _WdLogGlobalForLineNumber = 0x270;

-  }

-  *(long *)(unaff_RSI + 0x60) = lVar3;

-  return unaff_RSI;

+  return uVar1;

 }
```

## `MonitorSetSDRWhiteLevelOverride`  (modified)

```diff
--- MonitorSetSDRWhiteLevelOverride
+++ MonitorSetSDRWhiteLevelOverride
@@ -1,15 +1,53 @@
 

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

+/* long __cdecl MonitorSetSDRWhiteLevelOverride(void * __ptr64,unsigned int,unsigned long) */

 

 long __cdecl MonitorSetSDRWhiteLevelOverride(void *param_1,uint param_2,ulong param_3)

 

 {

-  long unaff_EBX;

-  undefined4 in_register_00000084;

+  bool bVar1;

+  long lVar2;

+  longlong lVar3;

+  longlong local_28 [4];

   

-  WdLogSingleEntry3(2,param_2,param_3,*(undefined8 *)(CONCAT44(in_register_00000084,param_3) + 0x40)

-                   );

-  _WdLogGlobalForLineNumber = 0x437;

-  return unaff_EBX;

+  lVar3 = WdLogNewEntry5_WdTrace();

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

+  *(void **)(lVar3 + 0x20) = param_1;

+  _WdLogGlobalForLineNumber = 0x184f;

+  if ((param_1 != (void *)0x0) && (param_2 != 0xffffffff)) {

+    MONITOR_MGR::AcquireMonitorExclusive(local_28,(uint)param_1,SUB41(param_2,0));

+    if (local_28[0] == 0) {

+      lVar2 = -0x3ffffff3;

+      WdLogSingleEntry1(2,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0x185b;

+    }

+    else {

+      bVar1 = DxgMonitor::MonitorColorState::EdidSupportsHDR

+                        (*(MonitorColorState **)(local_28[0] + 0xe0));

+      if ((bVar1) ||

+         (((*(byte *)(local_28[0] + 0xb1) & 0x20) != 0 &&

+          (bVar1 = DXGMONITOR::HasDescriptor((DXGMONITOR *)(local_28[0] + 0x10)), !bVar1)))) {

+        lVar2 = DxgMonitor::MonitorColorState::SetSDRWhiteLevel

+                          (*(MonitorColorState **)(local_28[0] + 0xe0),(param_3 * 1000) / 0x50,0);

+        if (-1 < lVar2) {

+          TriggerSDRWhiteLevelChangedWnf();

+          MONITOR_REF_LOCK_ACCESSOR::~MONITOR_REF_LOCK_ACCESSOR

+                    ((MONITOR_REF_LOCK_ACCESSOR *)local_28);

+          return 0;

+        }

+        WdLogSingleEntry1(2,(longlong)lVar2);

+        _WdLogGlobalForLineNumber = 0x1863;

+      }

+      else {

+        lVar2 = -0x3fffff45;

+        WdLogSingleEntry1(2,0xffffffffc00000bb);

+        _WdLogGlobalForLineNumber = 0x1861;

+      }

+    }

+    MONITOR_REF_LOCK_ACCESSOR::~MONITOR_REF_LOCK_ACCESSOR((MONITOR_REF_LOCK_ACCESSOR *)local_28);

+    return lVar2;

+  }

+  _WdLogGlobalForLineNumber = 0x184f;

+  return -0x3ffffff3;

 }
```

## `SetDisplayInfoDefaultToSDR`  (modified)

```diff
--- SetDisplayInfoDefaultToSDR
+++ SetDisplayInfoDefaultToSDR
@@ -1,10 +1,27 @@
+

+/* void __cdecl SetDisplayInfoDefaultToSDR(struct _DISPLAYCONFIG_GET_DISPLAY_INFO * __ptr64) */

 

 void __cdecl SetDisplayInfoDefaultToSDR(_DISPLAYCONFIG_GET_DISPLAY_INFO *param_1)

 

 {

-  longlong unaff_RBP;

+  int iVar1;

   

-  *(byte *)(unaff_RBP + 0x450f0c48) = *(byte *)(unaff_RBP + 0x450f0c48) | 0xc1;

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

+  *(undefined4 *)(param_1 + 0x7b8) = 8;

+  iVar1 = Feature_UseIntermediaryColorServer__private_IsEnabledDeviceUsageNoInline();

+  *(uint *)(param_1 + 0x7c0) = (-(uint)(iVar1 != 0) & 0xa3971) + 0x28f;

+  *(uint *)(param_1 + 0x7c4) = (-(uint)(iVar1 != 0) & 0x546ae) + 0x152;

+  *(uint *)(param_1 + 0x7c8) = (-(uint)(iVar1 != 0) & 0x4cacd) + 0x133;

+  *(uint *)(param_1 + 0x7cc) = (-(uint)(iVar1 != 0) & 0x9959a) + 0x266;

+  *(uint *)(param_1 + 2000) = (-(uint)(iVar1 != 0) & 0x26766) + 0x9a;

+  *(uint *)(param_1 + 0x7d4) = (-(uint)(iVar1 != 0) & 0xf3c3) + 0x3d;

+  *(uint *)(param_1 + 0x7d8) = (-(uint)(iVar1 != 0) & 0x4fec0) + 0x140;

+  *(uint *)(param_1 + 0x7dc) = (-(uint)(iVar1 != 0) & 0x542af) + 0x151;

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

+  *(undefined4 *)(param_1 + 0x7e4) = 2700000;

+  *(undefined4 *)(param_1 + 0x7e8) = 2700000;

+  *(undefined4 *)(param_1 + 0x7e0) = 5000;

+  *(uint *)(param_1 + 0x804) = *(uint *)(param_1 + 0x804) & 0xfffffdff | 0x1000;

   return;

 }
```

## `SmmIoMmuReferenceMdl`  (modified)

```diff
--- SmmIoMmuReferenceMdl
+++ SmmIoMmuReferenceMdl
@@ -1,42 +1,63 @@
 

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

 

-undefined1 SmmIoMmuReferenceMdl(void)

+int SmmIoMmuReferenceMdl(longlong param_1,longlong *param_2,undefined1 param_3)

 

 {

-  char cVar1;

-  int in_EAX;

-  uint uVar2;

-  longlong in_R10;

+  undefined8 uVar1;

+  undefined1 uVar2;

+  int iVar3;

+  int iVar4;

+  uint uVar5;

+  longlong lVar6;

+  uint uVar7;

+  ulonglong uVar8;

   

-  if (in_EAX == 1) {

-    uVar2 = (uint)*(byte *)(in_R10 + 0x7c);

+  uVar7 = *(uint *)(param_2 + 3);

+  iVar3 = 0;

+  uVar8 = 0;

+  iVar4 = 0;

+  uVar2 = ExAcquireSpinLockExclusive(param_1 + 8);

+  if (uVar7 != *(uint *)(param_2 + 2)) {

+    do {

+      uVar1 = *(undefined8 *)(*param_2 + (ulonglong)uVar7 * 8);

+      iVar3 = SmmIoMmuUpdatePfn(param_1,uVar1,param_3);

+      if (iVar3 == -0x3fffffe9) goto LAB_0;

+      uVar7 = uVar7 + 1;

+      if (iVar3 == 0x103) {

+        *(undefined8 *)(param_2[1] + uVar8 * 8) = uVar1;

+        uVar5 = (int)uVar8 + 1;

+        uVar8 = (ulonglong)uVar5;

+        if (uVar5 == *(uint *)((longlong)param_2 + 0x14)) goto LAB_1;

+      }

+    } while (uVar7 != *(uint *)(param_2 + 2));

+    if (iVar3 < 0) {

+LAB_0:

+      uVar5 = *(uint *)(param_2 + 3);

+      if (uVar5 < uVar7) {

+        lVar6 = (ulonglong)uVar5 * 8;

+        uVar8 = (ulonglong)(uVar7 - uVar5);

+        do {

+          SmmIoMmuUpdatePfn(param_1,*(undefined8 *)(lVar6 + *param_2),0);

+          lVar6 = lVar6 + 8;

+          uVar8 = uVar8 - 1;

+        } while (uVar8 != 0);

+      }

+      goto LAB_2;

+    }

+LAB_1:

+    iVar4 = (int)uVar8;

+    if ((uVar7 != *(uint *)(param_2 + 2)) && (*(int *)((longlong)param_2 + 0x14) != iVar4)) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x2cf;

+      DxgkLogInternalTriageEvent

+                (0,0x40002,0xffffffff,L"pArgs->OutputSize == OutputIndex",0x2cf,0,0,0,0);

+    }

   }

-  else if (in_EAX == 2) {

-    uVar2 = *(uint *)(in_R10 + 0x7c) >> 1;

-  }

-  else if (in_EAX == 3) {

-    uVar2 = *(uint *)(in_R10 + 0x7c) >> 2;

-  }

-  else {

-    if (in_EAX != 4) {

-      if (in_EAX != 0xff) {

-        WdLogSingleEntry1(2);

-        _WdLogGlobalForLineNumber = 0x2c3;

-        return 0;

-      }

-      goto LAB_0;

-    }

-    uVar2 = *(uint *)(in_R10 + 0x7c) >> 3;

-  }

-  if ((uVar2 & 1) == 0) {

-    return 0;

-  }

-LAB_0:

-  cVar1 = func_0x00014003c2c8();

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

-    return 0;

-  }

-  return 1;

+  *(int *)((longlong)param_2 + 0x1c) = iVar4;

+  *(uint *)(param_2 + 3) = uVar7;

+LAB_2:

+  ExReleaseSpinLockExclusive(param_1 + 8,uVar2);

+  return iVar3;

 }
```

## `DpiIndirectCbDisableRenderD3RequestsWorker`  (modified)

```diff
--- DpiIndirectCbDisableRenderD3RequestsWorker
+++ DpiIndirectCbDisableRenderD3RequestsWorker
@@ -1,593 +1,88 @@
 

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

+/* void __cdecl DpiIndirectCbDisableRenderD3RequestsWorker(struct _DEVICE_OBJECT * __ptr64,void *

+   __ptr64,struct _IO_WORKITEM * __ptr64) */

 

 void __cdecl

 DpiIndirectCbDisableRenderD3RequestsWorker

           (_DEVICE_OBJECT *param_1,void *param_2,_IO_WORKITEM *param_3)

 

 {

-  char cVar1;

-  undefined4 in_EAX;

-  undefined4 in_register_00000004;

+  int *piVar1;

+  undefined8 *puVar2;

+  code *pcVar3;

+  undefined8 *puVar4;

+  long lVar5;

+  undefined1 *puVar6;

+  _FDO_CONTEXT *local_res20;

+  undefined1 auStack_78 [8];

+  undefined1 auStack_70 [24];

+  undefined8 local_58;

+  long local_50;

+  undefined8 local_48;

+  undefined2 local_40;

+  undefined1 local_3e;

+  longlong local_38;

+  char local_30;

+  undefined8 local_28;

+  undefined8 uStack_20;

   

-  cVar1 = (char)in_EAX;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

-  *(char *)CONCAT44(in_register_00000004,in_EAX) =

-       *(char *)CONCAT44(in_register_00000004,in_EAX) + cVar1;

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

-  halt_baddata();

+  puVar6 = auStack_78;

+  do {

+    local_58 = 0;

+    KeWaitForSingleObject(&DAT_0,0,0,0);

+    puVar4 = DAT_1;

+    if ((undefined8 **)DAT_1 == &DAT_1) {

+LAB_2:

+      DAT_3 = 0;

+      *(undefined8 *)(puVar6 + -8) = 0x140187f76;

+      KeReleaseMutex(&DAT_0,0);

+      *(undefined8 *)(puVar6 + -8) = 0x140187f85;

+      IoFreeWorkItem(param_3);

+      return;

+    }

+    if (((undefined8 **)DAT_1[1] != &DAT_1) ||

+       (puVar2 = (undefined8 *)*DAT_1, (undefined8 *)puVar2[1] != DAT_1)) {

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

+      (*pcVar3)(3);

+      puVar6 = auStack_70;

+      goto LAB_2;

+    }

+    DAT_1 = puVar2;

+    puVar2[1] = &DAT_1;

+    KeReleaseMutex(&DAT_0,0);

+    uStack_20 = *(undefined8 *)((longlong)puVar4 + 0x14);

+    local_38 = 0;

+    local_28 = 0x100000001;

+    local_30 = '\0';

+    local_48 = 0;

+    local_40 = 0;

+    local_3e = 0;

+    local_res20 = (_FDO_CONTEXT *)0x0;

+    lVar5 = DpiIndirectGetMiniport

+                      ((DXGK_MINIPORT_FILTER *)&local_28,(AUTO_REMOVE_LOCK *)&local_38,

+                       (AUTO_PNPPOWER_LOCK *)&local_48,&local_res20);

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

+      local_58 = CONCAT44(local_58._4_4_,*(undefined4 *)(puVar4 + 2));

+      local_50 = lVar5;

+      McTemplateK0xtq_EtwWriteTransfer();

+    }

+    if (-1 < lVar5) {

+      if (*(int *)(puVar4 + 2) == 0) {

+        DpiEnableD3Requests(*(undefined8 *)(local_res20 + 0x18));

+      }

+      else {

+        LOCK();

+        piVar1 = (int *)(*(longlong *)(*(longlong *)(local_res20 + 0x18) + 0x40) + 0x1088);

+        *piVar1 = *piVar1 + 1;

+        UNLOCK();

+      }

+    }

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(puVar4);

+    AUTO_PNPPOWER_LOCK::Release((AUTO_PNPPOWER_LOCK *)&local_48);

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

+      IoReleaseRemoveLockEx(local_38 + 0x40);

+      local_30 = '\0';

+    }

+  } while( true );

 }
```

## `DxgkGetPresentHistoryReadyEvent`  (modified)

```diff
--- DxgkGetPresentHistoryReadyEvent
+++ DxgkGetPresentHistoryReadyEvent
@@ -1,10 +1,90 @@
 

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

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

 

-void DxgkGetPresentHistoryReadyEvent(void)

+long DxgkGetPresentHistoryReadyEvent(uint param_1,longlong *param_2)

 

 {

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

-  halt_baddata();

+  ADAPTER_RENDER *this;

+  DXGADAPTER *pDVar1;

+  long lVar2;

+  int iVar3;

+  DXGPROCESS *pDVar4;

+  DXGADAPTER **ppDVar5;

+  DXGPRESENTHISTORYTOKENQUEUE *pDVar6;

+  DXGADAPTER *local_res18;

+  longlong local_58;

+  __uint64 local_50;

+  DXGADAPTERBYHANDLE local_48 [16];

+  DXGAUTOPUSHLOCK local_38 [32];

+  

+  pDVar4 = DXGPROCESS::GetCurrent();

+  if (pDVar4 == (DXGPROCESS *)0x0) {

+    lVar2 = -0x3ffffff3;

+    WdLogSingleEntry1(2,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0x1b16;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,L"Invalid process context, returning 0x%I64x",0xffffffffc000000d

+               ,0,0,0,0);

+  }

+  else {

+    local_res18 = (DXGADAPTER *)0x0;

+    DXGADAPTERBYHANDLE::DXGADAPTERBYHANDLE(local_48,param_1,pDVar4,&local_res18,true);

+    pDVar1 = local_res18;

+    if (local_res18 == (DXGADAPTER *)0x0) {

+      lVar2 = -0x3ffffff3;

+      WdLogSingleEntry2(3,param_1,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0x1b21;

+    }

+    else {

+      local_58 = 0;

+      ppDVar5 = DXGADAPTER_REFERENCE::operator&((DXGADAPTER_REFERENCE *)&local_58);

+      lVar2 = DxgkpGetPairingAdapters

+                        (pDVar1,0,ppDVar5,&local_50,(DXGADAPTER **)0x0,(__uint64 *)0x0,'\0');

+      if (lVar2 < 0) {

+        WdLogSingleEntry2(2,pDVar1,(longlong)lVar2);

+        _WdLogGlobalForLineNumber = 0x1b35;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,

+                   L"Failed to get pairing adapters from adapter 0x%I64x for DxgkGetPresentHistoryReadyEvent (Status = 0x%I64x)!"

+                   ,pDVar1,(longlong)lVar2,0,0,0);

+        DXGADAPTER_REFERENCE::Assign((DXGADAPTER_REFERENCE *)&local_58,(DXGADAPTER *)0x0);

+      }

+      else {

+        this = *(ADAPTER_RENDER **)(local_58 + 0xc50);

+        DXGAUTOPUSHLOCK::DXGAUTOPUSHLOCK(local_38,(DXGPUSHLOCK *)(this + 0x3d0),false);

+        DXGAUTOPUSHLOCK::AcquireShared(local_38);

+        pDVar6 = ADAPTER_RENDER::GetPresentHistoryTokenQueue(this,local_38,1);

+        if (pDVar6 == (DXGPRESENTHISTORYTOKENQUEUE *)0x0) {

+          *param_2 = 0;

+          DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_38);

+          DXGADAPTER_REFERENCE::Assign((DXGADAPTER_REFERENCE *)&local_58,(DXGADAPTER *)0x0);

+          lVar2 = -0x3fffffe9;

+        }

+        else {

+          *param_2 = *(longlong *)(pDVar6 + 0x48);

+          iVar3 = Feature_GraphicsKernel2606BugFixes__private_IsEnabledDeviceUsageNoInline();

+          if ((iVar3 == 0) || (*param_2 != 0)) {

+            ObfReferenceObject(*param_2);

+            DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_38);

+            DXGADAPTER_REFERENCE::Assign((DXGADAPTER_REFERENCE *)&local_58,(DXGADAPTER *)0x0);

+            lVar2 = 0;

+          }

+          else {

+            WdLogSingleEntry3(2,pDVar6,local_58 != 0,0xffffffffc0000001);

+            _WdLogGlobalForLineNumber = 0x1b52;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"Failed to get present histroy ready event from token queue 0x%I64x for adapter 0x%I64x, returning 0x%I64x"

+                       ,pDVar6,local_58 != 0,0xffffffffc0000001,0,0);

+            DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_38);

+            DXGADAPTER_REFERENCE::Assign((DXGADAPTER_REFERENCE *)&local_58,(DXGADAPTER *)0x0);

+            lVar2 = -0x3fffffff;

+          }

+        }

+      }

+    }

+    DXGADAPTERBYHANDLE::~DXGADAPTERBYHANDLE(local_48);

+  }

+  return lVar2;

 }
```

## `MonitorSetSDRWhiteLevel`  (modified)

```diff
--- MonitorSetSDRWhiteLevel
+++ MonitorSetSDRWhiteLevel
@@ -1,27 +1,48 @@
 

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

+/* long __cdecl MonitorSetSDRWhiteLevel(struct HDXGMONITOR__ * __ptr64,unsigned long) */

 

 long __cdecl MonitorSetSDRWhiteLevel(HDXGMONITOR__ *param_1,ulong param_2)

 

 {

-  long lVar1;

-  byte bVar2;

-  undefined8 unaff_RBX;

-  char unaff_BPL;

-  undefined4 unaff_ESI;

-  BTL_TOPOLOGY_CONSTRUCTOR *unaff_RDI;

+  bool bVar1;

+  long lVar2;

+  MonitorColorState *this;

+  longlong local_28 [4];

   

-  bVar2 = (byte)((ulonglong)param_1 >> 8);

-  lVar1 = (long)CONCAT71((int7)((ulonglong)unaff_RBX >> 8),(byte)unaff_RBX + bVar2);

-  if ((CARRY1((byte)unaff_RBX,bVar2)) && (unaff_BPL != '\0')) {

-    lVar1 = BTL_TOPOLOGY_CONSTRUCTOR::_AddSecondaryPathToTopology

-                      (unaff_RDI,true,(_LUID *)(unaff_RDI + 0xc),0xffffffff);

-    if (lVar1 < 0) {

-      WdLogSingleEntry3(unaff_ESI,(longlong)lVar1,*(longlong *)unaff_RDI,

-                        *(undefined8 *)(*(longlong *)unaff_RDI + 0x40));

-      _WdLogGlobalForLineNumber = 0x3ff;

+  if (param_1 == (HDXGMONITOR__ *)0x0) {

+    lVar2 = -0x3ffffff3;

+    WdLogSingleEntry1(2,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0x1838;

+  }

+  else {

+    MONITOR_MGR::AcquireMonitorExclusive((HDXGMONITOR__ *)local_28);

+    if (local_28[0] == 0) {

+      lVar2 = -0x3ffffddb;

+      WdLogSingleEntry1(2,0xffffffffc0000225);

+      _WdLogGlobalForLineNumber = 0x183b;

     }

+    else {

+      this = *(MonitorColorState **)(local_28[0] + 0xe0);

+      bVar1 = DxgMonitor::MonitorColorState::EdidSupportsHDR(this);

+      if (bVar1) {

+        lVar2 = DxgMonitor::MonitorColorState::SetSDRWhiteLevel(this,param_2,0);

+        if (lVar2 < 0) {

+          WdLogSingleEntry1(2,(longlong)lVar2);

+          _WdLogGlobalForLineNumber = 0x183f;

+        }

+        else {

+          lVar2 = 0;

+        }

+      }

+      else {

+        lVar2 = -0x3fffff45;

+        WdLogSingleEntry1(2,0xffffffffc00000bb);

+        _WdLogGlobalForLineNumber = 0x183d;

+      }

+    }

+    MONITOR_REF_LOCK_ACCESSOR::~MONITOR_REF_LOCK_ACCESSOR((MONITOR_REF_LOCK_ACCESSOR *)local_28);

   }

-  return lVar1;

+  return lVar2;

 }
```

## `DxgkDisplayConfigDeviceInfoForAdapter`  (modified)

```diff
--- DxgkDisplayConfigDeviceInfoForAdapter
+++ DxgkDisplayConfigDeviceInfoForAdapter
@@ -1,436 +1,1354 @@
 

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

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

 

 ulonglong DxgkDisplayConfigDeviceInfoForAdapter

-                    (ulonglong param_1,undefined8 param_2,_DISPLAYCONFIG_HDR_FLAVOR *param_3,

-                    undefined8 param_4)

+                    (undefined8 param_1,DXGADAPTER_REFERENCE *param_2,

+                    DISPLAYCONFIG_TARGET_BASE_TYPE *param_3,_DXGK_DISPLAY_SCENARIO_CONTEXT *param_4)

 

 {

-  HDXGMONITOR__ *pHVar1;

+  code *pcVar1;

   DXGADAPTER *this;

-  uint uVar2;

-  long lVar3;

-  int iVar4;

-  uint uVar5;

-  _DISPLAYCONFIG_COLOR_ENCODING _Var6;

-  _LUID *p_Var7;

-  undefined4 unaff_EBX;

-  uint uVar8;

-  undefined8 *unaff_RBP;

-  ulonglong unaff_RSI;

-  char cVar9;

-  uint unaff_EDI;

-  wchar_t *pwVar10;

-  uint unaff_R12D;

-  uint unaff_R13D;

-  int *unaff_R14;

-  longlong *unaff_R15;

-  bool bVar11;

-  ulonglong uStack0000000000000028;

-  byte bStack0000000000000050;

-  byte bStack0000000000000051;

-  char cStack0000000000000052;

-  char cStack0000000000000054;

-  char cStack0000000000000055;

-  undefined4 in_stack_00000058;

-  char in_stack_00000068;

-  uint uStack0000000000000078;

-  uint uStack000000000000007c;

+  char cVar2;

+  byte bVar3;

+  byte bVar4;

+  uchar uVar5;

+  DISPLAYCONFIG_TARGET_BASE_TYPE DVar6;

+  int iVar7;

+  long lVar8;

+  uint uVar9;

+  uint uVar10;

+  _DISPLAYCONFIG_COLOR_ENCODING _Var11;

+  HDXGMONITOR__ *pHVar12;

+  longlong lVar13;

+  _DXGK_DISPLAYMODE_INFO *p_Var14;

+  char cVar15;

+  _LUID *p_Var16;

+  _DXGK_IDD_VIRTUAL_MONITOR_INFO *p_Var17;

+  ulonglong uVar18;

+  ulonglong uVar19;

+  uint uVar20;

+  void *pvVar21;

+  DISPLAYCONFIG_TARGET_BASE_TYPE *pDVar22;

+  wchar_t *pwVar23;

+  uint uVar24;

+  bool bVar25;

+  undefined4 uVar26;

+  undefined4 uVar27;

+  char local_res18;

+  undefined8 uVar28;

+  undefined8 uVar29;

+  HDXGMONITOR__ **ppHVar30;

+  DISPLAYCONFIG_TARGET_BASE_TYPE local_108;

+  bool local_106;

+  DISPLAYCONFIG_TARGET_BASE_TYPE local_105;

+  bool local_104;

+  bool local_103;

+  char local_102;

+  undefined4 local_100 [2];

+  undefined8 local_f8;

+  char local_f0;

+  char local_e8;

+  bool local_e7;

+  bool local_e6;

+  bool local_e5;

+  bool local_e4;

+  DISPLAYCONFIG_TARGET_BASE_TYPE local_e3;

+  byte local_e2;

+  byte local_e1;

+  uint local_e0;

+  uint local_dc;

+  HDXGMONITOR__ *local_d8;

+  HDXGMONITOR__ *local_c8;

+  undefined8 uStack_c0;

+  uint local_b8;

+  undefined8 local_a8;

+  undefined4 uStack_a0;

+  undefined4 uStack_9c;

+  ulong local_98;

+  _DISPLAYCONFIG_HDR_BRIGHTNESS_MODE local_94;

+  undefined4 local_90 [2];

+  HDXGMONITOR__ *local_88;

+  HDXGMONITOR__ *local_80;

+  HDXGMONITOR__ *local_78;

+  HDXGMONITOR__ *local_70;

+  __uint64 local_68 [2];

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

   

-  _WdLogGlobalForLineNumber = SUB84(&stack0x00000000,0);

-  uStack0000000000000028 = param_1;

-  DxgkLogInternalTriageEvent

-            (param_1,unaff_EBX,param_3,param_4,(ulonglong)&stack0x00000000 & 0xffffffff);

-  iVar4 = *unaff_R14;

-  if ((iVar4 == 9) || (iVar4 == 0xf)) {

-    if (*(char *)(unaff_RBP + 0xc) == '\0') {

-      WdLogSingleEntry0();

-      uStack0000000000000028 = 0;

-      _WdLogGlobalForLineNumber = 0x165a;

-      DxgkLogInternalTriageEvent(0,unaff_EBX,unaff_R12D,L"i_bGetDeviceInfo",0x165a);

-    }

-    pHVar1 = (HDXGMONITOR__ *)unaff_RBP[-0x10];

-    cStack0000000000000055 = '\0';

-    lVar3 = MonitorIsWcgEnabled(pHVar1,(bool *)((longlong)&stack0x00000050 + 5));

-    unaff_RSI = (ulonglong)lVar3;

-    if (lVar3 < 0) {

-      cStack0000000000000055 = '\0';

-      WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                        *(undefined4 *)(*unaff_R15 + 0x19c));

-      _WdLogGlobalForLineNumber = 0x1665;

-    }

-    else {

-      cStack0000000000000054 = '\0';

-      lVar3 = MonitorIsHdrEnabled(pHVar1,(bool *)((longlong)&stack0x00000050 + 4));

-      uVar8 = uStack0000000000000078;

-      unaff_RSI = (ulonglong)lVar3;

-      if (-1 < lVar3) {

-        if ((((cStack0000000000000055 == '\0') || (cStack0000000000000054 != '\0')) &&

-            (bStack0000000000000050 == 0)) &&

-           ((cStack0000000000000052 == '\0' || ((uStack0000000000000078 & 1) != 0)))) {

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)0x0;

-          iVar4 = 0;

-        }

-        else {

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)0x1;

-          iVar4 = 1;

-        }

-        if (*unaff_R14 != 0xf) {

-          if (*unaff_R14 != 9) goto LAB_0;

-          if ((((uStack0000000000000078 & 1) == 0) && (cStack0000000000000052 == '\0')) ||

-             (uVar8 = 1, *(char *)(unaff_RBP + 0xe) != '\0')) {

-            uVar8 = 0;

-          }

-          if ((bStack0000000000000051 == 0) && (bStack0000000000000050 == 0)) {

-            unaff_R13D = 0;

-          }

-          unaff_R14[5] = (unaff_R14[5] & 0xfffffffcU | uVar8 | unaff_R13D) & 0xfffffffb |

-                         (int)param_3 * 4;

-          uVar8 = GetColorDepthFromPickedWireFormat(uStack000000000000007c);

-          unaff_R14[7] = uVar8;

-          _Var6 = ConvertDmmToDisplayConfigColorEncoding(uStack000000000000007c);

-          unaff_R14[6] = _Var6;

-          bVar11 = DmmIsHdrAllowedOnTarget((DXGADAPTER *)*unaff_R15,unaff_EDI);

-          uStack000000000000007c = unaff_R14[5] & 0xfffffff7U | (bVar11 ^ 1) << 3;

-          goto LAB_1;

-        }

-        if (((uStack0000000000000078 & 1) == 0) && (cStack0000000000000052 == '\0')) {

-          cVar9 = *(char *)(unaff_RBP + 0xe);

-LAB_2:

-          uVar2 = 0;

-        }

-        else {

-          cVar9 = *(char *)(unaff_RBP + 0xe);

-          if (cVar9 != '\0') goto LAB_2;

-          uVar2 = 1;

-        }

-        if ((bStack0000000000000051 != 0) || (uVar5 = 0, bStack0000000000000050 != 0)) {

-          uVar5 = unaff_R13D;

-        }

-        unaff_R14[5] = (unaff_R14[5] & 0xfffffffcU | uVar2 | uVar5) & 0xfffffffb | iVar4 * 4;

-        uVar2 = GetColorDepthFromPickedWireFormat(uStack000000000000007c);

-        unaff_R14[7] = uVar2;

-        _Var6 = ConvertDmmToDisplayConfigColorEncoding(uStack000000000000007c);

-        uVar2 = *(uint *)(unaff_RBP + -0xc);

-        unaff_R14[6] = _Var6;

-        bVar11 = DmmIsHdrAllowedOnTarget((DXGADAPTER *)*unaff_R15,uVar2);

-        if (((uVar8 & 1) == 0) || (cVar9 != '\0')) {

-          uVar8 = 0;

-        }

-        else {

-          uVar8 = 0x10;

-        }

-        if ((cStack0000000000000052 == '\0') || (cVar9 != '\0')) {

-          uVar2 = 0;

-        }

-        else {

-          uVar2 = 0x40;

-        }

-        unaff_R14[5] = unaff_R14[5] & 7U | (bVar11 ^ 1) << 3 |

-                       -(uint)(cStack0000000000000054 != '\0') & 0x20 | uVar8 |

-                       -(uint)(cStack0000000000000055 != '\0') & 0x80 | uVar2;

-        if (bStack0000000000000051 == 0) {

-          unaff_R13D = (uint)(bStack0000000000000050 != 0);

-        }

-        unaff_R14[8] = unaff_R13D;

-        goto LAB_0;

-      }

-      cStack0000000000000054 = '\0';

-      WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                        *(undefined4 *)(*unaff_R15 + 0x19c));

-      _WdLogGlobalForLineNumber = 0x1673;

-    }

-    pwVar10 = 

-    L"MonitorGetIsAutoColorManagementSupported() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

-    ;

-LAB_3:

-    param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-    uStack0000000000000028 = (ulonglong)*(uint *)(*unaff_R15 + 0x19c);

-    DxgkLogInternalTriageEvent(0,0x40000,param_3,pwVar10,(longlong)*(int *)(*unaff_R15 + 0x1a0));

+  cVar15 = (char)param_1;

+  p_Var17 = (_DXGK_IDD_VIRTUAL_MONITOR_INFO *)&local_58;

+  local_100[0] = 0xffffffff;

+  local_f8 = 0;

+  uVar24 = 2;

+  if (((byte)DAT_0 & 2) == 0) {

+    local_f0 = '\0';

   }

   else {

-    if (iVar4 == 10) {

-      if (*(char *)(unaff_RBP + 0xc) != '\0') {

+    local_f0 = '\x01';

+    local_100[0] = 0x888;

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

+      McTemplateK0q_EtwWriteTransfer(param_1,&EventProfilerEnter,param_3,0x888);

+    }

+  }

+  DXGETWPROFILER_BASE::PushProfilerEntry((DXGETWPROFILER_BASE *)local_100,0x888);

+  if (param_3 == (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x1450;

+    pwVar23 = L"io_pRequestPacket != NULL";

+LAB_2:

+    DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,pwVar23,_WdLogGlobalForLineNumber,0,0,0,0);

+LAB_3:

+    DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+    if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+      McTemplateK0q_EtwWriteTransfer();

+    }

+    return 0xc000000d;

+  }

+  uVar20 = *(uint *)param_3;

+  if (uVar20 < 0x65) {

+    if (uVar20 == 100) {

+LAB_4:

+      this = *(DXGADAPTER **)param_2;

+      if ((*(uint *)(this + 0x1bc) & 0x100) == 0) {

+        WdLogSingleEntry3(3,this,(longlong)*(int *)(this + 0x1a0),*(undefined4 *)(this + 0x19c));

+        _WdLogGlobalForLineNumber = 0x1544;

+LAB_5:

+        DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+        if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+          McTemplateK0q_EtwWriteTransfer();

+        }

+        return 0xc00000bb;

+      }

+      if (uVar20 == 0xfffffff6) {

+        lVar8 = ADAPTER_DISPLAY::DodGetRenderAdapter

+                          (*(ADAPTER_DISPLAY **)(this + 0xc48),*(uint *)(param_3 + 0x10),

+                           (_LUID *)(param_3 + 0x14));

+        if (lVar8 < 0) {

+          lVar13 = *(longlong *)param_2;

+          WdLogSingleEntry3(3,lVar13,(longlong)*(int *)(lVar13 + 0x1a0),

+                            *(undefined4 *)(lVar13 + 0x19c));

+          _WdLogGlobalForLineNumber = 0x1553;

+          goto LAB_3;

+        }

+      }

+      else {

+        if (uVar20 != 100) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x156b;

+          pwVar23 = L"DISPLAYCONFIG_DEVICE_INFO type not handled";

+          goto LAB_2;

+        }

+        local_48 = 0;

+        local_58 = 0;

+        uStack_50 = 0;

+        lVar8 = DXGADAPTER::GetVirtualMonitorInfo(this,*(uint *)(param_3 + 0x10),p_Var17);

+        if (lVar8 < 0) {

+          lVar13 = *(longlong *)param_2;

+          WdLogSingleEntry3(3,lVar13,(longlong)*(int *)(lVar13 + 0x1a0),

+                            *(undefined4 *)(lVar13 + 0x19c));

+          _WdLogGlobalForLineNumber = 0x1563;

+          goto LAB_3;

+        }

+        *(undefined4 *)(param_3 + 0x14) = local_58._4_4_;

+      }

+LAB_6:

+      uVar18 = 0;

+      goto LAB_7;

+    }

+    if (uVar20 < 0xb) {

+      if (uVar20 == 10) goto switchD_1403c6b81_caseD_ffffffd3;

+      if (uVar20 == 2) {

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

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x148a;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x148a,0,0,0,0);

+        }

+        uVar24 = DisplayConfigFillTargetDeviceInfo

+                           ((DISPLAYCONFIG_TARGET_DEVICE_NAME *)param_3,param_2);

+LAB_8:

+        uVar18 = (ulonglong)uVar24;

+        goto LAB_7;

+      }

+      if (uVar20 != 4) {

+        if (uVar20 == 6) {

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

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x1494;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x1494,0,0,0,0);

+          }

+          uVar24 = DisplayConfigGetTargetBaseType(param_3,param_2);

+        }

+        else {

+          if ((uVar20 != 7) && (iVar7 = uVar20 - 8, iVar7 != 0)) goto LAB_9;

+          lVar13 = *(longlong *)param_2;

+          if (*(char *)(*(longlong *)(lVar13 + 0xc48) + 0x122) == '\0') {

+            WdLogSingleEntry3(3,lVar13,(longlong)*(int *)(lVar13 + 0x1a0),

+                              *(undefined4 *)(lVar13 + 0x19c));

+            _WdLogGlobalForLineNumber = 0x14a7;

+            goto LAB_5;

+          }

+          if (uVar20 == 7) {

+            local_105 = (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0;

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

+              WdLogSingleEntry0(1);

+              _WdLogGlobalForLineNumber = 0x14b2;

+              DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x14b2,0,0,0,0);

+            }

+            *(undefined4 *)(param_3 + 0x14) = 0;

+            uVar24 = MonitorIsMonitorVirtualModeDisabled

+                               (*(void **)param_2,*(uint *)(param_3 + 0x10),(uchar *)&local_105);

+            uVar18 = (ulonglong)uVar24;

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

+              *(uint *)(param_3 + 0x14) =

+                   *(uint *)(param_3 + 0x14) & 0xfffffffe |

+                   (uint)(local_105 != (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0);

+            }

+            goto LAB_7;

+          }

+          if ((cVar15 != '\0') || (uVar20 != 8)) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x14c3;

+            DxgkLogInternalTriageEvent

+                      (0,0x40002,0xffffffff,

+                       L"(!i_bGetDeviceInfo)&& (io_pRequestPacket->type == DISPLAYCONFIG_DEVICE_INFO_SET_SUPPORT_VIRTUAL_RESOLUTION)"

+                       ,0x14c3,0,0,0,0);

+          }

+          local_e8 = '\0';

+          iVar7 = CheckGivenTargetIsPartOfCloneGroup

+                            (*(undefined8 *)param_2,*(undefined4 *)(param_3 + 0x10),&local_e8);

+          if ((-1 < iVar7) && (local_e8 != '\0')) {

+            WdLogSingleEntry3(3,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                              *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                              *(undefined4 *)(param_3 + 0x10));

+            _WdLogGlobalForLineNumber = 0x14d0;

+            DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+            if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+              McTemplateK0q_EtwWriteTransfer();

+            }

+            return 0xc00000af;

+          }

+          uVar24 = MonitorDisableMonitorVirtualModeSupport

+                             (*(void **)param_2,*(uint *)(param_3 + 0x10),(byte)param_3[0x14] & 1,

+                              param_4);

+        }

+        goto LAB_8;

+      }

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

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1462;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,L"Adapter 0x%I64x had no FDO",*(undefined8 *)param_2,0,0,0,0

+                  );

+        DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+        if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+          McTemplateK0q_EtwWriteTransfer();

+        }

+        return 0xc0000225;

+      }

+      pHVar12 = (HDXGMONITOR__ *)IoGetDeviceAttachmentBaseRef();

+      local_a8 = (wchar_t *)0x0;

+      local_c8 = pHVar12;

+      wil::details::

+      unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+      ::reset((unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+               *)&local_a8,(ushort *)0x0);

+      iVar7 = IoGetDeviceInterfaces(&GUID_DEVINTERFACE_DISPLAY_ADAPTER,pHVar12,0,&local_a8);

+      uVar18 = (ulonglong)iVar7;

+      if (-1 < iVar7) {

+        wcsncpy_s((wchar_t *)(param_3 + 0x14),0x80,local_a8,0xffffffffffffffff);

+        *(undefined2 *)(param_3 + 0x16) = 0x5c;

+        wil::details::

+        unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+        ::

+        ~unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+                  ((unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+                    *)&local_a8);

+        wil::details::

+        unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+        ::

+        ~unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+                  ((unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+                    *)&local_c8);

+        goto LAB_7;

+      }

+      WdLogSingleEntry2(3,pHVar12,uVar18);

+      _WdLogGlobalForLineNumber = 0x1472;

+      wil::details::

+      unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+      ::

+      ~unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+                ((unique_storage<wil::details::resource_policy<unsigned_short*___ptr64,void___cdecl(unsigned_short*___ptr64)_noexcept,&public:_static_void___cdecl_wil::details::pool_helpers<unsigned_short*___ptr64,0>::FreePoolWithTag(unsigned_short*___ptr64),wistd::integral_constant<unsigned___int64,0>,unsigned_short*___ptr64,unsigned_short*___ptr64,0,std::nullptr_t>_>

+                  *)&local_a8);

+      wil::details::

+      unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+      ::

+      ~unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+                ((unique_storage<wil::details::resource_policy<_DEVICE_OBJECT*___ptr64,void___cdecl(void*___ptr64),&void___cdecl_widxg::details::DereferenceObject(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,_DEVICE_OBJECT*___ptr64,_DEVICE_OBJECT*___ptr64,0,std::nullptr_t>_>

+                  *)&local_c8);

+      goto LAB_10;

+    }

+    if (uVar20 != 0xb) {

+      if (uVar20 == 0xc) {

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',

+                           DxgkDisplayConfigDeviceInfo,&local_c8);

+        pHVar12 = local_c8;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                            *(undefined4 *)(param_3 + 0x10),uVar18);

+          _WdLogGlobalForLineNumber = 0x187b;

+          goto LAB_11;

+        }

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x187f;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x187f,0,0,0,0);

+        }

+        local_e7 = false;

+        local_e5 = false;

+        local_e6 = false;

+        lVar8 = MonitorGetPseudoSpecializedState(pHVar12,&local_e5,&local_e6,&local_e7);

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry1(2,uVar18);

+          pwVar23 = L"Failed to call MonitorGetPseudoSpecializedState with status 0x%I64x";

+          _WdLogGlobalForLineNumber = 0x1888;

+          goto LAB_12;

+        }

+        uVar24 = *(uint *)(param_3 + 0x14) & 0xfffffff8 | (uint)(local_e7 != false) |

+                 -(uint)(local_e6 != false) & 4 | -(uint)(local_e5 != false) & 2;

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)(ulonglong)uVar24;

+        *(uint *)(param_3 + 0x14) = uVar24;

+        goto LAB_13;

+      }

+      if (uVar20 == 0xd) goto LAB_14;

+      if ((uVar20 != 0xf) && (iVar7 = uVar20 - 0x10, iVar7 != 0)) {

+LAB_9:

+        if (iVar7 != 1) goto switchD_1403c6b81_caseD_ffffffd9;

+      }

+    }

+switchD_1403c6b81_caseD_ffffffd3:

+    uVar20 = *(uint *)(param_3 + 0x10);

+    local_102 = '\0';

+    local_b8 = uVar20;

+    iVar7 = CheckGivenTargetIsPartOfCloneGroup(*(undefined8 *)param_2,uVar20);

+    if (iVar7 == -0x3ffffddb) {

+      WdLogSingleEntry4(3,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                        *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,0xffffffffc0000225);

+      _WdLogGlobalForLineNumber = 0x1604;

+      local_102 = '\0';

+    }

+    cVar2 = local_102;

+    local_70 = (HDXGMONITOR__ *)0x0;

+    lVar8 = MonitorGetMonitorHandle

+                      (*(void **)param_2,uVar20,'\0',DxgkDisplayConfigDeviceInfo,&local_70);

+    pHVar12 = local_70;

+    uVar18 = (ulonglong)lVar8;

+    if (lVar8 < 0) {

+      WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                        *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+      _WdLogGlobalForLineNumber = 0x1619;

+      uVar26 = *(undefined4 *)(*(longlong *)param_2 + 0x19c);

+      iVar7 = *(int *)(*(longlong *)param_2 + 0x1a0);

+      goto LAB_15;

+    }

+    local_d8 = local_70;

+    if (local_70 == (HDXGMONITOR__ *)0x0) {

+      WdLogSingleEntry0();

+      _WdLogGlobalForLineNumber = 0x161d;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x161d,0,0,0,0);

+    }

+    local_e0 = 0;

+    lVar8 = MonitorIsMonitorAndLinkHDRCapable

+                      (pHVar12,(MONITOR_AND_LINK_HDR_CAPS *)&local_e0,

+                       (MonitorAndLinkHDRIncapableReason *)0x0);

+    uVar18 = (ulonglong)lVar8;

+    if (lVar8 < 0) {

+      WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                        *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+      pwVar23 = 

+      L"MonitorIsMonitorAndLinkHDRCapable() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+      ;

+      _WdLogGlobalForLineNumber = 0x1627;

+      uVar19 = uVar18;

+LAB_16:

+      pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,pwVar23,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                 *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18,0);

+      pHVar12 = local_d8;

+      uVar18 = uVar19;

+    }

+    else {

+      local_106 = false;

+      lVar8 = MonitorIsMonitorAndDriverWCGCapable

+                        (local_d8,&local_106,(MonitorAndLinkWCGIncapableReason *)0x0);

+      lVar13 = *(longlong *)param_2;

+      uVar18 = (ulonglong)lVar8;

+      if (lVar8 < 0) {

+        WdLogSingleEntry4(2,(longlong)*(int *)(lVar13 + 0x1a0),*(undefined4 *)(lVar13 + 0x19c),

+                          uVar20,uVar18);

+        pwVar23 = 

+        L"MonitorIsMonitorAndDriverWCGCapable() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+        ;

+        _WdLogGlobalForLineNumber = 0x1633;

+        uVar19 = uVar18;

+        goto LAB_16;

+      }

+      local_dc = 0;

+      local_90[0] = 0;

+      pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)&local_dc;

+      local_e2 = 0;

+      local_e1 = 0;

+      iVar7 = IsCurrentModeAdvancedColor(lVar13,uVar20,pDVar22,local_90,&local_e2,&local_e1);

+      bVar4 = local_e1;

+      bVar3 = local_e2;

+      uVar18 = (ulonglong)iVar7;

+      if (iVar7 < 0) {

+        WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                          *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+        pwVar23 = 

+        L"IsCurrentModeAdvancedColor() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+        ;

+        _WdLogGlobalForLineNumber = 0x1647;

+        uVar19 = uVar18;

+        goto LAB_16;

+      }

+      if ((cVar2 != '\0') && ((local_e2 != 0 || (local_e1 != 0)))) {

         WdLogSingleEntry0();

-        param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-        uStack0000000000000028 = 0;

-        _WdLogGlobalForLineNumber = 0x16b3;

-        DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"!i_bGetDeviceInfo",0x16b3);

-      }

-      uVar8 = uStack0000000000000078 & 1;

-      if (((uVar8 != 0) || (cStack0000000000000052 != '\0')) && (*(char *)(unaff_RBP + 0xe) == '\0')

-         ) {

-        if (uVar8 == 0) {

-          uVar2 = MonitorEnableDisableWcg

-                            ((HDXGMONITOR__ *)unaff_RBP[-0x10],(bool)(*(byte *)(unaff_R14 + 5) & 1))

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+        _WdLogGlobalForLineNumber = 0x1651;

+        DxgkLogInternalTriageEvent

+                  (0,0x40002,0xffffffff,L"!bCurrentModeHdr && !bCurrentModeWcg",0x1651,0,0,0,0);

+      }

+      iVar7 = *(int *)param_3;

+      if ((iVar7 == 9) || (iVar7 == 0xf)) {

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

+          WdLogSingleEntry0();

+          _WdLogGlobalForLineNumber = 0x165a;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x165a,0,0,0,0);

+        }

+        pHVar12 = local_d8;

+        local_103 = false;

+        lVar8 = MonitorIsWcgEnabled(local_d8,&local_103);

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          local_103 = false;

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          _WdLogGlobalForLineNumber = 0x1665;

+        }

+        else {

+          local_104 = false;

+          lVar8 = MonitorIsHdrEnabled(pHVar12,&local_104);

+          uVar9 = local_e0;

+          uVar18 = (ulonglong)lVar8;

+          if (-1 < lVar8) {

+            if ((((local_103 == false) || (local_104 != false)) && (bVar4 == 0)) &&

+               ((local_106 == false || ((local_e0 & 1) != 0)))) {

+              pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+              iVar7 = 0;

+            }

+            else {

+              pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x1;

+              iVar7 = 1;

+            }

+            if (*(int *)param_3 == 0xf) {

+              if ((((local_e0 & 1) == 0) && (local_106 == false)) || (cVar2 != '\0')) {

+                uVar20 = 0;

+              }

+              else {

+                uVar20 = 1;

+              }

+              if ((bVar3 != 0) || (uVar10 = 0, bVar4 != 0)) {

+                uVar10 = uVar24;

+              }

+              *(uint *)(param_3 + 0x14) =

+                   *(uint *)(param_3 + 0x14) & 0xfffffff8 | uVar20 | uVar10 | iVar7 * 4;

+              uVar20 = GetColorDepthFromPickedWireFormat(local_dc);

+              *(uint *)(param_3 + 0x1c) = uVar20;

+              _Var11 = ConvertDmmToDisplayConfigColorEncoding(local_dc);

+              *(_DISPLAYCONFIG_COLOR_ENCODING *)(param_3 + 0x18) = _Var11;

+              bVar25 = DmmIsHdrAllowedOnTarget(*(DXGADAPTER **)param_2,local_b8);

+              if (((uVar9 & 1) == 0) || (cVar2 != '\0')) {

+                uVar20 = 0;

+              }

+              else {

+                uVar20 = 0x10;

+              }

+              if ((local_106 == false) || (cVar2 != '\0')) {

+                uVar9 = 0;

+              }

+              else {

+                uVar9 = 0x40;

+              }

+              *(uint *)(param_3 + 0x14) =

+                   *(uint *)(param_3 + 0x14) & 7 | (bVar25 ^ 1) << 3 |

+                   -(uint)(local_104 != false) & 0x20 | uVar20 | -(uint)(local_103 != false) & 0x80

+                   | uVar9;

+              if (bVar3 == 0) {

+                uVar24 = (uint)(bVar4 != 0);

+              }

+              *(uint *)(param_3 + 0x20) = uVar24;

+              pHVar12 = local_d8;

+            }

+            else {

+              pHVar12 = local_d8;

+              if (*(int *)param_3 == 9) {

+                if ((((local_e0 & 1) == 0) && (local_106 == false)) || (uVar9 = 1, cVar2 != '\0')) {

+                  uVar9 = 0;

+                }

+                if ((bVar3 == 0) && (bVar4 == 0)) {

+                  uVar24 = 0;

+                }

+                *(uint *)(param_3 + 0x14) =

+                     *(uint *)(param_3 + 0x14) & 0xfffffff8 | uVar9 | uVar24 | (int)pDVar22 * 4;

+                uVar24 = GetColorDepthFromPickedWireFormat(local_dc);

+                *(uint *)(param_3 + 0x1c) = uVar24;

+                _Var11 = ConvertDmmToDisplayConfigColorEncoding(local_dc);

+                *(_DISPLAYCONFIG_COLOR_ENCODING *)(param_3 + 0x18) = _Var11;

+                bVar25 = DmmIsHdrAllowedOnTarget(*(DXGADAPTER **)param_2,uVar20);

+                uVar24 = *(uint *)(param_3 + 0x14) & 0xfffffff7 | (bVar25 ^ 1) << 3;

+                goto LAB_17;

+              }

+            }

+            goto LAB_13;

+          }

+          local_104 = false;

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          _WdLogGlobalForLineNumber = 0x1673;

+        }

+        pwVar23 = 

+        L"MonitorGetIsAutoColorManagementSupported() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+        ;

+        uVar19 = uVar18;

+        goto LAB_16;

+      }

+      if (iVar7 == 10) {

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

+          WdLogSingleEntry0();

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x16b3;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x16b3,0,0,0,0);

+        }

+        uVar24 = local_e0 & 1;

+        if (((uVar24 != 0) || (local_106 != false)) && (cVar2 == '\0')) {

+          if (uVar24 == 0) {

+            uVar9 = MonitorEnableDisableWcg(local_d8,(bool)((byte)param_3[0x14] & 1));

+          }

+          else {

+            uVar9 = MonitorEnableDisableHdr(local_d8,(bool)((byte)param_3[0x14] & 1));

+          }

+          uVar19 = (ulonglong)uVar9;

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

+            pHVar12 = local_d8;

+            uVar18 = uVar19;

+            if (uVar9 == 0xff) {

+              if ((bVar3 == 0) && ((uVar24 != 0 || (bVar4 == 0)))) {

+                uVar24 = 0;

+              }

+              else {

+                uVar24 = 1;

+              }

+              bVar25 = (*(uint *)(param_3 + 0x14) & 1) == uVar24;

+LAB_18:

+              pHVar12 = local_d8;

+              if (!bVar25) {

+                uVar18 = 0;

+              }

+            }

+            goto LAB_13;

+          }

+          uVar18 = (ulonglong)(int)uVar9;

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          pwVar23 = 

+          L"MonitorEnableDisableAdvancedColor() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

           ;

-        }

-        else {

-          uVar2 = MonitorEnableDisableHdr

-                            ((HDXGMONITOR__ *)unaff_RBP[-0x10],(bool)(*(byte *)(unaff_R14 + 5) & 1))

+          _WdLogGlobalForLineNumber = 0x16d6;

+          goto LAB_16;

+        }

+LAB_19:

+        pHVar12 = local_d8;

+        uVar18 = 0xc00000bb;

+      }

+      else if (iVar7 == 0x10) {

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

+          WdLogSingleEntry0();

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x16ec;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x16ec,0,0,0,0);

+        }

+        if (((local_e0 & 1) == 0) || (cVar2 != '\0')) goto LAB_19;

+        lVar8 = MonitorEnableDisableHdr(local_d8,(bool)((byte)param_3[0x14] & 1));

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          pwVar23 = 

+          L"MonitorEnableDisableHdr() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

           ;

-        }

-        unaff_RSI = (ulonglong)uVar2;

-        if (-1 < (int)uVar2) {

-          if (uVar2 != 0xff) goto LAB_0;

-          if ((bStack0000000000000051 == 0) && ((uVar8 != 0 || (bStack0000000000000050 == 0)))) {

-            uVar8 = 0;

-          }

-          else {

-            uVar8 = 1;

-          }

-          bVar11 = (unaff_R14[5] & 1U) == uVar8;

-LAB_4:

-          if (!bVar11) {

-            unaff_RSI = 0;

-          }

-          goto LAB_0;

-        }

-        WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                          *(undefined4 *)(*unaff_R15 + 0x19c));

-        pwVar10 = 

-        L"MonitorEnableDisableAdvancedColor() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

-        ;

-        _WdLogGlobalForLineNumber = 0x16d6;

-        goto LAB_3;

-      }

-    }

-    else if (iVar4 == 0x10) {

-      if (*(char *)(unaff_RBP + 0xc) != '\0') {

-        WdLogSingleEntry0();

-        param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-        uStack0000000000000028 = 0;

-        _WdLogGlobalForLineNumber = 0x16ec;

-        DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"!i_bGetDeviceInfo",0x16ec);

-      }

-      if (((uStack0000000000000078 & 1) != 0) && (*(char *)(unaff_RBP + 0xe) == '\0')) {

-        lVar3 = MonitorEnableDisableHdr

-                          ((HDXGMONITOR__ *)unaff_RBP[-0x10],(bool)(*(byte *)(unaff_R14 + 5) & 1));

-        unaff_RSI = (ulonglong)lVar3;

-        if (-1 < lVar3) {

-          if (lVar3 != 0xff) goto LAB_0;

-          bVar11 = ((byte)unaff_R14[5] & 1) == bStack0000000000000051;

-          goto LAB_4;

-        }

-        WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                          *(undefined4 *)(*unaff_R15 + 0x19c));

-        pwVar10 = 

-        L"MonitorEnableDisableHdr() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

-        ;

-        _WdLogGlobalForLineNumber = 0x1708;

-        goto LAB_3;

-      }

-    }

-    else if (iVar4 == 0x11) {

-      if (*(char *)(unaff_RBP + 0xc) != '\0') {

-        WdLogSingleEntry0();

-        param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-        uStack0000000000000028 = 0;

-        _WdLogGlobalForLineNumber = 0x171e;

-        DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"!i_bGetDeviceInfo",0x171e);

-      }

-      if ((cStack0000000000000052 != '\0') && (*(char *)(unaff_RBP + 0xe) == '\0')) {

-        lVar3 = MonitorEnableDisableWcg

-                          ((HDXGMONITOR__ *)unaff_RBP[-0x10],(bool)(*(byte *)(unaff_R14 + 5) & 1));

-        unaff_RSI = (ulonglong)lVar3;

-        if (-1 < lVar3) {

-          if (lVar3 != 0xff) goto LAB_0;

-          bVar11 = ((byte)unaff_R14[5] & 1) == bStack0000000000000050;

-          goto LAB_4;

-        }

-        WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                          *(undefined4 *)(*unaff_R15 + 0x19c));

-        pwVar10 = 

-        L"MonitorEnableDisableWcg() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

-        ;

-        _WdLogGlobalForLineNumber = 0x173a;

-        goto LAB_3;

-      }

-    }

-    else {

-      if (iVar4 == 0xb) {

-        if (*(char *)(unaff_RBP + 0xc) == '\0') {

+          _WdLogGlobalForLineNumber = 0x1708;

+          uVar19 = uVar18;

+          goto LAB_16;

+        }

+        pHVar12 = local_d8;

+        if (lVar8 == 0xff) {

+          bVar25 = ((byte)*(undefined4 *)(param_3 + 0x14) & 1) == bVar3;

+          goto LAB_18;

+        }

+      }

+      else if (iVar7 == 0x11) {

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

           WdLogSingleEntry0();

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-          uStack0000000000000028 = 0;

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x171e;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x171e,0,0,0,0);

+        }

+        if ((local_106 == false) || (cVar2 != '\0')) goto LAB_19;

+        lVar8 = MonitorEnableDisableWcg(local_d8,(bool)((byte)param_3[0x14] & 1));

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          pwVar23 = 

+          L"MonitorEnableDisableWcg() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+          ;

+          _WdLogGlobalForLineNumber = 0x173a;

+          uVar19 = uVar18;

+          goto LAB_16;

+        }

+        pHVar12 = local_d8;

+        if (lVar8 == 0xff) {

+          bVar25 = ((byte)*(undefined4 *)(param_3 + 0x14) & 1) == bVar4;

+          goto LAB_18;

+        }

+      }

+      else if (iVar7 == 0xb) {

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

+          WdLogSingleEntry0();

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

           _WdLogGlobalForLineNumber = 0x1750;

-          DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"i_bGetDeviceInfo",0x1750);

-        }

-        uStack000000000000007c = 1000;

-        *(undefined4 *)(unaff_RBP + -8) = 1000;

-        if ((bStack0000000000000051 != 0) && ((uStack0000000000000078 & 1) != 0)) {

-          lVar3 = MonitorGetSDRWhiteLevel

-                            ((HDXGMONITOR__ *)unaff_RBP[-0x10],(ulong *)(unaff_RBP + -8));

-          unaff_RSI = (ulonglong)lVar3;

-          if (lVar3 < 0) {

-            param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)*(uint *)(*unaff_R15 + 0x19c);

-            WdLogSingleEntry4(3,(longlong)*(int *)(*unaff_R15 + 0x1a0));

-            uStack000000000000007c = 3000;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x1750,0,0,0,0);

+        }

+        local_98 = 1000;

+        uVar24 = 1000;

+        if ((bVar3 != 0) && ((local_e0 & 1) != 0)) {

+          lVar8 = MonitorGetSDRWhiteLevel(local_d8,&local_98);

+          uVar18 = (ulonglong)lVar8;

+          uVar24 = local_98;

+          if (lVar8 < 0) {

+            pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)

+                      (ulonglong)*(uint *)(*(longlong *)param_2 + 0x19c);

+            WdLogSingleEntry4(3,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),pDVar22,uVar20,

+                              uVar18);

             _WdLogGlobalForLineNumber = 0x1762;

-          }

-          else {

-            uStack000000000000007c = *(uint *)(unaff_RBP + -8);

-          }

-        }

-LAB_1:

-        unaff_R14[5] = uStack000000000000007c;

-        goto LAB_0;

-      }

-      if (iVar4 == -0x12) {

-        if (*(char *)(unaff_RBP + 0xc) != '\0') {

+            uVar24 = 3000;

+          }

+        }

+LAB_17:

+        *(uint *)(param_3 + 0x14) = uVar24;

+        pHVar12 = local_d8;

+      }

+      else if (iVar7 == -0x12) {

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

           WdLogSingleEntry0(1);

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-          uStack0000000000000028 = 0;

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

           _WdLogGlobalForLineNumber = 0x176d;

-          DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"!i_bGetDeviceInfo",0x176d);

-        }

-        iVar4 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

-        pHVar1 = (HDXGMONITOR__ *)unaff_RBP[-0x10];

-        if (iVar4 != 0) {

-          *(undefined4 *)((longlong)unaff_RBP + -0x3c) = 0;

-          lVar3 = MonitorGetHdrBrightnessPolicy

-                            (pHVar1,(_DISPLAYCONFIG_HDR_BRIGHTNESS_MODE *)

-                                    ((longlong)unaff_RBP + -0x3c));

-          unaff_RSI = (ulonglong)lVar3;

-          if (lVar3 < 0) {

-            WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                              *(undefined4 *)(*unaff_R15 + 0x19c));

-            pwVar10 = 

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x176d,0,0,0,0);

+        }

+        iVar7 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+        pHVar12 = local_d8;

+        if (iVar7 != 0) {

+          local_94 = 0;

+          lVar8 = MonitorGetHdrBrightnessPolicy(local_d8,&local_94);

+          uVar18 = (ulonglong)lVar8;

+          if (lVar8 < 0) {

+            WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                              *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+            pwVar23 = 

             L"MonitorGetHdrBrightnessPolicy() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

             ;

             _WdLogGlobalForLineNumber = 0x177d;

-            goto LAB_3;

-          }

-          if (*(int *)((longlong)unaff_RBP + -0x3c) == 0) goto LAB_5;

-        }

-        uVar8 = unaff_R14[5];

-        p_Var7 = (_LUID *)(ulonglong)uVar8;

-        if (uVar8 - 1000 < 0x1389) {

-          if ((bStack0000000000000051 == 0) || ((uStack0000000000000078 & 1) == 0)) {

-            unaff_RSI = 0xc00000bb;

+            uVar19 = uVar18;

+            goto LAB_16;

+          }

+          if (local_94 == 0) goto LAB_19;

+        }

+        uVar24 = *(uint *)(param_3 + 0x14);

+        p_Var16 = (_LUID *)(ulonglong)uVar24;

+        if (uVar24 - 1000 < 0x1389) {

+          if ((bVar3 == 0) || ((local_e0 & 1) == 0)) {

+            uVar18 = 0xc00000bb;

           }

           else {

-            lVar3 = MonitorSetSDRWhiteLevel(pHVar1,uVar8);

-            unaff_RSI = (ulonglong)lVar3;

-            if (lVar3 < 0) {

-              WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                                *(undefined4 *)(*unaff_R15 + 0x19c));

-              param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

+            lVar8 = MonitorSetSDRWhiteLevel(pHVar12,uVar24);

+            uVar18 = (ulonglong)lVar8;

+            if (lVar8 < 0) {

+              WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                                *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+              pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

               _WdLogGlobalForLineNumber = 0x17a0;

-              uStack0000000000000028 = (ulonglong)*(uint *)(*unaff_R15 + 0x19c);

               DxgkLogInternalTriageEvent

-                        (0,0x40000,param_3,

+                        (0,0x40000,0xffffffff,

                          L"MonitorSetSDRWhiteLevel() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

-                         ,(longlong)*(int *)(*unaff_R15 + 0x1a0));

+                         ,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                         *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18,0);

             }

-            else if (lVar3 == 0) {

-              if ((char)unaff_R14[6] == '\0') goto LAB_0;

+            else if (lVar8 == 0) {

+              pHVar12 = local_d8;

+              if (param_3[0x18] == (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0) goto LAB_13;

               TriggerSDRWhiteLevelChangedWnf();

-              this = (DXGADAPTER *)*unaff_R15;

-              unaff_RBP[-0xe] = 0;

-              *unaff_RBP = 0;

-              unaff_RBP[1] = 0;

-              param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)0x0;

-              *(undefined4 *)unaff_RBP = 0xd;

-              unaff_RBP[2] = 0;

-              unaff_RBP[3] = 0;

-              DXGADAPTER::IsAdapterSessionized(this,p_Var7,(uint *)0x0,unaff_RBP + -0xe);

-              uStack0000000000000028 = uStack0000000000000028 & (ulonglong)param_3;

-              SMgrGdiCallout();

+              local_c8 = (HDXGMONITOR__ *)0x0;

+              uStack_50 = 0;

+              pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+              local_58 = 0xd;

+              local_48 = 0;

+              uStack_40 = 0;

+              DXGADAPTER::IsAdapterSessionized

+                        (*(DXGADAPTER **)param_2,p_Var16,(uint *)0x0,(__uint64 *)&local_c8);

+              SMgrGdiCallout(p_Var17,local_c8);

             }

-            else if (lVar3 == 0xff) {

-              unaff_RSI = 0;

+            else if (lVar8 == 0xff) {

+              uVar18 = 0;

             }

           }

         }

         else {

-          unaff_RSI = 0xc000000d;

-        }

-        if ((char)unaff_R14[6] != '\0') {

+          uVar18 = 0xc000000d;

+        }

+        pHVar12 = local_d8;

+        if (param_3[0x18] != (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0) {

           DxgkNotifyDisplayChange(0);

-        }

-        goto LAB_0;

-      }

-      if (iVar4 == -0x2c) {

-        if (*(char *)(unaff_RBP + 0xc) == '\0') {

+          pHVar12 = local_d8;

+        }

+      }

+      else if (iVar7 == -0x2c) {

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

           WdLogSingleEntry0();

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-          uStack0000000000000028 = 0;

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

           _WdLogGlobalForLineNumber = 0x17d8;

-          DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"i_bGetDeviceInfo",0x17d8);

-        }

-        if (((uStack0000000000000078 & 1) != 0) && (*(char *)(unaff_RBP + 0xe) == '\0')) {

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(unaff_R14 + 6);

-          lVar3 = MonitorGetHdrFlavor((HDXGMONITOR__ *)unaff_RBP[-0x10],

-                                      (_DISPLAYCONFIG_HDR_FLAVOR *)(unaff_R14 + 5),param_3);

-          unaff_RSI = (ulonglong)lVar3;

-          if (lVar3 < 0) {

-            param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)*(uint *)(*unaff_R15 + 0x19c);

-            WdLogSingleEntry4(3,(longlong)*(int *)(*unaff_R15 + 0x1a0));

-            _WdLogGlobalForLineNumber = 0x17ec;

-          }

-          goto LAB_0;

-        }

-      }

-      else {

-        if (iVar4 != -0x2b) {

-          if (iVar4 != -0x2d) goto LAB_0;

-          lVar3 = MonitorGetDitheringCaps

-                            ((HDXGMONITOR__ *)unaff_RBP[-0x10],

-                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)((longlong)&stack0x00000078 + 4)

-                            );

-          unaff_RSI = (ulonglong)lVar3;

-          if (lVar3 < 0) {

-            WdLogSingleEntry1(unaff_R13D,unaff_RSI);

-            _WdLogGlobalForLineNumber = 0x1811;

-            param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-            uStack0000000000000028 = 0;

-            DxgkLogInternalTriageEvent

-                      (0,0x40000,param_3,L"MonitorGetDitheringCaps() failed 0x%I64x)",unaff_RSI);

-            unaff_R14[5] = 0;

-            unaff_RSI = 0xc0000001;

-            goto LAB_0;

-          }

-          uVar8 = uStack000000000000007c >> 2;

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)uVar8;

-          uStack000000000000007c =

-               (uStack000000000000007c ^ uVar8) & 0xfc0000 ^ uStack000000000000007c;

-          uStack000000000000007c =

-               (uStack000000000000007c ^ uVar8) & 0x3f000 ^ uStack000000000000007c;

-          uStack000000000000007c = (uStack000000000000007c ^ uVar8) & 0xfc0 ^ uStack000000000000007c

-          ;

-          goto LAB_1;

-        }

-        if (*(char *)(unaff_RBP + 0xc) != '\0') {

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x17d8,0,0,0,0);

+        }

+        if (((local_e0 & 1) == 0) || (cVar2 != '\0')) goto LAB_19;

+        pDVar22 = param_3 + 0x18;

+        lVar8 = MonitorGetHdrFlavor(local_d8,(_DISPLAYCONFIG_HDR_FLAVOR *)(param_3 + 0x14),

+                                    (_DISPLAYCONFIG_HDR_FLAVOR *)pDVar22);

+        uVar18 = (ulonglong)lVar8;

+        pHVar12 = local_d8;

+        if (lVar8 < 0) {

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)

+                    (ulonglong)*(uint *)(*(longlong *)param_2 + 0x19c);

+          WdLogSingleEntry4(3,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),pDVar22,uVar20,uVar18

+                           );

+          _WdLogGlobalForLineNumber = 0x17ec;

+          pHVar12 = local_d8;

+        }

+      }

+      else if (iVar7 == -0x2b) {

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

           WdLogSingleEntry0();

-          param_3 = (_DISPLAYCONFIG_HDR_FLAVOR *)(ulonglong)unaff_R12D;

-          uStack0000000000000028 = 0;

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

           _WdLogGlobalForLineNumber = 0x17f4;

-          DxgkLogInternalTriageEvent(0,unaff_EBX,param_3,L"!i_bGetDeviceInfo",0x17f4);

-        }

-        if (((uStack0000000000000078 & 1) != 0) && (*(char *)(unaff_RBP + 0xe) == '\0')) {

-          lVar3 = MonitorSetHdrFlavor((HDXGMONITOR__ *)unaff_RBP[-0x10],unaff_R14[5]);

-          unaff_RSI = (ulonglong)lVar3;

-          if (-1 < lVar3) goto LAB_0;

-          WdLogSingleEntry4(unaff_R13D,(longlong)*(int *)(*unaff_R15 + 0x1a0),

-                            *(undefined4 *)(*unaff_R15 + 0x19c));

-          pwVar10 = 

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x17f4,0,0,0,0);

+        }

+        if (((local_e0 & 1) == 0) || (cVar2 != '\0')) goto LAB_19;

+        lVar8 = MonitorSetHdrFlavor(local_d8,*(_DISPLAYCONFIG_HDR_FLAVOR *)(param_3 + 0x14));

+        uVar18 = (ulonglong)lVar8;

+        pHVar12 = local_d8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          pwVar23 = 

           L"MonitorSetHdrFlavor() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

           ;

           _WdLogGlobalForLineNumber = 0x1807;

-          goto LAB_3;

-        }

-      }

-    }

-LAB_5:

-    unaff_RSI = 0xc00000bb;

+          uVar19 = uVar18;

+          goto LAB_16;

+        }

+      }

+      else {

+        pHVar12 = local_d8;

+        if (iVar7 == -0x2d) {

+          lVar8 = MonitorGetDitheringCaps(local_d8,(_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)&local_dc)

+          ;

+          uVar18 = (ulonglong)lVar8;

+          if (-1 < lVar8) {

+            uVar20 = local_dc >> 2;

+            pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)(ulonglong)uVar20;

+            uVar24 = (local_dc ^ uVar20) & 0xfc0000 ^ local_dc;

+            uVar24 = (uVar24 ^ uVar20) & 0x3f000 ^ uVar24;

+            uVar24 = (uVar24 ^ uVar20) & 0xfc0 ^ uVar24;

+            goto LAB_17;

+          }

+          WdLogSingleEntry1(2,uVar18);

+          _WdLogGlobalForLineNumber = 0x1811;

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,L"MonitorGetDitheringCaps() failed 0x%I64x)",uVar18,0,0,0,

+                     0);

+          *(undefined4 *)(param_3 + 0x14) = 0;

+          uVar18 = 0xc0000001;

+          pHVar12 = local_d8;

+        }

+      }

+    }

+LAB_13:

+    MonitorReleaseMonitorHandle(*(void **)param_2,pHVar12,pDVar22);

   }

-LAB_0:

-  MonitorReleaseMonitorHandle((void *)*unaff_R15,(HDXGMONITOR__ *)unaff_RBP[-0x10],param_3);

-  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)&stack0x00000058);

-  if ((in_stack_00000068 != '\0') && ((DAT_6 & 1) != 0)) {

+  else {

+    if (uVar20 < 0xffffffe0) {

+      if (uVar20 == 0xffffffdf) {

+        DpiGetAdapterMdmSupport(*(undefined8 *)(*(longlong *)param_2 + 0xd8),param_3 + 0x14);

+        goto LAB_6;

+      }

+      switch(uVar20) {

+      case 0xffffffd0:

+        iVar7 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) goto LAB_20;

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

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x19e1;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x19e1,0,0,0,0);

+        }

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+        local_78 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',

+                           DxgkDisplayConfigDeviceInfo,&local_78);

+        pHVar12 = local_78;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                            *(undefined4 *)(param_3 + 0x10),uVar18);

+          _WdLogGlobalForLineNumber = 0x19ed;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"MonitorGetMonitorHandle() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+                     ,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                     *(undefined4 *)(*(longlong *)param_2 + 0x19c),*(undefined4 *)(param_3 + 0x10),

+                     uVar18,0);

+          DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+          goto joined_r0x0001403c7547;

+        }

+        if (local_78 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x19f1;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x19f1,0,0,0,0);

+        }

+        lVar8 = MonitorGetSdrWhiteLevelWnfName(pHVar12,(ulong *)(param_3 + 0x14));

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry1(2,uVar18);

+          pwVar23 = L"Failed to call MonitorGetSdrWhiteLevelWnfName with status 0x%I64x";

+          _WdLogGlobalForLineNumber = 0x19fa;

+          goto LAB_12;

+        }

+        break;

+      case 0xffffffd1:

+        iVar7 = Feature_TargetProperties__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 != 0) {

+          uVar18 = 0xc000000d;

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

+            lVar13 = *(longlong *)(*(longlong *)(*(longlong *)param_2 + 0xc48) + 0x10);

+            pcVar1 = *(code **)(lVar13 + 0x6e0);

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

+              (*pcVar1)(0x12345678,*(undefined8 *)(lVar13 + 0x120),*(undefined4 *)(param_3 + 0x10));

+              goto LAB_6;

+            }

+            uVar18 = 0xc0000002;

+          }

+          goto LAB_7;

+        }

+LAB_20:

+        uVar18 = 0xc00000bb;

+        goto LAB_7;

+      case 0xffffffd2:

+        iVar7 = Feature_ScalarMultiplierForBrightness__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) goto switchD_1403c6b81_caseD_ffffffd9;

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',

+                           DxgkDisplayConfigDeviceInfo,&local_c8);

+        pHVar12 = local_c8;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                            *(undefined4 *)(param_3 + 0x10),uVar18);

+          _WdLogGlobalForLineNumber = 0x1997;

+          goto LAB_11;

+        }

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x199c;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x199c,0,0,0,0);

+        }

+        lVar8 = MonitorGetColorPipelineState2

+                          (pHVar12,(_DISPLAYCONFIG_COLOR_PIPELINE_STATE_2 *)param_3);

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry1(2,uVar18);

+          pwVar23 = L"Failed to call MonitorGetColorPipelineState2 with status 0x%I64x";

+          _WdLogGlobalForLineNumber = 0x19a3;

+          goto LAB_12;

+        }

+        break;

+      case 0xffffffd3:

+      case 0xffffffd4:

+      case 0xffffffd5:

+        goto switchD_1403c6b81_caseD_ffffffd3;

+      case 0xffffffd6:

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',

+                           DxgkDisplayConfigDeviceInfo,&local_c8);

+        pHVar12 = local_c8;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                            *(undefined4 *)(param_3 + 0x10),uVar18);

+          _WdLogGlobalForLineNumber = 0x19b6;

+LAB_11:

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"MonitorGetMonitorHandle() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+                     ,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                     *(undefined4 *)(*(longlong *)param_2 + 0x19c),*(undefined4 *)(param_3 + 0x10),

+                     uVar18,0);

+          DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+joined_r0x0001403c7547:

+          if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+            McTemplateK0q_EtwWriteTransfer();

+          }

+          return uVar18 & 0xffffffff;

+        }

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x19ba;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x19ba,0,0,0,0);

+        }

+        lVar8 = MonitorGetColorPipelineState(pHVar12,(_DISPLAYCONFIG_COLOR_PIPELINE_STATE *)param_3)

+        ;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry1(2,uVar18);

+          pwVar23 = L"Failed to call MonitorGetColorPipelineState with status 0x%I64x";

+          _WdLogGlobalForLineNumber = 0x19c1;

+LAB_12:

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar23,uVar18,0,0,0,0);

+        }

+        break;

+      case 0xffffffd7:

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

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x195e;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"!i_bGetDeviceInfo",0x195e,0,0,0,0);

+        }

+        uVar24 = *(uint *)(param_3 + 0x10);

+        if (*(int *)(param_3 + 0x14) == 0) {

+          DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+          if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+            McTemplateK0q_EtwWriteTransfer();

+          }

+          return 0xff;

+        }

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+        local_80 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,uVar24,'\0',DxgkDisplayConfigDeviceInfo,&local_80);

+        pHVar12 = local_80;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar24,uVar18);

+          _WdLogGlobalForLineNumber = 0x1976;

+LAB_21:

+          pwVar23 = 

+          L"MonitorGetMonitorHandle() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+          ;

+LAB_22:

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,pwVar23,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                     *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar24,uVar18,0);

+          goto LAB_7;

+        }

+        if (local_80 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x197a;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x197a,0,0,0,0);

+        }

+        uVar24 = MonitorSetDefaultAdvancedColorParams(pHVar12);

+LAB_23:

+        uVar18 = (ulonglong)uVar24;

+        break;

+      case 0xffffffd8:

+        iVar7 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) goto LAB_5;

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        MonitorGetMonitorHandle

+                  (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',DxgkDisplayConfigDeviceInfo,

+                   &local_c8);

+        pHVar12 = local_c8;

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x194c;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x194c,0,0,0,0);

+        }

+        uVar24 = MonitorSetHdrBrightnessPolicy

+                           (pHVar12,*(_DISPLAYCONFIG_HDR_BRIGHTNESS_MODE *)(param_3 + 0x14));

+        uVar18 = (ulonglong)uVar24;

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

+          TriggerHdrSdrCompensationPolicyChangedWnf();

+        }

+        break;

+      default:

+switchD_1403c6b81_caseD_ffffffd9:

+        uVar18 = 0xc000000d;

+        goto LAB_7;

+      case 0xffffffda:

+        iVar7 = Feature_DDCCIBrightnessControls__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) goto LAB_5;

+        uVar20 = *(uint *)(param_3 + 0x10);

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        uVar28 = 0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,uVar20,'\0',DxgkDisplayConfigDeviceInfo,&local_c8);

+        pHVar12 = local_c8;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          _WdLogGlobalForLineNumber = 0x1921;

+LAB_24:

+          uVar26 = *(undefined4 *)(*(longlong *)param_2 + 0x19c);

+          iVar7 = *(int *)(*(longlong *)param_2 + 0x1a0);

+          goto LAB_15;

+        }

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          uVar28 = 0xffffffff;

+          _WdLogGlobalForLineNumber = 0x1925;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x1925,0,0,0,0);

+        }

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)

+                  CONCAT71((int7)((ulonglong)uVar28 >> 8),*(int *)(param_3 + 0x14) != 0);

+        uVar24 = MonitorSetExternalBrightnessPolicy

+                           (pHVar12,*(int *)(param_3 + 0x18) != 0,*(int *)(param_3 + 0x14) != 0);

+        uVar18 = (ulonglong)uVar24;

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

+          TriggerExternalBrightnessPolicyChangedWnf();

+        }

+        break;

+      case 0xffffffdb:

+        iVar7 = Feature_ExternalBrightness__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) goto LAB_5;

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

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x18a7;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"i_bGetDeviceInfo",0x18a7,0,0,0,0);

+        }

+        uVar24 = *(uint *)(param_3 + 0x10);

+        *(undefined8 *)(param_3 + 0x14) = 0;

+        *(undefined8 *)(param_3 + 0x24) = 0;

+        *(undefined4 *)(param_3 + 0x1c) = 0;

+        pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

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

+        local_88 = (HDXGMONITOR__ *)0x0;

+        local_b8 = uVar24;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,uVar24,'\0',DxgkDisplayConfigDeviceInfo,&local_88);

+        pHVar12 = local_88;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar24,uVar18);

+          _WdLogGlobalForLineNumber = 0x18c5;

+          goto LAB_21;

+        }

+        local_d8 = local_88;

+        if (local_88 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0();

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x18c9;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x18c9,0,0,0,0);

+        }

+        local_res18 = '\0';

+        local_e4 = false;

+        local_108 = (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0;

+        local_e3 = (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0;

+        iVar7 = Feature_DDCCIBrightnessControls__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 != 0) {

+          pDVar22 = &local_e3;

+          lVar8 = MonitorGetExternalBrightnessPolicy

+                            (pHVar12,&local_e4,(bool *)pDVar22,

+                             (_DISPLAYCONFIG_EXTERNAL_BRIGHTNESS_OEM_ENABLEMENT *)(param_3 + 0x1c));

+          uVar24 = local_b8;

+          uVar18 = (ulonglong)lVar8;

+          if (lVar8 < 0) {

+            WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                              *(undefined4 *)(*(longlong *)param_2 + 0x19c),local_b8,uVar18);

+            pwVar23 = 

+            L"MonitorGetExternalBrightnessPolicy() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+            ;

+            _WdLogGlobalForLineNumber = 0x18d9;

+            goto LAB_22;

+          }

+          local_res18 = local_e4;

+          local_108 = local_e3;

+        }

+        iVar7 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 != 0) {

+          lVar8 = MonitorGetHdrBrightnessPolicy

+                            (pHVar12,(_DISPLAYCONFIG_HDR_BRIGHTNESS_MODE *)(param_3 + 0x20));

+          uVar24 = local_b8;

+          uVar18 = (ulonglong)lVar8;

+          if (lVar8 < 0) {

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

+            WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                              *(undefined4 *)(*(longlong *)param_2 + 0x19c),local_b8,uVar18);

+            pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+            _WdLogGlobalForLineNumber = 0x18ea;

+            DxgkLogInternalTriageEvent

+                      (0,0x40000,0xffffffff,

+                       L"MonitorGetHdrBrightnessPolicy() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+                       ,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                       *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar24,uVar18,0);

+            pHVar12 = local_d8;

+          }

+          *(uint *)(param_3 + 0x24) = *(uint *)(*(longlong *)param_2 + 0x9a8) >> 4 & 1;

+        }

+        *(uint *)(param_3 + 0x14) = (uint)(local_res18 != '\0');

+        *(uint *)(param_3 + 0x18) = (uint)(local_108 != (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0);

+        iVar7 = Feature_DDCCIBrightnessControls__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 != 0) {

+          *(uint *)(param_3 + 0x28) =

+               (uint)(*(longlong *)

+                       (*(longlong *)(*(longlong *)(*(longlong *)param_2 + 0xd8) + 0x40) + 0xc38) !=

+                     0);

+        }

+      }

+      goto LAB_13;

+    }

+    if (1 < uVar20 + 0x1b) {

+      if (uVar20 != 0xffffffe9) {

+        if (uVar20 == 0xffffffee) goto switchD_1403c6b81_caseD_ffffffd3;

+        if (uVar20 != 0xfffffff0) {

+          if (uVar20 != 0xfffffff4) {

+            if (uVar20 == 0xfffffff6) goto LAB_4;

+            goto switchD_1403c6b81_caseD_ffffffd9;

+          }

+          *(undefined4 *)(param_3 + 0x14) = 0;

+          uVar24 = *(uint *)(*(longlong *)param_2 + 0x9a8) >> 2 & 1;

+          *(uint *)(param_3 + 0x14) = uVar24;

+          uVar24 = *(uint *)(*(longlong *)param_2 + 0x9a8) >> 2 & 2 | uVar24;

+          *(uint *)(param_3 + 0x14) = uVar24;

+          uVar24 = *(uint *)(*(longlong *)param_2 + 0x9a8) >> 2 & 4 | uVar24;

+          *(uint *)(param_3 + 0x14) = uVar24;

+          uVar24 = (*(uint *)(*(longlong *)param_2 + 0x9a8) & 1) << 5 | uVar24;

+          *(uint *)(param_3 + 0x14) = uVar24;

+          *(uint *)(param_3 + 0x14) = (*(uint *)(*(longlong *)param_2 + 0x9a8) & 2) << 3 | uVar24;

+          goto LAB_6;

+        }

+        uVar20 = *(uint *)(param_3 + 0x10);

+        if (*(int *)((longlong)*(void **)param_2 + 0xac8) < 0x2400) goto LAB_5;

+        local_c8 = (HDXGMONITOR__ *)0x0;

+        lVar8 = MonitorGetMonitorHandle

+                          (*(void **)param_2,uVar20,'\x01',DxgkDisplayConfigDeviceInfoForAdapter,

+                           &local_c8);

+        pHVar12 = local_c8;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                            *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18);

+          _WdLogGlobalForLineNumber = 0x15a9;

+          goto LAB_24;

+        }

+        pDVar22 = param_3 + 0x1c;

+        lVar8 = MonitorSetAdvancedColorParams

+                          (local_c8,(uint *)(param_3 + 0x14),(uint *)pDVar22,

+                           (uint *)(param_3 + 0x24),(uint *)(param_3 + 0x2c),

+                           *(ulong *)(param_3 + 0x34),*(ulong *)(param_3 + 0x38),

+                           *(ulong *)(param_3 + 0x3c));

+        pvVar21 = *(void **)param_2;

+        uVar18 = (ulonglong)lVar8;

+        if (lVar8 < 0) {

+          WdLogSingleEntry4(2,(longlong)*(int *)((longlong)pvVar21 + 0x1a0),

+                            *(undefined4 *)((longlong)pvVar21 + 0x19c),uVar20,uVar18);

+          _WdLogGlobalForLineNumber = 0x15c3;

+          pvVar21 = (void *)0xffffffff;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"MonitorSetAdvancedColorParams() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+                     ,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                     *(undefined4 *)(*(longlong *)param_2 + 0x19c),uVar20,uVar18,0);

+          MonitorReleaseMonitorHandle(*(void **)param_2,pHVar12,pvVar21);

+          goto LAB_10;

+        }

+        MonitorReleaseMonitorHandle(pvVar21,pHVar12,pDVar22);

+        if (lVar8 != 0xff) {

+          uVar18 = 0xff;

+        }

+        goto LAB_7;

+      }

+LAB_14:

+      uVar5 = IsCurrentProcessAdmin();

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

+        DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+        if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

+          McTemplateK0q_EtwWriteTransfer();

+        }

+        return 0xc0000022;

+      }

+      pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0x0;

+      local_c8 = (HDXGMONITOR__ *)0x0;

+      lVar8 = MonitorGetMonitorHandle

+                        (*(void **)param_2,*(uint *)(param_3 + 0x10),'\0',

+                         DxgkDisplayConfigDeviceInfo,&local_c8);

+      pHVar12 = local_c8;

+      uVar18 = (ulonglong)lVar8;

+      if (-1 < lVar8) {

+        if (local_c8 == (HDXGMONITOR__ *)0x0) {

+          WdLogSingleEntry0(1);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x183d;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"MonitorHandle != NULL",0x183d,0,0,0,0);

+        }

+        if (*(int *)param_3 == -0x17) {

+          uVar28 = *(undefined8 *)(param_3 + 0x28);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)&local_c8;

+          uVar24 = *(uint *)(param_3 + 0x24);

+          p_Var17 = (_DXGK_IDD_VIRTUAL_MONITOR_INFO *)&local_a8;

+          ppHVar30 = (HDXGMONITOR__ **)0x0;

+          local_c8 = (HDXGMONITOR__ *)0x0;

+          uStack_c0 = 0;

+          uVar26 = *(undefined4 *)(param_3 + 0x14);

+          uVar27 = *(undefined4 *)(param_3 + 0x18);

+          uStack_a0 = *(undefined4 *)(param_3 + 0x1c);

+          uStack_9c = *(undefined4 *)(param_3 + 0x20);

+          uVar29 = 0;

+LAB_25:

+          local_a8 = (wchar_t *)CONCAT44(uVar27,uVar26);

+          uVar24 = MonitorSetAppOverride(pHVar12,p_Var17,pDVar22,uVar24,uVar28,uVar29,ppHVar30);

+          goto LAB_23;

+        }

+        if (*(int *)param_3 == 0xd) {

+          local_68[0] = 0;

+          lVar8 = RtlStringCbLengthW((ushort *)(param_3 + 0x38),0x100,local_68);

+          if ((-1 < lVar8) && (local_68[0] != 0)) {

+            local_c8 = (HDXGMONITOR__ *)0x0;

+            uStack_c0 = 0;

+            RtlInitUnicodeString(&local_c8,param_3 + 0x38);

+            local_58 = *(undefined8 *)(param_3 + 0x18);

+            uStack_50 = *(undefined8 *)(param_3 + 0x20);

+            ppHVar30 = &local_c8;

+            uVar26 = *(undefined4 *)(param_3 + 0x28);

+            uVar27 = *(undefined4 *)(param_3 + 0x2c);

+            uStack_a0 = *(undefined4 *)(param_3 + 0x30);

+            uStack_9c = *(undefined4 *)(param_3 + 0x34);

+            pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)&local_a8;

+            uVar29 = 1;

+            uVar28 = 0;

+            uVar24 = *(uint *)(param_3 + 0x14) & 1;

+            goto LAB_25;

+          }

+          WdLogSingleEntry0(2);

+          pDVar22 = (DISPLAYCONFIG_TARGET_BASE_TYPE *)0xffffffff;

+          _WdLogGlobalForLineNumber = 0x1854;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"DISPLAYCONFIG_DEVICE_INFO_SET_MONITOR_SPECIALIZATION was called with an invalid app name string."

+                     ,0x1854,0,0,0,0);

+          uVar18 = 0xc000000d;

+        }

+        goto LAB_13;

+      }

+      WdLogSingleEntry4(2,(longlong)*(int *)(*(longlong *)param_2 + 0x1a0),

+                        *(undefined4 *)(*(longlong *)param_2 + 0x19c),

+                        *(undefined4 *)(param_3 + 0x10),uVar18);

+      uVar20 = *(uint *)(param_3 + 0x10);

+      uVar26 = *(undefined4 *)(*(longlong *)param_2 + 0x19c);

+      iVar7 = *(int *)(*(longlong *)param_2 + 0x1a0);

+      _WdLogGlobalForLineNumber = 0x1839;

+LAB_15:

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"MonitorGetMonitorHandle() failed on adapter:0x%I64x%08I64x target:0x%I64x (Status = 0x%I64x)."

+                 ,(longlong)iVar7,uVar26,uVar20,uVar18,0);

+LAB_10:

+      DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+      goto joined_r0x0001403c7403;

+    }

+    if (*(uint *)(param_3 + 4) < 0x18) {

+      lVar13 = WdLogNewEntry5_WdTrace();

+      uVar18 = 0xffffffffc0000023;

+      *(ulonglong *)(lVar13 + 0x18) = (ulonglong)*(uint *)(param_3 + 4);

+      *(undefined8 *)(lVar13 + 0x20) = 0xffffffffc0000023;

+      _WdLogGlobalForLineNumber = 0x14e5;

+      DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+      goto joined_r0x0001403c7547;

+    }

+    if (uVar20 == 0xffffffe6) {

+      local_105 = (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0;

+      uVar24 = MonitorIsBoostRefreshRateEnabledByDefault

+                         (*(void **)param_2,*(uint *)(param_3 + 0x10),(bool *)&local_105);

+      uVar18 = (ulonglong)uVar24;

+      if (uVar24 == 0xc00000c0) {

+        uVar18 = 0;

+        DVar6 = (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0;

+      }

+      else {

+        DVar6 = local_105;

+        if ((int)uVar24 < 0) goto LAB_7;

+      }

+      param_3[0x14] = DVar6;

+    }

+    else {

+      uVar24 = MonitorEnableBoostRefreshRateEnabledByDefault

+                         (*(void **)param_2,*(uint *)(param_3 + 0x10),

+                          param_3[0x14] != (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0);

+      uVar18 = (ulonglong)uVar24;

+      if (uVar24 == 0xc0000016) {

+        local_a8 = (wchar_t *)((ulonglong)local_a8 & 0xffffffff00000000);

+        uVar24 = DmmGetSourceConnectedToTargetInClientVidPn

+                           (*(void **)param_2,*(uint *)(param_3 + 0x10),(uint *)&local_a8);

+        uVar18 = (ulonglong)uVar24;

+        if ((uVar24 == 0xc01e035c) || (uVar24 == 0xc01e0340)) goto LAB_6;

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

+          p_Var14 = ADAPTER_DISPLAY::GetDisplayModeInfo

+                              (*(ADAPTER_DISPLAY **)(*(longlong *)param_2 + 0xc48),(uint)local_a8);

+          if ((param_3[0x14] != (DISPLAYCONFIG_TARGET_BASE_TYPE)0x0) ||

+             (1 < *(uint *)(p_Var14 + 0x48))) {

+            uVar18 = 0xc0000016;

+          }

+        }

+      }

+    }

+  }

+LAB_7:

+  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)local_100);

+joined_r0x0001403c7403:

+  if ((local_f0 != '\0') && ((DAT_1 & 1) != 0)) {

     McTemplateK0q_EtwWriteTransfer();

   }

-  return unaff_RSI & 0xffffffff;

+  return uVar18 & 0xffffffff;

 }
```

## `DpiFdoDispatchIoctl`  (modified)

```diff
--- DpiFdoDispatchIoctl
+++ DpiFdoDispatchIoctl
@@ -1,520 +1,915 @@
 

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

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

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

 

-int DpiFdoDispatchIoctl(undefined8 param_1)

+ulonglong DpiFdoDispatchIoctl(_DEVICE_OBJECT *param_1,_IRP *param_2)

 

 {

   uint uVar1;

-  code *pcVar2;

-  _DEVICE_OBJECT *p_Var3;

-  char cVar4;

-  int iVar5;

-  int iVar6;

-  int iVar7;

-  undefined8 uVar8;

-  longlong lVar9;

-  _DXGKARG_COLLECTDIAGNOSTICINFO *p_Var10;

-  ulonglong uVar11;

-  longlong *plVar12;

-  longlong *unaff_RBX;

-  longlong unaff_RBP;

-  undefined4 unaff_ESI;

-  undefined4 unaff_EDI;

-  longlong *plVar13;

-  ulonglong uVar14;

-  char cVar15;

-  ulonglong unaff_R12;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  int unaff_R15D;

-  undefined4 uVar16;

-  undefined4 in_XMM0_Dc;

-  undefined4 in_XMM0_Dd;

-  undefined1 auStackX_8 [24];

-  char cStack0000000000000050;

-  char cStack0000000000000051;

-  char cStack0000000000000052;

-  undefined1 uStack0000000000000057;

-  char in_stack_00000058;

-  ulonglong in_stack_00000060;

-  ulonglong in_stack_00000068;

-  undefined4 uStack0000000000000070;

-  char cStack0000000000000076;

+  longlong lVar2;

+  longlong lVar3;

+  uint *puVar4;

+  ushort uVar5;

+  ushort uVar6;

+  undefined2 uVar7;

+  undefined2 uVar8;

+  undefined4 uVar9;

+  char cVar10;

+  int iVar11;

+  uint uVar12;

+  uint uVar13;

+  undefined4 uVar14;

+  ulonglong uVar15;

+  ulonglong uVar16;

+  ulonglong uVar17;

+  ulonglong uVar18;

+  undefined1 auStackY_b28 [32];

+  uint local_ae4;

+  CInterfaceCallContext local_ae0 [16];

+  undefined8 local_ad0;

+  uint local_ac0;

+  ulonglong local_ab0;

+  uint local_aa8;

+  uint local_aa4;

+  undefined8 uStack_aa0;

+  ushort uStack_a98;

+  undefined2 uStack_a96;

+  undefined4 uStack_a94;

+  undefined4 uStack_a90;

+  undefined4 uStack_a8c;

+  uint local_a88;

+  uint local_a84;

+  undefined8 local_a80;

+  undefined8 local_a78;

+  undefined8 local_a70;

+  undefined8 local_a68;

+  undefined8 local_a60;

+  undefined8 local_a58;

+  undefined8 local_a50;

+  undefined8 local_a48;

+  undefined8 local_a40;

+  undefined8 local_a38;

+  undefined8 local_a30;

+  undefined8 local_a28;

+  undefined8 local_a20;

+  undefined8 local_a18;

+  undefined8 local_a10;

+  undefined8 local_a08;

+  undefined8 local_a00;

+  undefined8 local_9f8;

+  undefined8 local_9f0;

+  undefined8 local_9e8;

+  uint local_9d8 [2];

+  longlong local_9d0;

+  undefined8 local_9c8;

+  undefined8 local_9c0;

+  undefined8 local_9b8;

+  undefined8 local_9b0;

+  undefined8 local_9a8;

+  undefined8 local_9a0;

+  undefined8 local_998;

+  undefined8 local_990;

+  undefined8 local_988;

+  undefined8 local_980;

+  undefined8 local_978;

+  ulonglong local_48;

   

-  *(int *)(unaff_RBP + 0x2f0) = (int)param_1;

-  *(int *)(unaff_RBP + 0x2f4) = (int)((ulonglong)param_1 >> 0x20);

-  *(undefined4 *)(unaff_RBP + 0x2f8) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + 0x2fc) = in_XMM0_Dd;

-  iVar5 = DpEvalAcpiMethod();

-  if (iVar5 < 0) {

-    WdLogSingleEntry1(unaff_R15D,(longlong)iVar5);

-    _WdLogGlobalForLineNumber = 0x4f1;

-  }

-  else {

-    *(undefined4 *)((longlong)unaff_RBX + 0x464) = *(undefined4 *)(unaff_RBP + 0x2f0);

-    *(undefined4 *)(unaff_RBX + 0x8d) = *(undefined4 *)(unaff_RBP + 0x2f4);

-  }

-  *(undefined4 *)(unaff_RBP + 0x300) = 0;

-  *(undefined4 *)(unaff_RBP + 0xd0) = unaff_EDI;

-  *(undefined8 *)(unaff_RBP + 0xd4) = 0x4255535f;

-  iVar7 = (int)unaff_R12;

-  *(int *)(unaff_RBP + 0xdc) = iVar7;

-  *(undefined8 *)(unaff_RBP + 0x2e0) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2e8) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2f0) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2f8) = 0;

-  iVar5 = DpEvalAcpiMethod(in_stack_00000060,unaff_ESI,unaff_RBP + 0xd0,0x18,unaff_RBP + 0x2e0);

-  if (iVar5 < 0) {

-    WdLogSingleEntry1(4,DpEvalAcpiMethod);

-    _WdLogGlobalForLineNumber = 0x513;

-  }

-  else {

-    *(undefined4 *)((longlong)unaff_RBX + 0x46c) = *(undefined4 *)(unaff_RBP + 0x2f0);

-    *(undefined4 *)(unaff_RBX + 0x8e) = *(undefined4 *)(unaff_RBP + 0x2f4);

-  }

-  *(undefined4 *)(unaff_RBP + 0x300) = 0;

-  *(undefined4 *)(unaff_RBP + 0xd0) = unaff_EDI;

-  *(undefined8 *)(unaff_RBP + 0xd4) = 0x5652485f;

-  *(int *)(unaff_RBP + 0xdc) = iVar7;

-  *(undefined8 *)(unaff_RBP + 0x2e0) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2e8) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2f0) = 0;

-  *(undefined8 *)(unaff_RBP + 0x2f8) = 0;

-  iVar5 = DpEvalAcpiMethod(in_stack_00000060,unaff_ESI,unaff_RBP + 0xd0,0x18,unaff_RBP + 0x2e0);

-  if (iVar5 < 0) {

-    WdLogSingleEntry1(4,DpEvalAcpiMethod);

-    _WdLogGlobalForLineNumber = 0x535;

-    iVar5 = iVar7;

-  }

-  else {

-    *(uint *)((longlong)unaff_RBX + 0x474) = (uint)*(ushort *)(unaff_RBP + 0x2f0);

-  }

-  cVar15 = (char)unaff_R12;

-  if (cStack0000000000000051 != cVar15) {

-    uVar8 = IoGetAttachedDeviceReference(*(undefined8 *)(unaff_RBP + -0x80));

-    iVar5 = DpiSetDeviceUsageType(uVar8,5);

-    ObfDereferenceObject(uVar8);

-    if (iVar5 < 0) {

-      WdLogSingleEntry1(unaff_R15D,(longlong)iVar5);

-      _WdLogGlobalForLineNumber = 0x551;

-      iVar5 = iVar7;

+  local_48 = __security_cookie ^ (ulonglong)auStackY_b28;

+  lVar2 = *(longlong *)(param_2 + 0xb8);

+  uVar15 = 0;

+  uVar16 = 0;

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

+  local_ab0 = 0;

+  uVar12 = *(uint *)(lVar2 + 8);

+  uVar13 = *(uint *)(lVar2 + 0x10);

+  uVar1 = *(uint *)(lVar2 + 0x18);

+  local_ae4 = uVar13;

+  if ((*(char *)(lVar3 + 0x486) == '\0') ||

+     ((*(char *)(lVar3 + 0x487) != '\0' && (uVar1 == 0x23cc04)))) {

+    iVar11 = Feature_Servicing_MSRC106447__private_IsEnabledDeviceUsageNoInline();

+    if ((iVar11 != 0) && (uVar1 - 0x226444 < 0x55)) {

+      iVar11 = DpiFdoGetVirtualGpuType(param_2);

+      if (iVar11 == 0) {

+        cVar10 = *(char *)(*(longlong *)(param_1 + 0x40) + 0x1418);

+      }

+      else {

+        cVar10 = *(longlong *)(lVar3 + 0xb58) != 0;

+      }

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

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0xf40;

+        uVar16 = uVar15;

+        goto LAB_0;

+      }

     }

-  }

-  if ((*(char *)((longlong)unaff_RBX + 0xa9c) != cVar15) &&

-     (*(char *)((longlong)unaff_RBX + 0xa9d) != cVar15)) {

-    iVar5 = -0x3ffffff3;

-    uVar16 = WdLogSingleEntry1(unaff_R15D,0xffffffffc000000d);

-    _WdLogGlobalForLineNumber = 0x73b;

-    goto LAB_0;

-  }

-  KeInitializeSpinLock(unaff_RBX + 0xb8);

-  plVar12 = unaff_RBX + 0xa7;

-  *(undefined2 *)(unaff_RBX + 0xa5) = 0x40;

-  uVar14 = 7;

-  if (((ulonglong)plVar12 & 4) != 0) {

-    *(undefined4 *)plVar12 = 1;

-    uVar14 = 6;

-    plVar12 = (longlong *)((longlong)unaff_RBX + 0x53c);

-  }

-  plVar13 = plVar12;

-  for (uVar11 = uVar14 >> 1; uVar11 != 0; uVar11 = uVar11 - 1) {

-    *plVar13 = 0x100000001;

-    plVar13 = plVar13 + 1;

-  }

-  if ((uVar14 & 1) != 0) {

-    *(undefined4 *)((longlong)plVar12 + uVar14 * 4 + -4) = 1;

-  }

-  KeInitializeDpc(unaff_RBX + 0xb0,DpiFdoDpcForIsr,in_stack_00000060);

-  KeInitializeMutex(unaff_RBX + 0x13e,0);

-  KeInitializeMutex(unaff_RBX + 0x148,0);

-  plVar12 = unaff_RBX + 0x13c;

-  unaff_RBX[0x13d] = (longlong)plVar12;

-  *plVar12 = (longlong)plVar12;

-  plVar12 = unaff_RBX + 0x146;

-  unaff_RBX[0x147] = (longlong)plVar12;

-  *plVar12 = (longlong)plVar12;

-  plVar12 = unaff_RBX + 0x155;

-  unaff_RBX[0x156] = (longlong)plVar12;

-  *plVar12 = (longlong)plVar12;

-  KeInitializeEvent(unaff_RBX + 0x9b,0,1);

-  KeInitializeEvent(unaff_RBX + 0x9e,0,1);

-  KeInitializeEvent(unaff_RBX + 0xa1,0,0);

-  unaff_RBX[0x99] = unaff_R12;

-  *(undefined4 *)(unaff_RBX + 0x92) = 1;

-  unaff_RBX[0x93] = unaff_R12;

-  *(int *)(unaff_RBX + 0x94) = iVar7;

-  KeInitializeEvent(unaff_RBX + 0x95,1,0);

-  *(undefined4 *)((longlong)unaff_RBX + 0xabc) = 0x11007;

-  if ((int)unaff_RBX[2] == 0x74727044) {

-    if (*(int *)((longlong)unaff_RBX + 0x14) == unaff_R15D) {

-      iVar5 = DpiFdoInitializeFdo(in_stack_00000060);

-      if (iVar5 < 0) {

-        uVar16 = WdLogSingleEntry1(unaff_R15D,(longlong)iVar5);

-        _WdLogGlobalForLineNumber = 0x777;

-        goto LAB_0;

-      }

+    uVar14 = uStack_a94;

+    uVar7 = uStack_a96;

+    uVar5 = uStack_a98;

+    puVar4 = *(uint **)(param_2 + 0x18);

+    uVar17 = uVar16;

+    if (uVar1 < 0x22646d) {

+      if (uVar1 != 0x22646c) {

+        uStack_a98 = (ushort)puVar4;

+        uVar6 = uStack_a98;

+        uStack_a96 = (undefined2)((ulonglong)puVar4 >> 0x10);

+        uVar8 = uStack_a96;

+        uStack_a94 = (undefined4)((ulonglong)puVar4 >> 0x20);

+        uVar9 = uStack_a94;

+        uStack_a98 = uVar5;

+        uStack_a96 = uVar7;

+        uStack_a94 = uVar14;

+        if (uVar1 < 0x226449) {

+          if (uVar1 == 0x226448) {

+            if (((1 < uVar13) && (puVar4 != (uint *)0x0)) && (uVar15 = 0xa8, 0xa7 < uVar12)) {

+              CInterfaceCallContext::CInterfaceCallContext

+                        (local_ae0,param_1,param_2,'\x01','\0','\0');

+              uVar13 = local_ac0;

+              uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                memset(&local_a84,0,0xa4);

+                local_a88 = (uint)(ushort)*puVar4;

+                uVar13 = DxgkDdiGetVirtualGpuProfile

+                                   (*(undefined8 *)(lVar3 + 0xfc0),uVar14,&local_a88);

+                uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                  *puVar4 = local_a88;

+                  puVar4[1] = local_a84;

+                  *(undefined8 *)(puVar4 + 2) = local_a80;

+                  *(undefined8 *)(puVar4 + 4) = local_a78;

+                  *(undefined8 *)(puVar4 + 6) = local_a70;

+                  *(undefined8 *)(puVar4 + 8) = local_a68;

+                  *(undefined8 *)(puVar4 + 10) = local_a60;

+                  *(undefined8 *)(puVar4 + 0xc) = local_a58;

+                  *(undefined8 *)(puVar4 + 0xe) = local_a50;

+                  *(undefined8 *)(puVar4 + 0x10) = local_a48;

+                  *(undefined8 *)(puVar4 + 0x12) = local_a40;

+                  *(undefined8 *)(puVar4 + 0x14) = local_a38;

+                  *(undefined8 *)(puVar4 + 0x16) = local_a30;

+                  *(undefined8 *)(puVar4 + 0x18) = local_a28;

+                  *(undefined8 *)(puVar4 + 0x1a) = local_a20;

+                  *(undefined8 *)(puVar4 + 0x1c) = local_a18;

+                  *(undefined8 *)(puVar4 + 0x1e) = local_a10;

+                  *(undefined8 *)(puVar4 + 0x20) = local_a08;

+                  *(undefined8 *)(puVar4 + 0x22) = local_a00;

+                  *(undefined8 *)(puVar4 + 0x24) = local_9f8;

+                  *(undefined8 *)(puVar4 + 0x26) = local_9f0;

+                  *(undefined8 *)(puVar4 + 0x28) = local_9e8;

+LAB_1:

+                  uVar17 = uVar15;

+                  uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

+                }

+              }

+              goto LAB_2;

+            }

+            uVar13 = 0xc0000023;

+            WdLogSingleEntry1(2);

+            _WdLogGlobalForLineNumber = 0xfae;

+          }

+          else {

+            if (uVar1 == 0x226044) {

+              uVar13 = DpiSriovNotification(param_1,param_2,puVar4,uVar12);

+            }

+            else if (uVar1 == 0x226048) {

+              if ((param_2[0x40] != (_IRP)0x0) &&

+                 (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 == '\0')) {

+                uVar13 = 0xc0000022;

+                WdLogSingleEntry1(2,0xffffffffc0000022);

+                _WdLogGlobalForLineNumber = 0x114a;

+                goto LAB_0;

+              }

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DpiSriovEventComplete(param_1,uVar14,puVar4,uVar13);

+            }

+            else {

+              if (uVar1 != 0x22604c) {

+                if (uVar1 == 0x226050) {

+                  if ((param_2[0x40] == (_IRP)0x0) ||

+                     (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 != '\0')

+                     ) {

+                    uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                    uVar13 = DpiSriovDetach(param_1,uVar14);

+                    goto LAB_3;

+                  }

+                  uVar13 = 0xc0000022;

+                  WdLogSingleEntry1(2,0xffffffffc0000022);

+                  _WdLogGlobalForLineNumber = 0x113b;

+                }

+                else if (uVar1 == 0x226054) {

+                  uVar13 = 0xc00000bb;

+                }

+                else if (uVar1 == 0x226058) {

+                  if ((param_2[0x40] == (_IRP)0x0) ||

+                     (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 != '\0')

+                     ) {

+                    if ((uVar13 < 2) || ((puVar4 == (uint *)0x0 || (uVar12 < 0x18)))) {

+                      uVar13 = 0xc0000023;

+                      WdLogSingleEntry1(2);

+                      _WdLogGlobalForLineNumber = 0x10e0;

+                      uVar16 = uVar15;

+                      goto LAB_4;

+                    }

+                    CInterfaceCallContext::CInterfaceCallContext

+                              (local_ae0,param_1,param_2,'\x01','\0','\0');

+                    uVar13 = local_ac0;

+                    uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                      uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                      local_aa8 = (uint)(ushort)*puVar4;

+                      local_aa4 = 0;

+                      uStack_aa0._0_4_ = 0;

+                      uStack_aa0._4_4_ = 0;

+                      uStack_a98 = 0;

+                      uStack_a96 = 0;

+                      uStack_a94 = 0;

+                      uStack_a90 = 0;

+                      uVar13 = DxgkDdiQueryMitigatedRangeCount

+                                         (*(undefined8 *)(lVar3 + 0xfc0),uVar14,&local_aa8);

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

+                        *(ulonglong *)puVar4 = CONCAT44((uint)uStack_aa0,local_aa4);

+                        *(ulonglong *)(puVar4 + 2) =

+                             CONCAT26(uStack_a96,CONCAT24(uStack_a98,uStack_aa0._4_4_));

+                        *(ulonglong *)(puVar4 + 4) = CONCAT44(uStack_a90,uStack_a94);

+LAB_5:

+                        uVar17 = 0x18;

+                      }

+                    }

+                    goto LAB_2;

+                  }

+                  uVar13 = 0xc0000022;

+                  WdLogSingleEntry1(2,0xffffffffc0000022);

+                  _WdLogGlobalForLineNumber = 0x10d5;

+                }

+                else {

+                  if (uVar1 != 0x22605c) {

+                    if (uVar1 != 0x226444) goto LAB_6;

+                    CInterfaceCallContext::CInterfaceCallContext

+                              (local_ae0,param_1,param_2,'\x01','\0','\0');

+                    uVar17 = uVar15;

+                    uVar13 = local_ac0;

+                    uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                      local_aa4 = 0;

+                      uStack_a98 = 0;

+                      uStack_a96 = 0;

+                      uStack_a94 = 0;

+                      if ((puVar4 == (uint *)0x0) || (uVar12 < 0x18)) {

+                        WdLogSingleEntry1(3,0x226444);

+                        _WdLogGlobalForLineNumber = 0xf5c;

+                        uVar13 = 0xc0000023;

+LAB_7:

+                        CInterfaceCallContext::~CInterfaceCallContext(local_ae0);

+                        uVar16 = uVar15;

+                        goto LAB_0;

+                      }

+                      local_ae4 = DpiFdoGetVirtualGpuType(param_2);

+                      uVar12 = uVar12 - 0x14 >> 1;

+                      uStack_aa0 = puVar4 + 5;

+                      local_aa8 = uVar12;

+                      uVar13 = DxgkDdiGetGpuPartitionInfo

+                                         (*(undefined8 *)(lVar3 + 0xfc0),local_ae4,&local_aa8);

+                      if ((int)uVar13 < 0) {

+                        if (uVar13 == 0xc0000023) {

+                          if (local_aa8 != 0) {

+                            *puVar4 = local_aa8;

+                            uVar13 = 0x80000005;

+                            *(ushort *)(puVar4 + 3) = uStack_a98;

+                            cVar10 = DpiFdoIsPostDevice(param_1);

+                            puVar4[4] = (uint)(cVar10 != '\0') | puVar4[4] & 0xfffffffe;

+                            RtlCopyLuid(puVar4 + 1,lVar3 + 0xa88);

+                            goto LAB_5;

+                          }

+                          WdLogSingleEntry1(3,0x226444);

+                          _WdLogGlobalForLineNumber = 0xf8d;

+                          uVar17 = uVar16;

+                          uVar13 = 0xc000000d;

+                        }

+                      }

+                      else {

+                        if ((g_LimitNumberOfVfs != 0) && (local_aa8 != 0)) {

+                          local_aa8 = 1;

+                          *(ushort *)uStack_aa0 = 1;

+                          uStack_a98 = 1;

+                        }

+                        if ((uVar12 < local_aa8) || (local_aa8 == 0)) {

+                          WdLogSingleEntry1(3,0x226444);

+                          _WdLogGlobalForLineNumber = 0xf75;

+                          uVar13 = 0xc000000d;

+                          goto LAB_7;

+                        }

+                        *puVar4 = local_aa8;

+                        *(ushort *)(puVar4 + 3) = uStack_a98;

+                        cVar10 = DpiFdoIsPostDevice(param_1);

+                        puVar4[4] = (uint)(cVar10 != '\0') | puVar4[4] & 0xfffffffe;

+                        DxgkDdiQueryPhysicalFunctionLuid

+                                  (*(undefined8 *)(lVar3 + 0xfc0),local_ae4,puVar4 + 1);

+                        uVar17 = (ulonglong)(local_aa8 * 2 + 0x14);

+                      }

+                    }

+LAB_2:

+                    CInterfaceCallContext::~CInterfaceCallContext(local_ae0);

+                    uVar16 = uVar17;

+                    goto LAB_4;

+                  }

+                  if ((param_2[0x40] == (_IRP)0x0) ||

+                     (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 != '\0')

+                     ) {

+                    if ((uVar13 < 4) || ((puVar4 == (uint *)0x0 || (uVar12 < 0x10)))) {

+                      uVar13 = 0xc0000023;

+                      WdLogSingleEntry1(2);

+                      _WdLogGlobalForLineNumber = 0x110a;

+                      uVar16 = uVar15;

+                      goto LAB_4;

+                    }

+                    CInterfaceCallContext::CInterfaceCallContext

+                              (local_ae0,param_1,param_2,'\x01','\0','\0');

+                    uVar13 = local_ac0;

+                    uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                      uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                      uVar15 = (ulonglong)uVar12;

+                      local_aa8 = (uint)(ushort)*puVar4;

+                      local_aa4 = (uint)*(byte *)((longlong)puVar4 + 2);

+                      uStack_aa0._0_4_ = uVar12 >> 4;

+                      uStack_aa0._4_4_ = 0;

+                      uStack_a98 = uVar6;

+                      uStack_a96 = uVar8;

+                      uStack_a94 = uVar9;

+                      uVar13 = DxgkDdiQueryMitigatedRanges

+                                         (*(undefined8 *)(lVar3 + 0xfc0),uVar14,&local_aa8);

+                      uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

+                      if (-1 < (int)uVar13) goto LAB_1;

+                    }

+                    goto LAB_2;

+                  }

+                  uVar13 = 0xc0000022;

+                  WdLogSingleEntry1(2,0xffffffffc0000022);

+                  _WdLogGlobalForLineNumber = 0x10ff;

+                }

+                goto LAB_0;

+              }

+              uVar13 = DpiSriovAttach(param_1,param_2);

+            }

+LAB_3:

+            uVar16 = uVar15;

+          }

+        }

+        else if (uVar1 == 0x22644c) {

+          if ((param_2[0x40] != (_IRP)0x0) &&

+             (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 == '\0')) {

+            uVar13 = 0xc0000022;

+            WdLogSingleEntry1(2,0xffffffffc0000022);

+            _WdLogGlobalForLineNumber = 0xfe5;

+            goto LAB_0;

+          }

+          if ((1 < uVar13) && (puVar4 != (uint *)0x0)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              local_ae4 = (uint)(ushort)*puVar4;

+              uVar13 = DxgkDdiSetGpuPartitionCount(*(undefined8 *)(lVar3 + 0xfc0),uVar14,&local_ae4)

+              ;

+              goto LAB_8;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0xff0;

+        }

+        else if (uVar1 == 0x226454) {

+          if ((param_2[0x40] != (_IRP)0x0) &&

+             (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 == '\0')) {

+            uVar13 = 0xc0000022;

+            WdLogSingleEntry1(2,0xffffffffc0000022);

+            _WdLogGlobalForLineNumber = 0x1008;

+            goto LAB_0;

+          }

+          if (((0x77 < uVar13) && (puVar4 != (uint *)0x0)) && (0x87 < uVar12)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\0','\0','\x01')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              lVar2 = *(longlong *)(puVar4 + 4);

+              if (((lVar2 == 0) && (*(longlong *)(puVar4 + 6) == 0)) &&

+                 (*(longlong *)(puVar4 + 8) == 0)) {

+                local_ae4 = (uint)(ushort)*puVar4;

+                uVar13 = DxgkDdiDestroyVirtualGpu(local_ad0,uVar14,&local_ae4,1);

+                goto LAB_8;

+              }

+              memset(local_9d8,0,0x990);

+              local_9d8[0] = (uint)(ushort)*puVar4;

+              local_9c8 = *(undefined8 *)(puVar4 + 6);

+              local_9c0 = *(undefined8 *)(puVar4 + 8);

+              local_9b8 = *(undefined8 *)(puVar4 + 10);

+              local_9b0 = *(undefined8 *)(puVar4 + 0xc);

+              local_9a8 = *(undefined8 *)(puVar4 + 0xe);

+              local_9a0 = *(undefined8 *)(puVar4 + 0x10);

+              local_998 = *(undefined8 *)(puVar4 + 0x12);

+              local_990 = *(undefined8 *)(puVar4 + 0x14);

+              local_988 = *(undefined8 *)(puVar4 + 0x16);

+              local_980 = *(undefined8 *)(puVar4 + 0x18);

+              local_978 = *(undefined8 *)(puVar4 + 0x1a);

+              local_9d0 = lVar2;

+              uVar13 = DxgkDdiCreateVirtualGpu

+                                 (local_ad0,uVar14,(char)puVar4[0x1c] == '\0',

+                                  *(char *)((longlong)puVar4 + 0x71) != '\0');

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

+                memset(&local_a84,0,100);

+                local_a88 = local_9d8[0];

+                uVar13 = DxgkDdiGetVirtualGpuInfo(local_ad0,uVar14,&local_a88,puVar4 + 3);

+                if ((int)uVar13 < 0) {

+                  local_ae4 = local_9d8[0];

+                  DxgkDdiDestroyVirtualGpu(local_ad0,uVar14,&local_ae4,1);

+                }

+                else {

+                  *(ushort *)(puVar4 + 2) = (ushort)local_9d8[0];

+                  *(undefined8 *)(puVar4 + 10) = local_a80;

+                  *(undefined8 *)(puVar4 + 0xc) = local_a78;

+                  *(undefined8 *)(puVar4 + 0xe) = local_a70;

+                  *(undefined8 *)(puVar4 + 0x10) = local_a68;

+                  *(undefined8 *)(puVar4 + 0x12) = local_a60;

+                  *(undefined8 *)(puVar4 + 0x14) = local_a58;

+                  *(undefined8 *)(puVar4 + 0x16) = local_a50;

+                  *(undefined8 *)(puVar4 + 0x18) = local_a48;

+                  *(undefined8 *)(puVar4 + 0x1a) = local_a40;

+                  *(undefined8 *)(puVar4 + 0x1c) = local_a38;

+                  *(undefined8 *)(puVar4 + 0x1e) = local_a30;

+                  *(undefined8 *)(puVar4 + 0x20) = local_a28;

+                  uVar17 = 0x88;

+                }

+              }

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1015;

+        }

+        else if (uVar1 == 0x226458) {

+          if (((1 < uVar13) && (puVar4 != (uint *)0x0)) && (uVar15 = 0x80, 0x7f < uVar12)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              memset(&local_a84,0,100);

+              local_a88 = (uint)(ushort)*puVar4;

+              uVar13 = DxgkDdiGetVirtualGpuInfo

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,&local_a88,puVar4 + 1);

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

+                *(ushort *)puVar4 = (ushort)local_a88;

+                *(undefined8 *)(puVar4 + 8) = local_a80;

+                *(undefined8 *)(puVar4 + 10) = local_a78;

+                *(undefined8 *)(puVar4 + 0xc) = local_a70;

+                *(undefined8 *)(puVar4 + 0xe) = local_a68;

+                *(undefined8 *)(puVar4 + 0x10) = local_a60;

+                *(undefined8 *)(puVar4 + 0x12) = local_a58;

+                *(undefined8 *)(puVar4 + 0x14) = local_a50;

+                *(undefined8 *)(puVar4 + 0x16) = local_a48;

+                *(undefined8 *)(puVar4 + 0x18) = local_a40;

+                *(undefined8 *)(puVar4 + 0x1a) = local_a38;

+                *(undefined8 *)(puVar4 + 0x1c) = local_a30;

+                *(undefined8 *)(puVar4 + 0x1e) = local_a28;

+                goto LAB_1;

+              }

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1082;

+        }

+        else {

+          if (uVar1 == 0x22645c) {

+            uVar13 = DpiSetPartitionVmbus(param_1,param_2,puVar4,uVar13);

+            goto LAB_3;

+          }

+          if (uVar1 != 0x226460) {

+            if (uVar1 == 0x226464) {

+              Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+              if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+                if (((0xb < uVar13) && (puVar4 != (uint *)0x0)) && (0x1f < uVar12)) {

+                  CInterfaceCallContext::CInterfaceCallContext

+                            (local_ae0,param_1,param_2,'\0','\0','\x01');

+                  uVar13 = local_ac0;

+                  uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                    uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                    uVar12 = (uVar12 - 8) / 0x18;

+                    uVar13 = DxgkDdiPrepareLiveMigration(local_ad0,uVar14,puVar4,puVar4[2]);

+                    *puVar4 = uVar12;

+                    uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                      uVar17 = (ulonglong)uVar12 * 0x18 + 8;

+                      uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

+                    }

+                  }

+                  goto LAB_2;

+                }

+                uVar13 = 0xc0000023;

+                WdLogSingleEntry1(2);

+                _WdLogGlobalForLineNumber = 0x1189;

+                goto LAB_4;

+              }

+              uVar13 = 0xc00000bb;

+              WdLogSingleEntry1(2);

+              _WdLogGlobalForLineNumber = 0x117e;

+            }

+            else {

+              if (uVar1 != 0x226468) goto LAB_6;

+              Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+              if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+                if ((0x17 < uVar13) && (puVar4 != (uint *)0x0)) {

+                  CInterfaceCallContext::CInterfaceCallContext

+                            (local_ae0,param_1,param_2,'\x01','\0','\0');

+                  uVar13 = local_ac0;

+                  uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                    uVar14 = DpiFdoGetVirtualGpuType(param_2);

+                    uVar13 = DxgkDdiSaveImmutableMigrationData

+                                       (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,

+                                        *(undefined8 *)(puVar4 + 2));

+                    goto LAB_8;

+                  }

+                  goto LAB_2;

+                }

+                uVar13 = 0xc0000023;

+                WdLogSingleEntry1(2);

+                _WdLogGlobalForLineNumber = 0x11bb;

+                goto LAB_4;

+              }

+              uVar13 = 0xc00000bb;

+              WdLogSingleEntry1(2);

+              _WdLogGlobalForLineNumber = 0x11b2;

+            }

+            goto LAB_0;

+          }

+          if ((7 < uVar13) && (puVar4 != (uint *)0x0)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\0','\x01','\0')

+            ;

+            uVar13 = local_ac0;

+            uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              local_aa4 = local_ae4;

+              local_aa8 = 0;

+              uStack_aa0._4_4_ = 0;

+              uStack_a90 = SUB84(puVar4,0);

+              uStack_aa0._0_4_ = uVar12;

+              uStack_a98 = uVar6;

+              uStack_a96 = uVar8;

+              uStack_a94 = uVar9;

+              uStack_a8c = uVar9;

+              uVar13 = DxgkDdiVirtualGpuDriverEscape

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,&local_aa8);

+              uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

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

+                uVar17 = (ulonglong)(uint)uStack_aa0;

+                uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

+              }

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x10b6;

+        }

+        goto LAB_4;

+      }

+      Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+      if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+        if ((0x17 < uVar13) && (puVar4 != (uint *)0x0)) {

+          CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0');

+          uVar13 = local_ac0;

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

+            uVar14 = DpiFdoGetVirtualGpuType(param_2);

+            uVar13 = DxgkDdiRestoreImmutableMigrationData

+                               (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,

+                                *(undefined8 *)(puVar4 + 2));

+            uVar15 = uVar16;

+            goto LAB_8;

+          }

+          goto LAB_2;

+        }

+        uVar13 = 0xc0000023;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x11dd;

+        goto LAB_4;

+      }

+      uVar13 = 0xc00000bb;

+      WdLogSingleEntry1(2);

+      _WdLogGlobalForLineNumber = 0x11d4;

     }

-    else if (*(int *)((longlong)unaff_RBX + 0x14) == 3) {

-      *(code **)(*(longlong *)(in_stack_00000060 + 0x40) + 0x158) = DpiLdaHandleQueryDeviceRelations

-      ;

-      iVar5 = iVar7;

+    else if (uVar1 < 0x22648d) {

+      if (uVar1 == 0x22648c) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if ((7 < uVar13) && (puVar4 != (uint *)0x0)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkDdiEndLiveMigration(*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4);

+              uVar15 = uVar16;

+LAB_8:

+              uVar17 = uVar15;

+              uStack_aa0 = (uint *)CONCAT44(uStack_aa0._4_4_,(uint)uStack_aa0);

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x131d;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1314;

+      }

+      else if (uVar1 == 0x226470) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if (((0xb < uVar13) && (puVar4 != (uint *)0x0)) && (3 < uVar12)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkDdiGetDirtyBitplane

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,puVar4[2]);

+              *puVar4 = uVar13;

+              uVar15 = 4;

+              goto LAB_8;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1246;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x123b;

+      }

+      else if (uVar1 == 0x226474) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if (((0xb < uVar13) && (puVar4 != (uint *)0x0)) && (uVar18 = 0x10, 0xf < uVar12)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkFillBufferWithDirty

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,puVar4[2]);

+              puVar4[2] = uVar13;

+LAB_9:

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

+                uVar15 = uVar18;

+              }

+              goto LAB_8;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1294;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1289;

+      }

+      else if (uVar1 == 0x226478) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if ((0xf < uVar13) && (puVar4 != (uint *)0x0)) {

+LAB_10:

+            uVar13 = DpiLiveMigrationWaitForFence

+                               (param_1,param_2,puVar4,*(undefined8 *)(puVar4 + 2));

+            goto LAB_3;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x12bc;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x12b3;

+      }

+      else if (uVar1 == 0x22647c) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if (((0xb < uVar13) && (puVar4 != (uint *)0x0)) && (uVar18 = 8, 7 < uVar12)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkSendDirtyToVRAM(*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,puVar4[2]);

+              goto LAB_9;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x12da;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x12cf;

+      }

+      else if (uVar1 == 0x226480) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if ((0xf < uVar13) && (puVar4 != (uint *)0x0)) goto LAB_10;

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1301;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x12f8;

+      }

+      else if (uVar1 == 0x226484) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if ((0x17 < uVar13) && (puVar4 != (uint *)0x0)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkDdiSaveMutableMigrationData

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,

+                                  *(undefined8 *)(puVar4 + 2));

+              uVar15 = uVar16;

+              goto LAB_8;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1200;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x11f7;

+      }

+      else {

+        if (uVar1 != 0x226488) goto LAB_6;

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) != 0) {

+          if ((0x17 < uVar13) && (puVar4 != (uint *)0x0)) {

+            CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0')

+            ;

+            uVar13 = local_ac0;

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

+              uVar14 = DpiFdoGetVirtualGpuType(param_2);

+              uVar13 = DxgkDdiRestoreMutableMigrationData

+                                 (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,

+                                  *(undefined8 *)(puVar4 + 2));

+              uVar15 = uVar16;

+              goto LAB_8;

+            }

+            goto LAB_2;

+          }

+          uVar13 = 0xc0000023;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1222;

+          goto LAB_4;

+        }

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1219;

+      }

     }

-  }

-  *(undefined1 *)((longlong)unaff_RBX + 0x39) = uStack0000000000000057;

-  KeWaitForSingleObject(unaff_R13 + 0x48,0,0,0);

-  in_stack_00000058 = '\x01';

-  if ((unaff_R14 == 0) || (*(int *)(unaff_R14 + 0x1f8) == iVar7)) {

-LAB_1:

-    plVar12 = *(longlong **)(unaff_R13 + 0x40);

-    if (*plVar12 == unaff_R13 + 0x38) {

-      *unaff_RBX = unaff_R13 + 0x38;

-      unaff_RBX[1] = (longlong)plVar12;

-      *plVar12 = (longlong)unaff_RBX;

-      *(longlong **)(unaff_R13 + 0x40) = unaff_RBX;

-      *(int *)(unaff_R13 + 0x80) = *(int *)(unaff_R13 + 0x80) + 1;

-      cStack0000000000000076 = '\x01';

-      if (unaff_RBX[0x15] == unaff_R12) {

-        lVar9 = ExAllocatePool2(0x40,0x70,0x74727044);

-        unaff_RBX[0x15] = lVar9;

-        if (lVar9 == 0) {

-          iVar5 = -0x3fffffe9;

-          uVar16 = WdLogSingleEntry1(6);

-          _WdLogGlobalForLineNumber = 0x7d1;

-        }

-        else {

-          *(undefined4 *)(lVar9 + 0x68) = 1;

-          *(char *)(unaff_RBX[0x15] + 0x6c) = cVar15;

-          iVar5 = ExInitializeResourceLite(unaff_RBX[0x15]);

-          if (-1 < iVar5) {

-            cStack0000000000000050 = '\x01';

-            goto LAB_2;

-          }

-          uVar16 = WdLogSingleEntry1(unaff_R15D,(longlong)iVar5);

-          _WdLogGlobalForLineNumber = 0x7df;

-        }

+    else if (uVar1 == 0x226490) {

+      Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+      if ((*(uint *)(lVar3 + 0x15d8) & 4) == 0) {

+        uVar13 = 0xc00000bb;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1334;

       }

       else {

-LAB_2:

-        KeInitializeMutex(unaff_RBX + 0x16);

-        if (unaff_R14 != 0) {

-          if (*(ulonglong *)(unaff_R14 + 0x5c8) == unaff_R12) {

-            lVar9 = ExAllocatePool2(0x40,0x10,0x74727044);

-            *(longlong *)(unaff_R14 + 0x5c8) = lVar9;

-            if (lVar9 == 0) {

-              iVar5 = -0x3fffffe9;

-              uVar16 = WdLogSingleEntry1(6);

-              _WdLogGlobalForLineNumber = 0x7fb;

-              goto LAB_3;

-            }

-            *(undefined4 *)(lVar9 + 8) = 1;

-            KeInitializeSpinLock(*(undefined8 *)(unaff_R14 + 0x5c8));

-          }

-          if (*(ulonglong *)(unaff_R14 + 0x5d0) == unaff_R12) {

-            lVar9 = ExAllocatePool2(0x40,0x10,0x74727044);

-            *(longlong *)(unaff_R14 + 0x5d0) = lVar9;

-            if (lVar9 == 0) {

-              iVar5 = -0x3fffffe9;

-              uVar16 = WdLogSingleEntry1(6);

-              _WdLogGlobalForLineNumber = 0x811;

-              goto LAB_3;

-            }

-            *(undefined4 *)(lVar9 + 8) = 1;

-            KeInitializeSpinLock(*(undefined8 *)(unaff_R14 + 0x5d0));

-          }

-          *(int *)(unaff_R14 + 0x5d8) = iVar7;

-          memset((void *)(unaff_R14 + 0x5e0),0,0x400);

-        }

-        KeReleaseMutex(unaff_R13 + 0x48);

-        unaff_RBX[0x10] = (longlong)DpiFdoDispatchPnp;

-        if (unaff_R14 != 0) {

-          *(code **)(unaff_R14 + 0x88) = DpiFdoDispatchPower;

-        }

-        in_stack_00000058 = cVar15;

-        if (cStack0000000000000051 != '\0') {

-          *(undefined1 *)(*(longlong *)(unaff_R14 + 0xa8) + 0x6c) = 1;

-          AcquireMiniportListMutex();

-          if (DAT_4 == unaff_R12) {

-            DAT_4 = in_stack_00000060;

-          }

-          else if (*(char *)(unaff_R14 + 0x480) != cVar15) {

-            DAT_4 = in_stack_00000060;

-            WdLogSingleEntry2(unaff_R15D,in_stack_00000060,(longlong)iVar5);

-            _WdLogGlobalForLineNumber = 0x84b;

-          }

-          *(ulonglong *)(unaff_RBP + -0x40) = unaff_R12;

-          iVar5 = DpiDxgkDdiExchangePreStartInfo();

-          ReleaseMiniportListMutex();

-          if (iVar5 < 0) {

-            uVar16 = WdLogSingleEntry2(unaff_R15D,*(undefined8 *)(unaff_R13 + 0x478),(longlong)iVar5

-                                      );

-            _WdLogGlobalForLineNumber = 0x863;

-            goto LAB_0;

-          }

-          if ((*(int *)(unaff_R14 + 0x10) == 0x74727044) &&

-             (*(int *)(unaff_R14 + 0x14) == unaff_R15D)) {

-            uVar1 = *(uint *)(unaff_RBP + -0x3c);

-            *(byte *)(unaff_R14 + 0xb1d) = (byte)uVar1 & 1;

-            *(byte *)(unaff_R14 + 0xb1e) = (byte)(uVar1 >> 1) & 1;

-          }

-        }

-        if ((cStack0000000000000052 != cVar15) && (in_stack_00000068._6_1_ != cVar15)) {

-          DAT_5 = in_stack_00000060;

-          memset((void *)(unaff_RBP + 0x144),0,0x118);

-          *(undefined4 *)(unaff_RBP + 0x140) = 0x11c;

-          iVar6 = RtlGetVersion(unaff_RBP + 0x140);

-          if (iVar6 < 0) {

+        if ((0x1f < uVar13) && (puVar4 != (uint *)0x0)) {

+          CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0');

+          uVar13 = local_ac0;

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

+            uVar14 = DpiFdoGetVirtualGpuType(param_2);

+            uVar13 = DxgkDdiWriteVirtualizedInterrupt

+                               (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,puVar4[2]);

+            uVar15 = uVar16;

+            goto LAB_8;

+          }

+          goto LAB_2;

+        }

+        uVar13 = 0xc0000023;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x133d;

+      }

+    }

+    else {

+      if (uVar1 == 0x226494) {

+        Feature_GpupLiveMigration_dxgkrnl__private_IsEnabledPreCheck();

+        if ((*(uint *)(lVar3 + 0x15d8) & 4) == 0) {

+          uVar13 = 0xc00000bb;

+          WdLogSingleEntry1(2);

+          _WdLogGlobalForLineNumber = 0x1261;

+          goto LAB_0;

+        }

+        uVar18 = 8;

+        if (((7 < uVar13) && (puVar4 != (uint *)0x0)) && (7 < uVar12)) {

+          CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0');

+          uVar13 = local_ac0;

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

+            uVar14 = DpiFdoGetVirtualGpuType(param_2);

+            uVar13 = DxgkLiveMigrationGetTransferSize

+                               (*(undefined8 *)(lVar3 + 0xfc0),uVar14,puVar4,puVar4);

+            goto LAB_9;

+          }

+          goto LAB_2;

+        }

+        uVar13 = 0xc0000023;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x126c;

+      }

+      else if (uVar1 == 0x226498) {

+        if (((7 < uVar13) && (puVar4 != (uint *)0x0)) && (3 < uVar12)) {

+          CInterfaceCallContext::CInterfaceCallContext(local_ae0,param_1,param_2,'\x01','\0','\0');

+          uVar13 = local_ac0;

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

+            iVar11 = DpiFdoGetVirtualGpuType();

+            *puVar4 = 0;

+            if (iVar11 == 0) {

+              *puVar4 = *(uint *)(lVar3 + 0x15d8) >> 2 & 1;

+            }

+            uVar17 = 4;

+          }

+          goto LAB_2;

+        }

+        uVar13 = 0xc0000023;

+        WdLogSingleEntry1(2);

+        _WdLogGlobalForLineNumber = 0x1359;

+      }

+      else {

+        if (uVar1 != 0x226844) {

+          if (uVar1 == 0x226848) {

+            uVar13 = DpiSetPartitionFlexIovVmbus(param_1,param_2,puVar4,uVar13);

+          }

+          else if (uVar1 == 0x22685c) {

+            uVar13 = DpiFlexIovMitigationUpdate(param_1,param_2,puVar4,uVar13);

+          }

+          else {

+            if (uVar1 != 0x23cc04) {

 LAB_6:

-            iVar7 = ExGetFirmwareType();

-            if ((iVar7 != unaff_R15D) && (DAT_8 == cVar15)) goto LAB_140240a0e;

-          }

-          else {

-            *(int *)(unaff_RBP + -100) = iVar7;

-            cVar4 = RtlGetProductInfo(*(undefined4 *)(unaff_RBP + 0x144),

-                                      *(undefined4 *)(unaff_RBP + 0x148),

-                                      *(undefined2 *)(unaff_RBP + 0x254),

-                                      *(undefined2 *)(unaff_RBP + 0x256),unaff_RBP + -100);

-            if ((cVar4 == '\0') || (*(int *)(unaff_RBP + -100) != 0xbb)) goto LAB_6;

-          }

-          *(undefined2 *)(unaff_R14 + 0xb1d) = 0x101;

-        }

-LAB_7:

-        if (*(char *)((longlong)unaff_RBX + 0x39) == cVar15) {

-          *(uint *)(in_stack_00000060 + 0x30) = *(uint *)(in_stack_00000060 + 0x30) | 4;

-          *(uint *)(in_stack_00000060 + 0x30) = *(uint *)(in_stack_00000060 + 0x30) | 0x2000;

-        }

-        else {

-          *(uint *)(in_stack_00000060 + 0x30) =

-               *(uint *)(in_stack_00000060 + 0x30) | *(uint *)(unaff_RBX[0x14] + 0x30) & 0x2014;

-        }

-        *(uint *)(in_stack_00000060 + 0x30) = *(uint *)(in_stack_00000060 + 0x30) & 0xffffbfff;

-        *(uint *)(in_stack_00000060 + 0x30) = *(uint *)(in_stack_00000060 + 0x30) & 0xffffff7f;

-        uVar16 = WdLogSingleEntry1(4,in_stack_00000060);

-        _WdLogGlobalForLineNumber = 0x8c3;

-      }

-LAB_0:

-      if (unaff_R14 != 0) goto LAB_3;

-      goto LAB_9;

-    }

-LAB_10:

-    cVar15 = (char)unaff_R12;

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

-    (*pcVar2)(3);

-    register0x00000020 = (BADSPACEBASE *)auStackX_8;

-    iVar5 = -0x3ffffff3;

-    uVar16 = WdLogSingleEntry3(0,0x113,0x15);

-    _WdLogGlobalForLineNumber = 0x176;

-    cStack0000000000000050 = (char)unaff_RBX;

-  }

-  else {

-    iVar5 = DpiLdaLinkDeviceToChain(in_stack_00000060);

-    if (-1 < iVar5) goto LAB_1;

-    uVar16 = WdLogSingleEntry1(unaff_R15D,(longlong)iVar5);

-    _WdLogGlobalForLineNumber = 0x7ae;

-LAB_3:

-    if ((*(int *)(unaff_R14 + 0x10) == 0x74727044) && (*(int *)(unaff_R14 + 0x14) == unaff_R15D)) {

-      uVar16 = DxgkLogInternalTriageEvent

-                         (*(undefined8 *)(unaff_R14 + 0xfc0),0x20005,0xffffffff,

-                          L"Adapter AddDevice has completed with status %1",(longlong)iVar5);

-    }

-LAB_9:

-    unaff_R12 = in_stack_00000068 & 0xffffffff;

-    *(int *)(unaff_RBP + -0x70) = iVar5;

-    if (-1 < iVar5) goto LAB_11;

-    if (cStack0000000000000076 == '\x01') {

-      KeWaitForSingleObject(unaff_R13 + 0x48,0,0,0,0);

-      lVar9 = *unaff_RBX;

-      if ((*(longlong **)(lVar9 + 8) != unaff_RBX) ||

-         (plVar12 = (longlong *)unaff_RBX[1], (longlong *)*plVar12 != unaff_RBX))

-      goto LAB_10;

-      *plVar12 = lVar9;

-      *(longlong **)(lVar9 + 8) = plVar12;

-      *(int *)(unaff_R13 + 0x80) = *(int *)(unaff_R13 + 0x80) + -1;

-      if ((unaff_R14 != 0) && (*(int *)(unaff_R14 + 0x1f8) != 0)) {

-        DpiLdaUnLinkDeviceFromChain(in_stack_00000060);

-      }

-      uVar16 = KeReleaseMutex(unaff_R13 + 0x48);

-      iVar5 = *(int *)(unaff_RBP + -0x70);

-    }

-    cVar15 = (char)in_stack_00000068;

-    if (in_stack_00000058 == '\x01') {

-      uVar16 = KeReleaseMutex(unaff_R13 + 0x48);

-    }

-  }

-  if (*(longlong *)((longlong)register0x00000020 + 0x60) != 0) {

-    if (*(char *)((longlong)register0x00000020 + 0x54) == '\x01') {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023ef9f;

-      DpiFdoResetFdo();

-    }

-    if (unaff_R14 != 0) {

-      if ((*(longlong *)(unaff_R14 + 0x5c8) != 0) &&

-         (*(int *)(*(longlong *)(unaff_R14 + 0x5c8) + 8) == 1)) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023efc3;

-        ExFreePoolWithTag();

-        *(undefined8 *)(unaff_R14 + 0x5c8) = 0;

-      }

-      if ((*(longlong *)(unaff_R14 + 0x5d0) != 0) &&

-         (*(int *)(*(longlong *)(unaff_R14 + 0x5d0) + 8) == 1)) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023efec;

-        ExFreePoolWithTag();

-        *(undefined8 *)(unaff_R14 + 0x5d0) = 0;

-      }

-      if (cVar15 == '\x01') {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f009;

-        DpiAcpiUnregisterAcpiCallbacks(*(undefined8 *)((longlong)register0x00000020 + 0x60));

-      }

-      pcVar2 = *(code **)(unaff_R14 + 0x248);

-      if (pcVar2 != (code *)0x0) {

-        uVar8 = *(undefined8 *)(unaff_R14 + 0x238);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f024;

-        (*pcVar2)(uVar8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f037;

-        memset((void *)(unaff_R14 + 0x230),0,0x40);

-      }

-      pcVar2 = *(code **)(unaff_R14 + 0x288);

-      if (pcVar2 != (code *)0x0) {

-        uVar8 = *(undefined8 *)(unaff_R14 + 0x278);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f04f;

-        (*pcVar2)(uVar8);

-        *(undefined8 *)(unaff_R14 + 0x270) = 0;

-        *(undefined8 *)(unaff_R14 + 0x278) = 0;

-        *(undefined8 *)(unaff_R14 + 0x280) = 0;

-        *(undefined8 *)(unaff_R14 + 0x288) = 0;

-        *(undefined8 *)(unaff_R14 + 0x290) = 0;

-        *(undefined8 *)(unaff_R14 + 0x298) = 0;

-      }

-      pcVar2 = *(code **)(unaff_R14 + 0x2b8);

-      if (pcVar2 != (code *)0x0) {

-        uVar8 = *(undefined8 *)(unaff_R14 + 0x2a8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f082;

-        (*pcVar2)(uVar8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f096;

-        memset((void *)(unaff_R14 + 0x2a0),0,0xb8);

-      }

-      pcVar2 = *(code **)(unaff_R14 + 0x370);

-      if (pcVar2 != (code *)0x0) {

-        uVar8 = *(undefined8 *)(unaff_R14 + 0x360);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f0ae;

-        (*pcVar2)(uVar8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f0c0;

-        memset((void *)(unaff_R14 + 0x358),0,0x58);

-      }

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f0ce;

-      RtlFreeUnicodeString(unaff_R14 + 0x200);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f0e1;

-      RtlFreeUnicodeString(unaff_R14 + 0x210);

-      lVar9 = *(longlong *)(unaff_R14 + 0x458);

-      if (lVar9 != 0) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14023f0ff;

-        ExFreePoolWithTag(lVar9,0);

-        *(undefined8 *)(unaff_R14 + 0x458) = 0;

-      }

-    }

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

-      if (unaff_RBX[0x15] != 0) {

-        if (cStack0000000000000050 == '\x01') {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240c3b;

-          ExDeleteResourceLite();

-        }

-        lVar9 = unaff_RBX[0x15];

-        if ((*(int *)(lVar9 + 0x68) == 1) && (lVar9 != 0)) {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240c5b;

-          ExFreePoolWithTag(lVar9,0);

-          unaff_RBX[0x15] = 0;

-        }

-      }

-      if (unaff_RBX[0x14] != 0) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240c7a;

-        IoDetachDevice();

-      }

-    }

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240c8b;

-    uVar16 = IoDeleteDevice(*(undefined8 *)((longlong)register0x00000020 + 0x60));

-    *(undefined8 *)((longlong)register0x00000020 + 0x60) = 0;

-  }

-  if (*(char *)((longlong)register0x00000020 + 0x55) == '\x01') {

-    uVar8 = *(undefined8 *)(unaff_RBP + -0x60);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240cad;

-    DpiDxgkDdiRemoveDevice(uVar16,uVar8);

-    cVar15 = *(char *)((longlong)register0x00000020 + 0x53);

-LAB_12:

-    if (cVar15 != '\0') {

-LAB_13:

-      if (iVar5 != -0x3fe1fbc8) {

-        *(undefined1 *)((longlong)register0x00000020 + 0x28) = 0;

-        *(undefined8 *)((longlong)register0x00000020 + 0x20) = 0;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240d70;

-        DxgCreateLiveDumpWithWdLogs(0x193,0x801,(longlong)iVar5,0);

-      }

+              param_2[0x43] = (_IRP)((char)param_2[0x43] + '\x01');

+              *(longlong *)(param_2 + 0xb8) = *(longlong *)(param_2 + 0xb8) + 0x48;

+              uVar15 = IofCallDriver(*(undefined8 *)(lVar3 + 0xa0),param_2);

+              return uVar15;

+            }

+            local_ae4 = 0;

+            uVar13 = DpiIndirectDdiIoControl(lVar3,uVar13,puVar4,uVar12);

+          }

+          goto LAB_3;

+        }

+        if ((param_2[0x40] != (_IRP)0x0) &&

+           (cVar10 = DxgkpCheckProcessForVirtualMachineManagementAccess(), cVar10 == '\0')) {

+          uVar13 = 0xc0000022;

+          WdLogSingleEntry1(2,0xffffffffc0000022);

+          _WdLogGlobalForLineNumber = 0x1159;

+          goto LAB_0;

+        }

+        uVar14 = DpiFdoGetVirtualGpuType(param_2);

+        uVar13 = DpiGetVirtualizationFlags(param_1,uVar14,puVar4,uVar13);

+        uVar16 = local_ab0;

+      }

+LAB_4:

+      if (uVar13 == 0x103) goto LAB_11;

     }

   }

   else {

-    cVar15 = *(char *)((longlong)register0x00000020 + 0x53);

-    if (cVar15 != '\0') {

-      if (*(longlong *)(unaff_R13 + 0x540) != 0) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240cd8;

-        p_Var10 = DxgAllocateDiagnosticInfoArgs(1);

-        if (p_Var10 != (_DXGKARG_COLLECTDIAGNOSTICINFO *)0x0) {

-          uVar1 = *(uint *)(p_Var10 + 0xd8);

-          p_Var3 = *(_DEVICE_OBJECT **)(unaff_RBP + -0x80);

-          *(undefined8 *)p_Var10 = *(undefined8 *)(unaff_RBP + -0x60);

-          pcVar2 = *(code **)(unaff_R13 + 0x540);

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240d03;

-          iVar7 = (*pcVar2)(p_Var3,p_Var10);

-          if (-1 < iVar7) {

-            if (uVar1 < *(uint *)(p_Var10 + 0xdc)) {

-              *(undefined4 *)(p_Var10 + 0xdc) = 0;

-            }

-            iVar7 = *(int *)(p_Var10 + 8);

-            *(_DXGKARG_COLLECTDIAGNOSTICINFO **)((longlong)register0x00000020 + 0x30) = p_Var10;

-            *(undefined8 *)((longlong)register0x00000020 + 0x28) = 0;

-            *(undefined8 *)((longlong)register0x00000020 + 0x20) = 0;

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240d39;

-            DxgCreateLiveDumpWithDriverBlob

-                      (p_Var3,0x1b0,(longlong)iVar7,(longlong)iVar5,

-                       *(__uint64 *)((longlong)register0x00000020 + 0x20),

-                       *(__uint64 *)((longlong)register0x00000020 + 0x28),

-                       *(_DXGKARG_COLLECTDIAGNOSTICINFO **)((longlong)register0x00000020 + 0x30));

-            cVar15 = '\0';

-          }

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240d44;

-          DxgFreeDiagnosticInfoArgs(p_Var10);

-          goto LAB_12;

-        }

-      }

-      goto LAB_13;

-    }

+    uVar13 = 0xc00000bb;

+    WdLogSingleEntry1(2);

+    _WdLogGlobalForLineNumber = 0xf20;

+    uVar16 = uVar15;

   }

-  uStack0000000000000070 = *(undefined4 *)((longlong)register0x00000020 + 0x70);

+LAB_0:

+  *(uint *)(param_2 + 0x30) = uVar13;

+  *(ulonglong *)(param_2 + 0x38) = uVar16;

+  IofCompleteRequest(param_2,1);

 LAB_11:

-  *(undefined8 *)(unaff_RBP + 0x108) = 0;

-  *(undefined8 *)(unaff_RBP + 0x110) = 0;

-  *(undefined8 *)(unaff_RBP + 0x118) = 0;

-  *(undefined4 *)(unaff_RBP + 300) = 0;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240d9b;

-  uVar16 = DxgkDiagCalcDuration1us(unaff_RBP + 0x48);

-  *(undefined4 *)(unaff_RBP + 0x100) = 6;

-  *(undefined4 *)(unaff_RBP + 0x104) = 0x40;

-  *(undefined4 *)(unaff_RBP + 0x128) = 0;

-  *(undefined8 *)(unaff_RBP + 0x108) = 0;

-  *(undefined8 *)(unaff_RBP + 0x120) = 0;

-  *(undefined8 *)(unaff_RBP + 0x110) = 0;

-  *(undefined8 *)(unaff_RBP + 0x118) = 0;

-  *(undefined4 *)(unaff_RBP + 0x130) = 0x22;

-  *(undefined4 *)(unaff_RBP + 0x134) = uStack0000000000000070;

-  *(undefined4 *)(unaff_RBP + 0x138) = uVar16;

-  *(int *)(unaff_RBP + 0x13c) = iVar5;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240e03;

-  DxgkWriteDiagEntry((_DXGK_DIAG_HEADER *)(unaff_RBP + 0x100),0x100000000);

-  if ((bTracingEnabled != '\0') && ((DAT_14 & 1) != 0)) {

-    uVar8 = *(undefined8 *)(unaff_RBP + -0x80);

-    *(int *)((longlong)register0x00000020 + 0x28) = iVar5;

-    *(undefined8 *)((longlong)register0x00000020 + 0x20) = uVar8;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240e32;

-    McTemplateK0ppq_EtwWriteTransfer();

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140240e43;

-  return iVar5;

+  return (ulonglong)uVar13;

 }
```

## `BmlPickColorSpaceAndWireFormat`  (modified)

```diff
--- BmlPickColorSpaceAndWireFormat
+++ BmlPickColorSpaceAndWireFormat
@@ -1,162 +1,213 @@
 

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

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

+/* long __cdecl BmlPickColorSpaceAndWireFormat(struct BML_VIDPN_PATH_ORDER const * __ptr64,enum

+   DXGK_DIAG_CCD_BML_ORIGIN,class DMMVIDPN * __ptr64) */

 

 long __cdecl

 BmlPickColorSpaceAndWireFormat

           (BML_VIDPN_PATH_ORDER *param_1,DXGK_DIAG_CCD_BML_ORIGIN param_2,DMMVIDPN *param_3)

 

 {

-  long lVar1;

-  code *pcVar2;

-  int iVar3;

-  int iVar4;

-  undefined8 uVar5;

-  undefined2 uVar6;

-  longlong unaff_RBX;

-  uint uVar7;

-  longlong unaff_RBP;

-  DXGPROCESS *unaff_RSI;

-  int *unaff_RDI;

-  ushort uVar8;

-  _D3DKMT_MEMORY_SEGMENT_GROUP _Var9;

-  undefined8 in_R9;

-  undefined4 unaff_R12D;

-  int unaff_R13D;

-  undefined4 unaff_R14D;

-  int *piVar10;

+  uint uVar1;

+  DMMVIDPNTARGETMODE *pDVar2;

+  byte *pbVar3;

+  DMMVIDPN *pDVar4;

+  char cVar5;

+  bool bVar6;

+  long lVar7;

+  int iVar8;

+  DMMVIDPNPRESENTPATH *this;

+  DXGGLOBAL *pDVar9;

+  DXGADAPTER *pDVar10;

+  DMMVIDPNSOURCEMODESET *pDVar11;

+  auto_rc<DMMVIDPNSOURCEMODESET> *this_00;

+  BML_WIREFORMAT_PREFERENCE BVar12;

+  ulonglong uVar13;

+  byte bVar14;

+  longlong lVar15;

+  uint uVar16;

+  uint local_res8 [2];

+  DXGK_DIAG_CCD_BML_ORIGIN local_res10;

+  DMMVIDPN *local_res18;

+  undefined4 local_res20 [2];

+  undefined4 local_78;

+  uint local_74;

+  DMMVIDPNSOURCEMODESET *local_70;

+  DMMVIDPNSOURCEMODESET *local_68;

+  DMMVIDPNSOURCEMODESET *local_60;

+  DMMVIDPNTOPOLOGY *local_58;

   

-  _WdLogGlobalForLineNumber = SUB84(&stack0x00000000,0);

-  DxgkLogInternalTriageEvent(0,unaff_R14D,param_3,in_R9,(ulonglong)&stack0x00000000 & 0xffffffff);

-  iVar3 = *unaff_RDI;

-  if (iVar3 < 10) {

-    if (iVar3 == 9) {

-      _Var9 = unaff_RDI[200];

-      uVar8 = 0;

+  local_74 = 0;

+  if (*param_1 != (BML_VIDPN_PATH_ORDER)0x0) {

+    local_58 = (DMMVIDPNTOPOLOGY *)(param_3 + 0x60);

+    local_res10 = param_2;

+    local_res18 = param_3;

+    do {

+      uVar13 = (ulonglong)local_74;

+      lVar15 = uVar13 * 0x78;

+      uVar1 = *(uint *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x1c);

+      uVar16 = *(uint *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x18);

+      this = DMMVIDPNTOPOLOGY::FindPath(local_58,uVar16,uVar1);

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

+        WdLogSingleEntry5(2,uVar13,param_1,uVar16,uVar1,local_res18);

+        _WdLogGlobalForLineNumber = 0x16f4;

+        return -0x3fe1fce7;

+      }

+      local_70 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(this + 0x60));

+      pDVar2 = *(DMMVIDPNTARGETMODE **)(local_70 + 0x90);

+      if (pDVar2 == (DMMVIDPNTARGETMODE *)0x0) {

+        WdLogSingleEntry2(2,*(undefined4 *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x1c),

+                          local_res18);

+        _WdLogGlobalForLineNumber = 0x1701;

+        lVar7 = -0x3fe1fcf7;

+        goto LAB_0;

+      }

+      local_res20[0] = 0;

+      lVar7 = MonitorGetDitheringCaps

+                        (*(HDXGMONITOR__ **)

+                          (*(longlong *)(*(longlong *)(this + 0x60) + 0x60) + 0x70),

+                         (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20);

+      pDVar4 = local_res18;

+      if (lVar7 < 0) {

+        WdLogSingleEntry3(2,*(undefined4 *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x1c),

+                          local_res18,(longlong)lVar7);

+        _WdLogGlobalForLineNumber = 0x1717;

+        local_res20[0] = 0;

+      }

+      pbVar3 = *(byte **)(param_1 + lVar15 + 0x10);

+      local_78 = *(undefined4 *)(pDVar2 + 0x80);

+      local_res8[0] = 0;

+      if ((*pbVar3 & 8) == 0) {

+LAB_1:

+        if ((((((byte)param_1[lVar15 + 0x84] & 2) == 0) ||

+             ((*(uint *)(param_1 + lVar15 + 0x74) & 1) == 0)) ||

+            (bVar6 = DMMVIDPNPRESENTPATH::IsHdrAllowedOnVidPnPath(this), !bVar6)) ||

+           ((bVar6 = ModeSupportsHighDepthColorFormat

+                               (pDVar2,(_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20), !bVar6

+            || (((byte)param_1[lVar15 + 0x84] & 1) != 0)))) {

+          uVar13 = (ulonglong)(byte)param_1[lVar15 + 0x84];

+          if ((((byte)param_1[lVar15 + 0x84] & 0xc) != 0xc) ||

+             ((bVar6 = ModeSupportsHighDepthColorFormat

+                                 (pDVar2,(_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20), !bVar6

+              || ((uVar13 & 1) != 0)))) {

+            uVar16 = 0;

+            BVar12 = 1;

+            iVar8 = Feature_SdrHighBpcPreference__private_IsEnabledDeviceUsageNoInline();

+            if ((iVar8 != 0) && (BVar12 = 1, ((byte)param_1[lVar15 + 0x84] & 0x20) != 0)) {

+              BVar12 = 0;

+            }

+            if ((local_res10 == 2) && ((*(uint *)(param_1 + 4) & 0x8000000) == 0)) {

+              BVar12 = BVar12 & -(uint)((*(int *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x74) -

+                                         0x1fU & 0xfffffffb) != 0);

+            }

+            lVar7 = PickWireFormatWithPreference

+                              (BVar12,(_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)&local_78,

+                               (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20,

+                               (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res8);

+            if (lVar7 < 0) {

+              uVar16 = 0;

+              local_res8[0] = local_res8[0] & 0xffffff0b | 8;

+              WdLogSingleEntry0(3);

+              _WdLogGlobalForLineNumber = 0x17ea;

+            }

+            goto LAB_2;

+          }

+          local_60 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(this + 0x58));

+          lVar15 = *(longlong *)(local_60 + 0x90);

+          if (((lVar15 == 0) || (*(int *)(lVar15 + 0x48) != 1)) ||

+             (iVar8 = 1, *(int *)(lVar15 + 0x60) != 0x71)) {

+            iVar8 = 0;

+          }

+          lVar7 = PickWireFormatWithPreference

+                            (iVar8 * 2 + 1,(_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)&local_78,

+                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20,

+                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res8);

+          uVar16 = -(uint)((char)iVar8 != '\0') & 0x1e;

+          if (lVar7 < 0) {

+            local_res8[0] = local_res8[0] & 0xffffff0b | 8;

+            WdLogSingleEntry0(3);

+            _WdLogGlobalForLineNumber = 0x17ba;

+            uVar16 = 0;

+          }

+          this_00 = (auto_rc<DMMVIDPNSOURCEMODESET> *)&local_60;

+        }

+        else {

+          if (((local_res10 != 2) || ((*(uint *)(param_1 + 4) & 0x8000000) != 0)) ||

+             ((*(int *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x74) == 0x24 ||

+              (bVar14 = 1, *(int *)(*(longlong *)(param_1 + lVar15 + 0x10) + 0x74) == 0x71)))) {

+            bVar14 = 0;

+          }

+          pDVar11 = DMMVIDPNSOURCE::AcquireCofuncModeSetRef(*(DMMVIDPNSOURCE **)(this + 0x58));

+          local_68 = pDVar11;

+          pDVar10 = VIDPN_MGR::GetContainingAdapter(*(VIDPN_MGR **)(pDVar4 + 0x30));

+          bVar6 = IsHdrSourceModePinned(pDVar10,pDVar11);

+          uVar16 = -(uint)bVar6 & ~-(uint)(bVar14 != 0) & 0xc;

+          lVar7 = PickWireFormatWithPreference

+                            (-(uint)bVar6 & (bVar14 ^ 1) << 2,

+                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)&local_78,

+                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res20,

+                             (_D3DKMDT_WIRE_FORMAT_AND_PREFERENCE *)local_res8);

+          if (lVar7 < 0) {

+            uVar16 = 0;

+            local_res8[0] = local_res8[0] & 0xffffff0b | 8;

+            WdLogSingleEntry0(3);

+            _WdLogGlobalForLineNumber = 0x1793;

+          }

+          this_00 = (auto_rc<DMMVIDPNSOURCEMODESET> *)&local_68;

+        }

+        auto_rc<DMMVIDPNSOURCEMODESET>::reset(this_00,(DMMVIDPNSOURCEMODESET *)0x0);

+      }

+      else {

+        uVar1 = *(uint *)(pbVar3 + 0xcc);

+        uVar16 = *(uint *)(pbVar3 + 0xd0);

+        cVar5 = BmlDoesTargetModeSupportWireFormat(pDVar2);

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

+          if ((*(byte *)(*(longlong *)(param_1 + lVar15 + 0x10) + 8) & 8) != 0) {

+            WdLogSingleEntry1(2);

+            _WdLogGlobalForLineNumber = 0x1750;

+            lVar7 = -0x3fe1fcb6;

+            goto LAB_0;

+          }

+          goto LAB_1;

+        }

+        local_res8[0] = uVar1;

+        if (uVar16 - 0x1f < 3) {

+          pDVar9 = DXGGLOBAL::GetGlobal();

+          if ((pDVar9[0x4a6f0] == (DXGGLOBAL)0x0) &&

+             (pDVar10 = VIDPN_MGR::GetContainingAdapter(*(VIDPN_MGR **)(pDVar4 + 0x30)),

+             (*(uint *)(pDVar10 + 0x1bc) & 8) == 0)) {

+            WdLogSingleEntry1(2);

+            _WdLogGlobalForLineNumber = 0x173a;

+            lVar7 = -0x3ffffff3;

+            goto LAB_0;

+          }

+          if (uVar16 != 0x20) goto LAB_3;

+          uVar1 = *(uint *)(param_1 + lVar15 + 0x74) & 2;

+LAB_4:

+          if (uVar1 == 0) {

+            lVar7 = -0x3fffff45;

 LAB_0:

-      lVar1 = VIDMM_EXPORT::VidMmQueryProcessSegmentGroupStatistics

-                        (*(VIDMM_EXPORT **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2f8),

-                         *(VIDMM_GLOBAL **)(*(longlong *)(unaff_RBP + 0xc50) + 0x300),uVar8,_Var9,

-                         unaff_RSI,

-                         (_D3DKMT_QUERYSTATISTICS_PROCESS_SEGMENT_GROUP_INFORMATION *)

-                         (unaff_RDI + 6));

-      return lVar1;

-    }

-    iVar3 = iVar3 - unaff_R13D;

-    if (iVar3 == 0) {

-      iVar3 = (**(code **)(*(longlong *)

-                            (*(longlong *)(*(longlong *)(unaff_RBP + 0xc50) + 0x2f8) + 8) + 0x118))

-                        (*(undefined8 *)(*(longlong *)(unaff_RBP + 0xc50) + 0x300));

-      if (iVar3 < 0) {

-        return iVar3;

-      }

-      lVar1 = VIDSCH_EXPORT::VidSchQueryProcessStatistics

-                        (*(VIDSCH_EXPORT **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e0),

-                         *(_VIDSCH_GLOBAL **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e8),unaff_RSI,

-                         (_D3DKMT_QUERYSTATISTICS_PROCESS_INFORMATION *)(unaff_RDI + 6));

-      return lVar1;

-    }

-    iVar4 = iVar3 - unaff_R13D;

-    if (iVar3 == unaff_R13D) {

-      uVar8 = 0;

-      goto LAB_1;

-    }

-    if (iVar4 == 2) {

-      uVar7 = unaff_RDI[200];

-      piVar10 = *(int **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2f8);

-      uVar5 = *(undefined8 *)(*(longlong *)(unaff_RBP + 0xc50) + 0x300);

-      if (*(longlong *)(unaff_RSI + 0x40) != 0) {

-        unaff_RBX = *(longlong *)

-                     (*(longlong *)(unaff_RSI + 0x40) + (ulonglong)(uint)(*piVar10 - unaff_R13D) * 8

-                     );

-      }

-      uVar6 = 0;

-      pcVar2 = *(code **)(*(longlong *)(piVar10 + 2) + 0x130);

-      goto LAB_2;

-    }

-    if (iVar4 != 4) {

-      if (iVar4 == 6) {

-        lVar1 = VIDSCH_EXPORT::VidSchQueryProcessVidPnSourceStatistics

-                          (*(VIDSCH_EXPORT **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e0),

-                           *(_VIDSCH_GLOBAL **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e8),

-                           unaff_RDI[200],unaff_RSI,

-                           (_D3DKMT_QUERYSTATISTICS_PROCESS_VIDPNSOURCE_INFORMATION *)

-                           (unaff_RDI + 6));

-        return lVar1;

-      }

-      goto LAB_3;

-    }

-    uVar7 = unaff_RDI[200];

-    piVar10 = *(int **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e0);

-    uVar5 = *(undefined8 *)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e8);

-    if ((*(longlong *)(unaff_RSI + 0x40) == 0) ||

-       (unaff_RBX = *(longlong *)

-                     (*(longlong *)(unaff_RSI + 0x40) + 0x10 +

-                     (ulonglong)(uint)(*piVar10 - unaff_R13D) * 8), unaff_RBX == 0)) {

-      WdLogSingleEntry0(unaff_R13D);

-      _WdLogGlobalForLineNumber = 0x52c;

-      DxgkLogInternalTriageEvent(0,0x40002,unaff_R12D,L"pVidSchProcess",0x52c);

-    }

-    uVar6 = 0xffff;

+            auto_rc<DMMVIDPNTARGETMODESET>::reset

+                      ((auto_rc<DMMVIDPNTARGETMODESET> *)&local_70,(DMMVIDPNTARGETMODESET *)0x0);

+            return lVar7;

+          }

+        }

+        else {

+LAB_3:

+          if (uVar16 == 0x21) {

+            uVar1 = *(uint *)(param_1 + lVar15 + 0x74) & 4;

+            goto LAB_4;

+          }

+        }

+      }

+LAB_2:

+      *(uint *)(pDVar2 + 0x84) = local_res8[0];

+      *(uint *)(pDVar2 + 0x88) = uVar16;

+      auto_rc<DMMVIDPNTARGETMODESET>::reset

+                ((auto_rc<DMMVIDPNTARGETMODESET> *)&local_70,(DMMVIDPNTARGETMODESET *)0x0);

+      local_74 = local_74 + 1;

+    } while (local_74 < (byte)*param_1);

   }

-  else {

-    if (iVar3 + -0xd == 0) {

-      uVar8 = *(ushort *)(unaff_RDI + 200);

-LAB_1:

-      lVar1 = VIDMM_EXPORT::VidMmQueryProcessAdapterStatistics

-                        (*(VIDMM_EXPORT **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2f8),

-                         *(VIDMM_GLOBAL **)(*(longlong *)(unaff_RBP + 0xc50) + 0x300),uVar8,

-                         unaff_RSI,

-                         (_D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION *)(unaff_RDI + 6));

-      if (-1 < lVar1) {

-        lVar1 = VIDSCH_EXPORT::VidSchQueryProcessAdapterStatistics

-                          (*(VIDSCH_EXPORT **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e0),

-                           *(_VIDSCH_GLOBAL **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e8),unaff_RSI,

-                           (_D3DKMT_QUERYSTATISTICS_PROCESS_ADAPTER_INFORMATION *)(unaff_RDI + 6));

-      }

-      return lVar1;

-    }

-    iVar3 = (iVar3 + -0xd) - unaff_R13D;

-    if (iVar3 == 0) {

-      uVar7 = (uint)*(ushort *)((longlong)unaff_RDI + 0x322);

-      uVar6 = (undefined2)unaff_RDI[200];

-      piVar10 = *(int **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2f8);

-      uVar5 = *(undefined8 *)(*(longlong *)(unaff_RBP + 0xc50) + 0x300);

-      if (*(longlong *)(unaff_RSI + 0x40) != 0) {

-        unaff_RBX = *(longlong *)

-                     (*(longlong *)(unaff_RSI + 0x40) + (ulonglong)(uint)(*piVar10 - unaff_R13D) * 8

-                     );

-      }

-      pcVar2 = *(code **)(*(longlong *)(piVar10 + 2) + 0x130);

-      goto LAB_2;

-    }

-    if (iVar3 == unaff_R13D) {

-      _Var9 = (_D3DKMT_MEMORY_SEGMENT_GROUP)*(ushort *)((longlong)unaff_RDI + 0x322);

-      uVar8 = *(ushort *)(unaff_RDI + 200);

-      goto LAB_0;

-    }

-    if (iVar3 - unaff_R13D != 4) {

-LAB_3:

-      WdLogSingleEntry1(3);

-      _WdLogGlobalForLineNumber = 0x17a5;

-      return -0x3ffffff3;

-    }

-    uVar7 = (uint)*(ushort *)((longlong)unaff_RDI + 0x322);

-    uVar6 = (undefined2)unaff_RDI[200];

-    piVar10 = *(int **)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e0);

-    uVar5 = *(undefined8 *)(*(longlong *)(unaff_RBP + 0xc50) + 0x2e8);

-    if ((*(longlong *)(unaff_RSI + 0x40) == 0) ||

-       (unaff_RBX = *(longlong *)

-                     (*(longlong *)(unaff_RSI + 0x40) + 0x10 +

-                     (ulonglong)(uint)(*piVar10 - unaff_R13D) * 8), unaff_RBX == 0)) {

-      WdLogSingleEntry0(unaff_R13D);

-      _WdLogGlobalForLineNumber = 0x52c;

-      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pVidSchProcess",0x52c);

-    }

-  }

-  pcVar2 = *(code **)(*(longlong *)(piVar10 + 2) + 0x2e0);

-LAB_2:

-  lVar1 = (*pcVar2)(uVar5,uVar6,uVar7,unaff_RBX,unaff_RDI + 6);

-  return lVar1;

+  return 0;

 }
```

## `CFlipManagerToken::Discard`  (modified)

```diff
--- CFlipManagerToken::Discard
+++ CFlipManagerToken::Discard
@@ -1,2 +1,31 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipManagerToken::Discard : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: virtual void __cdecl CFlipManagerToken::Discard(void) __ptr64 */

+

+void __thiscall CFlipManagerToken::Discard(CFlipManagerToken *this)

+

+{

+  uint in_EDX;

+  

+  if (*(FlipManagerTokenIFlipInfo **)(this + 0x48) != (FlipManagerTokenIFlipInfo *)0x0) {

+    FlipManagerTokenIFlipInfo::_scalar_deleting_destructor_

+              (*(FlipManagerTokenIFlipInfo **)(this + 0x48),in_EDX);

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

+  }

+  if ((*(int *)(this + 0x18) == 0) && (this[0x73] != (CFlipManagerToken)0x0)) {

+    (**(code **)(*(longlong *)this + 0x10))(this);

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

+    FlipManagerConsumerImmediateTokenCompleted(this + -8,(CToken **)0x0,(CFlipManagerSignal **)0x0);

+  }

+  if (*(longlong **)(this + 0x40) != (longlong *)0x0) {

+    (**(code **)(**(longlong **)(this + 0x40) + 0x10))();

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

+  }

+  if (*(longlong *)(this + 0x50) != 0) {

+    ObfDereferenceObject();

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

+  }

+  *(undefined4 *)(this + 0x18) = 6;

+  return;

+}

+
```

## `DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer`  (modified)

```diff
--- DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer
+++ DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer
@@ -1,2 +1,45 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: void __cdecl DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer(unsigned char) __ptr64 */

+

+void __thiscall

+DMMVIDEOPRESENTTARGET::StartLinkTrainingTimer(DMMVIDEOPRESENTTARGET *this,uchar param_1)

+

+{

+  longlong *plVar1;

+  char cVar2;

+  int iVar3;

+  uint uVar4;

+  

+  if ((*(int *)(*(longlong *)(this + 0x218) + 0x98) == 1) ||

+     (*(int *)(*(longlong *)(this + 0x218) + 0x98) == 3)) {

+    iVar3 = Feature_ConditionalDpcFlush__private_IsEnabledDeviceUsageNoInline();

+    if (iVar3 == 0) {

+      KeCancelTimer();

+    }

+    else {

+      cVar2 = KeCancelTimer();

+      if (cVar2 != '\0') goto LAB_0;

+    }

+    KeFlushQueuedDpcs();

+  }

+LAB_0:

+  if ((param_1 == '\0') && (*(int *)(*(longlong *)(this + 0x218) + 0x98) != 2)) {

+    WdLogSingleEntry0();

+    _WdLogGlobalForLineNumber = 0x1d3;

+  }

+  LOCK();

+  iVar3 = *(int *)(*(longlong *)(this + 0x218) + 0x98);

+  *(int *)(*(longlong *)(this + 0x218) + 0x98) = (-(uint)(param_1 != '\0') & 0xfffffffe) + 3;

+  UNLOCK();

+  WdLogSingleEntry2(7,param_1,(longlong)iVar3);

+  plVar1 = *(longlong **)(this + 0x218);

+  _WdLogGlobalForLineNumber = 0x1db;

+  uVar4 = *(uint *)(*(longlong *)(*plVar1 + 0xc48) + 0x214);

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

+    uVar4 = *(int *)(*(longlong *)(*plVar1 + 0xc48) + 0x218) - uVar4;

+  }

+  KeSetTimer(plVar1 + 2,(ulonglong)uVar4 * -100000,plVar1 + 10);

+  return;

+}

+
```

## `DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo`  (modified)

```diff
--- DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo
+++ DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo
@@ -1,2 +1,138 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

+/* public: static unsigned char __cdecl DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo(struct

+   DXGADAPTER_VMBUS_PACKET * __ptr64) */

+

+uchar __cdecl DXG_HOST_VIRTUALGPU_VMBUS::VmBusQueryAdapterInfo(DXGADAPTER_VMBUS_PACKET *param_1)

+

+{

+  int iVar1;

+  DXGKVMB_COMMAND_OPENADAPTER_19H1 *pDVar2;

+  int *piVar3;

+  undefined8 uVar4;

+  int *piVar5;

+  uchar uVar6;

+  uint uVar7;

+  wchar_t *pwVar8;

+  undefined1 auStack_b8 [32];

+  ulonglong local_98;

+  undefined8 local_90;

+  undefined8 local_88;

+  undefined8 local_80;

+  undefined8 local_78;

+  undefined8 local_68;

+  int *piStack_60;

+  ulonglong local_58;

+  DXGAUTOPUSHLOCKSHARED local_50 [24];

+  undefined8 local_38;

+  undefined4 local_30;

+  ulonglong local_28;

+  

+  local_28 = __security_cookie ^ (ulonglong)auStack_b8;

+  DXGAUTOPUSHLOCKSHARED::DXGAUTOPUSHLOCKSHARED

+            (local_50,(DXGPUSHLOCK *)(*(longlong *)(param_1 + 0x50) + 0xf8));

+  uVar6 = '\0';

+  if (*(char *)(*(longlong *)(param_1 + 0x50) + 0xad) == '\0') {

+    WdLogSingleEntry0(2);

+    local_78 = 0;

+    local_80 = 0;

+    local_88 = 0;

+    local_90 = 0;

+    local_98 = 0x1308;

+    _WdLogGlobalForLineNumber = 0x1308;

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"The adapter is already closed by the guest");

+    DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_50);

+    return '\0';

+  }

+  pDVar2 = CastToVmBusCommand<DXGKVMB_COMMAND_OPENADAPTER_19H1>(param_1);

+  if (pDVar2 == (DXGKVMB_COMMAND_OPENADAPTER_19H1 *)0x0) goto LAB_0;

+  piStack_60 = (int *)0x0;

+  local_58 = 0;

+  local_68 = (ulonglong)*(uint *)(pDVar2 + 0x18) << 0x20;

+  uVar7 = *(uint *)(pDVar2 + 0x1c);

+  if (uVar7 == 0) {

+    WdLogSingleEntry0(2);

+    local_78 = 0;

+    local_80 = 0;

+    local_88 = 0;

+    local_90 = 0;

+    local_98 = 0x132c;

+    _WdLogGlobalForLineNumber = 0x132c;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Invalid OutputBufferSize for DXGKVMB_COMMAND_QUERYADAPTERINFO, size is zero");

+    local_38 = 0x35369e9;

+    local_30 = 0;

+    RtlLogUnexpectedCodepath(&local_38);

+    goto LAB_0;

+  }

+  if (((ulonglong)*(uint *)(param_1 + 0x90) - 0x20 < (ulonglong)uVar7) || (0x20000 < uVar7)) {

+    WdLogSingleEntry1(2,uVar7);

+    local_98 = (ulonglong)*(uint *)(pDVar2 + 0x1c);

+    pwVar8 = L"Invalid OutputBufferSize";

+    uVar4 = 0x40000;

+    _WdLogGlobalForLineNumber = 0x1316;

+  }

+  else {

+    local_58 = (ulonglong)uVar7;

+    piVar3 = operator_new__((ulonglong)(uVar7 + 4),0x4b677844,0x40);

+    if (piVar3 != (int *)0x0) {

+      piStack_60 = piVar3 + 1;

+      memmove(piStack_60,pDVar2 + 0x20,(ulonglong)*(uint *)(pDVar2 + 0x1c));

+      iVar1 = Feature_2095820091__private_IsEnabledDeviceUsageNoInline();

+      if ((iVar1 == 0) || (local_68._4_4_ != 0x29)) {

+        iVar1 = DxgkQueryAdapterInfoImpl

+                          ((_D3DKMT_QUERYADAPTERINFO *)&local_68,'\0',

+                           *(DXGADAPTER **)(*(longlong *)(param_1 + 0x50) + 0x10));

+      }

+      else {

+        WdLogSingleEntry1(2);

+        local_98 = (ulonglong)local_68._4_4_;

+        local_78 = 0;

+        local_80 = 0;

+        local_88 = 0;

+        local_90 = 0;

+        _WdLogGlobalForLineNumber = 0x133e;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,L"Unsupported QueryAdapterInfo type over VMBus: 0x%I64x");

+        local_38 = 0x3b76466;

+        local_30 = 0;

+        RtlLogUnexpectedCodepath(&local_38);

+        iVar1 = -0x3ffffff3;

+      }

+      if (*(uint *)(param_1 + 0x98) < 0x27) {

+        uVar6 = '\0';

+        if (-1 < iVar1) {

+          piVar5 = piStack_60;

+          uVar7 = (uint)local_58;

+          goto LAB_1;

+        }

+      }

+      else {

+        *piVar3 = iVar1;

+        piVar5 = piVar3;

+        uVar7 = uVar7 + 4;

+LAB_1:

+        VmBusCompletePacket(*(VMBPACKETCOMPLETION__ **)(param_1 + 0x80),piVar5,uVar7);

+        uVar6 = '\x01';

+      }

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(piVar3);

+      goto LAB_0;

+    }

+    WdLogSingleEntry0(6);

+    local_98 = 0x1320;

+    pwVar8 = L"Failed to allocate pPrivateDriverDate";

+    _WdLogGlobalForLineNumber = 0x1320;

+    uVar4 = 0x40001;

+  }

+  local_78 = 0;

+  local_80 = 0;

+  local_88 = 0;

+  local_90 = 0;

+  DxgkLogInternalTriageEvent(0,uVar4,0xffffffff,pwVar8);

+LAB_0:

+  DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_50);

+  return uVar6;

+}

+
```

## `DXGCONTEXT::PresentMultiPlaneOverlay3`  (modified)

```diff
--- DXGCONTEXT::PresentMultiPlaneOverlay3
+++ DXGCONTEXT::PresentMultiPlaneOverlay3
@@ -1,409 +1,1158 @@
 

-/* WARNING: Instruction at (ram,0x0001402c5e62) overlaps instruction at (ram,0x0001402c5e5f)

-    */

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

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

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

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

+/* public: long __cdecl DXGCONTEXT::PresentMultiPlaneOverlay3(struct

+   _D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 const * __ptr64,class COREDEVICEACCESS * __ptr64,class

+   DXGCONTEXT * __ptr64 * __ptr64) __ptr64 */

 

 long __thiscall

-DXGAUTOMUTEX::PresentMultiPlaneOverlay3

+DXGCONTEXT::PresentMultiPlaneOverlay3

           (DXGCONTEXT *this,_D3DKMT_PRESENT_MULTIPLANE_OVERLAY3 *param_1,COREDEVICEACCESS *param_2,

           DXGCONTEXT **param_3)

 

 {

-  DXGADAPTER *pDVar1;

-  DXGDEVICE *pDVar2;

+  DXGALLOCATIONREFERENCE *pDVar1;

+  uint uVar2;

   uint uVar3;

-  undefined4 uVar4;

-  VIDSCH_EXPORT *this_00;

-  int *piVar5;

+  int iVar4;

+  int iVar5;

   longlong lVar6;

-  undefined *puVar7;

-  undefined1 uVar8;

-  uchar uVar9;

-  char cVar10;

-  byte bVar11;

-  long lVar12;

-  uint uVar13;

-  longlong lVar14;

-  ulonglong uVar15;

-  wchar_t *pwVar16;

-  int iVar17;

-  DXGDEVICE *pDVar18;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  uint unaff_ESI;

-  int unaff_EDI;

-  DXGADAPTER *unaff_R12;

-  DXGADAPTER *unaff_R13;

-  DXGADAPTER *unaff_R14;

-  char cVar19;

-  int iVar20;

-  ulonglong unaff_R15;

-  char in_SF;

-  char in_OF;

-  DXGDEVICE *in_stack_00000050;

-  char cStack0000000000000058;

-  char cStack0000000000000059;

-  char cStack000000000000005a;

-  char cStack000000000000005b;

-  longlong lStack0000000000000060;

-  undefined8 in_stack_00000070;

-  char in_stack_00000078;

-  uint in_stack_0000007c;

+  longlong lVar7;

+  int *piVar8;

+  uint *puVar9;

+  undefined8 *puVar10;

+  undefined4 *puVar11;

+  _D3DKMT_MULTIPLANE_OVERLAY3 *p_Var12;

+  undefined4 uVar13;

+  undefined8 uVar14;

+  bool bVar15;

+  bool bVar16;

+  bool bVar17;

+  bool bVar18;

+  int iVar19;

+  uchar uVar20;

+  bool bVar21;

+  long lVar22;

+  uint uVar23;

+  uint uVar24;

+  int iVar25;

+  undefined4 uVar26;

+  _DXGK_DISPLAYMODE_INFO *p_Var27;

+  DXGGLOBAL *pDVar28;

+  ulonglong uVar29;

+  ADAPTER_DISPLAY *pAVar30;

+  uint uVar31;

+  DXGALLOCATION *pDVar32;

+  uint uVar33;

+  ulonglong uVar34;

+  undefined4 uVar35;

+  wchar_t *pwVar36;

+  ulonglong uVar37;

+  char *pcVar38;

+  undefined1 auStackY_948 [32];

+  uchar local_878;

+  uchar local_877;

+  uchar local_876;

+  uchar local_874;

+  int local_870;

+  uint local_860;

+  uint local_858;

+  uint local_854;

+  int local_850;

+  int local_84c;

+  int iStack_83c;

+  int local_830;

+  longlong local_810;

+  ulonglong local_808;

+  longlong local_800;

+  COREDEVICEACCESS *local_7f8;

+  VIDSCH_SUBMIT_DATA_BASE *local_7f0 [2];

+  uint local_7e0;

+  uint local_7dc;

+  DXGALLOCATIONREFERENCE local_7d8 [8];

+  DXGALLOCATIONREFERENCE local_7d0 [8];

+  DXGALLOCATIONREFERENCE local_7c8 [8];

+  longlong local_7c0;

+  DXGCONTEXT **local_7b8;

+  undefined8 local_7b0;

+  undefined8 uStack_7a8;

+  undefined8 local_7a0;

+  undefined8 uStack_798;

+  undefined8 local_790;

+  undefined8 uStack_788;

+  undefined8 local_780;

+  undefined8 uStack_778;

+  undefined8 local_770;

+  undefined8 uStack_768;

+  undefined8 local_760;

+  undefined8 uStack_758;

+  DXGALLOCATIONREFERENCE *local_750 [5];

+  undefined4 local_728;

+  _DXGKARG_PRESENT local_718 [104];

+  int local_6b0;

+  uint local_6ac;

+  _D3DKMT_PRESENT local_668 [1504];

+  _D3DDDIFORMAT local_88 [10];

+  uchar local_60 [16];

+  ulonglong local_50;

   

-  if (in_OF != in_SF) {

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

-    halt_baddata();

-  }

-  _WdLogGlobalForLineNumber = 0x1dc3;

-  DxgkLogInternalTriageEvent(0);

-  iVar20 = (int)unaff_R15;

-  if (*(int *)(unaff_RBP + -100) != iVar20) {

-    if (*(int *)(in_stack_00000050 + 0x260) != 1) {

-      COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-      if (in_stack_00000050 != (DXGDEVICE *)0x0) {

-        LOCK();

-        pDVar18 = in_stack_00000050 + 0x40;

-        lVar14 = *(longlong *)pDVar18;

-        *(longlong *)pDVar18 = *(longlong *)pDVar18 + unaff_RBX;

-        UNLOCK();

-        if (lVar14 == 1) {

-          ADAPTER_RENDER::DestroyDeviceNoLocks

-                    (*(ADAPTER_RENDER **)(in_stack_00000050 + 0x10),in_stack_00000050);

-        }

-      }

-      LOCK();

-      pDVar1 = unaff_R14 + 0x18;

-      lVar14 = *(longlong *)pDVar1;

-      *(longlong *)pDVar1 = *(longlong *)pDVar1 + unaff_RBX;

-      UNLOCK();

-      if (lVar14 == 1) {

-        DXGGLOBAL::DestroyAdapter(*(DXGGLOBAL **)(unaff_R14 + 0x10),unaff_R14);

-      }

-      KeLeaveCriticalRegion();

-      return -0x3ffffd4a;

-    }

-    unaff_R12 = *(DXGADAPTER **)(unaff_RBP + -0x70);

-    unaff_R13 = *(DXGADAPTER **)(unaff_RBP + -0x60);

-  }

-  cVar19 = (char)unaff_R15;

-  *(int *)(unaff_RBP + -0x78) = iVar20;

-  cStack0000000000000058 = cVar19;

-  cStack0000000000000059 = cVar19;

-  cStack000000000000005a = cVar19;

-  uVar9 = DXGADAPTER::IsVSyncAvailable(unaff_R13,unaff_ESI);

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

-    COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-    if (in_stack_00000050 != (DXGDEVICE *)0x0) {

-      LOCK();

-      pDVar18 = in_stack_00000050 + 0x40;

-      lVar14 = *(longlong *)pDVar18;

-      *(longlong *)pDVar18 = *(longlong *)pDVar18 + unaff_RBX;

-      UNLOCK();

-      if (lVar14 == 1) {

-        ADAPTER_RENDER::DestroyDeviceNoLocks

-                  (*(ADAPTER_RENDER **)(in_stack_00000050 + 0x10),in_stack_00000050);

-      }

-    }

+  local_50 = __security_cookie ^ (ulonglong)auStackY_948;

+  uVar33 = *(uint *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0x1bc) & 0x100;

+  local_7f8 = param_2;

+  local_7e0 = uVar33;

+  local_7b8 = param_3;

+  uVar20 = ADAPTER_RENDER::IsCoreResourceSharedOwner

+                     (*(ADAPTER_RENDER **)(*(longlong *)(this + 0x10) + 0x10));

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

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xcb8;

+    DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"GetRenderCore()->IsCoreResourceSharedOwner()")

+    ;

+  }

+  lVar6 = *(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10);

+  if (((lVar6 != 0) || (uVar33 == 0)) &&

+     (*(longlong *)(*(longlong *)(this + 0x10) + 0x768) != lVar6)) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0xcb9;

+    DxgkLogInternalTriageEvent

+              (0,0x40002,0xffffffff,

+               L"(!GetRenderAdapter() && IsIndirectDisplayDevice) || (GetDisplayAdapter() == GetRenderAdapter())"

+              );

+  }

+  this[0x1b3] = (DXGCONTEXT)0x1;

+  uVar2 = *(uint *)(param_1 + 0x10);

+  if (uVar33 == 0) {

+    uVar31 = *(uint *)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10) +

+                      0xb98);

+  }

+  else {

+    uVar31 = 1;

+  }

+  if (uVar31 < *(uint *)(param_1 + 0x1c)) {

+    WdLogSingleEntry3(3,*(uint *)(param_1 + 0x1c),uVar31,0xffffffffc000000d);

+    _WdLogGlobalForLineNumber = 0xcca;

+    return -0x3ffffff3;

+  }

+  if (uVar33 == 0) {

+    lVar22 = CheckDevicePresentSettings(this,1,0,1,uVar2);

+    if (lVar22 < 0) {

+      WdLogSingleEntry3(3,(longlong)lVar22,this);

+      _WdLogGlobalForLineNumber = 0xcdd;

+      return lVar22;

+    }

+    if ((*(uint *)(*(longlong *)(this + 0x10) + 0x4d8 + (ulonglong)uVar2 * 4) >> 9 & 1) == 0) {

+      WdLogSingleEntry3(3,0xffffffffc01e0019,this,(ulonglong)uVar2);

+      _WdLogGlobalForLineNumber = 0xce6;

+      return -0x3fe1ffe7;

+    }

+  }

+  uVar33 = *(uint *)(param_1 + 0x18) & 3;

+  if (uVar33 != 0) {

+    if (1 < *(uint *)(param_1 + 0x1c)) {

+      WdLogSingleEntry2(2,this,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xcf5;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"DxgkPresentMultiPlaneOverlay doesn\'t support Stereo on more than 1 plane. Context 0x%I64x, Returning 0x%I64x"

+                );

+      return -0x3ffffff3;

+    }

+    if (uVar33 == 3) {

+      WdLogSingleEntry0();

+      _WdLogGlobalForLineNumber = 0xcfc;

+      pwVar36 = 

+      L"FlipStereoTemporaryMono and FlipStereo cannot be set together. STATUS_INVALID_PARAMETER";

+LAB_0:

+      DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar36);

+      return -0x3ffffff3;

+    }

+    if (((byte)*(uint *)(param_1 + 0x18) & 6) == 6) {

+      WdLogSingleEntry0();

+      _WdLogGlobalForLineNumber = 0xd02;

+      pwVar36 = 

+      L"FlipStereoTemporaryMono cannot be used with FlipStereoPreferRight. STATUS_INVALID_PARAMETER"

+      ;

+      goto LAB_0;

+    }

+    DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE

+              ((DXGALLOCATIONREFERENCE *)&local_810,(DXGALLOCATION *)0x0);

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

+    lVar7 = *(longlong *)(*(longlong *)(this + 0x10) + 0x28);

+    uVar33 = **(uint **)(lVar6 + 0x18);

+    DXGPUSHLOCK::AcquireShared((DXGPUSHLOCK *)(lVar7 + 0xf8));

+    uVar23 = uVar33 >> 6 & 0xffffff;

+    if (uVar23 < *(uint *)(lVar7 + 0x128)) {

+      uVar24 = *(uint *)(*(longlong *)(lVar7 + 0x118) + 8 + (ulonglong)uVar23 * 0x10);

+      if (((((byte)(uVar33 >> 0x19) & 0x60) != ((byte)uVar24 & 0x60)) || ((uVar24 >> 0xd & 1) != 0))

+         || ((uVar24 & 0x1f) == 0)) goto LAB_1;

+      if ((uVar24 & 0x1f) != 5) {

+        WdLogSingleEntry0(2);

+        _WdLogGlobalForLineNumber = 0x13e;

+        DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch");

+        goto LAB_1;

+      }

+      pDVar32 = *(DXGALLOCATION **)(*(longlong *)(lVar7 + 0x118) + (ulonglong)uVar23 * 0x10);

+    }

+    else {

+LAB_1:

+      pDVar32 = (DXGALLOCATION *)0x0;

+    }

+    DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE(local_7d8,pDVar32);

     LOCK();

-    pDVar1 = unaff_R14 + 0x18;

-    lVar14 = *(longlong *)pDVar1;

-    *(longlong *)pDVar1 = *(longlong *)pDVar1 + unaff_RBX;

+    *(int *)(lVar7 + 0x108) = *(int *)(lVar7 + 0x108) + -1;

     UNLOCK();

-    if (lVar14 == 1) {

-      DXGGLOBAL::DestroyAdapter(*(DXGGLOBAL **)(unaff_R14 + 0x10),unaff_R14);

-    }

+    ExReleasePushLockSharedEx(lVar7 + 0xf8,0);

     KeLeaveCriticalRegion();

-    return -0x3fe1fffa;

-  }

-  if (*(ulonglong *)(unaff_R13 + 0xc50) == unaff_R15) {

-    ADAPTER_DISPLAY::ControlVSyncAdapter(*(ADAPTER_DISPLAY **)(unaff_R13 + 0xc48),unaff_ESI);

-    lVar14 = *(longlong *)(unaff_RBP + -0x80);

+    DXGALLOCATIONREFERENCE::MoveAssign((DXGALLOCATIONREFERENCE *)&local_810,local_7d8);

+    DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE(local_7d8);

+    if (local_810 == 0) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry3(2,0xffffffffc000000d,this,**(undefined4 **)(lVar6 + 0x18));

+      _WdLogGlobalForLineNumber = 0xd0d;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"ret = 0x%I64x Context 0x%I64x: Invalid allocation handle for plane 0 specified: 0x%I64x"

+                );

+      goto LAB_2;

+    }

+    if ((*(uint *)(*(longlong *)(local_810 + 0x30) + 4) & 0x1000) == 0) {

+      WdLogSingleEntry0(2);

+      _WdLogGlobalForLineNumber = 0xd14;

+      DxgkLogInternalTriageEvent

+                (0,0x40000,0xffffffff,

+                 L"FlipStereoTemporaryMono and FlipStereo can only be used with stereo primary allocations. STATUS_INVALID_PARAMETER"

+                );

+      lVar22 = -0x3ffffff3;

+      goto LAB_2;

+    }

+    p_Var27 = ADAPTER_DISPLAY::GetDisplayModeInfo

+                        (*(ADAPTER_DISPLAY **)

+                          (*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48),

+                         *(uint *)(param_1 + 0x10));

+    if ((*(uint *)(p_Var27 + 0x28) & 0x10) == 0) {

+      WdLogSingleEntry0(2);

+      _WdLogGlobalForLineNumber = 0xd1b;

+      pwVar36 = 

+      L"Stereo flag is set but the current display mode does not support stereo. STATUS_GRAPHICS_PRESENT_MODE_CHANGED"

+      ;

+    }

+    else {

+      if (((*(uint *)(param_1 + 0x18) & 2) == 0) || ((*(uint *)(p_Var27 + 0x28) & 0x20) != 0)) {

+        DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE((DXGALLOCATIONREFERENCE *)&local_810);

+        goto LAB_3;

+      }

+      WdLogSingleEntry0(2);

+      _WdLogGlobalForLineNumber = 0xd21;

+      pwVar36 = 

+      L"FlipStereoTemporaryMono flag is set but the current display mode does not support it. STATUS_GRAPHICS_PRESENT_MODE_CHANGED"

+      ;

+    }

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar36);

+    lVar22 = -0x3fe1fffb;

+LAB_2:

+    DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE((DXGALLOCATIONREFERENCE *)&local_810);

+    return lVar22;

+  }

+LAB_3:

+  local_750[0] = (DXGALLOCATIONREFERENCE *)0x0;

+  local_728 = 0;

+  PagedPoolArray<DXGALLOCATIONREFERENCE,4>::AllocateElements

+            ((PagedPoolArray<DXGALLOCATIONREFERENCE,4> *)local_750,uVar31 * *(int *)(param_1 + 4));

+  if (local_750[0] == (DXGALLOCATIONREFERENCE *)0x0) {

+    WdLogSingleEntry0();

+    _WdLogGlobalForLineNumber = 0xd2d;

+    DxgkLogInternalTriageEvent

+              (0,0x40001,0xffffffff,L"Failed to allocate memory for MPO allocation references");

+    lVar22 = -0x3fffffe9;

+    goto LAB_4;

+  }

+  DXGDEVICE::GetDisplayedAllMultiPlaneOverlays

+            (*(DXGDEVICE **)(this + 0x10),uVar2,local_750[0],uVar31);

+  local_7c0 = *(longlong *)local_750[0];

+  ADAPTER_DISPLAY::GetDDIEnabledPlanes

+            (*(ADAPTER_DISPLAY **)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48),uVar2,

+             local_60);

+  local_88[8] = 0;

+  local_88[9] = 0;

+  local_88[0] = 0;

+  local_88[1] = 0;

+  local_88[2] = 0;

+  local_88[3] = 0;

+  local_88[4] = 0;

+  local_88[5] = 0;

+  local_88[6] = 0;

+  local_88[7] = 0;

+  uVar20 = ADAPTER_RENDER::IsMultiPlaneOverlaySupported

+                     (*(ADAPTER_RENDER **)(*(longlong *)(this + 0x10) + 0x10));

+  if ((uVar20 == '\0') ||

+     (bVar15 = false,

+     *(longlong *)(*(longlong *)(this + 0x10) + 0x768) !=

+     *(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10))) {

+    bVar15 = true;

+  }

+  p_Var27 = ADAPTER_DISPLAY::GetDisplayModeInfo

+                      (*(ADAPTER_DISPLAY **)

+                        (*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48),uVar2);

+  if (p_Var27 == (_DXGK_DISPLAYMODE_INFO *)0x0) {

+    lVar22 = -0x3ffffff3;

+    WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar2);

+    pwVar36 = L"ret = 0x%I64x Context 0x%I64x Failed to obtain display mode, VidPnSourceId 0x%I64x";

+    _WdLogGlobalForLineNumber = 0xd4a;

+LAB_5:

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar36);

+    goto LAB_4;

+  }

+  local_84c = *(int *)p_Var27;

+  local_858 = *(uint *)(p_Var27 + 4);

+  piVar8 = *(int **)(param_1 + 0x28);

+  local_808 = 0;

+  local_830 = 0;

+  local_850 = 0;

+  local_874 = '\0';

+  local_854 = 0;

+  if (piVar8 == (int *)0x0) {

+    local_874 = '\0';

+    local_854 = 0;

+    local_808 = 0;

+    if (bVar15) {

+      if (*(int *)(param_1 + 0x1c) == 1) {

+        if (*(int *)**(undefined8 **)(param_1 + 0x20) == 0) {

+          local_874 = '\0';

+          local_854 = 0;

+          local_808 = 0;

+          if ((((int *)**(undefined8 **)(param_1 + 0x20))[1] & 1U) != 0) goto LAB_6;

+        }

+        local_808 = 0;

+        lVar22 = -0x3ffffff3;

+        WdLogSingleEntry3(2,0xffffffffc000000d,this,1);

+        pwVar36 = 

+        L"0x%I64x Context 0x%I64x PresentMPO fails because the driver doesn\'t support MPO and plane 0 is not enabled"

+        ;

+        _WdLogGlobalForLineNumber = 0xda7;

+      }

+      else {

+        lVar22 = -0x3ffffff3;

+        WdLogSingleEntry3(2,0xffffffffc000000d,this,*(int *)(param_1 + 0x1c));

+        pwVar36 = 

+        L"0x%I64x Context 0x%I64x PresentMPO fails because the driver doesn\'t support MPO and 0x%I64x planes are specified"

+        ;

+        _WdLogGlobalForLineNumber = 0xd9e;

+      }

+      goto LAB_5;

+    }

   }

   else {

-    if (unaff_R13 != unaff_R12) {

-      WdLogSingleEntry0(unaff_EDI);

-      _WdLogGlobalForLineNumber = 0x1dd9;

-      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pDisplayAdapter == pRenderAdapter",0x1dd9);

-    }

-    uVar15 = unaff_R15 & 0xffffffff;

-    if ((*(uint *)(unaff_R12 + 3000) & 0x10) != 0) {

-      uVar15 = (ulonglong)unaff_ESI;

-    }

-    if ((uint)uVar15 < 0x10) {

-      LOCK();

-      *(int *)(unaff_R12 + uVar15 * 4 + 0xc68) =

-           *(int *)(unaff_R12 + uVar15 * 4 + 0xc68) + unaff_EDI;

-      UNLOCK();

-      unaff_R12 = *(DXGADAPTER **)(unaff_RBP + -0x70);

-      if (Microsoft_Windows_DxgKrnlEnableBits < '\0') {

-        McTemplateK0pqq_EtwWriteTransfer(uVar15,&VSyncWaiterChange);

-      }

-      unaff_R13 = *(DXGADAPTER **)(unaff_RBP + -0x60);

-    }

-    cStack0000000000000058 = '\x01';

-    cVar10 = (**(code **)(*(longlong *)(*(longlong *)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e0) + 8)

-                         + 0x228))

-                       (*(undefined8 *)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e8),unaff_ESI);

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

-      this_00 = *(VIDSCH_EXPORT **)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e0);

-      if (in_stack_00000050 == (DXGDEVICE *)0x0) {

-        lVar12 = VIDSCH_EXPORT::VidSchControlVSyncAdapter

-                           (this_00,*(_VIDSCH_GLOBAL **)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e8),1

-                            ,'\x01',unaff_ESI);

-        if (lVar12 < 0) {

-          pDVar18 = (DXGDEVICE *)(ulonglong)unaff_ESI;

-          DXGADAPTER::DecrementVSyncWaiter(unaff_R12,unaff_ESI);

-          COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-          goto LAB_0;

-        }

-        cStack0000000000000059 = '\x01';

+    if (*piVar8 != 0) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry3(3,this,*piVar8,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xd59;

+      goto LAB_4;

+    }

+    if (piVar8[9] != 1) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry3(3,this,(longlong)piVar8[9],0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xd5f;

+      goto LAB_4;

+    }

+    if ((piVar8[3] <= piVar8[1]) || (piVar8[4] <= piVar8[2])) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry2(3,this,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xd65;

+      goto LAB_4;

+    }

+    if ((piVar8[7] <= piVar8[5]) || (piVar8[8] <= piVar8[6])) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry2(3,this,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xd6b;

+      goto LAB_4;

+    }

+    if ((((piVar8[5] < 0) || (local_84c < piVar8[7])) || (piVar8[6] < 0)) ||

+       ((int)local_858 < piVar8[8])) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry2(3,this,0xffffffffc000000d);

+      _WdLogGlobalForLineNumber = 0xd71;

+      goto LAB_4;

+    }

+    if ((*(char *)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10) + 0xc01)

+         == '\0') || (bVar15)) {

+      lVar22 = -0x3ffffff3;

+      WdLogSingleEntry2(3,0xffffffffc000000d,this);

+      _WdLogGlobalForLineNumber = 0xd7c;

+      goto LAB_4;

+    }

+    local_830 = piVar8[1];

+    iVar25 = piVar8[3];

+    uVar33 = (uint)((ulonglong)*(undefined8 *)(piVar8 + 3) >> 0x20);

+    iStack_83c = (int)((ulonglong)*(undefined8 *)(piVar8 + 1) >> 0x20);

+    if (((local_830 == 0) && (iVar25 == local_84c)) && ((piVar8[2] == 0 && (uVar33 == local_858))))

+    {

+      local_850 = iStack_83c;

+      local_858 = piVar8[4];

+      local_84c = iVar25;

+    }

+    else {

+      local_854 = iVar25 - local_830;

+      local_808 = (ulonglong)(uVar33 - piVar8[2]);

+      local_850 = iStack_83c;

+      local_874 = '\x01';

+      local_858 = piVar8[4];

+      local_84c = iVar25;

+    }

+  }

+LAB_6:

+  bVar18 = false;

+  local_860 = 0xffffffff;

+  local_870 = 1;

+  local_876 = '\0';

+  local_877 = '\0';

+  local_878 = '\0';

+  bVar17 = false;

+  if ((*(int *)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10) + 0xbd4) <

+       3000) && (pDVar28 = DXGGLOBAL::GetGlobal(), pDVar28[0x4a6f0] == (DXGGLOBAL)0x0)) {

+    bVar16 = false;

+  }

+  else {

+    bVar16 = true;

+  }

+  uVar37 = 0;

+  uVar33 = 0;

+  if (*(int *)(param_1 + 0x1c) == 0) {

+LAB_7:

+    if (*(char *)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10) + 0xc01) ==

+        '\0') {

+      WdLogSingleEntry0(3);

+      _WdLogGlobalForLineNumber = 0xf8c;

+    }

+    else {

+      local_870 = 0;

+    }

+  }

+  else {

+    do {

+      uVar34 = 0;

+      puVar9 = *(uint **)(*(longlong *)(param_1 + 0x20) + uVar37 * 8);

+      uVar23 = *puVar9;

+      uVar29 = (ulonglong)uVar23;

+      if (uVar31 <= uVar23) {

+        lVar22 = -0x3ffffff3;

+        WdLogSingleEntry3(3,this,uVar23,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0xdbd;

+        goto LAB_4;

+      }

+      uVar24 = 1 << ((byte)uVar23 & 0x1f);

+      if ((uVar33 & uVar24) != 0) {

+        lVar22 = -0x3ffffff3;

+        WdLogSingleEntry3(3,this,uVar23,0xffffffffc000000d);

+        _WdLogGlobalForLineNumber = 0xdc4;

+        goto LAB_4;

+      }

+      local_7dc = uVar33 | uVar24;

+      if ((puVar9[1] & 1) == 0) {

+        pDVar1 = local_750[0] + uVar29 * 8;

+        if ((*(longlong *)pDVar1 != 0) || (local_60[uVar29] != '\0')) {

+          local_878 = local_878 + '\x01';

+        }

+        DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE(local_7c8,(DXGALLOCATION *)0x0);

+        DXGALLOCATIONREFERENCE::MoveAssign(pDVar1,local_7c8);

+        DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE(local_7c8);

       }

       else {

-        lVar12 = VIDSCH_EXPORT::VidSchControlVSyncDevice

-                           (this_00,*(_VIDSCH_DEVICE **)(in_stack_00000050 + 800),0,'\x01',unaff_ESI

+        if ((*(longlong *)(local_750[0] + uVar29 * 8) == 0) && (local_60[uVar29] == '\0')) {

+          local_876 = local_876 + '\x01';

+        }

+        else {

+          local_877 = local_877 + '\x01';

+        }

+        if (puVar9[4] != 0) {

+          do {

+            uVar29 = (ulonglong)((int)uVar34 * uVar31 + uVar23);

+            pDVar1 = local_750[0] + uVar29 * 8;

+            local_800 = *(longlong *)(*(longlong *)(this + 0x10) + 0x28);

+            uVar33 = *(uint *)(*(longlong *)(puVar9 + 6) + uVar34 * 4);

+            DXGPUSHLOCK::AcquireShared((DXGPUSHLOCK *)(local_800 + 0xf8));

+            uVar24 = uVar33 >> 6 & 0xffffff;

+            if (uVar24 < *(uint *)(local_800 + 0x128)) {

+              uVar3 = *(uint *)(*(longlong *)(local_800 + 0x118) + 8 + (ulonglong)uVar24 * 0x10);

+              if (((((byte)(uVar33 >> 0x19) & 0x60) != ((byte)uVar3 & 0x60)) ||

+                  ((uVar3 >> 0xd & 1) != 0)) || ((uVar3 & 0x1f) == 0)) goto LAB_8;

+              if ((uVar3 & 0x1f) != 5) {

+                WdLogSingleEntry0(2);

+                _WdLogGlobalForLineNumber = 0x13e;

+                DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch");

+                goto LAB_8;

+              }

+              pDVar32 = *(DXGALLOCATION **)

+                         (*(longlong *)(local_800 + 0x118) + (ulonglong)uVar24 * 0x10);

+            }

+            else {

+LAB_8:

+              pDVar32 = (DXGALLOCATION *)0x0;

+            }

+            DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE(local_7d0,pDVar32);

+            LOCK();

+            *(int *)(local_800 + 0x108) = *(int *)(local_800 + 0x108) + -1;

+            UNLOCK();

+            ExReleasePushLockSharedEx(local_800 + 0xf8,0);

+            KeLeaveCriticalRegion();

+            DXGALLOCATIONREFERENCE::MoveAssign(pDVar1,local_7d0);

+            DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE(local_7d0);

+            lVar6 = *(longlong *)(local_750[0] + uVar29 * 8);

+            if (lVar6 == 0) {

+              lVar22 = -0x3ffffff3;

+              WdLogSingleEntry3(3,0xffffffffc000000d,this,

+                                *(undefined4 *)(*(longlong *)(puVar9 + 6) + uVar34 * 4));

+              _WdLogGlobalForLineNumber = 0xde2;

+              goto LAB_4;

+            }

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

+                *(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10)) {

+              lVar22 = -0x3ffffff3;

+              WdLogSingleEntry3(2,*(longlong *)(this + 0x10),lVar6,0xffffffffc000000d);

+              pwVar36 = L"Device 0x%p does not match allocation 0x%p owner, returning 0x%I64x";

+              _WdLogGlobalForLineNumber = 0xdeb;

+              goto LAB_5;

+            }

+            uVar33 = (int)uVar34 + 1;

+            uVar34 = (ulonglong)uVar33;

+          } while (uVar33 < puVar9[4]);

+        }

+        iVar25 = IsMSRC110351_Enabled();

+        uVar29 = (ulonglong)uVar23;

+        if ((iVar25 != 0) && (*(longlong *)(local_750[0] + uVar29 * 8) == 0)) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry3(3,0xffffffffc000000d,this,uVar29);

+          _WdLogGlobalForLineNumber = 0xdfb;

+          goto LAB_4;

+        }

+        if ((*(uint *)(*(longlong *)(*(longlong *)(local_750[0] + uVar29 * 8) + 0x30) + 4) & 0x2000)

+            == 0) {

+          if ((*(uint *)(*(longlong *)(*(longlong *)(local_750[0] + uVar29 * 8) + 0x30) + 4) & 0xb)

+              == 0) {

+            if ((local_7e0 == 0) || ((*(uint *)(param_1 + 0x18) & 0x400) == 0)) {

+              lVar22 = -0x3ffffff3;

+              WdLogSingleEntry5(2,0xffffffffc000000d,this);

+              pwVar36 = L"0x%I64x 0x%I64x Source of Flip must be primary 0x%I64x 0x%I64x 0x%I64x";

+              _WdLogGlobalForLineNumber = 0xe5c;

+              goto LAB_5;

+            }

+          }

+          else if ((*(byte *)(*(longlong *)(*(longlong *)(local_750[0] + uVar29 * 8) + 0x30) + 4) &

+                   1) != 0) {

+            local_860 = uVar23;

+          }

+        }

+        else if ((*(uint *)(*(longlong *)(*(DXGALLOCATION **)(local_750[0] + uVar29 * 8) + 0x30) + 4

+                           ) & 0x20) == 0) {

+          uVar20 = DXGDEVICE::IsDirectFlipAllocationRequestedPinned

+                             (*(DXGDEVICE **)(this + 0x10),

+                              *(DXGALLOCATION **)(local_750[0] + uVar29 * 8));

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

+            WdLogSingleEntry5(4,0xffffffffc01e0005,this);

+            _WdLogGlobalForLineNumber = 0xe1c;

+LAB_9:

+            lVar22 = -0x3fe1ffe8;

+            goto LAB_4;

+          }

+          bVar21 = VIDMM_EXPORT::VidMmIsAllocationPinned

+                             (*(VIDMM_EXPORT **)

+                               (*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x2f8),

+                              *(VIDMM_GLOBAL **)

+                               (*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x300),

+                              *(VIDMM_MULTI_ALLOC **)

+                               (*(longlong *)(local_750[0] + uVar29 * 8) + 0x18));

+          if (!bVar21) {

+            MicrosoftTelemetryAssertTriggeredArgsMsgKM

+                      (*(longlong *)(*(longlong *)(this + 0x10) + 0x10),

+                       *(undefined4 *)

+                        (*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x10) +

+                        0xbd4),0,"DFlip allocation unpinned");

+            lVar22 = VIDMM_EXPORT::VidMmPinAllocation

+                               (*(VIDMM_EXPORT **)

+                                 (*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x2f8),

+                                *(VIDMM_GLOBAL **)

+                                 (*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x300),

+                                *(VIDMM_MULTI_ALLOC **)

+                                 (*(longlong *)(local_750[0] + (ulonglong)uVar23 * 8) + 0x18),

+                                (VIDMM_PAGING_QUEUE *)0x0,(ulong *)0x0,(_LARGE_INTEGER *)0x0,

+                                (__uint64 *)0x0);

+            if (lVar22 < 0) {

+              WdLogSingleEntry4(4,*(longlong *)(local_750[0] + (ulonglong)uVar23 * 8),

+                                *(undefined8 *)

+                                 (*(longlong *)(local_750[0] + (ulonglong)uVar23 * 8) + 0x30),

+                                **(undefined4 **)(puVar9 + 6));

+              _WdLogGlobalForLineNumber = 0xe3b;

+              goto LAB_9;

+            }

+          }

+        }

+        uVar29 = (ulonglong)uVar23;

+        uStack_798 = 0;

+        local_790 = 0;

+        uStack_788 = 0;

+        local_780 = 0;

+        uStack_778 = 0;

+        local_7a0 = *(undefined8 *)

+                     (*(longlong *)(*(longlong *)(local_750[0] + uVar29 * 8) + 0x30) + 0x10);

+        lVar22 = ADAPTER_RENDER::DdiDescribeAllocation

+                           (*(ADAPTER_RENDER **)(*(longlong *)(this + 0x10) + 0x10),

+                            (_DXGKARG_DESCRIBEALLOCATION *)&local_7a0);

+        uVar34 = 0;

+        if (lVar22 < 0) {

+          WdLogSingleEntry4(2,(longlong)lVar22,this,

+                            *(undefined8 *)

+                             (*(longlong *)(*(longlong *)(local_750[0] + uVar29 * 8) + 0x30) + 0x10)

                            );

-        if (lVar12 < 0) {

-          pDVar18 = (DXGDEVICE *)(ulonglong)unaff_ESI;

-          DXGADAPTER::DecrementVSyncWaiter(unaff_R12,unaff_ESI);

-          COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-          LOCK();

-          pDVar2 = in_stack_00000050 + 0x40;

-          lVar14 = *(longlong *)pDVar2;

-          *(longlong *)pDVar2 = *(longlong *)pDVar2 + unaff_RBX;

-          UNLOCK();

-          if (lVar14 == 1) {

-            ADAPTER_RENDER::DestroyDeviceNoLocks

-                      (*(ADAPTER_RENDER **)(in_stack_00000050 + 0x10),in_stack_00000050);

-            pDVar18 = in_stack_00000050;

-          }

-LAB_0:

-          DXGADAPTER::ReleaseReference(unaff_R14,(__uint64)pDVar18);

-          DXGCRITICALREGION::Leave((DXGCRITICALREGION *)&stack0x00000068);

-          return -0x3fe1fffa;

-        }

-        cStack000000000000005a = '\x01';

-      }

-    }

-    lVar14 = *(longlong *)(unaff_RBP + -0x80);

-    piVar5 = *(int **)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e0);

-    if ((*(longlong *)(lVar14 + 0x40) != 0) &&

-       (*(longlong *)(*(longlong *)(lVar14 + 0x40) + 0x10 + (ulonglong)(*piVar5 - 1) * 8) != 0)) {

-      (**(code **)(*(longlong *)(piVar5 + 2) + 0x430))

-                (*(undefined8 *)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e8));

-    }

-  }

-  COREADAPTERACCESS::Release((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-  lVar14 = *(longlong *)(lVar14 + 0x40);

-  uVar15 = (ulonglong)in_stack_0000007c;

-  uVar3 = *(uint *)(unaff_RBP + -0x68);

-  *(undefined4 *)(unaff_RBP + -0x80) = 0x3c;

-  cStack000000000000005b = *(char *)(lVar14 + 0x8a);

-  lStack0000000000000060 = uVar15 * 0xfb8;

-  uVar8 = in_stack_00000078;

-  do {

-    in_stack_00000078 = uVar8;

-    uVar13 = ADAPTER_DISPLAY::WaitForEventsOrVerticalBlankEvent

-                       (*(ADAPTER_DISPLAY **)(unaff_R13 + 0xc48),(uint)uVar15,true,uVar3,

-                        *(void ***)(unaff_RBP + -0x40),*(_LARGE_INTEGER **)(unaff_RBP + -0x50));

-    uVar3 = *(uint *)(unaff_RBP + -0x68);

-    if (((-1 < (int)uVar13) && ((int)uVar13 <= (int)uVar3)) || (uVar13 == 0x102)) {

-      *(uint *)(unaff_RBP + -0x78) = uVar13;

-    }

-    lVar14 = *(longlong *)(unaff_R13 + 0xc48);

-    iVar17 = *(int *)(unaff_RBP + -0x80) + -1;

-    *(int *)(unaff_RBP + -0x80) = iVar17;

-    in_stack_00000078 = *(char *)(*(longlong *)(lVar14 + 0x80) + 0x3b0 + lStack0000000000000060);

-    if (((uVar13 != uVar3) || (cStack000000000000005b != cVar19)) || (in_stack_00000078 != '\0')) {

-      if (iVar17 != 0) goto LAB_1;

-      break;

-    }

-    uVar15 = (ulonglong)in_stack_0000007c;

-    uVar8 = 0;

-  } while (iVar17 != 0);

-  LOCK();

-  pDVar1 = unaff_R13 + 0x1398;

-  iVar17 = *(int *)pDVar1;

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

-  UNLOCK();

-  if (iVar17 + 1U < 2) {

-    *(ulonglong *)(unaff_RBP + -0x50) = unaff_R15;

-    *(undefined1 *)(unaff_RBP + -0x50) = 1;

-    lVar12 = DxgCreateLiveDumpWithWdLogs2(0x193);

-    uVar3 = DAT_2;

-    lVar14 = *(longlong *)(unaff_RBP + -0x60);

-    *(undefined4 *)(unaff_RBP + -0x80) = *(undefined4 *)(lVar14 + 0x19c);

-    uVar4 = *(undefined4 *)(lVar14 + 0x1a0);

-    *(undefined4 *)(unaff_RBP + -0x7c) = uVar4;

-    if (((5 < uVar3) && ((_DAT_3 & 0x400000400000) != 0)) &&

-       ((DAT_4 & 0x400000400000) == DAT_4)) {

-      *(uint *)(unaff_RBP + -0x38) = (uint)*(byte *)(lVar14 + 0xd1);

-      bVar11 = WdIsDebuggerPresent(CONCAT71((uint7)(uint3)((uint)uVar4 >> 8),1));

-      *(undefined8 *)(unaff_RBP + 0x1f8) = 4;

-      *(uint *)(unaff_RBP + -0x34) = (uint)bVar11;

-      *(undefined4 *)(unaff_RBP + -0x30) = *(undefined4 *)(lVar14 + 0xca8);

-      *(uint *)(unaff_RBP + -0x2c) = (uint)*(byte *)(lVar14 + 0xc05);

-      *(long *)(unaff_RBP + -0x28) = lVar12;

-      *(undefined2 *)(unaff_RBP + -0x68) = *(undefined2 *)(lVar14 + 0xbd4);

-      *(undefined8 *)(unaff_RBP + -0x10) = *(undefined8 *)(lVar14 + 0x7f0);

-      pwVar16 = *(wchar_t **)(lVar14 + 0x7e8);

-      *(undefined4 *)(unaff_RBP + -0x24) = *(undefined4 *)(lVar14 + 0x1b4);

-      *(undefined4 *)(unaff_RBP + -0x20) = *(undefined4 *)(lVar14 + 0x1b0);

-      *(undefined4 *)(unaff_RBP + -0x48) = *(undefined4 *)(lVar14 + 0x1ac);

-      *(undefined4 *)(unaff_RBP + -0x44) = *(undefined4 *)(lVar14 + 0x1a8);

-      *(undefined4 *)(unaff_RBP + -0x40) = *(undefined4 *)(lVar14 + 0x1a4);

-      *(undefined8 *)(unaff_RBP + -8) = *(undefined8 *)(unaff_RBP + -0x80);

-      *(longlong *)(unaff_RBP + 0x1f0) = unaff_RBP + -0x38;

-      *(longlong *)(unaff_RBP + 0x1e0) = unaff_RBP + -0x34;

-      *(longlong *)(unaff_RBP + 0x1d0) = unaff_RBP + -0x30;

-      *(longlong *)(unaff_RBP + 0x1c0) = unaff_RBP + -0x2c;

-      *(longlong *)(unaff_RBP + 0x1b0) = unaff_RBP + -0x28;

-      *(longlong *)(unaff_RBP + 0x1a0) = unaff_RBP + -0x68;

-      *(longlong *)(unaff_RBP + 400) = unaff_RBP + -0x10;

-      in_stack_00000070 = 0x1000000;

-      *(undefined2 *)(unaff_RBP + -100) = 1;

-      *(undefined8 *)(unaff_RBP + 0x1e8) = 4;

-      *(undefined8 *)(unaff_RBP + 0x1d8) = 4;

-      *(undefined8 *)(unaff_RBP + 0x1c8) = 4;

-      *(undefined8 *)(unaff_RBP + 0x1b8) = 4;

-      *(undefined8 *)(unaff_RBP + 0x1a8) = 2;

-      *(undefined8 *)(unaff_RBP + 0x198) = 8;

-      lVar14 = unaff_RBX;

-      if (pwVar16 == (wchar_t *)0x0) {

-        pwVar16 = L"";

-        iVar17 = 2;

+          _WdLogGlobalForLineNumber = 0xe69;

+          pwVar36 = L"ret = 0x%I64x Context 0x%I64x: DdiDescribeAllocation failed 0x%I64x 0x%I64x";

+          goto LAB_5;

+        }

+        local_88[uVar29] = (_D3DDDIFORMAT)local_790;

+        lVar6 = *(longlong *)(puVar9 + 0xc);

+        if ((*(int *)(lVar6 + 0xc) <= *(int *)(lVar6 + 4)) ||

+           (*(int *)(lVar6 + 0x10) <= *(int *)(lVar6 + 8))) {

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          _WdLogGlobalForLineNumber = 0xe75;

+LAB_10:

+          lVar22 = -0x3ffffff3;

+          pwVar36 = L"ret = 0x%I64x Context 0x%I64x Source rect is invalid, index 0x%I64x";

+          goto LAB_5;

+        }

+        iVar25 = (int)uStack_798;

+        iVar19 = uStack_798._4_4_;

+        if ((((*(int *)(lVar6 + 4) < 0) || ((int)uStack_798 < *(int *)(lVar6 + 0xc))) ||

+            (*(int *)(lVar6 + 8) < 0)) || (uStack_798._4_4_ < *(int *)(lVar6 + 0x10))) {

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          _WdLogGlobalForLineNumber = 0xe7d;

+LAB_11:

+          lVar22 = -0x3ffffff3;

+          pwVar36 = 

+          L"ret = 0x%I64x Context 0x%I64x Source rect is outside of allocation rect, index 0x%I64x";

+          goto LAB_5;

+        }

+        iVar4 = *(int *)(lVar6 + 0x24);

+        iVar5 = *(int *)(lVar6 + 0x2c);

+        if ((iVar5 <= iVar4) || (*(int *)(lVar6 + 0x30) <= *(int *)(lVar6 + 0x28))) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          pwVar36 = L"ret = 0x%I64x Context 0x%I64x Clip rect is invalid, index 0x%I64x";

+          _WdLogGlobalForLineNumber = 0xe88;

+          goto LAB_5;

+        }

+        if ((*(int *)(lVar6 + 0x1c) <= *(int *)(lVar6 + 0x14)) ||

+           (*(int *)(lVar6 + 0x20) <= *(int *)(lVar6 + 0x18))) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          pwVar36 = L"ret = 0x%I64x Context 0x%I64x Destination rect is invalid, index 0x%I64x";

+          _WdLogGlobalForLineNumber = 0xe8f;

+          goto LAB_5;

+        }

+        if ((((iVar4 < local_830) || (local_84c < iVar5)) || (*(int *)(lVar6 + 0x28) < local_850))

+           || ((int)local_858 < *(int *)(lVar6 + 0x30))) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          _WdLogGlobalForLineNumber = 0xe96;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"ret = 0x%I64x Context 0x%I64x Clip rect is outside of virtual mode rect, index 0x%I64x"

+                    );

+          uVar33 = *(uint *)(*(longlong *)(puVar9 + 0xc) + 0x30) & 0xffff;

+          MicrosoftTelemetryAssertTriggeredArgsMsgKM

+                    (uVar33,*(int *)(*(longlong *)(puVar9 + 0xc) + 0x2c) << 0x10 | uVar33,

+                     local_84c << 0x10 | local_858 & 0xffff,"ClipRect outside VirtualModeRect");

+          goto LAB_4;

+        }

+        if (((iVar4 < *(int *)(lVar6 + 0x14)) || (*(int *)(lVar6 + 0x1c) < iVar5)) ||

+           ((*(int *)(lVar6 + 0x28) < *(int *)(lVar6 + 0x18) ||

+            (*(int *)(lVar6 + 0x20) < *(int *)(lVar6 + 0x30))))) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+          _WdLogGlobalForLineNumber = 0xea6;

+          DxgkLogInternalTriageEvent

+                    (0,0x40000,0xffffffff,

+                     L"ret = 0x%I64x Context 0x%I64x Clip rect is outside of destination rect, index 0x%I64x"

+                    );

+          lVar6 = *(longlong *)(puVar9 + 0xc);

+          uVar33 = *(uint *)(lVar6 + 0x30) & 0xffff;

+          MicrosoftTelemetryAssertTriggeredArgsMsgKM

+                    (uVar33,*(int *)(lVar6 + 0x2c) << 0x10 | uVar33,

+                     *(int *)(lVar6 + 0x1c) << 0x10 | *(uint *)(lVar6 + 0x20) & 0xffff,

+                     "ClipRect outside DestRect");

+          goto LAB_4;

+        }

+        iVar4 = *(int *)(lVar6 + 0x34);

+        if (iVar4 == 0) {

+          *(undefined4 *)(lVar6 + 0x34) = 1;

+        }

+        else if (((iVar4 != 1) && (iVar4 != 2)) && ((iVar4 != 3 && (iVar4 != 4)))) {

+          lVar22 = -0x3ffffff3;

+          WdLogSingleEntry4(2,0xffffffffc000000d,this,uVar37);

+          pwVar36 = 

+          L"ret = 0x%I64x Context 0x%I64x rotation is not valid, index 0x%I64x, rotation 0xI64x";

+          _WdLogGlobalForLineNumber = 0xec9;

+          goto LAB_5;

+        }

+        bVar21 = true;

+        if (*(uint *)(lVar6 + 0x3c) != 0) {

+          do {

+            if (!bVar21) goto LAB_12;

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

+            iVar4 = *(int *)(lVar7 + uVar34 * 0x10);

+            iVar5 = *(int *)(lVar7 + uVar34 * 0x10 + 8);

+            if ((iVar5 <= iVar4) ||

+               (*(int *)(lVar7 + 0xc + uVar34 * 0x10) <= *(int *)(lVar7 + 4 + uVar34 * 0x10))) {

+              bVar21 = false;

+            }

+            if ((((iVar4 < *(int *)(lVar6 + 4)) || (*(int *)(lVar6 + 0xc) < iVar5)) ||

+                (*(int *)(lVar7 + 4 + uVar34 * 0x10) < *(int *)(lVar6 + 8))) ||

+               (*(int *)(lVar6 + 0x10) < *(int *)(lVar7 + 0xc + uVar34 * 0x10))) {

+              bVar21 = false;

+            }

+            uVar33 = (int)uVar34 + 1;

+            uVar34 = (ulonglong)uVar33;

+          } while (uVar33 < *(uint *)(lVar6 + 0x3c));

+          if (!bVar21) {

+LAB_12:

+            *(undefined4 *)(lVar6 + 0x3c) = 0;

+          }

+        }

+        if ((*(char *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xbe2) != '\0') &&

+           (((lVar7 = *(longlong *)(puVar9 + 0xc), *(int *)(lVar7 + 0x14) != *(int *)(lVar7 + 0x24)

+             || (*(int *)(lVar7 + 0x1c) != *(int *)(lVar7 + 0x2c))) ||

+            ((*(int *)(lVar7 + 0x18) != *(int *)(lVar7 + 0x28) ||

+             (*(int *)(lVar7 + 0x20) != *(int *)(lVar7 + 0x30))))))) {

+          local_7b0 = 0;

+          uStack_7a8 = 0;

+          InverseXformMPORect3(&local_7b0);

+          *(undefined4 *)(lVar6 + 4) = (undefined4)local_7b0;

+          *(undefined4 *)(lVar6 + 8) = local_7b0._4_4_;

+          *(undefined4 *)(lVar6 + 0xc) = (undefined4)uStack_7a8;

+          *(undefined4 *)(lVar6 + 0x10) = uStack_7a8._4_4_;

+          lVar7 = *(longlong *)(puVar9 + 0xc);

+          uVar35 = *(undefined4 *)(lVar7 + 0x28);

+          uVar26 = *(undefined4 *)(lVar7 + 0x2c);

+          uVar13 = *(undefined4 *)(lVar7 + 0x30);

+          *(undefined4 *)(lVar6 + 0x14) = *(undefined4 *)(lVar7 + 0x24);

+          *(undefined4 *)(lVar6 + 0x18) = uVar35;

+          *(undefined4 *)(lVar6 + 0x1c) = uVar26;

+          *(undefined4 *)(lVar6 + 0x20) = uVar13;

+          if ((*(int *)(lVar6 + 0xc) <= *(int *)(lVar6 + 4)) ||

+             (*(int *)(lVar6 + 0x10) <= *(int *)(lVar6 + 8))) {

+            WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+            _WdLogGlobalForLineNumber = 0xef5;

+            goto LAB_10;

+          }

+          if ((*(int *)(lVar6 + 0x1c) <= *(int *)(lVar6 + 0x14)) ||

+             (*(int *)(lVar6 + 0x20) <= *(int *)(lVar6 + 0x18))) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+            pwVar36 = L"ret = 0x%I64x Context 0x%I64x Dest rect is invalid, index 0x%I64x";

+            _WdLogGlobalForLineNumber = 0xefc;

+            goto LAB_5;

+          }

+          if ((((*(int *)(lVar6 + 4) < 0) || (iVar25 < *(int *)(lVar6 + 0xc))) ||

+              (*(int *)(lVar6 + 8) < 0)) || (iVar19 < *(int *)(lVar6 + 0x10))) {

+            WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+            _WdLogGlobalForLineNumber = 0xf03;

+            goto LAB_11;

+          }

+          if (((*(int *)(lVar6 + 0x14) < local_830) || (local_84c < *(int *)(lVar6 + 0x1c))) ||

+             ((*(int *)(lVar6 + 0x18) < local_850 || ((int)local_858 < *(int *)(lVar6 + 0x20))))) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry3(2,0xffffffffc000000d,this,uVar37);

+            pwVar36 = 

+            L"ret = 0x%I64x Context 0x%I64x Dest rect is outside of screen rect, index 0x%I64x";

+            _WdLogGlobalForLineNumber = 0xf0a;

+            goto LAB_5;

+          }

+        }

+        if (uVar23 == 0) {

+          if (local_7c0 != 0) {

+            if ((*(uint *)(*(longlong *)(*(longlong *)local_750[0] + 0x30) + 4) >> 0xd & 1) == 0) {

+              if ((*(uint *)(*(longlong *)(local_7c0 + 0x30) + 4) >> 0xd & 1) != 0) {

+                bVar18 = true;

+              }

+            }

+            else if ((*(uint *)(*(longlong *)(local_7c0 + 0x30) + 4) >> 0xd & 1) == 0) {

+              bVar18 = true;

+            }

+          }

+          uVar33 = *(int *)(lVar6 + 0xc) - *(int *)(lVar6 + 4);

+          if (((*(int *)(lVar6 + 0x1c) - *(int *)(lVar6 + 0x14) != uVar33) ||

+              (*(int *)(lVar6 + 0x20) - *(int *)(lVar6 + 0x18) !=

+               *(int *)(lVar6 + 0x10) - *(int *)(lVar6 + 8))) &&

+             (*(char *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xbb2) != '\0')) {

+            local_808 = CONCAT44(local_808._4_4_,*(int *)(lVar6 + 0x10) - *(int *)(lVar6 + 8));

+            local_874 = '\x01';

+            local_854 = uVar33;

+          }

+        }

+        if (bVar15) {

+          if ((((((*(int *)(lVar6 + 0x14) != *(int *)(lVar6 + 4)) ||

+                 (*(int *)(lVar6 + 0x1c) != *(int *)(lVar6 + 0xc))) ||

+                (*(int *)(lVar6 + 0x18) != *(int *)(lVar6 + 8))) ||

+               ((*(int *)(lVar6 + 0x20) != *(int *)(lVar6 + 0x10) ||

+                (*(int *)(lVar6 + 0x14) != *(int *)(lVar6 + 0x24))))) ||

+              (*(int *)(lVar6 + 0x1c) != *(int *)(lVar6 + 0x2c))) ||

+             ((*(int *)(lVar6 + 0x18) != *(int *)(lVar6 + 0x28) ||

+              (*(int *)(lVar6 + 0x20) != *(int *)(lVar6 + 0x30))))) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry2(2,0xffffffffc000000d,this);

+            _WdLogGlobalForLineNumber = 0xf32;

+            pwVar36 = 

+            L"0x%I64x Context 0x%I64x PresentMPO fails because the driver doesn\'t support MPO and Source/Dest/Clip rects are not identical"

+            ;

+            goto LAB_5;

+          }

+          if (*(int *)(*(longlong *)(puVar9 + 0xc) + 0x34) != 1) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry3(2,0xffffffffc000000d,this,*(int *)(*(longlong *)(puVar9 + 0xc) + 0x34)

+                             );

+            pwVar36 = 

+            L"0x%I64x Context 0x%I64x PresentMPO fails because the driver doesn\'t support MPO and rotation 0x%I64x is specified"

+            ;

+            _WdLogGlobalForLineNumber = 0xf3b;

+            goto LAB_5;

+          }

+          if (uVar2 != (*(uint *)(*(longlong *)

+                                   (*(longlong *)(local_750[0] + (ulonglong)uVar23 * 8) + 0x30) + 4)

+                        >> 6 & 0xf)) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry4(2,0xffffffffc000000d,this,uVar2);

+            pwVar36 = 

+            L"0x%I64x Context 0x%I64x PresentMPO fails because the driver doesn\'t support MPO and VidPnSourceId (0x%I64x) doesn\'t match the surface VidPnSOurceId (0x%I64x)"

+            ;

+            _WdLogGlobalForLineNumber = 0xf44;

+            goto LAB_5;

+          }

+        }

+      }

+      if (((puVar9[1] & 1) != 0) || (bVar16)) {

+        uVar33 = puVar9[2];

+        if (uVar33 != 0) {

+          if (uVar33 != 1) {

+            lVar22 = -0x3ffffff3;

+            WdLogSingleEntry3(3,this,(longlong)(int)uVar33,0xffffffffc000000d);

+            _WdLogGlobalForLineNumber = 0xf6a;

+            goto LAB_4;

+          }

+          bVar17 = true;

+        }

+      }

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

+        local_800 = CONCAT44(local_800._4_4_,**(undefined4 **)(puVar9 + 0xc));

+        if (**(uint **)(puVar9 + 6) != 0) {

+          VIDMM_EXPORT::VidMmETWAllocationHandle

+                    (*(VIDMM_EXPORT **)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x2f8),

+                     *(VIDMM_GLOBAL **)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x300),

+                     **(uint **)(puVar9 + 6));

+        }

+        if (Microsoft_Windows_DxgKrnlEnableBits < '\0') {

+          McTemplateK0qqqpqddddddddddddqqqqqq_EtwWriteTransfer();

+        }

+      }

+      uVar23 = (int)uVar37 + 1;

+      uVar37 = (ulonglong)uVar23;

+      uVar33 = local_7dc;

+    } while (uVar23 < *(uint *)(param_1 + 0x1c));

+    if (!bVar17) goto LAB_7;

+  }

+  if (((local_876 == '\0') && (local_877 == '\0')) && (local_878 == '\0')) {

+    WdLogSingleEntry2(4,0,this);

+    _WdLogGlobalForLineNumber = 0xf97;

+LAB_13:

+    lVar22 = 0;

+    goto LAB_4;

+  }

+  memset(local_718,0,0xa8);

+  uVar33 = 4;

+  if (!bVar15) {

+    uVar33 = 0x1004;

+  }

+  local_6ac = (*(uint *)(param_1 + 0x18) & 7) << 8 ^ uVar33 | 8;

+  local_6b0 = local_870;

+  CVidSchSubmitData::CVidSchSubmitData

+            ((CVidSchSubmitData *)local_7f0,*(ADAPTER_RENDER **)(*(longlong *)(this + 0x10) + 0x10),

+             true);

+  if (local_7f0[0] == (VIDSCH_SUBMIT_DATA_BASE *)0x0) {

+    WdLogSingleEntry0();

+    _WdLogGlobalForLineNumber = 0xfb0;

+    DxgkLogInternalTriageEvent(0,0x40001,0xffffffff,L"Failed to allocate VidSchSubmitData");

+    CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+    PagedPoolArray<DXGALLOCATIONREFERENCE,4>::~PagedPoolArray<DXGALLOCATIONREFERENCE,4>

+              ((PagedPoolArray<DXGALLOCATIONREFERENCE,4> *)local_750);

+    return -0x3fffffe9;

+  }

+  uVar33 = *(uint *)local_7f0[0];

+  uVar35 = 1;

+  *(uint *)local_7f0[0] = uVar33 | 0x30020;

+  uVar31 = uVar33 | 0x30021;

+  *(undefined4 *)(local_7f0[0] + 0x70) = *(undefined4 *)(param_1 + 0x14);

+  *(uint *)local_7f0[0] = uVar31;

+  if (bVar18) {

+    uVar31 = uVar33 | 0x430021;

+    *(uint *)local_7f0[0] = uVar31;

+  }

+  uVar33 = uVar31 | 4;

+  *(uint *)local_7f0[0] = uVar33;

+  if ((!bVar15) && (*(uint *)(param_1 + 4) < 2)) {

+    uVar33 = uVar31 | 0x800004;

+    *(uint *)local_7f0[0] = uVar33;

+  }

+  uVar33 = (*(uint *)(param_1 + 0x18) >> 1 ^ uVar33) & 8 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  uVar33 = (*(uint *)(param_1 + 0x18) >> 1 ^ uVar33) & 0x10 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  uVar33 = (*(int *)(param_1 + 0x18) << 0x13 ^ uVar33) & 0x80000 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  uVar33 = (*(int *)(param_1 + 0x18) << 0x13 ^ uVar33) & 0x100000 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  uVar33 = (*(int *)(param_1 + 0x18) << 0x13 ^ uVar33) & 0x200000 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  uVar33 = (*(int *)(param_1 + 0x18) << 0x15 ^ uVar33) & 0x20000000 ^ uVar33;

+  *(uint *)local_7f0[0] = uVar33;

+  if ((*(uint *)(param_1 + 0x18) & 0x40) == 0) {

+    uVar26 = 0;

+  }

+  else {

+    uVar26 = *(undefined4 *)(param_1 + 0x30);

+  }

+  *(undefined4 *)(local_7f0[0] + 0x90) = uVar26;

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

+    uVar35 = *(undefined4 *)(param_1 + 0x48);

+  }

+  uVar37 = (ulonglong)uVar2;

+  *(uint *)(local_7f0[0] + 0x74) = uVar2;

+  *(undefined4 *)(local_7f0[0] + 0x98) = uVar35;

+  *(int *)(local_7f0[0] + 0x7c) = local_870;

+  *(undefined4 *)(local_7f0[0] + 0x78) = 5;

+  if (((*(uint *)(param_1 + 0x18) & 0x200) != 0) && (local_870 == 0)) {

+    *(uint *)local_7f0[0] = uVar33 | 0x10000000;

+  }

+  pDVar28 = DXGGLOBAL::GetGlobal();

+  if ((pDVar28[0x4a6f0] != (DXGGLOBAL)0x0) ||

+     ((*(uint *)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48) + 0x18) &

+      0x10) != 0)) {

+    uVar20 = ADAPTER_DISPLAY::IsHdrEnabled

+                       (*(ADAPTER_DISPLAY **)

+                         (*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48),uVar2);

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

+      *(uint *)local_7f0[0] = *(uint *)local_7f0[0] | 0x40000000;

+      *(undefined4 *)(local_7f0[0] + 0x168) = 0;

+    }

+    else {

+      uVar31 = (*(int *)(param_1 + 0x18) << 0x17 ^ *(uint *)local_7f0[0]) & 0x40000000 ^

+               *(uint *)local_7f0[0];

+      *(uint *)local_7f0[0] = uVar31;

+      *(undefined4 *)(local_7f0[0] + 0x168) = *(undefined4 *)(param_1 + 0x34);

+      uVar33 = *(uint *)(param_1 + 0x34);

+      if ((uVar31 & 0x40000000) == 0) {

+        if (2 < uVar33) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x100b;

+          DxgkLogInternalTriageEvent

+                    (0,0x40002,0xffffffff,

+                     L"D3DDDI_HDR_METADATA_TYPE_HDR10 == pArgs->HDRMetaDataType || D3DDDI_HDR_METADATA_TYPE_HDR10PLUS == pArgs->HDRMetaDataType || D3DDDI_HDR_METADATA_TYPE_NONE == pArgs->HDRMetaDataType"

+                    );

+        }

+        if ((*(longlong *)(param_1 + 0x40) != 0) || (*(int *)(param_1 + 0x38) != 0)) {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x100e;

+          DxgkLogInternalTriageEvent

+                    (0,0x40002,0xffffffff,

+                     L"NULL == pArgs->pHDRMetaData && NULL == pArgs->HDRMetaDataSize");

+        }

+        *(uint *)local_7f0[0] = *(uint *)local_7f0[0] | 0x40000000;

+        if (*(int *)(param_1 + 0x34) == 1) {

+          *(undefined4 *)(local_7f0[0] + 0x168) = 0x8000001;

+        }

+        else if (*(int *)(param_1 + 0x34) == 2) {

+          *(undefined4 *)(local_7f0[0] + 0x168) = 0x80000002;

+        }

+      }

+      else if (uVar33 != 0) {

+        if (uVar33 == 1) {

+          puVar11 = *(undefined4 **)(param_1 + 0x40);

+          uVar35 = puVar11[1];

+          uVar26 = puVar11[2];

+          uVar13 = puVar11[3];

+          *(undefined4 *)(local_7f0[0] + 0x16c) = *puVar11;

+          *(undefined4 *)(local_7f0[0] + 0x170) = uVar35;

+          *(undefined4 *)(local_7f0[0] + 0x174) = uVar26;

+          *(undefined4 *)(local_7f0[0] + 0x178) = uVar13;

+          *(undefined8 *)(local_7f0[0] + 0x17c) = *(undefined8 *)(puVar11 + 4);

+          *(undefined4 *)(local_7f0[0] + 0x184) = puVar11[6];

+        }

+        else if (uVar33 == 2) {

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

+          uVar14 = puVar10[1];

+          *(undefined8 *)(local_7f0[0] + 0x16c) = *puVar10;

+          *(undefined8 *)(local_7f0[0] + 0x174) = uVar14;

+          uVar14 = puVar10[3];

+          *(undefined8 *)(local_7f0[0] + 0x17c) = puVar10[2];

+          *(undefined8 *)(local_7f0[0] + 0x184) = uVar14;

+          uVar14 = puVar10[5];

+          *(undefined8 *)(local_7f0[0] + 0x18c) = puVar10[4];

+          *(undefined8 *)(local_7f0[0] + 0x194) = uVar14;

+          uVar14 = puVar10[7];

+          *(undefined8 *)(local_7f0[0] + 0x19c) = puVar10[6];

+          *(undefined8 *)(local_7f0[0] + 0x1a4) = uVar14;

+          *(undefined8 *)(local_7f0[0] + 0x1ac) = puVar10[8];

+        }

+        else {

+          WdLogSingleEntry0(1);

+          _WdLogGlobalForLineNumber = 0x1001;

+          DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"FALSE");

+          *(uint *)local_7f0[0] = *(uint *)local_7f0[0] & 0xbfffffff;

+        }

+      }

+    }

+  }

+  if (*(longlong *)(param_1 + 0x28) != 0) {

+    *(uint *)local_7f0[0] = *(uint *)local_7f0[0] | 0x80000000;

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

+    uVar35 = *(undefined4 *)(lVar6 + 8);

+    uVar26 = *(undefined4 *)(lVar6 + 0xc);

+    uVar13 = *(undefined4 *)(lVar6 + 0x10);

+    *(undefined4 *)(local_7f0[0] + 0x1b4) = *(undefined4 *)(lVar6 + 4);

+    *(undefined4 *)(local_7f0[0] + 0x1b8) = uVar35;

+    *(undefined4 *)(local_7f0[0] + 0x1bc) = uVar26;

+    *(undefined4 *)(local_7f0[0] + 0x1c0) = uVar13;

+    uVar14 = *(undefined8 *)(*(longlong *)(param_1 + 0x28) + 0x1c);

+    *(undefined8 *)(local_7f0[0] + 0x1c4) = *(undefined8 *)(*(longlong *)(param_1 + 0x28) + 0x14);

+    *(undefined8 *)(local_7f0[0] + 0x1cc) = uVar14;

+  }

+  lVar6 = *(longlong *)(this + 0x10);

+  if (*(longlong *)(lVar6 + 0x768) == *(longlong *)(*(longlong *)(lVar6 + 0x10) + 0x10)) {

+    iVar25 = *(int *)(lVar6 + 0x728 + uVar37 * 4);

+    if ((*(int *)(local_7f0[0] + 0x78) == iVar25) || (iVar25 == 0)) {

+LAB_14:

+      lVar22 = WaitForQueuedPresentLimit

+                         (this,uVar2,~(byte)(*(uint *)(param_1 + 0x18) >> 3) & 1,local_7f8);

+      if (lVar22 < 0) {

+        WdLogSingleEntry2(4,(longlong)lVar22,this);

+        _WdLogGlobalForLineNumber = 0x1060;

       }

       else {

-        do {

-          lVar6 = lVar14 + 1;

-          lVar14 = lVar14 + 1;

-        } while (pwVar16[lVar6] != (wchar_t)unaff_R15);

-        iVar17 = (int)lVar14 * 2 + 2;

-      }

-      *(int *)(unaff_RBP + 0x188) = iVar17;

-      *(wchar_t **)(unaff_RBP + 0x180) = pwVar16;

-      *(longlong *)(unaff_RBP + 0x170) = unaff_RBP + -0x24;

-      *(int *)(unaff_RBP + 0x18c) = iVar20;

-      *(longlong *)(unaff_RBP + 0x160) = unaff_RBP + -0x20;

-      *(undefined8 *)(unaff_RBP + 0x178) = 4;

-      *(longlong *)(unaff_RBP + 0x150) = unaff_RBP + -0x48;

-      *(longlong *)(unaff_RBP + 0x140) = unaff_RBP + -0x44;

-      *(longlong *)(unaff_RBP + 0x130) = unaff_RBP + -0x40;

-      *(longlong *)(unaff_RBP + 0x120) = unaff_RBP + -8;

-      *(undefined8 **)(unaff_RBP + 0x110) = &stack0x00000070;

-      *(longlong *)(unaff_RBP + 0x100) = unaff_RBP + -100;

-      *(undefined4 *)(unaff_RBP + 0xc) = 5;

-      puVar7 = PTR_DAT_5;

-      *(undefined **)(unaff_RBP + 0xe0) = PTR_DAT_5;

-      *(undefined8 *)(unaff_RBP + 0x168) = 4;

-      *(undefined8 *)(unaff_RBP + 0x158) = 4;

-      *(undefined8 *)(unaff_RBP + 0x148) = 4;

-      *(undefined8 *)(unaff_RBP + 0x138) = 4;

-      *(undefined8 *)(unaff_RBP + 0x128) = 8;

-      *(undefined8 *)(unaff_RBP + 0x118) = 8;

-      *(undefined8 *)(unaff_RBP + 0x108) = 2;

-      *(undefined4 *)(unaff_RBP + 8) = 0xb000000;

-      *(undefined8 *)(unaff_RBP + 0x10) = 0x400000400000;

-      *(uint *)(unaff_RBP + 0xe8) = (uint)*(ushort *)puVar7;

-      *(undefined **)(unaff_RBP + 0xf0) = &DAT_6;

-      *(undefined4 *)(unaff_RBP + 0xfc) = 1;

-      *(undefined4 *)(unaff_RBP + 0xec) = 2;

-      *(undefined4 *)(unaff_RBP + 0xf8) = 0x10a;

-      *(undefined4 *)(unaff_RBP + -0x80) = 0x66df;

-      EtwWriteTransfer(DAT_7);

-    }

-  }

-  unaff_R12 = *(DXGADAPTER **)(unaff_RBP + -0x70);

-LAB_1:

-  if (cStack0000000000000058 != cVar19) {

-    DXGADAPTER::DecrementVSyncWaiter(unaff_R12,in_stack_0000007c);

-  }

-  if (cStack0000000000000059 == cVar19) {

-    if (cStack000000000000005a == cVar19) {

-LAB_8:

-      if ((DAT_9 & 1) != 0) {

-        McTemplateK0tt_EtwWriteTransfer();

-      }

-      if ((-1 < (int)uVar13) && (iVar20 = *(int *)(unaff_RBP + -0x78), iVar20 != 0)) {

-        COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-        if (in_stack_00000050 != (DXGDEVICE *)0x0) {

-          LOCK();

-          pDVar18 = in_stack_00000050 + 0x40;

-          lVar14 = *(longlong *)pDVar18;

-          *(longlong *)pDVar18 = *(longlong *)pDVar18 + unaff_RBX;

-          UNLOCK();

-          if (lVar14 == 1) {

-            ADAPTER_RENDER::DestroyDeviceNoLocks

-                      (*(ADAPTER_RENDER **)(in_stack_00000050 + 0x10),in_stack_00000050);

-          }

-        }

-        LOCK();

-        pDVar1 = unaff_R14 + 0x18;

-        lVar14 = *(longlong *)pDVar1;

-        *(longlong *)pDVar1 = *(longlong *)pDVar1 + unaff_RBX;

-        UNLOCK();

-        if (lVar14 == 1) {

-          DXGGLOBAL::DestroyAdapter(*(DXGGLOBAL **)(unaff_R14 + 0x10),unaff_R14);

-        }

-        KeLeaveCriticalRegion();

-        return iVar20;

+        lVar22 = CheckDevicePresentSettings(this,1,0,1,uVar2);

+        if (-1 < lVar22) {

+          if (*(longlong *)(this + 0x168) != 0) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x107c;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"m_pPresentDmaBuffer == NULL");

+          }

+          lVar22 = SubmitPresentMultiPlaneOverlays3

+                             (this,param_1,local_876,local_877,local_878,local_750[0],local_60,

+                              local_718,local_7f0[0],local_7b8);

+          if (-1 < lVar22) {

+            if (*(int *)(*(longlong *)

+                          (*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48)

+                          + 0x80) + 0x430 + uVar37 * 0xfb8) == -1) {

+              WdLogSingleEntry0(1);

+              _WdLogGlobalForLineNumber = 0x108d;

+              DxgkLogInternalTriageEvent

+                        (0,0x40002,0xffffffff,

+                         L"!NT_SUCCESS(Status) || (GetDisplayAdapter(VidPnSourceId)->GetDisplayCore()->MapVidPnSourceToVidPnTarget(VidPnSourceId) != D3DDDI_ID_UNINITIALIZED)"

+                        );

+            }

+            UpdateDisplayStateForFullWDDMDevice

+                      (this,param_1,local_750[0],local_88,local_860,*(uint *)(local_7f0[0] + 0x88));

+            *(undefined4 *)(*(longlong *)(this + 0x10) + 0x728 + uVar37 * 4) =

+                 *(undefined4 *)(local_7f0[0] + 0x78);

+            pAVar30 = *(ADAPTER_DISPLAY **)

+                       (*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48);

+            uVar33 = (uint)local_808;

+            goto LAB_15;

+          }

+          goto LAB_16;

+        }

+        WdLogSingleEntry2(4,(longlong)lVar22,this);

+        _WdLogGlobalForLineNumber = 0x106b;

+        if (lVar22 == -0x3fe1fcc8) {

+          UpdateDisplayStateForFullWDDMDevice

+                    (this,param_1,local_750[0],local_88,local_860,*(uint *)(local_7f0[0] + 0x88));

+          *(undefined4 *)(*(longlong *)(this + 0x10) + 0x728 + uVar37 * 4) =

+               *(undefined4 *)(local_7f0[0] + 0x78);

+          CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+          goto LAB_13;

+        }

       }

     }

     else {

-      uVar13 = COREADAPTERACCESS::AcquireShared((COREADAPTERACCESS *)(unaff_RBP + 0x50),(char *)0x0)

+      if ((*(uint *)(param_1 + 0x18) & 8) != 0) {

+        WdLogSingleEntry1(4,0xffffffffc01e0005);

+        _WdLogGlobalForLineNumber = 0x1042;

+        CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+        lVar22 = -0x3fe1fffb;

+        goto LAB_4;

+      }

+      WdLogSingleEntry1(4);

+      _WdLogGlobalForLineNumber = 0x104a;

+      COREDEVICEACCESS::Release(local_7f8);

+      DXGDEVICE::FlushScheduler(*(DXGDEVICE **)(this + 0x10),3,uVar2,true);

+      lVar22 = COREDEVICEACCESS::AcquireShared(local_7f8,(char *)0x0);

+      pcVar38 = (char *)(longlong)lVar22;

+      if (-1 < lVar22) goto LAB_14;

+      WdLogSingleEntry1(4);

+      _WdLogGlobalForLineNumber = 0x1052;

+      COREDEVICEACCESS::AcquireSharedUncheck(local_7f8,pcVar38);

+    }

+    CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+  }

+  else {

+    if (*(longlong *)(lVar6 + 0x768) == 0) {

+      WdLogSingleEntry2(1,lVar6,0xffffffffc0000002);

+      _WdLogGlobalForLineNumber = 0x10b7;

+      DxgkLogInternalTriageEvent

+                (0,0x40002,0xffffffff,

+                 L"DxgkPresent is called for flip on a render only device 0x%I64x, returning 0x%I64x."

+                );

+      CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+      PagedPoolArray<DXGALLOCATIONREFERENCE,4>::~PagedPoolArray<DXGALLOCATIONREFERENCE,4>

+                ((PagedPoolArray<DXGALLOCATIONREFERENCE,4> *)local_750);

+      return -0x3ffffff3;

+    }

+    p_Var12 = (_D3DKMT_MULTIPLANE_OVERLAY3 *)**(undefined8 **)(param_1 + 0x20);

+    if (*(int *)p_Var12 != 0) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x10a5;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pPlane0->LayerIndex == 0");

+    }

+    memset(local_668,0,0x5d8);

+    local_770 = 0;

+    uStack_768 = 0;

+    local_760 = 0;

+    uStack_758 = 0;

+    ConvertMPOThunkToLegacyPresentThunk

+              (local_668,(_D3DKMT_PRESENT_RGNS *)&local_770,param_1,p_Var12);

+    lVar22 = DisplayOnlyPresent(this,local_668,*(DXGALLOCATION **)local_750[0],uVar2,local_718,

+                                local_7f8);

+    uVar33 = 0;

+    local_854 = 0;

+    local_874 = '\0';

+    pAVar30 = *(ADAPTER_DISPLAY **)(*(longlong *)(*(longlong *)(this + 0x10) + 0x768) + 0xc48);

+LAB_15:

+    UpdatePostComposition(uVar2,local_874,local_854,uVar33,pAVar30);

+LAB_16:

+    uVar20 = ADAPTER_RENDER::IsCoreResourceSharedOwner

+                       (*(ADAPTER_RENDER **)(*(longlong *)(this + 0x10) + 0x10));

+    if ((uVar20 == '\0') && (lVar22 != -0x3ffffd4a)) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x10bc;

+      DxgkLogInternalTriageEvent

+                (0,0x40002,0xffffffff,

+                 L"GetRenderCore()->IsCoreResourceSharedOwner() || Status == STATUS_DEVICE_REMOVED")

       ;

-      if (-1 < (int)uVar13) {

-        if (*(int *)(in_stack_00000050 + 0x260) == 1) {

-          uVar13 = VIDSCH_EXPORT::VidSchControlVSyncDevice

-                             (*(VIDSCH_EXPORT **)

-                               (*(longlong *)(*(longlong *)(unaff_RBP + -0x70) + 0xc50) + 0x2e0),

-                              *(_VIDSCH_DEVICE **)(in_stack_00000050 + 800),0,'\0',in_stack_0000007c

-                             );

-        }

-        goto LAB_8;

-      }

-    }

-    COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-    if (in_stack_00000050 == (DXGDEVICE *)0x0) goto LAB_10;

-    LOCK();

-    pDVar18 = in_stack_00000050 + 0x40;

-    lVar14 = *(longlong *)pDVar18;

-    *(longlong *)pDVar18 = *(longlong *)pDVar18 + unaff_RBX;

-    UNLOCK();

-  }

-  else {

-    uVar13 = COREADAPTERACCESS::AcquireShared((COREADAPTERACCESS *)(unaff_RBP + 0x50),(char *)0x0);

-    if (-1 < (int)uVar13) {

-      uVar13 = VIDSCH_EXPORT::VidSchControlVSyncAdapter

-                         (*(VIDSCH_EXPORT **)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e0),

-                          *(_VIDSCH_GLOBAL **)(*(longlong *)(unaff_R12 + 0xc50) + 0x2e8),1,'\0',

-                          in_stack_0000007c);

-      goto LAB_8;

-    }

-    COREADAPTERACCESS::~COREADAPTERACCESS((COREADAPTERACCESS *)(unaff_RBP + 0x50));

-    if (in_stack_00000050 == (DXGDEVICE *)0x0) goto LAB_10;

-    LOCK();

-    pDVar18 = in_stack_00000050 + 0x40;

-    lVar14 = *(longlong *)pDVar18;

-    *(longlong *)pDVar18 = *(longlong *)pDVar18 + unaff_RBX;

-    UNLOCK();

-  }

-  if (lVar14 == 1) {

-    ADAPTER_RENDER::DestroyDeviceNoLocks

-              (*(ADAPTER_RENDER **)(in_stack_00000050 + 0x10),in_stack_00000050);

-  }

-LAB_10:

-  LOCK();

-  pDVar1 = unaff_R14 + 0x18;

-  lVar14 = *(longlong *)pDVar1;

-  *(longlong *)pDVar1 = *(longlong *)pDVar1 + unaff_RBX;

-  UNLOCK();

-  if (lVar14 == 1) {

-    DXGGLOBAL::DestroyAdapter(*(DXGGLOBAL **)(unaff_R14 + 0x10),unaff_R14);

-  }

-  KeLeaveCriticalRegion();

-  return uVar13;

+    }

+    if (*(longlong *)(this + 0x168) != 0) {

+      WdLogSingleEntry0(1);

+      _WdLogGlobalForLineNumber = 0x10bd;

+      DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"m_pPresentDmaBuffer == NULL");

+    }

+    CVidSchSubmitData::~CVidSchSubmitData((CVidSchSubmitData *)local_7f0);

+  }

+LAB_4:

+  PagedPoolArray<DXGALLOCATIONREFERENCE,4>::~PagedPoolArray<DXGALLOCATIONREFERENCE,4>

+            ((PagedPoolArray<DXGALLOCATIONREFERENCE,4> *)local_750);

+  return lVar22;

 }
```

## `CFlipContentToken::Initialize`  (modified)

```diff
--- CFlipContentToken::Initialize
+++ CFlipContentToken::Initialize
@@ -1,2 +1,28 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipContentToken::Initialize : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: long __cdecl CFlipContentToken::Initialize(unsigned int,struct tagRECT const * __ptr64)

+   __ptr64 */

+

+long __thiscall CFlipContentToken::Initialize(CFlipContentToken *this,uint param_1,tagRECT *param_2)

+

+{

+  int iVar1;

+  int iVar2;

+  uint uVar3;

+  bool local_res20 [8];

+  

+  iVar1 = CToken::Initialize((CToken *)this);

+  iVar2 = Feature_FlipContentTokenLastChanceNotify__private_IsEnabledDeviceUsageNoInline();

+  if (iVar2 != 0) {

+    local_res20[0] = true;

+    CompositionSurfaceObject::GetIndependentFlipNotifyDwm

+              (*(CompositionSurfaceObject **)(this + 0x30),*(__uint64 *)(this + 0x38),local_res20);

+    this[0xe0] = (CFlipContentToken)((local_res20[0] & 1U) * '\x02' | (byte)this[0xe0] & 0xfd);

+  }

+  for (uVar3 = 0; (-1 < iVar1 && (uVar3 < param_1)); uVar3 = uVar3 + 1) {

+    iVar1 = (**(code **)(**(longlong **)(this + 0x60) + 0x28))

+                      (*(longlong **)(this + 0x60),param_2 + (ulonglong)uVar3 * 0x10);

+  }

+  return iVar1;

+}

+
```

## `DxgMonitor::MonitorColorState::SetSDRWhiteLevel`  (modified)

```diff
--- DxgMonitor::MonitorColorState::SetSDRWhiteLevel
+++ DxgMonitor::MonitorColorState::SetSDRWhiteLevel
@@ -1,2 +1,68 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DxgMonitor::MonitorColorState::SetSDRWhiteLevel : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

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

+/* public: long __cdecl DxgMonitor::MonitorColorState::SetSDRWhiteLevel(unsigned long,unsigned long)

+   __ptr64 */

+

+long __thiscall

+DxgMonitor::MonitorColorState::SetSDRWhiteLevel(MonitorColorState *this,ulong param_1,ulong param_2)

+

+{

+  char cVar1;

+  long lVar2;

+  int iVar3;

+  MonitorColorState *this_00;

+  undefined1 auStack_68 [32];

+  undefined8 local_48;

+  undefined4 local_40;

+  undefined4 local_38;

+  undefined4 local_28;

+  undefined4 local_24;

+  undefined8 local_20;

+  ulonglong local_18;

+  

+  local_18 = __security_cookie ^ (ulonglong)auStack_68;

+  if ((*(ulong *)(this + 0x1dc) == param_1) && (*(ulong *)(this + 0x1e0) == param_2)) {

+    return 0xff;

+  }

+  *(ulong *)(this + 0x1dc) = param_1;

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

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

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

+    (**(code **)(**(longlong **)(this + 8) + 0x88))

+              (*(longlong **)(this + 8),4,L"SDRWhiteLevel",param_1);

+  }

+  iVar3 = (**(code **)(**(longlong **)this + 0x70))();

+  if ((iVar3 != 0) &&

+     ((iVar3 == 0xc ||

+      (((iVar3 != 0x1e && (iVar3 != 0x1f)) && ((iVar3 == 0x20 || (iVar3 == 0x21)))))))) {

+    lVar2 = SetLuminanceValuesWithBrightnessCompensation(this,0xffffffff);

+    if (lVar2 < 0) {

+      WdLogSingleEntry1(2,(longlong)lVar2);

+      _WdLogGlobalForLineNumber = 0x704;

+      return lVar2;

+    }

+    this_00 = this;

+    lVar2 = SendAdjustedHDRParamsToDriver(this,true);

+    if (lVar2 < 0) {

+      WdLogSingleEntry1(2,(longlong)lVar2);

+      _WdLogGlobalForLineNumber = 0x708;

+      return lVar2;

+    }

+    TriggerMonitorColorimetryChangedWnf(this_00);

+  }

+  iVar3 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar3 != 0) && ((*(int *)(this + 0x1e4) != 0 || (*(int *)(this + 0x1e8) != 0)))) {

+    local_28 = *(undefined4 *)(this + 0x1dc);

+    local_38 = 0;

+    local_40 = 0;

+    local_48 = 0;

+    local_24 = *(undefined4 *)(this + 0x1e0);

+    local_20 = *(undefined8 *)(this + 0x1e4);

+    ZwUpdateWnfStateData(&local_20,&local_28,8);

+  }

+  (**(code **)(**(longlong **)this + 0x80))(*(longlong **)this,4);

+  return 0;

+}

+
```

## `DXGPRESENTHISTORYTOKENQUEUE::Initialize`  (modified)

```diff
--- DXGPRESENTHISTORYTOKENQUEUE::Initialize
+++ DXGPRESENTHISTORYTOKENQUEUE::Initialize
@@ -1,2 +1,73 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGPRESENTHISTORYTOKENQUEUE::Initialize : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl DXGPRESENTHISTORYTOKENQUEUE::Initialize(void) __ptr64 */

+

+long __thiscall DXGPRESENTHISTORYTOKENQUEUE::Initialize(DXGPRESENTHISTORYTOKENQUEUE *this)

+

+{

+  DXGPRESENTHISTORYTOKENQUEUE *pDVar1;

+  uchar uVar2;

+  int iVar3;

+  undefined8 local_res10;

+  undefined8 local_res18 [2];

+  ulonglong in_stack_ffffffffffffff88;

+  undefined4 uVar4;

+  undefined8 local_48;

+  undefined8 local_40;

+  undefined8 local_38;

+  undefined8 local_30;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  

+  uVar2 = GrowPresentHistoryBuffer(this);

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

+    return -0x3fffffe9;

+  }

+  local_res10 = 0;

+  local_48 = 0x30;

+  local_30 = 0x200;

+  local_40 = 0;

+  local_38 = 0;

+  local_28 = 0;

+  uStack_20 = 0;

+  iVar3 = ZwCreateEvent(&local_res10,0x1f0003,&local_48,0,

+                        in_stack_ffffffffffffff88 & 0xffffffffffffff00);

+  if (iVar3 < 0) {

+    return iVar3;

+  }

+  iVar3 = Feature_GraphicsKernel2606BugFixes__private_IsEnabledDeviceUsageNoInline();

+  local_res18[0] = 0;

+  uVar4 = 0;

+  if (iVar3 == 0) {

+    uVar4 = 0;

+    ObReferenceObjectByHandle(local_res10,2,*(undefined8 *)ExEventObjectType_exref,0,local_res18,0);

+    *(undefined8 *)(this + 0x48) = local_res18[0];

+    ZwClose(local_res10);

+LAB_0:

+    pDVar1 = this + 0x40;

+    local_48 = CONCAT44(local_48._4_4_,0x30);

+    local_40 = 0;

+    local_30 = CONCAT44(local_30._4_4_,0x40);

+    local_38 = 0;

+    local_28 = 0;

+    uStack_20 = 0;

+    iVar3 = ObCreateObject(0,*(undefined8 *)ExSemaphoreObjectType_exref,&local_48,0,0,

+                           CONCAT44(uVar4,0x20),0,0,pDVar1);

+    if (-1 < iVar3) {

+      KeInitializeSemaphore(*(undefined8 *)pDVar1,0x7ff,0x7ff);

+      ObDeleteCapturedInsertInfo(*(undefined8 *)pDVar1);

+    }

+  }

+  else {

+    iVar3 = ObReferenceObjectByHandle

+                      (local_res10,2,*(undefined8 *)ExEventObjectType_exref,0,local_res18,0);

+    *(undefined8 *)(this + 0x48) = local_res18[0];

+    if (-1 < iVar3) {

+      iVar3 = ZwClose(local_res10);

+      if (-1 < iVar3) goto LAB_0;

+      ObfDereferenceObject(*(undefined8 *)(this + 0x48));

+    }

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

+  }

+  return iVar3;

+}

+
```

## `CFlipManager::ConsumerDwmProcessUpdateTokens`  (modified)

```diff
--- CFlipManager::ConsumerDwmProcessUpdateTokens
+++ CFlipManager::ConsumerDwmProcessUpdateTokens
@@ -1,2 +1,94 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipManager::ConsumerDwmProcessUpdateTokens : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: long __cdecl CFlipManager::ConsumerDwmProcessUpdateTokens(class CFlipPresentUpdate *

+   __ptr64,class CFlipManagerToken * __ptr64,struct _LIST_ENTRY * __ptr64) __ptr64 */

+

+long __thiscall

+CFlipManager::ConsumerDwmProcessUpdateTokens

+          (CFlipManager *this,CFlipPresentUpdate *param_1,CFlipManagerToken *param_2,

+          _LIST_ENTRY *param_3)

+

+{

+  longlong ***ppplVar1;

+  longlong ***ppplVar2;

+  longlong lVar3;

+  code *pcVar4;

+  longlong ***ppplVar5;

+  char cVar6;

+  long lVar7;

+  CFlipContentToken *this_00;

+  bool local_res8 [8];

+  longlong ***local_48;

+  longlong ***local_40;

+  longlong ***local_38;

+  undefined1 local_30;

+  

+  local_40 = (longlong ***)&local_48;

+  local_48 = (longlong ***)&local_48;

+  lVar7 = CEndpointResourceStateManager::PrepareUpdateTokens

+                    ((CEndpointResourceStateManager *)(this + 0x68),(FlipManagerObject *)param_1,

+                     *(CFlipPropertySet **)(param_1 + 0x38),*(int *)(this + 0x150) == 2,

+                     (_LIST_ENTRY *)&local_48);

+  local_30 = 1;

+  local_38 = (longlong ***)&local_48;

+  if (-1 < lVar7) {

+    CEndpointResourceStateManager::CommitPendingUpdates

+              ((CEndpointResourceStateManager *)(this + 0x68));

+LAB_0:

+    do {

+      ppplVar5 = local_48;

+      if ((longlong ****)local_48 == &local_48) break;

+      this_00 = (CFlipContentToken *)(local_48 + -1);

+      ppplVar1 = (longlong ***)*local_48;

+      if (((longlong ***)ppplVar1[1] != local_48) ||

+         (ppplVar2 = (longlong ***)local_48[1], (longlong ***)*ppplVar2 != local_48)) {

+LAB_1:

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

+        (*pcVar4)(3);

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

+        lVar7 = (*pcVar4)();

+        return lVar7;

+      }

+      *ppplVar2 = (longlong **)ppplVar1;

+      ppplVar1[1] = (longlong **)ppplVar2;

+      lVar7 = ObReferenceObjectByPointer

+                        ((FlipManagerObject *)(this + -0x20),3,g_pDxgkCompositionObjectType);

+      if (-1 < lVar7) {

+        ppplVar5[0xf] = (longlong **)*(longlong ****)(param_2 + 0x70);

+        CFlipContentToken::SetFlipManagerObjectPreReferenced

+                  (this_00,(FlipManagerObject *)(this + -0x20));

+        ppplVar5[0xe] = (longlong **)*(longlong ****)(param_1 + 0x40);

+        lVar3 = *(longlong *)(param_2 + 0x50);

+        if (lVar3 != 0) {

+          *(undefined1 *)(ppplVar5 + 0x1c) = *(undefined1 *)(lVar3 + 0x1c);

+          *(undefined1 *)((longlong)ppplVar5 + 0xe3) = *(undefined1 *)(lVar3 + 0x55);

+          *(undefined1 *)((longlong)ppplVar5 + 0xe1) = *(undefined1 *)(lVar3 + 0x56);

+          *(undefined1 *)((longlong)ppplVar5 + 0xe2) = *(undefined1 *)(lVar3 + 0x54);

+          ppplVar5[0x1d] = (longlong **)*(longlong ****)(lVar3 + 0x48);

+          *(undefined4 *)(ppplVar5 + 0x1e) = *(undefined4 *)(lVar3 + 0x40);

+          *(undefined4 *)((longlong)ppplVar5 + 0xf4) = *(undefined4 *)(lVar3 + 0x50);

+          ppplVar5[0x1f] = (longlong **)*(longlong ****)(lVar3 + 0x38);

+        }

+        lVar7 = CFlipContentToken::InFrame(this_00,local_res8);

+        if (-1 < lVar7) {

+          cVar6 = (**(code **)(*(longlong *)this_00 + 0x98))(this_00);

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

+            ppplVar1 = *(longlong ****)(param_3 + 8);

+            if ((_LIST_ENTRY *)*ppplVar1 != param_3) goto LAB_1;

+            *ppplVar5 = (longlong **)param_3;

+            ppplVar5[1] = (longlong **)ppplVar1;

+            *ppplVar1 = (longlong **)ppplVar5;

+            *(longlong ****)(param_3 + 8) = ppplVar5;

+            goto LAB_0;

+          }

+        }

+      }

+      (**(code **)(*(longlong *)this_00 + 0x38))(this_00);

+      (*(code *)**(undefined8 **)this_00)(this_00,1);

+    } while (-1 < lVar7);

+  }

+  local_30 = 0;

+  <lambda_cfa85ae072c89c165dff36c328ecf84d>::operator()(&local_38);

+  return lVar7;

+}

+
```

## `CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame`  (modified)

```diff
--- CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame
+++ CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame
@@ -1,2 +1,67 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* protected: long __cdecl CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame(class

+   CFlipContentToken const * __ptr64,bool * __ptr64) __ptr64 */

+

+long __thiscall

+CCompositionSwapchainBuffer::NotifyFlipContentTokenInFrame

+          (CCompositionSwapchainBuffer *this,CFlipContentToken *param_1,bool *param_2)

+

+{

+  uint uVar1;

+  undefined8 uVar2;

+  bool bVar3;

+  bool bVar4;

+  char cVar5;

+  bool bVar6;

+  int iVar7;

+  long lVar8;

+  

+  lVar8 = 0;

+  *param_2 = false;

+  iVar7 = Feature_LastChanceSurfaceUpdateFullDirty__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar7 == 0) || (bVar4 = true, this[0x282] == (CCompositionSwapchainBuffer)0x0)) {

+    bVar4 = false;

+  }

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

+  if ((uVar1 == 0xffffffff) || (uVar1 < *(uint *)(this + 0x120))) {

+    uVar2 = *(undefined8 *)(param_1 + 0x78);

+    *(undefined8 *)(this + 0x2e0) = uVar2;

+    *(int *)(this + 0x124) = (int)uVar2;

+    bVar3 = false;

+    if (*(uint *)(this + 0x18c) != uVar1) {

+      *(uint *)(this + 0x18c) = uVar1;

+      *param_2 = true;

+      cVar5 = (**(code **)(*(longlong *)param_1 + 0x90))(param_1);

+      bVar3 = false;

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

+        bVar3 = true;

+      }

+    }

+    bVar6 = UpdateAttributes(this,param_1);

+    if (bVar6) {

+      *param_2 = true;

+    }

+    bVar6 = UpdateIndependentFlipState(this,param_1);

+    if (bVar6) {

+      *param_2 = true;

+    }

+    if (bVar3) {

+      this[0x282] = (CCompositionSwapchainBuffer)0x0;

+    }

+    if (bVar4) {

+      CCompositionBuffer::NotifyFullDirty((CCompositionBuffer *)this);

+    }

+    else {

+      CCompositionBuffer::NotifyDirty

+                ((CCompositionBuffer *)this,*(IRegion **)(param_1 + 0x60),

+                 (ScrollOptimization *)(param_1 + 0x44));

+      lVar8 = 0;

+    }

+  }

+  else {

+    lVar8 = -0x3ffffff3;

+  }

+  return lVar8;

+}

+
```

## `DispConfigTypes::RequiresSessionModeChangeLockShared`  (modified)

```diff
--- DispConfigTypes::RequiresSessionModeChangeLockShared
+++ DispConfigTypes::RequiresSessionModeChangeLockShared
@@ -1,2 +1,62 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DispConfigTypes::RequiresSessionModeChangeLockShared : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* bool __cdecl DispConfigTypes::RequiresSessionModeChangeLockShared(enum

+   DISPLAYCONFIG_DEVICE_INFO_TYPE) */

+

+bool __cdecl

+DispConfigTypes::RequiresSessionModeChangeLockShared(DISPLAYCONFIG_DEVICE_INFO_TYPE param_1)

+

+{

+  int iVar1;

+  bool bVar2;

+  

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

+    if (param_1 != 0xfffffffe) {

+      if (((param_1 + 0x28 & 0xfffffffc) == 0) && (param_1 != 0xffffffd9)) {

+        return true;

+      }

+      if (param_1 != 0xffffffe2) {

+        if (param_1 == 0xffffffe5) {

+          return true;

+        }

+        if (param_1 != 0xffffffeb) {

+          bVar2 = (param_1 + 0x12 & 0xfffffffd) == 0;

+          goto LAB_0;

+        }

+      }

+    }

+    iVar1 = Feature_UseIntermediaryColorServer__private_IsEnabledDeviceUsageNoInline();

+    if (iVar1 == 0) {

+      return false;

+    }

+  }

+  else {

+    if (param_1 == 7) {

+      return true;

+    }

+    if (param_1 == 8) {

+      return true;

+    }

+    if (param_1 == 9) {

+      return true;

+    }

+    if (param_1 == 10) {

+      return true;

+    }

+    if (param_1 == 0xb) {

+      return true;

+    }

+    if (param_1 == 0xf) {

+      return true;

+    }

+    if (param_1 == 0x10) {

+      return true;

+    }

+    bVar2 = param_1 == 0x11;

+LAB_0:

+    if (!bVar2) {

+      return false;

+    }

+  }

+  return true;

+}

+
```

## `CFlipManager::MarkAsLost`  (modified)

```diff
--- CFlipManager::MarkAsLost
+++ CFlipManager::MarkAsLost
@@ -1,2 +1,36 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipManager::MarkAsLost : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* private: void __cdecl CFlipManager::MarkAsLost(long,enum

+   CFlipManager::PresentHistory::Operation,unsigned __int64) __ptr64 */

+

+void __thiscall

+CFlipManager::MarkAsLost(CFlipManager *this,long param_1,Operation param_2,__uint64 param_3)

+

+{

+  code *pcVar1;

+  uint uVar2;

+  int iVar3;

+  Entry *pEVar4;

+  longlong lVar5;

+  

+  this[0x20] = (CFlipManager)0x1;

+  if (*(PresentHistory **)(this + 0x18) != (PresentHistory *)0x0) {

+    pEVar4 = PresentHistory::GetNextEntry(*(PresentHistory **)(this + 0x18));

+    *(long *)(pEVar4 + 0x50) = param_1;

+    *(Operation *)(pEVar4 + 0x28) = param_2;

+    *(__uint64 *)(pEVar4 + 0x10) = param_3;

+    RtlCaptureStackBackTrace(1,4,pEVar4 + 0x30);

+  }

+  lVar5 = DxgkGetWin32kImportTable();

+  pcVar1 = *(code **)(lVar5 + 0x178);

+  uVar2 = GetTracingId(this);

+  (*pcVar1)(uVar2);

+  KeSetEvent(*(undefined8 *)(this + 0x140),1);

+  iVar3 = Feature_FlipManagerMarkAsLostNullCheck__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar3 == 0) || (*(longlong *)(this + 0x130) != 0)) {

+    DxgkImmediateSignalSynchronizationObjectByReference

+              (*(longlong *)(this + 0x130),0xffffffffffffffff);

+  }

+  return;

+}

+
```

## `NtFlipObjectConsumerAcquirePresent`  (modified)

```diff
--- NtFlipObjectConsumerAcquirePresent
+++ CFlipManager::ConsumerDwmProcessUpdateTokens
@@ -1,10 +1,2 @@
-

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

-

-void NtFlipObjectConsumerAcquirePresent(void)

-

-{

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

-  halt_baddata();

-}

-

+Failed to decompile dxgkrnl.sys - .ProgramDB CFlipManager::ConsumerDwmProcessUpdateTokens : Error: Decompile error: 
+Marshaling error: Did not see expected closing element
```

## `BLTQUEUE_HW_VSYNC_SOURCE::StopVSync`  (modified)

```diff
--- BLTQUEUE_HW_VSYNC_SOURCE::StopVSync
+++ BLTQUEUE_HW_VSYNC_SOURCE::StopVSync
@@ -1,2 +1,20 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB BLTQUEUE_HW_VSYNC_SOURCE::StopVSync : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual void __cdecl BLTQUEUE_HW_VSYNC_SOURCE::StopVSync(void) __ptr64 */

+

+void __thiscall BLTQUEUE_HW_VSYNC_SOURCE::StopVSync(BLTQUEUE_HW_VSYNC_SOURCE *this)

+

+{

+  int iVar1;

+  

+  iVar1 = Feature_ConditionalDpcFlush__private_IsEnabledDeviceUsageNoInline();

+  if (iVar1 == 0) {

+    KeCancelTimer();

+    KeFlushQueuedDpcs();

+  }

+  else {

+    KeCancelTimer(this + 0x10);

+  }

+  DXGDODPRESENT::StopHwVSync(*(DXGDODPRESENT **)(this + 8));

+  return;

+}

+
```

## `CFlipContentToken::NotifyDwm`  (modified)

```diff
--- CFlipContentToken::NotifyDwm
+++ CFlipContentToken::NotifyDwm
@@ -1,2 +1,36 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipContentToken::NotifyDwm : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: virtual bool __cdecl CFlipContentToken::NotifyDwm(void)const __ptr64 */

+

+bool __thiscall CFlipContentToken::NotifyDwm(CFlipContentToken *this)

+

+{

+  char cVar1;

+  int iVar2;

+  long lVar3;

+  bool bVar4;

+  bool local_res8 [8];

+  

+  bVar4 = false;

+  cVar1 = (**(code **)(*(longlong *)this + 0x90))();

+  if ((cVar1 == '\0') || (this[0xeb] != (CFlipContentToken)0x0)) {

+    bVar4 = true;

+  }

+  else {

+    iVar2 = Feature_FlipContentTokenLastChanceNotify__private_IsEnabledDeviceUsageNoInline();

+    if (iVar2 == 0) {

+      local_res8[0] = false;

+      lVar3 = CompositionSurfaceObject::GetIndependentFlipNotifyDwm

+                        (*(CompositionSurfaceObject **)(this + 0x30),*(__uint64 *)(this + 0x38),

+                         local_res8);

+      if (-1 < lVar3) {

+        bVar4 = local_res8[0] != false;

+      }

+    }

+    else {

+      bVar4 = (bool)((byte)this[0xe0] >> 1 & 1);

+    }

+  }

+  return bVar4;

+}

+
```

## `DxgMonitor::MonitorColorState::CopyInstance`  (modified)

```diff
--- DxgMonitor::MonitorColorState::CopyInstance
+++ DxgMonitor::MonitorColorState::CopyInstance
@@ -1,2 +1,160 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DxgMonitor::MonitorColorState::CopyInstance : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: class wistd::unique_ptr<class DxgMonitor::MonitorColorState,struct

+   wistd::default_delete<class DxgMonitor::MonitorColorState> > __cdecl

+   DxgMonitor::MonitorColorState::CopyInstance(class DxgMonitor::IMonitorComponentParent &

+   __ptr64,class DxgMonitor::IMonitorRegistry & __ptr64)const __ptr64 */

+

+IMonitorComponentParent * __thiscall

+DxgMonitor::MonitorColorState::CopyInstance

+          (MonitorColorState *this,IMonitorComponentParent *param_1,IMonitorRegistry *param_2)

+

+{

+  undefined8 uVar1;

+  undefined4 uVar2;

+  undefined8 uVar3;

+  undefined8 uVar4;

+  MonitorColorState *this_00;

+  IMonitorRegistry *in_R9;

+  longlong lVar5;

+  longlong local_18 [2];

+  

+  this_00 = operator_new(0x230,0x4d677844,0x100);

+  lVar5 = 0;

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

+    local_18[0] = 0;

+  }

+  else {

+    local_18[0] = MonitorColorState(this_00,(IMonitorComponentParent *)param_2,in_R9);

+    if (local_18[0] != 0) {

+      uVar1 = *(undefined8 *)(this + 0x88);

+      uVar2 = *(undefined4 *)(this + 0xa0);

+      uVar3 = *(undefined8 *)(this + 0x90);

+      uVar4 = *(undefined8 *)(this + 0x98);

+      *(undefined8 *)(local_18[0] + 0x80) = *(undefined8 *)(this + 0x80);

+      *(undefined8 *)(local_18[0] + 0x88) = uVar1;

+      *(undefined8 *)(local_18[0] + 0x90) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x98) = uVar4;

+      *(undefined4 *)(local_18[0] + 0xa0) = uVar2;

+      uVar1 = *(undefined8 *)(this + 0xac);

+      uVar2 = *(undefined4 *)(this + 0xc4);

+      uVar3 = *(undefined8 *)(this + 0xb4);

+      uVar4 = *(undefined8 *)(this + 0xbc);

+      *(undefined8 *)(local_18[0] + 0xa4) = *(undefined8 *)(this + 0xa4);

+      *(undefined8 *)(local_18[0] + 0xac) = uVar1;

+      *(undefined8 *)(local_18[0] + 0xb4) = uVar3;

+      *(undefined8 *)(local_18[0] + 0xbc) = uVar4;

+      *(undefined4 *)(local_18[0] + 0xc4) = uVar2;

+      uVar1 = *(undefined8 *)(this + 0xd0);

+      uVar2 = *(undefined4 *)(this + 0xe8);

+      uVar3 = *(undefined8 *)(this + 0xd8);

+      uVar4 = *(undefined8 *)(this + 0xe0);

+      *(undefined8 *)(local_18[0] + 200) = *(undefined8 *)(this + 200);

+      *(undefined8 *)(local_18[0] + 0xd0) = uVar1;

+      *(undefined8 *)(local_18[0] + 0xd8) = uVar3;

+      *(undefined8 *)(local_18[0] + 0xe0) = uVar4;

+      *(undefined4 *)(local_18[0] + 0xe8) = uVar2;

+      uVar1 = *(undefined8 *)(this + 0xf4);

+      uVar2 = *(undefined4 *)(this + 0x10c);

+      uVar3 = *(undefined8 *)(this + 0xfc);

+      uVar4 = *(undefined8 *)(this + 0x104);

+      *(undefined8 *)(local_18[0] + 0xec) = *(undefined8 *)(this + 0xec);

+      *(undefined8 *)(local_18[0] + 0xf4) = uVar1;

+      *(undefined8 *)(local_18[0] + 0xfc) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x104) = uVar4;

+      *(undefined4 *)(local_18[0] + 0x10c) = uVar2;

+      *(undefined4 *)(local_18[0] + 0x110) = *(undefined4 *)(this + 0x110);

+      uVar1 = *(undefined8 *)(this + 0x18);

+      uVar2 = *(undefined4 *)(this + 0x30);

+      uVar3 = *(undefined8 *)(this + 0x20);

+      uVar4 = *(undefined8 *)(this + 0x28);

+      *(undefined8 *)(local_18[0] + 0x10) = *(undefined8 *)(this + 0x10);

+      *(undefined8 *)(local_18[0] + 0x18) = uVar1;

+      *(undefined8 *)(local_18[0] + 0x20) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x28) = uVar4;

+      *(undefined4 *)(local_18[0] + 0x30) = uVar2;

+      uVar1 = *(undefined8 *)(this + 0x3c);

+      uVar2 = *(undefined4 *)(this + 0x54);

+      uVar3 = *(undefined8 *)(this + 0x44);

+      uVar4 = *(undefined8 *)(this + 0x4c);

+      *(undefined8 *)(local_18[0] + 0x34) = *(undefined8 *)(this + 0x34);

+      *(undefined8 *)(local_18[0] + 0x3c) = uVar1;

+      *(undefined8 *)(local_18[0] + 0x44) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x4c) = uVar4;

+      *(undefined4 *)(local_18[0] + 0x54) = uVar2;

+      uVar1 = *(undefined8 *)(this + 0x60);

+      uVar2 = *(undefined4 *)(this + 0x78);

+      uVar3 = *(undefined8 *)(this + 0x68);

+      uVar4 = *(undefined8 *)(this + 0x70);

+      *(undefined8 *)(local_18[0] + 0x58) = *(undefined8 *)(this + 0x58);

+      *(undefined8 *)(local_18[0] + 0x60) = uVar1;

+      *(undefined8 *)(local_18[0] + 0x68) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x70) = uVar4;

+      *(undefined4 *)(local_18[0] + 0x78) = uVar2;

+      *(undefined4 *)(local_18[0] + 0x7c) = *(undefined4 *)(this + 0x7c);

+      uVar1 = *(undefined8 *)(this + 0x140);

+      *(undefined8 *)(local_18[0] + 0x138) = *(undefined8 *)(this + 0x138);

+      *(undefined8 *)(local_18[0] + 0x140) = uVar1;

+      uVar1 = *(undefined8 *)(this + 0x150);

+      *(undefined8 *)(local_18[0] + 0x148) = *(undefined8 *)(this + 0x148);

+      *(undefined8 *)(local_18[0] + 0x150) = uVar1;

+      uVar1 = *(undefined8 *)(this + 0x160);

+      *(undefined8 *)(local_18[0] + 0x158) = *(undefined8 *)(this + 0x158);

+      *(undefined8 *)(local_18[0] + 0x160) = uVar1;

+      uVar1 = *(undefined8 *)(this + 0x170);

+      *(undefined8 *)(local_18[0] + 0x168) = *(undefined8 *)(this + 0x168);

+      *(undefined8 *)(local_18[0] + 0x170) = uVar1;

+      uVar1 = *(undefined8 *)(this + 0x180);

+      *(undefined8 *)(local_18[0] + 0x178) = *(undefined8 *)(this + 0x178);

+      *(undefined8 *)(local_18[0] + 0x180) = uVar1;

+      *(undefined4 *)(local_18[0] + 0x188) = *(undefined4 *)(this + 0x188);

+      *(MonitorColorState *)(local_18[0] + 0x19c) = this[0x19c];

+      *(MonitorColorState *)(local_18[0] + 0x19d) = this[0x19d];

+      uVar1 = *(undefined8 *)(this + 0x1a8);

+      uVar3 = *(undefined8 *)(this + 0x1b0);

+      uVar4 = *(undefined8 *)(this + 0x1b8);

+      *(undefined8 *)(local_18[0] + 0x1a0) = *(undefined8 *)(this + 0x1a0);

+      *(undefined8 *)(local_18[0] + 0x1a8) = uVar1;

+      *(undefined8 *)(local_18[0] + 0x1b0) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x1b8) = uVar4;

+      *(undefined4 *)(local_18[0] + 0x1c0) = *(undefined4 *)(this + 0x1c0);

+      *(undefined4 *)(local_18[0] + 0x1c4) = *(undefined4 *)(this + 0x1c4);

+      *(MonitorColorState *)(local_18[0] + 0x1c8) = this[0x1c8];

+      *(MonitorColorState *)(local_18[0] + 0x1c9) = this[0x1c9];

+      *(MonitorColorState *)(local_18[0] + 0x1d4) = this[0x1d4];

+      *(undefined4 *)(local_18[0] + 0x1d8) = *(undefined4 *)(this + 0x1d8);

+      *(undefined4 *)(local_18[0] + 0x1dc) = *(undefined4 *)(this + 0x1dc);

+      *(undefined4 *)(local_18[0] + 0x1e0) = *(undefined4 *)(this + 0x1e0);

+      *(undefined4 *)(local_18[0] + 0x1ec) = *(undefined4 *)(this + 0x1ec);

+      *(undefined4 *)(local_18[0] + 0x1f0) = *(undefined4 *)(this + 0x1f0);

+      uVar2 = *(undefined4 *)(this + 0x20c);

+      uVar3 = *(undefined8 *)(this + 0x1fc);

+      uVar1 = *(undefined8 *)(this + 0x204);

+      *(undefined8 *)(local_18[0] + 500) = *(undefined8 *)(this + 500);

+      *(undefined8 *)(local_18[0] + 0x1fc) = uVar3;

+      *(undefined8 *)(local_18[0] + 0x204) = uVar1;

+      *(undefined4 *)(local_18[0] + 0x20c) = uVar2;

+      *(undefined4 *)(local_18[0] + 0x1d0) = *(undefined4 *)(this + 0x1d0);

+      *(undefined4 *)(local_18[0] + 0x1cc) = *(undefined4 *)(this + 0x1cc);

+      *(MonitorColorState *)(local_18[0] + 0x211) = this[0x211];

+      *(MonitorColorState *)(local_18[0] + 0x212) = this[0x212];

+      *(MonitorColorState *)(local_18[0] + 0x213) = this[0x213];

+      *(MonitorColorState *)(local_18[0] + 0x214) = this[0x214];

+      *(undefined4 *)(local_18[0] + 0x218) = *(undefined4 *)(this + 0x218);

+      *(MonitorColorState *)(local_18[0] + 0x21c) = this[0x21c];

+      *(undefined4 *)(local_18[0] + 0x220) = *(undefined4 *)(this + 0x220);

+      *(undefined4 *)(local_18[0] + 0x224) = *(undefined4 *)(this + 0x224);

+      *(MonitorColorState *)(local_18[0] + 0x228) = this[0x228];

+      *(longlong *)param_1 = local_18[0];

+      local_18[0] = lVar5;

+      goto LAB_0;

+    }

+  }

+  *(longlong *)param_1 = lVar5;

+LAB_0:

+  wistd::

+  unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>::

+  reset((unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+         *)local_18,(MonitorColorState *)0x0);

+  return param_1;

+}

+
```

## `DXGMONITOR::~DXGMONITOR`  (modified)

```diff
--- DXGMONITOR::~DXGMONITOR
+++ DXGMONITOR::~DXGMONITOR
@@ -1,2 +1,95 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGMONITOR::~DXGMONITOR : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: virtual __cdecl DXGMONITOR::~DXGMONITOR(void) __ptr64 */

+

+void __thiscall DXGMONITOR::~DXGMONITOR(DXGMONITOR *this)

+

+{

+  DXGMONITOR *pDVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  void *pvVar4;

+  MonitorDataStore *this_00;

+  code *pcVar5;

+  bool bVar6;

+  MUTEX_MEMBER_LOCK<MONITOR_MGR,104> local_res8 [32];

+  

+  *(undefined ***)this = &_vftable__for__ReferenceCounted__;

+  *(undefined ***)(this + 0x10) = &_vftable__for__DxgMonitor__IMonitorComponentParent__;

+  *(undefined ***)(this + 0x18) = &_vftable__for__DxgMonitor__IMonitorRegistryRoot__;

+  *(undefined ***)(this + 0x20) = &_vftable__for__DxgMonitor__IMonitorDxgiGammaSource__;

+  bVar6 = MONITOR_MGR::_IsMonitorInMonitorPendingList(*(MONITOR_MGR **)(this + 0xa8),this);

+  if (!bVar6) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x69;

+  }

+  MUTEX_MEMBER_LOCK<MONITOR_MGR,104>::MUTEX_MEMBER_LOCK<MONITOR_MGR,104>

+            (local_res8,*(MONITOR_MGR **)(this + 0xa8));

+  pDVar1 = this + 0x98;

+  lVar2 = *(longlong *)pDVar1;

+  if ((*(DXGMONITOR **)(lVar2 + 8) == pDVar1) &&

+     (plVar3 = *(longlong **)(this + 0xa0), (DXGMONITOR *)*plVar3 == pDVar1)) {

+    *plVar3 = lVar2;

+    *(longlong **)(lVar2 + 8) = plVar3;

+    MUTEX_MEMBER_LOCK<MONITOR_MGR,152>::~MUTEX_MEMBER_LOCK<MONITOR_MGR,152>

+              ((MUTEX_MEMBER_LOCK<MONITOR_MGR,152> *)local_res8);

+    DXGFASTMUTEX::~DXGFASTMUTEX((DXGFASTMUTEX *)(this + 0x380));

+    MONITOR_REF_ACCESSOR::Release((MONITOR_REF_ACCESSOR *)(this + 0x170));

+    MONITOR_REF_ACCESSOR::Release((MONITOR_REF_ACCESSOR *)(this + 0x120));

+    pvVar4 = *(void **)(this + 0x110);

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

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

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pvVar4);

+    }

+    wistd::

+    unique_ptr<DxgMonitor::MonitorUsb4State,wistd::default_delete<DxgMonitor::MonitorUsb4State>_>::

+    reset((unique_ptr<DxgMonitor::MonitorUsb4State,wistd::default_delete<DxgMonitor::MonitorUsb4State>_>

+           *)(this + 0x108),(MonitorUsb4State *)0x0);

+    wistd::

+    unique_ptr<DxgMonitor::MonitorMipiDsiState,wistd::default_delete<DxgMonitor::MonitorMipiDsiState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorMipiDsiState,wistd::default_delete<DxgMonitor::MonitorMipiDsiState>_>

+             *)(this + 0x100),(MonitorMipiDsiState *)0x0);

+    wistd::

+    unique_ptr<DxgMonitor::MonitorGammaState,wistd::default_delete<DxgMonitor::MonitorGammaState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorGammaState,wistd::default_delete<DxgMonitor::MonitorGammaState>_>

+             *)(this + 0xf8),(MonitorGammaState *)0x0);

+    pvVar4 = *(void **)(this + 0xf0);

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

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

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pvVar4);

+    }

+    wistd::unique_ptr<DxgMonitor::MonitorModes,wistd::default_delete<DxgMonitor::MonitorModes>_>::

+    reset((unique_ptr<DxgMonitor::MonitorModes,wistd::default_delete<DxgMonitor::MonitorModes>_> *)

+          (this + 0xe8),(MonitorModes *)0x0);

+    wistd::

+    unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+             *)(this + 0xe0),(MonitorColorState *)0x0);

+    wistd::

+    unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+             *)(this + 0xd8),(MonitorDescriptorState *)0x0);

+    this_00 = *(MonitorDataStore **)(this + 0xd0);

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

+    if (this_00 != (MonitorDataStore *)0x0) {

+      DxgMonitor::MonitorDataStore::_scalar_deleting_destructor_(this_00,1);

+    }

+    wistd::

+    unique_ptr<DxgMonitor::MonitorPnpState,wistd::default_delete<DxgMonitor::MonitorPnpState>_>::

+    reset((unique_ptr<DxgMonitor::MonitorPnpState,wistd::default_delete<DxgMonitor::MonitorPnpState>_>

+           *)(this + 200),(MonitorPnpState *)0x0);

+    wistd::

+    unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+    ::reset((unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+             *)(this + 0xc0),(IMonitorDescriptor *)0x0);

+    ExDeleteResourceLite(this + 0x28);

+    ReferenceCounted::~ReferenceCounted((ReferenceCounted *)this);

+    return;

+  }

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

+  (*pcVar5)(3);

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

+  (*pcVar5)();

+  return;

+}

+
```

## `CFlipManager::ConsumerImmediateTokenCompleted`  (modified)

```diff
--- CFlipManager::ConsumerImmediateTokenCompleted
+++ CFlipManager::ConsumerImmediateTokenCompleted
@@ -1,2 +1,254 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipManager::ConsumerImmediateTokenCompleted : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* WARNING: Type propagation algorithm not settling */

+/* public: void __cdecl CFlipManager::ConsumerImmediateTokenCompleted(class CFlipManagerToken *

+   __ptr64,class CToken * __ptr64 * __ptr64,class CFlipManagerSignal * __ptr64 * __ptr64) __ptr64 */

+

+void __thiscall

+CFlipManager::ConsumerImmediateTokenCompleted

+          (CFlipManager *this,CFlipManagerToken *param_1,CToken **param_2,

+          CFlipManagerSignal **param_3)

+

+{

+  IMonitorDescriptor *pIVar1;

+  longlong *******ppppppplVar2;

+  FlipManagerTokenIFlipInfo *pFVar3;

+  undefined8 uVar4;

+  code *pcVar5;

+  longlong *******ppppppplVar6;

+  PresentHistory *this_00;

+  FlipManagerObject *pFVar7;

+  CFlipManagerSignal *pCVar8;

+  bool bVar9;

+  uint uVar10;

+  long lVar11;

+  CFlipPresentUpdate *pCVar12;

+  longlong lVar13;

+  Entry *pEVar14;

+  FlipPresentProcessResult FVar15;

+  __uint64 _Var16;

+  undefined1 *puVar17;

+  CToken *pCVar18;

+  bool bVar19;

+  uint local_res8;

+  undefined1 auStack_e8 [8];

+  undefined1 auStack_e0 [56];

+  CFlipManagerSignal *local_a8;

+  CToken *local_a0;

+  CFlipManager *local_98;

+  CFlipPresentUpdate **local_90;

+  char local_88;

+  longlong *******local_80;

+  longlong *******local_78;

+  CFlipPresentUpdate *local_70;

+  longlong local_68;

+  FlipManagerTokenIFlipInfo *local_60;

+  CFlipManagerSignal **local_58;

+  CFlipManagerSignal *local_50;

+  undefined1 local_48;

+  

+  puVar17 = auStack_e8;

+  pCVar18 = (CToken *)0x0;

+  bVar19 = false;

+  if (this[0x20] != (CFlipManager)0x0) {

+    return;

+  }

+  pFVar3 = *(FlipManagerTokenIFlipInfo **)(param_1 + 0x50);

+  local_a0 = (CToken *)0x0;

+  local_a8 = (CFlipManagerSignal *)0x0;

+  local_68 = 0;

+  local_res8 = 0;

+  if (pFVar3 != (FlipManagerTokenIFlipInfo *)0x0) {

+    lVar13 = *(longlong *)(pFVar3 + 0x68);

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

+    bVar19 = *(int *)(lVar13 + 0x34) != 0;

+    local_res8 = *(uint *)(lVar13 + 0x30);

+  }

+  _Var16 = *(__uint64 *)(param_1 + 0x60);

+  local_60 = pFVar3;

+  pCVar12 = GetUpdateForPresentId(this,_Var16);

+  local_70 = pCVar12;

+  if (pCVar12 == (CFlipPresentUpdate *)0x0) {

+    MarkAsLost(this,-0x3fffffff,0x11,_Var16);

+    goto LAB_0;

+  }

+  local_90 = &local_70;

+  local_88 = 1;

+  local_98 = this;

+  if ((bVar19 == false) && (bVar9 = IsPresentCanceled(this,_Var16), bVar9)) {

+    lVar13 = DxgkGetWin32kImportTable();

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

+    pcVar5 = *(code **)(lVar13 + 0x180);

+    uVar10 = GetTracingId(this);

+    (*pcVar5)(uVar10,uVar4,2);

+    pCVar12 = local_70;

+  }

+  if ((pFVar3 != (FlipManagerTokenIFlipInfo *)0x0) &&

+     (bVar9 = CEndpointResourceStateManager::IsSimpleUpdatePresent(pCVar12), !bVar9)) {

+    _Var16 = *(__uint64 *)(pCVar12 + 0x40);

+    lVar11 = -0x3fffffff;

+    goto LAB_1;

+  }

+  PurgeSkippedTokens(this,*(__uint64 *)(pCVar12 + 0x40),bVar19);

+  puVar17 = auStack_e8;

+  if (this[0x20] == (CFlipManager)0x0) {

+    puVar17 = auStack_e8;

+    if (bVar19 == false) {

+      lVar11 = ApplyUpdateToConsumer(this,local_70);

+      if (lVar11 < 0) {

+        _Var16 = 0;

+      }

+      else {

+        local_78 = (longlong *******)&local_80;

+        local_80 = (longlong *******)&local_80;

+        lVar11 = ConsumerDwmProcessUpdateTokens(this,local_70,param_1,(_LIST_ENTRY *)&local_80);

+        if (-1 < lVar11) {

+          puVar17 = auStack_e8;

+          if ((longlong ********)local_80 != &local_80) {

+            if (param_2 != (CToken **)0x0) {

+              ppppppplVar6 = (longlong *******)*local_80;

+              if (((longlong ********)local_80[1] != &local_80) ||

+                 (pCVar18 = (CToken *)0x0, (longlong *******)ppppppplVar6[1] != local_80)) {

+LAB_2:

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

+                (*pcVar5)(3);

+                puVar17 = auStack_e0;

+                goto LAB_3;

+              }

+              ppppppplVar6[1] = (longlong ******)&local_80;

+              pIVar1 = (IMonitorDescriptor *)(local_80 + -1);

+              local_80 = ppppppplVar6;

+              wistd::

+              unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+              ::reset((unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+                       *)&local_a0,pIVar1);

+              pCVar18 = local_a0;

+            }

+            while (puVar17 = auStack_e8, (longlong ********)local_80 != &local_80) {

+              if (((longlong ********)local_80[1] != &local_80) ||

+                 (ppppppplVar6 = (longlong *******)*local_80,

+                 (longlong *******)ppppppplVar6[1] != local_80)) goto LAB_2;

+              ppppppplVar6[1] = (longlong ******)&local_80;

+              ppppppplVar2 = local_80 + -1;

+              local_80 = ppppppplVar6;

+              if (ppppppplVar2 != (longlong *******)0x0) {

+                (*(code *)**ppppppplVar2)(ppppppplVar2,1);

+              }

+            }

+          }

+LAB_3:

+          this_00 = *(PresentHistory **)(this + 0x18);

+          if (this_00 != (PresentHistory *)0x0) {

+            *(undefined8 *)(puVar17 + -8) = 0x14009f0da;

+            pEVar14 = PresentHistory::GetNextEntry(this_00);

+            *(undefined8 *)(pEVar14 + 0x18) = *(undefined8 *)(param_1 + 0x70);

+            *(undefined8 *)(pEVar14 + 0x10) = *(undefined8 *)(param_1 + 0x60);

+            *(undefined4 *)(pEVar14 + 0x28) = 8;

+          }

+          goto LAB_4;

+        }

+        _Var16 = 0;

+      }

+LAB_1:

+      MarkAsLost(this,lVar11,0x13,_Var16);

+      puVar17 = auStack_e8;

+    }

+    else {

+LAB_4:

+      pCVar12 = local_70;

+      *(undefined8 *)(puVar17 + -8) = 0x14009f100;

+      UpdateNextConsumerPresentIdForUpdate(this,pCVar12,0);

+      local_88 = '\0';

+      *(undefined8 *)(puVar17 + -8) = 0x14009f10d;

+      <lambda_45b452eeef8f878a1390d07846441040>::operator()(&local_98);

+      _Var16 = *(__uint64 *)(param_1 + 0x60);

+      local_58 = &local_a8;

+      local_50 = (CFlipManagerSignal *)0x0;

+      local_48 = 1;

+      *(undefined8 *)(puVar17 + -8) = 0x14009f133;

+      lVar11 = CFlipManagerSignal::Create(_Var16,(bool)(bVar19 ^ 1),pFVar3,&local_50);

+      *(undefined8 *)(puVar17 + -8) = 0x14009f13e;

+      wil::details::

+      out_param_t<wistd::unique_ptr<CFlipManagerSignal,wistd::default_delete<CFlipManagerSignal>_>_>

+      ::

+      ~out_param_t<wistd::unique_ptr<CFlipManagerSignal,wistd::default_delete<CFlipManagerSignal>_>_>

+                ((out_param_t<wistd::unique_ptr<CFlipManagerSignal,wistd::default_delete<CFlipManagerSignal>_>_>

+                  *)&local_58);

+      pCVar8 = local_a8;

+      if (lVar11 < 0) {

+LAB_5:

+        *(undefined8 *)(puVar17 + -8) = 0x14009f153;

+        MarkAsLost(this,lVar11,0x13,0);

+      }

+      else {

+        *(undefined8 *)(puVar17 + -8) = 0x14009f16f;

+        lVar11 = CEndpointResourceStateManager::PrepareBufferSignals

+                           ((CEndpointResourceStateManager *)(this + 0x68),pCVar8);

+        pCVar8 = local_a8;

+        if (lVar11 < 0) goto LAB_5;

+        if (pCVar18 == (CToken *)0x0) {

+          local_a8 = (CFlipManagerSignal *)0x0;

+          *(undefined8 *)(puVar17 + -8) = 0x14009f1a6;

+          ProcessSignal(this,pCVar8,0xffffffffffffffff,false);

+        }

+        else {

+          pFVar7 = *(FlipManagerObject **)(param_1 + 0x58);

+          *(undefined8 *)(puVar17 + -8) = 0x14009f189;

+          lVar11 = CFlipManagerSignal::SetFlipManagerObject(pCVar8,pFVar7);

+          if (lVar11 < 0) goto LAB_5;

+        }

+        if (bVar19 == false) {

+          FVar15 = (FlipPresentProcessResult)(local_68 == 0);

+        }

+        else {

+          FVar15 = 3;

+        }

+        _Var16 = *(__uint64 *)(param_1 + 0x60);

+        *(undefined8 *)(puVar17 + -8) = 0x14009f1cf;

+        lVar11 = PostFlipManagerPresentStatusStatistics(this,_Var16,0,FVar15);

+        if (lVar11 < 0) goto LAB_5;

+        _Var16 = *(__uint64 *)(param_1 + 0x60);

+        *(undefined8 *)(puVar17 + -8) = 0x14009f1e6;

+        FreeExpiredCancels(this,_Var16);

+        *(undefined8 *)(puVar17 + -8) = 0x14009f1eb;

+        lVar13 = DxgkGetWin32kImportTable();

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

+        pcVar5 = *(code **)(lVar13 + 0xd8);

+        *(undefined8 *)(puVar17 + -8) = 0x14009f205;

+        uVar10 = GetTracingId(this);

+        *(ulonglong *)(puVar17 + 0x28) = (ulonglong)local_res8;

+        *(longlong *)(puVar17 + 0x20) = local_68;

+        *(undefined8 *)(puVar17 + -8) = 0x14009f22a;

+        (*pcVar5)(uVar10,uVar4,pCVar18 != (CToken *)0x0,bVar19);

+        if (local_60 != (FlipManagerTokenIFlipInfo *)0x0) {

+          *(undefined8 *)(puVar17 + -8) = 0x14009f23d;

+          PostFlipManagerIFlipFrameStatistics(this,param_1);

+        }

+        if (param_2 != (CToken **)0x0) {

+          local_a0 = (CToken *)0x0;

+          *param_2 = pCVar18;

+        }

+        if (param_3 != (CFlipManagerSignal **)0x0) {

+          *param_3 = local_a8;

+          local_a8 = (CFlipManagerSignal *)0x0;

+        }

+      }

+      if (local_88 == '\0') goto LAB_0;

+    }

+  }

+  local_88 = '\0';

+  *(undefined8 *)(puVar17 + -8) = 0x14009f272;

+  <lambda_45b452eeef8f878a1390d07846441040>::operator()(&local_98);

+LAB_0:

+  *(undefined8 *)(puVar17 + -8) = 0x14009f27d;

+  wistd::unique_ptr<CFlipManagerSignal,wistd::default_delete<CFlipManagerSignal>_>::reset

+            ((unique_ptr<CFlipManagerSignal,wistd::default_delete<CFlipManagerSignal>_> *)&local_a8,

+             (CFlipManagerSignal *)0x0);

+  *(undefined8 *)(puVar17 + -8) = 0x14009f288;

+  wistd::

+  unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+  ::reset((unique_ptr<DxgMonitor::IMonitorDescriptor,wistd::default_delete<DxgMonitor::IMonitorDescriptor>_>

+           *)&local_a0,(IMonitorDescriptor *)0x0);

+  return;

+}

+
```

## `DXGDEVICE::CreateStandardAllocation`  (modified)

```diff
--- DXGDEVICE::CreateStandardAllocation
+++ DXGDEVICE::CreateStandardAllocation
@@ -1,2 +1,453 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGDEVICE::CreateStandardAllocation : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

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

+/* public: long __cdecl DXGDEVICE::CreateStandardAllocation(struct _D3DKM_CREATESTANDARDALLOCATION *

+   __ptr64,class COREDEVICEACCESS * __ptr64) __ptr64 */

+

+long __thiscall

+DXGDEVICE::CreateStandardAllocation

+          (DXGDEVICE *this,_D3DKM_CREATESTANDARDALLOCATION *param_1,COREDEVICEACCESS *param_2)

+

+{

+  char cVar1;

+  uint uVar2;

+  DXGADAPTER *this_00;

+  int *piVar3;

+  longlong lVar4;

+  undefined1 auVar5 [16];

+  byte bVar6;

+  uchar uVar7;

+  char cVar8;

+  int iVar9;

+  long lVar10;

+  uint uVar11;

+  void *pvVar12;

+  DXGPROCESS *pDVar13;

+  undefined4 uVar14;

+  uint uVar15;

+  DXGALLOCATION *pDVar16;

+  undefined8 uVar17;

+  uint *puVar18;

+  longlong lVar19;

+  uint *puVar20;

+  ulonglong uVar21;

+  wchar_t *pwVar22;

+  uint uVar23;

+  undefined1 auStackY_338 [32];

+  uint local_2b4;

+  _D3DKM_CREATESTANDARDALLOCATION *local_2b0;

+  uint local_2a8;

+  void *local_2a0;

+  uint *local_298;

+  longlong local_290;

+  COREDEVICEACCESS *local_288;

+  ulonglong local_280;

+  undefined8 uStack_278;

+  void *local_270;

+  ulonglong uStack_268;

+  void *local_260;

+  undefined8 uStack_258;

+  longlong local_250;

+  undefined4 local_248;

+  undefined8 local_244;

+  undefined8 local_238;

+  undefined4 local_230;

+  void *local_228;

+  undefined4 local_220;

+  uint local_21c;

+  uint *local_218;

+  uint local_210;

+  DXGHANDLETABLELOCKEXCLUSIVE local_1f8 [32];

+  uint *local_1d8;

+  uint local_1d0 [96];

+  uint local_50;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStackY_338;

+  local_288 = param_2;

+  memset(&local_248,0,0x48);

+  local_2a0 = (void *)0x0;

+  DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE

+            ((DXGALLOCATIONREFERENCE *)&local_290,(DXGALLOCATION *)0x0);

+  uVar23 = 1;

+  local_2a8 = 0;

+  this_00 = *(DXGADAPTER **)(*(longlong *)(this + 0x10) + 0x10);

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

+     ((this_00[0xbe7] != (DXGADAPTER)0x0 ||

+      (uVar7 = DXGADAPTER::ReplicateGdiContent(this_00), uVar7 != '\0')))) {

+LAB_0:

+    uVar23 = DXGADAPTER::GetNumDifferentPhysicalAdapters(this_00);

+LAB_1:

+    if ((*(int *)(param_1 + 0x10) == 1) && (*(longlong *)(this_00 + 0xc48) == 0)) {

+      *(undefined4 *)(*(longlong *)(param_1 + 0x18) + 0x14) = 0;

+    }

+  }

+  else {

+    uVar7 = DXGADAPTER::ReplicateGdiContent(*(DXGADAPTER **)(*(longlong *)(this + 0x10) + 0x10));

+    if ((uVar7 == '\0') || (*(int *)(param_1 + 0x10) != 4)) goto LAB_1;

+    if (((*(int *)(*(longlong *)(param_1 + 0x18) + 0xc) - 1U & 0xfffffffc) == 0) &&

+       (*(int *)(*(longlong *)(param_1 + 0x18) + 0xc) != 2)) goto LAB_0;

+  }

+  local_1d8 = (uint *)0x0;

+  local_50 = 0;

+  uVar15 = uVar23;

+  if (uVar23 < 5) {

+    local_1d8 = local_1d0;

+    if (uVar23 != 0) {

+      memset(local_1d0,0,(ulonglong)uVar23 * 0x60);

+    }

+  }

+  else {

+    auVar5._8_8_ = 0;

+    auVar5._0_8_ = CONCAT44(0,uVar23);

+    uVar15 = local_50;

+    if (0x5f < SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar5,0)) {

+      local_1d8 = (uint *)ExAllocatePool2(0x100,CONCAT44(0,uVar23) * 0x60,0x4b677844);

+      uVar15 = uVar23;

+    }

+  }

+  local_50 = uVar15;

+  puVar20 = local_1d8;

+  iVar9 = Feature_Servicing_MSRC110751__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar9 != 0) && (puVar20 == (uint *)0x0)) {

+    WdLogSingleEntry2(2,this,uVar23);

+    _WdLogGlobalForLineNumber = 0x1d50;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Device 0x%I64x: Failed to allocate AllocationInfoArray for %d allocations");

+    if ((local_1d8 != local_1d0) && (local_1d8 != (uint *)0x0)) {

+      ExFreePoolWithTag(local_1d8,0);

+    }

+    lVar10 = -0x3fffffe9;

+    goto LAB_2;

+  }

+  cVar1 = *(char *)(*(longlong *)(*(ADAPTER_RENDER **)(this + 0x10) + 0x10) + 0xd1);

+  local_280 = (ulonglong)*(uint *)(param_1 + 0x10);

+  uStack_278 = *(undefined8 *)(param_1 + 0x18);

+  local_270 = (void *)0x0;

+  uStack_268 = 0;

+  local_260 = (void *)0x0;

+  uStack_258 = 0;

+  lVar10 = ADAPTER_RENDER::DdiGetStandardAllocationDriverData

+                     (*(ADAPTER_RENDER **)(this + 0x10),

+                      (_DXGKARG_GETSTANDARDALLOCATIONDRIVERDATA *)&local_280);

+  if (-1 < lVar10) {

+    if (((uint)uStack_268 == 0) && ((int)uStack_258 == 0)) {

+      WdLogSingleEntry2(2,this,0xffffffffc000000d);

+      pwVar22 = 

+      L"Device 0x%I64x: Driver returned zero size for pAllocationPrivateDriverData and pResourcePrivateDriverData buffer, returning 0x%I64x"

+      ;

+      _WdLogGlobalForLineNumber = 0x1d69;

+    }

+    else {

+      if ((*(uint *)param_1 & 0x40) == 0) {

+LAB_3:

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

+          uVar14 = 0;

+LAB_4:

+          local_2b4 = 0;

+          if (uVar23 != 0) {

+            puVar18 = puVar20 + 6;

+            uVar15 = (uint)uStack_268;

+            do {

+              pvVar12 = (void *)0x0;

+              if (uVar15 != 0) {

+                pvVar12 = operator_new__((ulonglong)uVar15,0x4b677844,0x100);

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

+                  lVar10 = -0x3fffffe9;

+                  WdLogSingleEntry3(3,this,uStack_268 & 0xffffffff,0xffffffffc0000017);

+                  _WdLogGlobalForLineNumber = 0x1d9e;

+                  goto LAB_5;

+                }

+                local_2a8 = local_2a8 + 1;

+              }

+              *(void **)(puVar18 + -2) = pvVar12;

+              *puVar18 = (uint)uStack_268;

+              uVar15 = local_2b4;

+              if (uVar23 < 2) {

+                uVar15 = *(uint *)(param_1 + 0x17c);

+              }

+              uStack_258 = CONCAT44(uVar15,(int)uStack_258);

+              local_270 = pvVar12;

+              local_260 = local_2a0;

+              lVar10 = ADAPTER_RENDER::DdiGetStandardAllocationDriverData

+                                 (*(ADAPTER_RENDER **)(this + 0x10),

+                                  (_DXGKARG_GETSTANDARDALLOCATIONDRIVERDATA *)&local_280);

+              if (lVar10 < 0) {

+                WdLogSingleEntry3(1,this,(longlong)lVar10);

+                _WdLogGlobalForLineNumber = 0x1db3;

+                pwVar22 = 

+                L"Device 0x%I64x: Driver fialed to generate pPrivateDriverData buffer, returning 0x%I64x"

+                ;

+                uVar17 = 0x40002;

+LAB_6:

+                DxgkLogInternalTriageEvent(0,uVar17,0xffffffff,pwVar22);

+                goto LAB_5;

+              }

+              if ((((((*(uint *)param_1 & 0x60) != 0) &&

+                    (piVar3 = *(int **)(param_1 + 0x18), piVar3[2] != 0)) &&

+                   (iVar9 = GetPixelSizeInBytes(),

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

+                  && ((iVar9 != 0 && (uVar15 = piVar3[5], uVar15 != 0)))) &&

+                 (uVar15 != (*piVar3 * iVar9 + 0x7fU & 0xffffff80))) {

+                lVar10 = -0x3ffffff3;

+                WdLogSingleEntry4(2,this,uVar15,*piVar3);

+                pwVar22 = 

+                L"Device 0x%I64x: Driver returned invalid pitch (0x%I64x) for the cross adapter allocation width (0x%I64x), returning 0x%I64x"

+                ;

+                uVar17 = 0x40000;

+                _WdLogGlobalForLineNumber = 0x1dcd;

+                goto LAB_6;

+              }

+              if (((byte)*(undefined4 *)param_1 & 0xc0) == 0xc0) {

+                WdLogSingleEntry0(1);

+                _WdLogGlobalForLineNumber = 0x1dd7;

+                DxgkLogInternalTriageEvent(0,0x40002,0xffffffff);

+              }

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

+                uVar15 = *(uint *)(*(longlong *)(param_1 + 0x18) + 0x14);

+                puVar18[2] = puVar18[2] | 1;

+                puVar18[1] = uVar15;

+              }

+              puVar18 = puVar18 + 0x18;

+              local_2b4 = local_2b4 + 1;

+              if (uVar23 <= local_2b4) goto LAB_7;

+              uVar15 = (uint)uStack_268;

+            } while( true );

+          }

+          goto LAB_8;

+        }

+        local_2a0 = operator_new__(uStack_258 & 0xffffffff,0x4b677844,0x100);

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

+          uVar14 = (int)uStack_258;

+          goto LAB_4;

+        }

+        lVar10 = -0x3fffffe9;

+        WdLogSingleEntry3(3,this,uStack_258 & 0xffffffff,0xffffffffc0000017);

+        _WdLogGlobalForLineNumber = 0x1d8c;

+        goto LAB_9;

+      }

+      if (*(int *)(param_1 + 0x168) == (int)uStack_258) {

+        if (*(uint *)(param_1 + 0x178) == (uint)uStack_268) goto LAB_3;

+        WdLogSingleEntry3(2,this,0xffffffffc000000d,2);

+        pwVar22 = 

+        L"Device 0x%I64x: Input TotalPrivateDriverDataBufferSize does not match the driver\'s AllocationPrivateDriverDataSize, returning 0x%I64x"

+        ;

+        _WdLogGlobalForLineNumber = 0x1d7e;

+      }

+      else {

+        WdLogSingleEntry3(2,this,0xffffffffc000000d,1);

+        pwVar22 = 

+        L"Device 0x%I64x: Input ResourcePrivateDriverDataSize does not match the driver\'s ResourcePrivateDriverDataSize, returning 0x%I64x"

+        ;

+        _WdLogGlobalForLineNumber = 0x1d77;

+      }

+    }

+    DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,pwVar22);

+    if ((local_1d8 != local_1d0) && (local_1d8 != (uint *)0x0)) {

+      ExFreePoolWithTag(local_1d8,0);

+    }

+    lVar10 = -0x3ffffff3;

+    goto LAB_2;

+  }

+  WdLogSingleEntry2(2,this,(longlong)lVar10);

+  _WdLogGlobalForLineNumber = 0x1d61;

+  DxgkLogInternalTriageEvent

+            (0,0x40000,0xffffffff,

+             L"Device 0x%I64x: Failed to find size of PrivateDriverData buffers, returning 0x%I64x")

+  ;

+LAB_10:

+  if ((local_1d8 != local_1d0) && (local_1d8 != (uint *)0x0)) {

+    ExFreePoolWithTag(local_1d8,0);

+  }

+LAB_2:

+  local_1d8 = (uint *)0x0;

+  local_50 = 0;

+  DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE((DXGALLOCATIONREFERENCE *)&local_290);

+  return lVar10;

+LAB_7:

+  uVar14 = (int)uStack_258;

+LAB_8:

+  local_248 = *(undefined4 *)(param_1 + 4);

+  local_244 = 0;

+  local_228 = local_2a0;

+  local_238 = *(undefined8 *)(param_1 + 0x138);

+  local_230 = *(undefined4 *)(param_1 + 0x140);

+  uVar15 = *(uint *)param_1;

+  local_210 = (((((uVar15 & 0x60) * 2 | uVar15 & 0x18) << 2 | uVar15 & 4 | uVar15 & 0x800) * 2 |

+               uVar15 & 2) * 2 | uVar15 & 1) * 2 |

+              (uint)(param_1[0x198] == (_D3DKM_CREATESTANDARDALLOCATION)0x0) | uVar15 >> 4 & 0x440 |

+              local_210 & 0xffffa094;

+  local_220 = uVar14;

+  local_21c = uVar23;

+  local_218 = puVar20;

+  lVar10 = CreateAllocation(this,(_D3DKMT_CREATEALLOCATION *)&local_248,'\0','\0',

+                            (_DXGSHAREDALLOCOBJECT *)0x0,param_1,local_288,0,(_EPROCESS *)0x0,

+                            (uint *)0x0,(__uint64 *)0x0,(__uint64 *)0x0,

+                            (_D3DKMT_CREATESTANDARDALLOCATION *)0x0,(void *)0x0,0);

+  if (lVar10 < 0) {

+    WdLogSingleEntry3(3,this,(longlong)lVar10);

+    _WdLogGlobalForLineNumber = 0x1e02;

+  }

+  else {

+    local_2b4 = 0;

+    lVar19 = local_290;

+    if (uVar23 != 0) {

+      local_2b0 = param_1 + 0x34;

+      local_298 = puVar20;

+      do {

+        local_250 = *(longlong *)(this + 0x28);

+        uVar15 = *local_298;

+        DXGPUSHLOCK::AcquireShared((DXGPUSHLOCK *)(local_250 + 0xf8));

+        uVar11 = uVar15 >> 6 & 0xffffff;

+        if (uVar11 < *(uint *)(local_250 + 0x128)) {

+          uVar2 = *(uint *)(*(longlong *)(local_250 + 0x118) + 8 + (ulonglong)uVar11 * 0x10);

+          if (((((byte)(uVar15 >> 0x19) & 0x60) != ((byte)uVar2 & 0x60)) ||

+              ((uVar2 >> 0xd & 1) != 0)) || ((uVar2 & 0x1f) == 0)) goto LAB_11;

+          if ((uVar2 & 0x1f) == 5) {

+            pDVar16 = *(DXGALLOCATION **)

+                       (*(longlong *)(local_250 + 0x118) + (ulonglong)uVar11 * 0x10);

+          }

+          else {

+            WdLogSingleEntry0(2);

+            pDVar16 = (DXGALLOCATION *)0x0;

+            _WdLogGlobalForLineNumber = 0x13e;

+            DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch");

+          }

+        }

+        else {

+LAB_11:

+          pDVar16 = (DXGALLOCATION *)0x0;

+        }

+        DXGALLOCATIONREFERENCE::DXGALLOCATIONREFERENCE((DXGALLOCATIONREFERENCE *)&local_288,pDVar16)

+        ;

+        LOCK();

+        *(int *)(local_250 + 0x108) = *(int *)(local_250 + 0x108) + -1;

+        UNLOCK();

+        ExReleasePushLockSharedEx(local_250 + 0xf8,0);

+        KeLeaveCriticalRegion();

+        DXGALLOCATIONREFERENCE::MoveAssign

+                  ((DXGALLOCATIONREFERENCE *)&local_290,(DXGALLOCATIONREFERENCE *)&local_288);

+        DXGALLOCATIONREFERENCE::~DXGALLOCATIONREFERENCE((DXGALLOCATIONREFERENCE *)&local_288);

+        lVar19 = local_290;

+        if (local_290 == 0) {

+          WdLogSingleEntry3(1,this,puVar20[(ulonglong)local_2b4 * 0x18],0xffffffffc000000d);

+          pwVar22 = 

+          L"Device 0x%I64x: created standard allocation but the allocation handle (0x%I64x) lookup failed!, returning 0x%I64x"

+          ;

+          uVar17 = 0x40002;

+          _WdLogGlobalForLineNumber = 0x1e10;

+LAB_12:

+          lVar10 = -0x3ffffff3;

+          DxgkLogInternalTriageEvent(0,uVar17,0xffffffff,pwVar22);

+          lVar19 = 0;

+          if ((uint)local_244 == 0) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x1e54;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"CreateAlloc.hResource != NULL");

+          }

+          pDVar13 = DXGPROCESS::GetCurrent();

+          if (pDVar13 == (DXGPROCESS *)0x0) {

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x1e5c;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pProcess != NULL");

+          }

+          DXGHANDLETABLELOCKEXCLUSIVE::DXGHANDLETABLELOCKEXCLUSIVE(local_1f8,pDVar13);

+          uVar23 = (uint)local_244 >> 6 & 0xffffff;

+          if (uVar23 < *(uint *)(pDVar13 + 0x128)) {

+            lVar4 = *(longlong *)(pDVar13 + 0x118);

+            bVar6 = (byte)((ulonglong)local_244 >> 0x18);

+            uVar15 = *(uint *)(lVar4 + 8 + (ulonglong)uVar23 * 0x10);

+            if ((((bVar6 >> 1 & 0x60) != ((byte)uVar15 & 0x60)) || ((uVar15 & 0x2000) != 0)) ||

+               ((uVar15 & 0x1f) == 0)) goto LAB_13;

+            if ((uVar15 & 0x1f) != 4) {

+              WdLogSingleEntry0(2);

+              _WdLogGlobalForLineNumber = 0x13e;

+              DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Handle type mismatch");

+              goto LAB_13;

+            }

+            lVar19 = *(longlong *)(lVar4 + (ulonglong)uVar23 * 0x10);

+            if (lVar19 == 0) goto LAB_13;

+            uVar23 = (uint)local_244 >> 6 & 0xffffff;

+            if (((uVar23 < *(uint *)(pDVar13 + 0x128)) &&

+                (uVar23 = *(uint *)(lVar4 + 8 + (ulonglong)uVar23 * 0x10),

+                (bVar6 >> 1 & 0x60) == ((byte)uVar23 & 0x60))) &&

+               (((uVar23 & 0x2000) == 0 && ((uVar23 & 0x1f) != 0)))) {

+              puVar18 = (uint *)(lVar4 + 8 + (ulonglong)((uint)local_244 >> 6 & 0xffffff) * 0x10);

+              *puVar18 = *puVar18 | 0x2000;

+            }

+          }

+          else {

+LAB_13:

+            WdLogSingleEntry0(1);

+            _WdLogGlobalForLineNumber = 0x1e62;

+            DxgkLogInternalTriageEvent(0,0x40002,0xffffffff,L"pResource != NULL");

+          }

+          DXGPROCESSDDILOCK::~DXGPROCESSDDILOCK((DXGPROCESSDDILOCK *)local_1f8);

+          if (lVar19 != 0) {

+            DestroyAllocationInternal(this,0,0,lVar19);

+          }

+          goto LAB_5;

+        }

+        *(uint *)local_2b0 = *local_298;

+        if ((cVar1 == '\0') &&

+           (cVar8 = (**(code **)(*(longlong *)

+                                  (*(longlong *)(*(longlong *)(this + 0x10) + 0x2f8) + 8) + 0xa0))

+                              (*(undefined8 *)(*(longlong *)(local_290 + 0x30) + 8)), cVar8 == '\0')

+           ) {

+          iVar9 = *(int *)(param_1 + 0x10);

+          if (iVar9 == 4) {

+            if (*(int *)(*(longlong *)(param_1 + 0x18) + 0xc) == 2) {

+LAB_14:

+              if (((*(uint *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x10) + 0x9bc) & 0x200) ==

+                   0) || (iVar9 != 1)) {

+                WdLogSingleEntry3(2,this,(longlong)iVar9,0xffffffffc000000d);

+                pwVar22 = 

+                L"Device 0x%I64x: Driver did not create CPUVisible allocation for standard allocation type 0x%I64x, returning 0x%I64x"

+                ;

+                uVar17 = 0x40000;

+                _WdLogGlobalForLineNumber = 0x1e2a;

+                goto LAB_12;

+              }

+            }

+          }

+          else if (iVar9 != 5) goto LAB_14;

+        }

+        local_2b0 = local_2b0 + 4;

+        local_298 = local_298 + 0x18;

+        local_2b4 = local_2b4 + 1;

+      } while (local_2b4 < uVar23);

+    }

+    *(uint *)(param_1 + 8) = (uint)local_244;

+    *(undefined4 *)(param_1 + 0xc) = local_244._4_4_;

+    if ((*(int *)(param_1 + 0x10) == 4) &&

+       ((*(int *)(*(longlong *)(param_1 + 0x18) + 0xc) - 6U & 0xfffffffd) == 0)) {

+      uVar17 = (**(code **)(*(longlong *)(*(longlong *)(*(longlong *)(this + 0x10) + 0x2f8) + 8) +

+                           0x278))(*(undefined8 *)(lVar19 + 0x18));

+    }

+    else {

+      uVar17 = 0;

+    }

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

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

+      memmove(*(void **)(param_1 + 0x170),*(void **)(puVar20 + 4),

+              (ulonglong)*(uint *)(param_1 + 0x178));

+      memmove(*(void **)(param_1 + 0x160),local_260,(ulonglong)*(uint *)(param_1 + 0x168));

+    }

+  }

+LAB_5:

+  if (local_2a8 != 0) {

+    puVar20 = puVar20 + 4;

+    uVar21 = (ulonglong)local_2a8;

+    do {

+      DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(*(void **)puVar20);

+      puVar20 = puVar20 + 0x18;

+      uVar21 = uVar21 - 1;

+    } while (uVar21 != 0);

+  }

+LAB_9:

+  DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(local_2a0);

+  goto LAB_10;

+}

+
```

## `AUTO_PNPPOWER_LOCK::Release`  (modified)

```diff
--- AUTO_PNPPOWER_LOCK::Release
+++ AUTO_REMOVE_LOCK::Acquire
@@ -1,2 +1,2 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB AUTO_PNPPOWER_LOCK::Release : Error: Decompile error: 
+Failed to decompile dxgkrnl.sys - .ProgramDB AUTO_REMOVE_LOCK::Acquire : Error: Decompile error: 
 Marshaling error: Did not see expected closing element
```

## `DXGMONITOR::_InitializeMonitorNoDriver`  (modified)

```diff
--- DXGMONITOR::_InitializeMonitorNoDriver
+++ DXGMONITOR::_InitializeMonitorNoDriver
@@ -1,2 +1,298 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGMONITOR::_InitializeMonitorNoDriver : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

+/* public: long __cdecl DXGMONITOR::_InitializeMonitorNoDriver(class wistd::unique_ptr<class

+   DxgMonitor::IMonitorDriverInterface,struct wistd::default_delete<class

+   DxgMonitor::IMonitorDriverInterface> > && __ptr64,unsigned int,struct _DEVICE_OBJECT *

+   __ptr64,unsigned char,unsigned char,enum _DMM_VIDPN_MONITOR_TYPE,struct

+   DXGKMON_USB4_HOSTROUTER_INFO * __ptr64) __ptr64 */

+

+long __thiscall

+DXGMONITOR::_InitializeMonitorNoDriver

+          (DXGMONITOR *this,

+          unique_ptr<DxgMonitor::IMonitorDriverInterface,wistd::default_delete<DxgMonitor::IMonitorDriverInterface>_>

+          *param_1,uint param_2,_DEVICE_OBJECT *param_3,uchar param_4,uchar param_5,

+          _DMM_VIDPN_MONITOR_TYPE param_6,DXGKMON_USB4_HOSTROUTER_INFO *param_7)

+

+{

+  IMonitorComponentParent *pIVar1;

+  undefined8 uVar2;

+  undefined8 *puVar3;

+  POHANDLE__ *pPVar4;

+  MonitorDataStore *this_00;

+  void *pvVar5;

+  _D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY _Var6;

+  _DMM_VIDPN_MONITOR_TYPE _Var7;

+  char cVar8;

+  long lVar9;

+  longlong lVar10;

+  MonitorPnpState *pMVar11;

+  MonitorPnpState *pMVar12;

+  MonitorDescriptorState *pMVar13;

+  MonitorDescriptorState *pMVar14;

+  MonitorColorState *this_01;

+  MonitorColorState *pMVar15;

+  MonitorModes *this_02;

+  MonitorModes *pMVar16;

+  MonitorGammaState *this_03;

+  MonitorGammaState *pMVar17;

+  MonitorUsb4State *this_04;

+  MonitorUsb4State *pMVar18;

+  MonitorDisplayPortState *this_05;

+  MonitorMipiDsiState *pMVar19;

+  MonitorMipiDsiState *pMVar20;

+  bool bVar21;

+  undefined3 in_stack_00000029;

+  

+  lVar10 = WdLogNewEntry5_WdTrace();

+  _Var7 = param_6;

+  *(DXGMONITOR **)(lVar10 + 0x18) = this;

+  _WdLogGlobalForLineNumber = 0x2e0;

+  if (param_6 == 0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x2e9;

+LAB_0:

+    if (param_3 == (_DEVICE_OBJECT *)0x0) goto LAB_1;

+  }

+  else {

+    if (param_6 != 1) goto LAB_0;

+    if (param_3 != (_DEVICE_OBJECT *)0x0) goto LAB_1;

+  }

+  WdLogSingleEntry0(1);

+  _WdLogGlobalForLineNumber = 0x2ea;

+LAB_1:

+  *(uint *)(this + 0xb4) = param_2;

+  *(_DMM_VIDPN_MONITOR_TYPE *)(this + 0x118) = _Var7;

+  *(_DMM_VIDPN_MONITOR_TYPE *)(this + 0x11c) = _Var7;

+  uVar2 = *(undefined8 *)param_1;

+  *(undefined8 *)param_1 = 0;

+  puVar3 = *(undefined8 **)(this + 0xc0);

+  *(undefined8 *)(this + 0xc0) = uVar2;

+  if (puVar3 != (undefined8 *)0x0) {

+    (**(code **)*puVar3)(puVar3,1);

+  }

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

+    bVar21 = param_5 != '\0';

+    param_5 = -param_5;

+    this[0xb0] = (DXGMONITOR)(~-bVar21 & 4U | (byte)this[0xb0] & 0xfb | 2);

+  }

+  cVar8 = (**(code **)(**(longlong **)(this + 0xa8) + 0x58))();

+  param_6 = 0xffffffff;

+  this[0xb1] = (DXGMONITOR)(-(cVar8 != '\0') & 0x20U | (byte)this[0xb1] & 0xdf);

+  DmmGetVidPnTargetPowerComponentIndex

+            (*(void **)(*(longlong *)(*(longlong *)(this + 0xa8) + 0x18) + 0x10),

+             *(uint *)(this + 0xb4),&param_6);

+  pPVar4 = *(POHANDLE__ **)

+            (*(longlong *)(*(longlong *)(*(longlong *)(this + 0xa8) + 0x18) + 0x10) + 0xcb8);

+  pMVar11 = operator_new(0x50,0x4d677844,0x40);

+  pMVar12 = (MonitorPnpState *)0x0;

+  pIVar1 = (IMonitorComponentParent *)(this + 0x10);

+  if (pMVar11 != (MonitorPnpState *)0x0) {

+    *(IMonitorComponentParent **)pMVar11 = pIVar1;

+    pMVar11[0x10] = (MonitorPnpState)0x0;

+    *(undefined8 *)(pMVar11 + 0x18) = 0;

+    *(undefined8 *)(pMVar11 + 0x20) = 0;

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

+    *(undefined8 *)(pMVar11 + 0x30) = 0;

+    *(undefined8 *)(pMVar11 + 0x38) = 0;

+    *(undefined8 *)(pMVar11 + 0x40) = 0;

+    *(undefined8 *)(pMVar11 + 0x48) = 0;

+    *(_DEVICE_OBJECT **)(pMVar11 + 8) = param_3;

+    pMVar12 = pMVar11;

+  }

+  wistd::unique_ptr<DxgMonitor::MonitorPnpState,wistd::default_delete<DxgMonitor::MonitorPnpState>_>

+  ::reset((unique_ptr<DxgMonitor::MonitorPnpState,wistd::default_delete<DxgMonitor::MonitorPnpState>_>

+           *)(this + 200),pMVar12);

+  if (*(longlong *)(this + 200) == 0) {

+    WdLogSingleEntry1(2,0xffffffffc0000017);

+    _WdLogGlobalForLineNumber = 0x305;

+  }

+  else {

+    pMVar13 = operator_new(0x18,0x4d677844,0x100);

+    pMVar20 = (MonitorMipiDsiState *)0x0;

+    pMVar14 = (MonitorDescriptorState *)pMVar20;

+    if (pMVar13 != (MonitorDescriptorState *)0x0) {

+      *(IMonitorComponentParent **)(pMVar13 + 8) = pIVar1;

+      *(undefined ***)pMVar13 = &DxgMonitor::MonitorDataStore::_vftable_;

+      *(DXGMONITOR **)(pMVar13 + 0x10) = this + 0x18;

+      pMVar14 = pMVar13;

+    }

+    this_00 = *(MonitorDataStore **)(this + 0xd0);

+    *(MonitorDescriptorState **)(this + 0xd0) = pMVar14;

+    if (this_00 != (MonitorDataStore *)0x0) {

+      DxgMonitor::MonitorDataStore::_scalar_deleting_destructor_(this_00,1);

+    }

+    if (*(longlong *)(this + 0xd0) == 0) {

+      WdLogSingleEntry1(2,0xffffffffc0000017);

+      _WdLogGlobalForLineNumber = 0x308;

+    }

+    else {

+      pMVar13 = operator_new(0xb8,0x4d677844,0x40);

+      pMVar14 = (MonitorDescriptorState *)pMVar20;

+      if (pMVar13 != (MonitorDescriptorState *)0x0) {

+        pMVar14 = (MonitorDescriptorState *)

+                  DxgMonitor::MonitorDescriptorState::MonitorDescriptorState

+                            (pMVar13,pIVar1,*(IMonitorRegistry **)(this + 0xd0));

+      }

+      wistd::

+      unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+      ::reset((unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+               *)(this + 0xd8),pMVar14);

+      if (*(longlong *)(this + 0xd8) == 0) {

+        WdLogSingleEntry1(2,0xffffffffc0000017);

+        _WdLogGlobalForLineNumber = 0x30b;

+      }

+      else {

+        this_01 = operator_new(0x230,0x4d677844,0x100);

+        pMVar15 = (MonitorColorState *)pMVar20;

+        if (this_01 != (MonitorColorState *)0x0) {

+          pMVar15 = (MonitorColorState *)

+                    DxgMonitor::MonitorColorState::MonitorColorState

+                              (this_01,pIVar1,*(IMonitorRegistry **)(this + 0xd0));

+        }

+        wistd::

+        unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+        ::reset((unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+                 *)(this + 0xe0),pMVar15);

+        if (*(longlong *)(this + 0xe0) == 0) {

+          WdLogSingleEntry1(2,0xffffffffc0000017);

+          _WdLogGlobalForLineNumber = 0x30e;

+        }

+        else {

+          pMVar13 = operator_new(0x18,0x4d677844,0x100);

+          pMVar14 = (MonitorDescriptorState *)pMVar20;

+          if (pMVar13 != (MonitorDescriptorState *)0x0) {

+            *(undefined8 *)(pMVar13 + 8) = *(undefined8 *)(this + 0xd0);

+            *(IMonitorComponentParent **)pMVar13 = pIVar1;

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

+            *(undefined2 *)(pMVar13 + 0x14) = 0;

+            pMVar13[0x16] = (MonitorDescriptorState)0x0;

+            pMVar14 = pMVar13;

+          }

+          pvVar5 = *(void **)(this + 0xf0);

+          *(MonitorDescriptorState **)(this + 0xf0) = pMVar14;

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

+            DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pvVar5);

+          }

+          if (*(longlong *)(this + 0xf0) == 0) {

+            WdLogSingleEntry1(2,0xffffffffc0000017);

+            _WdLogGlobalForLineNumber = 0x311;

+          }

+          else {

+            this_02 = operator_new(0xf8,0x4d677844,0x40);

+            pMVar16 = (MonitorModes *)pMVar20;

+            if (this_02 != (MonitorModes *)0x0) {

+              pMVar16 = (MonitorModes *)

+                        DxgMonitor::MonitorModes::MonitorModes

+                                  (this_02,pIVar1,*(IMonitorRegistry **)(this + 0xd0));

+            }

+            wistd::

+            unique_ptr<DxgMonitor::MonitorModes,wistd::default_delete<DxgMonitor::MonitorModes>_>::

+            reset((unique_ptr<DxgMonitor::MonitorModes,wistd::default_delete<DxgMonitor::MonitorModes>_>

+                   *)(this + 0xe8),pMVar16);

+            if (*(longlong *)(this + 0xe8) == 0) {

+              WdLogSingleEntry1(2,0xffffffffc0000017);

+              _WdLogGlobalForLineNumber = 0x314;

+            }

+            else {

+              this_03 = operator_new(0xd0,0x4d677844,0x40);

+              pMVar17 = (MonitorGammaState *)pMVar20;

+              if (this_03 != (MonitorGammaState *)0x0) {

+                pMVar17 = (MonitorGammaState *)

+                          DxgMonitor::MonitorGammaState::MonitorGammaState

+                                    (this_03,pIVar1,(IMonitorDxgiGammaSource *)(this + 0x20));

+              }

+              wistd::

+              unique_ptr<DxgMonitor::MonitorGammaState,wistd::default_delete<DxgMonitor::MonitorGammaState>_>

+              ::reset((unique_ptr<DxgMonitor::MonitorGammaState,wistd::default_delete<DxgMonitor::MonitorGammaState>_>

+                       *)(this + 0xf8),pMVar17);

+              if (*(longlong *)(this + 0xf8) == 0) {

+                WdLogSingleEntry1(2,0xffffffffc0000017);

+                _WdLogGlobalForLineNumber = 0x317;

+              }

+              else {

+                this_04 = operator_new(0x60,0x4d677844,0x40);

+                pMVar18 = (MonitorUsb4State *)pMVar20;

+                if (this_04 != (MonitorUsb4State *)0x0) {

+                  pMVar18 = (MonitorUsb4State *)

+                            DxgMonitor::MonitorUsb4State::MonitorUsb4State

+                                      (this_04,pIVar1,param_7,pPVar4,param_6);

+                }

+                wistd::

+                unique_ptr<DxgMonitor::MonitorUsb4State,wistd::default_delete<DxgMonitor::MonitorUsb4State>_>

+                ::reset((unique_ptr<DxgMonitor::MonitorUsb4State,wistd::default_delete<DxgMonitor::MonitorUsb4State>_>

+                         *)(this + 0x108),pMVar18);

+                if (*(longlong *)(this + 0x108) == 0) {

+                  WdLogSingleEntry1(2,0xffffffffc0000017);

+                  _WdLogGlobalForLineNumber = 0x31a;

+                }

+                else {

+                  this_05 = operator_new(0x28,0x4d677844,0x100);

+                  pMVar14 = (MonitorDescriptorState *)pMVar20;

+                  if (this_05 != (MonitorDisplayPortState *)0x0) {

+                    pMVar14 = (MonitorDescriptorState *)

+                              DxgMonitor::MonitorDisplayPortState::MonitorDisplayPortState

+                                        (this_05,pIVar1);

+                  }

+                  pvVar5 = *(void **)(this + 0x110);

+                  *(MonitorDescriptorState **)(this + 0x110) = pMVar14;

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

+                    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pvVar5);

+                  }

+                  if (*(longlong *)(this + 0x110) != 0) {

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

+                      pMVar19 = operator_new(0x50,0x4d677844,0x40);

+                      if (pMVar19 != (MonitorMipiDsiState *)0x0) {

+                        *(IMonitorComponentParent **)pMVar19 = pIVar1;

+                        *(undefined8 *)(pMVar19 + 8) = 0;

+                        *(undefined8 *)(pMVar19 + 0x10) = 0;

+                        *(undefined4 *)(pMVar19 + 0x18) = 0;

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

+                        *(undefined4 *)(pMVar19 + 0x44) = 0xffffffff;

+                        *(undefined8 *)(pMVar19 + 0x30) = 0;

+                        *(undefined8 *)(pMVar19 + 0x38) = 0;

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

+                        *(undefined4 *)(pMVar19 + 0x48) = 0x11;

+                        pMVar20 = pMVar19;

+                      }

+                      wistd::

+                      unique_ptr<DxgMonitor::MonitorMipiDsiState,wistd::default_delete<DxgMonitor::MonitorMipiDsiState>_>

+                      ::reset((unique_ptr<DxgMonitor::MonitorMipiDsiState,wistd::default_delete<DxgMonitor::MonitorMipiDsiState>_>

+                               *)(this + 0x100),pMVar20);

+                      if (*(longlong *)(this + 0x100) == 0) {

+                        WdLogSingleEntry1(2,0xffffffffc0000017);

+                        _WdLogGlobalForLineNumber = 0x322;

+                        return -0x3fffffe9;

+                      }

+                    }

+                    _param_4 = 0xfffffffe;

+                    lVar9 = DmmGetVideoOutputTechnology

+                                      (*(void **)(*(longlong *)(*(longlong *)(this + 0xa8) + 0x18) +

+                                                 0x10),param_2,

+                                       (_D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY *)&param_4,

+                                       (_D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY *)0x0);

+                    if (lVar9 < 0) {

+                      WdLogSingleEntry0(1);

+                      _WdLogGlobalForLineNumber = 0x32e;

+                    }

+                    _Var6 = _param_4;

+                    if (_param_4 == 0xfffffffe) {

+                      WdLogSingleEntry0(1);

+                      _WdLogGlobalForLineNumber = 0x32f;

+                    }

+                    *(_D3DKMDT_VIDEO_OUTPUT_TECHNOLOGY *)(this + 0xb8) = _Var6;

+                    return 0;

+                  }

+                  WdLogSingleEntry1(2,0xffffffffc0000017);

+                  _WdLogGlobalForLineNumber = 0x31d;

+                }

+              }

+            }

+          }

+        }

+      }

+    }

+  }

+  return -0x3fffffe9;

+}

+
```

## `BLTQUEUE_REMOTE_VSYNC_SOURCE::StopVSync`  (modified)

```diff
--- BLTQUEUE_REMOTE_VSYNC_SOURCE::StopVSync
+++ CheckFeatureOSSupport
@@ -1,2 +1,12 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB BLTQUEUE_REMOTE_VSYNC_SOURCE::StopVSync : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+

+undefined8 CheckFeatureOSSupport(void)

+

+{

+  WdLogSingleEntry0();

+  _WdLogGlobalForLineNumber = 0x727;

+  DxgkLogInternalTriageEvent(0,0x40000,0xffffffff,L"Iommu interface does not support Pasid",0x727);

+  return 0xc00000bb;

+}

+
```

## `DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer`  (modified)

```diff
--- DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer
+++ DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer
@@ -1,2 +1,47 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: void __cdecl DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer(void) __ptr64 */

+

+void __thiscall DMMVIDEOPRESENTTARGET::CancelLinkTrainingTimer(DMMVIDEOPRESENTTARGET *this)

+

+{

+  char cVar1;

+  int iVar2;

+  longlong lVar3;

+  bool bVar4;

+  

+  if ((*(int *)(*(longlong *)(this + 0x218) + 0x98) == 1) ||

+     (*(int *)(*(longlong *)(this + 0x218) + 0x98) == 3)) {

+    iVar2 = Feature_ConditionalDpcFlush__private_IsEnabledDeviceUsageNoInline();

+    if (iVar2 == 0) {

+      KeCancelTimer(*(longlong *)(this + 0x218) + 0x10);

+    }

+    else {

+      cVar1 = KeCancelTimer();

+      if (cVar1 != '\0') goto LAB_0;

+    }

+    KeFlushQueuedDpcs();

+  }

+LAB_0:

+  LOCK();

+  iVar2 = *(int *)(*(longlong *)(this + 0x218) + 0x98);

+  *(int *)(*(longlong *)(this + 0x218) + 0x98) = 5;

+  UNLOCK();

+  if ((iVar2 - 2U & 0xfffffffd) != 0) {

+    LOCK();

+    iVar2 = *(int *)(*(longlong *)(this + 0x218) + 0x98);

+    bVar4 = iVar2 == 5;

+    if (bVar4) {

+      *(int *)(*(longlong *)(this + 0x218) + 0x98) = 0;

+      iVar2 = 5;

+    }

+    UNLOCK();

+    if (!bVar4) {

+      lVar3 = WdLogNewEntry5_WdTrace();

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

+      _WdLogGlobalForLineNumber = 0x216;

+    }

+  }

+  return;

+}

+
```

## `DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled`  (modified)

```diff
--- DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled
+++ DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled
@@ -1,2 +1,214 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

+/* public: void __cdecl DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled(bool) __ptr64 */

+

+void __thiscall

+DISPLAY_MUX_SWTICH_DDI_TRACKING::SwitchCanceled(DISPLAY_MUX_SWTICH_DDI_TRACKING *this,bool param_1)

+

+{

+  DISPLAY_MUX_SWTICH_DDI_TRACKING *pDVar1;

+  _DISPLAYCONFIG_DISPLAYMUX_TARGET *p_Var2;

+  bool bVar3;

+  long lVar4;

+  int iVar5;

+  uint uVar6;

+  LocksToAcquire LVar7;

+  undefined1 auStackY_198 [32];

+  bool local_148;

+  DISPLAY_MUX_SWTICH_DDI_TRACKING local_147;

+  undefined1 local_146 [6];

+  undefined1 local_140 [8];

+  _FDO_CONTEXT *local_138;

+  undefined1 local_130;

+  _FDO_CONTEXT *local_128;

+  undefined1 local_120;

+  CDisplayScenarioContextScope local_118 [8];

+  undefined8 local_110;

+  undefined1 *local_108;

+  undefined1 *local_100;

+  undefined4 *local_f8;

+  DISPLAY_MUX_SWTICH_DDI_TRACKING *local_f0;

+  bool *local_e8;

+  undefined1 local_e0;

+  undefined8 local_d8 [4];

+  int local_b8;

+  undefined8 local_a8 [4];

+  int local_88;

+  undefined4 local_78;

+  undefined4 local_74;

+  undefined8 local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined4 local_50;

+  DISPLAY_MUX_SWITCH_PROGRESS local_48;

+  undefined4 local_44;

+  uint local_40;

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStackY_198;

+  local_148 = false;

+  local_146[0] = 0;

+  local_147 = (DISPLAY_MUX_SWTICH_DDI_TRACKING)0x0;

+  local_140[0] = param_1;

+  memset(&local_78,0,0x40);

+  pDVar1 = this + 4;

+  local_48 = *(DISPLAY_MUX_SWITCH_PROGRESS *)pDVar1;

+  local_40 = local_40 & 0xfffffffe | (uint)param_1;

+  local_44 = *(undefined4 *)this;

+  if (param_1) {

+    local_40 = local_40 | 0x20;

+    local_78 = 0x37;

+    local_74 = 0x40;

+    local_50 = 0;

+    local_58 = 0;

+    local_70 = 0;

+    local_68 = 0;

+    uStack_60 = 0;

+    DxgkWriteDiagEntry(&local_78);

+  }

+  local_108 = local_140;

+  local_e0 = 1;

+  local_100 = local_146;

+  local_f8 = &local_78;

+  local_f0 = &local_147;

+  local_e8 = &local_148;

+  if ((*(DISPLAY_MUX_SWITCH_PROGRESS *)pDVar1 == 2) || (*(int *)this == 2)) {

+    LVar7 = *(LocksToAcquire *)(this + 0x1c);

+    local_146[0] = 1;

+    lVar4 = DISPLAY_MUX_MGR::IsTargetPartOfMux(DAT_0);

+    if (lVar4 < 0) {

+      local_147 = this[0x20];

+      LVar7 = (LocksToAcquire)(byte)local_147;

+      WdLogSingleEntry2(2);

+      _WdLogGlobalForLineNumber = 0x118;

+    }

+    iVar5 = Feature_DisplayMux_PostGA_BugBundle_4__private_IsEnabledDeviceUsageNoInline();

+    if (iVar5 == 0) {

+      if (*(int *)this == 2) {

+        p_Var2 = (_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 8);

+        local_138 = (_FDO_CONTEXT *)0x0;

+        local_130 = 0;

+        lVar4 = AUTO_REMOVE_LOCK::FindAdapterAndAcquire

+                          ((AUTO_REMOVE_LOCK *)&local_138,(_LUID *)p_Var2);

+        if (lVar4 < 0) {

+          LVar7 = *(LocksToAcquire *)p_Var2;

+          WdLogSingleEntry3(2);

+          _WdLogGlobalForLineNumber = 0x152;

+        }

+        else {

+          CInterfaceCallContext::CInterfaceCallContext

+                    ((CInterfaceCallContext *)local_d8,local_138,LVar7);

+          if (local_b8 < 0) {

+            LVar7 = *(LocksToAcquire *)p_Var2;

+            WdLogSingleEntry3(2);

+            _WdLogGlobalForLineNumber = 0x14d;

+          }

+          else {

+            local_40 = local_40 | 8;

+            iVar5 = DpiDxgkDdiDisplayMuxSwitchCanceled

+                              (local_138,*(undefined4 *)(this + 0x10),

+                               local_147 == (DISPLAY_MUX_SWTICH_DDI_TRACKING)0x0);

+            if (iVar5 < 0) {

+              WdLogSingleEntry1(2,(longlong)iVar5);

+              _WdLogGlobalForLineNumber = 0x13f;

+            }

+            DISPLAY_MUX_MGR::SetAdapterAllowedToReportDisplayMuxHpd(DAT_0,p_Var2);

+            LVar7 = (LocksToAcquire)(this + 0x24);

+            lVar4 = QueryConnectionChanges(local_d8[0]);

+            if (lVar4 < 0) {

+              WdLogSingleEntry1(2);

+              _WdLogGlobalForLineNumber = 0x147;

+            }

+            DISPLAY_MUX_MGR::SetAdapterAllowedToReportDisplayMuxHpd

+                      (DAT_0,(_DISPLAYCONFIG_DISPLAYMUX_TARGET *)0x0);

+          }

+          CInterfaceCallContext::~CInterfaceCallContext((CInterfaceCallContext *)local_d8);

+        }

+        local_148 = true;

+        *(undefined4 *)this = 3;

+        AUTO_REMOVE_LOCK::Release((AUTO_REMOVE_LOCK *)&local_138);

+      }

+      if (*(int *)(this + 4) == 2) {

+        local_128 = (_FDO_CONTEXT *)0x0;

+        local_120 = 0;

+        lVar4 = AUTO_REMOVE_LOCK::FindAdapterAndAcquire

+                          ((AUTO_REMOVE_LOCK *)&local_128,(_LUID *)(this + 0x14));

+        if (lVar4 < 0) {

+          WdLogSingleEntry3(2,(longlong)*(int *)(this + 0x18),*(undefined4 *)(this + 0x14));

+          _WdLogGlobalForLineNumber = 0x17f;

+        }

+        else {

+          CInterfaceCallContext::CInterfaceCallContext

+                    ((CInterfaceCallContext *)local_a8,local_128,LVar7);

+          if (local_88 < 0) {

+            WdLogSingleEntry3(2,(longlong)*(int *)(this + 0xc),*(undefined4 *)(this + 8));

+            _WdLogGlobalForLineNumber = 0x17a;

+          }

+          else {

+            local_40 = local_40 | 0x10;

+            iVar5 = DpiDxgkDdiDisplayMuxSwitchCanceled

+                              (local_128,*(undefined4 *)(this + 0x1c),local_147);

+            if (iVar5 < 0) {

+              WdLogSingleEntry1(2,(longlong)iVar5);

+              _WdLogGlobalForLineNumber = 0x16c;

+            }

+            DISPLAY_MUX_MGR::SetAdapterAllowedToReportDisplayMuxHpd

+                      (DAT_0,(_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 0x14));

+            lVar4 = QueryConnectionChanges(local_a8[0],*(undefined8 *)(this + 0x14),this + 0x24);

+            if (lVar4 < 0) {

+              WdLogSingleEntry1(2);

+              _WdLogGlobalForLineNumber = 0x174;

+            }

+            DISPLAY_MUX_MGR::SetAdapterAllowedToReportDisplayMuxHpd

+                      (DAT_0,(_DISPLAYCONFIG_DISPLAYMUX_TARGET *)0x0);

+          }

+          CInterfaceCallContext::~CInterfaceCallContext((CInterfaceCallContext *)local_a8);

+        }

+        local_148 = true;

+        *(undefined4 *)(this + 4) = 3;

+        AUTO_REMOVE_LOCK::Release((AUTO_REMOVE_LOCK *)&local_128);

+      }

+    }

+    else {

+      if (local_147 == (DISPLAY_MUX_SWTICH_DDI_TRACKING)0x0) {

+        bVar3 = CallDriverCancelDdi(this,false,(DISPLAY_MUX_SWITCH_PROGRESS *)pDVar1,

+                                    (_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 0x14),&local_148);

+        local_40 = local_40 & 0xffffffef | (uint)bVar3 << 4;

+        bVar3 = CallDriverCancelDdi(this,true,(DISPLAY_MUX_SWITCH_PROGRESS *)this,

+                                    (_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 8),&local_148);

+        uVar6 = (uint)bVar3 << 3;

+        local_40 = local_40 & 0xfffffff7;

+      }

+      else {

+        bVar3 = CallDriverCancelDdi(this,false,(DISPLAY_MUX_SWITCH_PROGRESS *)this,

+                                    (_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 8),&local_148);

+        local_40 = local_40 & 0xfffffff7 | (uint)bVar3 << 3;

+        bVar3 = CallDriverCancelDdi(this,true,(DISPLAY_MUX_SWITCH_PROGRESS *)pDVar1,

+                                    (_DISPLAYCONFIG_DISPLAYMUX_TARGET *)(this + 0x14),&local_148);

+        uVar6 = (uint)bVar3 << 4;

+        local_40 = local_40 & 0xffffffef;

+      }

+      local_40 = local_40 | uVar6;

+    }

+    if (local_148 != false) {

+      local_118[0] = (CDisplayScenarioContextScope)0x0;

+      CDisplayScenarioContextScope::ContextScopeConstructor(local_118,(_GUID *)0x0,0x4d,0);

+      iVar5 = DxgkRequestAsyncDisplaySwitchCallout(0,local_110,0x200000000);

+      if (iVar5 < 0) {

+        WdLogSingleEntry1(2,(longlong)iVar5);

+        _WdLogGlobalForLineNumber = 0x192;

+        DxgkLogInternalTriageEvent

+                  (0,0x40000,0xffffffff,

+                   L"Failed DxgkRequestAsyncDisplaySwitchCallout for DisplayMux switch failure (Status = 0x%I64x)."

+                  );

+      }

+      CDisplayScenarioContextScope::~CDisplayScenarioContextScope(local_118);

+    }

+  }

+  `UNKNOWN___cdecl_DXGKCALLONEXIT<<lambda_4ec9c3387e80d874534c4ef64e32e476>_>(<lambda_4ec9c3387e80d874534c4ef64e32e476>)'

+  ::__l2::DXGKCALLONEXIT::~DXGKCALLONEXIT((DXGKCALLONEXIT *)&local_108);

+  return;

+}

+
```

## `DXGADAPTER_REFERENCE::Assign`  (modified)

```diff
--- DXGADAPTER_REFERENCE::Assign
+++ DXGADAPTER::ReleaseReference
@@ -1,19 +1,2 @@
-

-/* public: void __cdecl DXGADAPTER_REFERENCE::Assign(class DXGADAPTER * __ptr64) __ptr64 */

-

-void __thiscall DXGADAPTER_REFERENCE::Assign(DXGADAPTER_REFERENCE *this,DXGADAPTER *param_1)

-

-{

-  if (*(DXGADAPTER **)this != (DXGADAPTER *)0x0) {

-    DXGADAPTER::ReleaseReference(*(DXGADAPTER **)this,*(__uint64 *)(this + 8));

-  }

-  *(DXGADAPTER **)this = param_1;

-  if (param_1 != (DXGADAPTER *)0x0) {

-    LOCK();

-    *(longlong *)(param_1 + 0x18) = *(longlong *)(param_1 + 0x18) + 1;

-    UNLOCK();

-    *(undefined8 *)(this + 8) = 0xffffffffffffffff;

-  }

-  return;

-}

-

+Failed to decompile dxgkrnl.sys - .ProgramDB DXGADAPTER::ReleaseReference : Error: Decompile error: 
+Marshaling error: Did not see expected closing element
```

## `DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch`  (modified)

```diff
--- DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch
+++ DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch
@@ -1,2 +1,114 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: void __cdecl DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch(struct

+   _D3DKMT_DISPLAYMUX_SWITCH_STATUS * __ptr64) __ptr64 */

+

+void __thiscall

+DISPLAY_MUX_SWITCH_OPERATION::FinishSwitch

+          (DISPLAY_MUX_SWITCH_OPERATION *this,_D3DKMT_DISPLAYMUX_SWITCH_STATUS *param_1)

+

+{

+  _DISPLAYMUX_SWITCH_CONTEXT *p_Var1;

+  bool bVar2;

+  long lVar3;

+  int iVar4;

+  LocksToAcquire LVar5;

+  _DISPLAYMUX_SWITCH_CONTEXT *p_Var6;

+  _D3DKMT_DISPLAYMUX_SWITCH_STATUS *local_res10;

+  undefined1 auStackY_108 [32];

+  char *in_stack_ffffffffffffff18;

+  char local_d8 [8];

+  _FDO_CONTEXT *local_d0;

+  undefined1 local_c8;

+  _FDO_CONTEXT *local_c0;

+  undefined1 local_b8;

+  DISPLAY_MUX_SWITCH_OPERATION *local_b0;

+  _D3DKMT_DISPLAYMUX_SWITCH_STATUS **local_a8;

+  undefined1 local_a0;

+  CInterfaceCallContext local_98 [8];

+  undefined8 local_90;

+  long local_78;

+  undefined4 local_68;

+  undefined4 local_64;

+  undefined8 local_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 local_40;

+  undefined8 local_38;

+  undefined8 local_30;

+  ulonglong local_28;

+  

+  local_28 = __security_cookie ^ (ulonglong)auStackY_108;

+  local_a8 = &local_res10;

+  local_a0 = 1;

+  local_d0 = (_FDO_CONTEXT *)0x0;

+  local_c8 = 0;

+  local_res10 = param_1;

+  local_b0 = this;

+  lVar3 = AUTO_REMOVE_LOCK::FindAdapterAndAcquire

+                    ((AUTO_REMOVE_LOCK *)&local_d0,(_LUID *)(this + 0x44));

+  p_Var1 = (_DISPLAYMUX_SWITCH_CONTEXT *)(this + 0x5c);

+  bVar2 = CheckFailed(lVar3,0x503,p_Var1,0x4b2,in_stack_ffffffffffffff18);

+  if (!bVar2) {

+    local_c0 = (_FDO_CONTEXT *)0x0;

+    local_b8 = 0;

+    lVar3 = AUTO_REMOVE_LOCK::FindAdapterAndAcquire

+                      ((AUTO_REMOVE_LOCK *)&local_c0,(_LUID *)(this + 0x50));

+    p_Var6 = p_Var1;

+    bVar2 = CheckFailed(lVar3,0x501,p_Var1,0x4ba,in_stack_ffffffffffffff18);

+    if (!bVar2) {

+      CInterfaceCallContext::CInterfaceCallContext(local_98,local_c0,(LocksToAcquire)p_Var6);

+      bVar2 = CheckFailed(local_78,0x505,p_Var1,0x4c2,in_stack_ffffffffffffff18);

+      if (!bVar2) {

+        bVar2 = CheckForMdmFaultOrDelayInjection(0x10,0x502,p_Var1);

+        if (!bVar2) {

+          local_d8[0] = '\0';

+          iVar4 = DpiDxgkDdiDisplayMuxPostSwitchToPhase2

+                            (local_90,*(undefined4 *)(this + 0x58),local_d8);

+          if (-1 < iVar4) {

+            *(undefined4 *)(this + 4) = 3;

+          }

+          p_Var6 = p_Var1;

+          bVar2 = CheckFailed(iVar4,0x502,p_Var1,0x4d0,in_stack_ffffffffffffff18);

+          LVar5 = (LocksToAcquire)p_Var6;

+          if (!bVar2) {

+            if (local_d8[0] == '\0') {

+              *(uint *)(this + 0x130) = *(uint *)(this + 0x130) | 4;

+              local_40 = 0;

+              local_68 = 6;

+              local_60 = 0;

+              local_58 = 0;

+              uStack_50 = 0;

+              local_64 = 0x40;

+              local_48 = 0;

+              local_38 = 0x89;

+              local_30 = 0;

+              DxgkWriteDiagEntry(&local_68);

+            }

+            CInterfaceCallContext::~CInterfaceCallContext(local_98);

+            CInterfaceCallContext::CInterfaceCallContext(local_98,local_d0,LVar5);

+            bVar2 = CheckFailed(local_78,0x506,p_Var1,0x4e5,in_stack_ffffffffffffff18);

+            if (!bVar2) {

+              bVar2 = CheckForMdmFaultOrDelayInjection(0x11,0x504,p_Var1);

+              if (!bVar2) {

+                iVar4 = DpiDxgkDdiDisplayMuxPostSwitchAway(local_90,*(undefined4 *)(this + 0x4c));

+                if (-1 < iVar4) {

+                  *(undefined4 *)this = 3;

+                }

+                CheckFailed(iVar4,0x504,p_Var1,0x4f2,in_stack_ffffffffffffff18);

+              }

+            }

+          }

+        }

+      }

+      CInterfaceCallContext::~CInterfaceCallContext(local_98);

+    }

+    AUTO_REMOVE_LOCK::Release((AUTO_REMOVE_LOCK *)&local_c0);

+  }

+  AUTO_REMOVE_LOCK::Release((AUTO_REMOVE_LOCK *)&local_d0);

+  `DXGKCALLONEXIT<<lambda_3df126e43ef527cc1a2970c1b44a89a0>_>'::__l2::DXGKCALLONEXIT::

+  ~DXGKCALLONEXIT(&local_b0);

+  return;

+}

+
```

## `DXGMONITOR::_DispatchInternalIOCtrl`  (modified)

```diff
--- DXGMONITOR::_DispatchInternalIOCtrl
+++ DXGMONITOR::_DispatchInternalIOCtrl
@@ -1,2 +1,116 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGMONITOR::_DispatchInternalIOCtrl : 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 DXGMONITOR::_DispatchInternalIOCtrl(unsigned long,unsigned long,void *

+   __ptr64,unsigned long,void * __ptr64,unsigned __int64 * __ptr64,unsigned long) __ptr64 */

+

+long __thiscall

+DXGMONITOR::_DispatchInternalIOCtrl

+          (DXGMONITOR *this,ulong param_1,ulong param_2,void *param_3,ulong param_4,void *param_5,

+          __uint64 *param_6,ulong param_7)

+

+{

+  __uint64 *p_Var1;

+  long lVar2;

+  int iVar3;

+  longlong lVar4;

+  _LUID *p_Var5;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  

+  p_Var1 = param_6;

+  *param_6 = 0;

+  lVar4 = WdLogNewEntry5_WdTrace();

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

+  *(DXGMONITOR **)(lVar4 + 0x20) = this;

+  _WdLogGlobalForLineNumber = 0x856;

+  if (param_1 < 0x232424) {

+    if ((((param_1 != 0x232423) && (param_1 != 0x232403)) && (param_1 != 0x23240f)) &&

+       (((param_1 != 0x232413 && (param_1 != 0x232417)) &&

+        ((param_1 != 0x23241b && (param_1 != 0x23241f)))))) {

+      _WdLogGlobalForLineNumber = 0x856;

+      return -0x3fffff45;

+    }

+  }

+  else if ((param_1 != 0x232427) && (param_1 != 0x23242b)) {

+    if (param_1 == 0x2324d3) {

+      if (param_2 < 0x20) {

+        _WdLogGlobalForLineNumber = 0x856;

+        return -0x3fffffdd;

+      }

+      if (*(int *)param_3 != 3) {

+        WdLogSingleEntry0(1);

+        _WdLogGlobalForLineNumber = 0x873;

+      }

+      DxgMonitor::MonitorColorState::OnBrightnessNitsUpdated

+                (*(MonitorColorState **)(this + 0xe0),*(uint *)((longlong)param_3 + 4),param_7);

+    }

+    else if (param_1 == 0x2324e3) {

+      iVar3 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+      if (iVar3 == 0) {

+        return -0x3fffff45;

+      }

+      if (param_4 < 0x14) {

+        return -0x3fffffdd;

+      }

+      lVar4 = *(longlong *)(this + 0xe0);

+      *p_Var1 = 0x14;

+      *(bool *)param_5 = *(int *)(lVar4 + 0x218) == 1;

+    }

+    else if (param_1 == 0x2324e7) {

+      iVar3 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+      if (iVar3 == 0) {

+        return -0x3fffff45;

+      }

+      if (param_2 < 0x18) {

+        return -0x3fffffdd;

+      }

+      p_Var5 = (_LUID *)((ulonglong)*(uint *)param_3 / 0x50);

+      if (5000 < (ulong)p_Var5 - 1000) {

+        return -0x3ffffff3;

+      }

+      lVar2 = DxgMonitor::MonitorColorState::SetSDRWhiteLevel

+                        (*(MonitorColorState **)(this + 0xe0),(ulong)p_Var5,

+                         *(ulong *)((longlong)param_3 + 4));

+      if (lVar2 < 0) {

+        WdLogSingleEntry0(2);

+        _WdLogGlobalForLineNumber = 0x8b4;

+      }

+      else if (lVar2 == 0) {

+        TriggerSDRWhiteLevelChangedWnf();

+        param_6 = (__uint64 *)0x0;

+        uStack_30 = 0;

+        local_38 = 0xd;

+        local_28 = 0;

+        uStack_20 = 0;

+        DXGADAPTER::IsAdapterSessionized

+                  (*(DXGADAPTER **)(*(longlong *)(*(longlong *)(this + 0xa8) + 0x18) + 0x10),p_Var5,

+                   (uint *)0x0,(__uint64 *)&param_6);

+        SMgrGdiCallout(&local_38,param_6);

+      }

+    }

+    else {

+      if (param_1 != 0x232503) {

+        _WdLogGlobalForLineNumber = 0x856;

+        return -0x3fffff45;

+      }

+      iVar3 = Feature_HdrBrightnessPolicy__private_IsEnabledDeviceUsageNoInline();

+      if (iVar3 == 0) {

+        return -0x3fffff45;

+      }

+      if (param_4 < 0x18) {

+        return -0x3fffffdd;

+      }

+      lVar4 = *(longlong *)(this + 0xe0);

+      *p_Var1 = 0x18;

+      *(int *)param_5 = *(int *)(lVar4 + 0x1dc) * 0x50;

+    }

+    return 0;

+  }

+  lVar2 = DxgMonitor::MonitorDescriptorState::OnInternalIoctl

+                    (*(MonitorDescriptorState **)(this + 0xd8),param_1,param_2,param_3,param_4,

+                     param_5,p_Var1);

+  return lVar2;

+}

+
```

## `CFlipExBuffer::NotifyTokenInFrame`  (modified)

```diff
--- CFlipExBuffer::NotifyTokenInFrame
+++ CFlipExBuffer::NotifyTokenInFrame
@@ -1,2 +1,78 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipExBuffer::NotifyTokenInFrame : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: virtual long __cdecl CFlipExBuffer::NotifyTokenInFrame(class CToken const & __ptr64,bool

+   * __ptr64,unsigned __int64) __ptr64 */

+

+long __thiscall

+CFlipExBuffer::NotifyTokenInFrame

+          (CFlipExBuffer *this,CToken *param_1,bool *param_2,__uint64 param_3)

+

+{

+  uint uVar1;

+  bool bVar2;

+  char cVar3;

+  bool bVar4;

+  int iVar5;

+  undefined4 uVar6;

+  CFlipToken *pCVar7;

+  CBufferRealization *pCVar8;

+  

+  *param_2 = false;

+  pCVar7 = CFlipToken::FromToken(param_1);

+  iVar5 = Feature_LastChanceSurfaceUpdateFullDirty__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar5 == 0) || (this[0x282] == (CFlipExBuffer)0x0)) {

+    bVar2 = false;

+  }

+  else {

+    bVar2 = true;

+  }

+  iVar5 = 0;

+  if (pCVar7 == (CFlipToken *)0x0) {

+    iVar5 = -0x3ffffff3;

+  }

+  if (-1 < iVar5) {

+    uVar1 = *(uint *)(pCVar7 + 0x78);

+    if (uVar1 < *(uint *)(this + 0x120)) {

+      uVar6 = (**(code **)(*(longlong *)pCVar7 + 0x70))(pCVar7);

+      *(undefined4 *)(this + 0x124) = uVar6;

+      if (*(uint *)(this + 0x18c) != uVar1) {

+        *(uint *)(this + 0x18c) = uVar1;

+        *param_2 = true;

+        cVar3 = (**(code **)(*(longlong *)param_1 + 0x90))(param_1);

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

+          this[0x282] = (CFlipExBuffer)0x0;

+        }

+      }

+      bVar4 = UpdateAttributes(this,pCVar7);

+      if (bVar4) {

+        *param_2 = true;

+      }

+      bVar4 = UpdateIndependentFlipState(this,pCVar7);

+      if (bVar4) {

+        *param_2 = true;

+      }

+      pCVar8 = CCompositionBuffer::GetRealizationAt((CCompositionBuffer *)this,uVar1);

+      if (*(int *)(pCVar7 + 0x23c) != *(int *)(pCVar8 + 0x50)) {

+        *(int *)(pCVar8 + 0x50) = *(int *)(pCVar7 + 0x23c);

+        *param_2 = true;

+      }

+      if ((param_3 != 0) && (*(uint *)(this + 0x108) < *(uint *)(this + 0x124))) {

+        *(__uint64 *)(this + 0x100) = param_3;

+        *(uint *)(this + 0x108) = *(uint *)(this + 0x124);

+      }

+      if (bVar2) {

+        CCompositionBuffer::NotifyFullDirty((CCompositionBuffer *)this);

+      }

+      else {

+        CCompositionBuffer::NotifyDirty

+                  ((CCompositionBuffer *)this,*(IRegion **)(pCVar7 + 0x60),

+                   (ScrollOptimization *)(pCVar7 + 0x44));

+      }

+    }

+    else {

+      iVar5 = -0x3ffffff3;

+    }

+  }

+  return iVar5;

+}

+
```

## `CTokenManager::AddDisableScanoutToken`  (modified)

```diff
--- CTokenManager::AddDisableScanoutToken
+++ CTokenManager::AddDisableScanoutToken
@@ -1,2 +1,50 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CTokenManager::AddDisableScanoutToken : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

+/* public: virtual long __cdecl CTokenManager::AddDisableScanoutToken(class CDisableScanoutToken *

+   __ptr64 & __ptr64) __ptr64 */

+

+long __thiscall

+CTokenManager::AddDisableScanoutToken(CTokenManager *this,CDisableScanoutToken **param_1)

+

+{

+  CDisableScanoutToken *pCVar1;

+  int iVar2;

+  long lVar3;

+  longlong lVar4;

+  bool bVar5;

+  undefined4 local_res8 [2];

+  

+  bVar5 = SystemReserved1[0xf] != *(void **)(this + 0x68);

+  if (bVar5) {

+    AcquireTokenManagerLock(this);

+  }

+  iVar2 = Feature_1956364603__private_IsEnabledDeviceUsageNoInline();

+  if (iVar2 == 0) {

+    lVar3 = AddTokenToQueue(this,(CToken *)*param_1);

+    if ((lVar3 < 0) && (pCVar1 = *param_1, pCVar1 != (CDisableScanoutToken *)0x0)) {

+      (*(code *)**(undefined8 **)pCVar1)(pCVar1,1);

+    }

+    lVar4 = DxgkGetWin32kImportTable();

+    (**(code **)(lVar4 + 0x170))

+              (*(undefined8 *)(*(longlong *)(*param_1 + 0x30) + 0x18),

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

+  }

+  else {

+    lVar4 = DxgkGetWin32kImportTable();

+    (**(code **)(lVar4 + 0x170))

+              (*(undefined8 *)(*(longlong *)(*param_1 + 0x30) + 0x18),

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

+    lVar3 = AddTokenToQueue(this,(CToken *)*param_1);

+    if ((lVar3 < 0) && (pCVar1 = *param_1, pCVar1 != (CDisableScanoutToken *)0x0)) {

+      (*(code *)**(undefined8 **)pCVar1)(pCVar1,1);

+    }

+  }

+  *param_1 = (CDisableScanoutToken *)0x0;

+  local_res8[0] = 0;

+  ZwSetEvent(*(undefined8 *)(this + 0x48),local_res8);

+  if (bVar5) {

+    ReleaseTokenManagerLock(this);

+  }

+  return lVar3;

+}

+
```

## `DXGMONITOR::_CopyMonitorInformation`  (modified)

```diff
--- DXGMONITOR::_CopyMonitorInformation
+++ DXGMONITOR::_CopyMonitorInformation
@@ -1,2 +1,81 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB DXGMONITOR::_CopyMonitorInformation : 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 DXGMONITOR::_CopyMonitorInformation(class MONITOR_REF_ACCESSOR const &

+   __ptr64) __ptr64 */

+

+long __thiscall DXGMONITOR::_CopyMonitorInformation(DXGMONITOR *this,MONITOR_REF_ACCESSOR *param_1)

+

+{

+  IMonitorRegistry *pIVar1;

+  undefined8 uVar2;

+  MonitorModes *pMVar3;

+  MonitorColorState *pMVar4;

+  MonitorDescriptorState *pMVar5;

+  undefined8 *puVar6;

+  MonitorModes *local_res8;

+  IMonitorComponentParent local_res10 [8];

+  IMonitorComponentParent local_res18 [8];

+  

+  if (*(longlong *)(param_1 + 8) == 0) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x41e;

+  }

+  if (*(int *)(this + 0x118) == 1) {

+    WdLogSingleEntry0(1);

+    _WdLogGlobalForLineNumber = 0x41f;

+  }

+  pIVar1 = (IMonitorRegistry *)(this + 0x10);

+  puVar6 = (undefined8 *)

+           DxgMonitor::MonitorModes::CopyInstance

+                     (*(MonitorModes **)(*(longlong *)(param_1 + 8) + 0xe8),

+                      (IMonitorComponentParent *)&local_res8,pIVar1);

+  uVar2 = *puVar6;

+  *puVar6 = 0;

+  pMVar3 = *(MonitorModes **)(this + 0xe8);

+  *(undefined8 *)(this + 0xe8) = uVar2;

+  if (pMVar3 != (MonitorModes *)0x0) {

+    DxgMonitor::MonitorModes::~MonitorModes(pMVar3);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pMVar3);

+  }

+  pMVar3 = local_res8;

+  local_res8 = (MonitorModes *)0x0;

+  if (pMVar3 != (MonitorModes *)0x0) {

+    DxgMonitor::MonitorModes::~MonitorModes(pMVar3);

+    DXGQUOTAALLOCATOR<256,1348958276>::operator_delete(pMVar3);

+  }

+  if (*(longlong *)(this + 0xe8) != 0) {

+    puVar6 = (undefined8 *)

+             DxgMonitor::MonitorColorState::CopyInstance

+                       (*(MonitorColorState **)(*(longlong *)(param_1 + 8) + 0xe0),local_res10,

+                        pIVar1);

+    pMVar4 = (MonitorColorState *)*puVar6;

+    *puVar6 = 0;

+    wistd::

+    unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+             *)(this + 0xe0),pMVar4);

+    wistd::

+    unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+    ::reset((unique_ptr<DxgMonitor::MonitorColorState,wistd::default_delete<DxgMonitor::MonitorColorState>_>

+             *)local_res10,(MonitorColorState *)0x0);

+    if (*(longlong *)(this + 0xe0) != 0) {

+      puVar6 = (undefined8 *)

+               DxgMonitor::MonitorDescriptorState::CopyInstance

+                         (*(MonitorDescriptorState **)(*(longlong *)(param_1 + 8) + 0xd8),

+                          local_res18,pIVar1);

+      pMVar5 = (MonitorDescriptorState *)*puVar6;

+      *puVar6 = 0;

+      wistd::

+      unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+      ::reset((unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+               *)(this + 0xd8),pMVar5);

+      wistd::

+      unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+      ::reset((unique_ptr<DxgMonitor::MonitorDescriptorState,wistd::default_delete<DxgMonitor::MonitorDescriptorState>_>

+               *)local_res18,(MonitorDescriptorState *)0x0);

+      return ~-(uint)(*(longlong *)(this + 0xd8) != 0) & 0xc0000017;

+    }

+  }

+  return -0x3fffffe9;

+}

+
```

## `BLTQUEUE::PreparePresentIndirect`  (modified)

```diff
--- BLTQUEUE::PreparePresentIndirect
+++ BLTQUEUE::PreparePresentIndirect
@@ -1,2 +1,150 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB BLTQUEUE::PreparePresentIndirect : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

+/* public: long __cdecl BLTQUEUE::PreparePresentIndirect(class DXGCONTEXT * __ptr64,struct

+   _D3DKMT_PRESENT const * __ptr64,struct _DXGKARG_PRESENT const * __ptr64,class COREDEVICEACCESS *

+   __ptr64,class BLTENTRY * __ptr64) __ptr64 */

+

+long __thiscall

+BLTQUEUE::PreparePresentIndirect

+          (BLTQUEUE *this,DXGCONTEXT *param_1,_D3DKMT_PRESENT *param_2,_DXGKARG_PRESENT *param_3,

+          COREDEVICEACCESS *param_4,BLTENTRY *param_5)

+

+{

+  int iVar1;

+  DXGSWAPCHAIN *pDVar2;

+  int *piVar3;

+  longlong lVar4;

+  ADAPTER_DISPLAY *pAVar5;

+  long lVar6;

+  int iVar7;

+  int iVar8;

+  undefined1 auStack_128 [32];

+  undefined8 local_108;

+  undefined8 local_100;

+  undefined8 local_f8;

+  undefined8 local_f0;

+  undefined8 local_e8;

+  undefined8 local_d8;

+  undefined4 local_d0;

+  undefined4 local_cc;

+  undefined4 local_c8;

+  int local_c4;

+  undefined4 *local_c0;

+  undefined8 local_b8;

+  undefined1 local_a8 [12];

+  undefined4 local_9c;

+  int local_98;

+  int local_94;

+  undefined8 local_90;

+  _D3DDDI_HDR_METADATA_TYPE local_78;

+  _D3DDDI_HDR_METADATA_HDR10 local_74 [28];

+  uint local_58 [4];

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_128;

+  if (*(undefined8 **)(this + 0xb10) == (undefined8 *)0x0) {

+    WdLogSingleEntry0(2);

+    local_e8 = 0;

+    local_f0 = 0;

+    local_f8 = 0;

+    local_100 = 0;

+    local_108 = 0x62e;

+    _WdLogGlobalForLineNumber = 0x62e;

+    DxgkLogInternalTriageEvent

+              (0,0x40000,0xffffffff,

+               L"Present to Indirect display does not have a shared swapchain to present to");

+    lVar6 = -0x3fffffff;

+  }

+  else {

+    pDVar2 = (DXGSWAPCHAIN *)**(undefined8 **)(this + 0xb10);

+    if (*(int *)(pDVar2 + 0xe8) == 0) {

+      local_d8 = 0;

+      local_b8 = 0;

+      local_c8 = 0;

+      local_cc = 1;

+      local_d0 = 1;

+      iVar7 = 0;

+      iVar8 = 0;

+      if (((*(uint *)(param_2 + 0x58) & 0x400000) != 0) &&

+         (piVar3 = *(int **)(param_2 + 0x5a0), iVar7 = 0, iVar8 = 0, piVar3 != (int *)0x0)) {

+        iVar7 = piVar3[4];

+        iVar8 = *piVar3;

+        if (iVar7 != 0) {

+          local_c0 = *(undefined4 **)(piVar3 + 6);

+          local_c4 = iVar7 * 0x18;

+          lVar6 = SwapChainGetSetMetaDataInternal

+                            (pDVar2,(_D3DKMT_GETSETSWAPCHAINMETADATA *)&local_d8,iVar8 * 0x10 + 0x54

+                             ,'\0');

+          if (lVar6 < 0) {

+            WdLogSingleEntry1(3);

+            _WdLogGlobalForLineNumber = 0x5d7;

+          }

+        }

+        iVar1 = **(int **)(param_2 + 0x5a0);

+        if (iVar1 != 0) {

+          local_c0 = *(undefined4 **)(*(int **)(param_2 + 0x5a0) + 2);

+          local_c4 = iVar1 << 4;

+          lVar6 = SwapChainGetSetMetaDataInternal

+                            ((DXGSWAPCHAIN *)**(undefined8 **)(this + 0xb10),

+                             (_D3DKMT_GETSETSWAPCHAINMETADATA *)&local_d8,0x54,'\0');

+          if (lVar6 < 0) {

+            WdLogSingleEntry1(3);

+            _WdLogGlobalForLineNumber = 0x5e6;

+          }

+        }

+      }

+      memset(local_a8,0,0x54);

+      local_90 = 0;

+      local_78 = 0;

+      local_9c = *(undefined4 *)(param_2 + 0x50);

+      local_98 = iVar8;

+      local_94 = iVar7;

+      if (((param_1 != (DXGCONTEXT *)0x0) && (*(longlong *)(param_1 + 0x10) != 0)) &&

+         (lVar4 = *(longlong *)(*(longlong *)(param_1 + 0x10) + 0x768), lVar4 != 0)) {

+        lVar6 = PopulateHDRMetadataFromDisplay

+                          (*(uint *)(param_2 + 0x10),*(ADAPTER_DISPLAY **)(lVar4 + 0xc48),local_74,

+                           &local_78);

+        if (lVar6 < 0) {

+          WdLogSingleEntry1(3,(longlong)lVar6);

+          _WdLogGlobalForLineNumber = 0x603;

+        }

+        iVar7 = Feature_DodPresent_Fix_SdrWhiteLevelFallback__private_IsEnabledDeviceUsageNoInline()

+        ;

+        pAVar5 = *(ADAPTER_DISPLAY **)(*(longlong *)(*(longlong *)(param_1 + 0x10) + 0x768) + 0xc48)

+        ;

+        if (iVar7 == 0) {

+          lVar6 = GetSdrWhiteLevel(*(uint *)(param_2 + 0x10),pAVar5,local_58);

+          if (lVar6 < 0) {

+            return lVar6;

+          }

+        }

+        else {

+          lVar6 = GetSdrWhiteLevel(*(uint *)(param_2 + 0x10),pAVar5,local_58);

+          if (lVar6 < 0) {

+            local_58[0] = 0x50;

+          }

+        }

+      }

+      local_c0 = &local_9c;

+      iVar7 = 0;

+      local_c4 = 0x48;

+      lVar6 = SwapChainGetSetMetaDataInternal

+                        ((DXGSWAPCHAIN *)**(undefined8 **)(this + 0xb10),

+                         (_D3DKMT_GETSETSWAPCHAINMETADATA *)&local_d8,0xc,'\0');

+      if (lVar6 < 0) {

+        WdLogSingleEntry1(3,(longlong)lVar6);

+        lVar6 = 0;

+        _WdLogGlobalForLineNumber = 0x622;

+      }

+      if (*(int *)(this + 0xb50) != 0) {

+        lVar6 = CompletePresentIndirectInternal(this,param_5,(_LARGE_INTEGER *)0x0,iVar7);

+      }

+    }

+    else {

+      lVar6 = 0;

+    }

+  }

+  return lVar6;

+}

+
```

## `CFlipContentToken::CFlipContentToken`  (modified)

```diff
--- CFlipContentToken::CFlipContentToken
+++ CFlipContentToken::CFlipContentToken
@@ -1,2 +1,26 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB CFlipContentToken::CFlipContentToken : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: __cdecl CFlipContentToken::CFlipContentToken(unsigned __int64,class

+   CompositionSurfaceObject * __ptr64) __ptr64 */

+

+CFlipContentToken * __thiscall

+CFlipContentToken::CFlipContentToken

+          (CFlipContentToken *this,__uint64 param_1,CompositionSurfaceObject *param_2)

+

+{

+  CToken::CToken((CToken *)this,param_1,param_2);

+  *(undefined ***)this = &_vftable_;

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

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

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

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

+  this[0xe0] = (CFlipContentToken)((byte)this[0xe0] & 0xfe | 2);

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

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

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

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

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

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

+  memset(this + 0x98,0,0x48);

+  return this;

+}

+
```

## `RAPID_HPD_MANAGER::GetCurrenRapidHPDState`  (modified)

```diff
--- RAPID_HPD_MANAGER::GetCurrenRapidHPDState
+++ RAPID_HPD_MANAGER::GetCurrenRapidHPDState
@@ -1,2 +1,129 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB RAPID_HPD_MANAGER::GetCurrenRapidHPDState : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

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

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

+/* public: void __cdecl RAPID_HPD_MANAGER::GetCurrenRapidHPDState(bool,enum _DXGK_RAPID_HPD_TYPE *

+   __ptr64,struct _GUID * __ptr64,struct _DXGK_RAPID_HPD_DIAG * __ptr64) __ptr64 */

+

+void __thiscall

+RAPID_HPD_MANAGER::GetCurrenRapidHPDState

+          (RAPID_HPD_MANAGER *this,bool param_1,_DXGK_RAPID_HPD_TYPE *param_2,_GUID *param_3,

+          _DXGK_RAPID_HPD_DIAG *param_4)

+

+{

+  undefined4 uVar1;

+  undefined4 uVar2;

+  undefined4 uVar3;

+  _GUID _Var4;

+  char cVar5;

+  int iVar6;

+  DXGPROCESS *pDVar7;

+  RAPID_HPD_MANAGER *pRVar8;

+  _tlgProvider_t *p_Var9;

+  _GUID *p_Var10;

+  wchar_t *pwVar11;

+  _GUID local_res8 [8];

+  _GUID local_78 [4];

+  undefined4 local_74;

+  undefined4 local_70;

+  uint local_6c;

+  uint local_68;

+  _DXGK_RAPID_HPD_TYPE local_64;

+  uint local_60 [2];

+  RAPID_HPD_MANAGER *local_58;

+  undefined8 local_50;

+  _GUID *local_48;

+  longlong local_40;

+  char local_38;

+  

+  DXGAUTOPUSHLOCKFASTSHARED::DXGAUTOPUSHLOCKFASTSHARED

+            ((DXGAUTOPUSHLOCKFASTSHARED *)&local_40,(DXGPUSHLOCKFAST *)this,SUB81(param_2,0));

+  iVar6 = 0;

+  pDVar7 = DXGPROCESS::GetCurrent();

+  if ((pDVar7 != (DXGPROCESS *)0x0) && (*(longlong *)(pDVar7 + 0x58) != 0)) {

+    iVar6 = (**(code **)(*(longlong *)(pDVar7 + 0x58) + 0xf0))(0,0,0);

+  }

+  pwVar11 = (wchar_t *)local_78;

+  local_res8[0] = (_GUID)0x0;

+  p_Var10 = local_res8;

+  local_78[0] = (_GUID)0x0;

+  pRVar8 = this;

+  InRapidHPDPeriod(this,0,(bool *)p_Var10,(bool *)pwVar11);

+  _Var4 = local_res8[0];

+  if (((iVar6 == 0) && (this[0x20] != (RAPID_HPD_MANAGER)0x0)) && (local_res8[0] != (_GUID)0x0)) {

+    if (*(int *)(this + 0x34) == 0) {

+      WdLogSingleEntry0(1);

+      pwVar11 = L"m_CurrentType != DXGK_RAPID_HPD_NONE";

+      p_Var10 = (_GUID *)0xffffffff;

+      _WdLogGlobalForLineNumber = 0xc1;

+      DxgkLogInternalTriageEvent

+                (0,0x40002,0xffffffff,L"m_CurrentType != DXGK_RAPID_HPD_NONE",0xc1,0,0,0,0);

+    }

+    *param_2 = *(_DXGK_RAPID_HPD_TYPE *)(this + 0x34);

+    uVar1 = *(undefined4 *)(this + 0x28);

+    uVar2 = *(undefined4 *)(this + 0x2c);

+    uVar3 = *(undefined4 *)(this + 0x30);

+    *(undefined4 *)param_3 = *(undefined4 *)(this + 0x24);

+    *(undefined4 *)(param_3 + 4) = uVar1;

+    *(undefined4 *)(param_3 + 8) = uVar2;

+    *(undefined4 *)(param_3 + 0xc) = uVar3;

+    if (*(int *)(this + 0x58) == 1) {

+      *(undefined4 *)(this + 0x34) = 1;

+    }

+    else if (param_1) {

+      iVar6 = Feature_AdditionalMonitorSleepDiagnostics__private_IsEnabledDeviceUsageNoInline();

+      if (((iVar6 != 0) && (*(int *)(this + 0x34) == 1)) && (5 < DAT_0)) {

+        p_Var9 = (_tlgProvider_t *)&DAT_0;

+        cVar5 = _tlgKeywordOn(&DAT_0,0x400000000002);

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

+          local_74 = *(undefined4 *)(this + 0x50);

+          local_70 = 1;

+          local_50 = 0x1000800;

+          local_58 = this + 0x24;

+          _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>,_tlgWrapperByVal<4>,_tlgWrapperByRef<16>,_tlgWrapperByVal<4>_>

+                    (p_Var9,&DAT_1,p_Var10,(_GUID *)pwVar11,(_tlgWrapperByVal<8> *)&local_50

+                     ,(_tlgWrapperByVal<4> *)&local_70,(_tlgWrapperByRef<16> *)&local_58,

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

+        }

+      }

+      *(undefined4 *)(this + 0x34) = 2;

+    }

+    pRVar8 = (RAPID_HPD_MANAGER *)param_4;

+    if (param_4 != (_DXGK_RAPID_HPD_DIAG *)0x0) {

+      *(undefined8 *)(param_4 + 8) = *(undefined8 *)(this + 0x48);

+      *(undefined4 *)param_4 = *(undefined4 *)(this + 0x50);

+    }

+  }

+  else {

+    *param_2 = 0;

+    *(undefined8 *)param_3 = 0;

+    *(undefined8 *)(param_3 + 8) = 0;

+    if (param_4 != (_DXGK_RAPID_HPD_DIAG *)0x0) {

+      *(undefined8 *)param_4 = 0;

+      *(undefined8 *)(param_4 + 8) = 0;

+    }

+  }

+  if (5 < DAT_0) {

+    local_68 = (uint)(byte)local_78[0];

+    local_64 = *param_2;

+    local_6c = (uint)(byte)_Var4;

+    local_60[0] = (uint)param_1;

+    local_48 = param_3;

+    _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<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByRef<16>_>

+              ((_tlgProvider_t *)pRVar8,&DAT_2,p_Var10,(_GUID *)pwVar11,

+               (_tlgWrapperByVal<4> *)local_60,(_tlgWrapperByVal<4> *)&local_64,

+               (_tlgWrapperByVal<4> *)&local_68,(_tlgWrapperByVal<4> *)&local_6c,

+               (_tlgWrapperByRef<16> *)&local_48);

+  }

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

+    LOCK();

+    *(int *)(local_40 + 0x10) = *(int *)(local_40 + 0x10) + -1;

+    UNLOCK();

+    ExReleasePushLockSharedEx(local_40,0);

+    KeLeaveCriticalRegion();

+  }

+  return;

+}

+
```

## `VIDPN_MGR::GetTargetPowerComponentIndex`  (modified)

```diff
--- VIDPN_MGR::GetTargetPowerComponentIndex
+++ VIDPN_MGR::GetTargetPowerComponentIndex
@@ -1,2 +1,65 @@
-Failed to decompile dxgkrnl.sys - .ProgramDB VIDPN_MGR::GetTargetPowerComponentIndex : 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 VIDPN_MGR::GetTargetPowerComponentIndex(unsigned int,unsigned int * __ptr64)

+   __ptr64 */

+

+long __thiscall VIDPN_MGR::GetTargetPowerComponentIndex(VIDPN_MGR *this,uint param_1,uint *param_2)

+

+{

+  DMMVIDEOPRESENTTARGETSET *this_00;

+  long lVar1;

+  int iVar2;

+  uint uVar3;

+  DMMVIDEOPRESENTTARGET *pDVar4;

+  DXGADAPTER *pDVar5;

+  

+  LOCK();

+  *(int *)(*(longlong *)(this + 0x78) + 0x48) = *(int *)(*(longlong *)(this + 0x78) + 0x48) + 1;

+  UNLOCK();

+  this_00 = *(DMMVIDEOPRESENTTARGETSET **)(this + 0x78);

+  pDVar4 = DMMVIDEOPRESENTTARGETSET::GetTargetById(this_00,param_1);

+  if (pDVar4 == (DMMVIDEOPRESENTTARGET *)0x0) {

+    pDVar5 = GetContainingAdapter(this);

+    WdLogSingleEntry2(2,param_1,pDVar5);

+    _WdLogGlobalForLineNumber = 0x175f;

+    if (this_00 != (DMMVIDEOPRESENTTARGETSET *)0x0) {

+      ReferenceCounted::Release((ReferenceCounted *)(this_00 + 0x40));

+    }

+    lVar1 = -0x3fe1fcfb;

+  }

+  else {

+    iVar2 = Feature_Usb4_DynamicTargets__private_IsEnabledDeviceUsageNoInline();

+    if (iVar2 == 0) {

+      uVar3 = *(uint *)(pDVar4 + 400);

+      *param_2 = uVar3;

+LAB_0:

+      if (uVar3 == 0xffffffff) {

+LAB_1:

+        if (this_00 != (DMMVIDEOPRESENTTARGETSET *)0x0) {

+          ReferenceCounted::Release((ReferenceCounted *)(this_00 + 0x40));

+        }

+        return -0x3ffffff3;

+      }

+    }

+    else {

+      *param_2 = 0xffffffff;

+      do {

+        if (*(DMMVIDEOPRESENTTARGET **)(pDVar4 + 0x1e0) != pDVar4 + 0x1e0) {

+          WdLogSingleEntry1(2,*(undefined4 *)(pDVar4 + 0x18));

+          _WdLogGlobalForLineNumber = 6000;

+          goto LAB_1;

+        }

+        uVar3 = *(uint *)(pDVar4 + 400);

+        *param_2 = uVar3;

+        pDVar4 = *(DMMVIDEOPRESENTTARGET **)(pDVar4 + 0x1d8);

+        if (pDVar4 == (DMMVIDEOPRESENTTARGET *)0x0) goto LAB_0;

+      } while (uVar3 == 0xffffffff);

+    }

+    if (this_00 != (DMMVIDEOPRESENTTARGETSET *)0x0) {

+      ReferenceCounted::Release((ReferenceCounted *)(this_00 + 0x40));

+    }

+    lVar1 = 0;

+  }

+  return lVar1;

+}

+
```

## `AUTO_PNPPOWER_LOCK::AUTO_PNPPOWER_LOCK`  (modified)

```diff
--- AUTO_PNPPOWER_LOCK::AUTO_PNPPOWER_LOCK
+++ DpiCheckForOutstandingD3Requests
@@ -1,19 +1,24 @@
 

-/* public: __cdecl AUTO_PNPPOWER_LOCK::AUTO_PNPPOWER_LOCK(struct _COMMON_PNP_CONTEXT *

-   __ptr64,bool,bool,bool) __ptr64 */

-

-AUTO_PNPPOWER_LOCK * __thiscall

-AUTO_PNPPOWER_LOCK::AUTO_PNPPOWER_LOCK

-          (AUTO_PNPPOWER_LOCK *this,_COMMON_PNP_CONTEXT *param_1,bool param_2,bool param_3,

-          bool param_4)

+void DpiCheckForOutstandingD3Requests(longlong param_1)

 

 {

-  *(_COMMON_PNP_CONTEXT **)this = param_1;

-  *(undefined2 *)(this + 8) = 0;

-  this[10] = (AUTO_PNPPOWER_LOCK)0x0;

-  if (param_1 != (_COMMON_PNP_CONTEXT *)0x0) {

-    Acquire(this);

+  int iVar1;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  undefined8 local_18;

+  

+  DpiDisableD3Requests(*(undefined8 *)(param_1 + 0x18));

+  local_18 = 0;

+  local_28 = 0;

+  uStack_20 = 0;

+  KeAcquireInStackQueuedSpinLock(param_1 + 0x1080,&local_28);

+  iVar1 = *(int *)(param_1 + 0x10c0);

+  KeReleaseInStackQueuedSpinLock(&local_28);

+  if (iVar1 != 0) {

+    DpiRequestDevicePowerState(*(undefined8 *)(param_1 + 0x18),1);

+    DpiEnableD3Requests(*(undefined8 *)(param_1 + 0x18));

   }

-  return this;

+  KeWaitForSingleObject(param_1 + 0x1090,0,0,0,0);

+  return;

 }
```

## `<lambda_5903d3295602326b4b0b9c65dd6f225b>::operator()`  (modified)

```diff
--- <lambda_5903d3295602326b4b0b9c65dd6f225b>::operator()
+++ <lambda_075fb055c3eefe17f41c87dd7eb29c78>::operator()
@@ -1,26 +1,138 @@
 

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

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

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

 

-undefined4 <lambda_a196522e28cbefec8f1ebe5a826d98cf>::operator()(void)

+void <lambda_075fb055c3eefe17f41c87dd7eb29c78>::operator()(undefined8 *param_1)

 

 {

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  undefined4 unaff_EDI;

-  undefined4 unaff_R12D;

-  char unaff_R15B;

-  undefined4 in_stack_00000040;

-  char in_stack_00000050;

+  longlong lVar1;

+  MonitorUsb4State *this;

+  char cVar2;

+  int iVar3;

+  undefined8 *puVar4;

+  undefined8 *puVar5;

+  _GUID *p_Var6;

+  undefined1 auStackY_138 [32];

+  undefined4 local_c8;

+  uint local_c4;

+  undefined4 local_c0;

+  undefined4 local_bc;

+  undefined4 local_b8;

+  undefined4 local_b4;

+  _tlgProvider_t *local_b0;

+  undefined8 *local_a8;

+  longlong local_a0;

+  undefined2 local_98;

+  undefined8 *local_90;

+  undefined1 local_88 [8];

+  undefined1 local_80 [8];

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined4 local_68;

+  undefined4 local_64;

+  undefined8 local_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined4 local_40;

+  undefined8 local_38;

+  undefined4 local_30;

+  undefined4 local_2c;

+  undefined4 local_28;

+  undefined4 local_24;

+  undefined4 local_20;

+  ulonglong local_18;

   

-  WdLogSingleEntry2(unaff_R12D,*(undefined4 *)(unaff_RSI + 8));

-  _WdLogGlobalForLineNumber = 0x1099;

-  DXGETWPROFILER_BASE::PopProfilerEntry((DXGETWPROFILER_BASE *)&stack0x00000040);

-  if ((in_stack_00000050 != unaff_R15B) && ((DAT_0 & 1) != 0)) {

-    McTemplateK0q_EtwWriteTransfer();

+  local_18 = __security_cookie ^ (ulonglong)auStackY_138;

+  local_78 = 0;

+  uStack_70 = 0;

+  puVar4 = *(undefined8 **)*param_1;

+  if (puVar4 != (undefined8 *)0x0) {

+    local_78 = *puVar4;

+    uStack_70 = puVar4[1];

   }

-  CDisplayScenarioContextScope::~CDisplayScenarioContextScope

-            ((CDisplayScenarioContextScope *)(unaff_RBP + -0x80));

-  return unaff_EDI;

+  iVar3 = Feature_AdditionalMonitorSleepDiagnostics__private_IsEnabledDeviceUsageNoInline();

+  p_Var6 = (_GUID *)&DAT_0;

+  if (iVar3 == 0) {

+    if (5 < DAT_1) {

+      cVar2 = _tlgKeywordOn(&DAT_1,0x400000001000);

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

+        lVar1 = param_1[1];

+        local_98 = SUB82(p_Var6,0);

+        local_a0 = lVar1 + 0x14;

+        local_b8 = *(undefined4 *)(lVar1 + 0x10);

+        local_bc = *(undefined4 *)(lVar1 + 0xc);

+        local_c0 = *(undefined4 *)param_1[3];

+        local_a8 = &local_78;

+        local_c4 = *(uint *)param_1[2];

+        local_c8 = 1;

+        local_b0 = (_tlgProvider_t *)0x1000800;

+        _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>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByRef<16>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperBinary>

+                  ((_tlgProvider_t *)(ulonglong)local_c4,&DAT_2,(_GUID *)&local_78,p_Var6,

+                   (_tlgWrapperByVal<8> *)&local_b0,(_tlgWrapperByVal<4> *)&local_c8,

+                   (_tlgWrapperByVal<4> *)&local_c4,(_tlgWrapperByRef<16> *)&local_a8,

+                   (_tlgWrapperByVal<4> *)&local_c0,(_tlgWrapperByVal<4> *)&local_bc,

+                   (_tlgWrapperByVal<4> *)&local_b8,(_tlgWrapperBinary *)&local_a0);

+      }

+    }

+  }

+  else {

+    if (5 < DAT_1) {

+      cVar2 = _tlgKeywordOn(&DAT_1);

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

+        puVar4 = (undefined8 *)param_1[1];

+        local_98 = SUB82(p_Var6,0);

+        local_a0 = (longlong)puVar4 + 0x14;

+        local_b4 = *(undefined4 *)(puVar4 + 2);

+        local_c8 = *(undefined4 *)((longlong)puVar4 + 0xc);

+        local_c4 = *(uint *)param_1[3];

+        local_90 = &local_78;

+        local_c0 = *(undefined4 *)param_1[2];

+        local_bc = (**(code **)(*(longlong *)*puVar4 + 0x10))();

+        puVar4 = (undefined8 *)(**(code **)(*(longlong *)*puVar4 + 8))((longlong *)*puVar4,local_88)

+        ;

+        local_b0 = (_tlgProvider_t *)*puVar4;

+        local_b8 = 2;

+        local_a8 = (undefined8 *)0x1000800;

+        _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>,_tlgWrapperByVal<4>,_tlgWrapperByVal<8>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByRef<16>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperByVal<4>,_tlgWrapperBinary>

+                  (local_b0,&DAT_3,(_GUID *)&local_78,p_Var6,

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

+                   (_tlgWrapperByVal<8> *)&local_b0,(_tlgWrapperByVal<4> *)&local_bc,

+                   (_tlgWrapperByVal<4> *)&local_c0,(_tlgWrapperByRef<16> *)&local_90,

+                   (_tlgWrapperByVal<4> *)&local_c4,(_tlgWrapperByVal<4> *)&local_c8,

+                   (_tlgWrapperByVal<4> *)&local_b4,(_tlgWrapperBinary *)&local_a0);

+      }

+    }

+    memset(&local_68,0,0x50);

+    local_40 = 0;

+    local_48 = 0;

+    local_64 = 0x50;

+    puVar4 = (undefined8 *)param_1[1];

+    local_60 = 0;

+    local_68 = 0x3b;

+    local_58 = 0;

+    uStack_50 = 0;

+    puVar5 = (undefined8 *)(**(code **)(*(longlong *)*puVar4 + 8))((longlong *)*puVar4,local_80);

+    local_38 = *puVar5;

+    local_30 = (**(code **)(*(longlong *)*puVar4 + 0x10))();

+    local_2c = *(undefined4 *)param_1[2];

+    local_28 = *(undefined4 *)param_1[3];

+    local_24 = *(undefined4 *)((longlong)puVar4 + 0xc);

+    local_20 = *(undefined4 *)(puVar4 + 2);

+    DxgkWriteDiagEntry(&local_68);

+  }

+  if (*(int *)param_1[2] < 0) {

+    WdLogSingleEntry2(2,*(undefined4 *)param_1[3],(longlong)*(int *)param_1[2]);

+    this = (MonitorUsb4State *)param_1[1];

+    _WdLogGlobalForLineNumber = 0x475;

+    DxgMonitor::MonitorUsb4State::DestroyPowerConnectionWithUsb4Stack(this,false);

+    this[8] = (MonitorUsb4State)0x0;

+  }

+  return;

 }
```

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

```diff
--- NTOSKRNL.EXE::KeReadStateEvent calling
+++ NTOSKRNL.EXE::KeReadStateEvent calling
@@ -40 +39,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::KeReleaseMutex calling
+++ NTOSKRNL.EXE::KeReleaseMutex calling
@@ -95,0 +96 @@
+DpiWnfUsbTunnelChangeWorkItem
```

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

```diff
--- NTOSKRNL.EXE::ExReleasePushLockSharedEx calling
+++ NTOSKRNL.EXE::ExReleasePushLockSharedEx calling
@@ -166 +165,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::RtlCreateSecurityDescriptor calling
+++ NTOSKRNL.EXE::RtlCreateSecurityDescriptor calling
@@ -6,0 +7 @@
+DxgMonitor::BuildSdrWhiteLevelWnfSecurityDescriptor
```

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

```diff
--- NTOSKRNL.EXE::RtlAbsoluteToSelfRelativeSD calling
+++ NTOSKRNL.EXE::RtlAbsoluteToSelfRelativeSD calling
@@ -2,0 +3 @@
+DxgMonitor::BuildSdrWhiteLevelWnfSecurityDescriptor
```

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

```diff
--- NTOSKRNL.EXE::IoAllocateWorkItem calling
+++ NTOSKRNL.EXE::IoAllocateWorkItem calling
@@ -24,0 +25 @@
+DpiWnfUsbTunnelChangeCallback
```

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

```diff
--- NTOSKRNL.EXE::IoFreeWorkItem calling
+++ NTOSKRNL.EXE::IoFreeWorkItem calling
@@ -27,0 +28 @@
+DpiWnfUsbTunnelChangeWorkItem
```

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

```diff
--- NTOSKRNL.EXE::ExAcquireResourceExclusiveLite calling
+++ NTOSKRNL.EXE::ExAcquireResourceExclusiveLite calling
@@ -63 +62,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::ZwUpdateWnfStateData calling
+++ NTOSKRNL.EXE::ZwUpdateWnfStateData calling
@@ -11,0 +12 @@
+DxgMonitor::MonitorColorState::SetSDRWhiteLevel
```

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

```diff
--- NTOSKRNL.EXE::RtlSetDaclSecurityDescriptor calling
+++ NTOSKRNL.EXE::RtlSetDaclSecurityDescriptor calling
@@ -6,0 +7 @@
+DxgMonitor::BuildSdrWhiteLevelWnfSecurityDescriptor
```

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

```diff
--- NTOSKRNL.EXE::ExFreeToLookasideListEx calling
+++ NTOSKRNL.EXE::ExFreeToLookasideListEx calling
@@ -7 +6,0 @@
-DXGCONTEXT::PresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::KeLeaveCriticalRegion calling
+++ NTOSKRNL.EXE::KeLeaveCriticalRegion calling
@@ -349,0 +350 @@
+DpiWnfUsbTunnelChangeWorkItem
```

## `WATCHDOG.SYS::WdLogSingleEntry2`  (modified)

```diff
--- WATCHDOG.SYS::WdLogSingleEntry2 calling
+++ WATCHDOG.SYS::WdLogSingleEntry2 calling
@@ -0,0 +1 @@
+<lambda_075fb055c3eefe17f41c87dd7eb29c78>::operator()
@@ -1,0 +3 @@
+<lambda_51c0b6db26470bbbee6edbc2832b4c89>::operator()
@@ -3,3 +5 @@
-<lambda_5903d3295602326b4b0b9c65dd6f225b>::operator()
-<lambda_7877251d41a5b51b54594303700a1794>::operator()
-<lambda_8c8b9ce90c786a665a384ccea2007054>::operator()
+<lambda_f6671327af613c45e06adb67f9a532c3>::operator()
```

## `WATCHDOG.SYS::WdLogSingleEntry3`  (modified)

```diff
--- WATCHDOG.SYS::WdLogSingleEntry3 calling
+++ WATCHDOG.SYS::WdLogSingleEntry3 calling
@@ -103,0 +104 @@
+DISPLAY_MUX_SWTICH_DDI_TRACKING::CallDriverCancelDdi
@@ -403,0 +405 @@
+DxgkGetPresentHistoryReadyEvent
```

## `WATCHDOG.SYS::WdLogSingleEntry0`  (modified)

```diff
--- WATCHDOG.SYS::WdLogSingleEntry0 calling
+++ WATCHDOG.SYS::WdLogSingleEntry0 calling
@@ -1,0 +2 @@
+<lambda_095b6d6186eb5e6fe8d9f16b1069770d>::operator()
@@ -4,2 +5,3 @@
-<lambda_9000b013b54c5d4fd00007edcb0ed276>::operator()
-<lambda_9ff15276089a9b05610374d641210723>::operator()
+<lambda_30dab93bc541a012369c07a887b1c857>::operator()
+<lambda_4ec9c3387e80d874534c4ef64e32e476>::operator()
+<lambda_97a682d0a478d0ee054b6403b798d101>::operator()
@@ -8,3 +10 @@
-<lambda_d3550799dafcb87631ec966092ee9b5d>::operator()
-<lambda_dd15c29f52acee5939696e6a7b93aeab>::operator()
-<lambda_f8d493ecc145a183b3c8a63082b98955>::operator()
+<lambda_beee8708c0607e17ddadb7a3f3f84f1e>::operator()
```

## `WATCHDOG.SYS::WdLogSingleEntry1`  (modified)

```diff
--- WATCHDOG.SYS::WdLogSingleEntry1 calling
+++ WATCHDOG.SYS::WdLogSingleEntry1 calling
@@ -2,2 +2 @@
-<lambda_3a98b0471e77705cc40c9c762bfba9df>::operator()
-<lambda_7877251d41a5b51b54594303700a1794>::operator()
+<lambda_51c0b6db26470bbbee6edbc2832b4c89>::operator()
@@ -5 +4 @@
-<lambda_8c8b9ce90c786a665a384ccea2007054>::operator()
+<lambda_9644267c8045bb97f47294e06e8277ff>::operator()
@@ -7,0 +7 @@
+<lambda_f6671327af613c45e06adb67f9a532c3>::operator()
@@ -231,0 +232 @@
+BmlPreparePathOrderAndVidPn
@@ -1178,0 +1180 @@
+DpiWnfUsbTunnelChangeCallback
@@ -1216,0 +1219 @@
+DxgMonitor::MonitorColorState::InitializeSdrWhiteLevelWnf
@@ -1561,0 +1565 @@
+MonitorGetSdrWhiteLevelWnfName
@@ -1854,0 +1859 @@
+VIDPN_MGR::GetTargetPowerComponentIndex
```

## `WATCHDOG.SYS::WdLogSingleEntry5`  (modified)

```diff
--- WATCHDOG.SYS::WdLogSingleEntry5 calling
+++ WATCHDOG.SYS::WdLogSingleEntry5 calling
@@ -397 +396,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::KeWaitForSingleObject calling
+++ NTOSKRNL.EXE::RtlCreateSecurityDescriptor calling
@@ -1,196 +1,8 @@
-ADAPTER_DISPLAY::WaitForVerticalBlankEvent
-ADAPTER_RENDER::DdiPreemptCommand
-ADAPTER_RENDER::DdiSubmitCommand
-AUTO_MUTEX_LOCK::AUTO_MUTEX_LOCK
-AcquireMiniportListMutex
-BLTQUEUE::AcquireOwnershipWorker
-BLTQUEUE::AcquireVidPnSourceOwnership
-BLTQUEUE::BltQueueWorker
-BLTQUEUE::Cleanup
-BLTQUEUE::CleanupWorker
-BLTQUEUE::DisableHwVSync
-BLTQUEUE::DiscardPendingPresent
-BLTQUEUE::EnableVSyncEventSignaling
-BLTQUEUE::EnableVSyncEventWorker
-BLTQUEUE::FinishCommand
-BLTQUEUE::Flush
-BLTQUEUE::GlobalVmBusStatusChangeWorker
-BLTQUEUE::HostMonitorPowerStateWorker
-BLTQUEUE::InsertQueueHead
-BLTQUEUE::InsertQueueTail
-BLTQUEUE::IssueCommand
-BLTQUEUE::NotifyGlobalVmBusStatusChange
-BLTQUEUE::NotifyHostMonitorPowerState
-BLTQUEUE::Present
-BLTQUEUE::PresentDisplayOnly
-BLTQUEUE::ProcessBltQueue
-BLTQUEUE::QueryPresentStats
-BLTQUEUE::QueryPresentStatsDWM
-BLTQUEUE::RemoveQueueHead
-BLTQUEUE::Reset
-BLTQUEUE::ResetWorker
-BLTQUEUE::RestartQueueWorker
-BLTQUEUE::SetIndirectSwapChainHandles
-BLTQUEUE::Startup
-BLTQUEUE::UpdateDisplayModeInfo
-BLTQUEUE::UpdateDisplayModeInfoWorker
-BLTQUEUE::UpdatePresentStats
-COREACCESS::AcquireExclusive
-COREACCESS::AcquireShared
-COREADAPTERACCESS::AcquireShared
-COREDEVICEACCESS::AcquireShared
-COREDEVICEACCESS::AcquireSharedUncheck
-CTTMDEVICE::UnRegisterTtmDevice
-CancelTimerCallbacksAndDeleteTimer
-DISPLAY_MUX_SWITCH_OPERATION::PerformSwitch
-DXGADAPTER::AcquireCoreSync
-DXGADAPTER::AcquireDdiSync
-DXGADAPTER::CallDriverQueryInterface
-DXGADAPTER::DdiControlInterrupt2
-DXGADAPTER::PowerRuntimeComponentIdleStateCallback
-DXGADAPTER::PowerRuntimeComponentIdleStateCallback_Thread
-DXGADAPTER::SubmitPresentHistoryTokenFromVm
-DXGADAPTERSYNCOBJECT::AdapterObjectSignalFence
-DXGDEADLOCK_TRACKER::Cancel
-DXGDEVICE::DestroyAllocations
-DXGDEVICE::DestroyDevice
-DXGDEVICE::FlushDeferredDestruction
-DXGDEVICE::NotifyProcessFreeze
-DXGDEVICEACCESSLOCKEXCLUSIVE::Acquire
-DXGDEVICEACCESSLOCKEXCLUSIVE::DXGDEVICEACCESSLOCKEXCLUSIVE
-DXGDEVICEACCESSLOCKEXCLUSIVECDD::DXGDEVICEACCESSLOCKEXCLUSIVECDD
-DXGDEVICEACCESSLOCKSHARED::Acquire
-DXGDEVICELOCKONAPPROPRIATETHREADMODEL::DXGDEVICELOCKONAPPROPRIATETHREADMODEL
-DXGKEYEDMUTEX::AcquireSync
-DXGSESSIONMGR::WaitForPnPTransitionDone
-DXGSWAPCHAINLOCKWITHDEVICE::Acquire
-DXGSYNCOBJECT::SignalFence
-DXGTRACKEDWORKLOAD::DestroyTrackedWorkload
-DXGVIRTUALMACHINE::EndTransaction
-DXGVMBUSCHANNEL::Enable
-DXG_GUEST_GLOBAL_VMBUS::CreateVmBusChannel
-DXG_GUEST_VIRTUALGPU_VMBUS::CreateVmBusChannel
-DpEvalAcpiMethod
-DpExcludeAdapterAccess
-DpIterateFdoContexts
-DpMapMemory
-DpReadSpbResource
-DpSpbResourceIoControl
-DpUnmapMemory
-DpWriteSpbResource
-DpiAcpiEvalAcpiMethodEx
-DpiAcpiHandleAcpiEvent
-DpiAcpiPrepareAcpiEnumChildCache
-DpiAddDevice
-DpiAgpAllocatePool
-DpiAgpFreePool
-DpiBrightness3Get
-DpiBrightness3GetCaps
-DpiBrightness3GetNitRanges
-DpiBrightness3Set
-DpiBrightness3SetBacklightOptimization
-DpiBrightnessIfGet
-DpiBrightnessIfGetBacklightReduction
-DpiBrightnessIfGetCaps
-DpiBrightnessIfGetPossible
-DpiBrightnessIfSet
-DpiBrightnessIfSetBacklightOptimization
-DpiBrightnessIfSetState
-DpiBrightnessNotifyMonitorDimming
-DpiBrightnessSetUncalibratedBrightness3Fallback
-DpiBrightnessStopDevice
-DpiCheckForOutstandingD3Requests
-DpiDumpAdaptersDisplayMuxStatus
-DpiEnterSystemDisplay
-DpiFdoAddPdoToPdoList
-DpiFdoDestroyRelatedObjects
-DpiFdoDetectPostDevice
-DpiFdoDetectVgaDeviceInCapabilities
-DpiFdoDispatchInternalIoctl
-DpiFdoEnumChildDevices
-DpiFdoExcludeAdapterAccess
-DpiFdoHandleDevicePower
-DpiFdoHandleQueryPowerRelations
-DpiFdoHandleRemoveDevice
-DpiFdoHandleSystemPower
-DpiFdoQueryAdapterInfoIntegratedDisplay2
-DpiFdoRemoveChildDescriptors
-DpiFdoRemovePdoFromPdoList
-DpiFdoStartAdapterThreadImpl
-DpiFdoStopAdapter
-DpiGdoCreateGdiObjects
-DpiGdoDestroyGdiObjects
-DpiGetDeviceInstanceId
-DpiGetDxgAdapterFromChild
-DpiGetDxgAdapterSafe
-DpiGetMonitorDescriptor
-DpiGetWholeMonitorDescriptor
-DpiIndirectCbDisableRenderD3RequestsWorker
-DpiIndirectFindDeviceFromInstanceId
-DpiLdaValidateSystemChainStatus
-DpiLiveMigrationWaitForFence
-DpiMiracastFindDisplayAdapterFdo
-DpiMiracastSendSyncUserModeRequest
-DpiMiracastStopMiracastSessionSync
-DpiMiracastTargetDeviceChange
-DpiMitigatedRangeUpdate
-DpiPanelBufferingSetOverrideState
-DpiPdoAddPdo
-DpiPdoDispatchInternalIoctl
-DpiPdoGetDeviceContainerIdFromDescriptor
-DpiPdoGetDeviceDescriptor
-DpiPdoHandleOpmIoctlsInternal
-DpiPdoIsChildConnected
-DpiPdoPollChild
-DpiPdoPollingWorkItem
-DpiPdoRemovePdo
-DpiPdoSetMonitorDriverInterfaceState
-DpiPdoSetMonitorDriverInterfaceStateWorker
-DpiPollAllDisplayChildren
-DpiPowerArbiterThread
-DpiQueryBusInterface
-DpiQueryDisplayIDDescriptor
-DpiRequestIoPowerState
-DpiSessionCreateCallback
-DpiSetDeviceUsageType
-DpiValidateDeviceName
-DpiVerifyResources
-DxgkCallDriverIoControl
-DxgkCddWaitForVerticalBlankEvent
-DxgkDrtTestEscape
-DxgkGetPresentHistoryInternal
-DxgkMakeResidentInternal
-DxgkMapUnmapProcessDebugBlob
-DxgkPowerOnOffMonitor
-DxgkPowerRuntimeComponentIdleStateCallback
-DxgkSubmitCommandInternal
-DxgkSubmitCommandToHwQueueInternal
-DxgkWaitForMonitorEventDoneInternal
-DxgkpProcessVSyncPhaseThread
-EnforceDriverModelScalingPolicy
-EnsureClientVmBusInterface
-EnsureServerVmBusInterface
-MonitorFlushUsb4PowerOnWorkQueue
-NtGdiDdDDIGetScanLine
-NtGdiDdDDILock
-NtGdiDdDDILock2
-NtGdiDdDDIMapGpuVirtualAddress
-NtGdiDdDDIOfferAllocations
-NtGdiDdDDIPresent
-NtGdiDdDDIPresentMultiPlaneOverlay3
-NtGdiDdDDIQueryVideoMemoryInfo
-NtGdiDdDDIReclaimAllocations2
-NtGdiDdDDISetQueuedLimit
-NtGdiDdDDIUnlock2
-NtGdiDdDDIUpdateGpuVirtualAddress
-OutputDuplThunks<_D3DKMT_OUTPUTDUPL_GET_POINTER_SHAPE_DATA*___ptr64>::RunForAdapter
-OutputDuplThunks<_DXGKARG_SETPOINTERPOSITION_const*___ptr64>::RunForAdapter
-PollDisplayChildrenForAdapter
-REMOTE_VSYNC::WaitForVSync
-SetPointerPositionForDisplaySource
-SubmitPresentHistoryTokenPreparation
-SubmitSignalSyncObjectsToHwQueue
-SubmitWaitForSyncObjectsFromGpu
-TdrTimedOperationWaitForSingleObject
-WaitForSynchronizationObjectFromCpu
-WaitForSynchronizationObjectFromGpu
+AdjustCcdDatabasePermissions
+CheckCallerMatchesSid
+DXGVAILOBJECT::AllocateDefaultSecurityDescriptor
+DXGVAILOBJECT::AllocateResourceSecurityDescriptor
+DpiCreateSecurityDescriptorForGpuVirtualization
+DpiIndirectEscapeAccessCheck
+DxgkNetDispAccessCheck
+SepSddlSecurityDescriptorFromSDDLString
```

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

```diff
--- NTOSKRNL.EXE::ExInterlockedRemoveHeadList calling
+++ NTOSKRNL.EXE::ExInterlockedRemoveHeadList calling
@@ -4 +3,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::ExReleaseResourceLite calling
+++ NTOSKRNL.EXE::ExReleaseResourceLite calling
@@ -104,0 +105 @@
+DpiWnfUsbTunnelChangeWorkItem
```

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

```diff
--- NTOSKRNL.EXE::ExReleaseRundownProtection calling
+++ NTOSKRNL.EXE::ExReleaseRundownProtection calling
@@ -9 +8,0 @@
-DXGCONTEXT::PresentMultiPlaneOverlay3
@@ -13 +11,0 @@
-DXGDEVICE::CreateStandardAllocation
```

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

```diff
--- NTOSKRNL.EXE::IoQueueWorkItemEx calling
+++ NTOSKRNL.EXE::IoQueueWorkItemEx calling
@@ -24,0 +25 @@
+DpiWnfUsbTunnelChangeCallback
```

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

```diff
--- NTOSKRNL.EXE::RtlCreateAcl calling
+++ NTOSKRNL.EXE::RtlCreateAcl calling
@@ -6,0 +7 @@
+DxgMonitor::BuildSdrWhiteLevelWnfSecurityDescriptor
```

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

```diff
--- NTOSKRNL.EXE::ExReleaseResourceLite calling
+++ NTOSKRNL.EXE::ExSubscribeWnfStateChange calling
@@ -1,168 +1,6 @@
-ADAPTER_DISPLAY::AddingMonitorOrientation
-ADAPTER_DISPLAY::GetCurrentOrientation
-ADAPTER_RENDER::TryReleaseDeviceLockForAllDevices
-AUTO_PNPPOWER_LOCK::Release
-CCD_TOPOLOGY::ApplyTopologyOnAdapter
-CCD_TOPOLOGY::FinalizeTopologyOnAdapter
-CInterfaceCallContext::CommonConstructor
-CInterfaceCallContext::~CInterfaceCallContext
-CONST_MONITOR_REF_LOCK_ACCESSOR::~CONST_MONITOR_REF_LOCK_ACCESSOR
-CreateSynchronizationObjectInternal
-DXGADAPTER::DdiControlInterrupt2
-DXGADAPTER::PrepareToReset
-DXGADAPTER::PresentDisplayOnlyRecoveryWorker
-DXGADAPTER::ReleaseCoreResource
-DXGADAPTER::ReleaseDdiSync
-DXGADAPTER::Reset
-DXGCONTEXT::AcquireMultiPlaneOverlay3FlipFences
-DXGCONTEXT::SubmitPresentMultiPlaneOverlays3
-DXGDEVICEACCESSLOCKEXCLUSIVE::Release
-DXGDEVICEACCESSLOCKEXCLUSIVE::~DXGDEVICEACCESSLOCKEXCLUSIVE
-DXGDEVICEACCESSLOCKEXCLUSIVECDD::Release
-DXGDEVICEACCESSLOCKSHARED::~DXGDEVICEACCESSLOCKSHARED
-DXGDEVICELOCKONAPPROPRIATETHREADMODEL::~DXGDEVICELOCKONAPPROPRIATETHREADMODEL
-DXGK_MONITORDESCRIPTORSET_INTERFACE_V1_IMPL::AcquireNextDescriptorInfo
-DXGK_MONITORDESCRIPTORSET_INTERFACE_V1_IMPL::GetNumDescriptors
-DXGK_MONITORDESCRIPTORSET_INTERFACE_V1_IMPL::ReleaseDescriptorInfo
-DXGK_MONITORSOURCEMODESET_INTERFACE_V1_IMPL::AcquireNextModeInfo
-DXGK_MONITORSOURCEMODESET_INTERFACE_V1_IMPL::AddMode
-DXGK_MONITORSOURCEMODESET_INTERFACE_V1_IMPL::CreateNewModeInfo
-DXGK_MONITORSOURCEMODESET_INTERFACE_V1_IMPL::ReleaseModeInfo
-DXGK_MONITOR_INTERFACE_V2_IMPL::GetAdditionalTiming
-DXGMONITOR::OnDescriptorUpdated
-DXGMONITOR::_InitializeMonitorWithDriver
-DXGPROCESS::ReleaseDeviceLockForAllDevices
-DXGSWAPCHAINLOCKWITHDEVICE::Release
-DXGSYNCOBJECTLOCK::Release
-DXGSYNCOBJECTLOCK::~DXGSYNCOBJECTLOCK
-DpiAcpiHandleAcpiEvent
-DpiAcquireCoreSyncAccessSafe
-DpiBrightnessNotifyMonitorDimming
-DpiDisableMsBddFallbackDriver
-DpiDoesMdmChildMeetRequirements
-DpiEnableMsBddFallbackDriver
-DpiEnterSystemDisplay
-DpiFdoCreateRelatedObjects
-DpiFdoDispatchCleanupAndClose
-DpiFdoDispatchInternalIoctl
-DpiFdoDispatchPnp
-DpiFdoEnumChildDevices
-DpiFdoExcludeAdapterAccess
-DpiFdoHandleDevicePower
-DpiFdoHandleQueryDeviceRelations
-DpiFdoHandleQueryFlexibleIovInterface
-DpiFdoHandleQueryPartitioningDeviceInterface
-DpiFdoHandleQueryPowerRelations
-DpiFdoHandleQuerySrIovInterface
-DpiFdoHandleQueryThermalInterface
-DpiFdoHandleStartDevice
-DpiFdoHandleStopDevice
-DpiFdoHandleSurpriseRemoval
-DpiFdoHandleSystemPower
-DpiFdoInvalidateChildRelations
-DpiFdoInvalidateChildStatus
-DpiFdoInvalidateChildWorkItem
-DpiFdoRemoveChildDescriptors
-DpiFdoSetAdapterPowerState
-DpiFdoStartAdapterThreadImpl
-DpiFdoStopAdapter
-DpiFdoStopMiracastSession
-DpiFdoThermalActiveCooling
-DpiFdoThermalPassiveCooling
-DpiFdoWaitWakePoCompletionWorkItem
-DpiGdoDestroyGdiObjects
-DpiGdoDispatchCreate
-DpiGdoDispatchInternalIoctl
-DpiGetDxgAdapterSafe
-DpiGetIntegratedEdidSizeForDisplayMuxTarget
-DpiIndicateConnectorChangeWorkItem
-DpiIndirectCbOpmGetSrmListVersion
-DpiIndirectCbOpmSetSrmList
-DpiKsrStopAdapter
-DpiLdaHandleQueryDeviceRelations
-DpiLdaLinkDeviceToChain
-DpiLdaUnLinkDeviceFromChain
-DpiLdaValidateSystemChainStatus
-DpiLeaveSystemDisplay
-DpiMiracastFindDisplayAdapterFdo
-DpiMiracastFindDisplayAdapterFdoIhv
-DpiMiracastStopMiracastSessionSync
-DpiMiracastTearDownAssociation
-DpiPdoDispatchInternalIoctl
-DpiPdoDispatchPnp
-DpiPdoDispatchPower
-DpiPdoHandleOpmIoctlsInternal
-DpiPdoHandleQueryDeviceRelations
-DpiPdoHandleStartDevice
-DpiPdoHandleStopDevice
-DpiPdoIsChildConnected
-DpiPdoPollingWorkItem
-DpiPdoRemovePdoObjects
-DpiPollDisplayChildren
-DpiPollSingleDisplayChild
-DpiPowerArbiterThread
-DpiReleaseCoreSyncAccessSafe
-DpiWnfUsbTunnelChangeWorkItem
-DxgMonitor::MonitorModes::RetrieveMonitorFrequencyRangeFromRegistry
-DxgkCddDestroyAllocation
-DxgkCddIssueSyncObjectOpForDevice
-DxgkCddOpenResource
-DxgkCddOpenResourceFromNtHandle
-DxgkCddQueryResourceInfo
-DxgkCddQueryResourceInfoFromNtHandle
-DxgkCddUnlock
-DxgkCreateSynchronizationObjectImpl
-DxgkDisplayOnOff
-DxgkEnableUnorderedWaitsForDevice
-DxgkGetAdapterDeviceDesc
-DxgkHandleMiracastEscape
-DxgkInvalidateDeviceState
-DxgkMakeResidentInternal
-DxgkMiracastQueryMiracastSupportInternal
-DxgkMiracastStartMiracastSession
-DxgkPinResourcesInternal
-DxgkPowerOnOffMonitor
-DxgkQueryConnectionChanges
-DxgkSubmitCommandInternal
-DxgkSubmitCommandToHwQueueInternal
-DxgkSubmitPresentToHwQueue
-DxgkpDelayPresentCddPrimary
-IsVirtualizationDisabledForTarget
-LogMonitorHandleOnOffState
-MONITOR_MGR::_CleanUpFromSimulatedMonitor
-MONITOR_MGR::_CreatePhysicalMonitor
-MONITOR_MGR::_EnableDisableMonitor
-MONITOR_MGR::_EnableDisableMonitorInternal
-MONITOR_MGR::_MonitorOnOffTelemetry
-MonitorGetMonitorOrientationsFromTarget
-MonitorGetNextMonitorSourceMode
-MonitorIsMonitorVirtualModeDisabled
-MonitorNotifyDeviceNodeReady
-MonitorSetAppOverride
-MonitorSetExternalBrightnessPolicy
-MonitorSetLastWireformatAndColorspace
-NtGdiDdDDICheckMultiPlaneOverlaySupport3
-NtGdiDdDDIConfigureSharedResource
-NtGdiDdDDILock
-NtGdiDdDDILock2
-NtGdiDdDDIMapGpuVirtualAddress
-NtGdiDdDDIOfferAllocations
-NtGdiDdDDIPresent
-NtGdiDdDDIPresentMultiPlaneOverlay3
-NtGdiDdDDIQueryResourceInfo
-NtGdiDdDDIQueryResourceInfoFromNtHandle
-NtGdiDdDDIReclaimAllocations2
-NtGdiDdDDISetAllocationPriority
-NtGdiDdDDISetQueuedLimit
-NtGdiDdDDISignalSynchronizationObjectFromCpu
-NtGdiDdDDIUnlock2
-NtGdiDdDDIUpdateGpuVirtualAddress
-OutputDuplPresentToHwQueue
-PreIndirectPresentReadAllocationInfo
-RESOURCE_LOCK<DXGMONITOR>::Release
-RESOURCE_LOCK<DXGMONITOR>::~RESOURCE_LOCK<DXGMONITOR>
-RESOURCE_LOCK<DxgMonitor::MonitorModes_const_>::~RESOURCE_LOCK<DxgMonitor::MonitorModes_const_>
-SubmitSignalSyncObjectsToHwQueue
-SubmitWaitForSyncObjectsFromGpu
-WaitForSynchronizationObjectFromCpu
-WaitForSynchronizationObjectFromGpu
+DXGGLOBAL::CsExitInitiatedWnfSubscription
+DXGGLOBAL::SubscribeWNFForCSAccounting
+DisplayDiagnostics::Initialize
+DpiInitializeGlobalState
+DriverEntry
+DxgkCddSubscribeWnfStateChange
```

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

```diff
--- NTOSKRNL.EXE::KeEnterCriticalRegion calling
+++ NTOSKRNL.EXE::KeEnterCriticalRegion calling
@@ -210,0 +211 @@
+DpiWnfUsbTunnelChangeWorkItem
```

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

```diff
--- NTOSKRNL.EXE::RtlLengthSid calling
+++ NTOSKRNL.EXE::RtlLengthSid calling
@@ -6,0 +7 @@
+DxgMonitor::BuildSdrWhiteLevelWnfSecurityDescriptor
```

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

```diff
--- NTOSKRNL.EXE::PsGetProcessDxgProcess calling
+++ NTOSKRNL.EXE::PsGetProcessDxgProcess calling
@@ -47 +46,0 @@
-NtGdiDdDDIPresentMultiPlaneOverlay3
```

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

```diff
--- NTOSKRNL.EXE::KeReadStateEvent calling
+++ NTOSKRNL.EXE::ExUnsubscribeWnfStateChange calling
@@ -1,50 +1,7 @@
-ADAPTER_RENDER::DdiPreemptCommand
-ADAPTER_RENDER::DdiSubmitCommand
-ADAPTER_RENDER::Stop
-BLTQUEUE::Flush
-BLTQUEUE::PresentDisplayOnly
-BLTQUEUE::ProcessBltQueue
-COREACCESS::AcquireExclusive
-COREACCESS::AcquireShared
-COREADAPTERACCESS::AcquireShared
-COREDEVICEACCESS::AcquireShared
-COREDEVICEACCESS::AcquireSharedUncheck
-DXGADAPTER::AcquireCoreSync
-DXGADAPTER::AcquireDdiSync
-DXGADAPTER::DdiControlInterrupt2
-DXGADAPTERSYNCOBJECT::AdapterObjectSignalFence
-DXGDEVICEACCESSLOCKEXCLUSIVE::Acquire
-DXGDEVICEACCESSLOCKEXCLUSIVE::DXGDEVICEACCESSLOCKEXCLUSIVE
-DXGDEVICEACCESSLOCKEXCLUSIVE::TryAcquire
-DXGDEVICEACCESSLOCKEXCLUSIVECDD::DXGDEVICEACCESSLOCKEXCLUSIVECDD
-DXGDEVICEACCESSLOCKSHARED::Acquire
-DXGDEVICELOCKONAPPROPRIATETHREADMODEL::DXGDEVICELOCKONAPPROPRIATETHREADMODEL
-DXGSWAPCHAINLOCKWITHDEVICE::Acquire
-DXGSYNCOBJECT::SignalFence
-DXGVIRTUALMACHINE::EndTransaction
-DXGVMBUSCHANNEL::Enable
-DxgkCddWaitForVerticalBlankEvent
-DxgkGetPresentHistoryInternal
-DxgkIddHandleSetDisplayConfig
-DxgkMakeResidentInternal
-DxgkSubmitCommandInternal
-DxgkSubmitCommandToHwQueueInternal
-DxgkpProcessVSyncPhaseThread
-EnforceDriverModelScalingPolicy
-NtGdiDdDDIGetScanLine
-NtGdiDdDDILock
-NtGdiDdDDILock2
-NtGdiDdDDIMapGpuVirtualAddress
-NtGdiDdDDIOfferAllocations
-NtGdiDdDDIPresent
-NtGdiDdDDIQueryVideoMemoryInfo
-NtGdiDdDDIReclaimAllocations2
-NtGdiDdDDISetQueuedLimit
-NtGdiDdDDIUnlock2
-OutputDuplThunks<_D3DKMT_OUTPUTDUPL_GET_POINTER_SHAPE_DATA*___ptr64>::RunForAdapter
-OutputDuplThunks<_DXGKARG_SETPOINTERPOSITION_const*___ptr64>::RunForAdapter
-SetPointerPositionForDisplaySource
-SubmitSignalSyncObjectsToHwQueue
-SubmitWaitForSyncObjectsFromGpu
-WaitForSynchronizationObjectFromCpu
-WaitForSynchronizationObjectFromGpu
+DXGGLOBAL::SubscribeWNFForCSAccounting
+DXGGLOBAL::~DXGGLOBAL
+DpiCleanUpGlobalState
+DpiInitializeGlobalState
+DxgkUnload
+DxgkUnsubscribeWnfStateChangeWork
+LongPowerButtonHoldListener::Stop
```
