# CVE-2026-119962 — Vid.sys patch diff

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

## `VsmmPpmIoctlCreate`  (modified)

```diff
--- VsmmPpmIoctlCreate
+++ VsmmPpmIoctlCreate
@@ -1,203 +1,372 @@
 

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

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

+/* WARNING: Removing unreachable block (ram,0x0001400aab6f) */

 

 uint VsmmPpmIoctlCreate(ulonglong param_1,longlong param_2,ulonglong param_3,ulonglong param_4,

                        uint *param_5,longlong *param_6,undefined8 *param_7)

 

 {

-  longlong lVar1;

-  longlong lVar2;

+  ulonglong *puVar1;

+  bool bVar2;

   longlong lVar3;

-  longlong lVar4;

-  undefined1 auVar5 [16];

-  undefined1 auVar6 [16];

-  uint uVar7;

-  uint uVar8;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  uint unaff_EBX;

+  char cVar4;

+  uint uVar5;

+  int iVar6;

+  longlong lVar7;

+  undefined8 *puVar8;

+  longlong *plVar9;

+  longlong *plVar10;

   longlong *plVar11;

-  char *unaff_RSI;

-  longlong *plVar12;

+  undefined8 uVar12;

   ulonglong uVar13;

-  longlong in_R10;

-  uint uVar14;

-  ulonglong unaff_R12;

-  int iVar15;

-  uint uVar16;

-  ulonglong unaff_R14;

-  ulonglong unaff_R15;

-  char in_stack_00000040;

-  int in_stack_00000044;

-  uint in_stack_00000048;

-  uint in_stack_0000004c;

-  longlong in_stack_00000050;

-  uint in_stack_00000058;

-  longlong in_stack_00000060;

-  undefined4 uStack0000000000000068;

-  undefined4 uStack000000000000006c;

-  undefined4 uStack0000000000000070;

-  undefined4 uStack0000000000000074;

+  ulonglong uVar14;

+  longlong *plVar15;

+  ulonglong uVar16;

+  uint uVar17;

+  ulonglong local_res20;

+  undefined8 *local_80;

+  uint local_78 [2];

+  undefined8 *local_70;

+  longlong local_68;

+  uint local_60;

+  longlong local_58;

+  longlong *local_50;

+  longlong *local_48;

   

-  do {

-    auVar5._8_8_ = 0;

-    auVar5._0_8_ = param_4;

-    auVar6._8_8_ = param_2;

-    auVar6._0_8_ = unaff_RSI + (param_4 - param_3) + -1;

-    uVar9 = SUB168(auVar6 / auVar5,0);

-    if (uVar9 < (ulonglong)(unaff_RSI + (unaff_R15 - param_3)) / param_4) {

-      RtlInterlockedSetBitRunEx

-                (in_R10 + 0x1a8,uVar9,

-                 (ulonglong)(unaff_RSI + (unaff_R15 - param_3)) / param_4 - uVar9);

-    }

-LAB_0:

-    do {

-      do {

-        do {

-          uVar8 = in_stack_00000048;

-          uVar16 = (int)unaff_R14 + 1;

-          unaff_R14 = (ulonglong)uVar16;

-          uVar14 = (uint)unaff_R12;

-          if (in_stack_00000058 <= uVar16) {

-            if (uVar14 == 0) goto LAB_1;

-            uVar9 = unaff_R12 & 0xffffffff;

-            uVar16 = (**(code **)(DAT_2 + 0x30))

-                               (&stack0x00000180,&stack0x00000100,unaff_R12 & 0xffffffff,

-                                in_stack_00000048,in_stack_00000044);

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

-              if (((uVar8 & 0x20) == 0) && (uVar14 != 0)) {

-                plVar11 = (longlong *)&stack0x00000080;

-                plVar12 = (longlong *)&stack0x00000180;

-                do {

-                  uStack0000000000000068 = (undefined4)*plVar12;

-                  uStack000000000000006c = *(undefined4 *)((longlong)plVar12 + 4);

-                  uStack0000000000000070 = (undefined4)plVar12[1];

-                  uStack0000000000000074 = *(undefined4 *)((longlong)plVar12 + 0xc);

-                  lVar1 = *(longlong *)(*plVar11 + 0x180);

-                  if ((*(uint *)(lVar1 + 0x14) & 8) != 0) {

-                    uVar10 = *(ulonglong *)(*(longlong *)(lVar1 + 8) + 0x18);

-                    uVar8 = (uint)(uVar10 >> 0xd);

-                    if ((*(uint *)(lVar1 + 0x14) & 1) != 0) {

-                      uVar8 = (uint)(uVar10 >> 9);

-                    }

-                    if ((uVar8 & 0xf) != 0) {

-                      uVar13 = 1L << (sbyte)(uVar8 & 0xf);

-                      lVar2 = *(longlong *)(*plVar11 + 0x100);

-                      uVar10 = ((*plVar12 - lVar2) + -1 + uVar13) / uVar13;

-                      uVar13 = (ulonglong)((plVar12[1] - lVar2) + *plVar12) / uVar13;

-                      if (uVar10 < uVar13) {

-                        RtlInterlockedSetBitRunEx(lVar1 + 0x1a8,uVar10,uVar13 - uVar10);

+  plVar10 = (longlong *)0x0;

+  local_80 = (undefined8 *)0x0;

+  uVar17 = 0;

+  plVar15 = (longlong *)0x0;

+  local_68 = *(longlong *)(param_1 + 0xed0);

+  *param_6 = 0;

+  *param_7 = 0xffffffffffffffff;

+  if (param_4 - 1 < 0xfffff) {

+    plVar9 = plVar10;

+    if (*param_5 < 0x10) {

+      if (((byte)*param_5 & 10) == 10) {

+        uVar5 = 0xc000000d;

+        VidTraceErrorStatusInternal0

+                  ("VsmmPpmIoctlCreate","onecore\\vm\\vid\\sys\\vsmm\\vsmmppm.c",0xc4,0xc000000d);

+      }

+      else {

+        local_58 = PsGetCurrentProcess();

+        if ((*param_5 & 4) == 0) {

+          plVar9 = plVar15;

+          if (local_58 != *(longlong *)(param_1 + 0x3780)) goto LAB_0;

+LAB_1:

+          plVar15 = (longlong *)ExAllocatePool2(0x40);

+          local_48 = plVar15;

+          if (plVar15 == (longlong *)0x0) {

+            if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+              WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),10,

+                       &WPP_baade17853f739a66dbb3f34976c6adf_Traceguids,0x98);

+            }

+            uVar5 = 0xc000009a;

+          }

+          else {

+            uVar12 = 0;

+            memset(plVar15 + 3,0,0x40);

+            plVar9 = plVar15 + 8;

+            plVar15[9] = (longlong)plVar9;

+            *plVar9 = (longlong)plVar9;

+            *(undefined4 *)plVar15 = 0x206d7050;

+            plVar15[0xd] = param_4;

+            plVar15[0x10] = param_3;

+            plVar15[0xf] = 0;

+            *(uint *)(plVar15 + 0x12) = *param_5;

+            plVar15[0x11] = -1;

+            *(undefined4 *)(plVar15 + 0xe) = 0;

+            plVar9 = plVar15;

+            if (param_2 == -1) {

+              local_80 = (undefined8 *)VsmmGpaRangeLookupByPageNumberFast(param_1,uVar12,param_3,0);

+              if (((local_80 == (undefined8 *)0x0) || (*(int *)(local_80 + 0x24) != 0)) ||

+                 ((lVar7 = local_80[0x30], *(int *)(lVar7 + 0x20) != 0 ||

+                  (((local_80[0x22] - param_3) + 1 < param_4 ||

+                   (uVar13 = VidOpCtrlStart((uint *)(lVar7 + 0x48)), (char)uVar13 == '\0'))))))

+              goto LAB_0;

+              plVar15[0xc] = lVar7;

+              param_3 = param_3 - local_80[0x20];

+              plVar15[0x10] = param_3;

+            }

+            else {

+              lVar7 = VsmmMemoryBlockLookupByHandle(param_1,param_2,0,0);

+              plVar15[0xc] = lVar7;

+              if (lVar7 == 0) {

+                uVar5 = 0xc0370012;

+                goto LAB_2;

+              }

+            }

+            LOCK();

+            *(int *)(lVar7 + 0xac) = *(int *)(lVar7 + 0xac) + 1;

+            UNLOCK();

+            LOCK();

+            plVar11 = (longlong *)(*(longlong *)(param_1 + 0x5e8) + 0x380);

+            *plVar11 = *plVar11 + 1;

+            UNLOCK();

+            uVar13 = *(ulonglong *)(plVar15[0xc] + 0x30) - 1;

+            if ((((*(int *)(plVar15[0xc] + 0x20) != 0) || (uVar13 < param_3)) ||

+                (*(ulonglong *)(plVar15[0xc] + 0x30) < param_4)) ||

+               ((uVar13 - param_4) + 1 < param_3)) goto LAB_0;

+            uVar5 = *param_5;

+            if (((uVar5 & 2) != 0) && (*(int *)(plVar15[0xc] + 0xbc) == 1)) {

+              if ((*(uint *)(param_1 + 0x20) & 0x3000) == 0) {

+                uVar5 = 0xc0000022;

+                bVar2 = false;

+                goto LAB_3;

+              }

+              uVar5 = uVar5 & 0xfffffffd;

+              *param_5 = uVar5;

+            }

+            local_70 = (undefined8 *)plVar15[0xc];

+            bVar2 = false;

+            if ((*(uint *)((longlong)local_70 + 0x14) & 8) != 0) {

+              if (local_80 == (undefined8 *)0x0) {

+                local_78[0] = 0x7fffffff;

+                plVar9 = plVar10;

+                if (*(int *)(local_70 + 0x15) != 0) {

+                  plVar9 = (longlong *)VsmmGpaRangeListAcquireReadOnly(param_1,local_78);

+                  puVar8 = local_70;

+                  local_60 = *(uint *)((longlong)plVar9 + 0x14);

+                  local_50 = plVar9;

+                  for (plVar11 = plVar10; (uint)plVar11 < local_60;

+                      plVar11 = (longlong *)(ulonglong)((uint)plVar11 + 1)) {

+                    local_70 = *(undefined8 **)(plVar9[1] + (longlong)plVar11 * 8);

+                    if ((*(int *)(local_70 + 0x24) == 0) && ((undefined8 *)local_70[0x30] == puVar8)

+                       ) {

+                      if (((param_3 == 0xffffffffffffffff) ||

+                          (((ulonglong)local_70[0x31] <= param_3 &&

+                           (param_3 <=

+                            (ulonglong)((local_70[0x21] - local_70[0x20]) + local_70[0x31]))))) &&

+                         (cVar4 = VsmmGpaRangeReference((longlong)local_70), plVar9 = local_50,

+                         cVar4 != '\0')) {

+                        local_80 = local_70;

+                        uVar5 = uVar17;

+                        goto LAB_4;

                       }

                     }

                   }

-                  plVar12 = plVar12 + 2;

-                  plVar11 = plVar11 + 1;

-                  uVar9 = uVar9 - 1;

-                } while (uVar9 != 0);

-              }

-LAB_1:

-              uVar16 = 0;

-            }

+                }

+                uVar5 = 0xc0000225;

+LAB_4:

+                if (plVar9 != (longlong *)0x0) {

+                  VsmmGpaRangeListReleaseReadOnly(plVar9,(ulonglong)local_78[0]);

+                }

+                if ((int)uVar5 < 0) goto LAB_2;

+              }

+              LOCK();

+              *(longlong *)(param_1 + 0x31a0) = *(longlong *)(param_1 + 0x31a0) + 1;

+              UNLOCK();

+              uVar5 = VsmmVaGpaRangeAccessPreparePages

+                                ((longlong)local_80,(char *)(local_80[0x20] + param_3),param_4,

+                                 *param_5 & 1,(char *)0x0);

+              if ((int)uVar5 < 0) {

+                bVar2 = true;

+                goto LAB_3;

+              }

+              lVar7 = plVar15[0xc];

+              if ((*(char *)(*(longlong *)(lVar7 + 8) + 0x38f9) != '\0') &&

+                 ((*(uint *)(lVar7 + 0x14) & 1) != 0)) {

+                VsmmMemoryBlockTrackPageRangeAccess(lVar7,param_3,param_4,(byte)*param_5 & 1);

+              }

+              puVar8 = (undefined8 *)ExAllocatePool2(0x40,(int)param_4 * 8 + 0x30);

+              local_70 = puVar8;

+              if (puVar8 == (undefined8 *)0x0) {

+                uVar5 = 0xc000009a;

+                bVar2 = true;

+                goto LAB_3;

+              }

+              *puVar8 = 0;

+              *(short *)(puVar8 + 1) = ((short)(param_4 * 0x1000 + 0xfff >> 0xc) + 6) * 8;

+              puVar8[4] = 0;

+              *(undefined4 *)((longlong)puVar8 + 0x2c) = 0;

+              *(int *)(puVar8 + 5) = (int)(param_4 * 0x1000);

+              *(undefined2 *)((longlong)puVar8 + 10) = 2;

+              *(undefined2 *)((longlong)puVar8 + 10) = 0;

+              puVar8[4] = param_3 * 0x1000 + *(longlong *)(plVar15[0xc] + 0x310);

+              MmProbeAndLockProcessPages(puVar8,*(undefined8 *)(param_1 + 0x37d0),1,*param_5 & 1);

+              plVar15[0xb] = (longlong)puVar8;

+              LOCK();

+              *(longlong *)(param_1 + 0x31a0) = *(longlong *)(param_1 + 0x31a0) + -1;

+              UNLOCK();

+              puVar8 = (undefined8 *)ExAllocatePool2(0x40,(int)param_4 * 8 + 0x30);

+              if (puVar8 == (undefined8 *)0x0) {

+                uVar5 = 0xc000009a;

+                bVar2 = false;

+                goto LAB_3;

+              }

+              *puVar8 = 0;

+              *(short *)(puVar8 + 1) = ((short)(param_4 * 0x1000 + 0xfff >> 0xc) + 6) * 8;

+              puVar8[4] = 0;

+              *(undefined4 *)((longlong)puVar8 + 0x2c) = 0;

+              *(int *)(puVar8 + 5) = (int)(param_4 * 0x1000);

+              *(undefined2 *)((longlong)puVar8 + 10) = 2;

+              memmove(puVar8 + 6,(void *)(plVar15[0xb] + 0x30),param_4 * 8);

+              lVar7 = local_58;

+              plVar15[10] = (longlong)puVar8;

+              plVar9 = VidClientBufferShare

+                                 (plVar15 + 3,0,plVar15 + 3,~*(uint *)(plVar15 + 0x12) & 1,local_58,

+                                  (longlong *)0x0);

+              uVar5 = (uint)plVar9;

+              if ((int)uVar5 < 0) goto LAB_3;

+LAB_5:

+              lVar3 = local_68;

+              *param_6 = plVar15[7];

+              VidLockAcquireExclusive(local_68);

+              if ((*param_5 & 4) == 0) {

+LAB_6:

+                uVar5 = uVar17;

+                if (**(int **)(lVar3 + 8) == 0) {

+                  uVar12 = VidHandleTablepReallocateTable

+                                     ((undefined8 *)(lVar3 + 8),*(int *)(lVar3 + 0x10) + 1);

+                  uVar5 = (uint)uVar12;

+                }

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

+                  puVar1 = *(ulonglong **)(lVar3 + 8);

+                  plVar9 = plVar10;

+                  if (*puVar1 != 0) {

+                    plVar9 = (longlong *)(*puVar1 & 0xffffffff);

+                    *puVar1 = puVar1[(longlong)plVar9];

+                  }

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

+                    puVar1[(longlong)plVar9] = (ulonglong)plVar15;

+                    plVar10 = plVar9;

+                  }

+                  *param_7 = plVar10;

+                  *(int *)(lVar3 + 0x20) = *(int *)(lVar3 + 0x20) + 1;

+                  uVar5 = uVar17;

+                }

+              }

+              else {

+                for (puVar8 = *(undefined8 **)(lVar3 + 0x28); puVar8 != (undefined8 *)(lVar3 + 0x28)

+                    ; puVar8 = (undefined8 *)*puVar8) {

+                  if (puVar8[2] == lVar7) goto LAB_6;

+                }

+                uVar5 = 0xc000000d;

+              }

+              VidLockRelease(lVar3);

+              bVar2 = false;

+              if ((-1 < (int)uVar5) && ((*param_5 & 2) != 0)) {

+                LOCK();

+                plVar10 = (longlong *)(*(longlong *)(param_1 + 0x5e8) + 0x388);

+                *plVar10 = *plVar10 + 1;

+                UNLOCK();

+              }

+              goto LAB_3;

+            }

+            uVar5 = -(uint)((uVar5 & 1) != 0) & 9;

+            *(uint *)(plVar15 + 0xe) = uVar5;

+            if ((*param_5 & 2) != 0) {

+              uVar5 = uVar5 | 2;

+              *(uint *)(plVar15 + 0xe) = uVar5;

+            }

+            uVar13 = param_3;

+            if ((*param_5 & 8) != 0) {

+              *(uint *)(plVar15 + 0xe) = uVar5 | 0x10;

+            }

+            for (; lVar7 = plVar15[0xc], uVar13 < param_3 + param_4; uVar13 = uVar13 + local_res20)

+            {

+              local_res20 = 1;

+              uVar16 = (ulonglong)*(uint *)(plVar15 + 0xe);

+              uVar14 = uVar13;

+              uVar5 = VsmmMbpLockAcquire(lVar7,uVar13,*(uint *)(plVar15 + 0xe));

+              if ((uVar5 == 0xc0000184) &&

+                 (lVar7 = plVar15[0xc], (*(uint *)(lVar7 + 0x14) & 1) != 0)) {

+                local_res20 = (param_3 - uVar13) + param_4;

+                uVar14 = uVar13;

+                uVar16 = local_res20;

+                uVar5 = VsmmDmSlpCommitAndWait

+                                  (lVar7,uVar13,local_res20,lVar7,*param_5 & 1,1,

+                                   *(uint *)(plVar15 + 0xe));

+              }

+              if ((int)uVar5 < 0) {

+                if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+                    ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+                   (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+                  WPP_SF_id(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar14,uVar16,uVar13);

+                }

+                goto LAB_2;

+              }

+              plVar15[0xf] = plVar15[0xf] + local_res20;

+            }

+            if ((*(char *)(*(longlong *)(lVar7 + 8) + 0x38f9) != '\0') &&

+               ((*(uint *)(lVar7 + 0x14) & 1) != 0)) {

+              VsmmMemoryBlockTrackPageRangeAccess(lVar7,param_3,param_4,(byte)*param_5 & 1);

+            }

+            uVar5 = uVar17;

+            if ((*param_5 & 10) == 0) {

+              uVar5 = (*param_5 & 1) * 2 + 1;

+            }

+            iVar6 = VsmmHostAccessAcquireMbpRange((undefined8 *)plVar15[0xc],param_3,param_4,uVar5);

+            if (iVar6 < 0) {

+              uVar5 = 0xc037002a;

+              bVar2 = false;

+              goto LAB_3;

+            }

+            uVar13 = VsmmSendClientNotificationsForMbpRange

+                               (param_1,plVar15[0xc],param_3,param_4,(*param_5 & 1) + 2,0xffff,0);

+            uVar5 = (uint)uVar13;

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

+              lVar7 = plVar15[0xc];

+              if ((*(char *)(*(longlong *)(lVar7 + 8) + 0x38f9) != '\0') &&

+                 ((*(uint *)(lVar7 + 0x14) & 1) != 0)) {

+                VsmmMemoryBlockTrackPageRangeAccess(lVar7,param_3,param_4,(byte)*param_5 & 1);

+              }

+              lVar7 = local_58;

+              plVar9 = VsmmPpmpUserModeRegionCreate((longlong)plVar15,local_58);

+              uVar5 = (uint)plVar9;

+              if (-1 < (int)uVar5) goto LAB_5;

+            }

+          }

+        }

+        else if (local_58 == *(longlong *)(param_1 + 0x3780)) {

+          uVar5 = 0xc000000d;

+          VidTraceErrorStatusInternal0

+                    ("VsmmPpmIoctlCreate","onecore\\vm\\vid\\sys\\vsmm\\vsmmppm.c",0xd3,0xc000000d);

+        }

+        else {

+          VidLockAcquireShared(local_68);

+          for (puVar8 = *(undefined8 **)(local_68 + 0x28); puVar8 != (undefined8 *)(local_68 + 0x28)

+              ; puVar8 = (undefined8 *)*puVar8) {

+            uVar5 = uVar17;

+            if (puVar8[2] == local_58) goto LAB_7;

+          }

+          uVar5 = 0xc000000d;

+LAB_7:

+          VidLockRelease(local_68);

+          if (-1 < (int)uVar5) goto LAB_1;

+        }

+      }

+    }

+    else {

+LAB_0:

+      plVar15 = plVar9;

+      uVar5 = 0xc000000d;

+    }

+  }

+  else {

+    uVar5 = 0xc000000d;

+    VidTraceErrorStatusInternal0

+              ("VsmmPpmIoctlCreate","onecore\\vm\\vid\\sys\\vsmm\\vsmmppm.c",0xb7,0xc000000d);

+  }

+LAB_2:

+  bVar2 = false;

 LAB_3:

-            LOCK();

-            *(longlong *)(in_stack_00000050 + 0x31a0) =

-                 *(longlong *)(in_stack_00000050 + 0x31a0) + -1;

-            UNLOCK();

-            return uVar16;

-          }

-          in_stack_00000040 = '\0';

-          lVar1 = *(longlong *)(in_stack_00000060 + unaff_R14 * 0x18);

-          unaff_RSI = *(char **)(in_stack_00000060 + 8 + unaff_R14 * 0x18);

-          unaff_R15 = *(ulonglong *)(in_stack_00000060 + 0x10 + unaff_R14 * 0x18);

-          lVar2 = *(longlong *)(lVar1 + 0x188);

-          lVar3 = *(longlong *)(lVar1 + 0x100);

-          lVar4 = *(longlong *)(*(longlong *)(lVar1 + 0x180) + 0x310);

-          uVar8 = (*(uint *)(lVar1 + 0x124) & 0x10 | 4) >> 2;

-          iVar15 = 0;

-          if ((*(uint *)(lVar1 + 0x124) >> 0xd & 1) == 0) {

-            iVar15 = 0;

-            if ((unaff_EBX & 4) == 0) {

-              if ((unaff_EBX & 2) != 0) {

-                iVar15 = 2;

-              }

-            }

-            else {

-              uVar8 = uVar8 | 2;

-            }

-          }

-          uVar16 = uVar8 | 0x80;

-          if ((*(byte *)(lVar1 + 0x124) & 1) == 0) {

-            uVar16 = uVar8;

-          }

-          uVar8 = uVar16 | 8;

-          if ((unaff_EBX & 1) == 0) {

-            uVar8 = uVar16;

-          }

-          uVar16 = (unaff_EBX & 1) * 0x40 + 6;

-          uVar7 = uVar8 | 0x20;

-          if ((unaff_EBX >> 3 & 1) == 0) {

-            uVar7 = uVar8;

-          }

-          uVar8 = uVar16 | 0x10;

-          if ((unaff_EBX >> 3 & 1) == 0) {

-            uVar8 = uVar16;

-          }

-          in_stack_0000004c = uVar7 | 0x10;

-          if ((unaff_EBX >> 4 & 1) == 0) {

-            in_stack_0000004c = uVar7;

-          }

-          uVar16 = uVar8 | 0x20;

-          if ((unaff_EBX >> 4 & 1) == 0) {

-            uVar16 = uVar8;

-          }

-          uVar8 = uVar16 | 1;

-          if ((in_stack_0000004c & 2) == 0 && iVar15 == 0) {

-            uVar8 = uVar16;

-          }

-          uVar16 = uVar8 | 0x80;

-          if ((unaff_EBX & 0x20) == 0) {

-            uVar16 = uVar8;

-          }

-          uVar16 = VsmmVaGpaRangeAccessPreparePages

-                             (lVar1,unaff_RSI,unaff_R15,uVar16,&stack0x00000040);

-          if ((int)uVar16 < 0) goto LAB_3;

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

-            if ((((in_stack_00000048 != in_stack_0000004c) || (in_stack_00000044 != iVar15)) ||

-                (uVar14 == 0x10)) && (uVar14 != 0)) {

-              uVar16 = (**(code **)(DAT_2 + 0x30))

-                                 (&stack0x00000180,&stack0x00000100,unaff_R12 & 0xffffffff,

-                                  in_stack_00000048,in_stack_00000044);

-              if ((int)uVar16 < 0) goto LAB_3;

-              VsmmNtSlatpHotPagesHintUpdateClusterBitmap

-                        ((longlong *)&stack0x00000180,(longlong *)&stack0x00000080,uVar14,

-                         (ulonglong)in_stack_00000048);

-              unaff_R12 = 0;

-            }

-            uVar9 = unaff_R12 & 0xffffffff;

-            *(longlong *)(&stack0x00000080 + unaff_R12 * 8) = lVar1;

-            *(ulonglong *)(&stack0x00000100 + unaff_R12 * 8) =

-                 (ulonglong)((longlong)(unaff_RSI + (lVar2 - lVar3)) * 0x1000 + lVar4) >> 0xc;

-            unaff_R12 = (ulonglong)((int)unaff_R12 + 1);

-            *(char **)(&stack0x00000180 + uVar9 * 0x10) = unaff_RSI;

-            *(ulonglong *)(&stack0x00000188 + uVar9 * 0x10) = unaff_R15;

-            in_stack_00000048 = in_stack_0000004c;

-            in_stack_00000044 = iVar15;

-            goto LAB_0;

-          }

-        } while ((in_stack_0000004c & 0x20) != 0);

-        in_R10 = *(longlong *)(lVar1 + 0x180);

-      } while ((*(uint *)(in_R10 + 0x14) & 8) == 0);

-      uVar9 = *(ulonglong *)(*(longlong *)(in_R10 + 8) + 0x18);

-      uVar8 = (uint)(uVar9 >> 0xd);

-      if ((*(uint *)(in_R10 + 0x14) & 1) != 0) {

-        uVar8 = (uint)(uVar9 >> 9);

-      }

-    } while ((uVar8 & 0xf) == 0);

-    param_3 = *(ulonglong *)(lVar1 + 0x100);

-    param_2 = 0;

-    param_1._0_1_ = (sbyte)(uVar8 & 0xf);

-    param_4 = 1L << (sbyte)param_1;

-  } while( true );

+  if (bVar2) {

+    LOCK();

+    *(longlong *)(param_1 + 0x31a0) = *(longlong *)(param_1 + 0x31a0) + -1;

+    UNLOCK();

+  }

+  if ((int)uVar5 < 0) {

+    if (plVar15 != (longlong *)0x0) {

+      VsmmPpmpDestroy(param_1,(longlong)plVar15);

+    }

+    *param_6 = 0;

+    *param_7 = 0xffffffffffffffff;

+  }

+  if (local_80 != (undefined8 *)0x0) {

+    VsmmGpaRangeRelease(local_80,(longlong)local_80,'\0');

+  }

+  return uVar5;

 }
```

