# CVE-2019-1474 — ntoskrnl.exe patch diff

`ntoskrnl.exe` 10.0.18362.476 -> 10.0.18362.535 (ghidriff).

## `PnpDeviceEventWorker`  (modified)

```diff
--- PnpDeviceEventWorker
+++ PnpDeviceEventWorker
@@ -1,101 +1,235 @@
 

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

-/* WARNING: Possible PIC construction at 0x00014067ebb7: Changing call to branch */

-/* WARNING: Possible PIC construction at 0x00014067ec21: Changing call to branch */

-/* WARNING: Possible PIC construction at 0x0001407d5012: Changing call to branch */

-/* WARNING: Possible PIC construction at 0x0001407d5008: Changing call to branch */

-/* WARNING: Removing unreachable block (ram,0x0001407d5012) */

-/* WARNING: Removing unreachable block (ram,0x00014067ec21) */

-/* WARNING: Removing unreachable block (ram,0x00014067ebb7) */

-/* WARNING: Removing unreachable block (ram,0x0001407d5008) */

-

-ulonglong PnpDeviceEventWorker(void *param_1)

+

+ulonglong PnpDeviceEventWorker(longlong param_1)

 

 {

-  uint uVar1;

-  int iVar2;

-  longlong unaff_RBX;

-  void *unaff_RSI;

-  ulonglong uVar3;

-  size_t unaff_R12;

-  longlong unaff_R13;

-  char unaff_R14B;

-  longlong unaff_R15;

-  bool in_CF;

-  bool in_ZF;

-  char in_SF;

-  char in_OF;

-  char cStack0000000000000030;

-  char cStack0000000000000031;

-  longlong in_stack_00000038;

-  longlong in_stack_00000040;

-  undefined4 in_stack_00000070;

+  ulonglong *puVar1;

+  code *pcVar2;

+  int iVar3;

+  int iVar4;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  ulonglong *unaff_RSI;

+  int unaff_EDI;

+  longlong lVar8;

+  undefined8 *puVar9;

+  ulonglong *puVar10;

+  int iVar11;

+  bool bVar12;

+  undefined8 auStack_88 [4];

+  undefined8 local_68;

+  ulonglong *local_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  ulonglong local_40;

+  ulonglong uStack_38;

+  ulonglong local_30;

   

-  if (in_OF != in_SF) {

-    if ((!in_CF && !in_ZF) || (param_1 < unaff_RSI)) {

-      DAT_0 = 0;

-    }

-    RtlCopyMemory(&stack0x00000050,unaff_RSI,unaff_R12);

-    uVar3 = FUN_14067eb1a();

-    return uVar3;

-  }

-  uVar1 = func_0x00014067ec64();

-  uVar3 = (ulonglong)uVar1;

-  if ((int)uVar1 < 0) goto FUN_14067ebbb;

-  cStack0000000000000030 = '\x01';

-  if (((&DAT_1)[unaff_RBX * 8] & 4) == 0) {

-    if (unaff_R13 != 0) {

-      uVar3 = 0xc00000f0;

-      goto FUN_14067ebbb;

-    }

+  local_30 = __security_cookie ^ (ulonglong)auStack_88;

+  local_40 = 0;

+  iVar4 = 0;

+  uStack_38 = 0;

+  local_50 = 0;

+  local_48 = 0;

+  PnpDeviceEventThread = SystemReserved1[0xf];

+  local_68 = 0;

+  iVar3 = KeWaitForMutexObject(PnpDeviceEventList + 8,0,0,0);

+  if (iVar3 < 0) {

+    KeAcquireGuardedMutex(&PnpNotificationInProgressLock);

+    KeSetEvent(&PnpEventQueueEmpty,0,0);

+    PnpNotificationInProgress = 0;

+    uVar5 = ExReleaseFastMutex(&PnpNotificationInProgressLock);

+    PnpDeviceEventThread = (void *)0x0;

   }

   else {

-    uVar1 = func_0x00014067ec64();

-    uVar3 = (ulonglong)uVar1;

-    if ((int)uVar1 < 0) goto FUN_14067ebbb;

-    cStack0000000000000031 = '\x01';

-    if (in_stack_00000040 == in_stack_00000038) {

-      uVar3 = 0xc000000d;

-      goto FUN_14067ebbb;

+    while( true ) {

+      KeAcquireGuardedMutex(PnpDeviceEventList + 0x40);

+      lVar8 = PnpDeviceEventList;

+      puVar10 = (ulonglong *)(PnpDeviceEventList + 0x78);

+      puVar1 = (ulonglong *)*puVar10;

+      if (puVar1 == puVar10) break;

+      if (((ulonglong *)puVar1[1] != puVar10) ||

+         (uVar5 = *puVar1, *(ulonglong **)(uVar5 + 8) != puVar1)) {

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

+        (*pcVar2)(3);

+        do {

+          auStack_88[0] = 0x1407d4efc;

+          MiWaitForFreePage(puVar1);

+          auStack_88[0] = 0x14067e8db;

+          uVar5 = MiGetPage(puVar1,unaff_EDI,0x302);

+        } while (uVar5 == 0xffffffffffffffff);

+        lVar8 = uVar5 * 0x30;

+        puVar9 = (undefined8 *)(lVar8 + -0x58000000000);

+        auStack_88[0] = 0x14067e907;

+        MiSetPfnLink(puVar9,0);

+        auStack_88[0] = 0x14067e917;

+        uVar6 = MiMakeValidPte(0,uVar5,0x90000006);

+        *puVar9 = 0;

+        *(ulonglong *)(lVar8 + -0x57fffffffd8) =

+             *(ulonglong *)(lVar8 + -0x57fffffffd8) ^

+             (*(ulonglong *)(lVar8 + -0x57fffffffd8) ^ uVar5) & 0xfffffffff;

+        uVar6 = uVar6 & 0xfffffffffffffeff;

+        auStack_88[0] = 0x14067e949;

+        MiSetPageTablePfnBuddy(puVar9,&stack0xffffffffffffffd8,0);

+        auStack_88[0] = 0x14067e967;

+        MiInitializePfnForOtherProcess(uVar5,&DAT_0,uVar5,0x200);

+        auStack_88[0] = 0x14067e977;

+        uVar7 = MiMakeValidPte(0,uVar5);

+        iVar3 = 0;

+        auStack_88[0] = 0x14067e985;

+        iVar4 = MiPteInShadowRange(unaff_RSI);

+        iVar11 = iVar3 + 1;

+        if (iVar4 != 0) {

+          auStack_88[0] = 0x1407d4f08;

+          iVar4 = MiPteHasShadow();

+          if (iVar4 == 0) {

+            if ((*(uint *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x6fc) & 0x1000)

+                != 0) goto LAB_1;

+          }

+          else {

+            iVar3 = iVar11;

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

+LAB_1:

+              if ((byte)((byte)iVar11 & (byte)uVar7) != 0) {

+                uVar7 = uVar7 | 0x8000000000000000;

+              }

+            }

+          }

+        }

+        *unaff_RSI = uVar7;

+        if (iVar3 != 0) {

+          auStack_88[0] = 0x1407d4f53;

+          MiWritePteShadow(unaff_RSI);

+        }

+        iVar3 = 0;

+        puVar10 = (ulonglong *)(((longlong)unaff_RSI * 0x2000000 >> 0x10) + 0xf68);

+        auStack_88[0] = 0x14067e9df;

+        iVar4 = MiPteInShadowRange(puVar10);

+        if (iVar4 != 0) {

+          auStack_88[0] = 0x1407d4f5e;

+          iVar4 = MiPteHasShadow();

+          if (iVar4 == 0) {

+            if ((*(uint *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x6fc) & 0x1000)

+                == 0) goto LAB_3;

+          }

+          else {

+            iVar3 = iVar11;

+            if (DAT_2 != '\0') goto LAB_14067e9e7;

+          }

+          if ((byte)((byte)iVar11 & (byte)uVar6) != 0) {

+            uVar6 = uVar6 | 0x8000000000000000;

+          }

+        }

+LAB_3:

+        *puVar10 = uVar6;

+        if (iVar3 != 0) {

+          auStack_88[0] = 0x1407d4fac;

+          MiWritePteShadow(puVar10,uVar6);

+        }

+        return uVar5;

+      }

+      *puVar10 = uVar5;

+      *(ulonglong **)(uVar5 + 8) = puVar10;

+      puVar1[1] = (ulonglong)puVar1;

+      *puVar1 = (ulonglong)puVar1;

+      ExReleaseFastMutex(lVar8 + 0x40);

+      lVar8 = -puVar1[0xb];

+      if (lVar8 == 0) {

+        lVar8 = -puVar1[0xc];

+      }

+      local_58 = puVar1;

+      if (lVar8 != 0) {

+        local_40 = puVar1[0xb];

+        uStack_38 = puVar1[0xc];

+        IoSetActivityIdThread(&local_40);

+      }

+      unaff_EDI = iVar4;

+      if ((puVar1[0x13] != 0) && (*(longlong *)(*(longlong *)(puVar1[0x13] + 0x138) + 0x28) == 0)) {

+        unaff_EDI = -0x3ffffff2;

+      }

+      unaff_RSI = puVar1;

+      if (DAT_4 != 0) {

+        LOCK();

+        bVar12 = PnpDeviceActionThread == 0;

+        if (bVar12) {

+          PnpDeviceActionThread = 0;

+        }

+        UNLOCK();

+        unaff_RSI = local_58;

+        if (bVar12) {

+          unaff_EDI = -0x3ffffe77;

+        }

+      }

+      if (unaff_EDI < 0) {

+LAB_5:

+        if (unaff_EDI != 0x103) goto LAB_6;

+      }

+      else {

+        PnpEnableWatchdog(puVar1,1);

+        iVar3 = (int)puVar1[0x10];

+        if (4 < iVar3) {

+          if (iVar3 < 6) {

+LAB_7:

+            unaff_EDI = -0x3fffffff;

+          }

+          else if (8 < iVar3) {

+            if (((iVar3 != 0xb) && (iVar3 != 9)) && (iVar3 != 10)) goto LAB_7;

+            unaff_EDI = PiUEventNotifyUserMode(puVar1);

+          }

+          goto LAB_5;

+        }

+        if (iVar3 != 4) {

+          if (iVar3 == 0) {

+            unaff_EDI = PiUEventNotifyUserMode(puVar1);

+            if (-1 < unaff_EDI) {

+              PnpNotifyHwProfileChange(puVar1 + 0xe,puVar1[6],puVar1[7]);

+            }

+          }

+          else if (iVar3 == 1) {

+            unaff_EDI = PnpProcessTargetDeviceEvent(&local_58);

+            unaff_RSI = local_58;

+          }

+          else {

+            if (iVar3 == 2) {

+              RtlInitUnicodeString(&local_50,puVar1 + 0x16);

+              PnpNotifyDeviceClassChange(puVar1 + 0xe,puVar1 + 0x14,&local_50);

+              goto LAB_8;

+            }

+            if (iVar3 != 3) goto LAB_7;

+            unaff_EDI = PnpProcessCustomDeviceEvent(&local_58);

+            unaff_RSI = local_58;

+          }

+          goto LAB_5;

+        }

+LAB_8:

+        PiUEventNotifyUserMode(puVar1);

+        unaff_EDI = iVar4;

+LAB_6:

+        if (unaff_RSI[0xd] != 0) {

+          PnpDisableWatchdog(unaff_RSI,1);

+          unaff_RSI[0xd] = 0;

+        }

+        PnpCompleteDeviceEvent(unaff_RSI,unaff_EDI);

+      }

+      PnpProcessDeferredRegistrations();

+      if (lVar8 != 0) {

+        IoSetActivityIdThread(0);

+      }

     }

+    KeAcquireGuardedMutex(&PnpNotificationInProgressLock);

+    KeSetEvent(&PnpEventQueueEmpty,0,0);

+    PnpNotificationInProgress = 0;

+    PnpProcessDeferredRegistrations();

+    ExReleaseFastMutex(&PnpNotificationInProgressLock);

+    ExReleaseFastMutex(PnpDeviceEventList + 0x40);

+    if (param_1 != 0) {

+      ExFreePool(param_1,0x4c706e50);

+    }

+    PnpDeviceEventThread = (void *)0x0;

+    uVar5 = KeReleaseMutex(PnpDeviceEventList + 8,0);

   }

-  iVar2 = (int)unaff_RBX;

-  if (iVar2 == 0) {

-    uVar1 = func_0x00014067ed14(in_stack_00000038,&stack0x00000050);

-  }

-  else if (iVar2 == 1) {

-    uVar1 = MmManagePartitionMoveMemory

-                      (in_stack_00000038,in_stack_00000040,&stack0x00000050,unaff_R14B);

-  }

-  else if (iVar2 == 2) {

-    uVar1 = MiCreatePagingFile();

-  }

-  else if (iVar2 == 3) {

-    uVar1 = MmManagePartitionCombineMemory(in_stack_00000038,&stack0x00000050);

-  }

-  else if (iVar2 == 4) {

-    uVar1 = MmManagePartitionInitialAddMemory();

-  }

-  else {

-    uVar1 = MmManagePartitionGetMemoryEvents(in_stack_00000038,&stack0x00000050,unaff_R14B);

-  }

-  uVar3 = (ulonglong)uVar1;

-  if ((-1 < (int)uVar1) && (((&DAT_1)[unaff_R15 * 8] & 2) != 0)) {

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

-      RtlCopyMemory(unaff_RSI,&stack0x00000050,unaff_R12);

-    }

-    else {

-      ProbeForWrite();

-      RtlCopyMemory(unaff_RSI,&stack0x00000050,unaff_R12);

-    }

-  }

-FUN_14067ebbb:

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

-    PsDereferencePartition(in_stack_00000038);

-  }

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

-    PsDereferencePartition(in_stack_00000040);

-  }

-  return uVar3;

+  return uVar5;

 }
```