## `VsmmHandleMemoryIntercept`  (modified)

```diff
--- VsmmHandleMemoryIntercept
+++ VsmmHandleMemoryIntercept
@@ -1,10 +1,584 @@
 

-/* 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 */

 

 undefined8 VsmmHandleMemoryIntercept(longlong *param_1)

 

 {

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

-  halt_baddata();

+  longlong *plVar1;

+  byte bVar2;

+  undefined2 uVar3;

+  uint uVar4;

+  longlong lVar5;

+  ulonglong uVar6;

+  longlong lVar7;

+  code *pcVar8;

+  undefined4 uVar9;

+  undefined4 uVar10;

+  int iVar11;

+  ulonglong uVar12;

+  undefined8 uVar13;

+  ulonglong uVar14;

+  int *piVar15;

+  int iVar16;

+  uint uVar17;

+  char *pcVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  longlong *plVar21;

+  longlong lVar22;

+  ulonglong uVar23;

+  ushort uVar24;

+  char *pcVar25;

+  int iVar26;

+  longlong lVar27;

+  char cVar28;

+  uint uVar29;

+  ulonglong unaff_R13;

+  byte bVar30;

+  char *pcVar31;

+  bool bVar32;

+  ulonglong local_res10;

+  undefined8 uStack_150;

+  undefined1 auStack_148 [32];

+  ulonglong uStack_128;

+  longlong local_120 [5];

+  char local_f8 [8];

+  ulonglong local_f0 [2];

+  int local_e0 [2];

+  undefined8 local_d8;

+  undefined8 local_d0;

+  undefined8 uStack_c8;

+  undefined8 uStack_c0;

+  undefined4 local_b8;

+  undefined4 local_b4;

+  undefined8 local_b0;

+  ulonglong local_a8;

+  char *pcStack_a0;

+  ulonglong local_98;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined4 local_58;

+  undefined4 uStack_54;

+  undefined4 uStack_50;

+  undefined4 uStack_4c;

+  undefined4 local_48;

+  undefined4 uStack_44;

+  undefined4 uStack_40;

+  undefined4 uStack_3c;

+  ulonglong local_38;

+  

+  puVar20 = auStack_148;

+  local_38 = __security_cookie ^ (ulonglong)auStack_148;

+  lVar5 = *param_1;

+  pcVar31 = (char *)((ulonglong)param_1[0xf] >> 0xc);

+  local_f8[0] = *(undefined1 *)((longlong)param_1 + 0x45);

+  puVar19 = auStack_148;

+  if ((1 << ((byte)(*(uint *)(lVar5 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) goto LAB_0;

+LAB_1:

+  uVar17 = SystemReserved1[0x12]._4_4_ & 0x3fffffff;

+  *(ulonglong *)(puVar19 + 0x158) = unaff_R13;

+  lVar22 = (ulonglong)uVar17 * 0x40;

+  while( true ) {

+    uVar4 = *(uint *)(lVar5 + 0xda0);

+    lVar27 = *(longlong *)(lVar5 + 0xd90 + (ulonglong)uVar4 * 8);

+    LOCK();

+    piVar15 = (int *)(lVar22 + lVar27);

+    *piVar15 = *piVar15 + 1;

+    UNLOCK();

+    if (*piVar15 == 0) break;

+    if (uVar4 == *(uint *)(lVar5 + 0xda0)) {

+      plVar21 = *(longlong **)(lVar5 + 0xea0);

+      if ((*(byte *)(lVar5 + 0x10) & 1) != 0) {

+        lVar22 = *plVar21;

+        uVar23 = 0;

+        uVar29 = *(uint *)((longlong)plVar21 + 0x14);

+        *(char **)(puVar19 + 0x58) = pcVar31;

+        pcVar18 = pcVar31;

+        if (((1 << ((byte)(*(uint *)(lVar22 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+           (pcVar25 = *(char **)(lVar22 + 0x3df0), pcVar25 <= pcVar31)) {

+          *(char **)(puVar19 + 0x58) = pcVar31 + -(longlong)pcVar25;

+          pcVar18 = pcVar31 + -(longlong)pcVar25;

+        }

+        goto LAB_2;

+      }

+      uVar14 = 0;

+      iVar26 = (int)plVar21[3] + -1;

+      uVar12 = uVar14;

+      pcVar18 = pcVar31;

+      if (((1 << ((byte)(*(uint *)(*plVar21 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+         (pcVar25 = *(char **)(*plVar21 + 0x3df0), uVar12 = 0, pcVar25 <= pcVar31)) {

+        pcVar18 = pcVar31 + -(longlong)pcVar25;

+      }

+      goto LAB_3;

+    }

+    LOCK();

+    piVar15 = (int *)(lVar22 + lVar27);

+    iVar26 = *piVar15;

+    *piVar15 = *piVar15 + -1;

+    UNLOCK();

+    if (iVar26 == 0) break;

+    if ((iVar26 == 1) && ((*(uint *)(lVar5 + 0xda4) & 1) != 0)) {

+      *(undefined8 *)(puVar19 + -8) = 0x140025621;

+      ExUnblockOnAddressPushLockEx(lVar5 + 0xda8,0);

+    }

+  }

+  goto LAB_4;

+LAB_3:

+  iVar16 = (int)uVar12;

+  uVar23 = uVar14;

+  if (iVar16 <= iVar26) {

+    iVar16 = iVar16 + (iVar26 - iVar16) / 2;

+    uVar6 = *(ulonglong *)(plVar21[1] + (longlong)iVar16 * 8);

+    if (pcVar18 < *(char **)(uVar6 + 0x100)) {

+      iVar26 = iVar16 + -1;

+    }

+    else {

+      if (pcVar18 <= *(char **)(uVar6 + 0x108)) {

+        uVar23 = 0;

+        if (iVar16 != -1) {

+          uVar23 = uVar6;

+        }

+        goto LAB_5;

+      }

+      uVar12 = (ulonglong)(iVar16 + 1);

+    }

+    goto LAB_3;

+  }

+LAB_5:

+  if (uVar23 != 0) {

+    *(undefined8 *)(puVar19 + -8) = 0x1400252be;

+    uVar12 = VidOpCtrlStart((uint *)(uVar23 + 8));

+    if (((char)uVar12 != '\0') && (uVar23 != 0)) goto LAB_6;

+  }

+  iVar26 = (int)plVar21[3];

+  iVar16 = iVar26 + -1 + *(int *)((longlong)plVar21 + 0x1c);

+  pcVar18 = pcVar31;

+  if (((1 << ((byte)(*(uint *)(*plVar21 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+     (pcVar25 = *(char **)(*plVar21 + 0x3df0), pcVar25 <= pcVar31)) {

+    pcVar18 = pcVar31 + -(longlong)pcVar25;

+  }

+  while (uVar23 = uVar14, iVar26 <= iVar16) {

+    iVar11 = (iVar16 - iVar26) / 2 + iVar26;

+    uVar12 = *(ulonglong *)(plVar21[1] + (longlong)iVar11 * 8);

+    if (pcVar18 < *(char **)(uVar12 + 0x100)) {

+      iVar16 = iVar11 + -1;

+    }

+    else {

+      if (pcVar18 <= *(char **)(uVar12 + 0x108)) {

+        if (iVar11 != -1) {

+          uVar23 = uVar12;

+        }

+        break;

+      }

+      iVar26 = iVar11 + 1;

+    }

+  }

+  if (uVar23 != 0) {

+    *(undefined8 *)(puVar19 + -8) = 0x140025120;

+    uVar12 = VidOpCtrlStart((uint *)(uVar23 + 8));

+    if ((char)uVar12 == '\0') {

+      uVar23 = uVar14;

+    }

+  }

+  goto LAB_6;

+LAB_2:

+  if (uVar29 != 0) {

+    uVar29 = uVar29 - 1;

+    lVar22 = *(longlong *)(plVar21[1] + (ulonglong)uVar29 * 8);

+    *(longlong *)(puVar19 + 0x60) = lVar22;

+    if ((*(char **)(lVar22 + 0x100) <= pcVar18) && (pcVar18 <= *(char **)(lVar22 + 0x108))) {

+      *(undefined8 *)(puVar19 + -8) = 0x1400255c6;

+      uVar12 = VidOpCtrlStart((uint *)(lVar22 + 8));

+      if ((char)uVar12 != '\0') {

+        uVar23 = *(ulonglong *)(puVar19 + 0x60);

+        goto LAB_6;

+      }

+      pcVar18 = *(char **)(puVar19 + 0x58);

+    }

+    goto LAB_2;

+  }

+LAB_6:

+  unaff_R13 = 0;

+  lVar22 = *plVar21;

+  piVar15 = (int *)((ulonglong)uVar17 * 0x40 +

+                   *(longlong *)(lVar22 + 0xd90 + (ulonglong)(uVar4 & 1) * 8));

+  LOCK();

+  iVar26 = *piVar15;

+  *piVar15 = *piVar15 + -1;

+  UNLOCK();

+  if (iVar26 == 0) {

+LAB_4:

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

+    (*pcVar8)(0xe);

+    puVar20 = puVar19 + 8;

+LAB_0:

+    puVar19 = puVar20;

+    if (*(char **)(lVar5 + 0x3df0) <= pcVar31) {

+      pcVar31 = pcVar31 + -(longlong)*(char **)(lVar5 + 0x3df0);

+    }

+    goto LAB_1;

+  }

+  if ((iVar26 == 1) && ((*(uint *)(lVar22 + 0xda4) & 1) != 0)) {

+    lVar27 = lVar22 + 0xda8;

+    lVar22 = 0;

+    *(undefined8 *)(puVar19 + -8) = 0x140025178;

+    ExUnblockOnAddressPushLockEx(lVar27);

+  }

+  iVar26 = 0;

+  if ((uVar23 == 0) || (*(int *)(uVar23 + 0x120) == 1)) {

+    iVar16 = 2;

+    iVar26 = 2;

+    if ((*(byte *)(*param_1 + 0x10) & 0x20) == 0) {

+      if (uVar23 != 0) goto LAB_7;

+      goto LAB_8;

+    }

+    if (uVar23 != 0) goto LAB_7;

+    if ((*(ushort *)((longlong)param_1 + 0x46) & 0x780) == 0) {

+      lVar22 = param_1[1];

+      uVar13 = *(undefined8 *)(lVar5 + 0x288);

+      puVar19[0x72] = *(undefined1 *)((longlong)param_1 + 0x45);

+      uStack_c8 = param_1[0xf];

+      *(undefined4 *)(puVar19 + 0x73) = 0;

+      puVar19[0x73] = 0;

+      *(undefined8 **)(puVar19 + 0x30) = &local_b0;

+      *(undefined4 **)(puVar19 + 0x28) = &local_58;

+      puVar19[0x77] = 0;

+      uStack_c0 = 0;

+      uVar9 = (undefined4)uStack_c8;

+      uVar10 = uStack_c8._4_4_;

+      *(undefined2 *)(puVar19 + 0x70) = 0x203;

+      *(undefined8 *)(puVar19 + 0x78) = 0;

+      *(undefined4 **)(puVar19 + 0x20) = &local_b8;

+      local_b0 = 0;

+      local_b8 = 0x10004;

+      local_b4 = 0x10005;

+      local_48 = uVar9;

+      uStack_44 = uVar10;

+      uStack_40 = 0;

+      uStack_3c = 0;

+      local_58 = *(undefined4 *)(puVar19 + 0x70);

+      uStack_54 = *(undefined4 *)(puVar19 + 0x74);

+      uStack_50 = *(undefined4 *)(puVar19 + 0x78);

+      uStack_4c = *(undefined4 *)(puVar19 + 0x7c);

+      *(undefined8 *)(puVar19 + -8) = 0x140025a48;

+      WinHvSetVpRegisters(uVar13,(int)lVar22,0x10,2);

+      goto LAB_9;

+    }

+LAB_10:

+    bVar30 = *(byte *)((longlong)param_1 + 0x6d) >> 1 & 1;

+    if (bVar30 == 0) {

+      *(undefined8 *)(puVar19 + 0x60) = 0;

+      puVar19[0x50] = 0;

+      uVar12 = unaff_R13;

+    }

+    else {

+      uVar12 = param_1[0xf];

+      *(longlong *)(puVar19 + 0x60) = param_1[0xe];

+      puVar19[0x50] = *(undefined1 *)((longlong)param_1 + 0x45);

+    }

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

+    bVar2 = *(byte *)((longlong)param_1 + 0x6c);

+    uVar3 = *(undefined2 *)((longlong)param_1 + 0x46);

+    lVar5 = *(longlong *)(*param_1 + 0xab0);

+    puVar19[0x51] = bVar2;

+    plVar21 = (longlong *)(lVar5 + (ulonglong)uVar17 * 0x980 + 0x7b0);

+    *(uint *)(plVar21 + 5) = *(uint *)(plVar21 + 5) | 1;

+    *(undefined4 *)(plVar21 + 4) = 0x1000004;

+    *(undefined4 *)((longlong)plVar21 + 0x24) = 0x1000000;

+    plVar21[7] = 0;

+    *(int *)plVar21[0xd] = (int)plVar21[4];

+    if ((*(uint *)(plVar21 + 4) & 0xffffff) == 1) {

+      *(uint *)plVar21[0xd] = *(uint *)plVar21[0xd] & 0xfeffffff;

+    }

+    *(undefined4 *)(plVar21[0xd] + 0x10) = *(undefined4 *)((longlong)plVar21 + 0x2c);

+    *(undefined8 *)(plVar21[0xd] + 8) = 0;

+    uVar14 = (ulonglong)(*(uint *)(plVar21 + 4) & 0xffffff);

+    if (0x11 < (*(uint *)(plVar21 + 4) & 0xffffff)) {

+      uVar14 = unaff_R13;

+    }

+    *(undefined4 *)(plVar21[0xd] + 4) = *(undefined4 *)(&DAT_11 + uVar14 * 0xc);

+    uVar14 = (ulonglong)(*(uint *)(plVar21 + 4) & 0xffffff);

+    if (0x11 < (*(uint *)(plVar21 + 4) & 0xffffff)) {

+      uVar14 = unaff_R13;

+    }

+    *(undefined4 *)(plVar21[0xd] + 0x144) = *(undefined4 *)(&DAT_12 + uVar14 * 0xc);

+    lVar5 = plVar21[0xd];

+    *(undefined8 *)(puVar19 + -8) = 0x140025495;

+    memmove((void *)(lVar5 + 0x22),param_1 + 0x10,(ulonglong)bVar2);

+    *(undefined1 *)(lVar5 + 0x32) = puVar19[0x51];

+    *(undefined1 *)(lVar5 + 0x35) = puVar19[0x50];

+    *(undefined8 *)(lVar5 + 0x38) = *(undefined8 *)(puVar19 + 0x60);

+    *(code **)(puVar19 + 0x70) = VidGenericInterceptReturnCallback;

+    *(undefined2 *)(lVar5 + 0x20) = uVar3;

+    *(undefined1 *)(lVar5 + 0x33) = 0;

+    *(byte *)(lVar5 + 0x34) = bVar30;

+    *(ulonglong *)(lVar5 + 0x40) = uVar12;

+    lVar5 = plVar21[0xd];

+    *(undefined8 *)(puVar19 + 0x78) = 0;

+    *(undefined8 *)(puVar19 + 0x80) = 0;

+    *(undefined4 *)((longlong)plVar21 + 0x24) = 0x1000001;

+    lVar22 = *(longlong *)(puVar19 + 0x78);

+    plVar21[10] = *(longlong *)(puVar19 + 0x70);

+    plVar21[0xb] = lVar22;

+    plVar21[0xc] = 0;

+    *(undefined4 *)(lVar5 + 0x140) = 0;

+    uVar12 = (ulonglong)(*(uint *)(plVar21 + 4) & 0xffffff);

+    if (0x11 < (*(uint *)(plVar21 + 4) & 0xffffff)) {

+      uVar12 = unaff_R13;

+    }

+    LOCK();

+    plVar1 = (longlong *)

+             (*(longlong *)(plVar21[6] + 0x5e8) +

+             (longlong)(*(int *)(&VidMessageInfoArray + uVar12 * 0xc) + 0x100) * 8);

+    *plVar1 = *plVar1 + 1;

+    UNLOCK();

+    lVar5 = plVar21[6];

+    if ((*(uint *)(plVar21 + 5) >> 1 & 1) == 0) {

+      *(undefined8 *)(puVar19 + -8) = 0x1400257df;

+      VidDispatchInterfaceAdd(lVar5 + 0x330,plVar21);

+    }

+    else {

+      uVar17 = *(uint *)((longlong)plVar21 + 0x2c);

+      lVar5 = *(longlong *)(lVar5 + 0xab0);

+      *(undefined8 *)(puVar19 + -8) = 0x14002555c;

+      VidMessageSlotAdd((ulonglong)uVar17 * 0x980 + lVar5 + 0x740);

+    }

+  }

+  else {

+    cVar28 = puVar19[0x50];

+    pcVar18 = pcVar31 + (*(longlong *)(uVar23 + 0x188) - *(longlong *)(uVar23 + 0x100));

+    lVar27 = *(longlong *)(uVar23 + 0x180);

+    *(longlong *)(puVar19 + 0x60) = lVar27;

+    if (cVar28 == '\x02') {

+      if ((*(uint *)(uVar23 + 0x124) & 0x10) == 0) {

+        uVar24 = 1;

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

+          uVar24 = 3;

+        }

+        goto LAB_13;

+      }

+LAB_14:

+      if ((*(uint *)(uVar23 + 0x124) & 4) != 0) {

+        LOCK();

+        plVar21 = (longlong *)(*(longlong *)(lVar5 + 0x5e8) + 0x5f8);

+        *plVar21 = *plVar21 + 1;

+        UNLOCK();

+        lVar22 = *param_1;

+        lVar27 = *(longlong *)(lVar22 + 0x3968);

+        if ((lVar27 != 0) && (*(longlong *)(lVar22 + 0x38b8) == 0)) {

+          *(undefined8 *)(puVar19 + -8) = 0x140025318;

+          uVar13 = VsmmEpfpFaultIsDeliverable(param_1);

+          lVar7 = *(longlong *)(lVar22 + 0x5e8);

+          if ((char)uVar13 == '\0') {

+            LOCK();

+            *(longlong *)(lVar7 + 0x600) = *(longlong *)(lVar7 + 0x600) + 1;

+            UNLOCK();

+          }

+          else if (*(longlong *)(lVar27 + 0x20) == 0) {

+            LOCK();

+            *(longlong *)(lVar7 + 0x608) = *(longlong *)(lVar7 + 0x608) + 1;

+            UNLOCK();

+          }

+          else {

+            cVar28 = *(char *)((longlong)param_1 + 0x45);

+            puVar19[0x51] = cVar28;

+            LOCK();

+            *(longlong *)(lVar7 + 0x610) = *(longlong *)(lVar7 + 0x610) + 1;

+            UNLOCK();

+            puVar19[0x20] = 1;

+            *(undefined8 *)(puVar19 + -8) = 0x14002535b;

+            uVar17 = VsmmGpaAccessVaFault(lVar22,uVar23,pcVar31,cVar28,puVar19[0x20]);

+            if (uVar17 != 0xc00000d8) {

+              if ((int)uVar17 < 0) {

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

+                lVar5 = *param_1;

+                *(undefined8 *)(puVar19 + -8) = 0x14002584c;

+                VsmmInjectSyntheticMachineCheckEventWithErrorDetail(lVar5,uVar17,6);

+              }

+              LOCK();

+              plVar21 = (longlong *)(*(longlong *)(lVar22 + 0x5e8) + 0x618);

+              *plVar21 = *plVar21 + 1;

+              UNLOCK();

+              goto LAB_7;

+            }

+            lVar27 = *param_1;

+            iVar16 = *(int *)(*(longlong *)(lVar27 + 0x3968) + 0x28);

+            do {

+              if (iVar16 + -1 < 0) {

+                LOCK();

+                plVar21 = (longlong *)(*(longlong *)(lVar22 + 0x5e8) + 0x620);

+                *plVar21 = *plVar21 + 1;

+                UNLOCK();

+                local_98 = 0;

+                local_98 = (ulonglong)(byte)puVar19[0x51];

+                local_a8 = uVar23;

+                pcStack_a0 = pcVar31;

+                *(undefined8 *)(puVar19 + -8) = 0x14002568e;

+                uVar13 = VsmmEpfpWorkerQueue(param_1,0,(longlong *)&local_a8,(longlong *)0x0);

+                if ((char)uVar13 != '\0') goto LAB_7;

+                break;

+              }

+              piVar15 = (int *)(*(longlong *)(lVar27 + 0x3968) + 0x28);

+              LOCK();

+              iVar11 = *piVar15;

+              bVar32 = iVar16 == iVar11;

+              if (bVar32) {

+                *piVar15 = iVar16 + -1;

+                iVar11 = iVar16;

+              }

+              iVar16 = iVar11;

+              UNLOCK();

+            } while (!bVar32);

+          }

+        }

+        puVar19[0x20] = 0;

+        *(undefined8 *)(puVar19 + -8) = 0x14002529a;

+        uVar17 = VsmmGpaAccessVaFault(lVar5,uVar23,pcVar31,puVar19[0x50],puVar19[0x20]);

+        if (uVar17 == 0xc0000225) goto LAB_15;

+        if (-1 < (int)uVar17) goto LAB_7;

+        uVar24 = 6;

+        goto LAB_13;

+      }

+      *(undefined4 *)(puVar19 + 0x68) = 0;

+      *(undefined8 **)(puVar19 + 0x28) = &local_88;

+      uVar12 = (ulonglong)(cVar28 == '\x01');

+      *(undefined1 **)(puVar19 + 0x20) = puVar19 + 0x68;

+      uVar17 = (uint)(cVar28 == '\x01');

+      *(uint *)(puVar19 + 0x58) = uVar17;

+      local_88 = 0;

+      uStack_80 = 0;

+      local_78 = 0;

+      uStack_70 = 0;

+      *(undefined8 *)(puVar19 + -8) = 0x140025890;

+      pcVar25 = pcVar18;

+      uVar13 = VsmmGpaAccessAnalyze

+                         (uVar23,lVar22,(longlong)pcVar18,uVar17,*(int **)(puVar19 + 0x20),

+                          *(undefined8 **)(puVar19 + 0x28));

+      iVar16 = *(int *)(puVar19 + 0x68);

+      cVar28 = (char)uVar13;

+      *(undefined8 *)(puVar19 + -8) = 0x1400258a5;

+      bVar32 = VsmmMbpNotificationIsNeeded((longlong)&local_88,iVar16);

+      if (!bVar32) {

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

+          lVar22 = *(longlong *)(puVar19 + 0x60);

+          if (*(int *)(lVar22 + 0x20) == 1) goto LAB_15;

+          uVar14 = (ulonglong)((uint)uStack_80 & 0xf);

+          if (uVar14 - 3 < 6) {

+            *(longlong **)(puVar19 + 0x48) = param_1;

+            *(code **)(puVar19 + 0x40) = VsmmDmSlpCompleteIntercept;

+            *(longlong *)(puVar19 + 0x38) = param_1[0x10c];

+            *(undefined4 *)(puVar19 + 0x20) = *(undefined4 *)(puVar19 + 0x58);

+            *(undefined8 *)(puVar19 + -8) = 0x140025975;

+            iVar26 = VsmmDmSlpCommitAndExecuteCallback

+                               (lVar22,pcVar18,pcVar25,uVar12,*(int *)(puVar19 + 0x20),

+                                *(undefined8 *)(puVar19 + 0x28),*(undefined8 *)(puVar19 + 0x30),

+                                *(void **)(puVar19 + 0x38),*(undefined8 *)(puVar19 + 0x40),

+                                *(undefined8 *)(puVar19 + 0x48));

+            if (iVar26 < 0) goto LAB_15;

+            iVar26 = 1;

+          }

+          else if (uVar14 == 9) {

+            *(undefined8 *)(puVar19 + -8) = 0x140025942;

+            VsmmMbpBlockOnSwapping(lVar22,(longlong)pcVar18,&local_88);

+          }

+          else {

+            if (uVar14 != 10) goto LAB_15;

+            lVar22 = param_1[0xf];

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

+            puVar19[0x20] = *(char *)((longlong)param_1 + 0x45) != '\x02';

+            *(undefined8 *)(puVar19 + -8) = 0x140025931;

+            VsmmWheaMcInjectPointOfConsumption(lVar5,uVar17,pcVar25,lVar22,puVar19[0x20]);

+          }

+        }

+        else {

+          if (*(char *)(VidDeviceExtension + 0x130) != '\0') goto LAB_7;

+LAB_15:

+          iVar26 = 2;

+        }

+        goto LAB_7;

+      }

+      if (*(int *)(*(longlong *)(puVar19 + 0x60) + 0x20) != 0) goto LAB_15;

+      *(int *)(puVar19 + 0x28) = iVar16;

+      *(char **)(puVar19 + 0x20) = pcVar18;

+      *(undefined8 *)(puVar19 + -8) = 0x1400258d4;

+      VsmmGpaAccessSendClientNotification

+                (uVar23,(longlong)&local_88,pcVar31,(longlong)param_1,

+                 *(undefined8 *)(puVar19 + 0x20),*(int *)(puVar19 + 0x28));

+    }

+    else {

+      if (cVar28 != '\x01') goto LAB_14;

+      if ((*(uint *)(uVar23 + 0x124) & 0x2000) == 0) {

+        if ((*(byte *)(*(longlong *)(lVar27 + 0x118) + ((longlong)pcVar18 >> 3)) >>

+             ((ulonglong)pcVar18 & 7) & 1) == 0) goto LAB_14;

+        uVar24 = 2;

+      }

+      else {

+        uVar24 = 5;

+      }

+LAB_13:

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

+      *(undefined8 *)(puVar19 + -8) = 0x14002582b;

+      VsmmInjectSyntheticMachineCheckEventWithErrorDetail(lVar5,uVar17,uVar24);

+LAB_7:

+      iVar16 = iVar26;

+      LOCK();

+      piVar15 = (int *)(uVar23 + 8);

+      iVar26 = *piVar15;

+      *piVar15 = *piVar15 + -1;

+      UNLOCK();

+      if ((iVar26 - 1U & 0x1fffffff) == 0x10000000) {

+        if ((iVar26 - 1U >> 0x1d & 1) != 0) {

+          *(undefined8 *)(puVar19 + -8) = 0x14002574d;

+          bVar30 = KeGetCurrentIrql();

+          if (bVar30 < 3) {

+            LOCK();

+            *(uint *)(uVar23 + 8) = *(uint *)(uVar23 + 8) ^ 0x20000000;

+            UNLOCK();

+            *(undefined8 *)(puVar19 + -8) = 0x14002576e;

+            KeSetEvent(uVar23 + 0x10,0,0);

+          }

+          else {

+            *(undefined8 *)(puVar19 + -8) = 0x140025797;

+            KeInsertQueueDpc(uVar23 + 0x28,0,0);

+          }

+        }

+        *(undefined8 *)(puVar19 + -8) = 0x14002570b;

+        bVar30 = KeGetCurrentIrql();

+        if (bVar30 < 3) {

+          if (bVar30 == 2) {

+            lVar5 = *(longlong *)(uVar23 + 0xb8);

+            *(undefined8 *)(puVar19 + -8) = 0x1400257be;

+            VidThreadPoolWorkItemQueue(lVar5,(longlong *)(uVar23 + 0xc0),0x1400a3200,0);

+          }

+          else {

+            pcVar8 = *(code **)(uVar23 + 0x68);

+            uVar13 = *(undefined8 *)(uVar23 + 0x70);

+            *(undefined8 *)(puVar19 + -8) = 0x140025727;

+            (*pcVar8)(uVar13);

+          }

+        }

+        else {

+          *(undefined8 *)(puVar19 + -8) = 0x14002573c;

+          KeInsertQueueDpc(uVar23 + 0x78,0,0);

+        }

+      }

+LAB_8:

+      if (iVar16 != 1) {

+        if ((iVar16 == 0) || (iVar16 != 2)) {

+LAB_9:

+          uVar13 = 0;

+          goto LAB_16;

+        }

+        goto LAB_10;

+      }

+    }

+  }

+  uVar13 = 1;

+LAB_16:

+  *(undefined8 *)(puVar19 + -8) = 0x1400251d5;

+  return uVar13;

 }
```

## `VsmmVsmpQueryMbpRangeVtlProtections`  (modified)

```diff
--- VsmmVsmpQueryMbpRangeVtlProtections
+++ VsmmVsmpQueryMbpRangeVtlProtections
@@ -1,134 +1,111 @@
 

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

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

 

 int VsmmVsmpQueryMbpRangeVtlProtections

-              (longlong *param_1,longlong *param_2,longlong param_3,uint param_4,undefined *param_5,

-              undefined8 param_6)

+              (longlong *param_1,longlong *param_2,longlong param_3,undefined4 param_4,

+              undefined *param_5,undefined8 param_6)

 

 {

-  uint uVar1;

-  int iVar2;

+  longlong *plVar1;

+  longlong lVar2;

   longlong *plVar3;

-  uint uVar4;

-  longlong lVar5;

-  longlong *plVar6;

-  ulonglong unaff_RBX;

-  longlong unaff_RBP;

-  int iVar7;

-  ulonglong unaff_RSI;

-  longlong *unaff_RDI;

+  longlong *plVar4;

+  char cVar5;

+  int iVar6;

+  longlong *plVar7;

   ulonglong uVar8;

-  longlong *unaff_R12;

-  ulonglong unaff_R13;

-  ulonglong unaff_R14;

-  ulonglong unaff_R15;

-  char in_stack_00000040;

-  byte in_stack_00000041;

-  uint in_stack_00000044;

-  uint in_stack_0000004c;

-  longlong *in_stack_00000050;

-  uint in_stack_00000058;

-  uint in_stack_00000060;

-  undefined4 in_stack_00000064;

-  ulonglong *in_stack_00000068;

-  ulonglong *in_stack_00000070;

+  longlong *plVar9;

+  ulonglong uVar10;

+  longlong *plVar11;

+  ulonglong uVar12;

+  uint local_res8 [2];

+  short local_res10 [4];

+  uint local_res18;

+  undefined4 local_res20;

+  undefined *local_58;

+  undefined8 local_50;

   

-  uVar8 = (ulonglong)param_4;

+  plVar1 = (longlong *)((longlong)param_2 + param_3);

+  lVar2 = param_1[1];

+  uVar10 = 0;

+  local_res10[0] = 0;

+  local_res10[1] = 0;

+  local_58 = param_5;

+  plVar11 = (longlong *)0x0;

+  local_50 = param_6;

+  plVar9 = param_1;

+  local_res20 = param_4;

 LAB_0:

-  while( true ) {

-    in_stack_00000058 = in_stack_00000058 & (uint)unaff_RBX;

-    uVar1 = 1 << ((byte)uVar8 & 0x1f);

-    uVar4 = ~(uVar1 - 1 | uVar1) & (uint)param_3;

-    uVar1 = 0;

-    if (uVar4 != 0) {

-      for (; (uVar4 >> uVar1 & 1) == 0; uVar1 = uVar1 + 1) {

+  do {

+    if (plVar1 <= param_2) {

+      iVar6 = 0;

+LAB_1:

+      if (plVar11 != (longlong *)0x0) {

+        VsmmGpaRangeRelease(plVar9,(longlong)plVar11,'\x01');

       }

+      return iVar6;

     }

-    uVar8 = (ulonglong)uVar1;

-    if (uVar4 == 0) break;

-    uVar1 = ~(uint)*(ushort *)((longlong)&stack0x00000044 + (uVar8 & 0xff) * 2 + 2) &

-            in_stack_0000004c;

-    if (uVar1 != 0) {

-      uVar1 = (((uint)(uVar8 & 0xff) & 0xf) << 8 | uVar1 & 0xff) << 8;

-      in_stack_00000060 = uVar1 | 1;

-      unaff_RBX = CONCAT44(in_stack_00000064,uVar1) | 1;

-      unaff_R13 = unaff_R15;

-LAB_1:

-      lVar5 = unaff_R14 + 0xcc8;

-      iVar7 = 0;

-      *in_stack_00000070 = unaff_RBX;

-      *in_stack_00000068 = unaff_R13;

-      iVar2 = 0;

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

+    local_res8[0] = 0x7fffffff;

+    if ((int)param_1[0x15] == 0) {

 LAB_2:

-        iVar7 = iVar2;

-        lVar5 = unaff_R14 + 0xcc8;

-        VidObjectLockRelease(lVar5);

-      }

-      if (unaff_RDI != (longlong *)0x0) {

-        VsmmGpaRangeRelease(lVar5,(longlong)unaff_RDI,'\x01');

-      }

-      return iVar7;

+      VsmmVsmGetDefaultVtlPermissionSet(lVar2,local_res10);

+      plVar9 = param_2;

+      iVar6 = (*(code *)param_5)(param_2,1,local_res10,param_6);

+      if (iVar6 < 0) goto LAB_1;

+      param_2 = (longlong *)((longlong)param_2 + 1);

+      goto LAB_0;

     }

-    param_3 = (longlong)in_stack_00000044;

-  }

-  in_stack_00000050 = param_2;

-  plVar3 = (longlong *)0x0;

-  do {

-    unaff_R15 = unaff_R15 + (longlong)in_stack_00000050;

-    unaff_R12 = (longlong *)((longlong)unaff_R12 - (longlong)in_stack_00000050);

-    if (unaff_R12 == (longlong *)0x0) goto LAB_1;

-    plVar6 = in_stack_00000050;

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

-LAB_3:

-      unaff_RDI = (longlong *)VsmmGpaRangeLookupByPageNumberFast(unaff_R14,plVar6,unaff_R15,0);

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

-        iVar2 = -0x3ffffddb;

-        goto LAB_2;

-      }

-      param_3 = (longlong)in_stack_00000044;

-    }

-    else if ((unaff_R15 < (ulonglong)unaff_RDI[0x20]) || ((ulonglong)unaff_RDI[0x21] < unaff_R15)) {

-      VsmmGpaRangeRelease(plVar3,(longlong)unaff_RDI,'\x01');

-      plVar6 = unaff_RDI;

-      goto LAB_3;

-    }

-    plVar3 = (longlong *)((unaff_RDI[0x21] - unaff_R15) + 1);

-    param_2 = unaff_R12;

-    if (plVar3 <= unaff_R12) {

-      param_2 = plVar3;

-    }

-    if ((*(uint *)(unaff_RDI + 0x24) == (uint)unaff_RBX) &&

-       ((*(uint *)((longlong)unaff_RDI + 0x124) & 1) == 0)) break;

-    plVar3 = (longlong *)0x0;

-    if (param_2 < (longlong *)0x1fe) {

-      if (param_2 != (longlong *)0x0) goto LAB_4;

+    plVar7 = (longlong *)VsmmGpaRangeListAcquireReadOnly(lVar2,local_res8);

+    plVar9 = (longlong *)(ulonglong)*(uint *)((longlong)param_1 + 0x14);

+    if ((*(uint *)((longlong)param_1 + 0x14) & 1) == 0) {

+      iVar6 = -0x3ffffff3;

     }

     else {

-      param_2 = (longlong *)0x1fe;

-LAB_4:

-      do {

-        *(ulonglong *)(unaff_RBP + 0xf70 + (longlong)plVar3 * 8) = unaff_R15 + (longlong)plVar3;

-        plVar3 = (longlong *)((longlong)plVar3 + 1);

-      } while (plVar3 < param_2);

+      local_res18 = *(uint *)(plVar7 + 3);

+      for (uVar12 = 0; (uint)uVar12 < local_res18; uVar12 = (ulonglong)((uint)uVar12 + 1)) {

+        plVar3 = *(longlong **)(plVar7[1] + uVar12 * 8);

+        if ((((((int)plVar3[0x24] == 0) && ((longlong *)plVar3[0x30] == param_1)) &&

+             ((*(uint *)((longlong)plVar3 + 0x124) & 1) != 0)) &&

+            ((plVar4 = (longlong *)plVar3[0x31], param_2 == (longlong *)0xffffffffffffffff ||

+             ((plVar4 <= param_2 &&

+              (plVar9 = (longlong *)((plVar3[0x21] - plVar3[0x20]) + (longlong)plVar4),

+              param_2 <= plVar9)))))) &&

+           (plVar9 = plVar3, cVar5 = VsmmGpaRangeReference((longlong)plVar3), cVar5 != '\0')) {

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

+            uVar10 = 0xffffffffffffffff;

+          }

+          else {

+            uVar10 = (plVar3[0x20] - (longlong)plVar4) + (longlong)param_2;

+          }

+          iVar6 = 0;

+          plVar11 = plVar3;

+          goto LAB_3;

+        }

+      }

+      iVar6 = -0x3ffffddb;

     }

-    iVar2 = WinHvCheckSparseGpaPageVtlAccess

-                      (*(undefined8 *)(unaff_R14 + 0x288),

-                       CONCAT71((int7)((ulonglong)param_2 >> 8),(char)unaff_RSI),in_stack_0000004c,

-                       param_2,unaff_RBP + 0xf70);

-    if (iVar2 < 0) goto LAB_2;

-    for (plVar3 = (longlong *)0x0; plVar3 < in_stack_00000050;

-        plVar3 = (longlong *)((longlong)plVar3 + 1)) {

-      if (*(char *)(unaff_RBP + -0x80 + (longlong)plVar3 * 8) != (char)unaff_RBX) {

-        unaff_RBX = *(ulonglong *)(unaff_RBP + -0x80 + (longlong)plVar3 * 8);

-        unaff_R13 = unaff_R15 + (longlong)plVar3;

-        goto LAB_1;

-      }

+LAB_3:

+    if (plVar7 != (longlong *)0x0) {

+      VsmmGpaRangeListReleaseReadOnly(plVar7,(ulonglong)local_res8[0]);

+      plVar9 = plVar7;

     }

-    unaff_RSI = (ulonglong)in_stack_00000041;

-    param_3 = (longlong)in_stack_00000044;

+    if (iVar6 < 0) {

+      if (iVar6 == -0x3ffffddb) goto LAB_2;

+      goto LAB_1;

+    }

+    uVar8 = (plVar11[0x22] - uVar10) + 1;

+    uVar12 = (longlong)plVar1 - (longlong)param_2;

+    if (uVar8 <= uVar12) {

+      uVar12 = uVar8;

+    }

+    plVar9 = plVar11;

+    iVar6 = VsmmVsmpQueryGpaRangeVtlProtections

+                      ((longlong)plVar11,uVar10,uVar12,local_res20,0,

+                       VsmmVsmpConvertGpaRangeToMbpRangeConsumer,&local_58);

+    if (iVar6 < 0) goto LAB_1;

+    VsmmGpaRangeRelease(plVar9,(longlong)plVar11,'\x01');

+    plVar11 = (longlong *)0x0;

+    param_2 = (longlong *)((longlong)param_2 + uVar12);

   } while( true );

-  uVar8 = unaff_RSI & 0xff;

-  goto LAB_0;

 }
```

## `VsmmWheapMemoryBlockTaskArraySetup`  (modified)

```diff
--- VsmmWheapMemoryBlockTaskArraySetup
+++ VsmmWheapMemoryBlockTaskArraySetup
@@ -1,16 +1,78 @@
 

-undefined8

-VsmmWheapMemoryBlockTaskArraySetup

-          (longlong param_1,undefined8 param_2,longlong *param_3,uint *param_4)

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

+

+ulonglong VsmmWheapMemoryBlockTaskArraySetup

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

 

 {

   longlong lVar1;

-  longlong in_R10;

+  uint uVar2;

+  longlong *plVar3;

+  longlong lVar4;

+  ulonglong uVar5;

+  longlong lVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  undefined1 auStackY_f8 [32];

+  longlong local_c8;

+  longlong *local_c0;

+  uint *local_b8;

+  undefined8 local_a8 [4];

+  longlong local_88 [2];

+  longlong local_78 [2];

+  longlong **local_68;

+  undefined8 local_60;

+  longlong *local_58;

+  undefined8 local_50;

+  ulonglong local_48;

   

-  lVar1 = *(longlong *)(in_R10 + 8);

-  *(longlong *)(lVar1 + 0x10) = *(longlong *)(param_4 + 4) + *(longlong *)(param_4 + 2) * 8;

-  *(undefined8 *)(*(longlong *)(in_R10 + 8) + 8) = 1;

-  **(undefined8 **)(*(longlong *)(in_R10 + 8) + 0x10) = param_3;

-  return CONCAT71((int7)((ulonglong)lVar1 >> 8),1);

+  local_48 = __security_cookie ^ (ulonglong)auStackY_f8;

+  lVar1 = param_1 + 0xcc8;

+  local_b8 = param_4;

+  VidObjectLockAcquireShared(lVar1);

+  uVar2 = *(uint *)(param_1 + 0xae0);

+  uVar8 = 0;

+  if (uVar2 == 0) {

+    *param_3 = 0;

+    *param_4 = 0;

+  }

+  else {

+    lVar4 = ExAllocatePool2(0x100,(ulonglong)uVar2 << 3);

+    if (lVar4 != 0) {

+      local_c8 = -1;

+      local_c0 = (longlong *)(param_1 + 0xac8);

+      lVar6 = VidHandleTableGetNext(local_c0,&local_c8);

+      plVar3 = local_c0;

+      while (lVar6 != 0) {

+        uVar5 = uVar8;

+        if (((*(uint *)(lVar6 + 0x14) & 0x40) != 0) &&

+           (uVar7 = VidOpCtrlStart((uint *)(lVar6 + 0x48)), (char)uVar7 != '\0')) {

+          uVar5 = (ulonglong)((int)uVar8 + 1);

+          *(longlong *)(lVar4 + uVar8 * 8) = lVar6;

+        }

+        lVar6 = VidHandleTableGetNext(plVar3,&local_c8);

+        param_4 = local_b8;

+        uVar8 = uVar5;

+      }

+      VidObjectLockRelease(lVar1);

+      *param_3 = lVar4;

+      *param_4 = uVar2;

+      return 0;

+    }

+    uVar8 = 0xc000009a;

+    if ((2 < DAT_0) && (uVar5 = _tlgKeywordOn(0x1400510e8,0x100), (char)uVar5 != '\0')) {

+      _tlgCreate1Sz_char(local_88,"VsmmWheapMemoryBlockTaskArraySetup");

+      _tlgCreate1Sz_char(local_78,"onecore\\vm\\vid\\sys\\vsmm\\vsmmwhea.c");

+      local_68 = &local_c0;

+      local_c0 = (longlong *)CONCAT44(local_c0._4_4_,0x1a52);

+      local_58 = &local_c8;

+      local_60 = 4;

+      local_c8 = CONCAT44(local_c8._4_4_,uVar2);

+      local_50 = 4;

+      _tlgWriteTransfer_EtwWriteTransfer(0x1400510e8,&DAT_1,0,0,6,local_a8);

+    }

+  }

+  VidObjectLockRelease(lVar1);

+  return uVar8;

 }
```

## `VidIoControlFastPartition`  (modified)