## `ExpWnfDeleteProcessContext`  (modified)

```diff
--- ExpWnfDeleteProcessContext
+++ ExpWnfDeleteProcessContext
@@ -1,10 +1,179 @@
 

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

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

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

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

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

 

-void ExpWnfDeleteProcessContext(void)

+void ExpWnfDeleteProcessContext(longlong param_1,uint param_2)

 

 {

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

-  halt_baddata();

+  ulonglong *puVar1;

+  ulonglong uVar2;

+  longlong *plVar3;

+  longlong lVar4;

+  longlong *plVar5;

+  code *pcVar6;

+  longlong lVar7;

+  byte bVar8;

+  uint unaff_R12D;

+  ulonglong uVar9;

+  longlong in_stack_00000038;

+  uint in_stack_00000040;

+  

+  puVar1 = (ulonglong *)(param_1 + 0x50);

+  uVar9 = (ulonglong)param_2;

+  lVar7 = KeAbPreAcquire(puVar1,0,0);

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

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

+    ExfAcquirePushLockExclusiveEx(puVar1,lVar7,puVar1);

+  }

+  if (lVar7 != 0) {

+    *(byte *)(lVar7 + 0x1a) = *(byte *)(lVar7 + 0x1a) | 1;

+  }

+  while (plVar3 = *(longlong **)(param_1 + 0x58), plVar3 != (longlong *)(param_1 + 0x58)) {

+    ExAcquireRundownProtection(plVar3 + -2);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar2 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    ExpWnfDeleteSubscription(plVar3 + -3);

+    lVar7 = KeAbPreAcquire(puVar1,0);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar1);

+    }

+    if (lVar7 != 0) {

+      *(byte *)(lVar7 + 0x1a) = *(byte *)(lVar7 + 0x1a) | 1;

+    }

+  }

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 - 1;

+  UNLOCK();

+  if (((byte)uVar2 & 6) == 2) {

+    ExfTryToWakePushLock(puVar1);

+  }

+  KeAbPostRelease(puVar1);

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

+  lVar7 = KeAbPreAcquire(puVar1,0,0);

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

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

+    ExfAcquirePushLockExclusiveEx(puVar1,lVar7,puVar1);

+  }

+  if (lVar7 != 0) {

+    *(byte *)(lVar7 + 0x1a) = *(byte *)(lVar7 + 0x1a) | 1;

+  }

+  while (plVar3 = *(longlong **)(param_1 + 0x40), plVar3 != (longlong *)(param_1 + 0x40)) {

+    ExAcquireRundownProtection(plVar3 + -0x10);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((byte)uVar2 & 6) == 2) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    ExpWnfNotifyNameSubscribers(plVar3 + -0x11,0x10,0);

+    ExpWnfDeleteNameInstance(plVar3[-0xb],plVar3 + -0x11);

+    lVar7 = KeAbPreAcquire(puVar1,0);

+    LOCK();

+    uVar2 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar1,lVar7);

+    }

+    if (lVar7 != 0) {

+      *(byte *)(lVar7 + 0x1a) = *(byte *)(lVar7 + 0x1a) | 1;

+    }

+  }

+  LOCK();

+  uVar2 = *puVar1;

+  *puVar1 = *puVar1 - 1;

+  UNLOCK();

+  if (((byte)uVar2 & 6) == 2) {

+    ExfTryToWakePushLock(puVar1);

+  }

+  KeAbPostRelease(puVar1);

+  if (param_2 != 0) {

+    lVar7 = KeAbPreAcquire(&ExpWnfProcessesListLock,0,0);

+    LOCK();

+    uVar2 = ExpWnfProcessesListLock & 1;

+    ExpWnfProcessesListLock = ExpWnfProcessesListLock | 1;

+    UNLOCK();

+    if (uVar2 != 0) {

+      ExfAcquirePushLockExclusiveEx(&ExpWnfProcessesListLock,lVar7,&ExpWnfProcessesListLock);

+    }

+    if (lVar7 != 0) {

+      *(byte *)(lVar7 + 0x1a) = *(byte *)(lVar7 + 0x1a) | 1;

+    }

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

+    lVar4 = *plVar3;

+    if ((*(longlong **)(lVar4 + 8) != plVar3) ||

+       (plVar5 = *(longlong **)(param_1 + 0x18), (longlong *)*plVar5 != plVar3)) {

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

+      (*pcVar6)(3);

+      plVar3 = (longlong *)(param_1 + 0x70);

+      LOCK();

+      lVar4 = *plVar3;

+      *plVar3 = *plVar3 + -1;

+      UNLOCK();

+      if (((byte)lVar4 & 6) == 2) {

+        ExfTryToWakePushLock(plVar3);

+      }

+      KeAbPostRelease(plVar3);

+      if (uVar9 != 0) {

+        LOCK();

+        plVar3 = (longlong *)(uVar9 + 0x50);

+        lVar4 = *plVar3;

+        *plVar3 = *plVar3 + -1;

+        UNLOCK();

+        if (((byte)lVar4 & 6) == 2) {

+          ExfTryToWakePushLock(uVar9 + 0x50);

+        }

+        KeAbPostRelease(uVar9 + 0x50);

+      }

+      if ((in_stack_00000040 & unaff_R12D) != 0) {

+        ExpWnfNotifyNameSubscribers

+                  (param_1,4,0x409af960,in_stack_00000038 != PsInitialSystemProcess);

+      }

+      if (unaff_R12D != 0) {

+        ExReleaseRundownProtection(param_1 + 8);

+      }

+      ExReleaseRundownProtection(lVar7 + 8);

+      ExWaitForRundownProtectionRelease(lVar7 + 8);

+      ExFreePool(lVar7,0x20666e57);

+      return;

+    }

+    *plVar5 = lVar4;

+    *(longlong **)(lVar4 + 8) = plVar5;

+    LOCK();

+    uVar2 = ExpWnfProcessesListLock - 1;

+    UNLOCK();

+    bVar8 = (byte)ExpWnfProcessesListLock;

+    ExpWnfProcessesListLock = uVar2;

+    if ((bVar8 & 6) == 2) {

+      ExfTryToWakePushLock(&ExpWnfProcessesListLock);

+    }

+    KeAbPostRelease(&ExpWnfProcessesListLock);

+    if (*(longlong *)(param_1 + 0x80) != 0) {

+      ObfDereferenceObject();

+    }

+    ExFreePool(param_1,0x20666e57);

+  }

+  return;

 }
```