```diff
--- VidIoControlFastPartition
+++ VidIoControlFastPartition
@@ -1,143 +1,902 @@
 

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

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

 

-ulonglong VidIoControlFastPartition

-                    (ulonglong *param_1,ulonglong *param_2,uint param_3,ulonglong *param_4,

-                    uint param_5,uint param_6,undefined8 *param_7)

+ulonglong *

+VidIoControlFastPartition

+          (ulonglong *param_1,ulonglong *param_2,uint param_3,ulonglong *param_4,uint param_5,

+          uint param_6,undefined8 *param_7)

 

 {

-  uint *puVar1;

-  longlong *plVar2;

-  uint uVar3;

-  char cVar4;

-  uint uVar5;

-  undefined8 uVar6;

-  longlong *plVar7;

-  longlong *plVar8;

-  byte bVar9;

-  int unaff_R12D;

-  char unaff_R13B;

-  uint unaff_R15D;

-  bool bVar10;

-  uint in_stack_00000060;

-  undefined4 in_stack_00000064;

-  byte in_stack_00000098;

+  longlong *plVar1;

+  uint uVar2;

+  int iVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  char cVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  undefined8 uVar9;

+  char *pcVar10;

+  ulonglong uVar11;

+  uint *puVar12;

+  int *piVar13;

+  longlong *plVar14;

+  uint uVar15;

+  uint uVar16;

+  longlong *plVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  longlong *plVar21;

+  byte bVar22;

+  ulonglong uVar23;

+  longlong *plVar24;

+  char cVar25;

+  ulonglong *puVar26;

+  bool bVar27;

+  undefined1 auStackY_338 [8];

+  undefined1 auStackY_330 [24];

+  undefined8 in_stack_fffffffffffffce8;

+  undefined8 local_2d8;

+  longlong *local_2d0;

+  longlong *local_2c8;

+  undefined8 *local_2c0;

+  undefined1 local_2b8;

+  byte local_2b7;

+  byte local_2b6;

+  undefined1 local_2b5;

+  byte local_2b4;

+  byte local_2b3;

+  char local_2b2;

+  uint local_2b0;

+  longlong *local_2a8;

+  uint local_2a0;

+  ulonglong local_298;

+  longlong *local_290;

+  undefined4 local_288;

+  uint local_284;

+  uint local_280;

+  uint local_27c;

+  uint local_278;

+  uint local_274;

+  uint local_270;

+  uint local_26c;

+  uint local_268;

+  uint local_264;

+  undefined4 local_260;

+  undefined4 local_25c;

+  uint local_258;

+  uint local_254;

+  uint local_250;

+  uint local_24c;

+  uint local_248;

+  uint local_244;

+  int local_240;

+  ulonglong local_238;

+  ulonglong local_230;

+  ulonglong local_228;

+  void *local_220;

+  void *local_218;

+  ulonglong local_210;

+  ulonglong local_208;

+  ulonglong local_200;

+  ulonglong local_1f8;

+  ulonglong local_1f0;

+  ulonglong local_1e8;

+  ulonglong local_1e0;

+  ulonglong local_1d8;

+  ulonglong local_1d0;

+  ulonglong local_1c8;

+  ulonglong local_1c0;

+  ulonglong local_1b8;

+  ulonglong *local_1b0;

+  char *local_1a8;

+  char *local_1a0;

+  char *local_198;

+  char *local_190;

+  undefined8 *local_188;

+  char *local_180;

+  char *local_178;

+  ulonglong local_170;

+  ulonglong local_168;

+  ulonglong local_160;

+  ulonglong local_158;

+  ulonglong local_150;

+  ulonglong local_148;

+  ulonglong local_140;

+  ulonglong local_138;

+  ulonglong local_130;

+  ulonglong local_128;

+  ulonglong local_120;

+  ulonglong local_118;

+  ulonglong local_110;

+  ulonglong local_108;

+  void *local_100;

+  void *local_f8;

+  ulonglong local_f0;

+  ulonglong local_e8;

+  ulonglong local_e0;

+  char *local_d8;

+  char *local_d0;

+  char *local_c8;

+  char *local_c0;

+  undefined8 *local_b8;

+  char *local_b0;

+  char *local_a8;

+  ulonglong local_a0;

+  longlong *local_98;

+  longlong *local_90;

+  ulonglong local_88;

+  ulonglong local_80;

+  ulonglong local_78;

+  ulonglong uStack_70;

+  ulonglong local_68;

+  ulonglong uStack_60;

+  ulonglong local_58;

+  ulonglong uStack_50;

+  ulonglong local_48;

+  longlong *plVar17;

   

-  plVar7 = (longlong *)(ulonglong)in_stack_00000060;

-  plVar2 = plVar7 + 0xe8;

-  plVar8 = plVar7;

-  if ((int)param_4 == 4) {

-    VidVpCancel(plVar7,param_2);

-    uVar5 = unaff_R15D;

+  puVar19 = auStackY_338;

+  puVar20 = auStackY_338;

+  local_48 = __security_cookie ^ (ulonglong)auStackY_338;

+  local_2c0 = param_7;

+  plVar14 = (longlong *)0x0;

+  *param_7 = 0;

+  uVar15 = 0;

+  if (param_6 == 0x221107) {

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_258 = (uint)*param_2;

+    uVar8 = (ulonglong)local_258;

+    local_2a0 = *(uint *)((longlong)param_2 + 4);

+    uVar11 = (ulonglong)local_2a0;

+    param_4 = (ulonglong *)0x0;

+    cVar25 = '\0';

+    uVar7 = 0;

+    local_2d8 = (longlong *)0x0;

+    uVar9 = VidVpLookup((longlong)param_1,local_258,&local_2d8);

+    plVar21 = local_2d8;

+    plVar17 = plVar14;

+    puVar20 = auStackY_338;

+    uVar16 = uVar7;

+    uVar2 = (uint)uVar9;

+    if ((int)(uint)uVar9 < 0) {

+LAB_1:

+      uVar7 = uVar2;

+      uVar15 = uVar16;

+      plVar21 = *(longlong **)(puVar20 + 0x60);

+      puVar19 = puVar20;

+    }

+    else {

+      plVar17 = local_2d8 + 0xe8;

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

+        VidVpCancel(local_2d8,uVar8);

+      }

+      else if (((int)uVar11 == 0) || ((uVar11 & 0xfffffffc) != 0)) {

+        uVar7 = 0xc000000d;

+        puVar19 = auStackY_338;

+      }

+      else {

+        uVar9 = VidMessageSlotTrySetBusy((longlong)plVar17);

+        bVar22 = (byte)uVar11;

+        uVar7 = (uint)uVar9;

+        puVar19 = auStackY_338;

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

+          uVar23 = 1;

+          uVar15 = 1;

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

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

+              VidVpSuspend(plVar21,uVar8);

+            }

+            LOCK();

+            puVar12 = (uint *)(plVar21 + 0xf4);

+            uVar16 = *puVar12;

+            *puVar12 = *puVar12 & 0xfbffffff;

+            UNLOCK();

+            uVar7 = 0xc000000d;

+            if ((uVar16 >> 0x1a & 1) != 0) {

+              LOCK();

+              puVar12 = (uint *)(plVar21 + 0xf4);

+              uVar16 = *puVar12;

+              *puVar12 = *puVar12 & 0xfdffffff;

+              UNLOCK();

+              uVar7 = 0xc000000d;

+              if ((uVar16 >> 0x19 & 1) != 0) {

+                *(undefined4 *)((longlong)plVar21 + 0x7d4) = 0x1000004;

+                if ((code *)plVar21[0x100] == (code *)0x0) {

+                  VidMessageBufferFree((longlong)(plVar21 + 0xf6));

+                  uVar7 = 0;

+                }

+                else {

+                  uVar8 = plVar21[0x101];

+                  uVar7 = (*(code *)plVar21[0x100])(plVar21 + 0xf6,uVar8,plVar21[0x102]);

+                }

+              }

+            }

+            puVar20 = auStackY_338;

+            uVar16 = uVar15;

+            uVar2 = uVar7;

+            if ((int)uVar7 < 0) goto LAB_1;

+            bVar22 = (byte)local_2a0;

+            plVar21 = local_2d8;

+          }

+          puVar26 = (ulonglong *)0xc000000d;

+          puVar20 = auStackY_338;

+          puVar19 = auStackY_338;

+          if ((bVar22 & 1) != 0) goto LAB_2;

+        }

+      }

+    }

+    goto LAB_3;

+  }

+  if (param_6 == 0x2211c7) {

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0x20);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_298 = *param_2;

+    local_290 = (longlong *)0x0;

+    uVar15 = SystemReserved1[0x12]._4_4_ & 0x3fffffff;

+    uVar16 = uVar15 | 0x80000000;

+    plVar17 = (longlong *)(ulonglong)uVar16;

+    uVar23 = 1;

+    while( true ) {

+      uVar2 = (uint)param_1[0x1b4];

+      uVar8 = (ulonglong)uVar2;

+      piVar13 = (int *)((ulonglong)uVar15 * 0x40 + param_1[uVar8 + 0x1b2]);

+      LOCK();

+      *piVar13 = *piVar13 + 1;

+      UNLOCK();

+      if (*piVar13 == 0) break;

+      if (uVar2 == (uint)param_1[0x1b4]) {

+        local_2b0 = (uVar2 & 1) << 0x1e | uVar16;

+        puVar26 = (ulonglong *)param_1[0x1d4];

+        plVar17 = (longlong *)(ulonglong)*(uint *)((longlong)puVar26 + 0x14);

+        uVar15 = 1 << ((byte)(*(uint *)(*puVar26 + 0x20) >> 5) & 0xf);

+        uVar23 = (ulonglong)uVar15;

+        uVar8 = local_298;

+        if (((uVar15 & 0xc00c) != 0) &&

+           (uVar11 = *(ulonglong *)(*puVar26 + 0x3df0), uVar11 <= local_298)) {

+          uVar8 = local_298 - uVar11;

+        }

+        goto LAB_4;

+      }

+      LOCK();

+      iVar3 = *piVar13;

+      *piVar13 = *piVar13 + -1;

+      UNLOCK();

+      if (iVar3 == 0) break;

+      if ((iVar3 == 1) && ((*(uint *)((longlong)param_1 + 0xda4) & 1) != 0)) {

+        ExUnblockOnAddressPushLockEx(param_1 + 0x1b5,0);

+      }

+    }

+    goto LAB_5;

+  }

+  if (param_6 < 0x221140) {

+    if (param_6 == 0x22113f) {

+      local_2d0 = (longlong *)0x0;

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x40,(longlong)param_4,param_5,8);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_1a8 = (char *)*param_2;

+        local_1a0 = (char *)param_2[1];

+        local_198 = (char *)param_2[2];

+        local_190 = (char *)param_2[3];

+        local_188 = (undefined8 *)param_2[4];

+        local_180 = (char *)param_2[5];

+        local_178 = (char *)param_2[6];

+        local_254 = (uint)param_2[7];

+        pcVar10 = VsmmIoctlReadWriteMemoryBlockPageRange

+                            (param_1,local_1a8,local_1a0,local_198,local_190,local_188,local_180,

+                             local_178,local_254,(ulonglong *)&local_2d0,0);

+        puVar26 = (ulonglong *)((ulonglong)pcVar10 & 0xffffffff);

+        puVar20 = auStackY_338;

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

+          *param_4 = (ulonglong)local_2d0;

+          *param_7 = 8;

+          puVar20 = auStackY_338;

+        }

+      }

+      goto LAB_0;

+    }

+    if (param_6 < 0x221014) {

+      if (param_6 == 0x221013) {

+        uVar8 = VidIoControlFastCheckParams

+                          ((longlong)param_2,param_3,0x18,(longlong)param_4,param_5,0);

+        puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+        puVar20 = auStackY_338;

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

+          local_230 = *param_2;

+          local_228 = param_2[1];

+          local_288 = (undefined4)param_2[2];

+          local_2b8 = *(undefined1 *)((longlong)param_2 + 0x14);

+          uVar15 = WinHvAssertVirtualInterrupt(param_1[0x51]);

+          puVar26 = (ulonglong *)(ulonglong)uVar15;

+          puVar20 = auStackY_338;

+        }

+        goto LAB_0;

+      }

+      if (param_6 == 0x220003) {

+        local_2d8 = (longlong *)0x0;

+        uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,8)

+        ;

+        puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+        puVar20 = auStackY_338;

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

+          local_238 = *param_2;

+          uVar15 = VidPartitionIoctlPropertyGet((longlong)param_1,local_238,&local_2d8);

+          puVar26 = (ulonglong *)(ulonglong)uVar15;

+          puVar20 = auStackY_338;

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

+            *param_4 = (ulonglong)local_2d8;

+            *param_7 = 8;

+            puVar20 = auStackY_338;

+          }

+        }

+        goto LAB_0;

+      }

+switchD_1400231ca_caseD_221024:

+      puVar26 = (ulonglong *)0xc0000002;

+      puVar20 = auStackY_338;

+      goto LAB_0;

+    }

+    switch(param_6) {

+    case 0x221023:

+      uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        uVar15 = WinHvClearVirtualInterrupt(param_1[0x51]);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

+      }

+      break;

+    default:

+      goto switchD_1400231ca_caseD_221024;

+    case 0x22105f:

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x10,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_210 = *param_2;

+        local_248 = (uint)param_2[1];

+        uVar15 = VsmmDestroyGpaRange((longlong *)param_1,local_210,local_248,0);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

+      }

+      break;

+    case 0x221063:

+      uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_200 = *param_2;

+        uVar15 = VsmmDestroyMemoryBlock((longlong)param_1,local_200,0);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

+      }

+      break;

+    case 0x221067:

+      uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

+      if ((int)uVar8 < 0) break;

+      local_208 = *param_2;

+      uVar9 = VidSynicPortRemoveEntry((longlong)param_1,local_208);

+      uVar15 = (uint)uVar9;

+      goto LAB_6;

+    case 0x221077:

+      local_2d0 = (longlong *)0x0;

+      local_2d8 = (longlong *)((ulonglong)local_2d8._4_4_ << 0x20);

+      local_2c8 = (longlong *)0x0;

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x1008,(longlong)param_4,param_5,0x18);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_250 = (uint)param_2[0x200];

+        local_1b0 = param_2;

+        uVar15 = VsmmDmIoctlBalloon((longlong *)param_1,(longlong)param_2,local_250,

+                                    (longlong *)&local_2d0,(int *)&local_2d8,(ulonglong *)&local_2c8

+                                   );

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        *param_4 = (ulonglong)local_2d0;

+        *(uint *)(param_4 + 1) = (uint)local_2d8;

+        param_4[2] = (ulonglong)local_2c8;

+        *param_7 = 0x18;

+        puVar20 = auStackY_338;

+      }

+      break;

+    case 0x221087:

+      uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

+      if ((int)uVar8 < 0) break;

+      local_2c0 = (undefined8 *)*param_2;

+      uVar8 = VsmmDmIoctlHotAddUndo((longlong *)param_1,(ulonglong *)&local_2c0);

+      uVar15 = (uint)uVar8;

+      goto LAB_6;

+    case 0x2210b7:

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x20,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

+      if ((int)uVar8 < 0) break;

+      local_1e0 = *param_2;

+      local_1d8 = param_2[1];

+      local_1d0 = param_2[2];

+      local_24c = (uint)param_2[3];

+      uVar15 = VsmmMemoryBlockIoctlFlushPageRange

+                         ((longlong)param_1,local_1e0,local_1d8,local_1d0,local_24c);

+      goto LAB_6;

+    case 0x2210bb:

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x18,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

+      if ((int)uVar8 < 0) break;

+      local_1c8 = *param_2;

+      local_1c0 = param_2[1];

+      local_1b8 = param_2[2];

+      uVar15 = VsmmPpmIoctlFlush((longlong)param_1,local_1c8,local_1c0,local_1b8);

+      goto LAB_6;

+    case 0x2210bf:

+      local_2d8 = (longlong *)0x0;

+      local_2c8 = (longlong *)0x0;

+      local_2d0 = (longlong *)0x0;

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0,(longlong)param_4,param_5,0x18);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        uVar15 = VidHvMemIoctlMemoryBalanceGet((longlong)param_1,&local_2d8,&local_2c8,&local_2d0);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

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

+          *param_4 = (ulonglong)local_2d8;

+          param_4[1] = (ulonglong)local_2c8;

+          param_4[2] = (ulonglong)local_2d0;

+          *param_7 = 0x18;

+          puVar20 = auStackY_338;

+        }

+      }

+      break;

+    case 0x2210c3:

+      uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0,(longlong)param_4,param_5,8);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        *param_4 = param_1[0x51];

+        *param_7 = 8;

+        puVar20 = auStackY_338;

+      }

+      break;

+    case 0x2210cb:

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x20,(longlong)param_4,param_5,0);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_284 = (uint)*param_2;

+        local_280 = *(uint *)((longlong)param_2 + 4);

+        local_220 = (void *)param_2[1];

+        local_2b7 = (byte)param_2[2];

+        local_218 = (void *)param_2[3];

+        uVar15 = VidVpIoctlStateGet((longlong)param_1,local_284,local_280,local_220,local_2b7,

+                                    local_218);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

+      }

+      break;

+    case 0x2210ef:

+      local_2d8 = (longlong *)((ulonglong)local_2d8._4_4_ << 0x20);

+      local_2d0 = (longlong *)0x0;

+      local_2c8 = (longlong *)0x0;

+      uVar8 = VidIoControlFastCheckParams

+                        ((longlong)param_2,param_3,0x20,(longlong)param_4,param_5,0x10);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        local_1f8 = *param_2;

+        local_1f0 = param_2[1];

+        local_1e8 = param_2[2];

+        local_2d8 = (longlong *)CONCAT44(local_2d8._4_4_,(int)param_2[3]);

+        uVar15 = VsmmPpmIoctlCreate((ulonglong)param_1,local_1f8,local_1f0,local_1e8,

+                                    (uint *)&local_2d8,(longlong *)&local_2d0,&local_2c8);

+        puVar26 = (ulonglong *)(ulonglong)uVar15;

+        puVar20 = auStackY_338;

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

+          *param_4 = (ulonglong)local_2d0;

+          param_4[1] = (ulonglong)local_2c8;

+          *param_7 = 0x10;

+          puVar20 = auStackY_338;

+        }

+      }

+    }

     goto LAB_0;

   }

-  if (((int)param_4 == 0) || (((ulonglong)param_4 & 0xfffffffc) != 0)) {

-    uVar5 = 0xc000000d;

+  switch(param_6) {

+  case 0x221163:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x10,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_2b3 = (byte)*param_2;

+    local_a0 = param_2[1];

+    uVar15 = VsmmReleasePages((longlong)param_1,local_2b3,local_a0);

+    break;

+  default:

+    goto switchD_1400231ca_caseD_221024;

+  case 0x22116f:

+    uVar9 = 1;

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,1,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_2b2 = (char)*param_2;

+    uVar15 = VidPartitionIoctlReset((longlong)param_1,local_2b2,uVar9,(ulonglong)param_4);

+    break;

+  case 0x22118b:

+    local_2d0 = (longlong *)0x0;

+    local_2c8 = (longlong *)0x0;

+    uVar8 = VidIoControlFastCheckParams

+                      ((longlong)param_2,param_3,0x30,(longlong)param_4,param_5,0x10);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_138 = *param_2;

+      local_130 = param_2[1];

+      local_128 = param_2[2];

+      local_27c = (uint)param_2[3];

+      local_120 = param_2[4];

+      local_118 = param_2[5];

+      puVar12 = VsmmSetMemoryBlockClientNotifications

+                          ((longlong *)param_1,local_138,0,local_130,local_128,local_27c,local_120,

+                           local_118,(longlong *)&local_2c8,(longlong *)&local_2d0);

+      puVar26 = (ulonglong *)((ulonglong)puVar12 & 0xffffffff);

+      *param_4 = (ulonglong)local_2d0;

+      param_4[1] = (ulonglong)local_2c8;

+      *param_7 = 0x10;

+      puVar20 = auStackY_338;

+    }

+    goto LAB_0;

+  case 0x221197:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x10,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_110 = *param_2;

+    local_108 = param_2[1];

+    uVar15 = VidPartitionIoctlPropertySet((longlong)param_1,local_110,local_108);

+    break;

+  case 0x22119b:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x18,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_170 = *param_2;

+    local_240 = (int)param_2[1];

+    local_168 = param_2[2];

+    uVar15 = VidSynicPortSetProperty((longlong)param_1,local_170,local_240,local_168);

+    break;

+  case 0x2211a7:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x20,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_278 = (uint)*param_2;

+    local_274 = *(uint *)((longlong)param_2 + 4);

+    local_100 = (void *)param_2[1];

+    local_2b4 = (byte)param_2[2];

+    local_f8 = (void *)param_2[3];

+    uVar15 = VidVpIoctlStateSet((longlong)param_1,local_278,local_274,local_100,local_2b4,local_f8);

+    break;

+  case 0x2211cb:

+    local_78 = 0;

+    uStack_70 = 0;

+    local_68 = 0;

+    uStack_60 = 0;

+    local_58 = 0;

+    uStack_50 = 0;

+    local_2c0 = (undefined8 *)0x0;

+    uVar8 = VidIoControlFastCheckParams

+                      ((longlong)param_2,param_3,0x18,(longlong)param_4,param_5,0x60);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_270 = (uint)*param_2;

+      local_f0 = param_2[1];

+      local_e8 = param_2[2];

+      local_2c8 = (longlong *)0x0;

+      local_2d0 = (longlong *)0x0;

+      local_2d8 = (longlong *)0x0;

+      local_2a8 = (longlong *)0x0;

+      if (local_270 < (uint)param_1[0x155]) {

+        uVar8 = VsmmTranslateVirtualAddress

+                          (param_1,local_270,local_f0,local_e8,(int *)&local_78,

+                           (ulonglong *)&local_2c0,(ulonglong *)&local_2d0,(ulonglong *)&local_2c8,

+                           &local_2d8,(ulonglong *)&local_2a8);

+        puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+        plVar14 = local_2d0;

+      }

+      else {

+        puVar26 = (ulonglong *)0xc000000d;

+        local_2d8 = plVar14;

+        local_2a8 = plVar14;

+        local_2c8 = plVar14;

+      }

+      puVar20 = auStackY_338;

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

+        *param_4 = local_78;

+        param_4[1] = uStack_70;

+        param_4[2] = local_68;

+        param_4[3] = uStack_60;

+        param_4[4] = local_58;

+        param_4[5] = uStack_50;

+        param_4[6] = (ulonglong)local_2c0;

+        param_4[7] = (ulonglong)plVar14;

+        param_4[8] = (ulonglong)local_2c8;

+        param_4[9] = (ulonglong)local_2d8;

+        param_4[10] = (ulonglong)local_2a8;

+        *param_7 = 0x60;

+        puVar20 = auStackY_338;

+      }

+    }

+    goto LAB_0;

+  case 0x2211d3:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_80 = *param_2;

+      uVar8 = VidTriggerIoctlDestroy((longlong)param_1,local_80);

+      puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+      puVar20 = auStackY_338;

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

+        puVar26 = (ulonglong *)0x0;

+        puVar20 = auStackY_338;

+      }

+    }

+    goto LAB_0;

+  case 0x2211e3:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,8,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_e0 = *param_2;

+    uVar9 = VsmmPpmIoctlDelete((longlong)param_1,local_e0);

+    uVar15 = (uint)uVar9;

+    break;

+  case 0x2211ef:

+    local_2c0 = (undefined8 *)0x0;

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x40,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_d8 = (char *)*param_2;

+      local_d0 = (char *)param_2[1];

+      local_c8 = (char *)param_2[2];

+      local_c0 = (char *)param_2[3];

+      local_b8 = (undefined8 *)param_2[4];

+      local_b0 = (char *)param_2[5];

+      local_a8 = (char *)param_2[6];

+      local_26c = (uint)param_2[7];

+      pcVar10 = VsmmIoctlReadWriteMemoryBlockPageRange

+                          (param_1,local_d8,local_d0,local_c8,local_c0,local_b8,local_b0,local_a8,

+                           local_26c,(ulonglong *)&local_2c0,1);

+      puVar26 = (ulonglong *)((ulonglong)pcVar10 & 0xffffffff);

+      puVar20 = auStackY_338;

+    }

+    goto LAB_0;

+  case 0x22121b:

+    local_2c0 = (undefined8 *)0x0;

+    local_2d0 = (longlong *)0x0;

+    uVar9 = CONCAT44((int)((ulonglong)in_stack_fffffffffffffce8 >> 0x20),param_5);

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x10,(longlong)param_4,param_5,8);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_2b6 = (byte)*param_2;

+      local_244 = *(uint *)((longlong)param_2 + 4);

+      local_160 = param_2[1];

+      uVar15 = VsmmVsmIoctlCheckGpaPageVtlAccess

+                         ((short *)param_1,local_2b6,local_244,local_160,uVar9,

+                          (ulonglong *)&local_2d0,(ulonglong *)&local_2c0);

+      puVar26 = (ulonglong *)(ulonglong)uVar15;

+      puVar20 = auStackY_338;

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

+        *param_4 = (ulonglong)local_2d0;

+        *param_7 = 8;

+        puVar20 = auStackY_338;

+      }

+    }

+    goto LAB_0;

+  case 0x22122b:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,0x28,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_158 = *param_2;

+    local_150 = param_2[1];

+    local_2b5 = (char)param_2[4] != '\0';

+    local_148 = param_2[2];

+    local_140 = param_2[3];

+    uVar15 = VsmmIoctlReadWriteMappedMemoryBlockPageRange

+                       ((longlong)param_1,local_158,local_150,local_148,local_140,local_2b5);

+    break;

+  case 0x22122f:

+    local_2c0 = (undefined8 *)0x0;

+    local_2a8 = (longlong *)0x0;

+    uVar8 = VidIoControlFastCheckParams

+                      ((longlong)param_2,param_3,0x28,(longlong)param_4,param_5,0x10);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

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

+      local_98 = (longlong *)*param_2;

+      local_268 = (uint)param_2[1];

+      local_90 = (longlong *)param_2[2];

+      local_88 = param_2[3];

+      local_264 = (uint)param_2[4];

+      uVar15 = VsmmControlGpaAccessTracking

+                         ((char *)param_1,local_98,local_268,local_90,local_88,

+                          (longlong *)&local_2c0,(longlong *)&local_2a8,local_264);

+      puVar26 = (ulonglong *)(ulonglong)uVar15;

+      puVar20 = auStackY_338;

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

+        *param_4 = (ulonglong)local_2c0;

+        param_4[1] = (ulonglong)local_2a8;

+        *param_7 = 0x10;

+        puVar20 = auStackY_338;

+      }

+    }

+    goto LAB_0;

+  case 0x221233:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,4,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_260 = (undefined4)*param_2;

+    uVar8 = VidPartitionIoctlFrequencyCapSet((longlong)param_1,local_260);

+    uVar15 = (uint)uVar8;

+    break;

+  case 0x221237:

+    uVar8 = VidIoControlFastCheckParams((longlong)param_2,param_3,4,(longlong)param_4,param_5,0);

+    puVar26 = (ulonglong *)(uVar8 & 0xffffffff);

+    puVar20 = auStackY_338;

+    if ((int)uVar8 < 0) goto LAB_0;

+    local_25c = (undefined4)*param_2;

+    uVar8 = VidPartitionIoctlResourcePrioritiesSet((longlong)param_1,local_25c);

+    uVar15 = (uint)uVar8;

+  }

+LAB_6:

+  puVar26 = (ulonglong *)(ulonglong)uVar15;

+  puVar20 = auStackY_338;

+LAB_0:

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

+  return puVar26;

+  while( true ) {

+    uVar15 = (int)plVar17 - 1;

+    plVar17 = (longlong *)(ulonglong)uVar15;

+    plVar21 = *(longlong **)(puVar26[1] + (ulonglong)uVar15 * 8);

+    if ((((ulonglong)plVar21[0x20] <= uVar8) && (uVar8 <= (ulonglong)plVar21[0x21])) &&

+       (uVar11 = VidOpCtrlStart((uint *)(plVar21 + 1)), (char)uVar11 != '\0')) break;

+LAB_4:

+    plVar21 = plVar14;

+    if ((int)plVar17 == 0) break;

+  }

+  uVar8 = *puVar26;

+  piVar13 = (int *)((ulonglong)(local_2b0 & 0x3fffffff) * 0x40 +

+                   *(longlong *)(uVar8 + 0xd90 + (ulonglong)(local_2b0 >> 0x1e & 1) * 8));

+  LOCK();

+  iVar3 = *piVar13;

+  *piVar13 = *piVar13 + -1;

+  UNLOCK();

+  if (iVar3 != 0) {

+    if ((iVar3 == 1) && ((*(uint *)(uVar8 + 0xda4) & 1) != 0)) {

+      ExUnblockOnAddressPushLockEx(uVar8 + 0xda8);

+    }

+    plVar17 = plVar14;

+    plVar24 = plVar14;

+    if (plVar21 != (longlong *)0x0) {

+      plVar18 = (longlong *)plVar21[0x30];

+      if (((int)plVar21[0x24] != 1) &&

+         (plVar4 = (longlong *)plVar18[0x16], plVar1 = plVar18 + 4, plVar18 = plVar4,

+         (int)*plVar1 != 1)) {

+        plVar24 = (longlong *)((plVar21[0x31] - plVar21[0x20]) + local_298);

+        plVar17 = (longlong *)(ulonglong)(*(uint *)((longlong)plVar21 + 0x124) & 0x1ff);

+        plVar18 = plVar14;

+        local_290 = plVar4;

+        if ((*(uint *)((longlong)plVar21 + 0x124) & 4) != 0) {

+          plVar18 = (longlong *)0x0;

+          plVar17 = (longlong *)((ulonglong)plVar17 & 0xfffffffffffffffe);

+        }

+      }

+      VidRefCounterDec((uint *)(plVar21 + 1),'\0');

+      plVar14 = plVar18;

+    }

+    puVar26 = (ulonglong *)0x0;

+    *param_4 = (ulonglong)plVar14;

+    param_4[1] = (ulonglong)local_290;

+    param_4[2] = (ulonglong)plVar24;

+    param_4[3] = (ulonglong)plVar17;

+    *local_2c0 = 0x20;

+    puVar20 = auStackY_338;

     goto LAB_0;

   }

-  uVar6 = VidMessageSlotTrySetBusy((longlong)plVar2);

-  bVar9 = (byte)param_4;

-  uVar5 = (uint)uVar6;

-  if ((int)uVar5 < 0) goto LAB_0;

-  unaff_R12D = 1;

-  if (((ulonglong)param_4 & 2) != 0) {

-    if (((ulonglong)param_4 & 1) == 0) {

-      VidVpSuspend(plVar7,param_2);

+LAB_5:

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

+  (*pcVar5)(0xe);

+  puVar20 = auStackY_330;

+  do {

+    plVar21 = *(longlong **)(puVar20 + 0x60);

+LAB_2:

+    cVar25 = (char)param_4;

+    uVar15 = (uint)uVar23;

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

+    uVar9 = VidVpRun(plVar21);

+    uVar7 = (uint)uVar9;

+    if ((int)uVar7 < 0) goto LAB_7;

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

+    cVar6 = PsIsThreadTerminating(SystemReserved1[0xf]);

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

+      uVar16 = uVar15;

+      uVar2 = 0xc000004b;

+      goto LAB_1;

+    }

+    uVar8 = uVar23 & 0xff;

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

+    cVar6 = VidMessageSlotWait((longlong)plVar17,(char)uVar23);

+  } while (cVar6 == '\0');

+  uVar16 = *(uint *)(plVar17 + 0xc);

+  do {

+    if ((uVar16 >> 0x1a & 1) != 0) {

+      uVar7 = (uint)puVar26;

+      goto LAB_8;

+    }

+    if ((uVar16 >> 0x1c & 1) != 0) {

+      uVar7 = 0xc037001a;

+      goto LAB_8;

+    }

+    if ((uVar16 >> 0x19 & 1) == 0) {

+      uVar7 = 0xc0000184;

+      goto LAB_8;

     }

     LOCK();

-    puVar1 = (uint *)(plVar7 + 0xf4);

-    uVar3 = *puVar1;

-    *puVar1 = *puVar1 & 0xfbffffff;

+    uVar2 = *(uint *)(plVar17 + 0xc);

+    bVar27 = uVar16 == uVar2;

+    if (bVar27) {

+      *(uint *)(plVar17 + 0xc) = uVar16 | 0x4000000;

+      uVar2 = uVar16;

+    }

+    uVar16 = uVar2;

     UNLOCK();

-    uVar5 = 0xc000000d;

-    if ((uVar3 >> 0x1a & 1) != 0) {

-      LOCK();

-      puVar1 = (uint *)(plVar7 + 0xf4);

-      uVar3 = *puVar1;

-      *puVar1 = *puVar1 & 0xfdffffff;

-      UNLOCK();

-      uVar5 = 0xc000000d;

-      if ((uVar3 >> 0x19 & 1) != 0) {

-        *(undefined4 *)((longlong)plVar7 + 0x7d4) = 0x1000004;

-        if ((code *)plVar7[0x100] == (code *)0x0) {

-          VidMessageBufferFree((longlong)(plVar7 + 0xf6));

-          uVar5 = unaff_R15D;

-        }

-        else {

-          param_2 = (ulonglong *)plVar7[0x101];

-          uVar5 = (*(code *)plVar7[0x100])(plVar7 + 0xf6,param_2,plVar7[0x102]);

-        }

-      }

-    }

-    if ((int)uVar5 < 0) {

-LAB_1:

-      plVar8 = (longlong *)CONCAT44(in_stack_00000064,in_stack_00000060);

-      goto LAB_0;

-    }

-    plVar8 = (longlong *)CONCAT44(in_stack_00000064,in_stack_00000060);

-    bVar9 = in_stack_00000098;

+  } while (!bVar27);

+  *(undefined4 *)((longlong)plVar17 + 0x94) = 3;

+  uVar7 = 0;

+LAB_8:

+  plVar21 = *(longlong **)(puVar20 + 0x60);

+LAB_7:

+  puVar19 = puVar20;

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

+    *(undefined1 *)((longlong)plVar21 + 0x145) = 0;

+    cVar25 = (char)uVar23;

   }

-  if ((bVar9 & 1) == 0) goto LAB_0;

-  while( true ) {

-    uVar6 = VidVpRun(plVar8);

-    uVar5 = (uint)uVar6;

-    if ((int)uVar5 < 0) break;

-    cVar4 = PsIsThreadTerminating(SystemReserved1[0xf]);

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

-      uVar5 = 0xc000004b;

-      goto LAB_1;

-    }

-    param_2 = (ulonglong *)0x1;

-    cVar4 = VidMessageSlotWait((longlong)plVar2,'\x01');

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

-      uVar5 = *(uint *)(plVar7 + 0xf4);

-      goto LAB_2;

-    }

-    plVar8 = (longlong *)CONCAT44(in_stack_00000064,in_stack_00000060);

+LAB_3:

+  if (uVar15 != 0) {

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

+      *(undefined8 *)(puVar19 + -8) = 0x140024437;

+      VidVpEnsureSuspended(plVar21,uVar8);

+    }

+    *(undefined8 *)(puVar19 + -8) = 0x1400230ba;

+    VidMessageSlotClearBusy((longlong)plVar17);

   }

-  goto LAB_3;

-  while( true ) {

-    if ((uVar5 >> 0x19 & 1) == 0) {

-      uVar5 = 0xc0000184;

-      goto LAB_4;

-    }

-    LOCK();

-    uVar3 = *(uint *)(plVar7 + 0xf4);

-    bVar10 = uVar5 == uVar3;

-    if (bVar10) {

-      *(uint *)(plVar7 + 0xf4) = uVar5 | 0x4000000;

-      uVar3 = uVar5;

-    }

-    uVar5 = uVar3;

-    UNLOCK();

-    if (bVar10) break;

-LAB_2:

-    if ((uVar5 >> 0x1a & 1) != 0) {

-      uVar5 = 0xc000000d;

-      goto LAB_4;

-    }

-    if ((uVar5 >> 0x1c & 1) != 0) {

-      uVar5 = 0xc037001a;

-      goto LAB_4;

-    }

-  }

-  *(undefined4 *)((longlong)plVar7 + 0x7d4) = 3;

-  uVar5 = unaff_R15D;

-LAB_4:

-  plVar8 = (longlong *)CONCAT44(in_stack_00000064,in_stack_00000060);

-LAB_3:

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

-    unaff_R13B = '\x01';

-    *(undefined1 *)((longlong)plVar8 + 0x145) = 0;

-  }

-LAB_0:

-  if (unaff_R12D != 0) {

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

-      VidVpEnsureSuspended(plVar8,param_2);

-    }

-    VidMessageSlotClearBusy((longlong)plVar2);

-  }

-  return (ulonglong)uVar5;

+  puVar26 = (ulonglong *)(ulonglong)uVar7;

+  puVar20 = puVar19;

+  goto LAB_0;

 }
```

## `VsmmGpaRangeLookupByPageNumber`  (modified)

```diff
--- VsmmGpaRangeLookupByPageNumber
+++ VsmmGpaRangeLookupByPageNumber
@@ -1,17 +1,27 @@
 

 longlong VsmmGpaRangeLookupByPageNumber

                    (longlong *param_1,ulonglong param_2,uint param_3,uint param_4)

 

 {

   longlong lVar1;

-  uint *unaff_RBX;

-  undefined4 in_register_00000084;

-  undefined4 in_register_0000008c;

+  ulonglong uVar2;

+  uint uVar3;

   

-  WinHvCancelVpDispatchLoop

-            (*(undefined8 *)((ulonglong)*unaff_RBX + 0x288),unaff_RBX[2],

-             CONCAT44(in_register_00000084,param_3),CONCAT44(in_register_0000008c,param_4));

-  lVar1 = KeWaitForSingleObject(*(longlong *)(unaff_RBX + 0x60) + 8,0,0,0,0);

+  uVar3 = *(uint *)((longlong)param_1 + 0x14);

+  if (((1 << ((byte)(*(uint *)(*param_1 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+     (uVar2 = *(ulonglong *)(*param_1 + 0x3df0), uVar2 <= param_2)) {

+    param_2 = param_2 - uVar2;

+  }

+  do {

+    if (uVar3 == 0) {

+      return 0;

+    }

+    uVar3 = uVar3 - 1;

+    lVar1 = *(longlong *)(param_1[1] + (ulonglong)uVar3 * 8);

+  } while ((((param_2 < *(ulonglong *)(lVar1 + 0x100)) || (*(ulonglong *)(lVar1 + 0x108) < param_2))

+           || ((param_4 & *(uint *)(lVar1 + 0x124)) != 0 ||

+               (*(uint *)(lVar1 + 0x124) & param_3) != param_3)) ||

+          (uVar2 = VidOpCtrlStart((uint *)(lVar1 + 8)), (char)uVar2 == '\0'));

   return lVar1;

 }
```

## `VsmmDmpFindPrimaryRamGpaRangeWithMemoryBlock`  (modified)

```diff
--- VsmmDmpFindPrimaryRamGpaRangeWithMemoryBlock
+++ VsmmDmpFindPrimaryRamGpaRangeWithMemoryBlock
@@ -1,366 +1,44 @@
 

 ulonglong VsmmDmpFindPrimaryRamGpaRangeWithMemoryBlock

                     (longlong param_1,longlong param_2,ulonglong param_3,longlong *param_4)

 

 {

-  ulonglong *puVar1;

-  undefined1 auVar2 [16];

-  longlong lVar3;

-  longlong lVar4;

-  longlong *plVar5;

-  longlong lVar6;

-  undefined1 auVar7 [16];

-  int iVar8;

-  longlong *plVar9;

-  ulonglong uVar10;

-  undefined8 uVar11;

-  ulonglong uVar12;

-  uint uVar13;

-  uint uVar14;

-  ulonglong uVar15;

-  ulonglong uVar16;

-  ulonglong uVar17;

-  char cVar18;

-  ulonglong uVar19;

-  undefined8 *unaff_RBP;

-  ulonglong unaff_RSI;

-  ulonglong uVar20;

-  undefined1 (*pauVar21) [16];

-  longlong lVar22;

-  longlong lVar23;

-  ulonglong unaff_R14;

-  int iVar24;

-  longlong *unaff_R15;

-  bool bVar25;

-  undefined8 uVar26;

-  undefined4 uVar27;

-  undefined4 uVar28;

-  undefined4 uVar29;

-  undefined4 uVar30;

-  undefined4 uVar31;

-  undefined4 uVar32;

-  undefined4 uVar33;

-  undefined4 uVar34;

-  char in_stack_00000040;

-  int in_stack_00000044;

-  longlong in_stack_00000048;

-  ulonglong in_stack_00000050;

-  ulonglong in_stack_00000060;

-  ulonglong *in_stack_00000068;

-  ulonglong in_stack_00000070;

-  longlong *in_stack_00000078;

+  longlong lVar1;

+  longlong *plVar2;

+  ulonglong uVar3;

+  ulonglong uVar4;

+  uint local_res20 [2];

   

-code_r0x000140029920:

-  in_stack_00000070 = in_stack_00000070 + 1;

-  if (unaff_RSI <= in_stack_00000070) {

-    plVar5 = (longlong *)unaff_RBP[0x15];

-    lVar23 = unaff_RBP[-7];

-    lVar22 = in_stack_00000048;

-    do {

-      if (*(char *)(unaff_RBP + 0x12) != '\0') {

-        VsmmDmSlpBitmapRangeSet

-                  ((longlong *)(unaff_R14 + 0x1c8),unaff_RBP[0x13] + *unaff_R15,unaff_RSI);

+  uVar4 = 0;

+  local_res20[0] = 0;

+  *param_4 = 0;

+  plVar2 = (longlong *)VsmmGpaRangeListAcquireReadOnly(param_1,local_res20);

+  uVar3 = uVar4;

+  do {

+    if (*(uint *)(plVar2 + 3) <= (uint)uVar3) {

+LAB_0:

+      uVar4 = 0xc000028c;

+LAB_1:

+      VidReaderCounterLeave(*plVar2 + 0xd88,0,local_res20[0]);

+      return uVar4;

+    }

+    lVar1 = *(longlong *)(plVar2[1] + uVar3 * 8);

+    if ((((*(int *)(lVar1 + 0x120) == 0) &&

+         (((byte)*(undefined4 *)(lVar1 + 0x124) >> 2 & 1) ==

+          ((byte)(*(uint *)(param_1 + 0x10) >> 9) & 1))) &&

+        (*(longlong *)(lVar1 + 0x180) == param_2)) &&

+       ((*(ulonglong *)(lVar1 + 0x188) <= param_3 &&

+        (param_3 <=

+         (*(longlong *)(lVar1 + 0x110) - *(longlong *)(lVar1 + 0x100)) +

+         *(ulonglong *)(lVar1 + 0x188))))) {

+      uVar3 = VidOpCtrlStart((uint *)(lVar1 + 8));

+      if ((char)uVar3 != '\0') {

+        *param_4 = lVar1;

+        goto LAB_1;

       }

-      RtlClearBitsEx(unaff_R14 + 0x110,unaff_RBP[0x13] + *unaff_R15,unaff_RSI);

-      plVar9 = in_stack_00000078;

-      VidReaderCounterAdvanceAndWait((uint *)(in_stack_00000078 + 0x1b1),1);

-      if ((*(char *)(unaff_RBP + 0x12) == '\0') && (*(int *)(unaff_R14 + 0xbc) != 0)) {

-        VsmmDmReleaseHostAccess

-                  ((longlong)plVar9,unaff_R14,(void *)(*plVar5 + (plVar5[1] + *unaff_R15) * 8),

-                   unaff_RSI);

-      }

-      if ((*(uint *)(unaff_R14 + 0x14) & 8) == 0) {

-        VsmmUpdateGpaSpaceForMbpRangeModification

-                  (plVar9,unaff_R14,unaff_RBP[0x13] + *unaff_R15,unaff_RSI,0,-1,(uint *)0x0);

-      }

-      else {

-        VsmmHvMapGpasFromPfnArray

-                  ((longlong)plVar9,lVar23,unaff_RSI,6,0,unaff_RBP + -6,*(uint *)(lVar22 + 0x124),0)

-        ;

-        in_stack_00000040 = '\0';

-      }

-      lVar6 = unaff_RBP[0x14];

-      *unaff_R15 = *unaff_R15 + unaff_RSI;

-      unaff_RBP[0x14] = lVar6 - unaff_RSI;

-      if (lVar6 - unaff_RSI == 0) {

-        uVar13 = 0;

-LAB_0:

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

-          VsmmMemoryBlockDecommitPrimaryRamRange

-                    (unaff_R14,

-                     (*(longlong *)(lVar22 + 0x188) - *(longlong *)(lVar22 + 0x100)) + lVar23,

-                     unaff_RSI,1);

-        }

-        if (*unaff_R15 != 0) {

-          if (*(char *)(unaff_RBP + 0x12) != '\0') {

-            LOCK();

-            *(longlong *)(in_stack_00000078[0xbd] + 0x498) =

-                 *(longlong *)(in_stack_00000078[0xbd] + 0x498) + *unaff_R15;

-            UNLOCK();

-            lVar22 = in_stack_00000048;

-          }

-          uVar13 = 0;

-        }

-        if (lVar22 != 0) {

-          VidRefCounterDec((uint *)(lVar22 + 8),'\x01');

-        }

-        if (uVar13 == 0xc037002d) {

-          uVar13 = 0xc000009a;

-        }

-        return (ulonglong)uVar13;

-      }

-      if (lVar22 != 0) {

-        VidRefCounterDec((uint *)(lVar22 + 8),'\x01');

-        in_stack_00000048 = 0;

-      }

-      uVar10 = VsmmDmpFindPrimaryRamGpaRangeWithMemoryBlock

-                         ((longlong)plVar9,unaff_R14,unaff_RBP[0x13] + *unaff_R15,&stack0x00000048);

-      lVar22 = in_stack_00000048;

-      uVar13 = (uint)uVar10;

-      if ((int)uVar13 < 0) goto LAB_0;

-      lVar6 = *(longlong *)(in_stack_00000048 + 0x100);

-      lVar3 = *(longlong *)(in_stack_00000048 + 0x188);

-      lVar4 = *(longlong *)(in_stack_00000048 + 0x108);

-      lVar23 = (lVar6 - lVar3) + *unaff_R15 + unaff_RBP[0x13];

-      unaff_RBP[-7] = lVar23;

-      uVar10 = (lVar4 - lVar23) + 1;

-      unaff_RSI = unaff_RBP[0x14];

-      if (uVar10 <= (ulonglong)unaff_RBP[0x14]) {

-        unaff_RSI = uVar10;

-      }

-      uVar13 = *(uint *)(unaff_R14 + 0x14);

-      unaff_RBP[-8] = unaff_RSI;

-      if (((uVar13 & 8) != 0) && ((uVar13 >> 0xd & 1) == 0)) {

-        uVar10 = VsmmMemoryBlockCommitPrimaryRamRange(unaff_R14,(lVar3 - lVar6) + lVar23,unaff_RSI);

-        uVar13 = (uint)uVar10;

-        if ((int)uVar13 < 0) goto LAB_0;

-        in_stack_00000040 = '\x01';

-      }

-      uVar11 = VsmmDmpPageRangeAddPage

-                         (unaff_RBP[0x17],*(uint *)(unaff_RBP + 0x18),(uint *)unaff_RBP[0x19],lVar23

-                          ,unaff_RSI);

-      uVar13 = (uint)uVar11;

-      if ((int)uVar13 < 0) goto LAB_0;

-      in_stack_00000070 = 0;

-    } while (unaff_RSI == 0);

-  }

-  cVar18 = *(char *)(unaff_RBP + 0x12);

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

-    if ((*(byte *)(unaff_RBP + 0x16) & 2) == 0) {

-      if ((*(uint *)(unaff_R14 + 0x14) & 8) == 0) {

-        in_stack_00000050 = *in_stack_00000068;

-        in_stack_00000068 = in_stack_00000068 + 1;

-      }

+      goto LAB_0;

     }

-    else {

-      in_stack_00000050 = in_stack_00000060;

-      in_stack_00000060 = in_stack_00000060 + 1;

-    }

-  }

-  lVar22 = *unaff_R15 + in_stack_00000070 + unaff_RBP[0x13];

-  lVar23 = *(longlong *)(unaff_R14 + 0xc0);

-  if ((*(uint *)(unaff_R14 + 0x14) & 8) == 0) {

-    unaff_RBP[2] = 0;

-    unaff_RBP[3] = 0;

-    *unaff_RBP = *(undefined8 *)(lVar23 + lVar22 * 0x10);

-    uVar11 = unaff_RBP[2];

-    uVar26 = unaff_RBP[3];

-    unaff_RBP[1] = *(undefined8 *)(lVar23 + 8 + lVar22 * 0x10);

-    uVar27 = *(undefined4 *)unaff_RBP;

-    uVar28 = *(undefined4 *)((longlong)unaff_RBP + 4);

-    uVar29 = *(undefined4 *)(unaff_RBP + 1);

-    uVar30 = *(undefined4 *)((longlong)unaff_RBP + 0xc);

-  }

-  else {

-    uVar11 = *(undefined8 *)(lVar23 + lVar22 * 8);

-    unaff_RBP[4] = 0;

-    unaff_RBP[5] = uVar11;

-    uVar27 = *(undefined4 *)(unaff_RBP + 4);

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

-    uVar29 = *(undefined4 *)(unaff_RBP + 5);

-    uVar30 = *(undefined4 *)((longlong)unaff_RBP + 0x2c);

-    unaff_RBP[6] = 0;

-    unaff_RBP[7] = 0;

-    uVar11 = unaff_RBP[6];

-    uVar26 = unaff_RBP[7];

-  }

-  uVar12 = CONCAT44(uVar28,uVar27);

-  unaff_RBP[-2] = uVar11;

-  unaff_RBP[-1] = uVar26;

-  auVar2._4_4_ = uVar28;

-  auVar2._0_4_ = uVar27;

-  auVar2._8_4_ = uVar29;

-  auVar2._12_4_ = uVar30;

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

-  uVar31 = *(undefined4 *)(unaff_RBP + -2);

-  uVar32 = *(undefined4 *)((longlong)unaff_RBP + -0xc);

-  uVar33 = *(undefined4 *)(unaff_RBP + -1);

-  uVar34 = *(undefined4 *)((longlong)unaff_RBP + -4);

-  *(undefined4 *)(unaff_RBP + -4) = uVar27;

-  *(undefined4 *)((longlong)unaff_RBP + -0x1c) = uVar28;

-  *(undefined4 *)(unaff_RBP + -3) = uVar29;

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

-  *(undefined4 *)(unaff_RBP + -0xc) = uVar27;

-  *(undefined4 *)((longlong)unaff_RBP + -0x5c) = uVar28;

-  *(undefined4 *)(unaff_RBP + -0xb) = uVar29;

-  *(undefined4 *)((longlong)unaff_RBP + -0x54) = uVar30;

-  *(undefined4 *)(unaff_RBP + -10) = uVar31;

-  *(undefined4 *)((longlong)unaff_RBP + -0x4c) = uVar32;

-  *(undefined4 *)(unaff_RBP + -9) = uVar33;

-  *(undefined4 *)((longlong)unaff_RBP + -0x44) = uVar34;

-  uVar10 = in_stack_00000050;

-  uVar17 = auVar2._8_8_;

-  iVar24 = in_stack_00000044;

-  do {

-    *(undefined4 *)(unaff_RBP + -0x10) = uVar27;

-    *(undefined4 *)((longlong)unaff_RBP + -0x7c) = uVar28;

-    *(undefined4 *)(unaff_RBP + -0xf) = uVar29;

-    *(undefined4 *)((longlong)unaff_RBP + -0x74) = uVar30;

-    *(undefined4 *)(unaff_RBP + -0xe) = uVar31;

-    *(undefined4 *)((longlong)unaff_RBP + -0x6c) = uVar32;

-    *(undefined4 *)(unaff_RBP + -0xd) = uVar33;

-    *(undefined4 *)((longlong)unaff_RBP + -100) = uVar34;

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

-      uVar19 = 1;

-    }

-    else {

-      iVar24 = 0;

-      uVar19 = 3;

-      uVar10 = *(ulonglong *)

-                (*(longlong *)

-                  (*(longlong *)(VidDeviceExtension + 0x108) +

-                  (ulonglong)*(byte *)(unaff_R14 + 0xb8) * 8) + 0x48);

-    }

-    uVar13 = *(uint *)(unaff_R14 + 0x14) & 8;

-    if (uVar13 == 0) {

-      uVar20 = uVar12 & 0xffffff0000000000 | uVar10 & 0xffffffffff;

-      unaff_RBP[-0x10] = uVar20;

-      uVar15 = (longlong)iVar24 << 0x3f | unaff_RBP[-0xf] & 0x7fffffffffffffff;

-    }

-    else {

-      uVar15 = unaff_RBP[-0xf];

-      uVar20 = unaff_RBP[-0x10];

-    }

-    uVar16 = uVar15 & 0xfffffffffffffff0 | uVar19;

-    if (uVar13 == 0) {

-      iVar8 = (int)uVar19;

-      uVar13 = 1 << ((byte)(*(uint *)(*(longlong *)(unaff_R14 + 8) + 0x20) >> 5) & 0xf) & 0xc00c;

-      if (iVar8 == 0) {

-LAB_1:

-        uVar16 = 0;

-      }

-      else if ((iVar8 - 5U < 3) || (iVar8 == 10)) {

-LAB_2:

-        uVar16 = 0x180;

-      }

-      else if ((uVar15 & 0x10) == 0) {

-LAB_3:

-        uVar14 = (uint)uVar16 & 0xf;

-        uVar16 = (ulonglong)uVar14;

-        if ((uVar16 - 1 < 3) || (uVar16 == 8)) {

-          if (iVar8 == 2) {

-            uVar16 = 0xc0;

-          }

-          else if (iVar8 - 3U < 2) {

-            uVar16 = 0x100;

-          }

-          else if ((((uVar15 & 0x20) == 0) || (uVar13 != 0)) && (uVar16 == 1)) {

-            if (((uVar15 & 0x10) != 0) || ((uVar15 & 0x20) != 0)) goto LAB_1;

-            uVar16 = (ulonglong)(uVar14 + 0x3f);

-          }

-          else {

-            uVar16 = 0x80;

-          }

-        }

-        else {

-LAB_4:

-          uVar16 = 0x140;

-        }

-      }

-      else {

-        uVar14 = (uint)uVar16 & 0xf;

-        if ((uVar14 == 1) || (uVar14 == 8)) {

-          if (uVar13 != 0) goto LAB_3;

-          goto LAB_4;

-        }

-        if (iVar8 != 2) goto LAB_2;

-        uVar16 = 0x1c0;

-      }

-      uVar16 = uVar15 & 0xfffffffffffffe30 | uVar19 | uVar16;

-      pauVar21 = (undefined1 (*) [16])(lVar22 * 0x10 + *(longlong *)(unaff_R14 + 0xc0));

-      unaff_RBP[-0xf] = uVar16;

-      if ((*(byte *)(unaff_RBP + -0xe) & 1) == 0) {

-        LOCK();

-        auVar2 = *pauVar21;

-        auVar7._8_8_ = uVar17;

-        auVar7._0_8_ = uVar12;

-        bVar25 = auVar7 == auVar2;

-        if (bVar25) {

-          *(ulonglong *)*pauVar21 = uVar20;

-          *(ulonglong *)(*pauVar21 + 8) = uVar16;

-        }

-        else {

-          uVar17 = auVar2._8_8_;

-          uVar12 = auVar2._0_8_;

-        }

-        UNLOCK();

-        unaff_RBP[-0xc] = uVar12;

-        unaff_RBP[-0xb] = uVar17;

-      }

-      else {

-        LOCK();

-        uVar19 = *(ulonglong *)(*pauVar21 + 8);

-        bVar25 = uVar17 == uVar19;

-        if (bVar25) {

-          *(ulonglong *)(*pauVar21 + 8) = uVar16;

-          uVar19 = uVar17;

-        }

-        UNLOCK();

-        unaff_RBP[-0xb] = uVar19;

-        uVar12 = 0;

-        unaff_RBP[-0xc] = 0;

-        uVar17 = uVar19;

-      }

-      uVar16 = unaff_RBP[-0xf];

-      uVar19 = uVar17;

-    }

-    else {

-      lVar23 = *(longlong *)(unaff_R14 + 0xc0);

-      unaff_RBP[-0xf] = uVar16;

-      puVar1 = (ulonglong *)(lVar23 + lVar22 * 8);

-      LOCK();

-      uVar19 = *puVar1;

-      bVar25 = uVar17 == uVar19;

-      if (bVar25) {

-        *puVar1 = uVar16;

-        uVar19 = uVar17;

-      }

-      UNLOCK();

-      unaff_RBP[-0xf] = uVar16;

-      unaff_RBP[-0xb] = uVar19;

-      uVar12 = 0;

-      unaff_RBP[-0xc] = 0;

-    }

-    if (bVar25) break;

-    uVar31 = *(undefined4 *)(unaff_RBP + -10);

-    uVar32 = *(undefined4 *)((longlong)unaff_RBP + -0x4c);

-    uVar33 = *(undefined4 *)(unaff_RBP + -9);

-    uVar34 = *(undefined4 *)((longlong)unaff_RBP + -0x44);

-    uVar27 = *(undefined4 *)(unaff_RBP + -0xc);

-    uVar28 = *(undefined4 *)((longlong)unaff_RBP + -0x5c);

-    uVar29 = *(undefined4 *)(unaff_RBP + -0xb);

-    uVar30 = *(undefined4 *)((longlong)unaff_RBP + -0x54);

-    cVar18 = *(char *)(unaff_RBP + 0x12);

-    uVar17 = uVar19;

+    uVar3 = (ulonglong)((uint)uVar3 + 1);

   } while( true );

-  unaff_RSI = unaff_RBP[-8];

-  unaff_R15 = (longlong *)unaff_RBP[0x1a];

-  if (((byte)uVar16 & 0xf) == 3) {

-    LOCK();

-    plVar5 = (longlong *)(*(longlong *)(*(longlong *)(unaff_R14 + 8) + 0x5e8) + 0x4a0);

-    *plVar5 = *plVar5 + 1;

-    UNLOCK();

-  }

-  goto code_r0x000140029920;

 }
```