## `HvpAddBin`  (modified)

```diff
--- HvpAddBin
+++ HvpAddBin
@@ -1,55 +1,320 @@
 

-void HvpAddBin(undefined8 param_1,ulonglong param_2,uint param_3,int param_4,char param_5,

-              ulonglong param_6)

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

+

+uint HvpAddBin(longlong param_1,uint param_2,int param_3)

 

 {

-  ulonglong uVar1;

-  ulonglong *puVar2;

-  uint uVar3;

-  ulonglong uVar4;

-  undefined8 unaff_RBX;

-  undefined8 unaff_RBP;

-  undefined8 unaff_RSI;

-  undefined8 unaff_RDI;

-  int iVar5;

-  uint uVar6;

+  longlong lVar1;

+  code *pcVar2;

+  bool bVar3;

+  bool bVar4;

+  bool bVar5;

+  char cVar6;

+  int iVar7;

+  uint uVar8;

+  int iVar9;

+  undefined4 uVar10;

+  ulonglong uVar11;

+  ulonglong *puVar12;

+  uint uVar13;

+  ulonglong uVar14;

+  undefined4 *puVar15;

+  undefined4 *puVar16;

+  uint uVar17;

+  longlong *plVar18;

+  uint uVar19;

+  longlong *plVar20;

+  longlong *plVar21;

+  uint uVar22;

+  undefined1 local_res8;

+  undefined1 local_res20;

+  uint local_84;

+  uint local_80;

+  uint local_7c;

+  undefined4 *local_78;

+  undefined4 *local_70;

+  longlong *local_68;

+  undefined4 *local_60;

+  longlong *local_58;

   

-  uVar1 = (ulonglong)&stack0x00000000 & 0xffffffff;

-  *(undefined8 *)(uVar1 + 8) = unaff_RBX;

-  *(undefined8 *)(uVar1 + 0x10) = unaff_RBP;

-  *(undefined8 *)(uVar1 + 0x18) = unaff_RSI;

-  *(undefined8 *)(uVar1 + 0x20) = unaff_RDI;

-  uVar1 = (ulonglong)param_3;

-  uVar6 = 0;

-  do {

-    iVar5 = uVar6 + param_4;

-    puVar2 = (ulonglong *)HvpGetCellMap(param_1,iVar5);

-    if (puVar2 == (ulonglong *)0x0) {

+  uVar14 = (ulonglong)param_3;

+  local_80 = 0;

+  local_84 = 0xffffffff;

+  uVar13 = param_2 + 0x101f & 0xfffff000;

+  bVar3 = false;

+  local_78 = (undefined4 *)0x0;

+  local_68 = (longlong *)0x0;

+  local_70 = (undefined4 *)0x0;

+  bVar5 = false;

+  local_7c = 0;

+  bVar4 = false;

+  if ((uVar13 < 0x3001) && (((ulonglong)uVar13 - (ulonglong)param_2) - 0x20 < 0xe00)) {

+    uVar13 = uVar13 + 0x1000;

+  }

+  puVar15 = (undefined4 *)(uVar14 * 0x278);

+  plVar18 = (longlong *)(param_1 + 0x370 + (longlong)puVar15);

+  for (plVar20 = (longlong *)*plVar18;

+      (plVar21 = (longlong *)0x0, uVar22 = 0, plVar20 != plVar18 &&

+      ((uVar22 = *(uint *)(plVar20 + 2), uVar22 < uVar13 ||

+       (plVar21 = plVar20,

+       *(uint *)((longlong)puVar15 + param_1 + 0x110) < *(int *)((longlong)plVar20 + 0x14) + uVar22)

+       ))); plVar20 = (longlong *)*plVar20) {

+  }

+  local_60 = puVar15;

+  local_58 = plVar18;

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

+    uVar22 = *(uint *)((longlong)puVar15 + param_1 + 0x110);

+    puVar16 = (undefined4 *)(ulonglong)(uVar13 + uVar22);

+    uVar17 = uVar22;

+    if (((param_3 == 0) && (uVar13 < 0x40001)) &&

+       (((uVar13 + uVar22 + 0xfff ^ uVar22 + 0x1000) & 0xfffc0000) != 0)) {

+      uVar17 = (uVar22 + 0x40fff & 0xfffc0000) - 0x1000;

+      local_80 = uVar17 - uVar22;

+      puVar16 = (undefined4 *)(ulonglong)(uVar13 + uVar17);

+    }

+    uVar19 = (uint)puVar16;

+    if (uVar19 < uVar22) {

+      return 0xffffffff;

+    }

+    cVar6 = CmpCanGrowHive(param_1,puVar16);

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

+      return 0xffffffff;

+    }

+    iVar7 = HvpExpandMap(param_1,param_3,uVar22,puVar16);

+    if (iVar7 < 0) {

+      return 0xffffffff;

+    }

+    *(uint *)((longlong)local_60 + param_1 + 0x110) = uVar19;

+    iVar7 = HvpAdjustHiveFreeDisplay(param_1,puVar16,param_3);

+    if (-1 < iVar7) {

+      if (param_3 != 0) goto LAB_0;

+      uVar8 = *(uint *)(param_1 + 0xa0);

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

+        iVar7 = HvpGrowDirtyVectors(param_1,puVar16);

+        if (-1 < iVar7) {

+          uVar8 = *(uint *)(param_1 + 0xa0);

+          bVar3 = true;

+          goto LAB_1;

+        }

+      }

+      else {

+LAB_1:

+        if ((uVar8 & 0x8001) == 0) {

+          iVar7 = CmpDoFileSetSizeEx(param_1,0,uVar19 + 0x1000,1);

+          if (iVar7 < 0) goto LAB_2;

+          if (((*(uint *)(param_1 + 0x1038) & 0x800) != 0) && (*(int *)(param_1 + 0x10ac) == 0)) {

+            *(uint *)(param_1 + 0x10ac) = uVar22;

+          }

+        }

+        if ((*(uint *)(param_1 + 0xa0) & 0x20000) == 0) {

+LAB_0:

+          local_res20 = 1;

+          local_res8 = 1;

+        }

+        else {

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

+            uVar11 = 0x7fffffffffffffff;

+          }

+          else {

+            uVar11 = *(ulonglong *)(param_1 + 0xe8);

+          }

+          uVar11 = uVar11 & 0xfffffffffffff000;

+          if (0x7fffefff < (longlong)uVar11) {

+            uVar11 = 0x7ffff000;

+          }

+          if ((int)uVar11 - 0x1000U < uVar19) goto LAB_0;

+          iVar7 = HvpViewMapExtendStorage(param_1 + 0xd8,puVar16);

+          if (iVar7 < 0) goto LAB_2;

+          local_res8 = 0;

+          bVar5 = true;

+          local_res20 = 0;

+        }

+        bVar4 = bVar5;

+        if (local_80 == 0) {

+LAB_3:

+          if (bVar5) {

+            cVar6 = CmpClaimGlobalQuota(uVar13);

+            bVar4 = bVar5;

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

+              local_7c = local_7c + uVar13;

+              iVar7 = HvpViewMapPromoteRangeToMapping(param_1 + 0xd8,uVar17,uVar13,&local_70);

+              if (-1 < iVar7) {

+                iVar7 = HvpViewMapCOWAndUnsealRange(param_1 + 0xd8,uVar17,uVar13);

+                goto LAB_4;

+              }

+            }

+          }

+          else {

+            iVar7 = HvpAllocateBin(param_1,uVar13,param_3,0x36314d43,&local_70);

+            bVar4 = false;

+            if (-1 < iVar7) {

+              iVar7 = HvpProtectBin();

+              bVar4 = false;

+LAB_4:

+              if (-1 < iVar7) {

+                memset(local_70,0,(ulonglong)uVar13);

+                local_70[7] = 0;

+                local_70[1] = uVar17 & 0x7fffffff;

+                *local_70 = 0x6e696268;

+                local_70[2] = uVar13;

+                local_70[8] = uVar13 - 0x20;

+                if (local_78 != (undefined4 *)0x0) {

+                  puVar15 = (undefined4 *)(ulonglong)(uVar17 - uVar22);

+                  HvpPointMapEntriesToBuffer

+                            (param_1,local_78,puVar15,param_3 * -0x80000000 + uVar22,local_res8,

+                             local_68);

+                  lVar1 = *local_58;

+                  if (*(longlong **)(lVar1 + 8) != local_58) goto LAB_5;

+                  *local_68 = lVar1;

+                  local_68[1] = (longlong)local_58;

+                  *(longlong **)(lVar1 + 8) = local_68;

+                  *local_58 = (longlong)local_68;

+                  local_res20 = local_res8;

+                }

+                uVar17 = uVar17 + param_3 * -0x80000000;

+                HvpPointMapEntriesToBuffer(param_1,local_70,uVar13,uVar17,local_res20,0);

+                if (param_3 != 0) {

+                  return uVar17;

+                }

+                if (((*(uint *)(param_1 + 0xa0) & 1) != 0) ||

+                   (cVar6 = HvpMarkDirty(param_1,uVar22,uVar19 - uVar22,0), bVar4 = bVar5,

+                   cVar6 != '\0')) {

+                  CmpUpdateSystemHiveHysteresis(param_1,puVar16,uVar22);

+                  HvpSetRangeProtection(param_1,uVar22,uVar19 - uVar22,4);

+                  return uVar17;

+                }

+              }

+            }

+          }

+        }

+        else if (bVar5) {

+          cVar6 = CmpClaimGlobalQuota(local_80);

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

+            local_7c = local_80;

+            iVar7 = HvpViewMapPromoteRangeToMapping(param_1 + 0xd8,uVar22,local_80,&local_78);

+            if (-1 < iVar7) {

+              iVar7 = HvpViewMapCOWAndUnsealRange(param_1 + 0xd8,uVar22,local_80);

+              goto LAB_6;

+            }

+          }

+        }

+        else {

+          bVar4 = false;

+          iVar7 = HvpAllocateBin(param_1,local_80,param_3,0x30324d43,&local_78);

+          if (-1 < iVar7) {

+            bVar4 = false;

+            iVar7 = HvpProtectBin();

+LAB_6:

+            if (-1 < iVar7) {

+              memset(local_78,0,(ulonglong)local_80);

+              local_78[7] = 0;

+              local_78[1] = uVar22 & 0x7fffffff;

+              local_78[2] = local_80;

+              *local_78 = 0x6e696268;

+              local_78[8] = local_80 - 0x20;

+              local_68 = (longlong *)(**(code **)(param_1 + 0x18))(0x18,0,0x31324d43);

+              bVar4 = bVar5;

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

+                *(uint *)(local_68 + 2) = local_80;

+                *(uint *)((longlong)local_68 + 0x14) = uVar22;

+                goto LAB_3;

+              }

+            }

+          }

+        }

+      }

+LAB_2:

+      HvpAdjustHiveFreeDisplay(param_1,uVar22,param_3);

+    }

+    HvpShrinkMap(param_1,param_3,puVar16,uVar22);

+    *(uint *)((longlong)local_60 + param_1 + 0x110) = uVar22;

+    if (bVar3) {

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

+      uVar13 = uVar22 >> 9;

+      uVar14 = (ulonglong)uVar13;

+      *(uint *)(param_1 + 0x58) = uVar13;

+      iVar7 = *(int *)(param_1 + 0x68);

+      iVar9 = RtlNumberOfSetBits();

+      *(int *)(param_1 + 0x68) = iVar9;

+      LOCK();

+      CmpDirtySectorCount = CmpDirtySectorCount + (iVar9 - iVar7);

+      UNLOCK();

+      *(uint *)(param_1 + 0x70) = uVar13;

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

+      uVar10 = RtlNumberOfSetBits();

+      *(undefined4 *)(param_1 + 0x80) = uVar10;

+    }

+    if (bVar4) {

+      HvpViewMapShrinkStorage(param_1 + 0xd8,uVar22);

+    }

+    if ((local_78 != (undefined4 *)0x0) && (!bVar5)) {

+      puVar16 = local_78;

+      HvpFreeBin(param_1,uVar17 - uVar22,local_78);

+    }

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

+      (**(code **)(param_1 + 0x20))(local_68,0x18);

+    }

+    if ((local_70 != (undefined4 *)0x0) && (!bVar5)) {

+      puVar16 = local_70;

+      HvpFreeBin(param_1,uVar19 - uVar17,local_70);

+    }

+    if (local_7c == 0) {

+      return 0xffffffff;

+    }

+    CmpReleaseGlobalQuota(local_7c);

+    plVar18 = local_58;

+  }

+  else {

+    lVar1 = *plVar21;

+    if ((*(longlong **)(lVar1 + 8) != plVar21) ||

+       (plVar20 = (longlong *)plVar21[1], (longlong *)*plVar20 != plVar21)) goto LAB_5;

+    *plVar20 = lVar1;

+    *(longlong **)(lVar1 + 8) = plVar20;

+    puVar16 = (undefined4 *)(ulonglong)*(uint *)(plVar21 + 2);

+    uVar13 = param_3 * -0x80000000;

+    uVar14 = (ulonglong)uVar13;

+    cVar6 = HvpMarkDirty(param_1,*(int *)((longlong)plVar21 + 0x14) + uVar13);

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

+      puVar16 = (undefined4 *)0x0;

+      local_84 = *(int *)((longlong)plVar21 + 0x14) + uVar13;

+      if (uVar22 != 0) {

+        do {

+          uVar11 = (ulonglong)((int)puVar16 + local_84);

+          puVar12 = (ulonglong *)HvpGetCellMap(param_1,uVar11);

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

                     /* WARNING: Subroutine does not return */

-      KeBugCheckEx(0x51,1,param_1,iVar5,0x20a);

-    }

-    puVar2[1] = param_2;

-    if (uVar6 == 0) {

-      puVar2[1] = param_2 | 1;

-      uVar3 = (uint)uVar1;

+            KeBugCheckEx(0x51,1,param_1,uVar11 & 0xffffffff,0x267);

+          }

+          puVar12[1] = puVar12[1] & 0xfffffffffffffffd;

+          uVar11 = (ulonglong)puVar16 & 0xffffffff;

+          uVar13 = (int)puVar16 + 0x1000;

+          puVar16 = (undefined4 *)(ulonglong)uVar13;

+          *puVar12 = uVar11;

+        } while (uVar13 < uVar22);

+      }

+    }

+  }

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

+    if (local_84 == 0xffffffff) {

+      lVar1 = *plVar18;

+      puVar15 = puVar16;

+      if (*(longlong **)(lVar1 + 8) != plVar18) {

+LAB_5:

+        uVar10 = SUB84(puVar15,0);

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

+        (*pcVar2)(3);

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x51,1,uVar14,uVar10,0x20a);

+      }

+      *plVar21 = lVar1;

+      plVar21[1] = (longlong)plVar18;

+      *(longlong **)(lVar1 + 8) = plVar21;

+      *plVar18 = (longlong)plVar21;

     }

     else {

-      uVar3 = 0;

-    }

-    *(uint *)(puVar2 + 2) = uVar3;

-    if (param_6 == 0) {

-      uVar4 = (ulonglong)uVar6;

-    }

-    else {

-      puVar2[1] = puVar2[1] | 2;

-      uVar4 = param_6;

-    }

-    *puVar2 = uVar4;

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

-      puVar2[1] = puVar2[1] | 8;

-    }

-    uVar6 = uVar6 + 0x1000;

-  } while (uVar6 < (uint)uVar1);

-  return;

+      (**(code **)(param_1 + 0x20))(plVar21,0x18);

+    }

+  }

+  return local_84;

 }
```

## `CmpRundownUnitOfWork`  (modified)

```diff
--- CmpRundownUnitOfWork
+++ CmpRundownUnitOfWork
@@ -1,35 +1,255 @@
 

-ulonglong CmpRundownUnitOfWork

-                    (longlong param_1,longlong param_2,undefined8 param_3,ulonglong param_4)

+longlong * CmpRundownUnitOfWork(longlong *param_1)

 

 {

-  char cVar1;

-  ulonglong uVar2;

-  ulonglong uVar3;

-  short sVar4;

+  longlong *plVar1;

+  undefined8 *puVar2;

+  code *pcVar3;

+  bool bVar4;

+  bool bVar5;

+  byte bVar6;

+  uint uVar7;

+  longlong *plVar8;

+  uint *puVar9;

+  uint *puVar10;

+  uint uVar11;

   longlong unaff_RBX;

   longlong unaff_RBP;

-  undefined8 in_R10;

-  uint in_R11D;

-  bool in_SF;

-  float10 in_ST0;

+  longlong lVar12;

+  longlong lVar13;

+  ulonglong uVar14;

+  int iVar15;

+  ulonglong unaff_R12;

+  longlong unaff_R13;

+  int in_stack_00000030;

+  undefined8 *in_stack_00000058;

+  ulonglong in_stack_fffffffffffffff0;

   

-  if (!in_SF) {

-    *(int *)(param_2 + 0x70) = *(int *)(param_2 + 0x70) + (int)param_1;

-    return param_4 & 0xffffffff;

-  }

-  cVar1 = in((short)param_2);

-  *(char *)(unaff_RBP + 0x33) = *(char *)(unaff_RBP + 0x33) - cVar1;

-  *(int *)(unaff_RBX + -0x2e + param_1 * 4) = (int)in_ST0;

-  uVar3 = (ulonglong)in_R11D;

-  for (sVar4 = *(short *)(param_1 + 2); -1 < sVar4; sVar4 = sVar4 + -1) {

-    uVar2 = CmpGetKcbAtLayerHeight(param_1);

-    if (((*(short *)(uVar2 + 0x42) != 0) && (*(char *)(uVar2 + 0x41) == '\x01')) ||

-       ((*(int *)(uVar2 + 0x28) != -1 &&

-        ((uVar3 = uVar2, *(short *)(uVar2 + 0x42) != 0 && (*(char *)(uVar2 + 0x41) != (char)in_R11D)

-         ))))) break;

-  }

-  uVar3 = func_0x000140655594(uVar3,in_R10);

-  return uVar3;

+  puVar10 = (uint *)param_1[2];

+  bVar4 = true;

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

+    param_1[2] = 0;

+    uVar7 = *puVar10 & 0x7fffffff;

+    if (uVar7 == 1) {

+      if (*(longlong **)(puVar10 + 2) != param_1) {

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x51,0x12,1,puVar10,param_1);

+      }

+      *puVar10 = 0;

+      puVar10[2] = 0;

+      puVar10[3] = 0;

+    }

+    else {

+      uVar14 = 0;

+      if (uVar7 != 0) {

+        do {

+          if (*(longlong **)(*(longlong *)(puVar10 + 2) + uVar14 * 8) == param_1) break;

+          uVar11 = (int)uVar14 + 1;

+          uVar14 = (ulonglong)uVar11;

+        } while (uVar11 < uVar7);

+      }

+      uVar11 = (uint)uVar14;

+      if (uVar11 == uVar7) {

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x51,0x12,2,puVar10,param_1);

+      }

+      if (uVar11 < uVar7 - 1) {

+        lVar13 = uVar14 << 3;

+        lVar12 = (ulonglong)(uVar11 + 1) << 3;

+        uVar14 = (ulonglong)((uVar7 - 1) - uVar11);

+        do {

+          puVar2 = (undefined8 *)(lVar12 + *(longlong *)(puVar10 + 2));

+          lVar12 = lVar12 + 8;

+          *(undefined8 *)(lVar13 + *(longlong *)(puVar10 + 2)) = *puVar2;

+          lVar13 = lVar13 + 8;

+          uVar14 = uVar14 - 1;

+        } while (uVar14 != 0);

+      }

+      *puVar10 = *puVar10 - 1;

+      if (*puVar10 == 1) {

+        unaff_RBX = **(longlong **)(puVar10 + 2);

+        ExFreePool(*(longlong **)(puVar10 + 2),0x78494d43);

+        *(longlong *)(puVar10 + 2) = unaff_RBX;

+      }

+    }

+  }

+  puVar10 = (uint *)param_1[3];

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

+    param_1[3] = 0;

+    uVar7 = *puVar10 & 0x7fffffff;

+    if (uVar7 == 1) {

+      if (*(longlong **)(puVar10 + 2) != param_1) {

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x51,0x12,1,puVar10,param_1);

+      }

+      *puVar10 = 0;

+      puVar10[2] = 0;

+      puVar10[3] = 0;

+    }

+    else {

+      uVar14 = 0;

+      if (uVar7 != 0) {

+        do {

+          if (*(longlong **)(*(longlong *)(puVar10 + 2) + uVar14 * 8) == param_1) break;

+          uVar11 = (int)uVar14 + 1;

+          uVar14 = (ulonglong)uVar11;

+        } while (uVar11 < uVar7);

+      }

+      uVar11 = (uint)uVar14;

+      if (uVar11 == uVar7) {

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x51,0x12,2,puVar10,param_1);

+      }

+      if (uVar11 < uVar7 - 1) {

+        lVar13 = uVar14 << 3;

+        lVar12 = (ulonglong)(uVar11 + 1) << 3;

+        uVar14 = (ulonglong)((uVar7 - 1) - uVar11);

+        do {

+          puVar2 = (undefined8 *)(lVar12 + *(longlong *)(puVar10 + 2));

+          lVar12 = lVar12 + 8;

+          *(undefined8 *)(lVar13 + *(longlong *)(puVar10 + 2)) = *puVar2;

+          lVar13 = lVar13 + 8;

+          uVar14 = uVar14 - 1;

+        } while (uVar14 != 0);

+      }

+      *puVar10 = *puVar10 - 1;

+      if (*puVar10 == 1) {

+        unaff_RBX = **(longlong **)(puVar10 + 2);

+        ExFreePool(*(longlong **)(puVar10 + 2),0x78494d43);

+        *(longlong *)(puVar10 + 2) = unaff_RBX;

+      }

+    }

+  }

+  if ((longlong *)*param_1 != param_1) {

+    LOCK_TRANSACTION_LIST();

+    lVar12 = *param_1;

+    if ((*(longlong **)(lVar12 + 8) != param_1) ||

+       (plVar8 = (longlong *)param_1[1], (longlong *)*plVar8 != param_1)) goto LAB_0;

+    *plVar8 = lVar12;

+    *(longlong **)(lVar12 + 8) = plVar8;

+    UNLOCK_TRANSACTION_LIST();

+    param_1[7] = 0;

+  }

+  plVar8 = param_1 + 4;

+  plVar1 = (longlong *)*plVar8;

+  if (plVar1 != plVar8) {

+    lVar12 = param_1[6];

+    if (((longlong *)plVar1[1] != plVar8) ||

+       (puVar2 = (undefined8 *)param_1[5], (longlong *)*puVar2 != plVar8)) {

+LAB_0:

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

+      (*pcVar3)(3);

+LAB_1:

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

+LAB_2:

+        plVar8 = (longlong *)0xc0190002;

+LAB_3:

+        iVar15 = (int)unaff_R12;

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

+          plVar8 = (longlong *)FUN_1407c86a5();

+          return plVar8;

+        }

+LAB_4:

+        if (iVar15 != 0) {

+          ExReleaseRundownProtection(unaff_R13 + 0x660);

+          KeLeaveCriticalRegion();

+        }

+        if (bVar4) {

+          UNLOCK_TRANSACTION_LIST();

+        }

+        if (unaff_RBX != 0) {

+          CmpTransDereferenceTransaction(unaff_RBX);

+        }

+        return plVar8;

+      }

+      in_stack_00000030 = CmpTransactionInitializingCount;

+      UNLOCK_TRANSACTION_LIST();

+      in_stack_fffffffffffffff0 = in_stack_fffffffffffffff0 & unaff_R12;

+      ExBlockOnAddressPushLock

+                (&CmpTransactionInitializingEvent,&CmpTransactionInitializingCount,&stack0x00000030,

+                 4,in_stack_fffffffffffffff0);

+      do {

+        LOCK_TRANSACTION_LIST();

+        puVar9 = (uint *)CmpSearchForTrans();

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

+          if ((int)param_1 == 0) goto LAB_2;

+        }

+        else {

+          if ((unaff_RBX != 0) && ((puVar9[0xc] & 7) != 0)) goto LAB_2;

+          if ((puVar9[0xc] & 8) != 0) goto LAB_1;

+        }

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

+          if (*(ulonglong *)(unaff_RBP + 0x50) != unaff_R12) {

+            *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+                 *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+            bVar6 = ExAcquireRundownProtection(*(longlong *)(unaff_RBP + 0x50) + 0x660);

+            unaff_R12 = (ulonglong)bVar6;

+            if (bVar6 == 0) {

+              plVar8 = (longlong *)FUN_1407c864c();

+              return plVar8;

+            }

+          }

+          plVar8 = *(longlong **)(unaff_RBP + 0x18);

+          if (*plVar8 != unaff_RBP + 0x10) {

+LAB_5:

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

+            (*pcVar3)(3);

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

+            plVar8 = (longlong *)(*pcVar3)();

+            return plVar8;

+          }

+          *(longlong *)puVar10 = unaff_RBP + 0x10;

+          *(longlong **)(puVar10 + 2) = plVar8;

+          *plVar8 = (longlong)puVar10;

+          *(uint **)(unaff_RBP + 0x18) = puVar10;

+          CmpTransactionInitializingCount = CmpTransactionInitializingCount + 1;

+          UNLOCK_TRANSACTION_LIST();

+          bVar4 = false;

+          uVar7 = CmpTransInitializeTransaction(puVar10);

+          plVar8 = (longlong *)(ulonglong)uVar7;

+          bVar5 = false;

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

+LAB_6:

+            bVar4 = bVar5;

+            iVar15 = (int)unaff_R12;

+            plVar8 = (longlong *)0x0;

+            *in_stack_00000058 = puVar10;

+            goto LAB_4;

+          }

+          LOCK_TRANSACTION_LIST();

+          lVar12 = *(longlong *)puVar10;

+          if ((*(uint **)(lVar12 + 8) != puVar10) ||

+             (plVar1 = *(longlong **)(puVar10 + 2), (uint *)*plVar1 != puVar10)) goto LAB_5;

+          *plVar1 = lVar12;

+          *(longlong **)(lVar12 + 8) = plVar1;

+          CmpTransactionInitializingCount = CmpTransactionInitializingCount + -1;

+          UNLOCK_TRANSACTION_LIST();

+          LOCK();

+          UNLOCK();

+          if (CmpTransactionInitializingEvent != 0) {

+            ExfUnblockPushLock(&CmpTransactionInitializingEvent,0);

+          }

+          goto LAB_3;

+        }

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

+          CmpBindHiveToTrans();

+          puVar10 = puVar9;

+          bVar5 = true;

+          goto LAB_6;

+        }

+        UNLOCK_TRANSACTION_LIST();

+        puVar10 = (uint *)CmpTransAllocateTrans(unaff_RBX);

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

+          plVar8 = (longlong *)FUN_1407c8642();

+          return plVar8;

+        }

+      } while( true );

+    }

+    *puVar2 = plVar1;

+    plVar1[1] = (longlong)puVar2;

+    plVar8 = (longlong *)CmpDereferenceKeyControlBlockUnsafe(lVar12);

+    param_1[6] = 0;

+  }

+  return plVar8;

 }
```