## `VsmmGpaRangeLookupByPageNumberFast`  (modified)

```diff
--- VsmmGpaRangeLookupByPageNumberFast
+++ VsmmEpfpWorkerQueue
@@ -1,34 +1,43 @@
 

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

-

-ulonglong VsmmGpaRangeLookupByPageNumberFast

-                    (ulonglong param_1,undefined2 *param_2,ulonglong param_3,uint param_4)

+longlong VsmmEpfpWorkerQueue(longlong *param_1,int param_2,longlong *param_3,longlong *param_4)

 

 {

   char cVar1;

-  char *in_RAX;

-  int *piVar2;

-  int iVar3;

-  undefined8 unaff_RBX;

-  undefined8 uVar4;

-  int *unaff_RSI;

-  undefined2 in_ES;

-  uint uStack000000000000004c;

+  int in_EAX;

+  longlong lVar2;

+  undefined4 in_register_00000014;

+  longlong unaff_RBX;

+  uint unaff_EBP;

+  longlong unaff_RSI;

+  ulonglong unaff_RDI;

+  int in_R10D;

+  int in_R11D;

   

-  *param_2 = in_ES;

-  cVar1 = (char)in_RAX;

-  *in_RAX = *in_RAX + cVar1;

-  uStack000000000000004c = (uint)(short)in_RAX;

-  piVar2 = (int *)(ulonglong)uStack000000000000004c;

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

-  uVar4 = CONCAT62((int6)((ulonglong)unaff_RBX >> 0x10),

-                   CONCAT11((char)((ulonglong)unaff_RBX >> 8) + cVar1 * '\x02',(char)unaff_RBX));

-  *piVar2 = *piVar2 + uStack000000000000004c;

-  *(char *)piVar2 = (char)*piVar2 + cVar1;

-  EtwWriteTransfer(DAT_0);

-  iVar3 = (int)uVar4;

-  *unaff_RSI = iVar3;

-  *(longlong *)(unaff_RSI + 2) = (longlong)iVar3;

-  return CONCAT71((int7)(int3)((ulonglong)uVar4 >> 8),1);

+  lVar2 = CONCAT44(in_register_00000014,param_2);

+  while( true ) {

+    lVar2 = param_1[lVar2];

+    if (unaff_RDI < *(ulonglong *)(lVar2 + 0x100)) {

+      in_R11D = in_EAX + -1;

+    }

+    else {

+      if (unaff_RDI <= *(ulonglong *)(lVar2 + 0x108)) {

+        if ((in_EAX != -1) &&

+           (((*(uint *)(lVar2 + 0x124) & unaff_EBP) != unaff_EBP ||

+            (unaff_RBX = lVar2, ((uint)param_4 & *(uint *)(lVar2 + 0x124)) != 0))))

+        goto LAB_0;

+        break;

+      }

+      in_R10D = in_EAX + 1;

+    }

+    if (in_R11D < in_R10D) break;

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

+    in_EAX = (in_R11D - in_R10D) / 2 + in_R10D;

+    lVar2 = (longlong)in_EAX;

+  }

+  if ((unaff_RBX != 0) && (cVar1 = func_0x000140024dd0(unaff_RBX + 8), cVar1 == '\0')) {

+LAB_0:

+    unaff_RBX = 0;

+  }

+  return unaff_RBX;

 }
```

## `VsmmGpaLockpAcquireBeginAsyncOperation`  (modified)

```diff
--- VsmmGpaLockpAcquireBeginAsyncOperation
+++ VsmmGpaLockpAcquireBeginAsyncOperation
@@ -1,20 +1,42 @@
 

 undefined4 VsmmGpaLockpAcquireBeginAsyncOperation(longlong param_1,uint *param_2)

 

 {

-  ulonglong in_RAX;

-  ulonglong uVar1;

-  longlong unaff_RDI;

+  longlong *plVar1;

+  uint uVar2;

+  longlong lVar3;

+  longlong lVar4;

+  char cVar5;

+  undefined4 uVar6;

+  bool bVar7;

   

-  *(char *)(param_1 + 0x3b) = *(char *)(param_1 + 0x3b) + (char)in_RAX;

-  *(char *)(unaff_RDI + 8) = *(char *)(unaff_RDI + 8) << 1;

-  if ((1 < (uint)param_2) && (((int)param_1 == 0x41 || ((int)param_1 == 0x4b)))) {

-    uVar1 = ((ulonglong)param_2 & 0xffffffff) << 9;

-    in_RAX = 0x1000;

-    if (uVar1 < 0x1000) {

-      in_RAX = uVar1;

+  cVar5 = VsmmGpaRangeReference(*(longlong *)(param_1 + 0x38));

+  uVar6 = 0;

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

+    uVar6 = 0xc0370022;

+  }

+  else {

+    uVar2 = *(uint *)(param_1 + 0x34);

+    if (uVar2 != 0) {

+      lVar3 = *(longlong *)(*(longlong *)(param_1 + 0x38) + 0x180);

+      do {

+        lVar4 = *(longlong *)(lVar3 + 0x38);

+        if (lVar4 == -1) break;

+        plVar1 = (longlong *)(lVar3 + 0x38);

+        LOCK();

+        bVar7 = lVar4 == *plVar1;

+        if (bVar7) {

+          *plVar1 = lVar4 + (ulonglong)uVar2;

+        }

+        UNLOCK();

+      } while (!bVar7);

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

     }

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

+      *param_2 = *(uint *)(param_1 + 0x1c) & 1;

+    }

+    *(uint *)(param_1 + 0x1c) = *(uint *)(param_1 + 0x1c) | 1;

   }

-  return (int)in_RAX;

+  return uVar6;

 }
```

## `VsmmMemoryBlockLookupByHandle`  (modified)

```diff
--- VsmmMemoryBlockLookupByHandle
+++ VsmmMemoryBlockLookupByHandle
@@ -1,10 +1,27 @@
-

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

 

 longlong VsmmMemoryBlockLookupByHandle(longlong param_1,longlong param_2,int param_3,int param_4)

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  ulonglong uVar2;

+  

+  if (param_4 == 0) {

+    KeEnterCriticalRegion();

+    ExAcquirePushLockSharedEx(param_1 + 0xcd0,0);

+  }

+  lVar1 = VidHandleTableLookupEntry((longlong *)(param_1 + 0xac8),param_2);

+  if (lVar1 != 0) {

+    if (*(int *)(lVar1 + 0x20) == param_3) {

+      uVar2 = VidOpCtrlStart((uint *)(lVar1 + 0x48));

+      if ((char)uVar2 != '\0') goto LAB_0;

+    }

+    lVar1 = 0;

+  }

+LAB_0:

+  if (param_4 == 0) {

+    ExReleasePushLockEx(param_1 + 0xcd0,0);

+    KeLeaveCriticalRegion();

+  }

+  return lVar1;

 }
```

## `VsmmDmSlpCommitAsync`  (modified)

```diff
--- VsmmDmSlpCommitAsync
+++ VsmmDmSlpCommitAsync
@@ -1,10 +1,160 @@
 

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

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

 

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

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

 

 {

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

-  halt_baddata();

+  uint *puVar1;

+  undefined8 *puVar2;

+  longlong *plVar3;

+  uint uVar4;

+  int iVar5;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  longlong lVar8;

+  longlong lVar9;

+  int iVar10;

+  ulonglong uVar11;

+  int local_res8 [2];

+  uint local_res10 [2];

+  int local_res18 [2];

+  longlong local_res20;

+  byte bStack_a0;

+  byte bStack_80;

+  

+  uVar7 = *(ulonglong *)(param_1 + 0x20);

+  local_res20 = 0;

+  local_res8[0] = 0;

+  local_res10[0] = 0;

+  plVar3 = *(longlong **)(uVar7 + 8);

+  local_res18[0] = 0;

+  if (-1 < *(int *)(param_1 + 0x158)) {

+    puVar1 = (uint *)(param_1 + 0x204);

+    uVar11 = *(longlong *)(param_1 + 0x28) + *(longlong *)(param_1 + 0x40);

+    lVar8 = *(longlong *)(param_1 + 0x30) - *(longlong *)(param_1 + 0x40);

+    *(longlong *)(param_1 + 0x38) = lVar8;

+    lVar9 = (uVar11 >> 9) * 0x30 + *(longlong *)(uVar7 + 0x100);

+    uVar4 = *(uint *)(lVar9 + 0x20);

+    if ((ulonglong)uVar4 != (uVar11 - 1) + lVar8 >> 9) {

+      *puVar1 = *puVar1 | 0x80;

+      *(ulonglong *)(param_1 + 0x38) = (ulonglong)(uVar4 + 1) * 0x200 - uVar11;

+    }

+    uVar4 = *puVar1;

+    if ((uVar4 & 0x20) == 0) {

+      *puVar1 = uVar4 | 0x20;

+      lVar8 = ExpInterlockedPushEntrySList(lVar9,param_1);

+      if (lVar8 != 0) {

+        return;

+      }

+      *puVar1 = *puVar1 | 0x40;

+      uVar4 = *puVar1;

+    }

+    if ((uVar4 & 0x40) == 0) {

+      return;

+    }

+    if (((uVar4 >> 0xb & 1) == 0) &&

+       (uVar6 = VidOpCtrlStart((uint *)(plVar3 + 0x5f9)), (char)uVar6 != '\0')) {

+      *puVar1 = *puVar1 | 0x800;

+    }

+    if ((*(uint *)(uVar7 + 0x14) & 8) == 0) {

+      bStack_a0 = (byte)*(undefined8 *)(*(longlong *)(uVar7 + 0xc0) + 8 + uVar11 * 0x10);

+    }

+    else {

+      bStack_80 = (byte)*(undefined8 *)(*(longlong *)(uVar7 + 0xc0) + uVar11 * 8);

+      bStack_a0 = bStack_80;

+    }

+    if ((((bStack_a0 & 0xf) == 3) && ((*(uint *)(param_1 + 0x204) & 0x800) != 0)) &&

+       (uVar4 = VsmmDmSlppCommitForFirstAccess(param_1,lVar9,param_3,param_4), -1 < (int)uVar4)) {

+      *(uint *)(param_1 + 0x158) = uVar4;

+    }

+    else {

+      VidLockAcquireShared(plVar3 + 0x19a);

+      if (((*(uint *)(param_1 + 0x204) & 0x800) == 0) &&

+         (uVar6 = VidOpCtrlStart((uint *)(plVar3 + 0x5f9)), (char)uVar6 != '\0')) {

+        *(uint *)(param_1 + 0x204) = *(uint *)(param_1 + 0x204) | 0x800;

+      }

+      VidPushLockAcquireExclusive

+                (*(longlong *)(uVar7 + 0xf8) + (ulonglong)*(uint *)(lVar9 + 0x20) * 8);

+      iVar5 = VsmmMbpCommitRangeForAccessBegin

+                        (uVar7,uVar11,*(longlong *)(param_1 + 0x38),0,

+                         *(uint *)(param_1 + 0x204) >> 3 & 1,*(uint *)(param_1 + 0x204) & 1,

+                         *(uint *)(param_1 + 0x208),local_res8,&local_res20,local_res10,local_res18)

+      ;

+      lVar8 = local_res20;

+      iVar10 = local_res8[0];

+      if (-1 < iVar5) {

+        if (local_res20 != *(longlong *)(param_1 + 0x38)) {

+          *(uint *)(param_1 + 0x204) = *(uint *)(param_1 + 0x204) | 0x80;

+          *(longlong *)(param_1 + 0x38) = local_res20;

+        }

+        if (((*(uint *)(param_1 + 0x204) & 8) != 0) && (local_res8[0] != 0)) {

+          *(longlong *)(param_1 + 0x48) = *(longlong *)(param_1 + 0x48) + local_res20;

+        }

+        if (local_res10[0] == 0) {

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

+            VsmmUpdateGpaSpaceForMbpRangeModification

+                      (plVar3,uVar7,uVar11,local_res20,0,-1,(uint *)0x0);

+            VsmmDmSlpBitmapRangeClear((longlong *)(uVar7 + 0x1c8),uVar11,lVar8);

+            LOCK();

+            *(longlong *)(plVar3[0xbd] + 0x490) = *(longlong *)(plVar3[0xbd] + 0x490) - lVar8;

+            UNLOCK();

+            iVar10 = 1;

+          }

+        }

+        else {

+          *(uint *)(param_1 + 0x204) = *(uint *)(param_1 + 0x204) | 0x100;

+        }

+      }

+      VidPushLockRelease(*(longlong *)(uVar7 + 0xf8) + (ulonglong)*(uint *)(lVar9 + 0x20) * 8);

+      VidLockRelease(plVar3 + 0x19a);

+      if (iVar5 < 0) {

+        if (iVar5 == -0x7fffffef) {

+          VsmmDmSlppRequestQueueInsert(plVar3[0x5f8],param_1);

+          return;

+        }

+      }

+      else if (iVar10 == 0) {

+        puVar2 = (undefined8 *)

+                 (param_1 + ((ulonglong)(*(int *)(param_1 + 0x200) - 1) + 0x16) * 0x10);

+        *puVar2 = 0;

+        puVar2[1] = 0;

+        uVar4 = *(int *)(param_1 + 0x200) - 1;

+        *(uint *)(param_1 + 0x200) = uVar4;

+        *(code **)(param_1 + ((ulonglong)uVar4 + 0x16) * 0x10) = VsmmDmSlppCommitAsyncPostProcess;

+        *(undefined8 *)(param_1 + 0x168 + (ulonglong)*(uint *)(param_1 + 0x200) * 0x10) = 0;

+        uVar4 = *(int *)(param_1 + 0x200) + 1;

+        *(uint *)(param_1 + 0x200) = uVar4;

+        *(code **)(param_1 + ((ulonglong)uVar4 + 0x16) * 0x10) =

+             VsmmDmSlppCommitAsyncBackingViaCommitComplete;

+        *(undefined8 *)(param_1 + 0x168 + (ulonglong)*(uint *)(param_1 + 0x200) * 0x10) = 0;

+        uVar4 = *(int *)(param_1 + 0x200) + 1;

+        uVar7 = (ulonglong)uVar4;

+        *(uint *)(param_1 + 0x200) = uVar4;

+        if (local_res10[0] == 0) {

+          *(code **)(param_1 + (uVar7 + 0x16) * 0x10) = VsmmDmSlppCommitAsyncPageIn;

+          *(undefined8 *)(param_1 + 0x168 + (ulonglong)*(uint *)(param_1 + 0x200) * 0x10) = 0;

+          *(int *)(param_1 + 0x200) = *(int *)(param_1 + 0x200) + 1;

+          uVar7 = (ulonglong)*(uint *)(param_1 + 0x200);

+        }

+        *(code **)(param_1 + (uVar7 + 0x16) * 0x10) = VsmmDmSlppCommitAsyncProvision;

+        *(undefined8 *)(param_1 + 0x168 + (ulonglong)*(uint *)(param_1 + 0x200) * 0x10) = 0;

+        goto LAB_0;

+      }

+      *(int *)(param_1 + 0x158) = iVar5;

+    }

+  }

+  puVar2 = (undefined8 *)(param_1 + ((ulonglong)(*(int *)(param_1 + 0x200) - 1) + 0x16) * 0x10);

+  *puVar2 = 0;

+  puVar2[1] = 0;

+  uVar4 = *(int *)(param_1 + 0x200) - 1;

+  *(uint *)(param_1 + 0x200) = uVar4;

+  *(code **)(param_1 + ((ulonglong)uVar4 + 0x16) * 0x10) = VsmmDmSlppCommitAsyncPostProcess;

+  *(undefined8 *)(param_1 + 0x168 + (ulonglong)*(uint *)(param_1 + 0x200) * 0x10) =

+       *(undefined8 *)(param_1 + 0x168 + (ulonglong)(*(uint *)(param_1 + 0x200) - 1) * 0x10);

+LAB_0:

+  uVar4 = *(uint *)(param_1 + 0x200);

+  *(uint *)(param_1 + 0x200) = uVar4 + 1;

+  (**(code **)(param_1 + ((ulonglong)uVar4 + 0x16) * 0x10))(param_1);

+  return;

 }
```

## `VsmmGpaRangeLookupByPageNumberPrimary`  (modified)

```diff
--- VsmmGpaRangeLookupByPageNumberPrimary
+++ VsmmGpaRangeLookupByPageNumberPrimary
@@ -1,11 +1,45 @@
-

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

 

 longlong VsmmGpaRangeLookupByPageNumberPrimary

                    (longlong *param_1,ulonglong param_2,uint param_3,uint param_4)

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  int iVar2;

+  longlong lVar3;

+  ulonglong uVar4;

+  int iVar5;

+  int iVar6;

+  

+  iVar6 = (int)param_1[3] + -1;

+  iVar5 = 0;

+  if (((1 << ((byte)(*(uint *)(*param_1 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+     (uVar4 = *(ulonglong *)(*param_1 + 0x3df0), iVar5 = 0, uVar4 <= param_2)) {

+    param_2 = param_2 - uVar4;

+  }

+LAB_0:

+  do {

+    lVar3 = 0;

+    if (iVar6 < iVar5) {

+LAB_1:

+      if ((lVar3 != 0) && (uVar4 = VidOpCtrlStart((uint *)(lVar3 + 8)), (char)uVar4 == '\0')) {

+LAB_2:

+        lVar3 = 0;

+      }

+      return lVar3;

+    }

+    iVar2 = (iVar6 - iVar5) / 2 + iVar5;

+    lVar1 = *(longlong *)(param_1[1] + (longlong)iVar2 * 8);

+    if (*(ulonglong *)(lVar1 + 0x100) <= param_2) {

+      if (param_2 <= *(ulonglong *)(lVar1 + 0x108)) {

+        if ((iVar2 != -1) &&

+           (((*(uint *)(lVar1 + 0x124) & param_3) != param_3 ||

+            (lVar3 = lVar1, (param_4 & *(uint *)(lVar1 + 0x124)) != 0)))) goto LAB_2;

+        goto LAB_1;

+      }

+      iVar5 = iVar2 + 1;

+      goto LAB_0;

+    }

+    iVar6 = iVar2 + -1;

+  } while( true );

 }
```

## `VsmmGpaRangeLookupByPageNumberNonPrimaryNoOverlap`  (modified)

```diff
--- VsmmGpaRangeLookupByPageNumberNonPrimaryNoOverlap
+++ VsmmGpaRangeLookupByPageNumberNonPrimaryNoOverlap
@@ -1,20 +1,44 @@
-

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

 

 longlong VsmmGpaRangeLookupByPageNumberNonPrimaryNoOverlap

                    (longlong *param_1,ulonglong param_2,uint param_3)

 

 {

-  uint uVar1;

-  ulonglong unaff_RDI;

+  longlong lVar1;

+  int iVar2;

+  longlong lVar3;

+  ulonglong uVar4;

+  int iVar5;

+  int iVar6;

   

-  if ((code *)param_1[10] == (code *)0x0) {

-    VidMessageBufferFree((longlong)param_1);

+  iVar5 = (int)param_1[3];

+  iVar6 = iVar5 + -1 + *(int *)((longlong)param_1 + 0x1c);

+  if (((1 << ((byte)(*(uint *)(*param_1 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

+     (uVar4 = *(ulonglong *)(*param_1 + 0x3df0), uVar4 <= param_2)) {

+    param_2 = param_2 - uVar4;

   }

-  else {

-    uVar1 = (*(code *)param_1[10])(param_1,param_1[0xb],param_1[0xc]);

-    unaff_RDI = (ulonglong)uVar1;

-  }

-  return unaff_RDI & 0xffffffff;

+LAB_0:

+  do {

+    lVar3 = 0;

+    if (iVar6 < iVar5) {

+LAB_1:

+      if ((lVar3 != 0) && (uVar4 = VidOpCtrlStart((uint *)(lVar3 + 8)), (char)uVar4 == '\0')) {

+LAB_2:

+        lVar3 = 0;

+      }

+      return lVar3;

+    }

+    iVar2 = (iVar6 - iVar5) / 2 + iVar5;

+    lVar1 = *(longlong *)(param_1[1] + (longlong)iVar2 * 8);

+    if (*(ulonglong *)(lVar1 + 0x100) <= param_2) {

+      if (param_2 <= *(ulonglong *)(lVar1 + 0x108)) {

+        if ((iVar2 != -1) && (lVar3 = lVar1, (*(uint *)(lVar1 + 0x124) & param_3) != param_3))

+        goto LAB_2;

+        goto LAB_1;

+      }

+      iVar5 = iVar2 + 1;

+      goto LAB_0;

+    }

+    iVar6 = iVar2 + -1;

+  } while( true );

 }
```

## `VsmmGpaRangeReference`  (modified)

```diff
--- VsmmGpaRangeReference
+++ VsmmGpaRangeReference
@@ -1,20 +1,8 @@
 

-ulonglong VsmmGpaRangeReference(longlong param_1)

+void VsmmGpaRangeReference(longlong param_1)

 

 {

-  int *piVar1;

-  undefined8 in_RAX;

-  ulonglong uVar2;

-  int unaff_EDI;

-  longlong unaff_R14;

-  

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

-  uVar2 = CONCAT71((int7)((ulonglong)in_RAX >> 8),((byte)in_RAX + 0x58) - ((byte)in_RAX < 0x3e));

-  piVar1 = (int *)(uVar2 + 0x103);

-  *piVar1 = *piVar1 + unaff_EDI;

-  if (*piVar1 == 0) {

-    uVar2 = (ulonglong)*(uint *)(unaff_R14 + 0x28);

-  }

-  return uVar2;

+  VidOpCtrlStart((uint *)(param_1 + 8));

+  return;

 }
```

## `VsmmDestroyGpaRange`  (modified)

```diff
--- VsmmDestroyGpaRange
+++ VsmmDestroyGpaRange
@@ -1,27 +1,246 @@
 

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

+/* WARNING: Type propagation algorithm not settling */

 

 uint VsmmDestroyGpaRange(longlong *param_1,longlong param_2,uint param_3,int param_4)

 

 {

-  longlong in_RAX;

-  uint unaff_EBX;

-  longlong in_stack_00000028;

-  longlong in_stack_00000030;

-  longlong in_stack_00000038;

+  longlong lVar1;

+  bool bVar2;

+  bool bVar3;

+  char cVar4;

+  undefined8 uVar5;

+  ulonglong uVar6;

+  longlong *plVar7;

+  byte *pbVar8;

+  longlong lVar9;

+  uint uVar10;

+  undefined1 auStackY_178 [32];

+  undefined8 local_148;

+  int local_140 [2];

+  undefined8 local_138;

+  longlong local_130;

+  undefined8 local_128;

+  undefined8 local_120;

+  undefined8 local_118;

+  longlong local_110 [5];

+  undefined8 local_e8 [4];

+  longlong local_c8 [2];

+  longlong local_b8 [2];

+  undefined8 *local_a8;

+  undefined4 local_a0;

+  undefined4 local_9c;

+  undefined8 *local_98;

+  undefined4 local_90;

+  undefined4 local_8c;

+  longlong *local_88;

+  undefined4 local_80;

+  undefined4 local_7c;

+  longlong *local_78;

+  undefined4 local_70;

+  undefined4 local_6c;

+  undefined8 *local_68;

+  undefined4 local_60;

+  undefined4 local_5c;

+  longlong *local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  ulonglong local_48;

   

-  *(int *)(in_RAX + -0x73) = *(int *)(in_RAX + -0x73) + -1;

-  VidTraceErrorInternal0((char *)param_1,(char *)param_2,param_3);

-  VidObjectLockRelease(in_stack_00000038);

-  if (in_stack_00000028 != 0) {

-    VsmmGpaRangeRelease(in_stack_00000038,in_stack_00000028,'\0');

-  }

-  if ((int)unaff_EBX < 0) {

-    VidTraceErrorStatusPartitionInternal0

-              ("VsmmVaGpaRangeIoctlQueryWorkingSetInfo",

-               "onecore\\vm\\vid\\sys\\vsmm\\vsmmvagparange.c",0x1bb,unaff_EBX,

-               in_stack_00000030 + 0x290);

-  }

-  return unaff_EBX;

+  local_48 = __security_cookie ^ (ulonglong)auStackY_178;

+  local_110[3] = 0;

+  local_110[1] = 0;

+  local_110[2] = 0;

+  bVar3 = false;

+  bVar2 = false;

+  local_148._4_4_ = param_3;

+  local_140[0] = param_4;

+  local_130 = param_2;

+  VidObjectLockAcquireExclusive((longlong)(param_1 + 0x199));

+  if ((param_2 < 1) || ((longlong)(ulonglong)*(uint *)(param_1 + 0x15e) <= param_2)) {

+LAB_0:

+    lVar9 = 0;

+  }

+  else {

+    lVar1 = *(longlong *)(param_1[0x15d] + param_2 * 8);

+    lVar9 = 0;

+    if (lVar1 < 0) {

+      lVar9 = lVar1;

+    }

+    if (lVar9 != 0) {

+      cVar4 = VsmmGpaRangeReference(lVar9);

+      if (cVar4 == '\0') goto LAB_0;

+      if (lVar9 != 0) {

+        plVar7 = (longlong *)(lVar9 + 0x128);

+        if ((*(char *)((longlong)param_1 + 0x3079) == '\0') || (*plVar7 == 0)) {

+          if ((*(int *)(lVar9 + 0x120) == 0) &&

+             (*(int *)(*(longlong *)(lVar9 + 0x180) + 0x20) != local_140[0])) {

+            uVar10 = 0xc000000d;

+            VidTraceErrorInternal0

+                      ("VsmmDestroyGpaRange","onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c",0x9a9);

+            goto LAB_1;

+          }

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

+            if ((*plVar7 != 0) &&

+               (uVar5 = VsmmGpaRangeListOverlapCheck

+                                  ((longlong)param_1,*(ulonglong *)(lVar9 + 0x100),

+                                   (*(longlong *)(lVar9 + 0x110) - *(ulonglong *)(lVar9 + 0x100)) +

+                                   1,1,lVar9), (int)uVar5 != 0)) {

+              uVar10 = 0xc037000d;

+              VidTraceErrorInternal0

+                        ("VsmmDestroyGpaRange","onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c",0x9cd);

+              goto LAB_1;

+            }

+          }

+          else if (((*(int *)(lVar9 + 0x120) != 0) || ((*(uint *)(lVar9 + 0x124) & 1) == 0)) ||

+                  (*plVar7 != 0)) {

+            uVar10 = 0xc000000d;

+            goto LAB_1;

+          }

+          if (*(int *)(lVar9 + 0x120) == 0) {

+            if (((*(uint *)(lVar9 + 0x124) & 1) != 0) &&

+               (*(int *)(*(longlong *)(lVar9 + 0x180) + 0xa8) != 1)) {

+              uVar10 = 0xc037000d;

+              if ((DAT_2 < 3) ||

+                 (uVar6 = _tlgKeywordOn(0x1400510e8,0x100), (char)uVar6 == '\0'))

+              goto LAB_1;

+              _tlgCreate1Sz_char(local_c8,"VsmmDestroyGpaRange");

+              _tlgCreate1Sz_char(local_b8,"onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c");

+              local_a8 = &local_138;

+              pbVar8 = &DAT_3;

+              local_138 = CONCAT44(local_138._4_4_,0x9e8);

+              local_148._0_4_ = *(undefined4 *)(*(longlong *)(lVar9 + 0x180) + 0xa8);

+              local_98 = &local_148;

+              local_90 = 4;

+LAB_4:

+              local_9c = 0;

+              local_a0 = 4;

+              local_8c = 0;

+              _tlgWriteTransfer_EtwWriteTransfer(0x1400510e8,pbVar8,0,0,6,local_e8);

+              goto LAB_1;

+            }

+            if ((*(uint *)(lVar9 + 0x124) & 0x45) != 0) {

+              uVar10 = VsmmMbpLockCountBlock(*(longlong *)(lVar9 + 0x180));

+              if ((int)uVar10 < 0) {

+                if ((DAT_2 < 3) ||

+                   (uVar6 = _tlgKeywordOn(0x1400510e8,0x100), (char)uVar6 == '\0'))

+                goto LAB_1;

+                _tlgCreate1Sz_char(local_c8,"VsmmDestroyGpaRange");

+                _tlgCreate1Sz_char(local_b8,"onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c");

+                local_a8 = &local_148;

+                pbVar8 = &DAT_5;

+                local_148._0_4_ = 0xa07;

+                local_138 = *(undefined8 *)(*(longlong *)(lVar9 + 0x180) + 0x38);

+                local_98 = &local_138;

+                local_90 = 8;

+                goto LAB_4;

+              }

+              bVar3 = true;

+              param_3 = local_148._4_4_;

+            }

+          }

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

+             (uVar10 = VsmmGpaRangeRestrictAndVerifyDefaultVtlPermissions(param_1,lVar9),

+             (int)uVar10 < 0)) {

+            if (bVar3) {

+              VsmmMbpLockCountUnblock(*(longlong *)(lVar9 + 0x180));

+            }

+            goto LAB_1;

+          }

+          if (*(int *)(lVar9 + 0x120) == 1) {

+            *(uint *)(lVar9 + 0x124) = *(uint *)(lVar9 + 0x124) | 0x800;

+          }

+          else if (((*(int *)(lVar9 + 0x120) == 0) && ((*(uint *)(lVar9 + 0x124) & 1) != 0)) &&

+                  (uVar6 = (ulonglong)*(byte *)(*(longlong *)(lVar9 + 0x180) + 0x10),

+                  param_1[uVar6 + 0x640] == *(longlong *)(lVar9 + 0x108) + 1)) {

+            param_1[uVar6 + 0x640] = 0;

+          }

+          VidRefCounterDelete((uint *)(lVar9 + 8));

+          if (((*(int *)(lVar9 + 0x120) == 0) &&

+              ((*(uint *)(*(longlong *)(lVar9 + 0x180) + 0x14) & 1) != 0)) &&

+             ((*(uint *)(lVar9 + 0x124) & 1) == 0)) {

+            bVar2 = true;

+            KeInitializeEvent(local_110 + 1,0);

+            *(longlong **)(lVar9 + 0x178) = local_110 + 1;

+          }

+        }

+        uVar10 = 0;

+        goto LAB_1;

+      }

+    }

+  }

+  uVar10 = 0xc0370015;

+  VidTraceErrorInternal0("VsmmDestroyGpaRange","onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c",0x996);

+LAB_1:

+  plVar7 = param_1 + 0x199;

+  VidObjectLockRelease((longlong)plVar7);

+  if (lVar9 != 0) {

+    if (((int)uVar10 < 0) && (2 < DAT_2)) {

+      plVar7 = (longlong *)&DAT_2;

+      uVar6 = _tlgKeywordOn(0x1400510e8,0x100);

+      if ((char)uVar6 != '\0') {

+        _tlgCreate1Sz_char(local_c8,"VsmmDestroyGpaRange");

+        _tlgCreate1Sz_char(local_b8,"onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c");

+        local_9c = 0;

+        local_a8 = &local_148;

+        local_8c = 0;

+        local_7c = 0;

+        plVar7 = (longlong *)&DAT_2;

+        local_6c = 0;

+        local_5c = 0;

+        local_4c = 0;

+        local_98 = &local_138;

+        local_128 = *(undefined8 *)(lVar9 + 0xf8);

+        local_88 = &local_128;

+        local_120 = *(undefined8 *)(lVar9 + 0x100);

+        local_78 = &local_120;

+        local_118 = *(undefined8 *)(lVar9 + 0x108);

+        local_68 = &local_118;

+        local_110[0] = (longlong)*(int *)(lVar9 + 0x124);

+        local_58 = local_110;

+        local_148._0_4_ = 0xa62;

+        local_a0 = 4;

+        local_138 = CONCAT44(local_138._4_4_,uVar10);

+        local_90 = 4;

+        local_80 = 8;

+        local_70 = 8;

+        local_60 = 8;

+        local_50 = 8;

+        _tlgWriteTransfer_EtwWriteTransfer(0x1400510e8,&DAT_6,0,0,10,local_e8);

+      }

+    }

+    VsmmGpaRangeRelease(plVar7,lVar9,'\0');

+  }

+  if ((int)uVar10 < 0) {

+    if ((2 < DAT_2) && (uVar6 = _tlgKeywordOn(0x1400510e8,0x100), (char)uVar6 != '\0')) {

+      _tlgCreate1Sz_char(local_c8,"VsmmDestroyGpaRange");

+      _tlgCreate1Sz_char(local_b8,"onecore\\vm\\vid\\sys\\vsmm\\vsmmapi.c");

+      local_9c = 0;

+      local_a8 = &local_148;

+      local_8c = 0;

+      local_7c = 0;

+      local_6c = 0;

+      local_5c = 0;

+      local_4c = 0;

+      local_98 = &local_138;

+      local_88 = param_1 + 0x52;

+      local_78 = &local_130;

+      local_68 = (undefined8 *)((longlong)&local_148 + 4);

+      local_58 = (longlong *)local_140;

+      local_148._0_4_ = 0xa7a;

+      local_a0 = 4;

+      local_138 = CONCAT44(local_138._4_4_,uVar10);

+      local_90 = 4;

+      local_80 = 0x10;

+      local_70 = 8;

+      local_60 = 4;

+      local_50 = 4;

+      _tlgWriteTransfer_EtwWriteTransfer(0x1400510e8,&DAT_7,0,0,10,local_e8);

+    }

+  }

+  else if (bVar2) {

+    KeWaitForSingleObject(local_110 + 1,0,0,0);

+  }

+  return uVar10;

 }
```

## `VidOpCtrlStart`  (modified)

```diff
--- VidOpCtrlStart
+++ VsmmHandleMemoryIntercept
@@ -1,30 +1,10 @@
 

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

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

 

-ulonglong VidOpCtrlStart(uint *param_1)

+undefined8 VsmmHandleMemoryIntercept(longlong *param_1)

 

 {

-  longlong lVar1;

-  longlong unaff_RBP;

-  ulonglong unaff_RSI;

-  longlong *unaff_R12;

-  longlong unaff_R13;

-  ulonglong unaff_R14;

-  char in_SF;

-  char in_OF;

-  char in_stack_00000043;

-  longlong *in_stack_00000050;

-  int in_stack_00000058;

-  

-  if ((in_OF == in_SF) &&

-     ((&stack0x00000048)[(longlong)param_1] =

-           (&stack0x00000048)[(longlong)param_1] + (char)unaff_RSI, in_stack_00000058 == 0)) {

-    ExFreePoolWithTag();

-  }

-  if ((in_stack_00000043 != '\0') && (lVar1 = *unaff_R12, lVar1 != unaff_RBP)) {

-    VsmmUpdateGpaSpaceForMbpRangeModification

-              (in_stack_00000050,unaff_R14,lVar1 + unaff_R13,unaff_RBP - lVar1,0,-1,(uint *)0x0);

-  }

-  return unaff_RSI & 0xffffffff;

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

+  halt_baddata();

 }
```

## `VidHandlePartitionInsufficientMemoryIntercept`  (modified)

```diff
--- VidHandlePartitionInsufficientMemoryIntercept
+++ VidHandlePartitionInsufficientMemoryIntercept
@@ -1,14 +1,25 @@
 

 void VidHandlePartitionInsufficientMemoryIntercept(longlong param_1,longlong param_2)

 

 {

-  char in_AL;

-  undefined7 in_register_00000001;

+  char cVar1;

+  ulonglong uVar2;

   

-  *(char *)CONCAT71(in_register_00000001,in_AL) =

-       *(char *)CONCAT71(in_register_00000001,in_AL) + in_AL;

-  *(undefined8 *)((ulonglong)((int)&stack0x00000000 + 0x3e) - 8) = 0x14000c4f8;

-  KeInsertQueueDpc();

+  LOCK();

+  cVar1 = *(char *)(param_1 + 0x3e70);

+  *(char *)(param_1 + 0x3e70) = '\x01';

+  UNLOCK();

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

+    uVar2 = VidOpCtrlStart((uint *)(param_1 + 0x2b0));

+    if ((char)uVar2 == '\0') {

+      *(undefined1 *)(param_1 + 0x3e70) = 0;

+    }

+    else {

+      *(undefined2 *)(param_1 + 0x3ec0) = *(undefined2 *)(param_2 + 4);

+      *(undefined8 *)(param_1 + 0x3ec4) = *(undefined8 *)(param_2 + 8);

+      KeInsertQueueDpc(param_1 + 0x3e78,0,0);

+    }

+  }

   return;

 }
```

## `VidManagedBufferListElementRequest`  (modified)

```diff
--- VidManagedBufferListElementRequest
+++ VidManagedBufferListElementRequest
@@ -1,27 +1,18 @@
 

 longlong VidManagedBufferListElementRequest(longlong param_1,ulonglong param_2)

 

 {

-  longlong lVar1;

-  ulonglong uVar2;

-  ulonglong unaff_R14;

+  ulonglong uVar1;

+  longlong lVar2;

   

-  InitializeSListHead((PSLIST_HEADER)param_1);

-  if ((param_2 & 0xf) != 0) {

-    param_2 = param_2 + 0x10 & 0xfffffffffffffff0;

+  uVar1 = VidOpCtrlStart((uint *)(param_1 + 8));

+  if ((char)uVar1 != '\0') {

+    if ((param_2 <= *(ulonglong *)(param_1 + 0x90)) &&

+       (lVar2 = ExpInterlockedPopEntrySList(param_1 + 0x70), lVar2 != 0)) {

+      return lVar2;

+    }

+    VidOpCtrlFinish((uint *)(param_1 + 8));

   }

-  uVar2 = 0;

-  while( true ) {

-    if (unaff_R14 <= uVar2) {

-      return 0;

-    }

-    lVar1 = ExAllocatePool2(0x40,param_2,0x72446456);

-    if (lVar1 == 0) break;

-    ExpInterlockedPushEntrySList(param_1,lVar1);

-    *(longlong *)(param_1 + 0x10) = *(longlong *)(param_1 + 0x10) + 1;

-    uVar2 = uVar2 + 1;

-  }

-  VidBufferListTeardown(param_1);

-  return 0xc000009a;

+  return 0;

 }
```

## `VsmmVaGpaCoreProcessTeardown`  (modified)

```diff
--- VsmmVaGpaCoreProcessTeardown
+++ VsmmVaGpaCoreProcessTeardown
@@ -1,41 +1,212 @@
 

-int VsmmVaGpaCoreProcessTeardown(ulonglong param_1,undefined8 param_2,undefined8 param_3)

+void VsmmVaGpaCoreProcessTeardown

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

 

 {

   longlong lVar1;

-  ulonglong uVar2;

-  undefined8 *puVar3;

-  ulonglong uVar4;

-  int unaff_EBX;

-  longlong unaff_RBP;

-  uint unaff_ESI;

-  longlong unaff_R12;

-  ulonglong *unaff_R14;

-  uint unaff_R15D;

+  byte bVar2;

+  longlong lVar3;

+  code *pcVar4;

+  bool bVar5;

+  undefined1 *puVar6;

+  ulonglong uVar7;

+  undefined8 *puVar8;

+  undefined8 *puVar9;

+  ulonglong *puVar10;

+  ulonglong *puVar11;

+  ulonglong *puVar12;

+  undefined1 *puVar13;

+  undefined1 *puVar14;

+  longlong *plVar15;

+  ulonglong *puVar16;

+  bool bVar17;

+  bool bVar18;

+  undefined1 auStack_68 [8];

+  undefined1 auStack_60 [40];

+  undefined8 ***local_38;

+  undefined8 ***local_30;

   

-  if ((*(byte *)(unaff_RBP + -0x7b) & 0xed) != 0) {

-    do {

-      if (unaff_R15D < unaff_ESI) break;

-      uVar4 = *unaff_R14;

-      *(ulonglong *)(unaff_RBP + 0x58) = uVar4;

-      lVar1 = uVar4 - 1;

-      uVar2 = unaff_R14[1];

-      while ((uVar4 <= lVar1 + uVar2 &&

-             (puVar3 = VsmmVaGpaCorepFindRange

-                                 (unaff_R12,unaff_RBP + 0x58,(ulonglong *)(unaff_RBP + -0x10)),

-             puVar3 != (undefined8 *)0x0))) {

-        if ((unaff_EBX < 0) && (*(char *)((longlong)puVar3 + 100) != '\0')) {

-          VsmmVaGpaCorepGpaRangeUnpinInternal((longlong)puVar3);

+  lVar3 = VidDeviceExtension;

+  puVar13 = auStack_68;

+  puVar14 = auStack_68;

+  local_30 = &local_38;

+  local_38 = &local_38;

+  plVar15 = (longlong *)0x0;

+  bVar5 = false;

+  lVar1 = VidDeviceExtension + 0x770;

+  VidLockAcquireExclusive(lVar1);

+  uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

+  bVar17 = (int)uVar7 != 0;

+  puVar8 = *(undefined8 **)(lVar3 + 0x760U);

+  if (((*(byte *)(lVar3 + 0x768) & 1) != 0) && (puVar8 != (undefined8 *)0x0)) {

+    puVar8 = (undefined8 *)((ulonglong)puVar8 ^ (ulonglong)(lVar3 + 0x760U));

+  }

+  bVar2 = *(byte *)(lVar3 + 0x768);

+  while (puVar9 = puVar8, puVar9 != (undefined8 *)0x0) {

+    param_2 = puVar9;

+    uVar7 = VsmmVaGpaCorepCompareForMemoryHostTree((ulonglong)param_1,(longlong)puVar9);

+    if ((int)uVar7 < 0) {

+      puVar8 = (undefined8 *)*puVar9;

+    }

+    else {

+      if ((int)uVar7 < 1) break;

+      puVar8 = (undefined8 *)puVar9[1];

+    }

+    if (((bVar2 & 1) != 0) && (puVar8 != (undefined8 *)0x0)) {

+      puVar8 = (undefined8 *)((ulonglong)puVar9 ^ (ulonglong)puVar8);

+    }

+  }

+  uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

+  puVar6 = auStack_68;

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

+    if (puVar9 == (undefined8 *)0x0) goto LAB_0;

+    uVar7 = VidOpCtrlStartEx((uint *)(puVar9[3] + 0x2b0),'\x01');

+    if ((char)uVar7 == '\0') {

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

+      (*pcVar4)();

+      puVar13 = auStack_60;

+    }

+    plVar15 = (longlong *)puVar9[3];

+    puVar6 = puVar13;

+  }

+  puVar14 = puVar6;

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1970;

+  VidLockRelease(lVar1);

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1975;

+  uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

+  param_2 = (undefined8 *)0x0;

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

+    param_2 = (undefined8 *)(ulonglong)bVar17;

+  }

+  bVar17 = SUB81(param_2,0);

+  if (puVar9 == (undefined8 *)0x0) goto LAB_0;

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1991;

+  uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

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

+    puVar8 = puVar9 + -3;

+    lVar3 = puVar9[3];

+    *(undefined8 *)(puVar14 + -8) = 0x1400a19a9;

+    VidObjectLockAcquireExclusive(lVar3 + 0xcc8);

+    lVar3 = puVar9[3];

+    *(undefined8 *)(puVar14 + -8) = 0x1400a19b9;

+    VidObjectLockAcquireExclusive(lVar3 + 0x3980);

+    param_1 = param_2;

+    bVar18 = false;

+  }

+  else {

+    *(undefined8 *)(puVar14 + -8) = 0x1400a19c7;

+    VidObjectLockAcquireExclusive((longlong)(plVar15 + 0x199));

+    *(undefined8 *)(puVar14 + -8) = 0x1400a19d3;

+    VidObjectLockAcquireExclusive((longlong)(plVar15 + 0x730));

+    bVar5 = true;

+    *(undefined8 *)(puVar14 + -8) = 0x1400a19e1;

+    puVar8 = VsmmVaGpaCorepGetProcessContext((longlong)plVar15,(ulonglong)param_1);

+    param_2 = param_1;

+    bVar18 = true;

+    if (puVar8 == (undefined8 *)0x0) goto LAB_0;

+  }

+  bVar5 = bVar18;

+  lVar3 = puVar8[6];

+  *(undefined8 *)(puVar14 + -8) = 0x1400a19fd;

+  VidLockAcquireShared(lVar3 + 0x3990);

+  puVar12 = (ulonglong *)puVar8[9];

+  if (((ulonglong)puVar12 & 1) == 0) {

+LAB_1:

+    while (puVar12 != (ulonglong *)0x0) {

+      puVar11 = (ulonglong *)puVar12[1];

+      puVar10 = puVar12;

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

+        do {

+          puVar11 = (ulonglong *)(puVar10[2] & 0xfffffffffffffffc);

+          if (puVar11 == (ulonglong *)0x0) break;

+          bVar18 = (ulonglong *)*puVar11 != puVar10;

+          puVar10 = puVar11;

+        } while (bVar18);

+      }

+      else {

+        for (puVar10 = (ulonglong *)*puVar11; puVar10 != (ulonglong *)0x0;

+            puVar10 = (ulonglong *)*puVar10) {

+          puVar11 = puVar10;

         }

-        uVar4 = puVar3[8] + 1;

-        *(undefined1 *)((longlong)puVar3 + 100) = 0;

-        *(ulonglong *)(unaff_RBP + 0x58) = uVar4;

       }

-      unaff_ESI = unaff_ESI + 1;

-      unaff_R14 = unaff_R14 + 2;

-    } while (unaff_ESI < *(uint *)(unaff_RBP + 0x50));

-  }

-  VsmmVaGpaCorepAttemptMergeAllRanges(unaff_R12);

-  return unaff_EBX;

+      puVar16 = puVar12 + 6;

+      for (puVar10 = (ulonglong *)*puVar16; puVar12 = puVar11, puVar10 != puVar16;

+          puVar10 = (ulonglong *)*puVar10) {

+        param_1 = (undefined8 *)puVar10[4];

+        param_4 = (longlong *)(puVar14 + 0x30);

+        lVar3 = puVar8[6];

+        *(undefined8 *)(puVar14 + -8) = 0x1400a1a74;

+        VsmmVaGpaCorepGpaRangeDelete(lVar3,param_1,param_3,(longlong)param_4);

+      }

+    }

+  }

+  else if (puVar12 != (ulonglong *)0x1) {

+    puVar12 = (ulonglong *)(((ulonglong)(puVar8 + 8) | 1) ^ (ulonglong)puVar12);

+    goto LAB_1;

+  }

+  lVar3 = puVar8[6];

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1a91;

+  VidLockRelease(lVar3 + 0x3990);

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1a96;

+  uVar7 = Feature_709781817__private_IsEnabledDeviceUsageNoInline();

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

+    *(undefined8 *)(puVar14 + -8) = 0x1400a1a9f;

+    uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

+    if ((int)uVar7 != 0) goto LAB_2;

+    if (*(undefined1 **)(puVar14 + 0x30) != puVar14 + 0x30) {

+      *(undefined8 *)(puVar14 + 0x20) = 0;

+      param_4 = (longlong *)(puVar14 + 0x30);

+      puVar9 = (undefined8 *)puVar8[6];

+      param_3 = 0;

+      param_1 = (undefined8 *)0x1;

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1aca;

+      VsmmVaGpaCorepCommit(puVar9,1,(longlong *)0x0,param_4,*(longlong **)(puVar14 + 0x20));

+    }

+    lVar3 = puVar8[6];

+    *(undefined8 *)(puVar14 + -8) = 0x1400a1ada;

+    VidObjectLockRelease(lVar3 + 0x3980);

+    puVar8 = (undefined8 *)puVar8[6];

+  }

+  else {

+LAB_2:

+    puVar8 = (undefined8 *)puVar8[6];

+    if (*(undefined1 **)(puVar14 + 0x30) != puVar14 + 0x30) {

+      *(undefined8 *)(puVar14 + 0x20) = 0;

+      param_4 = (longlong *)(puVar14 + 0x30);

+      param_3 = 0;

+      param_1 = (undefined8 *)0x1;

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1b11;

+      VsmmVaGpaCorepCommit(puVar8,1,(longlong *)0x0,param_4,*(longlong **)(puVar14 + 0x20));

+    }

+    *(undefined8 *)(puVar14 + -8) = 0x1400a1b16;

+    uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

+    param_2 = param_1;

+    if ((int)uVar7 != 0) goto LAB_0;

+    *(undefined8 *)(puVar14 + -8) = 0x1400a1b26;

+    VidObjectLockRelease((longlong)(puVar8 + 0x730));

+  }

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1b32;

+  VidObjectLockRelease((longlong)(puVar8 + 0x199));

+  param_2 = param_1;

+LAB_0:

+  *(undefined8 *)(puVar14 + -8) = 0x1400a1b37;

+  uVar7 = Feature_2798276923__private_IsEnabledDeviceUsageNoInline();

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

+    if (bVar17 != false) {

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1b48;

+      VidLockRelease(lVar1);

+    }

+    if (bVar5) {

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1b59;

+      VidObjectLockRelease((longlong)(plVar15 + 0x730));

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1b65;

+      VidObjectLockRelease((longlong)(plVar15 + 0x199));

+    }

+    if (plVar15 != (longlong *)0x0) {

+      *(undefined8 *)(puVar14 + -8) = 0x1400a1b72;

+      VidDereferencePartition(plVar15,(undefined *)param_2,param_3,param_4);

+    }

+  }

+  return;

 }
```

## `VsmmGpaRangeLookupGpaByMbp`  (modified)