## `PiUEventNotifyUserMode`  (modified)

```diff
--- PiUEventNotifyUserMode
+++ PiUEventNotifyUserMode
@@ -1,13 +1,158 @@
 

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

-

-void PiUEventNotifyUserMode(void)

+ulonglong PiUEventNotifyUserMode(longlong param_1)

 

 {

-  longlong in_RAX;

+  undefined4 *puVar1;

+  longlong *plVar2;

+  code *pcVar3;

+  char cVar4;

+  int iVar5;

+  longlong *_Dst;

+  longlong lVar6;

+  undefined8 *puVar7;

+  ulonglong uVar8;

+  char cVar9;

+  char local_res10 [8];

+  uint local_res18 [2];

+  undefined8 local_res20;

+  ulonglong in_stack_ffffffffffffff98;

+  undefined8 *puVar10;

+  undefined *local_48;

+  longlong local_40;

   

-  *(int *)(in_RAX + -0x7d) = *(int *)(in_RAX + -0x7d) + -1;

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

-  halt_baddata();

+  uVar8 = 0;

+  cVar9 = '\0';

+  local_res20 = 0;

+  local_res10[0] = '\0';

+  if (DAT_0 != 0) {

+    return 0xc0000189;

+  }

+  if (((*(int *)(param_1 + 0x80) == 4) &&

+      (iVar5 = PiUEventDeviceNeedsInstall(param_1 + 0xa0,local_res10), -1 < iVar5)) &&

+     (local_res10[0] != '\0')) {

+    uVar8 = FUN_1407d4b7e();

+    return uVar8;

+  }

+  cVar4 = PiUEventShouldQueueEvent(param_1);

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

+    return 0;

+  }

+  cVar4 = PiUEventIsDeviceEventVetoable();

+  local_res18[0] = *(int *)(param_1 + 0x94) + 0x48;

+  _Dst = (longlong *)ExAllocatePoolWithTag(1,local_res18[0],0x59706e50);

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

+    return 0xc000009a;

+  }

+  memset(_Dst,0,(ulonglong)local_res18[0]);

+  lVar6 = ExAllocatePoolWithTag(0x200,0x38,0x59706e50);

+  _Dst[2] = lVar6;

+  if (lVar6 == 0) goto LAB_1;

+  KeInitializeGuardedMutex(lVar6);

+  *(undefined4 *)(_Dst + 7) = 1;

+  *(char *)((longlong)_Dst + 0x45) = cVar4;

+  puVar1 = *(undefined4 **)(param_1 + 0x30);

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

+    if (puVar1 != (undefined4 *)0x0) {

+      *puVar1 = 0;

+    }

+    if (*(longlong *)(param_1 + 0x38) != 0) {

+      **(undefined2 **)(*(longlong *)(param_1 + 0x38) + 8) = 0;

+      **(undefined2 **)(param_1 + 0x38) = 0;

+    }

+  }

+  else {

+    _Dst[4] = (longlong)puVar1;

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

+    _Dst[5] = lVar6;

+    **(undefined2 **)(lVar6 + 8) = 0;

+    *(undefined2 *)_Dst[5] = 0;

+    *(undefined4 *)_Dst[4] = 0;

+  }

+  if ((*(longlong *)(param_1 + 0x18) == 0) && (cVar4 == '\0')) {

+LAB_2:

+    *(char *)((longlong)_Dst + 0x44) = cVar9;

+    *(int *)(_Dst + 8) = *(int *)(param_1 + 0x94) + 8;

+    RtlCopyMemory(_Dst + 9,(void *)(param_1 + 0x70),(ulonglong)*(uint *)(param_1 + 0x94));

+    PiUEventCacheObjectProperties(_Dst);

+    ExAcquireFastMutex(&PiUEventUsermodeEventQueueLock);

+    puVar10 = PiUEventUsermodeEventQueue;

+    if ((undefined8 **)*DAT_3 != &PiUEventUsermodeEventQueue) {

+LAB_4:

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

+      (*pcVar3)(3);

+      return (ulonglong)puVar10 & 0xffffffff;

+    }

+    *_Dst = (longlong)&PiUEventUsermodeEventQueue;

+    _Dst[1] = (longlong)DAT_3;

+    *DAT_3 = (longlong)_Dst;

+    DAT_3 = _Dst;

+    ExReleaseFastMutex(&PiUEventUsermodeEventQueueLock);

+    if ((undefined8 **)puVar10 != &PiUEventUsermodeEventQueue) {

+LAB_5:

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

+        local_48 = &PnpShutdownEvent;

+        local_40 = _Dst[3];

+        puVar10 = &local_res20;

+        local_res20 = 0xffffffffee1e5d00;

+        iVar5 = KeWaitForMultipleObjects

+                          (2,&local_48,1,0,in_stack_ffffffffffffff98 & 0xffffffffffffff00,1,puVar10,

+                           0);

+        local_res18[0] = 0;

+        ZwUpdateWnfStateData

+                  (&WNF_PNPB_AWAITING_RESPONSE,local_res18,4,0,0,0,

+                   (ulonglong)puVar10 & 0xffffffff00000000);

+        if (iVar5 == 0) {

+          uVar8 = 0xc0000189;

+        }

+        else if (iVar5 == 1) {

+          if ((cVar4 != '\0') && (**(int **)(param_1 + 0x30) != 0)) {

+            uVar8 = 0xc0000120;

+          }

+        }

+        else {

+          uVar8 = (ulonglong)(-(uint)(iVar5 != 0x102) & 0xc0000001);

+        }

+        ExAcquireFastMutex(&PiUEventUsermodeEventQueueLock);

+        _Dst[4] = 0;

+        _Dst[5] = 0;

+        ExReleaseFastMutex(&PiUEventUsermodeEventQueueLock);

+        PiUEventDereferenceEventEntry(_Dst);

+        return uVar8;

+      }

+      return 0;

+    }

+    puVar7 = (undefined8 *)ExAllocatePoolWithTag(0x200,0x20,0x59706e50);

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

+      puVar7[3] = puVar7;

+      puVar7[2] = PiUEventProcessEventWorker;

+      *puVar7 = 0;

+      ExQueueWorkItem(puVar7,3);

+      goto LAB_5;

+    }

+    ExAcquireFastMutex(&PiUEventUsermodeEventQueueLock);

+    lVar6 = *_Dst;

+    if ((*(longlong **)(lVar6 + 8) != _Dst) ||

+       (plVar2 = (longlong *)_Dst[1], (longlong *)*plVar2 != _Dst)) goto LAB_4;

+    *plVar2 = lVar6;

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

+    ExReleaseFastMutex(&PiUEventUsermodeEventQueueLock);

+    if (cVar9 == '\0') goto LAB_1;

+  }

+  else {

+    cVar9 = '\x01';

+    lVar6 = ExAllocatePoolWithTag(0x200,0x18,0x59706e50);

+    _Dst[3] = lVar6;

+    if (lVar6 != 0) {

+      KeInitializeEvent(lVar6,0,0);

+      PiUEventReferenceEventEntry(_Dst);

+      goto LAB_2;

+    }

+  }

+  if (_Dst[3] != 0) {

+    PiUEventDereferenceEventEntry(_Dst);

+  }

+LAB_1:

+  PiUEventFreeEventEntry(_Dst);

+  return 0xc000009a;

 }
```