```diff
--- VsmmGpaRangeLookupGpaByMbp
+++ VsmmGpaRangeLookupGpaByMbp
@@ -1,16 +1,66 @@
-

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

 

 undefined4

 VsmmGpaRangeLookupGpaByMbp

           (longlong param_1,longlong param_2,ulonglong param_3,uint param_4,uint param_5,

           longlong *param_6,longlong *param_7)

 

 {

-  longlong in_RAX;

+  longlong lVar1;

+  ulonglong uVar2;

+  char cVar3;

+  longlong *plVar4;

+  uint uVar5;

+  undefined4 unaff_R12D;

+  uint uVar6;

+  uint local_res10 [2];

+  ulonglong local_res18;

+  uint local_res20;

   

-  *(int *)(in_RAX + -0x73) = *(int *)(in_RAX + -0x73) + -1;

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

-  halt_baddata();

+  local_res10[0] = 0x7fffffff;

+  if (*(int *)(param_2 + 0xa8) == 0) {

+    return unaff_R12D;

+  }

+  local_res18 = param_3;

+  local_res20 = param_4;

+  plVar4 = (longlong *)VsmmGpaRangeListAcquireReadOnly(param_1,local_res10);

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

+    uVar6 = *(uint *)((longlong)plVar4 + 0x14);

+  }

+  else {

+    if ((*(uint *)(param_2 + 0x14) & 1) == 0) goto LAB_0;

+    uVar6 = *(uint *)(plVar4 + 3);

+  }

+  for (uVar5 = 0; uVar5 < uVar6; uVar5 = uVar5 + 1) {

+    lVar1 = *(longlong *)(plVar4[1] + (ulonglong)uVar5 * 8);

+    if ((((*(int *)(lVar1 + 0x120) == 0) && (*(longlong *)(lVar1 + 0x180) == param_2)) &&

+        ((param_5 & *(uint *)(lVar1 + 0x124)) == 0 &&

+         (*(uint *)(lVar1 + 0x124) & param_4) == param_4)) &&

+       ((uVar2 = *(ulonglong *)(lVar1 + 0x188), local_res18 == 0xffffffffffffffff ||

+        ((param_4 = local_res20, uVar2 <= local_res18 &&

+         (local_res18 <= (*(longlong *)(lVar1 + 0x108) - *(longlong *)(lVar1 + 0x100)) + uVar2))))))

+    {

+      if (param_7 != (longlong *)0x0) {

+        cVar3 = VsmmGpaRangeReference(lVar1);

+        param_4 = local_res20;

+        if (cVar3 == '\0') goto LAB_1;

+        *param_7 = lVar1;

+      }

+      if (param_6 != (longlong *)0x0) {

+        if (local_res18 == 0xffffffffffffffff) {

+          *param_6 = -1;

+        }

+        else {

+          *param_6 = (*(longlong *)(lVar1 + 0x100) - uVar2) + local_res18;

+        }

+      }

+      break;

+    }

+LAB_1:

+  }

+LAB_0:

+  if (plVar4 != (longlong *)0x0) {

+    VsmmGpaRangeListReleaseReadOnly(plVar4,(ulonglong)local_res10[0]);

+  }

+  return unaff_R12D;

 }
```

## `VsmmHvControlGpaAccessTracking`  (modified)

```diff
--- VsmmHvControlGpaAccessTracking
+++ VsmmHvControlGpaAccessTracking
@@ -1,17 +1,149 @@
-

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

 

 int VsmmHvControlGpaAccessTracking

               (char *param_1,ulonglong param_2,int param_3,ulonglong param_4,undefined8 param_5,

               longlong *param_6,longlong *param_7,uint param_8)

 

 {

-  undefined1 *unaff_RSI;

-  undefined1 *unaff_RDI;

+  longlong lVar1;

+  bool bVar2;

+  char cVar3;

+  int iVar4;

+  ulonglong uVar5;

+  longlong *plVar6;

+  undefined8 uVar7;

+  char *pcVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  longlong lVar11;

+  ulonglong uVar12;

+  ulonglong uVar13;

+  uint local_64;

+  uint local_60;

+  ulonglong local_58;

+  longlong *local_50;

+  longlong local_48;

+  ulonglong local_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

   

-  *unaff_RDI = *unaff_RSI;

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

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

-  halt_baddata();

+  local_38 = 0;

+  uStack_30 = 0;

+  local_64 = 0;

+  lVar10 = 0;

+  local_50 = (longlong *)0x0;

+  if (param_6 != (longlong *)0x0) {

+    *param_6 = 0;

+  }

+  if (param_7 != (longlong *)0x0) {

+    *param_7 = 0;

+  }

+  if (param_3 < 3) {

+    if (((param_8 & 1) == 0) &&

+       ((param_1[0x3828] != '\0' || ((*(uint *)(param_1 + 0x10) >> 9 & 1) != 0)))) {

+      iVar4 = -0x3ffffff3;

+      pcVar8 = "VsmmHvControlGpaAccessTracking";

+      VidTraceErrorStatusInternal0

+                ("VsmmHvControlGpaAccessTracking","onecore\\vm\\vid\\sys\\vsmm\\vsmmhv.c",0x683,

+                 0xc000000d);

+    }

+    else {

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

+        RtlInitializeBitMapEx(&local_38,param_5,param_4);

+      }

+      uVar5 = VidOpCtrlStart((uint *)(param_1 + 0x3908));

+      if ((char)uVar5 != '\0') {

+        bVar2 = true;

+        pcVar8 = param_1;

+        iVar4 = VsmmHvpControlGpaAccessTrackingQueryHv

+                          ((longlong)param_1,param_2,param_3,param_4,(longlong)&local_38,param_6,

+                           param_8);

+        if (iVar4 < 0) {

+          pcVar8 = "VsmmHvControlGpaAccessTracking";

+          VidTraceErrorStatusInternal0

+                    ("VsmmHvControlGpaAccessTracking","onecore\\vm\\vid\\sys\\vsmm\\vsmmhv.c",0x6aa,

+                     iVar4);

+        }

+        else if (((param_8 & 2) != 0) || ((param_8 & 4) != 0)) {

+          local_60 = param_3 * 9;

+          pcVar8 = (char *)(ulonglong)local_60;

+          local_48 = 1L << ((byte)local_60 & 0x3f);

+          uVar5 = (param_4 << ((byte)local_60 & 0x3f)) + -1 + param_2;

+          local_58 = uVar5;

+          local_40 = param_2;

+          while (lVar11 = 0, lVar10 = lVar11, param_2 <= uVar5) {

+            plVar6 = (longlong *)VsmmGpaRangeListAcquireReadOnly((longlong)param_1,&local_64);

+            uVar13 = 0;

+            uVar5 = local_58;

+            local_50 = plVar6;

+            while ((lVar10 = lVar11, (uint)uVar13 < *(uint *)(plVar6 + 3) &&

+                   (((lVar1 = *(longlong *)(plVar6[1] + uVar13 * 8),

+                     *(ulonglong *)(lVar1 + 0x108) < param_2 ||

+                     ((*(ulonglong *)(lVar1 + 0x100) <= uVar5 &&

+                      (cVar3 = VsmmGpaRangeReference(lVar1), uVar5 = local_58, lVar10 = lVar1,

+                      plVar6 = local_50, cVar3 == '\0')))) &&

+                    (lVar10 = lVar11, *(ulonglong *)(lVar1 + 0x100) <= uVar5))))) {

+              uVar13 = (ulonglong)((uint)uVar13 + 1);

+            }

+            VsmmGpaRangeListReleaseReadOnly(local_50,(ulonglong)local_64);

+            uVar5 = local_58;

+            if (lVar10 == 0) {

+              bVar2 = true;

+              goto LAB_0;

+            }

+            uVar13 = *(ulonglong *)(lVar10 + 0x100);

+            uVar12 = uVar13;

+            if (uVar13 <= param_2) {

+              uVar12 = param_2;

+            }

+            uVar12 = uVar12 & ~(local_48 - 1U);

+            uVar9 = *(ulonglong *)(lVar10 + 0x108);

+            if (local_58 <= *(ulonglong *)(lVar10 + 0x108)) {

+              uVar9 = local_58;

+            }

+            pcVar8 = *(char **)(lVar10 + 0x180);

+            uVar7 = VsmmMemoryBlockQueryPageRangeAccess

+                              ((longlong)pcVar8,local_40,uVar12,

+                               (*(longlong *)(lVar10 + 0x188) - uVar13) + uVar12,param_3,

+                               ((uVar9 >> ((byte)local_60 & 0x3f)) -

+                               (uVar12 >> ((byte)local_60 & 0x3f))) + 1,(longlong)&local_38,param_6,

+                               param_7,(byte)param_8);

+            iVar4 = (int)uVar7;

+            if (iVar4 < 0) {

+              pcVar8 = "VsmmHvControlGpaAccessTracking";

+              VidTraceErrorStatusInternal0

+                        ("VsmmHvControlGpaAccessTracking","onecore\\vm\\vid\\sys\\vsmm\\vsmmhv.c",

+                         0x6ec,iVar4);

+              break;

+            }

+            lVar11 = *(longlong *)(lVar10 + 0x108);

+            VsmmGpaRangeRelease(pcVar8,lVar10,'\0');

+            param_2 = lVar11 + 1;

+          }

+        }

+        goto LAB_1;

+      }

+      iVar4 = -0x3ffffe7c;

+      pcVar8 = "VsmmHvControlGpaAccessTracking";

+      VidTraceErrorStatusInternal0

+                ("VsmmHvControlGpaAccessTracking","onecore\\vm\\vid\\sys\\vsmm\\vsmmhv.c",0x69b,

+                 0xc0000184);

+    }

+  }

+  else {

+    iVar4 = -0x3ffffff3;

+    pcVar8 = "VsmmHvControlGpaAccessTracking";

+    VidTraceErrorInternal0

+              ("VsmmHvControlGpaAccessTracking","onecore\\vm\\vid\\sys\\vsmm\\vsmmhv.c",0x675);

+  }

+  bVar2 = false;

+LAB_1:

+  if (lVar10 != 0) {

+    VsmmGpaRangeRelease(pcVar8,lVar10,'\0');

+  }

+LAB_0:

+  if (bVar2) {

+    VidOpCtrlFinish((uint *)(param_1 + 0x3908));

+  }

+  return iVar4;

 }
```

## `VsmmGpaRangeLookupByHandle`  (modified)

```diff
--- VsmmGpaRangeLookupByHandle
+++ VsmmGpaRangeLookupByHandle
@@ -1,74 +1,26 @@
-

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

 

 ulonglong VsmmGpaRangeLookupByHandle(longlong param_1,longlong param_2)

 

 {

-  char *pcVar1;

-  uint uVar2;

-  char *in_RAX;

-  undefined8 *puVar3;

-  ulonglong uVar4;

-  longlong unaff_RBX;

-  ulonglong uVar5;

-  longlong unaff_RDI;

-  ulonglong uVar6;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  longlong lVar7;

-  ulonglong unaff_R15;

-  longlong in_stack_00000040;

+  char cVar1;

+  ulonglong uVar2;

+  ulonglong uVar3;

   

-  pcVar1 = (char *)(unaff_RBX + -0x49 + param_1 * 4);

-  *pcVar1 = *pcVar1 + (char)param_1;

-  *(char *)param_1 = (char)in_RAX;

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

-  lVar7 = unaff_R14 * 0x1000 + *(longlong *)(*(longlong *)(unaff_RDI + 0x180) + 0x310);

-  uVar6 = 0;

-  do {

-    if (unaff_R15 <= uVar6) {

-      uVar2 = 0;

-LAB_0:

-      VidObjectLockRelease(in_stack_00000040);

-      if (unaff_RDI != 0) {

-        VsmmGpaRangeRelease(in_stack_00000040,unaff_RDI,'\0');

-      }

-      if ((int)uVar2 < 0) {

-        VidTraceErrorStatusPartitionInternal0

-                  ("VsmmVaGpaRangeIoctlQueryWorkingSetInfo",

-                   "onecore\\vm\\vid\\sys\\vsmm\\vsmmvagparange.c",0x1bb,uVar2,unaff_R13 + 0x290);

-      }

-      return (ulonglong)uVar2;

+  if ((param_2 < 1) || ((longlong)(ulonglong)*(uint *)(param_1 + 0xaf0) <= param_2)) {

+    uVar3 = 0;

+  }

+  else {

+    uVar3 = *(ulonglong *)(*(longlong *)(param_1 + 0xae8) + param_2 * 8);

+    uVar2 = 0;

+    if ((longlong)uVar3 < 0) {

+      uVar2 = uVar3;

     }

-    uVar5 = 0x20;

-    if (unaff_R15 - uVar6 < 0x20) {

-      uVar5 = unaff_R15 - uVar6;

+    uVar3 = 0;

+    if (uVar2 != 0) {

+      cVar1 = VsmmGpaRangeReference(uVar2);

+      uVar3 = uVar2 & -(ulonglong)(cVar1 != '\0');

     }

-    if (uVar5 != 0) {

-      puVar3 = (undefined8 *)&stack0x00000068;

-      uVar4 = uVar5;

-      do {

-        puVar3[-1] = lVar7;

-        *puVar3 = 0;

-        lVar7 = lVar7 + 0x1000;

-        puVar3 = puVar3 + 2;

-        uVar4 = uVar4 - 1;

-      } while (uVar4 != 0);

-    }

-    uVar2 = ZwQueryVirtualMemory

-                      (*(undefined8 *)(unaff_R13 + 0x37c8),0,4,&stack0x00000060,uVar5 << 4);

-    if ((int)uVar2 < 0) {

-      VidTraceErrorInternal0

-                ("VsmmVaGpaRangeIoctlQueryWorkingSetInfo",

-                 "onecore\\vm\\vid\\sys\\vsmm\\vsmmvagparange.c",0x18e);

-      goto LAB_0;

-    }

-    for (uVar4 = 0; uVar4 < uVar5; uVar4 = uVar4 + 1) {

-      if (((&stack0x00000068)[uVar4 * 0x10] & 1) != 0) {

-        RtlSetBitEx(&stack0x00000048);

-      }

-    }

-    uVar6 = uVar6 + uVar5;

-  } while( true );

+  }

+  return uVar3;

 }
```

## `VsmmGpaRangeLookupByPageNumber`  (modified)

```diff
--- VsmmGpaRangeLookupByPageNumber
+++ VidLockRelease
@@ -1,27 +1,100 @@
 

-longlong VsmmGpaRangeLookupByPageNumber

-                   (longlong *param_1,ulonglong param_2,uint param_3,uint param_4)

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

+

+int VidLockRelease(undefined8 param_1)

 

 {

-  longlong lVar1;

-  ulonglong uVar2;

-  uint uVar3;

+  ulonglong in_RAX;

+  ulonglong uVar1;

+  int unaff_ESI;

+  longlong unaff_R12;

+  longlong unaff_R15;

+  undefined8 in_stack_00000060;

+  undefined4 uStack0000000000000068;

+  undefined8 in_stack_00000070;

+  undefined8 in_stack_00000080;

+  undefined8 uStack0000000000000098;

+  undefined8 uStack00000000000000a0;

+  undefined1 *puStack00000000000000f0;

+  undefined8 uStack00000000000000f8;

+  undefined1 *puStack0000000000000100;

+  undefined8 uStack0000000000000108;

+  undefined1 *puStack0000000000000110;

+  undefined8 uStack0000000000000118;

+  undefined1 *puStack0000000000000120;

+  undefined8 uStack0000000000000128;

+  undefined1 *puStack0000000000000130;

+  undefined8 uStack0000000000000138;

+  undefined1 *puStack0000000000000140;

+  undefined8 uStack0000000000000148;

+  undefined1 *puStack0000000000000150;

+  undefined8 uStack0000000000000158;

+  undefined1 *puStack0000000000000160;

+  undefined8 uStack0000000000000168;

+  undefined8 *puStack0000000000000170;

+  undefined8 uStack0000000000000178;

+  undefined8 *puStack0000000000000180;

+  undefined8 uStack0000000000000188;

+  undefined1 *puStack0000000000000190;

+  undefined8 uStack0000000000000198;

+  undefined1 *puStack00000000000001a0;

+  undefined8 uStack00000000000001a8;

   

-  uVar3 = *(uint *)((longlong)param_1 + 0x14);

-  if (((1 << ((byte)(*(uint *)(*param_1 + 0x20) >> 5) & 0xf) & 0xc00cU) != 0) &&

-     (uVar2 = *(ulonglong *)(*param_1 + 0x3df0), uVar2 <= param_2)) {

-    param_2 = param_2 - uVar2;

+  puStack00000000000000f0 = (undefined1 *)(in_RAX & 0xffffffffffffff78);

+  uStack00000000000000f8 = 4;

+  puStack0000000000000100 = (undefined1 *)&stack0x00000068;

+  uStack0000000000000108 = 4;

+  uStack00000000000000a0 = *(undefined8 *)(unaff_R15 + 0x18);

+  puStack0000000000000110 = (undefined1 *)&stack0x000000a0;

+  uStack0000000000000118 = 8;

+  uStack0000000000000098 = *(undefined8 *)(unaff_R15 + 0x28);

+  puStack0000000000000120 = (undefined1 *)&stack0x00000098;

+  uStack0000000000000128 = 8;

+  puStack0000000000000130 = &stack0x00000090;

+  uStack0000000000000138 = 8;

+  puStack0000000000000140 = &stack0x00000088;

+  uStack0000000000000148 = 8;

+  _tlgWriteTransfer_EtwWriteTransfer

+            (0x1400510e8,&DAT_0,0,0,10,(undefined8 *)&stack0x000000b0);

+  VidOpCtrlFinish((uint *)(unaff_R15 + 0x48));

+  if ((unaff_ESI < 0) && (2 < DAT_1)) {

+    uVar1 = _tlgKeywordOn(0x1400510e8,0x100);

+    if ((char)uVar1 != '\0') {

+      _tlgCreate1Sz_char((longlong *)&stack0x000000d0,"VsmmIoctlReadWriteMemoryBlockPageRange");

+      _tlgCreate1Sz_char((longlong *)&stack0x000000e0,"onecore\\vm\\vid\\sys\\vsmm\\vsmmutilities.c"

+                        );

+      uStack0000000000000068 = 0xbdb;

+      puStack00000000000000f0 = (undefined1 *)&stack0x00000068;

+      uStack00000000000000f8 = 4;

+      puStack0000000000000100 = &stack0x00000078;

+      uStack0000000000000108 = 4;

+      puStack0000000000000110 = (undefined1 *)(unaff_R12 + 0x290);

+      uStack0000000000000118 = 0x10;

+      uStack00000000000000a0 = in_stack_00000080;

+      puStack0000000000000120 = (undefined1 *)&stack0x000000a0;

+      uStack0000000000000128 = 8;

+      uStack0000000000000098 = in_stack_00000070;

+      puStack0000000000000130 = (undefined1 *)&stack0x00000098;

+      uStack0000000000000138 = 8;

+      puStack0000000000000140 = &stack0x00000090;

+      uStack0000000000000148 = 8;

+      puStack0000000000000150 = &stack0x00000088;

+      uStack0000000000000158 = 8;

+      puStack0000000000000160 = &stack0x000000a8;

+      uStack0000000000000168 = 8;

+      in_stack_00000080 = in_stack_00000060;

+      puStack0000000000000170 = &stack0x00000080;

+      uStack0000000000000178 = 8;

+      puStack0000000000000180 = &stack0x00000060;

+      uStack0000000000000188 = 8;

+      puStack0000000000000190 = &stack0x00000050;

+      uStack0000000000000198 = 4;

+      puStack00000000000001a0 = &stack0x00000058;

+      uStack00000000000001a8 = 1;

+      _tlgWriteTransfer_EtwWriteTransfer

+                (0x1400510e8,&DAT_2,0,0,0x10,(undefined8 *)&stack0x000000b0);

+    }

   }

-  do {

-    if (uVar3 == 0) {

-      return 0;

-    }

-    uVar3 = uVar3 - 1;

-    lVar1 = *(longlong *)(param_1[1] + (ulonglong)uVar3 * 8);

-  } while ((((param_2 < *(ulonglong *)(lVar1 + 0x100)) || (*(ulonglong *)(lVar1 + 0x108) < param_2))

-           || ((param_4 & *(uint *)(lVar1 + 0x124)) != 0 ||

-               (*(uint *)(lVar1 + 0x124) & param_3) != param_3)) ||

-          (uVar2 = VidOpCtrlStart((uint *)(lVar1 + 8)), (char)uVar2 == '\0'));

-  return lVar1;

+  return unaff_ESI;

 }
```

## `VidLockRelease`  (modified)

```diff
--- VidLockRelease
+++ Feature_2798276923__private_IsEnabledDeviceUsageNoInline
@@ -1,100 +1,17 @@
 

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

-

-int VidLockRelease(undefined8 param_1)

+ulonglong Feature_2798276923__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  ulonglong in_RAX;

   ulonglong uVar1;

-  int unaff_ESI;

-  longlong unaff_R12;

-  longlong unaff_R15;

-  undefined8 in_stack_00000060;

-  undefined4 uStack0000000000000068;

-  undefined8 in_stack_00000070;

-  undefined8 in_stack_00000080;

-  undefined8 uStack0000000000000098;

-  undefined8 uStack00000000000000a0;

-  undefined1 *puStack00000000000000f0;

-  undefined8 uStack00000000000000f8;

-  undefined1 *puStack0000000000000100;

-  undefined8 uStack0000000000000108;

-  undefined1 *puStack0000000000000110;

-  undefined8 uStack0000000000000118;

-  undefined1 *puStack0000000000000120;

-  undefined8 uStack0000000000000128;

-  undefined1 *puStack0000000000000130;

-  undefined8 uStack0000000000000138;

-  undefined1 *puStack0000000000000140;

-  undefined8 uStack0000000000000148;

-  undefined1 *puStack0000000000000150;

-  undefined8 uStack0000000000000158;

-  undefined1 *puStack0000000000000160;

-  undefined8 uStack0000000000000168;

-  undefined8 *puStack0000000000000170;

-  undefined8 uStack0000000000000178;

-  undefined8 *puStack0000000000000180;

-  undefined8 uStack0000000000000188;

-  undefined1 *puStack0000000000000190;

-  undefined8 uStack0000000000000198;

-  undefined1 *puStack00000000000001a0;

-  undefined8 uStack00000000000001a8;

+  undefined8 local_res8;

   

-  puStack00000000000000f0 = (undefined1 *)(in_RAX & 0xffffffffffffff78);

-  uStack00000000000000f8 = 4;

-  puStack0000000000000100 = (undefined1 *)&stack0x00000068;

-  uStack0000000000000108 = 4;

-  uStack00000000000000a0 = *(undefined8 *)(unaff_R15 + 0x18);

-  puStack0000000000000110 = (undefined1 *)&stack0x000000a0;

-  uStack0000000000000118 = 8;

-  uStack0000000000000098 = *(undefined8 *)(unaff_R15 + 0x28);

-  puStack0000000000000120 = (undefined1 *)&stack0x00000098;

-  uStack0000000000000128 = 8;

-  puStack0000000000000130 = &stack0x00000090;

-  uStack0000000000000138 = 8;

-  puStack0000000000000140 = &stack0x00000088;

-  uStack0000000000000148 = 8;

-  _tlgWriteTransfer_EtwWriteTransfer

-            (0x1400510e8,&DAT_0,0,0,10,(undefined8 *)&stack0x000000b0);

-  VidOpCtrlFinish((uint *)(unaff_R15 + 0x48));

-  if ((unaff_ESI < 0) && (2 < DAT_1)) {

-    uVar1 = _tlgKeywordOn(0x1400510e8,0x100);

-    if ((char)uVar1 != '\0') {

-      _tlgCreate1Sz_char((longlong *)&stack0x000000d0,"VsmmIoctlReadWriteMemoryBlockPageRange");

-      _tlgCreate1Sz_char((longlong *)&stack0x000000e0,"onecore\\vm\\vid\\sys\\vsmm\\vsmmutilities.c"

-                        );

-      uStack0000000000000068 = 0xbdb;

-      puStack00000000000000f0 = (undefined1 *)&stack0x00000068;

-      uStack00000000000000f8 = 4;

-      puStack0000000000000100 = &stack0x00000078;

-      uStack0000000000000108 = 4;

-      puStack0000000000000110 = (undefined1 *)(unaff_R12 + 0x290);

-      uStack0000000000000118 = 0x10;

-      uStack00000000000000a0 = in_stack_00000080;

-      puStack0000000000000120 = (undefined1 *)&stack0x000000a0;

-      uStack0000000000000128 = 8;

-      uStack0000000000000098 = in_stack_00000070;

-      puStack0000000000000130 = (undefined1 *)&stack0x00000098;

-      uStack0000000000000138 = 8;

-      puStack0000000000000140 = &stack0x00000090;

-      uStack0000000000000148 = 8;

-      puStack0000000000000150 = &stack0x00000088;

-      uStack0000000000000158 = 8;

-      puStack0000000000000160 = &stack0x000000a8;

-      uStack0000000000000168 = 8;

-      in_stack_00000080 = in_stack_00000060;

-      puStack0000000000000170 = &stack0x00000080;

-      uStack0000000000000178 = 8;

-      puStack0000000000000180 = &stack0x00000060;

-      uStack0000000000000188 = 8;

-      puStack0000000000000190 = &stack0x00000050;

-      uStack0000000000000198 = 4;

-      puStack00000000000001a0 = &stack0x00000058;

-      uStack00000000000001a8 = 1;

-      _tlgWriteTransfer_EtwWriteTransfer

-                (0x1400510e8,&DAT_2,0,0,0x10,(undefined8 *)&stack0x000000b0);

-    }

+  local_res8 = (ulonglong)Feature_2798276923__private_featureState;

+  if ((Feature_2798276923__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_2798276923__private_IsEnabledFallback(local_res8,3);

   }

-  return unaff_ESI;

+  else {

+    uVar1 = (ulonglong)(Feature_2798276923__private_featureState & 1);

+  }

+  return uVar1;

 }
```