## `MiDeleteStaleCacheMaps`  (modified)

```diff
--- MiDeleteStaleCacheMaps
+++ MiDeleteStaleCacheMaps
@@ -1,10 +1,126 @@
 

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

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

 

-void MiDeleteStaleCacheMaps(void)

+longlong **** MiDeleteStaleCacheMaps(void)

 

 {

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

-  halt_baddata();

+  longlong ***ppplVar1;

+  longlong ***ppplVar2;

+  code *pcVar3;

+  byte bVar4;

+  uint uVar5;

+  longlong ****in_RAX;

+  longlong lVar6;

+  PSLIST_ENTRY_conflict p_Var7;

+  longlong ****pppplVar8;

+  longlong ****unaff_RBX;

+  int unaff_EBP;

+  uint uVar9;

+  undefined8 unaff_RDI;

+  longlong lVar10;

+  uint unaff_R12D;

+  longlong unaff_R14;

+  byte bVar11;

+  ulonglong in_CR8;

+  byte unaff_retaddr;

+  longlong ***ppplStack_18;

+  longlong ***ppplStack_10;

+  

+  uVar9 = KiCacheFlushTimeStamp;

+  if ((longlong *****)DAT_0 != &DAT_0) {

+    LOCK();

+    UNLOCK();

+    uVar5 = KiCacheFlushTimeStamp - DAT_1;

+    in_RAX = (longlong ****)(ulonglong)uVar5;

+    if ((2 < uVar5) || (((DAT_1 & 1) == 0 && (1 < uVar5)))) {

+      ppplStack_10 = (longlong ***)&ppplStack_18;

+      ppplStack_18 = (longlong ***)&ppplStack_18;

+      bVar4 = ExAcquireSpinLockExclusive(&DAT_2);

+      lVar10 = CONCAT71((int7)((ulonglong)unaff_RDI >> 8),bVar4);

+      while( true ) {

+        pppplVar8 = DAT_0;

+        bVar11 = (byte)in_CR8;

+        if ((longlong *****)DAT_0 == &DAT_0) break;

+        uVar5 = uVar9 - *(uint *)(DAT_0 + 4);

+        if ((uVar5 < 3) && (((*(uint *)(DAT_0 + 4) & 1) != 0 || (uVar5 < 2)))) break;

+        ppplVar1 = *DAT_0;

+        ppplVar2 = DAT_0[1];

+        unaff_RBX = pppplVar8;

+        if (((longlong ****)ppplVar1[1] != DAT_0) ||

+           ((longlong ****)*ppplVar2 != DAT_0)) goto LAB_140222677;

+        *ppplVar2 = (longlong **)ppplVar1;

+        ppplVar1[1] = (longlong **)ppplVar2;

+        RtlAvlRemoveNode(&DAT_4);

+        _DAT_5 = _DAT_5 + -1;

+        if ((longlong ****)ppplStack_18[1] != &ppplStack_18) goto LAB_3;

+        *pppplVar8 = ppplStack_18;

+        pppplVar8[1] = (longlong ***)&ppplStack_18;

+        ppplStack_18[1] = (longlong **)pppplVar8;

+        ppplStack_18 = (longlong ***)pppplVar8;

+      }

+      ExReleaseSpinLockExclusiveFromDpcLevel(&DAT_2);

+      if ((KiIrqlFlags != 0) && ((((KiIrqlFlags & 1) != 0 && (1 < bVar11)) && (bVar4 < 2)))) {

+        LOCK();

+        **(uint **)((longlong)FiberData + 0x61b8) =

+             **(uint **)((longlong)FiberData + 0x61b8) & 0xfffeffff;

+        UNLOCK();

+        KiRemoveSystemWorkPriorityKick();

+      }

+      in_CR8 = (ulonglong)bVar4;

+      while (in_RAX = (longlong ****)ppplStack_18, (longlong ****)ppplStack_18 != &ppplStack_18) {

+        ppplVar1 = (longlong ***)*ppplStack_18;

+        ppplVar2 = (longlong ***)ppplStack_18[1];

+        if (((longlong ***)ppplVar1[1] != ppplStack_18) || ((longlong ***)*ppplVar2 != ppplStack_18)

+           ) {

+LAB_3:

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

+          lVar6 = (*pcVar3)(3);

+          do {

+            p_Var7 = ExpInterlockedPopEntrySList

+                               ((PSLIST_HEADER)(((ulonglong)uVar9 + unaff_R14) * 0x40 + lVar6));

+            if (p_Var7 == (PSLIST_ENTRY_conflict)0x0) goto LAB_6;

+            unaff_EBP = unaff_EBP + 1;

+            MiDeleteUltraMapContext(p_Var7 + 1,3);

+            ExFreePool(p_Var7,0);

+            while (lVar6 = DAT_7, *(ushort *)(lVar10 + DAT_7) < 3) {

+LAB_6:

+              bVar4 = (byte)in_CR8;

+              uVar9 = uVar9 + 1;

+              lVar10 = lVar10 + 0x40;

+              if (7 < uVar9) {

+                pppplVar8 = (longlong ****)(ulonglong)(uint)KeNumberNodes;

+                uVar9 = (int)unaff_RBX + 1;

+                unaff_RBX = (longlong ****)(ulonglong)uVar9;

+                if (KeNumberNodes <= uVar9) {

+                  if (unaff_EBP != 0) {

+                    KeAcquireInStackQueuedSpinLock(&DAT_8,&ppplStack_10);

+                    DAT_9 = DAT_9 - unaff_EBP;

+                    KeReleaseInStackQueuedSpinLockFromDpcLevel(&ppplStack_10);

+                    if ((((KiIrqlFlags != 0) && ((KiIrqlFlags & 1) != 0)) && (1 < bVar4)) &&

+                       (unaff_retaddr < 2)) {

+                      LOCK();

+                      **(uint **)((longlong)FiberData + 0x61b8) =

+                           **(uint **)((longlong)FiberData + 0x61b8) & 0xfffeffff;

+                      UNLOCK();

+                      KiRemoveSystemWorkPriorityKick();

+                    }

+                    pppplVar8 = (longlong ****)(ulonglong)unaff_retaddr;

+                  }

+                  return pppplVar8;

+                }

+                unaff_R14 = (longlong)unaff_RBX << 3;

+                lVar10 = (longlong)unaff_RBX << 9;

+                uVar9 = unaff_R12D;

+              }

+            }

+          } while( true );

+        }

+        *ppplVar2 = (longlong **)ppplVar1;

+        ppplVar1[1] = (longlong **)ppplVar2;

+        ExFreePool(ppplStack_18 + -3,0);

+      }

+    }

+  }

+  return in_RAX;

 }
```
