# CVE-2022-44689 — ntoskrnl.exe patch diff

`ntoskrnl.exe` 10.0.22621.900 -> 10.0.22621.963 (ghidriff).

## `NtCreatePrivateNamespace`  (modified)

```diff
--- NtCreatePrivateNamespace
+++ NtCreatePrivateNamespace
@@ -1,134 +1,132 @@
 

-uint NtCreatePrivateNamespace(void)

+ulonglong NtCreatePrivateNamespace

+                    (undefined8 *param_1,undefined4 param_2,undefined8 param_3,undefined8 param_4)

 

 {

-  longlong *plVar1;

-  uint *puVar2;

-  char cVar3;

-  ulonglong uVar4;

-  byte bVar5;

-  int iVar6;

-  longlong unaff_RBX;

-  uint unaff_EBP;

-  longlong unaff_RSI;

-  uint *unaff_RDI;

-  longlong unaff_R12;

-  longlong unaff_R13;

-  uint uVar7;

-  uint uVar8;

-  longlong lVar9;

-  uint *unaff_R15;

-  uint local_res20;

-  uint uStackX_24;

-  uint in_stack_00000028;

-  undefined4 uStack0000000000000030;

-  undefined4 uStack0000000000000034;

-  undefined4 in_stack_00000038;

-  int in_stack_00000090;

-  char in_stack_00000098;

-  char in_stack_000000a0;

-  uint in_stack_000000a8;

-  longlong in_stack_000000b0;

-  longlong in_stack_000000c0;

-  int *in_stack_000000c8;

-  byte in_stack_000000d0;

-  undefined1 *in_stack_000000d8;

+  char cVar1;

+  size_t _Size;

+  longlong *plVar2;

+  code *pcVar3;

+  void *pvVar4;

+  uint uVar5;

+  uint uVar6;

+  ulonglong uVar7;

+  longlong lVar8;

+  undefined8 *puVar9;

+  longlong lVar10;

+  longlong *plVar11;

+  longlong local_38;

+  void *local_30;

+  undefined8 local_28 [2];

   

-  uVar7 = *unaff_RDI;

-  do {

-    puVar2 = (uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + unaff_RSI * 8);

-    *puVar2 = *puVar2 | uVar7 & 4;

-    do {

-      iVar6 = (int)unaff_RBX;

-      *unaff_RDI = *unaff_RDI + iVar6;

-      lVar9 = CONCAT44(uStack0000000000000034,uStack0000000000000030);

-      do {

-        do {

-          unaff_R15 = unaff_R15 + 4;

-          uStackX_24 = uStackX_24 + iVar6;

-          bVar5 = (byte)unaff_RBX;

-          if (uStackX_24 < in_stack_000000a8) goto LAB_0;

-          do {

-            do {

-              while( true ) {

-                in_stack_00000028 = in_stack_00000028 + iVar6;

-                uVar4 = (ulonglong)in_stack_00000028;

-                if (*(uint *)(unaff_R13 + 0x7c) <= in_stack_00000028) {

-                  if ((in_stack_000000a0 == '\0') && (local_res20 < in_stack_000000a8)) {

-                    unaff_EBP = 0x106;

-                  }

-                  if ((*unaff_RDI == 0) || (in_stack_00000098 == '\0')) {

-                    unaff_RBX = 0;

-                  }

-                  *in_stack_000000d8 = (char)unaff_RBX;

-                  if (unaff_R12 == 0) {

-                    return unaff_EBP;

-                  }

-                  *in_stack_000000c8 = in_stack_00000090 + *unaff_RDI * 0x10 + 8;

-                  return unaff_EBP;

-                }

-                unaff_RSI = uVar4 * 2;

-                plVar1 = (longlong *)(*(longlong *)(unaff_R13 + 0x98) + uVar4 * 0x10);

-                uStack0000000000000030 = (undefined4)*plVar1;

-                uStack0000000000000034 = *(undefined4 *)((longlong)plVar1 + 4);

-                lVar9 = *plVar1;

-                in_stack_00000038 = (undefined4)plVar1[1];

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

-                uVar7 = *(uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + uVar4 * 0x10) & 6;

-                if ((uVar7 - 2 & 0xfffffffd) == 0) {

-                  uVar8 = (uint)*(byte *)(*plVar1 + 1) * 4 + 8;

-                  in_stack_00000090 = in_stack_00000090 + uVar8;

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

-                    if (unaff_R12 != 0) {

-                      *(undefined4 *)(unaff_R12 + ((ulonglong)*unaff_RDI + unaff_RBX) * 0x10) =

-                           in_stack_00000038;

-                      *(longlong *)(unaff_R12 + 8 + (ulonglong)*unaff_RDI * 0x10) =

-                           in_stack_000000c0;

-                      RtlCopySid(uVar8);

-                      in_stack_000000c0 = in_stack_000000c0 + (ulonglong)uVar8;

-                    }

-                    if (uVar7 == 2) {

-                      puVar2 = (uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + uVar4 * 0x10);

-                      *puVar2 = *puVar2 | 4;

-                    }

-                    else {

-                      puVar2 = (uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + uVar4 * 0x10);

-                      *puVar2 = *puVar2 & 0xfffffffb;

-                    }

-                  }

-                  *unaff_RDI = *unaff_RDI + iVar6;

-                }

-              }

-              uStackX_24 = uStackX_24 & unaff_EBP;

-              in_stack_000000d0 = 0;

-            } while (in_stack_000000a8 == 0);

-            unaff_R15 = (uint *)(in_stack_000000b0 + 8);

-LAB_0:

-          } while (in_stack_000000d0 != 0);

-          cVar3 = RtlEqualSid(lVar9,*(undefined8 *)(unaff_R15 + -2));

-        } while (cVar3 == '\0');

-        local_res20 = local_res20 + iVar6;

-        uVar7 = *(uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + unaff_RSI * 8);

-        in_stack_000000d0 = bVar5;

-      } while (((uVar7 ^ *unaff_R15) & 4) == 0);

-      if ((bVar5 & (byte)uVar7) != 0) {

-        return 0xc000005d;

-      }

-      if ((uVar7 & 0x10) != 0) {

-        return 0xc00002b3;

-      }

-      uVar7 = (uint)*(byte *)(CONCAT44(uStack0000000000000034,uStack0000000000000030) + 1) * 4 + 8;

-      in_stack_00000090 = in_stack_00000090 + uVar7;

-    } while (in_stack_00000098 == (char)unaff_EBP);

-    if (unaff_R12 != 0) {

-      *(undefined4 *)(unaff_R12 + ((ulonglong)*unaff_RDI + unaff_RBX) * 0x10) = in_stack_00000038;

-      *(longlong *)(unaff_R12 + 8 + (ulonglong)*unaff_RDI * 0x10) = in_stack_000000c0;

-      RtlCopySid(uVar7,in_stack_000000c0,CONCAT44(uStack0000000000000034,uStack0000000000000030));

-      in_stack_000000c0 = in_stack_000000c0 + (ulonglong)uVar7;

+  local_30 = (void *)0x0;

+  local_28[0] = 0;

+  local_38 = 0;

+  cVar1 = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

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

+    puVar9 = (undefined8 *)&DAT_0;

+    if (param_1 < &DAT_0) {

+      puVar9 = param_1;

     }

-    uVar7 = *(uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + unaff_RSI * 8);

-    *(uint *)(*(longlong *)(unaff_R13 + 0x98) + 8 + unaff_RSI * 8) = ~(uVar7 & 4) & uVar7;

-    uVar7 = *unaff_R15;

-  } while( true );

+    *puVar9 = *puVar9;

+  }

+  uVar7 = ObpCaptureBoundaryDescriptor(param_4,&local_38);

+  lVar8 = local_38;

+  if ((int)uVar7 < 0) {

+    return uVar7;

+  }

+  uVar5 = ObpVerifyCreatorAccessCheck(local_38 + 0x30);

+  uVar7 = (ulonglong)uVar5;

+  if ((int)uVar5 < 0) {

+LAB_1:

+    ExFreePoolWithTag(lVar8,0x534e624f);

+    return uVar7;

+  }

+  uVar5 = *(int *)(lVar8 + 0x18) + 0x188;

+  if ((ulonglong)uVar5 < *(ulonglong *)(lVar8 + 0x18)) {

+    uVar7 = 0xc000000d;

+    goto LAB_1;

+  }

+  uVar6 = ObCreateObjectEx(CONCAT71((int7)((ulonglong)&local_30 >> 8),cVar1),ObpDirectoryObjectType,

+                           param_3,cVar1);

+  pvVar4 = local_30;

+  lVar10 = 0;

+  if ((int)uVar6 < 0) {

+    uVar7 = (ulonglong)uVar6;

+    goto LAB_1;

+  }

+  memset(local_30,0,(ulonglong)uVar5);

+  plVar11 = (longlong *)((longlong)pvVar4 + 0x15fU & 0xfffffffffffffff8);

+  plVar11[1] = (longlong)plVar11;

+  *plVar11 = (longlong)plVar11;

+  _Size = *(size_t *)(lVar8 + 0x18);

+  plVar11[3] = _Size;

+  plVar11[2] = 0;

+  *(undefined1 *)(plVar11 + 5) = *(undefined1 *)(lVar8 + 0x28);

+  RtlCopyMemory(plVar11 + 6,(void *)(lVar8 + 0x30),_Size);

+  ExFreePoolWithTag(lVar8,0x534e624f);

+  *(undefined8 *)((longlong)pvVar4 + 0x128) = 0;

+  *(undefined4 *)((longlong)pvVar4 + 0x154) = 0xffffffff;

+  *(undefined4 *)((longlong)pvVar4 + 0x150) = 1;

+  if ((*(byte *)((longlong)pvVar4 + -0x16) & 2) != 0) {

+    lVar10 = (longlong)pvVar4 +

+             (-0x30 - (ulonglong)

+                      (byte)(&ObpInfoMaskToOffset)[*(byte *)((longlong)pvVar4 + -0x16) & 3]);

+  }

+  if (lVar10 != 0) {

+    uVar7 = FUN_1407c341c();

+    return uVar7;

+  }

+  uVar5 = ObpRegisterPrivateNamespace(plVar11);

+  if ((int)uVar5 < 0) {

+    ObfDereferenceObject(pvVar4);

+    return (ulonglong)uVar5;

+  }

+  ObfReferenceObject(pvVar4);

+  uVar5 = ObInsertObjectEx(pvVar4,0,param_2,0,0,0,local_28);

+  local_38 = CONCAT44(local_38._4_4_,uVar5);

+  lVar8 = PsGetCurrentServerSiloGlobals();

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

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

+  ExAcquirePushLockExclusiveEx(lVar8 + 0x2d0,0);

+  if ((int)uVar5 < 0) {

+    lVar10 = *plVar11;

+    plVar2 = (longlong *)plVar11[1];

+    if ((*(longlong **)(lVar10 + 8) != plVar11) || ((longlong *)*plVar2 != plVar11)) {

+LAB_2:

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

+      (*pcVar3)(3);

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

+      (*pcVar3)(3);

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

+      uVar7 = (*pcVar3)();

+      return uVar7;

+    }

+    *plVar2 = lVar10;

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

+  }

+  else {

+    if ((*(uint *)((longlong)pvVar4 + 0x150) & 2) == 0) {

+      plVar11[2] = (longlong)local_30;

+      *(longlong **)((longlong)local_30 + 0x140) = plVar11;

+      goto LAB_3;

+    }

+    lVar10 = *plVar11;

+    plVar2 = (longlong *)plVar11[1];

+    if ((*(longlong **)(lVar10 + 8) != plVar11) || ((longlong *)*plVar2 != plVar11))

+    goto LAB_2;

+    *plVar2 = lVar10;

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

+  }

+  *(int *)(lVar8 + 0x2d8) = *(int *)(lVar8 + 0x2d8) + -1;

+  ObfDereferenceObject(local_30);

+LAB_3:

+  ExReleasePushLockEx(lVar8 + 0x2d0,0);

+  KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

+  if ((int)uVar5 < 0) {

+    return (ulonglong)uVar5;

+  }

+  *param_1 = local_28[0];

+  return (ulonglong)uVar5;

 }
```

## `ExpWnfSubscribeNameInstance`  (modified)

```diff
--- ExpWnfSubscribeNameInstance
+++ ExpWnfSubscribeNameInstance
@@ -1,154 +1,291 @@
 

-ulonglong ExpWnfSubscribeNameInstance(int param_1,undefined4 param_2)

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

+

+undefined8

+ExpWnfSubscribeNameInstance

+          (longlong param_1,longlong param_2,ulonglong *param_3,undefined8 param_4,

+          undefined4 param_5,undefined4 param_6,char param_7,undefined8 *param_8,undefined8 *param_9

+          ,undefined8 *param_10,undefined4 *param_11)

 

 {

   ulonglong *puVar1;

-  longlong *plVar2;

-  longlong lVar3;

-  code *pcVar4;

-  char cVar5;

-  longlong lVar6;

-  ulonglong uVar7;

-  uint unaff_EBX;

-  longlong *plVar8;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong *unaff_RDI;

-  int unaff_R12D;

-  longlong *unaff_R14;

-  ulonglong unaff_R15;

+  int *piVar2;

+  ulonglong uVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  int iVar6;

+  longlong lVar7;

+  undefined4 *_Dst;

+  longlong lVar8;

+  undefined8 uVar9;

+  uint uVar10;

+  undefined8 *unaff_RSI;

+  longlong *plVar11;

+  ulonglong *puVar12;

+  ulonglong *puVar13;

+  undefined4 *puVar14;

+  undefined8 *unaff_R13;

+  int local_58;

+  int local_54;

+  undefined8 local_50;

+  longlong local_48;

+  longlong local_40;

   

-  param_1 = param_1 - (int)&stack0x00000000;

-  if (param_1 == 0) {

-    param_2 = 4;

-  }

-  else if (param_1 == unaff_R12D) {

-    param_2 = RtlLengthSid();

-  }

-  else if (param_1 - unaff_R12D != unaff_R12D) {

-    uVar7 = FUN_1408dec33();

-    return uVar7;

-  }

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

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

-  if ((*(uint *)(unaff_RBP + -0x40) == unaff_EBX) || (unaff_RSI == 0)) {

-    puVar1 = (ulonglong *)(*unaff_RDI + (unaff_R15 * 3 + 4) * 8);

-    plVar2 = (longlong *)(*unaff_RDI + (unaff_R15 * 3 + 5) * 8);

-    lVar6 = KeAbPreAcquire(puVar1,0,0);

-    LOCK();

-    uVar7 = *puVar1;

-    if (uVar7 == 0) {

-      *puVar1 = 0x11;

-    }

-    UNLOCK();

-    if (uVar7 != 0) {

-      ExfAcquirePushLockSharedEx(puVar1,0,lVar6,puVar1);

-    }

-    if (lVar6 != 0) {

-      *(undefined1 *)(lVar6 + 0x12) = 1;

-    }

-    unaff_RSI = ExpWnfFindScopeInstance();

-    if (unaff_RSI == 0) {

-      LOCK();

-      uVar7 = *puVar1;

-      if (uVar7 == 0x11) {

-        *puVar1 = 0;

-      }

-      UNLOCK();

-      if (uVar7 != 0x11) {

-        ExfReleasePushLockShared(puVar1);

+  local_48 = *(longlong *)(param_2 + 0x868);

+  uVar10 = 0;

+  local_50 = 0;

+  *param_11 = 0;

+  local_58 = 0;

+  local_54 = 0;

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

+    plVar11 = (longlong *)(local_48 + 0x50);

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

+    LOCK();

+    lVar8 = *plVar11;

+    if (lVar8 == 0) {

+      *plVar11 = 0x11;

+    }

+    UNLOCK();

+    if (lVar8 != 0) {

+      ExfAcquirePushLockSharedEx(plVar11,0,lVar7,plVar11);

+    }

+    if (lVar7 != 0) {

+      *(undefined1 *)(lVar7 + 0x12) = 1;

+    }

+    iVar6 = ExpWnfUpdateSubscription

+                      (param_1,local_48,param_3,param_4,param_6,&local_50,&local_58,&local_54,

+                       param_8);

+    LOCK();

+    lVar8 = *plVar11;

+    if (lVar8 == 0x11) {

+      *plVar11 = 0;

+    }

+    UNLOCK();

+    if (lVar8 != 0x11) {

+      ExfReleasePushLockShared(plVar11);

+    }

+    KeAbPostRelease(plVar11);

+    if (iVar6 < 0) goto LAB_0;

+  }

+  else {

+LAB_0:

+    lVar8 = local_48;

+    _Dst = (undefined4 *)

+           ExAllocatePool2((ulonglong)(PsInitialSystemProcess != param_2) + 0x100,0x88,0x20666e57);

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

+      return 0xc000009a;

+    }

+    memset(_Dst,0,0x88);

+    *_Dst = 0x880905;

+    _Dst[0x18] = param_5;

+    _Dst[0x19] = param_6;

+    *(ulonglong **)(_Dst + 0x14) = param_3;

+    *(undefined8 *)(_Dst + 0x16) = param_4;

+    *(undefined8 *)(_Dst + 2) = 0;

+    *(undefined8 *)(_Dst + 0xe) = *(undefined8 *)(param_1 + 0x28);

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

+      puVar14 = _Dst;

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

+        *param_9 = _Dst;

+      }

+    }

+    else {

+      do {

+        LOCK();

+        lVar7 = ExpWnfSubcriptionIdCounter + 1;

+        UNLOCK();

+        puVar14 = (undefined4 *)(ExpWnfSubcriptionIdCounter + 1);

+        ExpWnfSubcriptionIdCounter = lVar7;

+      } while (puVar14 == (undefined4 *)0x0);

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

+        *param_8 = puVar14;

+      }

+    }

+    puVar12 = (ulonglong *)(lVar8 + 0x50);

+    lVar8 = KeAbPreAcquire(puVar12,0);

+    LOCK();

+    uVar3 = *puVar12;

+    *puVar12 = *puVar12 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar12,lVar8);

+    }

+    if (lVar8 != 0) {

+      *(undefined1 *)(lVar8 + 0x12) = 1;

+    }

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

+    puVar13 = (ulonglong *)0x0;

+    local_40 = KeAbPreAcquire(puVar1,0);

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      puVar13 = puVar1;

+      ExfAcquirePushLockExclusiveEx(puVar1,local_40);

+    }

+    if (local_40 != 0) {

+      *(undefined1 *)(local_40 + 0x12) = 1;

+    }

+    if (*(longlong *)(param_1 + 0x30) == 0) {

+      LOCK();

+      uVar3 = *puVar1;

+      *puVar1 = *puVar1 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar1);

       }

       KeAbPostRelease(puVar1);

-      unaff_EBX = ExpWnfAllocateScopeInstance(unaff_RBP + -0x38,unaff_R15 & 0xffffffff);

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

-      lVar6 = KeAbPreAcquire(puVar1,0,0);

-      LOCK();

-      uVar7 = *puVar1;

-      *puVar1 = *puVar1 | 1;

-      UNLOCK();

-      if ((uVar7 & 1) != 0) {

-        ExfAcquirePushLockExclusiveEx(puVar1,lVar6,puVar1);

-      }

-      if (lVar6 != 0) {

-        *(undefined1 *)(lVar6 + 0x12) = 1;

-      }

-      unaff_RSI = ExpWnfFindScopeInstance(plVar2);

-      if (unaff_RSI == 0) {

-        lVar6 = *(longlong *)(unaff_RBP + -0x38);

-        ExAcquireRundownProtection(lVar6 + 8);

-        lVar3 = *plVar2;

-        plVar8 = (longlong *)(lVar6 + 0x20);

-        if (*(longlong **)(lVar3 + 8) != plVar2) {

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

-          (*pcVar4)(3);

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

-          uVar7 = (*pcVar4)();

-          return uVar7;

-        }

-        *plVar8 = lVar3;

-        *(longlong **)(lVar6 + 0x28) = plVar2;

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

-        *plVar2 = (longlong)plVar8;

+      LOCK();

+      uVar3 = *puVar12;

+      *puVar12 = *puVar12 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar12);

+      }

+      KeAbPostRelease(puVar12);

+      ExFreePoolWithTag(_Dst,0x20666e57);

+      return 0xc0000034;

+    }

+    if ((param_7 != '\x01') ||

+       (iVar6 = ExpWnfUpdateSubscription

+                          (param_1,local_48,param_3,param_4,param_6,&local_50,&local_58,&local_54,

+                           param_8), puVar13 = param_3, iVar6 < 0)) {

+      *(longlong *)(_Dst + 10) = param_2;

+      *(longlong *)(_Dst + 0xc) = param_1;

+      *(undefined4 **)(_Dst + 4) = puVar14;

+      ExAcquireRundownProtection(_Dst + 2);

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

+        ExAcquireRundownProtection(_Dst + 2);

+      }

+      plVar11 = (longlong *)(_Dst + 6);

+      plVar4 = *(longlong **)(local_48 + 0x60);

+      if (*plVar4 != local_48 + 0x58) {

+LAB_1:

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

+        lVar8 = (*pcVar5)(3);

+        *(undefined4 *)puVar1 = 1;

+        iVar6 = iRam0000000000000077;

+        if ((iRam0000000000000077 != 2) &&

+           (((ulonglong)puVar13 & 1) == 0 && (uRam000000000000007b & 1) != 0)) {

+          *_Dst = (int)lVar8;

+        }

+        plVar11 = plRam000000000000006f;

+        lVar7 = lRam0000000000000067;

+        uRam0000000000000063 = (uint)puVar13;

+        uRam000000000000007b = uRam0000000000000063 & uRam000000000000007b;

+        _DAT_2 = param_1;

+        puRam0000000000000057 = puVar14;

+        if (((iVar6 != 0) && (uRam000000000000007b == 0)) && (iRam000000000000007f == 0)) {

+          if ((*(longlong *)(lRam0000000000000067 + 8) != 0x67) || (*plRam000000000000006f != 0x67))

+          {

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

+            (*pcVar5)(3);

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

+            uVar9 = (*pcVar5)();

+            return uVar9;

+          }

+          *plRam000000000000006f = lRam0000000000000067;

+          *(longlong **)(lVar7 + 8) = plVar11;

+          iRam0000000000000077 = 0;

+        }

         LOCK();

-        uVar7 = *puVar1;

-        *puVar1 = *puVar1 - 1;

+        uVar3 = *puVar12;

+        *puVar12 = *puVar12 + lVar8;

         UNLOCK();

-        if (((byte)uVar7 & 6) == 2) {

-          ExfTryToWakePushLock(puVar1);

-        }

-        KeAbPostRelease(puVar1);

-        unaff_EBX = 0;

-        if (*(int *)(unaff_RBP + -0x40) != 0) {

-          LOCK();

-          if (*unaff_R14 == 0) {

-            *unaff_R14 = *(longlong *)(unaff_RBP + -0x38);

-          }

-          UNLOCK();

-        }

-        unaff_RSI = *(longlong *)(unaff_RBP + -0x38);

-        goto LAB_1;

-      }

-      cVar5 = ExAcquireRundownProtection(unaff_RSI + 8);

-      LOCK();

-      uVar7 = *puVar1;

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

+          ExfTryToWakePushLock(puVar12);

+        }

+        KeAbPostRelease(puVar12);

+        ExAcquireRundownProtection(7);

+        *unaff_R13 = 0xffffffffffffffff;

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

+          *unaff_RSI = uRam000000000000000f;

+        }

+        return 0;

+      }

+      *plVar11 = local_48 + 0x58;

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

+      *plVar4 = (longlong)plVar11;

+      *(longlong **)(local_48 + 0x60) = plVar11;

+      plVar4 = *(longlong **)(param_1 + 0x80);

+      plVar11 = (longlong *)(_Dst + 0x10);

+      if (*plVar4 != param_1 + 0x78) goto LAB_1;

+      *plVar11 = param_1 + 0x78;

+      *(longlong **)(_Dst + 0x12) = plVar4;

+      *plVar4 = (longlong)plVar11;

+      *(longlong **)(param_1 + 0x80) = plVar11;

+      if ((_Dst[0x19] & 1) != 0) {

+        LOCK();

+        piVar2 = (int *)(param_1 + 0xa0);

+        iVar6 = *piVar2;

+        *piVar2 = *piVar2 + 1;

+        UNLOCK();

+        if (iVar6 == 0) {

+          local_58 = 1;

+        }

+      }

+      LOCK();

+      uVar3 = *puVar1;

       *puVar1 = *puVar1 - 1;

       UNLOCK();

-      if (((byte)uVar7 & 6) == 2) {

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

         ExfTryToWakePushLock(puVar1);

       }

       KeAbPostRelease(puVar1);

-      ExpWnfFreeScopeInstance(*(undefined8 *)(unaff_RBP + -0x38),0);

-    }

-    else {

-      cVar5 = ExAcquireRundownProtection();

-      LOCK();

-      uVar7 = *puVar1;

-      if (uVar7 == 0x11) {

-        *puVar1 = 0;

-      }

-      UNLOCK();

-      if (uVar7 != 0x11) {

-        ExfReleasePushLockShared(puVar1);

-      }

-      KeAbPostRelease(puVar1);

-    }

-    if (cVar5 == '\0') goto LAB_2;

-    unaff_EBX = 0;

+      LOCK();

+      uVar3 = *puVar12;

+      *puVar12 = *puVar12 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar12);

+      }

+      KeAbPostRelease(puVar12);

+      *param_10 = _Dst;

+      goto LAB_3;

+    }

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    LOCK();

+    uVar3 = *puVar12;

+    *puVar12 = *puVar12 - 1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(puVar12);

+    }

+    KeAbPostRelease(puVar12);

+    ExFreePoolWithTag(_Dst,0x20666e57);

+  }

+  *param_10 = local_50;

+LAB_3:

+  if (local_54 < 0) {

+    LOCK();

+    piVar2 = (int *)(param_1 + 0xa4);

+    iVar6 = *piVar2;

+    *piVar2 = *piVar2 + -1;

+    UNLOCK();

+    if (iVar6 == 1) {

+      uVar10 = 8;

+    }

+  }

+  if (local_58 < 1) {

+    if (local_58 < 0) {

+      uVar10 = uVar10 | 4;

+    }

   }

   else {

-    cVar5 = ExAcquireRundownProtection(unaff_RSI + 8);

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

-LAB_2:

-      unaff_EBX = 0xc0000034;

-      goto LAB_0;

-    }

-  }

-LAB_1:

-  **(longlong **)(unaff_RBP + 0x40) = unaff_RSI;

-LAB_0:

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

-    ExFreePoolWithTag(*(longlong *)(unaff_RBP + -0x18),0x20666e57);

-  }

-  return (ulonglong)unaff_EBX;

+    uVar10 = uVar10 | 2;

+  }

+  if (uVar10 != 0) {

+    ExpWnfNotifyNameSubscribers(param_1,uVar10,1,param_7 != '\0');

+    *param_11 = 1;

+  }

+  return 0;

 }
```

## `IoFreeAdapterChannelV3`  (modified)

```diff
--- IoFreeAdapterChannelV3
+++ IoFreeAdapterChannelV3
@@ -1,36 +1,78 @@
 

-byte IoFreeAdapterChannelV3(void)

+void IoFreeAdapterChannelV3(longlong param_1)

 

 {

-  void *pvVar1;

-  uint uVar2;

-  byte *in_RAX;

-  byte unaff_BL;

-  longlong unaff_RSI;

-  int in_R10D;

-  byte unaff_R12B;

-  byte in_CR8;

+  undefined4 uVar1;

+  bool bVar2;

+  void *pvVar3;

+  char cVar4;

+  longlong lVar5;

+  ulonglong uVar6;

+  byte bVar7;

+  uint uVar8;

+  ulonglong in_CR8;

+  int local_res8 [2];

   

-  *in_RAX = *in_RAX & (byte)in_RAX;

-  *in_RAX = *in_RAX + (byte)in_RAX;

-  uVar2 = (int)unaff_RSI + 5;

-  if (unaff_BL != unaff_R12B) {

-    uVar2 = uVar2 & (uint)(unaff_RSI << (unaff_BL + 1 & 0x3f));

+  if (((char)in_CR8 == '\x02') && (*(int *)(param_1 + 0x208) != 0)) {

+    if (*(char *)(param_1 + 0xe0) != '\0') {

+      ExQueueWorkItem(param_1 + 0x1e0,0);

+    }

   }

-  *(uint *)(*(longlong *)(in_RAX + 35000) + 0x14) =

-       *(uint *)(*(longlong *)(in_RAX + 35000) + 0x14) | uVar2;

-  if (in_R10D != 0) {

-    HalpDmaFreeMapRegisters();

+  else {

+    uVar6 = in_CR8;

+    IoFreeAdapterChannelV3Internal();

+    do {

+      lVar5 = HalpDmaGetNextWcb(param_1);

+      if (lVar5 == 0) {

+        return;

+      }

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

+      bVar2 = false;

+      *(undefined4 *)(param_1 + 0xf8) = *(undefined4 *)(lVar5 + 0x28);

+      uVar1 = *(undefined4 *)(lVar5 + 0x10);

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

+      *(undefined4 *)(param_1 + 0x184) = uVar1;

+      if ((byte)in_CR8 < 2) {

+        if (((KiIrqlFlags != 0) && ((KiIrqlFlags & 1) != 0)) && (bVar7 = (byte)uVar6, bVar7 < 0x10))

+        {

+          if (bVar7 == 2) {

+            uVar8 = 4;

+          }

+          else {

+            uVar8 = (uint)(-1L << (bVar7 + 1 & 0x3f)) & 4;

+          }

+          *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) =

+               *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) | uVar8;

+        }

+        bVar2 = true;

+        in_CR8 = uVar6;

+        uVar6 = 2;

+      }

+      local_res8[0] = 1;

+      cVar4 = HalpAllocateDmaResourcesInternal(param_1,0,local_res8);

+      if ((cVar4 != '\0') && (local_res8[0] != 1)) {

+        if (local_res8[0] != 2) {

+          if (local_res8[0] != 3) goto LAB_0;

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

+        }

+        IoFreeAdapterChannelV3Internal(param_1);

+      }

+LAB_0:

+      pvVar3 = FiberData;

+      if (bVar2) {

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

+           (((byte)uVar6 < 0x10 &&

+            ((((byte)in_CR8 < 0x10 && (1 < (byte)uVar6)) &&

+             (uVar8 = *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) &

+                      ~((uint)(-1L << ((byte)in_CR8 + 1 & 0x3f)) & 0xffff),

+             *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) = uVar8, uVar8 == 0))))))

+        {

+          KiRemoveSystemWorkPriorityKick(pvVar3);

+        }

+        uVar6 = in_CR8 & 0xff;

+      }

+    } while (cVar4 != '\0');

   }

-  HalpDmaProcessMapRegisterQueueV3();

-  pvVar1 = FiberData;

-  if ((((KiIrqlFlags != 0) && ((KiIrqlFlags & 1) != 0)) && (in_CR8 < 0x10)) &&

-     (((unaff_BL < 0x10 && (unaff_R12B <= in_CR8)) &&

-      (uVar2 = *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) &

-               ~((uint)(unaff_RSI << (unaff_BL + 1 & 0x3f)) & 0xffff),

-      *(uint *)(*(longlong *)((longlong)FiberData + 35000) + 0x14) = uVar2, uVar2 == 0)))) {

-    KiRemoveSystemWorkPriorityKick(pvVar1);

-  }

-  return unaff_BL;

+  return;

 }
```

## `ObReferenceObjectByNameEx`  (modified)

```diff
--- ObReferenceObjectByNameEx
+++ ObReferenceObjectByNameEx
@@ -1,17 +1,144 @@
 

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

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

 

-void ObReferenceObjectByNameEx(char *param_1,undefined2 param_2)

+int ObReferenceObjectByNameEx

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

+              undefined1 param_5,undefined8 param_6,longlong *param_7)

 

 {

-  char in_AL;

-  undefined6 in_register_00000002;

-  undefined2 in_ES;

+  PSLIST_ENTRY_conflict p_Var1;

+  PSLIST_ENTRY_conflict p_Var2;

+  PSLIST_HEADER p_Var3;

+  code *pcVar4;

+  void *pvVar5;

+  char cVar6;

+  PSLIST_ENTRY_conflict p_Var7;

+  undefined8 uVar8;

+  ushort *puVar9;

+  PSLIST_ENTRY_conflict p_Var10;

+  int local_res8;

+  undefined8 in_stack_ffffffffffffff30;

+  undefined4 uVar11;

+  longlong local_88;

+  _SLIST_ENTRY local_80;

+  longlong lStack_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  longlong local_60;

+  _SLIST_ENTRY *p_Stack_58;

+  PSLIST_ENTRY local_50;

+  undefined8 uStack_48;

+  undefined8 local_40;

   

-  out(uRam0000000000000000,param_2);

-  *param_1 = *param_1 + (char)((ushort)param_2 >> 8);

-  *(undefined2 *)CONCAT62(in_register_00000002,(short)in_AL * (short)cRam0000000000000001) = in_ES;

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

-  halt_baddata();

+  pvVar5 = FiberData;

+  uVar11 = (undefined4)((ulonglong)in_stack_ffffffffffffff30 >> 0x20);

+  local_88 = 0;

+  local_40 = 0;

+  local_80.Next = (PSLIST_ENTRY)0x0;

+  lStack_78 = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_60 = 0;

+  p_Stack_58 = (_SLIST_ENTRY *)0x0;

+  local_50 = (PSLIST_ENTRY)0x0;

+  uStack_48 = 0;

+  if ((param_1 == 0) || (param_4 == 0)) {

+    return -0x3ffffff3;

+  }

+  p_Var3 = *(PSLIST_HEADER *)((longlong)FiberData + 0x880);

+  *(int *)((longlong)p_Var3 + 0x14) = *(int *)((longlong)p_Var3 + 0x14) + 1;

+  p_Var7 = ExpInterlockedPopEntrySList(p_Var3);

+  if (p_Var7 == (PSLIST_ENTRY_conflict)0x0) {

+    *(int *)((longlong)p_Var3 + 0x18) = *(int *)((longlong)p_Var3 + 0x18) + 1;

+    p_Var3 = *(PSLIST_HEADER *)((longlong)pvVar5 + 0x888);

+    *(int *)((longlong)p_Var3 + 0x14) = *(int *)((longlong)p_Var3 + 0x14) + 1;

+    p_Var7 = ExpInterlockedPopEntrySList(p_Var3);

+    if (p_Var7 == (PSLIST_ENTRY_conflict)0x0) {

+      pcVar4 = (code *)p_Var3[3].s.Alignment;

+      *(int *)((longlong)p_Var3 + 0x18) = *(int *)((longlong)p_Var3 + 0x18) + 1;

+      p_Var7 = (PSLIST_ENTRY_conflict)

+               (*pcVar4)(*(undefined4 *)((longlong)p_Var3 + 0x24),

+                         *(undefined4 *)((longlong)p_Var3 + 0x2c),

+                         *(undefined4 *)((longlong)p_Var3 + 0x28));

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

+    }

+  }

+  *(undefined4 *)&p_Var7->Next = *(undefined4 *)((longlong)pvVar5 + 0x24);

+LAB_0:

+  if (p_Var7 == (PSLIST_ENTRY_conflict)0x0) {

+    return -0x3fffff66;

+  }

+  p_Var1 = p_Var7 + 0x14;

+  local_res8 = ObpCaptureObjectCreateInformation

+                         (param_5,param_5,param_1,&local_80,p_Var1,CONCAT44(uVar11,1));

+  if (-1 < local_res8) {

+    p_Var10 = param_2;

+    if (((param_2 != (PSLIST_ENTRY_conflict)0x0) ||

+        (local_res8 = SeCreateAccessState(p_Var7,p_Var7 + 0x1c,param_3,param_4 + 0x4c),

+        p_Var10 = p_Var7, -1 < local_res8)) &&

+       (local_res8 = ObpAdjustAccessMask(p_Var10), param_2 = p_Var10, -1 < local_res8)) {

+      p_Var2 = p_Var7 + 0x38;

+      uVar8 = PsGetCurrentSilo();

+      local_res8 = ObpLookupObjectName(p_Var7[0x15].Next,&local_80,*(undefined4 *)&p_Var1->Next,

+                                       param_4,param_5,param_6,0,0,uVar8,p_Var10,p_Var2,0,&local_88)

+      ;

+      if (-1 < local_res8) {

+        if (p_Var2->Next != (PSLIST_ENTRY)0x0) {

+          ObpUnlockDirectory(p_Var2);

+        }

+        if ((*(uint *)&p_Var1->Next &

+            *(uint *)((&ObTypeIndexTable)

+                      [local_88 - 0x30U >> 8 & 0xff ^ (ulonglong)*(byte *)(local_88 + -0x18) ^

+                       (ulonglong)ObHeaderCookie] + 0x48)) == 0) {

+          if (SepLearningModeTokenCount != 0) {

+            local_60 = (&ObTypeIndexTable)

+                       [local_88 - 0x30U >> 8 & 0xff ^ (ulonglong)*(byte *)(local_88 + -0x18) ^

+                        (ulonglong)ObHeaderCookie] + 0x10;

+            p_Stack_58 = &local_80;

+            local_50 = p_Var7[0x15].Next;

+            SeSetLearningModeObjectInformation(&local_70);

+          }

+          cVar6 = ObpCheckObjectReference(local_88,p_Var10);

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

+            ObDereferenceObject(local_88);

+          }

+          else {

+            *param_7 = local_88;

+          }

+          SeClearLearningModeObjectInformation();

+        }

+        else {

+          ObDereferenceObject();

+          local_res8 = -0x3ffffff3;

+        }

+      }

+    }

+    if (param_2 == p_Var7) {

+      SepDeleteAccessState(param_2);

+      SeReleaseSubjectContext(param_2 + 4);

+    }

+    if (p_Var7[0x18].Next != (PSLIST_ENTRY)0x0) {

+      SeReleaseSecurityDescriptor(p_Var7[0x18].Next,*(undefined1 *)&p_Var7[0x16].Next,1);

+      p_Var7[0x18].Next = (PSLIST_ENTRY)0x0;

+    }

+    if (lStack_78 != 0) {

+      ObpFreeObjectNameBuffer(&local_80);

+    }

+  }

+  pvVar5 = FiberData;

+  puVar9 = *(ushort **)((longlong)FiberData + 0x880);

+  *(int *)(puVar9 + 0xe) = *(int *)(puVar9 + 0xe) + 1;

+  if (puVar9[8] <= *puVar9) {

+    *(int *)(puVar9 + 0x10) = *(int *)(puVar9 + 0x10) + 1;

+    puVar9 = *(ushort **)((longlong)pvVar5 + 0x888);

+    *(int *)(puVar9 + 0xe) = *(int *)(puVar9 + 0xe) + 1;

+    if (puVar9[8] <= *puVar9) {

+      *(int *)(puVar9 + 0x10) = *(int *)(puVar9 + 0x10) + 1;

+      (**(code **)(puVar9 + 0x1c))(p_Var7);

+      return local_res8;

+    }

+  }

+  ExpInterlockedPushEntrySList(puVar9,p_Var7);

+  return local_res8;

 }
```

## `CmRmFinalizeRecovery`  (modified)

```diff
--- CmRmFinalizeRecovery
+++ CmRmFinalizeRecovery
@@ -1,30 +1,87 @@
 

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

 

-undefined4 CmRmFinalizeRecovery(char param_1)

+undefined8 CmRmFinalizeRecovery(longlong param_1)

 

 {

-  char cVar1;

-  ulonglong in_RAX;

-  char *pcVar2;

-  undefined4 unaff_EBX;

-  ulonglong unaff_RBP;

-  ulonglong uVar3;

-  undefined4 *unaff_RSI;

+  byte *pbVar1;

+  longlong lVar2;

+  code *pcVar3;

+  undefined8 uVar4;

+  longlong unaff_RBP;

+  byte *pbVar5;

+  undefined4 uVar6;

+  undefined8 auStack_68 [4];

+  undefined4 local_48 [2];

+  ulonglong local_40;

+  undefined8 uStack_38;

+  undefined8 local_30;

+  undefined8 uStack_28;

+  undefined8 local_20;

+  undefined8 uStack_18;

+  ulonglong local_10;

   

-  *(char *)(in_RAX - 0x73) = *(char *)(in_RAX - 0x73) + param_1;

-  pcVar2 = (char *)(unaff_RBP & 0xffffffff);

-  uVar3 = in_RAX & 0xffffffff;

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

-  RtlInitUnicodeString(uVar3 - 0x78);

-  RtlInitUnicodeString(uVar3 - 0x58,uVar3 - 0x40);

-  RtlInitUnicodeString(&stack0x00000078,uVar3 + 0x1e0);

-  RtlInitUnicodeString(uVar3 - 0x68,uVar3 + 0x50);

-  cVar1 = RtlEqualUnicodeString(uVar3 - 0x78,&stack0x00000078,1);

-  if ((cVar1 == '\0') || (cVar1 = RtlEqualUnicodeString(uVar3 - 0x58,uVar3 - 0x68,1), cVar1 == '\0')

-     ) {

-    *unaff_RSI = 1;

+  local_10 = __security_cookie ^ (ulonglong)auStack_68;

+  local_48[0] = 0;

+  local_40 = 0;

+  uStack_38 = 0;

+  local_30 = 0;

+  uStack_28 = 0;

+  local_20 = 0;

+  uStack_18 = 0;

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

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

+  ExAcquireFastMutexUnsafe(&CmpTransactionListLock);

+  pbVar5 = (byte *)(param_1 + 0x10);

+  while( true ) {

+    pbVar1 = *(byte **)pbVar5;

+    if (pbVar1 == pbVar5) {

+      ExReleaseFastMutexUnsafe(&CmpTransactionListLock);

+      KeLeaveCriticalRegion();

+      return 0;

+    }

+    if ((*(byte **)(pbVar1 + 8) != pbVar5) ||

+       (lVar2 = *(longlong *)pbVar1, *(byte **)(lVar2 + 8) != pbVar1)) break;

+    *(longlong *)pbVar5 = lVar2;

+    *(byte **)(lVar2 + 8) = pbVar5;

+    ExReleaseFastMutexUnsafe(&CmpTransactionListLock);

+    KeLeaveCriticalRegion();

+    CmpTransMgrRollback(pbVar1,local_48);

+    CmpAttachToRegistryProcess(&local_40);

+    CmpTransMgrFreeVolatileData(pbVar1,8);

+    CmpDetachFromRegistryProcess(&local_40);

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

+      CmpTransDereferenceTransaction(*(undefined8 *)(pbVar1 + 0x38));

+    }

+    if (*(longlong *)(pbVar1 + 0x48) != 0) {

+      ObfDereferenceObject();

+    }

+    if (*(longlong *)(pbVar1 + 0x50) != 0) {

+      ZwClose();

+    }

+    ExFreePoolWithTag(pbVar1,0x72544d43);

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

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

+    ExAcquireFastMutexUnsafe(&CmpTransactionListLock);

   }

-  return unaff_EBX;

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

+  uVar6 = (*pcVar3)(3);

+  uVar4 = *(undefined8 *)(pbVar1 + 0x38);

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

+  *(undefined8 *)(unaff_RBP + -0x50) = uVar4;

+  auStack_68[0] = 0x14090844f;

+  uVar6 = ZwFreeVirtualMemory(uVar6,unaff_RBP + -0x50,unaff_RBP + -0x48,0x8000);

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

+    uVar4 = *(undefined8 *)(pbVar1 + 0x40);

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

+    uStack_38 = CONCAT44(uStack_38._4_4_,0x40000000);

+    *(undefined8 *)(unaff_RBP + -0x50) = uVar4;

+    local_40 = local_40 & 0xffffffffffffff00;

+    auStack_68[0] = 0x140908485;

+    MmFreeVirtualMemory(uVar6,unaff_RBP + -0x50,unaff_RBP + -0x48,0x8000);

+  }

+  auStack_68[0] = 0x1407eb8d6;

+  uVar4 = KiUnstackDetachProcess(unaff_RBP + -0x40,0);

+  return uVar4;

 }
```

## `PipAddRequestToEdge`  (modified)

```diff
--- PipAddRequestToEdge
+++ PipAddRequestToEdge
@@ -1,13 +1,104 @@
 

-uint PipAddRequestToEdge(uint *param_1)

+longlong * PipAddRequestToEdge(longlong param_1,int *param_2)

 

 {

-  uint uVar1;

-  uint in_EAX;

+  longlong *plVar1;

+  longlong *plVar2;

+  code *pcVar3;

+  char cVar4;

+  int iVar5;

+  longlong lVar6;

+  longlong lVar7;

+  ulonglong uVar8;

+  longlong *plVar9;

+  longlong *plVar10;

+  undefined8 *puVar11;

+  undefined8 *puVar12;

+  longlong in_R10;

+  longlong *plVar13;

   

-  uVar1 = *param_1;

-  ExReleaseResourceLite();

-  PpDevNodeUnlockTree(0);

-  return in_EAX & uVar1;

+  plVar10 = (longlong *)0x0;

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

+  plVar9 = (longlong *)0x0;

+  plVar2 = (longlong *)*plVar1;

+  while (plVar13 = plVar2, plVar13 != plVar1) {

+    if (plVar9 != (longlong *)0x0) goto LAB_0;

+    plVar2 = (longlong *)*plVar13;

+    iVar5 = (int)plVar13[2];

+    if (iVar5 == *param_2) {

+      if (iVar5 == 0) {

+        if (plVar13[3] == *(longlong *)(param_2 + 2)) {

+          plVar9 = plVar13;

+        }

+      }

+      else if ((iVar5 == 1) &&

+              (cVar4 = RtlEqualUnicodeString(plVar13[3],*(undefined8 *)(param_2 + 2),0),

+              cVar4 != '\0')) {

+        plVar9 = plVar13;

+      }

+    }

+  }

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

+    lVar6 = 0x53706e50;

+    plVar10 = (longlong *)ExAllocatePool2(0x100,0x28);

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

+      uVar8 = (ulonglong)(uint)param_2[4];

+      *(int *)(plVar10 + 4) = param_2[4];

+      iVar5 = *param_2;

+      *(int *)(plVar10 + 2) = iVar5;

+      if (iVar5 == 0) {

+        plVar10[3] = *(longlong *)(param_2 + 2);

+      }

+      else if (iVar5 == 1) {

+        lVar6 = ExAllocatePool2(0x100,0x10,0x53706e50);

+        plVar10[3] = lVar6;

+        uVar8 = *(ulonglong *)(param_2 + 2);

+        iVar5 = RtlDuplicateUnicodeString(0);

+        if (iVar5 < 0) {

+          PipFreeBindingRequestEntry(plVar10);

+          plVar10 = (longlong *)0x0;

+          goto LAB_1;

+        }

+      }

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

+      if ((longlong *)*plVar2 != plVar1) {

+        lVar7 = 3;

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

+        (*pcVar3)();

+        do {

+          lVar7 = *(longlong *)(lVar7 + 0x10);

+          if (lVar7 == lVar6) {

+            return (longlong *)0x0;

+          }

+        } while (lVar7 != IopRootDeviceNode);

+        puVar12 = (undefined8 *)(uVar8 + 0x10);

+        puVar11 = (undefined8 *)*puVar12;

+        do {

+          if (puVar11 == puVar12) {

+            return (longlong *)0x1;

+          }

+          lVar6 = PiListEntryToDependencyEdge(puVar11,0);

+          puVar11 = (undefined8 *)*puVar11;

+        } while (*(longlong *)(lVar6 + 0x20) != in_R10);

+        return (longlong *)0x0;

+      }

+      *plVar10 = (longlong)plVar1;

+      plVar10[1] = (longlong)plVar2;

+      *plVar2 = (longlong)plVar10;

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

+    }

+  }

+  else {

+LAB_0:

+    *(uint *)(plVar9 + 4) = *(uint *)(plVar9 + 4) | param_2[4];

+  }

+LAB_1:

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

+    plVar9 = plVar10;

+  }

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

+    PipMergeDependencyTypes(param_1,param_2[4]);

+  }

+  return plVar9;

 }
```

## `RtlpAddIntersectingRanges`  (modified)

```diff
--- RtlpAddIntersectingRanges
+++ RtlpAddIntersectingRanges
@@ -1,12 +1,192 @@
 

-void RtlpAddIntersectingRanges(byte param_1)

+undefined8

+RtlpAddIntersectingRanges

+          (ulonglong *param_1,ulonglong *param_2,ulonglong *param_3,ulonglong *param_4)

 

 {

-  byte *pbVar1;

-  longlong in_RAX;

+  longlong *plVar1;

+  ulonglong *puVar2;

+  ulonglong *puVar3;

+  ulonglong uVar4;

+  undefined8 *puVar5;

+  code *pcVar6;

+  undefined8 uVar7;

+  longlong lVar8;

+  ulonglong *puVar9;

+  ulonglong *puVar10;

+  ulonglong *puVar11;

+  ulonglong *puVar12;

+  ulonglong *puVar13;

+  ulonglong *puVar14;

+  ulonglong *puVar15;

+  ulonglong *puVar16;

+  byte bVar17;

+  undefined8 in_R10;

+  ulonglong in_R11;

+  ulonglong *puVar18;

   

-  pbVar1 = (byte *)(in_RAX + -0x75);

-  *pbVar1 = *pbVar1 >> (param_1 & 7) | *pbVar1 << 8 - (param_1 & 7);

-  return;

+  bVar17 = *(byte *)((longlong)param_3 + 0x21) & 1;

+  puVar18 = (ulonglong *)

+            (CONCAT71((int7)((ulonglong)in_R10 >> 8),*(byte *)((longlong)param_3 + 0x21)) &

+            0xffffffffffffff01);

+  puVar15 = param_3;

+  puVar16 = param_4;

+  if ((((ulonglong)param_4 & 1) == 0) && (param_1 != param_2 + 5)) {

+    in_R11 = param_3[1];

+    puVar11 = param_2;

+    do {

+      if (in_R11 < *puVar11) break;

+      if ((*(byte *)((longlong)puVar11 + 0x22) & 1) == 0) {

+        if ((bVar17 == 0) || ((*(byte *)((longlong)puVar11 + 0x21) & 1) == 0)) {

+          return 0xc0000282;

+        }

+      }

+      else {

+        puVar16 = puVar11 + 2;

+        puVar10 = (ulonglong *)*puVar16;

+        if (puVar16 != puVar10) {

+          puVar15 = (ulonglong *)*param_3;

+          do {

+            uVar4 = puVar10[-5];

+            if (((puVar15 <= uVar4) || (puVar15 <= puVar10[-4])) &&

+               ((uVar4 <= puVar15 || (uVar4 <= in_R11)))) {

+              if (bVar17 == 0) {

+                return 0xc0000282;

+              }

+              if ((*(byte *)((longlong)puVar10 + -7) & 1) == 0) {

+                return 0xc0000282;

+              }

+            }

+            puVar10 = (ulonglong *)*puVar10;

+          } while (puVar16 != puVar10);

+        }

+      }

+      puVar10 = puVar11 + 5;

+      puVar11 = (ulonglong *)*puVar10 + -5;

+    } while (param_1 != (ulonglong *)*puVar10);

+  }

+  if ((*(byte *)((longlong)param_2 + 0x22) & 1) == 0) {

+    lVar8 = RtlpCopyRangeListEntry(param_2);

+    if (lVar8 == 0) {

+      return 0xc000009a;

+    }

+    puVar11 = param_2 + 2;

+    if ((*(byte *)((longlong)param_2 + 0x21) & 0x10) != 0) {

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

+      *(byte *)((longlong)param_2 + 0x21) = *(byte *)((longlong)param_2 + 0x21) & 0xef;

+    }

+    plVar1 = (longlong *)(lVar8 + 0x28);

+    *(undefined2 *)((longlong)param_2 + 0x22) = 1;

+    *plVar1 = (longlong)puVar11;

+    *(ulonglong **)(lVar8 + 0x30) = puVar11;

+    param_2[3] = (ulonglong)plVar1;

+    *puVar11 = (ulonglong)plVar1;

+  }

+  puVar11 = (ulonglong *)param_2[5];

+  puVar10 = (ulonglong *)param_2[5] + -5;

+  while( true ) {

+    while( true ) {

+      puVar13 = (ulonglong *)0x1;

+      puVar12 = (ulonglong *)*puVar11;

+      puVar14 = puVar12 + -5;

+      if ((param_1 == puVar11) || (param_3[1] < *puVar10)) {

+        uVar7 = RtlpAddToMergedRange(param_2,param_3,(ulonglong)param_4 & 0xffffffff);

+        return uVar7;

+      }

+      puVar11 = puVar12;

+      if ((*(byte *)((longlong)puVar10 + 0x22) & 1) == 0) break;

+      puVar9 = (ulonglong *)puVar10[2];

+      puVar12 = puVar9 + -5;

+      while( true ) {

+        puVar3 = (ulonglong *)*puVar9;

+        puVar13 = puVar3 + -5;

+        if (puVar10 + 2 == puVar9) break;

+        puVar15 = (ulonglong *)*puVar9;

+        if (((ulonglong *)puVar15[1] != puVar9) ||

+           (puVar2 = (ulonglong *)puVar9[1], (ulonglong *)*puVar2 != puVar9)) goto LAB_0;

+        *puVar2 = (ulonglong)puVar15;

+        puVar15[1] = (ulonglong)puVar2;

+        puVar15 = (ulonglong *)((ulonglong)param_4 & 0xffffffff);

+        RtlpAddToMergedRange(param_2);

+        puVar9 = puVar3;

+        puVar12 = puVar13;

+      }

+      puVar12 = puVar10 + 5;

+      uVar4 = *puVar12;

+      if ((*(ulonglong **)(uVar4 + 8) != puVar12) ||

+         (puVar9 = (ulonglong *)puVar10[6], (ulonglong *)*puVar9 != puVar12)) goto LAB_0;

+      *puVar9 = uVar4;

+      *(ulonglong **)(uVar4 + 8) = puVar9;

+      RtlpFreeRangeListEntry(puVar10);

+      puVar10 = puVar14;

+    }

+    puVar9 = puVar10 + 5;

+    puVar12 = (ulonglong *)*puVar9;

+    if (((ulonglong *)puVar12[1] != puVar9) ||

+       (puVar5 = (undefined8 *)puVar10[6], (ulonglong *)*puVar5 != puVar9)) break;

+    *puVar5 = puVar12;

+    puVar15 = (ulonglong *)((ulonglong)param_4 & 0xffffffff);

+    puVar12[1] = (ulonglong)puVar5;

+    RtlpAddToMergedRange(param_2,puVar10);

+    puVar10 = puVar14;

+  }

+LAB_0:

+  puVar11 = (ulonglong *)0x3;

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

+  puVar10 = (ulonglong *)(*pcVar6)();

+  do {

+    if ((*(byte *)((longlong)puVar11 + 0x21) & 1) != 0) goto LAB_1;

+    do {

+      if (((ulonglong)puVar13 & 1) == 0) {

+        return 0xc0000282;

+      }

+      *(byte *)((longlong)puVar11 + 0x21) = *(byte *)((longlong)puVar11 + 0x21) | 2;

+      puVar15 = (ulonglong *)*puVar12;

+      *(byte *)((longlong)puVar12 + 0x21) = *(byte *)((longlong)puVar12 + 0x21) | 2;

+      puVar10 = (ulonglong *)*puVar11;

+LAB_1:

+      do {

+        if ((puVar18 == (ulonglong *)0x0) && (puVar15 < puVar10)) {

+          puVar18 = (ulonglong *)puVar11[6];

+        }

+        uVar4 = puVar11[5];

+        puVar11 = (ulonglong *)(uVar4 - 0x28);

+        if (in_R11 == uVar4) {

+          puVar15 = puVar12 + 5;

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

+            puVar18 = *(ulonglong **)(in_R11 + 8);

+            if (*puVar18 != in_R11) {

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

+              (*pcVar6)(3);

+              return 0xc000009a;

+            }

+            *puVar15 = in_R11;

+            puVar12[6] = (ulonglong)puVar18;

+            *puVar18 = (ulonglong)puVar15;

+            *(ulonglong **)(in_R11 + 8) = puVar15;

+          }

+          else {

+            uVar4 = *puVar18;

+            *puVar15 = uVar4;

+            puVar12[6] = (ulonglong)puVar18;

+            *(ulonglong **)(uVar4 + 8) = puVar15;

+            *puVar18 = (ulonglong)puVar15;

+          }

+          if (*puVar12 < *puVar16) {

+            *puVar16 = *puVar12;

+          }

+          if (puVar16[1] < puVar12[1]) {

+            puVar16[1] = puVar12[1];

+          }

+          if (((*(byte *)((longlong)puVar16 + 0x21) & 1) != 0) && ((char)puVar14 == '\0')) {

+            *(byte *)((longlong)puVar16 + 0x21) = *(byte *)((longlong)puVar16 + 0x21) & 0xfe;

+          }

+          return 0;

+        }

+        puVar10 = (ulonglong *)*puVar11;

+      } while (((puVar10 < puVar15) && (*(ulonglong **)(uVar4 - 0x20) < puVar15)) ||

+              ((puVar15 < puVar10 && ((ulonglong *)puVar12[1] < puVar10))));

+    } while ((char)puVar14 == '\0');

+  } while( true );

 }
```

## `NtNotifyChangeMultipleKeys`  (modified)

```diff
--- NtNotifyChangeMultipleKeys
+++ NtNotifyChangeMultipleKeys
@@ -1,618 +1,617 @@
 

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

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

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

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

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

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

 

 ulonglong NtNotifyChangeMultipleKeys

                     (undefined8 param_1,uint param_2,undefined8 param_3,longlong param_4,

                     code *param_5,undefined8 param_6,uint *param_7,uint param_8,undefined1 param_9,

                     undefined8 param_10,undefined4 param_11,char param_12)

 

 {

   short sVar1;

   ulonglong uVar2;

   ulonglong uVar3;

   longlong *plVar4;

   code *pcVar5;

   byte bVar6;

   char cVar7;

   uint uVar8;

   longlong *plVar9;

   longlong *plVar10;

   longlong lVar11;

   longlong lVar12;

   char cVar13;

   undefined1 *puVar14;

   undefined1 *puVar15;

   undefined1 *puVar16;

   byte bVar17;

   longlong *plVar18;

   longlong *plVar19;

   ulonglong *puVar20;

   int iVar21;

   bool bVar22;

   longlong *in_CR8;

-  undefined1 local_e8 [8];

+  undefined1 auStack_e8 [8];

   undefined1 auStack_e0 [24];

-  longlong **pplStack_c8;

-  code *pcStack_c0;

-  longlong *plStack_b8;

-  undefined8 uStack_b0;

-  char cStack_a8;

-  byte bStack_a7;

-  char cStack_a6;

-  char cStack_a5;

-  byte bStack_a4;

+  longlong **local_c8;

+  code *local_c0;

+  longlong *local_b8;

+  undefined8 local_b0;

+  char local_a8;

+  byte local_a7;

+  char local_a6;

+  char local_a5;

+  byte local_a4;

   longlong *local_a0;

-  int iStack_98;

-  longlong *plStack_90;

-  longlong lStack_88;

-  longlong lStack_80;

-  longlong *plStack_78;

-  longlong *plStack_70;

-  undefined8 uStack_68;

+  int local_98;

+  longlong *local_90;

+  longlong local_88;

+  longlong local_80;

+  longlong *local_78;

+  longlong *local_70;

+  undefined8 local_68;

   undefined8 uStack_60;

-  longlong *plStack_58;

-  undefined4 uStack_50;

+  longlong *local_58;

+  undefined4 local_50;

   longlong *local_48;

   

-  puVar14 = local_e8;

-  puVar15 = local_e8;

-  puVar16 = local_e8;

-  uStack_68 = 0;

+  puVar14 = auStack_e8;

+  puVar15 = auStack_e8;

+  puVar16 = auStack_e8;

+  local_68 = 0;

   uStack_60 = 0;

   plVar19 = (longlong *)0x0;

   local_a0 = (longlong *)0x0;

-  plStack_78 = (longlong *)0x0;

-  plStack_90 = (longlong *)0x0;

-  iStack_98 = 1;

-  bStack_a4 = 0;

-  lStack_80 = 0;

-  uStack_50 = 0;

-  CmpInitializeThreadInfo(&uStack_68);

-  cStack_a8 = CmpAcquireShutdownRundown();

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

+  local_78 = (longlong *)0x0;

+  local_90 = (longlong *)0x0;

+  local_98 = 1;

+  local_a4 = 0;

+  local_80 = 0;

+  local_50 = 0;

+  CmpInitializeThreadInfo(&local_68);

+  local_a8 = CmpAcquireShutdownRundown();

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

     plVar18 = (longlong *)0xc0000189;

-    puVar16 = local_e8;

+    puVar16 = auStack_e8;

     goto LAB_0;

   }

   bVar22 = param_2 == 1;

   if (1 < param_2) {

 LAB_1:

     CmpReleaseShutdownRundown();

     plVar18 = (longlong *)0xc000000d;

     goto LAB_0;

   }

-  bStack_a7 = *(byte *)((longlong)SystemReserved1[0xf] + 0x232);

-  cStack_a5 = bVar22;

-  if (bStack_a7 == 0) {

-    if ((param_12 != '\0') && (iStack_98 = 3, param_2 != 0)) {

+  local_a7 = *(byte *)((longlong)SystemReserved1[0xf] + 0x232);

+  local_a5 = bVar22;

+  if (local_a7 == 0) {

+    if ((param_12 != '\0') && (local_98 = 3, param_2 != 0)) {

       CmpReleaseShutdownRundown();

-      CmCleanupThreadInfo(&uStack_68);

+      CmCleanupThreadInfo(&local_68);

       return 0xc000000d;

     }

   }

   else if ((param_8 & 0x10000000) == 0) {

     if (*(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x580) == 0) {

 LAB_2:

       bVar17 = 0;

     }

     else {

       sVar1 = *(short *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x96c);

       bVar17 = 1;

       if ((sVar1 == 0x14c) || (bVar6 = 0, sVar1 == 0x1c4)) {

         bVar6 = bVar17;

       }

       if (bVar6 == 0) goto LAB_2;

     }

-    bStack_a4 = bVar17;

+    local_a4 = bVar17;

     ProbeForWrite(param_7,(bVar17 ^ 1) * '\b' + '\b',4);

     ProbeForWrite(param_10,param_11,4);

     if (bVar17 == 0) {

       *param_7 = 0x103;

       param_7[2] = 0;

       param_7[3] = 0;

     }

     else {

       param_7[0] = 0x103;

       param_7[1] = 0;

     }

     if (param_12 != '\0') {

-      iStack_98 = 2;

+      local_98 = 2;

     }

   }

   else {

     if (((param_12 == '\0') || (param_5 != (code *)0x0)) || (param_4 == 0)) goto LAB_1;

-    iStack_98 = 4;

+    local_98 = 4;

   }

   if (param_8 == (param_8 & 0x1000000f)) {

-    pcStack_c0 = (code *)0x0;

-    pplStack_c8 = &local_a0;

+    local_c0 = (code *)0x0;

+    local_c8 = &local_a0;

     uVar8 = CmObReferenceObjectByHandle(param_1,0x10);

     plVar18 = (longlong *)(ulonglong)uVar8;

-    puVar16 = local_e8;

+    puVar16 = auStack_e8;

     if (-1 < (int)uVar8) {

-      lStack_88 = 0;

+      local_88 = 0;

       if (param_2 == 1) {

-        pcStack_c0 = (code *)&lStack_88;

-        pplStack_c8 = (longlong **)CONCAT71(pplStack_c8._1_7_,bStack_a7);

+        local_c0 = (code *)&local_88;

+        local_c8 = (longlong **)CONCAT71(local_c8._1_7_,local_a7);

         uVar8 = CmObReferenceObjectByName(param_3);

         plVar18 = (longlong *)(ulonglong)uVar8;

-        puVar16 = local_e8;

+        puVar16 = auStack_e8;

         if (-1 < (int)uVar8) {

-          if (*(longlong *)(local_a0[1] + 0x20) !=

-              *(longlong *)(*(longlong *)(lStack_88 + 8) + 0x20)) goto LAB_3;

-          ObfDereferenceObject(lStack_88);

+          if (*(longlong *)(local_a0[1] + 0x20) != *(longlong *)(*(longlong *)(local_88 + 8) + 0x20)

+             ) goto LAB_3;

+          ObfDereferenceObject(local_88);

           plVar18 = (longlong *)0xc000000d;

-          puVar16 = local_e8;

+          puVar16 = auStack_e8;

         }

 LAB_4:

         puVar15 = puVar16;

         cVar13 = puVar15[0x40];

       }

       else {

 LAB_3:

-        lVar12 = lStack_88;

-        iVar21 = iStack_98;

-        plVar9 = (longlong *)CmpAllocatePostBlock(iStack_98,0x10000,0);

-        plStack_70 = plVar9;

+        lVar12 = local_88;

+        iVar21 = local_98;

+        plVar9 = (longlong *)CmpAllocatePostBlock(local_98,0x10000,0);

+        local_70 = plVar9;

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

           if (param_2 == 1) {

             ObfDereferenceObject(lVar12);

           }

 LAB_5:

           plVar18 = (longlong *)0xc000009a;

-          puVar16 = local_e8;

+          puVar16 = auStack_e8;

           goto LAB_4;

         }

         plVar10 = plVar19;

         if ((param_2 == 1) &&

-           (plVar10 = (longlong *)CmpAllocatePostBlock(iVar21,0,lVar12), plStack_90 = plVar10,

+           (plVar10 = (longlong *)CmpAllocatePostBlock(iVar21,0,lVar12), local_90 = plVar10,

            plVar10 == (longlong *)0x0)) {

           ObfDereferenceObject(lVar12);

           CmpFreePostBlock(plVar9);

           goto LAB_5;

         }

         if (iVar21 != 1) {

           if (param_4 == 0) {

 LAB_6:

-            if (iStack_98 == 2) {

+            if (local_98 == 2) {

               *(uint **)(plVar9[8] + 0x68) = param_7;

               *(longlong **)(plVar9[8] + 8) = plVar19;

-              pcStack_c0 = FsRtlInitializeOplock;

+              local_c0 = FsRtlInitializeOplock;

               if (param_5 != (code *)0x0) {

-                pcStack_c0 = param_5;

+                local_c0 = param_5;

               }

-              uStack_b0 = param_6;

-              plStack_b8 = (longlong *)

-                           CONCAT71(plStack_b8._1_7_,-(param_5 != (code *)0x0) & bStack_a7);

-              pplStack_c8 = (longlong **)CmpPostApcRunDown;

+              local_b0 = param_6;

+              local_b8 = (longlong *)CONCAT71(local_b8._1_7_,-(param_5 != (code *)0x0) & local_a7);

+              local_c8 = (longlong **)CmpPostApcRunDown;

               KeInitializeApc(plVar9[8] + 0x10,SystemReserved1[0xf],2,CmpPostApc);

-              lVar12 = lStack_88;

+              lVar12 = local_88;

             }

             else {

               *(longlong **)plVar9[8] = plVar19;

-              if (iStack_98 != 4) {

+              if (local_98 != 4) {

                 *(code **)(plVar9[8] + 8) = param_5;

                 *(int *)(plVar9[8] + 0x10) = (int)param_6;

               }

             }

             goto LAB_7;

           }

-          plStack_58 = (longlong *)0x0;

-          pcStack_c0 = (code *)0x0;

-          pplStack_c8 = &plStack_58;

+          local_58 = (longlong *)0x0;

+          local_c0 = (code *)0x0;

+          local_c8 = &local_58;

           uVar8 = ObReferenceObjectByHandle(param_4,2,ExEventObjectType);

-          plVar19 = plStack_58;

+          plVar19 = local_58;

           plVar18 = (longlong *)(ulonglong)uVar8;

-          plStack_78 = plStack_58;

+          local_78 = local_58;

           if (-1 < (int)uVar8) {

             KeClearEvent();

             goto LAB_6;

           }

           if (param_2 != 1) goto LAB_8;

 LAB_9:

           CmpFreePostBlock(plVar10);

 LAB_8:

           CmpFreePostBlock(plVar9);

-          puVar16 = local_e8;

+          puVar16 = auStack_e8;

           goto LAB_4;

         }

 LAB_7:

         CmpLockRegistry();

         if (param_2 == 1) {

           CmpLockTwoKcbsShared(local_a0[1],*(undefined8 *)(lVar12 + 8));

         }

         else {

           CmpLockKcbShared(local_a0[1]);

         }

         cVar7 = CmpIsKeyDeletedForKeyBody(local_a0,0);

         if ((cVar7 != '\0') ||

            ((param_2 == 1 && (cVar7 = CmpIsKeyDeletedForKeyBody(lVar12,0), cVar7 != '\0')))) {

           if (param_2 == 1) {

             CmpUnlockTwoKcbs(local_a0[1],*(undefined8 *)(lVar12 + 8));

           }

           else {

             CmpUnlockKcb(local_a0[1]);

           }

           CmpUnlockRegistry();

           if (plVar19 != (longlong *)0x0) {

             ObfDereferenceObject(plVar19);

           }

           if (param_2 == 1) {

             CmpFreePostBlock(plVar10);

           }

           CmpFreePostBlock(plVar9);

           plVar18 = (longlong *)0xc000017c;

-          puVar16 = local_e8;

+          puVar16 = auStack_e8;

           goto LAB_4;

         }

         iVar21 = 1;

         if (param_2 == 1) {

           local_48 = local_a0;

           uVar2 = *(ulonglong *)(local_a0[1] + 0x20);

           uVar3 = *(ulonglong *)(*(longlong *)(lVar12 + 8) + 0x20);

           if (uVar2 == uVar3) goto LAB_10;

           if (uVar2 < uVar3) {

             puVar20 = (ulonglong *)(uVar2 + 0x690);

             lVar11 = KeAbPreAcquire(puVar20,0,0);

             LOCK();

             uVar2 = *puVar20;

             *puVar20 = *puVar20 | 1;

             UNLOCK();

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

               ExfAcquirePushLockExclusiveEx(puVar20,lVar11,puVar20);

             }

             if (lVar11 != 0) {

               *(undefined1 *)(lVar11 + 0x12) = 1;

             }

             puVar20 = (ulonglong *)(*(longlong *)(*(longlong *)(lVar12 + 8) + 0x20) + 0x690);

             lVar11 = KeAbPreAcquire(puVar20,0,0);

             LOCK();

             uVar2 = *puVar20;

             *puVar20 = *puVar20 | 1;

             UNLOCK();

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

               ExfAcquirePushLockExclusiveEx(puVar20,lVar11,puVar20);

             }

             if (lVar11 != 0) {

               *(undefined1 *)(lVar11 + 0x12) = 1;

             }

             iVar21 = 2;

           }

           else {

             puVar20 = (ulonglong *)(uVar3 + 0x690);

             lVar11 = KeAbPreAcquire(puVar20,0,0);

             LOCK();

             uVar2 = *puVar20;

             *puVar20 = *puVar20 | 1;

             UNLOCK();

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

               ExfAcquirePushLockExclusiveEx(puVar20,lVar11,puVar20);

             }

             if (lVar11 != 0) {

               *(undefined1 *)(lVar11 + 0x12) = 1;

             }

             puVar20 = (ulonglong *)(*(longlong *)(local_48[1] + 0x20) + 0x690);

             lVar11 = KeAbPreAcquire(puVar20,0,0);

             LOCK();

             uVar2 = *puVar20;

             *puVar20 = *puVar20 | 1;

             UNLOCK();

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

               ExfAcquirePushLockExclusiveEx(puVar20,lVar11,puVar20);

             }

             if (lVar11 != 0) {

               *(undefined1 *)(lVar11 + 0x12) = 1;

             }

             iVar21 = 3;

           }

-          lStack_80 = *(longlong *)(*(longlong *)(lVar12 + 8) + 0x20);

+          local_80 = *(longlong *)(*(longlong *)(lVar12 + 8) + 0x20);

         }

         else {

 LAB_10:

           puVar20 = (ulonglong *)(*(longlong *)(local_a0[1] + 0x20) + 0x690);

           lVar12 = KeAbPreAcquire(puVar20,0,0);

           LOCK();

           uVar2 = *puVar20;

           *puVar20 = *puVar20 | 1;

           UNLOCK();

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

             ExfAcquirePushLockExclusiveEx(puVar20,lVar12,puVar20);

           }

           if (lVar12 != 0) {

             *(undefined1 *)(lVar12 + 0x12) = 1;

           }

         }

         ExAcquireFastMutexUnsafe(&CmpPostLock);

         plVar19 = local_a0;

-        plStack_b8 = plVar9;

+        local_b8 = plVar9;

         uVar8 = CmpNotifyChangeKey(local_a0,plVar9,param_8,param_9);

-        cVar7 = cStack_a5;

+        cVar7 = local_a5;

         plVar18 = (longlong *)(ulonglong)uVar8;

         if ((int)uVar8 < 0) {

           ExReleaseFastMutexUnsafe(&CmpPostLock);

-          lVar12 = lStack_80;

+          lVar12 = local_80;

           if (iVar21 == 1) {

             lVar12 = *(longlong *)(plVar19[1] + 0x20);

 LAB_11:

             LOCK();

             plVar19 = (longlong *)(lVar12 + 0x690);

             lVar11 = *plVar19;

             *plVar19 = *plVar19 + -1;

             UNLOCK();

             if (((byte)lVar11 & 6) == 2) {

               ExfTryToWakePushLock(lVar12 + 0x690);

             }

             KeAbPostRelease(lVar12 + 0x690);

           }

           else {

             if (iVar21 == 2) {

               LOCK();

-              plVar19 = (longlong *)(lStack_80 + 0x690);

+              plVar19 = (longlong *)(local_80 + 0x690);

               lVar11 = *plVar19;

               *plVar19 = *plVar19 + -1;

               UNLOCK();

               if (((byte)lVar11 & 6) == 2) {

-                ExfTryToWakePushLock(lStack_80 + 0x690);

+                ExfTryToWakePushLock(local_80 + 0x690);

               }

               KeAbPostRelease(lVar12 + 0x690);

               lVar12 = *(longlong *)(local_a0[1] + 0x20);

               goto LAB_11;

             }

             if (iVar21 == 3) {

               lVar11 = *(longlong *)(local_a0[1] + 0x20);

               LOCK();

               plVar19 = (longlong *)(lVar11 + 0x690);

               lVar12 = *plVar19;

               *plVar19 = *plVar19 + -1;

               UNLOCK();

               if (((byte)lVar12 & 6) == 2) {

                 ExfTryToWakePushLock(lVar11 + 0x690);

               }

               KeAbPostRelease(lVar11 + 0x690);

-              lVar12 = lStack_80;

+              lVar12 = local_80;

               goto LAB_11;

             }

           }

           if (param_2 == 1) {

-            CmpUnlockTwoKcbs(local_a0[1],*(undefined8 *)(lStack_88 + 8));

+            CmpUnlockTwoKcbs(local_a0[1],*(undefined8 *)(local_88 + 8));

           }

           else {

             CmpUnlockKcb(local_a0[1]);

           }

           CmpUnlockRegistry();

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

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

             ObfDereferenceObject();

           }

-          plVar9 = plStack_90;

-          puVar16 = local_e8;

+          plVar9 = local_90;

+          puVar16 = auStack_e8;

           if (param_2 != 1) goto LAB_4;

           goto LAB_8;

         }

-        cStack_a6 = cStack_a5;

+        local_a6 = local_a5;

         if (param_2 == 1) {

-          ObfReferenceObject(lStack_88);

+          ObfReferenceObject(local_88);

           if (uVar8 == 0) {

-            CmpFreePostBlock(plStack_90);

-            cStack_a6 = '\0';

+            CmpFreePostBlock(local_90);

+            local_a6 = '\0';

             goto LAB_12;

           }

-          plStack_b8 = plVar9;

-          uVar8 = CmpNotifyChangeKey(lStack_88,plStack_90,param_8,param_9);

+          local_b8 = plVar9;

+          uVar8 = CmpNotifyChangeKey(local_88,local_90,param_8,param_9);

           plVar18 = (longlong *)(ulonglong)uVar8;

-          cStack_a6 = cVar7;

+          local_a6 = cVar7;

           if (-1 < (int)uVar8) goto LAB_12;

           lVar12 = *plVar9;

           plVar19 = (longlong *)plVar9[1];

           if ((*(longlong **)(lVar12 + 8) == plVar9) && ((longlong *)*plVar19 == plVar9)) {

             *plVar19 = lVar12;

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

             plVar19 = plVar9 + 2;

             lVar12 = *plVar19;

             plVar10 = (longlong *)plVar9[3];

             if ((*(longlong **)(lVar12 + 8) == plVar19) && ((longlong *)*plVar10 == plVar19)) {

               *plVar10 = lVar12;

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

               in_CR8 = (longlong *)((ulonglong)in_CR8 & 0xff);

-              cStack_a6 = cStack_a5;

+              local_a6 = local_a5;

               goto LAB_12;

             }

           }

           goto LAB_13;

         }

 LAB_12:

-        cVar7 = cStack_a6;

+        cVar7 = local_a6;

         ExReleaseFastMutexUnsafe(&CmpPostLock);

-        lVar12 = lStack_80;

+        lVar12 = local_80;

         if (iVar21 == 1) {

 LAB_14:

           lVar12 = *(longlong *)(local_a0[1] + 0x20);

 LAB_15:

           LOCK();

           plVar19 = (longlong *)(lVar12 + 0x690);

           lVar11 = *plVar19;

           *plVar19 = *plVar19 + -1;

           UNLOCK();

           if (((byte)lVar11 & 6) == 2) {

             ExfTryToWakePushLock(lVar12 + 0x690);

           }

           KeAbPostRelease(lVar12 + 0x690);

         }

         else {

           if (iVar21 == 2) {

             LOCK();

-            plVar19 = (longlong *)(lStack_80 + 0x690);

+            plVar19 = (longlong *)(local_80 + 0x690);

             lVar11 = *plVar19;

             *plVar19 = *plVar19 + -1;

             UNLOCK();

             if (((byte)lVar11 & 6) == 2) {

-              ExfTryToWakePushLock(lStack_80 + 0x690);

+              ExfTryToWakePushLock(local_80 + 0x690);

             }

             KeAbPostRelease(lVar12 + 0x690);

             goto LAB_14;

           }

           if (iVar21 == 3) {

             lVar11 = *(longlong *)(local_a0[1] + 0x20);

             LOCK();

             plVar19 = (longlong *)(lVar11 + 0x690);

             lVar12 = *plVar19;

             *plVar19 = *plVar19 + -1;

             UNLOCK();

             if (((byte)lVar12 & 6) == 2) {

               ExfTryToWakePushLock(lVar11 + 0x690);

             }

             KeAbPostRelease(lVar11 + 0x690);

-            lVar12 = lStack_80;

+            lVar12 = local_80;

             goto LAB_15;

           }

         }

         if (param_2 == 1) {

-          CmpUnlockTwoKcbs(local_a0[1],*(undefined8 *)(lStack_88 + 8));

+          CmpUnlockTwoKcbs(local_a0[1],*(undefined8 *)(local_88 + 8));

         }

         else {

           CmpUnlockKcb(local_a0[1]);

         }

         CmpUnlockRegistry();

-        if (lStack_88 != 0) {

+        if (local_88 != 0) {

           ObfDereferenceObject();

         }

         if ((int)plVar18 < 0) {

 LAB_16:

           *(undefined8 *)(puVar14 + -8) = 0x1406e4fc9;

           CmpFreePostBlock(plVar9);

           puVar16 = puVar14;

           if (*(longlong *)(puVar14 + 0x70) != 0) {

             *(undefined8 *)(puVar14 + -8) = 0x1406e4fd8;

             ObfDereferenceObject();

           }

           goto LAB_4;

         }

-        puVar16 = local_e8;

-        if (iStack_98 != 1) goto LAB_4;

+        puVar16 = auStack_e8;

+        if (local_98 != 1) goto LAB_4;

         CmpReleaseShutdownRundown();

-        cStack_a8 = '\0';

-        pplStack_c8 = (longlong **)0x0;

-        uVar8 = KeWaitForMutexObject(plVar9[8],0,bStack_a7,1);

+        local_a8 = '\0';

+        local_c8 = (longlong **)0x0;

+        uVar8 = KeWaitForMutexObject(plVar9[8],0,local_a7,1);

         plVar18 = (longlong *)(ulonglong)uVar8;

         if ((uVar8 == 0x101) || (uVar8 == 0xc0)) {

           CmpLockRegistry();

           ExAcquireFastMutexUnsafe(&CmpPostLock);

-          plVar10 = plStack_90;

-          plStack_70 = in_CR8;

+          plVar10 = local_90;

+          local_70 = in_CR8;

           if (cVar7 != '\0') {

-            lVar12 = *plStack_90;

+            lVar12 = *local_90;

             if (lVar12 != 0) {

-              plVar19 = (longlong *)plStack_90[1];

-              if ((*(longlong **)(lVar12 + 8) != plStack_90) || ((longlong *)*plVar19 != plStack_90)

-                 ) goto LAB_13;

+              plVar19 = (longlong *)local_90[1];

+              if ((*(longlong **)(lVar12 + 8) != local_90) || ((longlong *)*plVar19 != local_90))

+              goto LAB_13;

               *plVar19 = lVar12;

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

             }

-            plVar19 = plStack_90 + 2;

+            plVar19 = local_90 + 2;

             lVar12 = *plVar19;

-            plVar4 = (longlong *)plStack_90[3];

+            plVar4 = (longlong *)local_90[3];

             if ((*(longlong **)(lVar12 + 8) != plVar19) || ((longlong *)*plVar4 != plVar19))

             goto LAB_13;

             *plVar4 = lVar12;

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

           }

           lVar12 = *plVar9;

           if (lVar12 != 0) {

             plVar19 = (longlong *)plVar9[1];

             if ((*(longlong **)(lVar12 + 8) != plVar9) || ((longlong *)*plVar19 != plVar9))

             goto LAB_13;

             *plVar19 = lVar12;

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

           }

           plVar19 = plVar9 + 2;

           lVar12 = *plVar19;

           plVar4 = (longlong *)plVar9[3];

           if ((*(longlong **)(lVar12 + 8) == plVar19) && ((longlong *)*plVar4 == plVar19)) {

             *plVar4 = lVar12;

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

             ExReleaseFastMutexUnsafe(&CmpPostLock);

             CmpUnlockRegistry();

             if (cVar7 != '\0') goto LAB_9;

             goto LAB_8;

           }

 LAB_13:

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

           (*pcVar5)(3);

           puVar14 = auStack_e0;

           goto LAB_16;

         }

         CmpLockRegistry();

         plVar18 = in_CR8;

         ExAcquireFastMutexUnsafe(&CmpPostLock);

-        plVar19 = plStack_90;

+        plVar19 = local_90;

         if (cVar7 != '\0') {

-          lVar12 = *plStack_90;

+          lVar12 = *local_90;

           if (lVar12 != 0) {

-            plVar10 = (longlong *)plStack_90[1];

-            if ((*(longlong **)(lVar12 + 8) != plStack_90) || ((longlong *)*plVar10 != plStack_90))

+            plVar10 = (longlong *)local_90[1];

+            if ((*(longlong **)(lVar12 + 8) != local_90) || ((longlong *)*plVar10 != local_90))

             goto LAB_13;

             *plVar10 = lVar12;

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

           }

-          plVar10 = plStack_90 + 2;

+          plVar10 = local_90 + 2;

           lVar12 = *plVar10;

-          plVar4 = (longlong *)plStack_90[3];

+          plVar4 = (longlong *)local_90[3];

           if ((*(longlong **)(lVar12 + 8) != plVar10) || ((longlong *)*plVar4 != plVar10))

           goto LAB_13;

           *plVar4 = lVar12;

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

         }

         lVar12 = *plVar9;

         if (lVar12 != 0) {

           plVar10 = (longlong *)plVar9[1];

           if ((*(longlong **)(lVar12 + 8) != plVar9) || ((longlong *)*plVar10 != plVar9))

           goto LAB_13;

           *plVar10 = lVar12;

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

         }

         plVar10 = plVar9 + 2;

         lVar12 = *plVar10;

         plVar4 = (longlong *)plVar9[3];

         if ((*(longlong **)(lVar12 + 8) != plVar10) || ((longlong *)*plVar4 != plVar10))

         goto LAB_13;

         *plVar4 = lVar12;

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

         ExReleaseFastMutexUnsafe(&CmpPostLock);

         CmpUnlockRegistry();

-        cVar13 = cStack_a8;

+        cVar13 = local_a8;

         plVar18 = (longlong *)(ulonglong)*(uint *)(plVar9[8] + 0x18);

         *param_7 = *(uint *)(plVar9[8] + 0x18);

-        if (bStack_a4 == 0) {

+        if (local_a4 == 0) {

           param_7[2] = 0;

           param_7[3] = 0;

         }

         else {

           param_7[1] = 0;

         }

         if (cVar7 != '\0') {

           CmpFreePostBlock(plVar19);

         }

         CmpFreePostBlock(plVar9);

       }

       *(undefined8 *)(puVar15 + -8) = 0x1406e5038;

       ObfDereferenceObject(*(undefined8 *)(puVar15 + 0x48));

       puVar16 = puVar15;

       if (cVar13 == '\0') goto LAB_0;

     }

   }

   else {

     plVar18 = (longlong *)0xc000000d;

-    puVar16 = local_e8;

+    puVar16 = auStack_e8;

   }

   *(undefined8 *)(puVar16 + -8) = 0x1406e5041;

   CmpReleaseShutdownRundown();

 LAB_0:

   *(undefined8 *)(puVar16 + -8) = 0x1406e504e;

   CmCleanupThreadInfo(puVar16 + 0x80);

   return (ulonglong)plVar18 & 0xffffffff;

 }
```

## `EtwUnregister`  (modified)

```diff
--- EtwUnregister
+++ EtwUnregister
@@ -1,33 +1,112 @@
 

-void EtwUnregister(undefined8 param_1,undefined8 param_2,ulonglong *param_3,longlong param_4)

+ulonglong EtwUnregister(longlong *param_1,undefined8 param_2,ulonglong param_3,longlong param_4)

 

 {

-  ulonglong uVar1;

-  ulonglong uVar2;

-  uint unaff_EBX;

-  ulonglong unaff_RDI;

+  ulonglong *puVar1;

+  longlong *plVar2;

+  ulonglong *puVar3;

+  code *pcVar4;

+  longlong lVar5;

+  char cVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  longlong lVar9;

+  uint uVar10;

+  uint uVar11;

+  ulonglong uVar12;

+  uint uVar13;

+  undefined4 extraout_XMM0_Da;

   

-  do {

-    uVar1 = 1000 / ((ulonglong)unaff_EBX / 6);

-    uVar2 = 1000 % ((ulonglong)unaff_EBX / 6);

-    if ((uint)uVar1 < 2) {

-      uVar1 = 1;

+                    /* 0x7b8d50  182  EtwUnregister */

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

+    return 0xc0000008;

+  }

+  if ((*(byte *)((longlong)param_1 + 0x62) & 1) != 0) {

+    if (param_1[5] != 0) {

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

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

+      ExAcquirePushLockExclusiveEx(param_1[5] + 0x198);

+      *(void **)(param_1[5] + 0x1a0) = SystemReserved1[0xf];

     }

-    while( true ) {

-      while( true ) {

-        *(short *)(param_4 + 0x92c) = (short)uVar1;

-        param_3 = (ulonglong *)PsGetNextPartition(param_3,uVar2);

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

-          return;

+    uVar12 = 0;

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

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

+    ExAcquirePushLockExclusiveEx(param_1[4] + 0x198);

+    *(void **)(param_1[4] + 0x1a0) = SystemReserved1[0xf];

+    lVar9 = *param_1;

+    if ((*(longlong **)(lVar9 + 8) == param_1) &&

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

+      *plVar2 = lVar9;

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

+      puVar1 = (ulonglong *)(param_1 + 2);

+      uVar12 = *puVar1;

+      if ((*(ulonglong **)(uVar12 + 8) == puVar1) &&

+         (puVar3 = (ulonglong *)param_1[3], (ulonglong *)*puVar3 == puVar1)) {

+        *puVar3 = uVar12;

+        *(ulonglong **)(uVar12 + 8) = puVar3;

+        *(undefined8 *)(param_1[4] + 0x1a0) = 0;

+        ExReleasePushLockEx(param_1[4] + 0x198,0);

+        KeLeaveCriticalRegion();

+        if (param_1[5] != 0) {

+          *(undefined8 *)(param_1[5] + 0x1a0) = 0;

+          ExReleasePushLockEx(param_1[5] + 0x198,0);

+          KeLeaveCriticalRegion();

         }

-        uVar2 = *param_3;

-        param_4 = *(longlong *)(uVar2 + 0x4218);

-        if (unaff_EBX != 0) break;

-        uVar1 = unaff_RDI & 0xffff;

+        cVar6 = EtwEventEnabled(EtwpEventTracingProvRegHandle,&ETW_EVENT_PROVIDER_UNREGISTERS);

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

+          EtwpEventWriteTemplateSessAndProv(extraout_XMM0_Da,&ETW_EVENT_PROVIDER_UNREGISTERS);

+        }

+        EtwpUnreferenceGuidEntry(param_1[4]);

+        if (param_1[5] != 0) {

+          EtwpUnreferenceGuidEntry();

+        }

+        EtwpReleaseProviderTraitsReference(param_1);

+        ExFreePoolWithTag(param_1,0);

+        return 0;

       }

-      if (0xb < unaff_EBX) break;

-      uVar1 = 1000;

     }

-  } while( true );

+    lVar9 = 3;

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

+    (*pcVar4)();

+    do {

+      *(undefined4 *)(lVar9 + 0x90) = 0;

+      uVar13 = 0;

+      do {

+        uVar10 = *(uint *)(lVar9 + 0xd0);

+        uVar11 = (uint)uVar12;

+        if (uVar11 == uVar10) {

+          *(undefined4 *)(lVar9 + 0xd0) = 0xffffffff;

+          uVar10 = 0xffffffff;

+        }

+        uVar7 = (int)param_3 - 1;

+        param_3 = (ulonglong)uVar7;

+        if (uVar7 == uVar10) {

+          *(uint *)(lVar9 + 0xd0) = uVar11;

+        }

+        if (uVar7 == uVar13) {

+          *(uint *)(lVar9 + 0x90) = uVar11;

+        }

+        uVar8 = param_3 * 2;

+        lVar5 = (param_1 + param_3 * 2)[1];

+        param_1[param_4] = param_1[param_3 * 2];

+        (param_1 + param_4)[1] = lVar5;

+        while( true ) {

+          uVar10 = (uint)uVar12;

+          if (uVar7 <= uVar10) {

+            *(uint *)(lVar9 + 0x7c) = uVar7;

+            return uVar8;

+          }

+          param_1 = *(longlong **)(lVar9 + 0x98);

+          param_4 = (uVar12 & 0xffffffff) * 2;

+          uVar8 = (ulonglong)*(uint *)(param_1 + (uVar12 & 0xffffffff) * 2 + 1);

+          if ((*(uint *)(param_1 + (uVar12 & 0xffffffff) * 2 + 1) & 0x34) == 0) break;

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

+        }

+        uVar13 = *(uint *)(lVar9 + 0x90);

+      } while (uVar10 != uVar13);

+    } while( true );

+  }

+                    /* WARNING: Subroutine does not return */

+  KeBugCheckEx(0x11d,4,param_1,1,0);

 }
```

## `CmpTransSearchAddLightWeightTrans`  (modified)

```diff
--- CmpTransSearchAddLightWeightTrans
+++ CmpTransSearchAddLightWeightTrans
@@ -1,14 +1,89 @@
 

-undefined8 CmpTransSearchAddLightWeightTrans(void)

+int CmpTransSearchAddLightWeightTrans

+              (ulonglong param_1,undefined8 param_2,int param_3,longlong *param_4)

 

 {

-  undefined4 in_EAX;

-  undefined8 uVar1;

+  longlong *plVar1;

+  code *pcVar2;

+  int iVar3;

+  undefined8 *puVar4;

+  longlong lVar5;

+  bool bVar6;

   

-  uVar1 = func_0x000140749414(in_EAX);

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

-    uVar1 = 0;

+  bVar6 = false;

+  iVar3 = CmpTransReferenceTransaction();

+  if (iVar3 < 0) {

+    return iVar3;

   }

-  return uVar1;

+  lVar5 = *(longlong *)((param_1 & 0xfffffffffffffffe) + 0x10);

+  if (lVar5 == 0) {

+    if (param_3 == 0) {

+      iVar3 = -0x3fe6fffe;

+      bVar6 = false;

+    }

+    else {

+      puVar4 = (undefined8 *)CmpTransAllocateTrans(param_1,0,0,param_2);

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

+        iVar3 = -0x3fffff66;

+      }

+      else {

+        plVar1 = (longlong *)((param_1 & 0xfffffffffffffffe) + 0x10);

+        LOCK();

+        lVar5 = *plVar1;

+        bVar6 = lVar5 == 0;

+        if (bVar6) {

+          *plVar1 = (longlong)puVar4;

+          lVar5 = 0;

+        }

+        UNLOCK();

+        if (bVar6) {

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

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

+          ExAcquireFastMutexUnsafe(&CmpTransactionListLock);

+          if ((*(uint *)(puVar4 + 6) & 7) == 0) {

+            *(undefined4 *)(puVar4 + 6) = 0x80;

+            if ((undefined *)*DAT_0 == &CmpLightTransactionList) {

+              *puVar4 = &CmpLightTransactionList;

+              puVar4[1] = DAT_0;

+              *DAT_0 = puVar4;

+              DAT_0 = puVar4;

+              ExReleaseFastMutexUnsafe(&CmpTransactionListLock);

+              KeLeaveCriticalRegion();

+              *param_4 = (longlong)puVar4;

+              return 0;

+            }

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

+            (*pcVar2)(3);

+            ObfDereferenceObject(param_1);

+            return -0x3fe6fffd;

+          }

+          iVar3 = -0x3fe6fffe;

+          goto LAB_1;

+        }

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

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

+        bVar6 = true;

+        ExAcquireFastMutexUnsafe(&CmpTransactionListLock);

+        iVar3 = CmpBindHiveToTrans(param_2,lVar5);

+        iVar3 = (-(uint)(iVar3 != 0) & 2) + 0xc0190001;

+        ExFreePoolWithTag(puVar4,0x72544d43);

+      }

+    }

+  }

+  else {

+    *param_4 = lVar5;

+    iVar3 = 0;

+    bVar6 = false;

+  }

+  if (param_1 != 0) {

+    CmpTransDereferenceTransaction(param_1);

+  }

+  if (!bVar6) {

+    return iVar3;

+  }

+LAB_1:

+  ExReleaseFastMutexUnsafe(&CmpTransactionListLock);

+  KeLeaveCriticalRegion();

+  return iVar3;

 }
```

## `ExpWnfDeleteNameInstance`  (modified)

```diff
--- ExpWnfDeleteNameInstance
+++ ExpWnfDeleteNameInstance
@@ -1,28 +1,240 @@
 

-int ExpWnfDeleteNameInstance(short *param_1)

+undefined8 * ExpWnfDeleteNameInstance(longlong param_1,undefined8 *param_2,char param_3)

 

 {

-  short sVar1;

-  short *psVar2;

-  int iVar3;

+  ulonglong *puVar1;

+  longlong *plVar2;

+  ulonglong uVar3;

   longlong lVar4;

-  longlong lVar5;

+  longlong *plVar5;

+  code *pcVar6;

+  char cVar7;

+  int iVar8;

+  longlong lVar9;

+  longlong *plVar10;

+  undefined8 *puVar11;

+  longlong lVar12;

+  _exception *_Except;

+  undefined8 *puVar13;

+  ulonglong *puVar14;

+  undefined8 unaff_R15;

   

-  iVar3 = 0;

-  if (param_1 != (short *)0x0) {

-    sVar1 = *param_1;

-    psVar2 = param_1;

-    while (sVar1 != 0) {

-      lVar4 = -1;

-      do {

-        lVar5 = lVar4;

-        lVar4 = lVar5 + 1;

-      } while (psVar2[lVar4] != 0);

-      psVar2 = psVar2 + lVar5 + 2;

-      sVar1 = *psVar2;

-    }

-    iVar3 = (int)((longlong)psVar2 - (longlong)param_1 >> 1) + 1;

-  }

-  return iVar3;

+  puVar14 = (ulonglong *)(param_1 + 0x30);

+  lVar9 = KeAbPreAcquire(puVar14,0,0);

+  LOCK();

+  uVar3 = *puVar14;

+  *puVar14 = *puVar14 | 1;

+  UNLOCK();

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

+    ExfAcquirePushLockExclusiveEx(puVar14,lVar9,puVar14);

+  }

+  if (lVar9 != 0) {

+    *(undefined1 *)(lVar9 + 0x12) = 1;

+  }

+  if (param_2[6] == 0) {

+    LOCK();

+    uVar3 = *puVar14;

+    *puVar14 = *puVar14 - 1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(puVar14);

+    }

+    KeAbPostRelease(puVar14);

+    puVar11 = (undefined8 *)0x0;

+  }

+  else {

+    puVar1 = param_2 + 0xe;

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

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar1,lVar9,puVar1);

+    }

+    if (lVar9 != 0) {

+      *(undefined1 *)(lVar9 + 0x12) = 1;

+    }

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

+      RtlAvlRemoveNode(param_1 + 0x38,param_2 + 2);

+    }

+    param_2[6] = 0;

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    puVar11 = (undefined8 *)CONCAT71((int7)((ulonglong)unaff_R15 >> 8),6);

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

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    LOCK();

+    uVar3 = *puVar14;

+    *puVar14 = *puVar14 - 1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(puVar14);

+    }

+    KeAbPostRelease(puVar14);

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

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar1,lVar9,puVar1);

+    }

+    if (lVar9 != 0) {

+      *(undefined1 *)(lVar9 + 0x12) = 1;

+    }

+    while (plVar10 = (longlong *)param_2[0xf], plVar10 != param_2 + 0xf) {

+      ExAcquireRundownProtection(plVar10 + -7);

+      lVar9 = plVar10[-3];

+      LOCK();

+      uVar3 = *puVar1;

+      *puVar1 = *puVar1 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar1);

+      }

+      KeAbPostRelease(puVar1);

+      puVar14 = (ulonglong *)(*(longlong *)(lVar9 + 0x868) + 0x50);

+      lVar9 = KeAbPreAcquire(puVar14,0,0);

+      LOCK();

+      uVar3 = *puVar14;

+      *puVar14 = *puVar14 | 1;

+      UNLOCK();

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

+        ExfAcquirePushLockExclusiveEx(puVar14);

+      }

+      if (lVar9 != 0) {

+        *(undefined1 *)(lVar9 + 0x12) = 1;

+      }

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

+      LOCK();

+      uVar3 = *puVar1;

+      *puVar1 = *puVar1 | 1;

+      UNLOCK();

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

+        ExfAcquirePushLockExclusiveEx(puVar1);

+      }

+      if (lVar9 != 0) {

+        *(undefined1 *)(lVar9 + 0x12) = 1;

+      }

+      if (plVar10[-2] != 0) {

+        lVar9 = *plVar10;

+        if (((longlong *)*(longlong *)(lVar9 + 8) != plVar10) ||

+           (plVar2 = (longlong *)plVar10[1], (longlong *)*plVar2 != plVar10)) goto LAB_0;

+        *plVar2 = lVar9;

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

+        plVar10[-2] = 0;

+      }

+      LOCK();

+      uVar3 = *puVar14;

+      *puVar14 = *puVar14 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar14);

+      }

+      KeAbPostRelease(puVar14);

+      ExReleaseRundownProtection(plVar10 + -7);

+    }

+    LOCK();

+    uVar3 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    if (param_2[0x13] != 0) {

+      puVar14 = (ulonglong *)(*(longlong *)(param_2[0x13] + 0x868) + 0x38);

+      plVar10 = (longlong *)KeAbPreAcquire(puVar14,0,0);

+      LOCK();

+      uVar3 = *puVar14;

+      *puVar14 = *puVar14 | 1;

+      UNLOCK();

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

+        ExfAcquirePushLockExclusiveEx(puVar14,plVar10,puVar14);

+      }

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

+        *(undefined1 *)((longlong)plVar10 + 0x12) = 1;

+      }

+      plVar2 = param_2 + 0x11;

+      lVar9 = *plVar2;

+      if ((*(longlong **)(lVar9 + 8) != plVar2) ||

+         (plVar5 = (longlong *)param_2[0x12], (longlong *)*plVar5 != plVar2)) {

+LAB_0:

+        _Except = (_exception *)0x3;

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

+        (*pcVar6)();

+        iVar8 = _GetStoragePropertyPost_SC_DEVICE__MEAAJW4_STORAGE_PROPERTY_ID__PEAU_STORAGE_DESCRIPTOR_HEADER___Z

+                          (_Except);

+        lVar9 = PsGetServerSiloGlobals(iVar8);

+        lVar9 = *(longlong *)(lVar9 + 0x390);

+        if (lVar9 == 0) {

+          param_2 = (undefined8 *)0x0;

+        }

+        else {

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

+          lVar12 = KeAbPreAcquire(plVar2,0,0);

+          LOCK();

+          lVar4 = *plVar2;

+          if (lVar4 == 0) {

+            *plVar2 = 0x11;

+          }

+          UNLOCK();

+          if (lVar4 != 0) {

+            ExfAcquirePushLockSharedEx(plVar2,0,lVar12,plVar2);

+          }

+          if (lVar12 != 0) {

+            *(undefined1 *)(lVar12 + 0x12) = 1;

+          }

+          if ((plVar10 == (longlong *)0x0) ||

+             (puVar13 = *(undefined8 **)((longlong)plVar10 + 0x20), puVar13 == (undefined8 *)0x0)) {

+            puVar13 = *(undefined8 **)(lVar9 + 0x10);

+          }

+          for (; puVar13 != (undefined8 *)(lVar9 + 0x10); puVar13 = (undefined8 *)*puVar13) {

+            param_2 = puVar13 + -4;

+            cVar7 = ExAcquireRundownProtection(puVar13 + -3);

+            if (cVar7 != '\0') break;

+            param_2 = puVar11;

+          }

+          LOCK();

+          lVar9 = *plVar2;

+          if (lVar9 == 0x11) {

+            *plVar2 = (longlong)puVar11;

+          }

+          UNLOCK();

+          if (lVar9 != 0x11) {

+            ExfReleasePushLockShared(plVar2);

+          }

+          KeAbPostRelease(plVar2);

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

+            ExReleaseRundownProtection((longlong)plVar10 + 8);

+          }

+        }

+        return param_2;

+      }

+      *plVar5 = lVar9;

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

+      param_2[0x13] = 0;

+      LOCK();

+      uVar3 = *puVar14;

+      *puVar14 = *puVar14 - 1;

+      UNLOCK();

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

+        ExfTryToWakePushLock(puVar14);

+      }

+      KeAbPostRelease(puVar14);

+    }

+    ExReleaseRundownProtection(param_2 + 1);

+    ExWaitForRundownProtectionRelease(param_2 + 1);

+    ExpWnfDeleteStateData(param_2);

+    ObDereferenceSecurityDescriptor(param_2[9],1);

+    ExFreePoolWithTag(param_2,0x20666e57);

+    puVar11 = (undefined8 *)0x1;

+  }

+  return puVar11;

 }
```

## `MmLinkJobProcess`  (modified)

```diff
--- MmLinkJobProcess
+++ MmLinkJobProcess
@@ -1,94 +1,149 @@
 

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

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

-

-ulonglong MmLinkJobProcess(void)

+longlong * MmLinkJobProcess(longlong param_1,longlong param_2)

 

 {

-  int iVar1;

-  uint uVar2;

-  undefined8 *puVar3;

+  longlong *****ppppplVar1;

+  ulonglong *puVar2;

+  short *psVar3;

   ulonglong uVar4;

-  uint uVar5;

-  uint unaff_EBX;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  ulonglong unaff_R12;

-  char unaff_R13B;

-  char unaff_R14B;

-  uint uVar6;

-  char unaff_R15B;

-  bool bVar7;

-  char local_res20;

+  undefined8 uVar5;

+  longlong *plVar6;

+  longlong ****pppplVar7;

+  longlong ****pppplVar8;

+  code *pcVar9;

+  void *pvVar10;

+  longlong ****pppplVar11;

+  int iVar12;

+  undefined8 *puVar13;

+  longlong lVar14;

+  longlong *plVar15;

+  undefined8 *puVar16;

+  longlong *****ppppplVar17;

+  longlong ****local_38;

+  longlong ****local_30;

   

-  do {

-    PsThawMultiProcess();

-    uVar5 = unaff_EBX;

+  pvVar10 = SystemReserved1[0xf];

+  puVar2 = (ulonglong *)(param_2 + 0x930);

+  local_30 = (longlong ****)&local_38;

+  iVar12 = 0;

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

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

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

+  puVar13 = (undefined8 *)KeAbPreAcquire(puVar2,0,0);

+  LOCK();

+  uVar4 = *puVar2;

+  *puVar2 = *puVar2 | 1;

+  UNLOCK();

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

+    ExfAcquirePushLockExclusiveEx(puVar2,puVar13,puVar2);

+  }

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

+    *(undefined1 *)((longlong)puVar13 + 0x12) = 1;

+  }

+  if ((*(uint *)(param_2 + 0x87c) & 0x10) == 0) {

+    puVar13 = (undefined8 *)(param_2 + 0x938);

+    for (puVar16 = (undefined8 *)*puVar13; puVar16 != puVar13; puVar16 = (undefined8 *)*puVar16) {

+      uVar5 = puVar16[2];

+      lVar14 = MiAllocatePool(0x100,0x40,0x6e53694d);

+      if (lVar14 == 0) {

+        iVar12 = -0x3fffff66;

+        break;

+      }

+      *(undefined8 *)(lVar14 + 0x38) = uVar5;

+      *(undefined8 *)(lVar14 + 0x20) = puVar16[-1];

+      ppppplVar1 = (longlong *****)(lVar14 + 0x28);

+      if ((longlong *****)*local_30 != &local_38) goto LAB_0;

+      *(longlong *****)(lVar14 + 0x30) = local_30;

+      *ppppplVar1 = (longlong ****)&local_38;

+      *local_30 = (longlong ***)ppppplVar1;

+      local_30 = (longlong ****)ppppplVar1;

+    }

+    puVar16 = (undefined8 *)*puVar13;

+    while (puVar16 != puVar13) {

+      MiRemoveSharedCommitNode(puVar16[2],param_2,1);

+      puVar16 = (undefined8 *)*puVar13;

+    }

+    if (iVar12 < 0) {

+      while ((longlong *****)local_38 != &local_38) {

+        if (((longlong *****)local_38[1] != &local_38) ||

+           (ppppplVar1 = (longlong *****)*local_38, ppppplVar1[1] != local_38)) goto LAB_0;

+        ppppplVar1[1] = (longlong ****)&local_38;

+        ppppplVar17 = (longlong *****)(local_38 + -5);

+        local_38 = (longlong ****)ppppplVar1;

+        ExFreePoolWithTag(ppppplVar17,0);

+      }

+    }

+    else if ((*(uint *)(param_2 + 0x87c) & 8) == 0) {

+      LOCK();

+      *(uint *)(param_2 + 0x87c) = *(uint *)(param_2 + 0x87c) | 8;

+      UNLOCK();

+    }

+  }

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

+  plVar15 = (longlong *)(param_2 + 0x5c8);

+  if (*plVar6 == param_1 + 0x28) {

+    *plVar15 = param_1 + 0x28;

+    puVar13 = (undefined8 *)0xffffffffffffffff;

+    *(longlong **)(param_2 + 0x5d0) = plVar6;

+    *plVar6 = (longlong)plVar15;

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

+    *(longlong *)(param_2 + 0x510) = param_1;

     while( true ) {

-      do {

-        if ((unaff_R15B != '\0') && (iVar1 = MmOutSwapWorkingSet(), iVar1 < 0)) {

-          uVar4 = FUN_1408e9b43();

-          return uVar4;

+      pppplVar11 = local_38;

+      plVar15 = (longlong *)(param_2 + 0x930);

+      if ((longlong *****)local_38 == &local_38) {

+        if (iVar12 < 0) {

+          while (plVar6 = *(longlong **)(param_2 + 0x938), plVar6 != (longlong *)(param_2 + 0x938))

+          {

+            MiRemoveSharedCommitNode(plVar6[2],param_2,1);

+          }

+          LOCK();

+          *(uint *)(param_2 + 0x87c) = *(uint *)(param_2 + 0x87c) & 0xfffffff7;

+          UNLOCK();

+          LOCK();

+          *(uint *)(param_2 + 0x87c) = *(uint *)(param_2 + 0x87c) | 0x10;

+          UNLOCK();

         }

-        uVar6 = *(uint *)(unaff_RDI + 0x460);

-        while( true ) {

-          uVar2 = uVar6 >> 0x1c;

-          unaff_EBX = uVar2 & 3;

-          if ((unaff_EBX != uVar5) && (unaff_EBX != uVar5)) break;

-          LOCK();

-          uVar2 = *(uint *)(unaff_RDI + 0x460);

-          bVar7 = uVar6 == uVar2;

-          if (bVar7) {

-            *(uint *)(unaff_RDI + 0x460) = (uVar5 << 6 | uVar5) << 0x16 | uVar6 & 0x8f3fffff;

-            uVar2 = uVar6;

-          }

-          UNLOCK();

-          uVar6 = uVar2;

-          if (bVar7) {

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

-              if (unaff_RBP != 0) {

-                MmDetachSession(unaff_RBP,&stack0x00000028);

-                ObfDereferenceObject(unaff_RBP);

-              }

-              KiUnstackDetachProcess(&stack0x00000058,0);

-            }

-            if ((unaff_R14B != '\0') &&

-               (puVar3 = (undefined8 *)ExGetExtensionTable(PspMmcssExtensionHost),

-               puVar3 != (undefined8 *)0x0)) {

-              (*(code *)*puVar3)();

-              ExReleaseExtensionTable(PspMmcssExtensionHost);

-            }

-            return unaff_R12 & 0xffffffff;

-          }

+        LOCK();

+        lVar14 = *plVar15;

+        *plVar15 = *plVar15 + -1;

+        UNLOCK();

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

+          ExfTryToWakePushLock(plVar15);

         }

-        unaff_R15B = '\0';

-        uVar6 = unaff_EBX ^ uVar5;

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

-          KiStackAttachProcess();

-          iVar1 = PsGetProcessSessionIdEx();

-          if (((iVar1 != -1) && (unaff_RBP = MmGetSessionById(iVar1), unaff_RBP != 0)) &&

-             (iVar1 = MmAttachSession(unaff_RBP), iVar1 < 0)) {

-            ObfDereferenceObject(unaff_RBP);

-            unaff_RBP = 0;

-          }

-          unaff_R13B = '\x01';

+        plVar15 = (longlong *)KeAbPostRelease(plVar15);

+        psVar3 = (short *)((longlong)pvVar10 + 0x1e6);

+        *psVar3 = *psVar3 + 1;

+        if ((*psVar3 == 0) &&

+           (plVar15 = (longlong *)((longlong)pvVar10 + 0x98), (longlong *)*plVar15 != plVar15)) {

+          plVar15 = (longlong *)KiCheckForKernelApcDelivery();

         }

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

-          if ((uVar2 & 2) == 0) {

-            MmInSwapWorkingSet();

-          }

-          else {

-            unaff_R15B = '\x01';

-          }

+        return plVar15;

+      }

+      if (((longlong *****)local_38[1] != &local_38) ||

+         (ppppplVar1 = (longlong *****)*local_38, ppppplVar1[1] != local_38)) break;

+      ppppplVar1[1] = (longlong ****)&local_38;

+      ppppplVar17 = (longlong *****)(local_38 + -5);

+      if (-1 < iVar12) {

+        pppplVar7 = (longlong ****)local_38[-1];

+        pppplVar8 = (longlong ****)local_38[2];

+        local_38 = (longlong ****)ppppplVar1;

+        while ((ppppplVar1 = (longlong *****)local_38, pppplVar7 != (longlong ****)0x0 &&

+               (iVar12 = MiInsertSharedCommitNode(pppplVar8,param_2,1),

+               ppppplVar1 = (longlong *****)local_38, -1 < iVar12))) {

+          ppppplVar1 = (longlong *****)(pppplVar11 + -1);

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

+          pppplVar7 = *ppppplVar1;

         }

-        uVar5 = unaff_EBX;

-        unaff_R14B = local_res20;

-      } while ((uVar6 & 1) == 0);

-      unaff_R14B = '\x01';

-      local_res20 = '\x01';

-      if ((uVar2 & 1) == 0) break;

-      PsFreezeProcess();

+      }

+      local_38 = (longlong ****)ppppplVar1;

+      ExFreePoolWithTag(ppppplVar17,0);

     }

-  } while( true );

+  }

+LAB_0:

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

+  (*pcVar9)(3);

+  puVar16 = (undefined8 *)PsGetProcessServerSilo(param_2);

+  return (longlong *)(ulonglong)(puVar13 == puVar16);

 }
```

## `PnpOrphanNotification`  (modified)

```diff
--- PnpOrphanNotification
+++ PnpOrphanNotification
@@ -1,20 +1,69 @@
 

-int PnpOrphanNotification(void)

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

+

+void PnpOrphanNotification(longlong param_1)

 

 {

-  int iVar1;

-  undefined8 *unaff_RBP;

+  longlong *plVar1;

+  longlong *plVar2;

+  undefined8 uVar3;

+  code *pcVar4;

+  int iVar5;

+  longlong lVar6;

+  undefined2 uVar7;

+  longlong unaff_RBP;

   

-  *unaff_RBP = 0x1407e86aa;

-  iVar1 = AlpcpProcessSynchronousRequest();

-  if (iVar1 == -0x3ffff8fd) {

-    iVar1 = -0x3fffffc9;

+  ExAcquireFastMutex(&PnpTargetDeviceNotifyLock);

+  plVar1 = (longlong *)(param_1 + 0x1d8);

+  while( true ) {

+    plVar2 = (longlong *)*plVar1;

+    if (plVar2 == plVar1) {

+      ExReleaseFastMutex(&PnpTargetDeviceNotifyLock);

+      return;

+    }

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

+       (lVar6 = *plVar2, (longlong *)*(longlong *)(lVar6 + 8) != plVar2)) break;

+    *plVar1 = lVar6;

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

+    plVar2[1] = (longlong)plVar2;

+    *plVar2 = (longlong)plVar2;

+    if ((plVar2[0xb] != 0) &&

+       ((*(char *)((longlong)plVar2 + 0x3a) == '\0' || ((*(uint *)(param_1 + 0x2c0) & 0x4000) == 0))

+       )) {

+      ObfDereferenceObject();

+      plVar2[0xb] = 0;

+    }

   }

-  else if (iVar1 == -0x3ffff8ff) {

-    iVar1 = -0x3ffffdad;

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

+  (*pcVar4)(3);

+  uVar7 = SUB82(plVar2,0);

+  *(undefined2 *)(unaff_RBP + -0x41) = uVar7;

+  *(longlong *)(unaff_RBP + -0x39) = unaff_RBP + 0xf;

+  iVar5 = IopGetRegistryValue(plVar1,unaff_RBP + 0xf,0,unaff_RBP + -0x29);

+  if (iVar5 < 0) {

+    lVar6 = *(longlong *)(unaff_RBP + -0x29);

   }

-  *unaff_RBP = 0x1407e86c6;

-  KeLeaveCriticalRegion();

-  return iVar1;

+  else {

+    ZwDeleteValueKey(plVar1,unaff_RBP + -0x41);

+    *(longlong *)(unaff_RBP + -0x49) = unaff_RBP + 0xf;

+    RtlStringCchPrintfExW(unaff_RBP + 0xf,10,unaff_RBP + -0x49);

+    *(undefined2 *)(unaff_RBP + -0x3f) = uVar7;

+    lVar6 = *(longlong *)(unaff_RBP + -0x49) - (unaff_RBP + 0xf) >> 1;

+    if ((int)lVar6 == -1) {

+      *(undefined2 *)(unaff_RBP + -0x41) = uVar7;

+    }

+    else {

+      *(short *)(unaff_RBP + -0x41) = (short)lVar6 * 2;

+    }

+    uVar3 = *(undefined8 *)(unaff_RBP + -0x29);

+    *(longlong *)(unaff_RBP + -0x39) = unaff_RBP + 0xf;

+    ZwSetValueKey(plVar1,unaff_RBP + -0x41,0,1);

+    ExFreePoolWithTag(uVar3,0);

+    lVar6 = 0;

+  }

+  if (lVar6 != 0) {

+    ExFreePoolWithTag(lVar6,0);

+  }

+  return;

 }
```

## `RtlpFlsSetValueSlot`  (modified)

```diff
--- RtlpFlsSetValueSlot
+++ RtlpFlsSetValueSlot
@@ -1,10 +1,118 @@
 

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

-

-void RtlpFlsSetValueSlot(void)

+long RtlpFlsSetValueSlot(undefined8 param_1,longlong param_2,uint param_3,longlong param_4)

 

 {

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

-  halt_baddata();

+  longlong *plVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  longlong *plVar4;

+  int iVar5;

+  code *pcVar6;

+  long lVar7;

+  longlong *plVar8;

+  longlong *plVar9;

+  undefined4 local_78;

+  undefined4 uStack_74;

+  undefined8 ******ppppppuStack_70;

+  undefined8 ******ppppppuStack_68;

+  undefined4 local_58;

+  undefined4 uStack_54;

+  undefined4 uStack_50;

+  undefined4 uStack_4c;

+  undefined8 local_48;

+  

+  ppppppuStack_68 = &ppppppuStack_70;

+  iVar5 = 0x1f;

+  if (param_3 != 0) {

+    for (; param_3 >> iVar5 == 0; iVar5 = iVar5 + -1) {

+    }

+  }

+  ppppppuStack_70 = &ppppppuStack_70;

+  if (*(longlong *)(&DAT_0 + (ulonglong)(iVar5 - 4) * 8) == 0) {

+    plVar8 = (longlong *)0x0;

+  }

+  else {

+    plVar8 = (longlong *)

+             (*(longlong *)(&DAT_0 + (ulonglong)(iVar5 - 4) * 8) +

+             ((ulonglong)(1 << ((byte)iVar5 & 0x1f) ^ param_3) * 5 + 1) * 8);

+  }

+  iVar5 = 0x1f;

+  if (param_3 != 0) {

+    for (; param_3 >> iVar5 == 0; iVar5 = iVar5 + -1) {

+    }

+  }

+  lVar2 = *(longlong *)(param_2 + (ulonglong)(iVar5 - 4) * 8);

+  if ((lVar2 == 0) ||

+     (plVar9 = (longlong *)(lVar2 + ((ulonglong)(1 << ((byte)iVar5 & 0x1f) ^ param_3) * 3 + 1) * 8),

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

+    ppppppuStack_70 = (undefined8 *******)0x0;

+    ppppppuStack_68 = (undefined8 *******)0x0;

+    local_78 = (undefined4)param_4;

+    uStack_74 = (undefined4)((ulonglong)param_4 >> 0x20);

+    local_58 = local_78;

+    uStack_54 = uStack_74;

+    uStack_50 = 0;

+    uStack_4c = 0;

+    local_48 = 0;

+    lVar7 = RTL_BINARY_ARRAY<RTLP_FLS_SLOT,4,4>::SetValue(param_2,param_3,&local_58);

+    if (lVar7 < 0) {

+      return lVar7;

+    }

+    iVar5 = 0x1f;

+    if (param_3 != 0) {

+      for (; param_3 >> iVar5 == 0; iVar5 = iVar5 + -1) {

+      }

+    }

+    lVar2 = *(longlong *)(param_2 + (ulonglong)(iVar5 - 4) * 8);

+    if (lVar2 == 0) {

+      plVar9 = (longlong *)0x0;

+    }

+    else {

+      plVar9 = (longlong *)(lVar2 + ((ulonglong)(1 << ((byte)iVar5 & 0x1f) ^ param_3) * 3 + 1) * 8);

+    }

+    plVar1 = plVar9 + 1;

+    plVar9[2] = (longlong)plVar1;

+    *plVar1 = (longlong)plVar1;

+  }

+  plVar1 = plVar9 + 1;

+  if ((longlong *)*plVar1 == plVar1) {

+    if (param_4 == 0) goto LAB_1;

+    ExAcquirePushLockExclusiveEx(plVar8,0);

+    puVar3 = (undefined8 *)plVar8[4];

+    if ((longlong *)*puVar3 != plVar8 + 3) {

+LAB_2:

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

+      (*pcVar6)(3);

+      return -0x3ffffebf;

+    }

+    *plVar1 = (longlong)(plVar8 + 3);

+    plVar9[2] = (longlong)puVar3;

+    *puVar3 = plVar1;

+    plVar8[4] = (longlong)plVar1;

+  }

+  else {

+    if (param_4 != 0) goto LAB_1;

+    ExAcquirePushLockExclusiveEx(plVar8,0);

+    *plVar9 = 0;

+    lVar2 = *plVar1;

+    if ((*(longlong **)(lVar2 + 8) != plVar1) ||

+       (plVar4 = (longlong *)plVar9[2], (longlong *)*plVar4 != plVar1)) goto LAB_2;

+    *plVar4 = lVar2;

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

+    plVar9[2] = (longlong)plVar1;

+    *plVar1 = (longlong)plVar1;

+  }

+  LOCK();

+  lVar2 = *plVar8;

+  *plVar8 = *plVar8 + -1;

+  UNLOCK();

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

+    ExfTryToWakePushLock(plVar8);

+  }

+  KeAbPostRelease(plVar8);

+LAB_1:

+  *plVar9 = param_4;

+  *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) | 1;

+  return 0;

 }
```

## `HalpBuildScatterGatherList`  (modified)

```diff
--- HalpBuildScatterGatherList
+++ HalpBuildScatterGatherList
@@ -1,12 +1,110 @@
 

-undefined4 HalpBuildScatterGatherList(void)

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

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

+

+ulonglong HalpBuildScatterGatherList

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

+                    ulonglong param_5,uint param_6,undefined4 param_7,longlong param_8,

+                    undefined8 param_9,char param_10,longlong param_11,undefined4 param_12,

+                    undefined8 param_13,undefined8 param_14,undefined8 *param_15)

 

 {

-  longlong unaff_RBP;

-  undefined4 unaff_EDI;

+  uint uVar1;

+  ulonglong uVar2;

+  longlong lVar3;

+  uint *puVar4;

+  uint *puVar5;

   

-  *(undefined1 *)(unaff_RBP + 0x33) = 0;

-  HalpAllocateAdapterCallbackV3();

-  return unaff_EDI;

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

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

+      *param_15 = 0;

+    }

+    do {

+      puVar5 = (uint *)(param_4 + 5);

+      if (param_5 < *puVar5) {

+        uVar2 = HalGetDmaTransferInfoInternal(0,param_4,param_5,param_6);

+        if ((int)uVar2 < 0) {

+          return uVar2;

+        }

+        if (param_11 == 0) {

+          lVar3 = ExAllocatePool2(0x42,0,0x446c6148);

+          if (lVar3 == 0) {

+            return 0xc000009a;

+          }

+          puVar5 = (uint *)(lVar3 + 0x28);

+          *puVar5 = 0;

+          *(longlong *)(lVar3 + 200) = lVar3;

+          *(undefined4 *)(lVar3 + 0xc4) = 0;

+        }

+        else {

+          puVar5 = (uint *)(param_11 + 0x28);

+          *puVar5 = *puVar5 | 1;

+          *(longlong *)(param_11 + 200) = param_11;

+          *(undefined4 *)(param_11 + 0xc4) = param_12;

+        }

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

+          *param_15 = *(undefined8 *)(puVar5 + 0x28);

+        }

+        puVar5[0x27] = puVar5[0x27] - 0xa8;

+        *(longlong **)(puVar5 + 2) = param_4;

+        puVar5[4] = 0;

+        puVar5[5] = 0;

+        uVar1 = *(uint *)((longlong)param_4 + 0x2c);

+        lVar3 = param_4[4];

+        *(longlong *)(puVar5 + 0x1e) = param_8;

+        *(ulonglong *)(puVar5 + 8) = (ulonglong)uVar1 + lVar3 + param_5;

+        puVar5[10] = param_6;

+        *(undefined8 *)(puVar5 + 0x20) = param_9;

+        *(longlong *)(puVar5 + 0x24) = param_1;

+        *(char *)(puVar5 + 0x26) = param_10;

+        puVar5[0xb] = 0;

+        puVar5[6] = 0;

+        puVar5[7] = 0;

+        if (param_3 == 0) {

+          puVar4 = puVar5 + 0xc;

+          puVar5[0x11] = puVar5[0x11] & 0xfffffffd;

+        }

+        else {

+          puVar4 = (uint *)(param_3 + 0x10);

+          *(uint **)(param_3 + 0x58) = puVar5;

+          *(uint *)(param_3 + 0x24) = *(uint *)(param_3 + 0x24) | 2;

+        }

+        *(uint **)(puVar4 + 8) = puVar5;

+        *(longlong *)(puVar4 + 0xc) = param_2;

+        *(undefined8 *)(puVar4 + 0xe) = *(undefined8 *)(param_2 + 0x20);

+        if (((*(char *)(param_1 + 0x1b8) == '\0') && (*(int *)(param_1 + 0x208) != 3)) &&

+           ((*(char *)(param_1 + 0x1bd) != '\0' || (param_10 != '\0')))) {

+          HalpAllocateAdapterCallbackV3(param_2,*(undefined8 *)(param_2 + 0x20),0,puVar5);

+          return 0;

+        }

+        puVar5[0xb] = 1;

+        if (param_8 == 0) {

+          uVar1 = HalpAllocateAdapterChannel(param_1,puVar4,1,0,param_7,0);

+          if (uVar1 == 0) {

+            HalpAllocateAdapterCallbackV3

+                      (param_2,*(undefined8 *)(param_2 + 0x20),*(undefined8 *)(param_1 + 0xf0),

+                       puVar5);

+            return 0;

+          }

+        }

+        else {

+          uVar1 = HalpAllocateAdapterChannel

+                            (param_1,puVar4,1,0,param_7,HalpAllocateAdapterCallbackV3);

+        }

+        uVar2 = (ulonglong)uVar1;

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

+          return uVar2;

+        }

+        if (param_11 != 0) {

+          return uVar2;

+        }

+        ExFreePoolWithTag(*(undefined8 *)(puVar5 + 0x28),0);

+        return uVar2;

+      }

+      param_4 = (longlong *)*param_4;

+      param_5 = param_5 - *puVar5;

+    } while (param_4 != (longlong *)0x0);

+  }

+  return 0xc000000d;

 }
```

## `PfSnOpenVolumesForPrefetch`  (modified)

```diff
--- PfSnOpenVolumesForPrefetch
+++ PfSnOpenVolumesForPrefetch
@@ -1,27 +1,345 @@
 

-undefined4 PfSnOpenVolumesForPrefetch(undefined8 param_1,byte param_2)

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

+

+ulonglong PfSnOpenVolumesForPrefetch(longlong *param_1,undefined4 *param_2)

 

 {

-  int in_EAX;

-  uint unaff_EBX;

-  byte *unaff_RSI;

-  void *unaff_RDI;

-  uint *unaff_R12;

-  undefined4 unaff_R14D;

-  char unaff_R15B;

+  short sVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  code *pcVar4;

+  short ****ppppsVar5;

+  char cVar6;

+  int iVar7;

+  longlong lVar8;

+  short *****pppppsVar9;

+  short *psVar10;

+  ulonglong uVar11;

+  short *psVar12;

+  uint *puVar13;

+  short *****pppppsVar14;

+  undefined4 uVar15;

+  uint uVar16;

+  short *****pppppsVar17;

+  void *_Dst;

+  longlong *plVar18;

+  short *****pppppsVar19;

+  longlong lVar20;

+  undefined4 extraout_XMM0_Da;

+  undefined4 extraout_XMM0_Da_00;

+  undefined4 extraout_XMM0_Da_01;

+  undefined4 extraout_XMM0_Da_02;

+  undefined4 uVar21;

+  uint local_res8 [2];

+  undefined4 *local_res10;

+  undefined8 local_res18;

+  ulonglong local_res20;

+  ulonglong in_stack_fffffffffffffee8;

+  short *****pppppsVar22;

+  undefined8 uVar23;

+  short ****local_f8;

+  short ****local_f0;

+  undefined4 local_e8 [2];

+  short ****ppppsStack_e0;

+  short ***local_d8;

+  longlong lStack_d0;

+  undefined8 local_c8;

+  short *psStack_c0;

+  longlong local_b8;

+  longlong lStack_b0;

+  undefined8 uStack_a8;

+  undefined8 local_a0;

+  short ***local_98;

+  short ***pppsStack_90;

+  short ***pppsStack_88;

+  short ***pppsStack_80;

+  undefined4 local_78;

+  undefined4 local_74;

+  undefined8 local_70;

+  undefined8 local_68;

+  undefined4 local_60;

+  undefined4 local_5c;

+  undefined8 local_58;

+  undefined8 uStack_50;

   

-  *unaff_RSI = *unaff_RSI | param_2;

-  if ((*unaff_RSI == 0) || (in_EAX < 0)) {

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

-      ProbeForWrite(*(undefined8 *)(unaff_RSI + 0x10),*(undefined4 *)(unaff_RSI + 0x18),8);

-    }

-    unaff_EBX = (*(int *)((longlong)unaff_RDI + 8) + 8) * 0x18;

-    RtlCopyMemory(*(void **)(unaff_RSI + 0x10),unaff_RDI,(ulonglong)unaff_EBX);

+  lVar2 = *param_1;

+  local_f0 = (short ****)&local_f8;

+  pppppsVar14 = (short *****)0x0;

+  uVar15 = 0;

+  local_74 = 0;

+  local_f8 = (short ****)&local_f8;

+  local_5c = 0;

+  local_d8 = (short ***)0x0;

+  local_e8[0] = 0;

+  local_res8[0] = 0;

+  local_c8 = 0;

+  psStack_c0 = (short *)0x0;

+  local_res20 = local_res20 & 0xffffffff00000000;

+  pppppsVar19 = (short *****)0x0;

+  ppppsStack_e0 = (short ****)0x0;

+  local_98 = (short ***)0x0;

+  pppsStack_90 = (short ***)0x0;

+  pppsStack_88 = (short ***)0x0;

+  pppsStack_80 = (short ***)0x200000000;

+  local_b8 = 0;

+  lStack_b0 = 0;

+  uStack_a8 = 0;

+  local_a0 = 0x200000000;

+  lStack_d0 = 0;

+  local_res10 = param_2;

+  PfSnLogOpenVolumesForPrefetch(lVar2,1);

+  if ((lVar2 == 0) || (0x3fff < *(uint *)(lVar2 + 0x70))) {

+    uVar11 = 0xc000000d;

+    goto LAB_0;

   }

-  *unaff_R12 = unaff_EBX;

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

-    ExFreePoolWithTag();

+  lVar8 = ExAllocatePool2(0x100,*(uint *)(lVar2 + 0x70) * 0x70,0x76506343);

+  param_1[2] = lVar8;

+  pppppsVar19 = pppppsVar14;

+  if (lVar8 != 0) {

+    pppppsVar9 = pppppsVar14;

+    if (*(int *)(lVar2 + 0x70) != 0) {

+      do {

+        _Dst = (void *)((longlong)pppppsVar9 * 0x70 + param_1[2]);

+        memset(_Dst,0,0x70);

+        *(void **)((longlong)_Dst + 8) = _Dst;

+        *(void **)_Dst = _Dst;

+        uVar16 = (int)pppppsVar9 + 1;

+        pppppsVar9 = (short *****)(ulonglong)uVar16;

+        *(undefined8 *)((longlong)_Dst + 0x20) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x28) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x30) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x38) = 0;

+        *(ulonglong *)((longlong)_Dst + 0x38) = *(ulonglong *)((longlong)_Dst + 0x38) | 0x200000000;

+        *(undefined8 *)((longlong)_Dst + 0x40) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x48) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x50) = 0;

+        *(undefined8 *)((longlong)_Dst + 0x58) = 0;

+        *(ulonglong *)((longlong)_Dst + 0x58) = *(ulonglong *)((longlong)_Dst + 0x58) | 0x200000000;

+      } while (uVar16 < *(uint *)(lVar2 + 0x70));

+    }

+    pppppsVar9 = (short *****)0x0;

+    local_78 = 0x30;

+    local_70 = 0;

+    local_68 = 0;

+    local_60 = 0x200;

+    local_58 = 0;

+    uStack_50 = 0;

+    uVar16 = NtCreateEvent(&lStack_d0,0x1f0003,&local_78,0,

+                           in_stack_fffffffffffffee8 & 0xffffffffffffff00);

+    uVar11 = (ulonglong)uVar16;

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

+    pppppsVar22 = &ppppsStack_e0;

+    uVar23 = 0;

+    uVar16 = IopGetDeviceInterfaces(&GUID_DEVINTERFACE_VOLUME,0,0,0,pppppsVar22,0);

+    pppppsVar19 = (short *****)ppppsStack_e0;

+    uVar11 = (ulonglong)uVar16;

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

+    local_res18 = local_res18 & 0xffffffff00000000;

+    sVar1 = *(short *)ppppsStack_e0;

+    iVar7 = 0;

+    pppppsVar17 = (short *****)ppppsStack_e0;

+    while (sVar1 != 0) {

+      lVar8 = -1;

+      do {

+        lVar20 = lVar8;

+        lVar8 = lVar20 + 1;

+      } while (*(short *)((longlong)pppppsVar17 + lVar8 * 2) != 0);

+      ppppsStack_e0 = (short ****)((ulonglong)((int)lVar20 + 2) * 2);

+      if (pppppsVar9 <= ppppsStack_e0) {

+        uVar11 = local_res18 >> 0x20;

+        local_res18 = CONCAT44((int)uVar11,(int)lVar8 * 2 + 2);

+      }

+      iVar7 = PfSnIsVolumeMounted(pppppsVar17,local_res8,&local_res20);

+      if (iVar7 < 0) {

+        local_res8[0] = 0;

+      }

+      if ((local_res8[0] != 0) && ((int)local_res20 == 0)) {

+        pppppsVar22 = (short *****)local_e8;

+        iVar7 = PfSnQueryVolumeInfo(param_1[1],pppppsVar17,&local_98,&local_d8,pppppsVar22);

+        if (-1 < iVar7) {

+          pppppsVar9 = (short *****)ExAllocatePool2(0x100,0x48,0x76506343);

+          if (pppppsVar9 == (short *****)0x0) goto LAB_1;

+          memset(pppppsVar9,0,0x48);

+          pppppsVar9[2] = (short ****)local_98;

+          pppppsVar9[3] = (short ****)pppsStack_90;

+          *(undefined4 *)((longlong)pppppsVar9 + 0x3c) = local_e8[0];

+          pppppsVar9[8] = (short ****)local_d8;

+          pppppsVar9[4] = (short ****)pppsStack_88;

+          pppppsVar9[5] = (short ****)pppsStack_80;

+          pppppsVar9[6] = (short ****)pppppsVar17;

+          *(int *)(pppppsVar9 + 7) = (int)lVar8;

+          local_98 = (short ***)0x0;

+          pppsStack_90 = (short ***)0x0;

+          pppsStack_88 = (short ***)0x0;

+          pppsStack_80 = (short ***)0x200000000;

+          if ((short *****)*local_f0 != &local_f8) goto LAB_2;

+          pppppsVar9[1] = local_f0;

+          *pppppsVar9 = (short ****)&local_f8;

+          *local_f0 = (short ***)pppppsVar9;

+          local_f0 = (short ****)pppppsVar9;

+        }

+      }

+      pppppsVar17 = (short *****)((longlong)pppppsVar17 + (longlong)ppppsStack_e0);

+      sVar1 = *(short *)pppppsVar17;

+      pppppsVar9 = (short *****)(local_res18 & 0xffffffff);

+      iVar7 = (int)local_res18;

+    }

+    local_res18 = (ulonglong)(iVar7 + 2U);

+    psVar10 = (short *)ExAllocatePool2(0x100,iVar7 + 2U,0x76506343);

+    uVar11 = 0;

+    if (psVar10 != (short *)0x0) {

+      local_res20 = (ulonglong)*(uint *)(lVar2 + 0x6c) + lVar2;

+      local_res8[0] = 0;

+      uVar21 = extraout_XMM0_Da;

+      if (*(int *)(lVar2 + 0x70) != 0) {

+        do {

+          plVar18 = (longlong *)(uVar11 * 0x70 + param_1[2]);

+          puVar13 = (uint *)(uVar11 * 0x60 + local_res20);

+          plVar18[2] = *puVar13 + local_res20;

+          *(uint *)(plVar18 + 3) = puVar13[1];

+          *(undefined4 *)(plVar18 + 0xd) = 0;

+          plVar18[0xc] = puVar13[7] + local_res20;

+          pppppsVar9 = (short *****)local_f8;

+          while( true ) {

+            if (pppppsVar9 == &local_f8) {

+              uVar11 = FUN_1408f0b00();

+              return uVar11;

+            }

+            local_d8 = (short ***)pppppsVar9[8];

+            cVar6 = PfMetadataRecordIsEqual

+                              (uVar21,&local_d8,*(undefined4 *)((longlong)pppppsVar9 + 0x3c));

+            uVar15 = (undefined4)((ulonglong)pppppsVar22 >> 0x20);

+            uVar21 = (undefined4)((ulonglong)uVar23 >> 0x20);

+            if (cVar6 != '\0') break;

+            pppppsVar9 = (short *****)*pppppsVar9;

+            uVar21 = extraout_XMM0_Da_00;

+          }

+          RtlStringCbPrintfW(psVar10,local_res18,&u__s_,pppppsVar9[6]);

+          local_c8 = 0;

+          psStack_c0 = (short *)0x0;

+          lVar8 = 0x7fff;

+          psVar12 = psVar10;

+          do {

+            if (*psVar12 == 0) {

+              sVar1 = (0x7fff - (short)lVar8) * 2;

+              local_c8 = (ulonglong)CONCAT22(sVar1 + 2,sVar1);

+              psStack_c0 = psVar10;

+              break;

+            }

+            psVar12 = psVar12 + 1;

+            lVar8 = lVar8 + -1;

+          } while (lVar8 != 0);

+          pppppsVar17 = pppppsVar9 + 2;

+          uVar23 = CONCAT44(uVar21,0x21);

+          pppppsVar22 = (short *****)CONCAT44(uVar15,0x120089);

+          iVar7 = PfpOpenHandleCreate(&local_b8,param_1[1],&local_c8,0,pppppsVar22,uVar23,0x80,

+                                      pppppsVar17);

+          lVar8 = local_b8;

+          if (iVar7 < 0) {

+            local_a0 = 0x200000000;

+            uVar21 = 0;

+            local_b8 = 0;

+            puVar3 = (undefined8 *)param_1[4];

+            lStack_b0 = 0;

+            uStack_a8 = 0;

+            if ((longlong *)*puVar3 != param_1 + 3) goto LAB_2;

+            *plVar18 = (longlong)(param_1 + 3);

+            plVar18[1] = (longlong)puVar3;

+            *puVar3 = plVar18;

+            param_1[4] = (longlong)plVar18;

+          }

+          else {

+            ppppsVar5 = pppppsVar9[3];

+            plVar18[4] = (longlong)*pppppsVar17;

+            plVar18[5] = (longlong)ppppsVar5;

+            ppppsVar5 = pppppsVar9[5];

+            plVar18[6] = (longlong)pppppsVar9[4];

+            plVar18[7] = (longlong)ppppsVar5;

+            uVar15 = (undefined4)local_a0;

+            uVar21 = local_a0._4_4_;

+            local_a0 = 0x200000000;

+            *pppppsVar17 = (short ****)0x0;

+            pppppsVar9[3] = (short ****)0x0;

+            pppppsVar9[4] = (short ****)0x0;

+            pppppsVar9[5] = (short ****)0x0;

+            pppppsVar9[5] = (short ****)((ulonglong)pppppsVar9[5] | 0x200000000);

+            local_b8 = 0;

+            plVar18[8] = lVar8;

+            plVar18[9] = lStack_b0;

+            *(undefined4 *)(plVar18 + 10) = (undefined4)uStack_a8;

+            *(undefined4 *)((longlong)plVar18 + 0x54) = uStack_a8._4_4_;

+            *(undefined4 *)(plVar18 + 0xb) = uVar15;

+            *(undefined4 *)((longlong)plVar18 + 0x5c) = uVar21;

+            puVar3 = (undefined8 *)param_1[6];

+            lStack_b0 = 0;

+            uStack_a8 = 0;

+            if ((longlong *)*puVar3 != param_1 + 5) goto LAB_2;

+            *plVar18 = (longlong)(param_1 + 5);

+            plVar18[1] = (longlong)puVar3;

+            *puVar3 = plVar18;

+            param_1[6] = (longlong)plVar18;

+            uVar16 = PfSnVolumeCheckSeekPenalty(plVar18 + 4,lStack_d0);

+            *(uint *)((longlong)plVar18 + 0x6c) =

+                 *(uint *)((longlong)plVar18 + 0x6c) ^

+                 (uVar16 ^ *(uint *)((longlong)plVar18 + 0x6c)) & 1;

+            uVar21 = extraout_XMM0_Da_01;

+            if ((*(uint *)((longlong)plVar18 + 0x6c) & 1) == 0) {

+              if ((pppppsVar14 == (short *****)0x0) &&

+                 (iVar7 = PfSnVolumeCheckIsSdBus(plVar18 + 4,lStack_d0),

+                 uVar21 = extraout_XMM0_Da_02, iVar7 == 0)) {

+                pppppsVar14 = (short *****)&DAT_3;

+              }

+            }

+            else {

+              pppppsVar14 = (short *****)(ulonglong)((uint)pppppsVar14 | 1);

+            }

+          }

+          uVar15 = SUB84(pppppsVar14,0);

+          local_res8[0] = local_res8[0] + 1;

+          uVar11 = (ulonglong)local_res8[0];

+        } while (local_res8[0] < *(uint *)(lVar2 + 0x70));

+      }

+      uVar11 = 0;

+      *local_res10 = uVar15;

+      ExFreePoolWithTag(psVar10,0);

+      goto LAB_0;

+    }

   }

-  return unaff_R14D;

+LAB_1:

+  uVar11 = 0xc000009a;

+LAB_0:

+  if (((ulonglong)pppsStack_80 & 0x400000000) != 0) {

+    PfpOpenHandleClose(&local_98,param_1[1]);

+  }

+  while( true ) {

+    ppppsVar5 = local_f8;

+    if ((short *****)local_f8 == &local_f8) {

+      if (pppppsVar19 != (short *****)0x0) {

+        ExFreePoolWithTag(pppppsVar19,0);

+      }

+      if (lStack_d0 != 0) {

+        NtClose();

+      }

+      PfSnLogOpenVolumesForPrefetch(lVar2,0);

+      return uVar11;

+    }

+    pppppsVar14 = (short *****)local_f8;

+    if (((short *****)local_f8[1] != &local_f8) ||

+       (pppppsVar9 = (short *****)*local_f8, pppppsVar9[1] != local_f8)) break;

+    pppppsVar9[1] = (short ****)&local_f8;

+    if (((ulonglong)local_f8[5] & 0x400000000) != 0) {

+      pppppsVar14 = (short *****)(local_f8 + 2);

+      local_f8 = (short ****)pppppsVar9;

+      PfpOpenHandleClose(pppppsVar14);

+      pppppsVar9 = (short *****)local_f8;

+    }

+    local_f8 = (short ****)pppppsVar9;

+    ExFreePoolWithTag(ppppsVar5);

+  }

+LAB_2:

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

+  (*pcVar4)(3);

+  PfpOpenHandleClose(&local_a0,lVar2);

+  return (ulonglong)pppppsVar14 & 0xffffffff;

 }
```

## `PoRegisterPowerSettingCallback`  (modified)

```diff
--- PoRegisterPowerSettingCallback
+++ PoRegisterPowerSettingCallback
@@ -1,175 +1,156 @@
 

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

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

 

-void PoRegisterPowerSettingCallback(void)

+ulonglong PoRegisterPowerSettingCallback

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

+                    undefined8 *param_5)

 

 {

-  uint uVar1;

-  longlong lVar2;

-  undefined8 *puVar3;

-  undefined8 uVar4;

-  code *pcVar5;

-  bool bVar6;

-  char cVar7;

-  byte bVar8;

-  longlong *plVar9;

-  int *unaff_RBX;

-  undefined1 *puVar10;

-  int *unaff_RBP;

-  byte bVar11;

-  int *unaff_RSI;

-  longlong lVar12;

-  int *unaff_RDI;

-  int *piVar13;

-  longlong lVar14;

-  int *unaff_R13;

-  longlong unaff_R14;

-  undefined1 in_ZF;

-  bool bVar15;

-  longlong in_CR8;

-  undefined1 local_res8 [8];

-  undefined1 local_res10 [24];

+  longlong *plVar1;

+  code *pcVar2;

+  undefined4 uVar3;

+  undefined4 uVar4;

+  char cVar5;

+  int iVar6;

+  longlong *plVar7;

+  longlong lVar8;

+  longlong lVar9;

+  undefined *puVar10;

+  undefined *puVar11;

+  ulonglong uVar12;

+  bool bVar13;

+  undefined8 auStack_2a8 [4];

+  int local_288;

+  int local_284;

+  undefined8 **local_280;

+  undefined8 local_278;

+  undefined1 *puStack_270;

+  longlong local_268;

+  undefined8 *local_260;

+  undefined8 uStack_258;

+  undefined1 local_248 [160];

+  undefined1 local_1a8 [368];

+  ulonglong local_38;

   

-  do {

-    if ((!(bool)in_ZF) || (piVar13 = unaff_RDI + 8, unaff_RDI = unaff_RBP, (char)*piVar13 != '\0'))

-    {

-      PopUnregisterPowerSettingCallback();

-      unaff_RDI = unaff_RBP;

+                    /* 0x725d30  1848  PoRegisterPowerSettingCallback */

+  local_38 = __security_cookie ^ (ulonglong)auStack_2a8;

+  local_288 = 0;

+  local_280 = (undefined8 **)0x0;

+  local_284 = DAT_0;

+  local_260 = (undefined8 *)0x0;

+  uStack_258 = 0;

+  bVar13 = false;

+  local_278 = 0;

+  puStack_270 = (undefined1 *)0x0;

+  local_268 = param_1;

+  cVar5 = PopStateIsSessionSpecific(param_2);

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

+    return 0xc000000d;

+  }

+  puVar10 = (undefined *)0x0;

+  puVar11 = puVar10;

+  if (param_3 != 0) {

+    lVar8 = 0x47a0704a6fe69556 - *param_2;

+    if (lVar8 == 0) {

+      lVar8 = 0x47da6f938dc2248f - param_2[1];

     }

-    while( true ) {

-      while (unaff_RDI == unaff_RSI) {

-        if (((*(int **)unaff_RSI == unaff_RSI) && (unaff_RBX[0xe] == 0)) && (unaff_RBX[0xf] == 0)) {

-          bVar15 = true;

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

-          lVar14 = 3;

-          do {

-            lVar2 = *plVar9;

-            plVar9 = plVar9 + 1;

-            bVar6 = false;

-            if (lVar2 == 0) {

-              bVar6 = bVar15;

-            }

-            bVar15 = bVar6;

-            lVar14 = lVar14 + -1;

-          } while (lVar14 != 0);

-          piVar13 = *(int **)unaff_RBX;

-          if (bVar15) {

-            if ((*(int **)(piVar13 + 2) != unaff_RBX) ||

-               (puVar3 = *(undefined8 **)(unaff_RBX + 2), (int *)*puVar3 != unaff_RBX)) {

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

-              (*pcVar5)(3);

-              puVar10 = local_res8;

-              goto LAB_0;

-            }

-            *puVar3 = piVar13;

-            *(undefined8 **)(piVar13 + 2) = puVar3;

-            ExFreePoolWithTag(unaff_RBX,0x74655350);

-          }

+    if (lVar8 == 0) {

+      local_278 = 0;

+      puStack_270 = (undefined1 *)0x0;

+      memset(local_248,0,0x208);

+      puStack_270 = local_248;

+      local_278._0_4_ = CONCAT22(0x208,(undefined2)local_278);

+      iVar6 = RtlPcToFileName(param_3,&local_278);

+      if (-1 < iVar6) {

+        local_260 = &local_278;

+        uStack_258 = CONCAT44(uStack_258._4_4_,0x10);

+        local_280 = &local_260;

+        iVar6 = EmClientRuleEvaluate

+                          (&GUID_EM_PO_CONSOLE_STATE_CHANGE_REMAP_RULE,&local_280,1,&local_288);

+        puVar11 = (undefined *)0x0;

+        if ((-1 < iVar6) && (puVar11 = &PopPrimaryDisplayVisibleStateErratum, local_288 != 2)) {

+          puVar11 = puVar10;

         }

-        else {

-          piVar13 = *(int **)unaff_RBX;

-        }

-        unaff_RBX = piVar13;

-        if (unaff_RBX == unaff_R13) {

-          ExReleaseFastMutex(&PopSettingLock);

-          PopDecrementPowerSettingPendingUpdates(0);

-          return;

-        }

-        unaff_RSI = unaff_RBX + 4;

-        unaff_RDI = *(int **)unaff_RSI;

       }

-      if ((char)unaff_RDI[0x1a] == '\0') break;

-      unaff_RDI = *(int **)unaff_RDI;

     }

-    *(undefined1 *)(unaff_RDI + 0x1a) = 1;

-    if (*(longlong *)(unaff_RDI + 0x12) != *(longlong *)(unaff_RBX + unaff_R14 * 2 + 0x10)) {

-      func_0x000140725a34();

+  }

+  ExAcquireFastMutex(&PopSettingLock);

+  plVar7 = (longlong *)ExAllocatePool2(0x100,0x70,0x74655350);

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

+    uVar12 = 0xc000009a;

+    goto LAB_1;

+  }

+  *(undefined4 *)(plVar7 + 2) = 0x74655350;

+  lVar8 = *param_2;

+  uVar3 = *(undefined4 *)((longlong)param_2 + 4);

+  lVar9 = param_2[1];

+  uVar4 = *(undefined4 *)((longlong)param_2 + 0xc);

+  plVar7[10] = param_3;

+  plVar7[0xb] = param_4;

+  *(int *)((longlong)plVar7 + 0x34) = (int)lVar8;

+  *(undefined4 *)(plVar7 + 7) = uVar3;

+  *(int *)((longlong)plVar7 + 0x3c) = (int)lVar9;

+  *(undefined4 *)(plVar7 + 8) = uVar4;

+  plVar7[0xc] = local_268;

+  if (puVar11 != (undefined *)0x0) {

+    PopEnsureErratumSubscribed(puVar11);

+    param_2 = (longlong *)(puVar11 + 0x10);

+  }

+  uVar3 = *(undefined4 *)((longlong)param_2 + 4);

+  lVar8 = param_2[1];

+  uVar4 = *(undefined4 *)((longlong)param_2 + 0xc);

+  *(int *)((longlong)plVar7 + 0x24) = (int)*param_2;

+  *(undefined4 *)(plVar7 + 5) = uVar3;

+  *(int *)((longlong)plVar7 + 0x2c) = (int)lVar8;

+  *(undefined4 *)(plVar7 + 6) = uVar4;

+  lVar8 = PopFindPowerSettingConfiguration(param_2,0xffffffff);

+  if (lVar8 == 0) {

+    if ((undefined8 *)*DAT_3 != &PopRegisteredPowerSettingCallbacks) goto LAB_1407260f0;

+    *plVar7 = (longlong)&PopRegisteredPowerSettingCallbacks;

+    plVar7[1] = (longlong)DAT_3;

+    *DAT_3 = (longlong)plVar7;

+    DAT_3 = plVar7;

+  }

+  else {

+    lVar9 = *param_2 + -0x163df734515c31d8;

+    if (lVar9 == 0) {

+      lVar9 = param_2[1] + 0xe176e735fee0260;

     }

-    unaff_RBP = *(int **)unaff_RDI;

-    *(undefined1 *)(unaff_RDI + 0x1a) = 0;

-    in_ZF = *(char *)((longlong)unaff_RDI + 0x21) == '\0';

-  } while( true );

-LAB_0:

-  *(undefined4 *)((longlong)unaff_RBP + 3) = 0;

-  *(undefined4 *)((longlong)unaff_RBP + 0x13) = 0;

-  *(undefined4 *)((longlong)unaff_RBP + 0x23) = 0;

-  *(undefined4 *)((longlong)unaff_RBP + 0x33) = 0;

-  *(longlong *)((longlong)unaff_RBP + -9) = (longlong)unaff_RBP + -0x41;

-  *(undefined4 *)((longlong)unaff_RBP + 0x1f) = 4;

-  *(int **)((longlong)unaff_RBP + 7) = unaff_RBX + 9;

-  *(undefined4 *)((longlong)unaff_RBP + -1) = 8;

-  *(longlong *)((longlong)unaff_RBP + 0x17) = (longlong)unaff_RBP + -0x49;

-  *(int **)((longlong)unaff_RBP + 0x27) = piVar13 + 3;

-  *(undefined4 *)((longlong)unaff_RBP + 0xf) = 0x10;

-  *(int *)((longlong)unaff_RBP + 0x2f) = (int)unaff_RSI;

-  EtwWrite(unaff_R14,&POP_ETW_EVENT_POWER_SETTING_CALLBACK_START,0,4);

-  do {

-    lVar14 = in_CR8;

-    (**(code **)(unaff_RBX + 0x14))

-              (unaff_RBX + 0xd,piVar13 + 3,piVar13[1],*(undefined8 *)(unaff_RBX + 0x16));

-    bVar11 = (byte)in_CR8;

-    bVar8 = (byte)lVar14;

-    if (bVar8 != bVar11) {

-LAB_1:

-      uVar4 = *(undefined8 *)(unaff_RBX + 0x14);

-      *(ulonglong *)(puVar10 + 0x20) = (ulonglong)bVar8;

-                    /* WARNING: Subroutine does not return */

-      *(undefined **)(puVar10 + -8) = &UNK_2;

-      KeBugCheckEx(0xa0,0x900,uVar4,bVar11);

-    }

-    bVar15 = PopDiagHandleRegistered != '\0';

-    *(undefined8 *)((longlong)unaff_RBP + -0x39) = *(undefined8 *)(unaff_RBX + 0x14);

-    lVar2 = PopDiagHandle;

-    lVar12 = in_CR8;

-    in_CR8 = lVar14;

-    if ((bVar15) &&

-       (cVar7 = EtwEventEnabled(PopDiagHandle,&POP_ETW_EVENT_POWER_SETTING_CALLBACK_STOP),

-       lVar12 = lVar2, in_CR8 = lVar14, cVar7 != '\0')) {

-      *(undefined4 *)((longlong)unaff_RBP + -0x25) = 0;

-      *(undefined4 *)((longlong)unaff_RBP + -0x15) = 0;

-      *(longlong *)((longlong)unaff_RBP + -0x31) = (longlong)unaff_RBP + -0x39;

-      *(undefined4 *)((longlong)unaff_RBP + -0x29) = 8;

-      *(int **)((longlong)unaff_RBP + -0x21) = unaff_RBX + 9;

-      *(undefined4 *)((longlong)unaff_RBP + -0x19) = 0x10;

-      EtwWrite(lVar2,&POP_ETW_EVENT_POWER_SETTING_CALLBACK_STOP,0,2);

-      in_CR8 = lVar14;

-    }

-    bVar11 = (byte)lVar12;

-    if (*(int *)((longlong)SystemReserved1[0xf] + 0x1e4) != 0) {

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

-      bVar8 = (*pcVar5)(0x20);

-      puVar10 = local_res10;

-      goto LAB_1;

-    }

-    ExAcquireFastMutex(&PopSettingLock);

-    if ((*(int **)(unaff_RBX + 0x12) == (int *)0x0) || (piVar13 == *(int **)(unaff_RBX + 0x12))) {

-      bVar15 = false;

+    if (lVar9 == 0) {

+LAB_4:

+      plVar7[9] = *(longlong *)(lVar8 + 0x40 + (longlong)local_284 * 8);

     }

     else {

-      bVar15 = true;

+      lVar9 = *param_2 + -0x48d82a54cf23f240;

+      if (lVar9 == 0) {

+        lVar9 = param_2[1] + -0x2e05ff1815de14b1;

+      }

+      if (lVar9 == 0) goto LAB_4;

     }

-    *piVar13 = *piVar13 + -1;

-    if (*piVar13 == 0) {

-      ExFreePoolWithTag(piVar13,0x74655350);

+    plVar1 = *(longlong **)(lVar8 + 0x18);

+    if (*plVar1 != lVar8 + 0x10) {

+LAB_2:

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

+      (*pcVar2)(3);

+      auStack_2a8[0] = 0x1408d0589;

+      PnpDiagnosticTraceObject(&KMPnPEvt_DeviceEnum_Pend,local_1a8);

+      return (ulonglong)param_2 & 0xffffffff;

     }

-    if (!bVar15) {

-      unaff_RBX[6] = 0;

-      unaff_RBX[7] = 0;

-      return;

-    }

-    piVar13 = *(int **)(unaff_RBX + 0x12);

-    *piVar13 = *piVar13 + 1;

-    ExReleaseFastMutex(&PopSettingLock);

-    bVar15 = PopDiagHandleRegistered == '\0';

-    uVar1 = piVar13[1];

-    unaff_RSI = (int *)(ulonglong)uVar1;

-    *(undefined8 *)((longlong)unaff_RBP + -0x41) = *(undefined8 *)(unaff_RBX + 0x14);

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

-    unaff_R14 = PopDiagHandle;

-  } while ((bVar15) ||

-          (cVar7 = EtwEventEnabled(PopDiagHandle,&POP_ETW_EVENT_POWER_SETTING_CALLBACK_START),

-          cVar7 == '\0'));

-  goto LAB_0;

+    *plVar7 = lVar8 + 0x10;

+    plVar7[1] = (longlong)plVar1;

+    *plVar1 = (longlong)plVar7;

+    *(longlong **)(lVar8 + 0x18) = plVar7;

+  }

+  uVar12 = 0;

+  bVar13 = 2 < PopOsInitPhase;

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

+    *param_5 = plVar7;

+  }

+LAB_1:

+  ExReleaseFastMutex(&PopSettingLock);

+  if (bVar13) {

+    PopSetNotificationWork(0x20);

+  }

+  return uVar12;

 }
```

## `HalpBuildScatterGatherList`  (modified)

```diff
--- HalpBuildScatterGatherList
+++ HalPutScatterGatherListV3
@@ -1,110 +1,31 @@
 

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

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

-

-ulonglong HalpBuildScatterGatherList

-                    (longlong param_1,longlong param_2,longlong param_3,longlong *param_4,

-                    ulonglong param_5,uint param_6,undefined4 param_7,longlong param_8,

-                    undefined8 param_9,char param_10,longlong param_11,undefined4 param_12,

-                    undefined8 param_13,undefined8 param_14,undefined8 *param_15)

+void HalPutScatterGatherListV3(undefined8 param_1,longlong param_2,undefined1 param_3)

 

 {

-  uint uVar1;

-  ulonglong uVar2;

-  longlong lVar3;

-  uint *puVar4;

-  uint *puVar5;

+  uint *puVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  undefined8 *puVar4;

   

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

-    if (param_15 != (undefined8 *)0x0) {

-      *param_15 = 0;

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

+  lVar2 = *(longlong *)(puVar1 + 2);

+  HalFlushAdapterBuffersEx

+            (param_1,lVar2,*(undefined8 *)(puVar1 + 6),

+             (*(longlong *)(puVar1 + 8) - (ulonglong)*(uint *)(lVar2 + 0x2c)) -

+             *(longlong *)(lVar2 + 0x20),puVar1[10],param_3);

+  IoFreeMapRegistersV3(param_1,*(undefined8 *)(puVar1 + 6),puVar1[0xb]);

+  puVar4 = *(undefined8 **)(puVar1 + 4);

+  while (puVar4 != (undefined8 *)0x0) {

+    puVar3 = (undefined8 *)*puVar4;

+    if ((*(byte *)((longlong)puVar4 + 10) & 1) != 0) {

+      MmUnmapLockedPages(puVar4[3],puVar4);

     }

-    do {

-      puVar5 = (uint *)(param_4 + 5);

-      if (param_5 < *puVar5) {

-        uVar2 = HalGetDmaTransferInfoInternal(0,param_4,param_5,param_6);

-        if ((int)uVar2 < 0) {

-          return uVar2;

-        }

-        if (param_11 == 0) {

-          lVar3 = ExAllocatePool2(0x42,0,0x446c6148);

-          if (lVar3 == 0) {

-            return 0xc000009a;

-          }

-          puVar5 = (uint *)(lVar3 + 0x28);

-          *puVar5 = 0;

-          *(longlong *)(lVar3 + 200) = lVar3;

-          *(undefined4 *)(lVar3 + 0xc4) = 0;

-        }

-        else {

-          puVar5 = (uint *)(param_11 + 0x28);

-          *puVar5 = *puVar5 | 1;

-          *(longlong *)(param_11 + 200) = param_11;

-          *(undefined4 *)(param_11 + 0xc4) = param_12;

-        }

-        if (param_15 != (undefined8 *)0x0) {

-          *param_15 = *(undefined8 *)(puVar5 + 0x28);

-        }

-        puVar5[0x27] = puVar5[0x27] - 0xa8;

-        *(longlong **)(puVar5 + 2) = param_4;

-        puVar5[4] = 0;

-        puVar5[5] = 0;

-        uVar1 = *(uint *)((longlong)param_4 + 0x2c);

-        lVar3 = param_4[4];

-        *(longlong *)(puVar5 + 0x1e) = param_8;

-        *(ulonglong *)(puVar5 + 8) = (ulonglong)uVar1 + lVar3 + param_5;

-        puVar5[10] = param_6;

-        *(undefined8 *)(puVar5 + 0x20) = param_9;

-        *(longlong *)(puVar5 + 0x24) = param_1;

-        *(char *)(puVar5 + 0x26) = param_10;

-        puVar5[0xb] = 0;

-        puVar5[6] = 0;

-        puVar5[7] = 0;

-        if (param_3 == 0) {

-          puVar4 = puVar5 + 0xc;

-          puVar5[0x11] = puVar5[0x11] & 0xfffffffd;

-        }

-        else {

-          puVar4 = (uint *)(param_3 + 0x10);

-          *(uint **)(param_3 + 0x58) = puVar5;

-          *(uint *)(param_3 + 0x24) = *(uint *)(param_3 + 0x24) | 2;

-        }

-        *(uint **)(puVar4 + 8) = puVar5;

-        *(longlong *)(puVar4 + 0xc) = param_2;

-        *(undefined8 *)(puVar4 + 0xe) = *(undefined8 *)(param_2 + 0x20);

-        if (((*(char *)(param_1 + 0x1b8) == '\0') && (*(int *)(param_1 + 0x208) != 3)) &&

-           ((*(char *)(param_1 + 0x1bd) != '\0' || (param_10 != '\0')))) {

-          HalpAllocateAdapterCallbackV3(param_2,*(undefined8 *)(param_2 + 0x20),0,puVar5);

-          return 0;

-        }

-        puVar5[0xb] = 1;

-        if (param_8 == 0) {

-          uVar1 = HalpAllocateAdapterChannel(param_1,puVar4,1,0,param_7,0);

-          if (uVar1 == 0) {

-            HalpAllocateAdapterCallbackV3

-                      (param_2,*(undefined8 *)(param_2 + 0x20),*(undefined8 *)(param_1 + 0xf0),

-                       puVar5);

-            return 0;

-          }

-        }

-        else {

-          uVar1 = HalpAllocateAdapterChannel

-                            (param_1,puVar4,1,0,param_7,HalpAllocateAdapterCallbackV3);

-        }

-        uVar2 = (ulonglong)uVar1;

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

-          return uVar2;

-        }

-        if (param_11 != 0) {

-          return uVar2;

-        }

-        ExFreePoolWithTag(*(undefined8 *)(puVar5 + 0x28),0);

-        return uVar2;

-      }

-      param_4 = (longlong *)*param_4;

-      param_5 = param_5 - *puVar5;

-    } while (param_4 != (longlong *)0x0);

+    IoFreeMdl(puVar4);

+    puVar4 = puVar3;

   }

-  return 0xc000000d;

+  if ((*puVar1 & 1) == 0) {

+    ExFreePoolWithTag(*(undefined8 *)(puVar1 + 0x28),0);

+  }

+  return;

 }
```

## `PspJobIoRateControlDisable`  (modified)

```diff
--- PspJobIoRateControlDisable
+++ PspJobIoRateControlDisable
@@ -1,57 +1,44 @@
 

-undefined8 PspJobIoRateControlDisable(undefined8 param_1,undefined8 param_2,code *param_3)

+ulonglong PspJobIoRateControlDisable(longlong param_1)

 

 {

-  longlong lVar1;

-  longlong *plVar2;

-  code *pcVar3;

-  undefined8 uVar4;

-  longlong *unaff_RBX;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  longlong lVar5;

-  undefined4 uStack0000000000000028;

+  longlong ***ppplVar1;

+  code *pcVar2;

+  longlong **pplVar3;

+  ulonglong uVar4;

+  bool bVar5;

+  longlong **local_18;

+  longlong **local_10;

   

-  uVar4 = 0x4077fd00;

+  bVar5 = *(longlong *)(param_1 + 0x670) != 0;

+  if (bVar5) {

+    PspIoRateEntryDeactivate(param_1 + 0x648);

+  }

+  uVar4 = (ulonglong)bVar5;

+  local_10 = (longlong **)&local_18;

+  local_18 = (longlong **)&local_18;

+  PspJobIoRateVolumeEntryRemoveAll(param_1,&local_18);

   while( true ) {

-    uStack0000000000000028 = 8;

-    PspEnumJobsAndProcessesInJobHierarchy

-              (unaff_RDI,PspSetCpuRateControlJobPreCallback,param_3,0,uVar4);

-    lVar1 = *unaff_RBX;

-    if ((*(longlong **)(lVar1 + 8) != unaff_RBX) ||

-       (plVar2 = (longlong *)unaff_RBX[1], (longlong *)*plVar2 != unaff_RBX)) break;

-    *plVar2 = lVar1;

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

-    ExFreePoolWithTag(unaff_RBX,0x624a7350);

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

-    if (unaff_RBX == (longlong *)(unaff_RBP + -0x10)) {

-      return 0;

+    pplVar3 = local_18;

+    if ((longlong ***)local_18 == &local_18) {

+      return uVar4;

     }

-    unaff_RDI = unaff_RBX[2];

-    lVar1 = *(longlong *)(unaff_RDI + 0x4c0);

-    if (*(longlong *)(unaff_RDI + 0x500) == 0) {

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

-      if ((PsCpuFairShareEnabled != '\0') && (lVar5 != 0)) {

-        ObfReferenceObjectWithTag(*(undefined8 *)(unaff_RDI + 0x528),0x624a7350);

-      }

-    }

-    else {

-      lVar5 = *(longlong *)(*(longlong *)(unaff_RDI + 0x500) + 0x4c0) + 0x80;

-    }

-    KeInsertSchedulingGroup(lVar1 + 0x80,*(undefined8 *)(lVar1 + 0x80),lVar5);

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

-      uStack0000000000000028 = 8;

-      PspEnumJobsAndProcessesInJobHierarchy

-                (unaff_RDI,PspSetCpuRateControlJobPreCallback,PspSetCpuRateControlJobPostCallback,0,

-                 0);

-    }

-    uVar4 = *(undefined8 *)(unaff_RDI + 0x4c0);

-    param_3 = PspSetCpuRateControlJobPostCallback;

+    if (((longlong ***)local_18[1] != &local_18) ||

+       (ppplVar1 = (longlong ***)*local_18, ppplVar1[1] != local_18)) break;

+    ppplVar1[1] = (longlong **)&local_18;

+    local_18 = (longlong **)ppplVar1;

+    PspIoRateEntryDeactivate(pplVar3);

+    ExFreePoolWithTag(pplVar3,0);

+    uVar4 = (ulonglong)((int)uVar4 + 1);

   }

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

-  (*pcVar3)(3);

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

-  uVar4 = (*pcVar3)();

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

+  (*pcVar2)(3);

+  PspStorageEmptyArray(uVar4,0x20);

+  if (*(longlong *)(uVar4 + 0x200) != 0) {

+    PspStorageEmptyArray(*(longlong *)(uVar4 + 0x200),0x100);

+  }

+  uVar4 = PspFreeStorage(pplVar3[0xbd]);

+  pplVar3[0xbd] = (longlong *)0x0;

   return uVar4;

 }
```

## `KsepCacheDeviceInsertData`  (modified)

```diff
--- KsepCacheDeviceInsertData
+++ KsepCacheDeviceInsertData
@@ -1,29 +1,78 @@
 

-int KsepCacheDeviceInsertData(void)

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

+

+ulonglong KsepCacheDeviceInsertData

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

+                    uint param_5)

 

 {

-  int iVar1;

-  int iVar2;

-  int *in_RAX;

-  undefined8 *unaff_RSI;

-  int unaff_EDI;

+  longlong *plVar1;

+  code *pcVar2;

+  byte bVar3;

+  uint uVar4;

+  longlong *plVar5;

+  void *_Dst;

+  ulonglong uVar6;

+  byte bVar7;

+  longlong unaff_RBX;

+  longlong *unaff_RSI;

+  undefined4 *puVar8;

+  longlong in_R10;

   

-  while( true ) {

-    if (in_RAX == (int *)0x0) {

-      return -0x3fffff66;

-    }

-    iVar2 = ZwQuerySystemInformation(0xb,in_RAX,unaff_EDI,&stack0x00000030);

-    iVar1 = *in_RAX;

-    if (-1 < iVar2) break;

-    if (iVar2 != -0x3ffffffc) {

-      KsepPoolFreePaged(in_RAX);

-      return iVar2;

-    }

-    KsepPoolFreePaged(in_RAX);

-    unaff_EDI = iVar1 * 0x128 + 8;

-    in_RAX = (int *)KsepPoolAllocatePaged(unaff_EDI);

+  plVar5 = (longlong *)KsepPoolAllocatePaged(0x30);

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

+    return 0xc0000017;

   }

-  *unaff_RSI = in_RAX;

-  return iVar2;

+  uVar4 = KsepStringDuplicate(plVar5 + 2,param_2);

+  uVar6 = (ulonglong)uVar4;

+  if ((int)uVar4 < 0) {

+LAB_0:

+    KsepStringFree(plVar5 + 2);

+    KsepPoolFreePaged(plVar5[5]);

+    KsepPoolFreePaged(plVar5);

+    return uVar6;

+  }

+  puVar8 = (undefined4 *)(ulonglong)param_5;

+  _Dst = (void *)KsepPoolAllocatePaged(puVar8);

+  plVar5[5] = (longlong)_Dst;

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

+    uVar6 = 0xc0000017;

+    goto LAB_0;

+  }

+  uVar6 = (ulonglong)param_5;

+  RtlCopyMemory(_Dst,param_3,uVar6);

+  *(undefined4 *)((longlong)plVar5 + 0x24) = param_4;

+  *(uint *)(plVar5 + 4) = param_5;

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

+  if (*plVar1 == param_1 + 0x38) {

+    *plVar5 = param_1 + 0x38;

+    plVar5[1] = (longlong)plVar1;

+    *plVar1 = (longlong)plVar5;

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

+    return 0;

+  }

+  bVar7 = 3;

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

+  bVar3 = (*pcVar2)();

+  if ((bVar3 & bVar7) == 0) {

+LAB_1:

+    uVar6 = 0;

+  }

+  else {

+    *(undefined4 *)(uVar6 + 0x40 + in_R10) = 0;

+    uVar6 = SdbpOpenLocalDatabaseEx(in_R10,&stack0x00000010);

+    if (unaff_RBX == 0) goto LAB_1;

+    if ((int)uVar6 != 0) goto LAB_2;

+  }

+  unaff_RBX = 0;

+  plVar5 = (longlong *)0x0;

+LAB_2:

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

+    *unaff_RSI = unaff_RBX;

+  }

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

+    *puVar8 = (int)plVar5;

+  }

+  return uVar6;

 }
```

## `PspLookupProcessQuotaBlock`  (modified)

```diff
--- PspLookupProcessQuotaBlock
+++ PspLookupProcessQuotaBlock
@@ -1,111 +1,107 @@
 

-ulonglong PspLookupProcessQuotaBlock(ulonglong *param_1,undefined8 param_2)

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

+

+ulonglong PspLookupProcessQuotaBlock

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

 

 {

-  ulonglong *puVar1;

-  ulonglong uVar2;

-  undefined8 uVar3;

-  void *pvVar4;

-  undefined1 uVar5;

-  uint uVar6;

-  undefined8 in_RAX;

-  undefined7 uVar10;

-  longlong lVar8;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  void *pvVar5;

+  char cVar6;

+  uint uVar7;

+  undefined4 uVar8;

   ulonglong uVar9;

-  char *unaff_RBX;

-  longlong unaff_RBP;

-  byte *unaff_RDI;

-  undefined8 in_XMM0_Qa;

-  undefined4 in_XMM0_Dc;

-  undefined4 in_XMM0_Dd;

-  undefined8 in_stack_00000020;

-  undefined4 uVar11;

-  undefined1 *puVar7;

+  undefined8 *puVar10;

+  longlong lVar11;

+  undefined4 *unaff_R13;

   

-  uVar11 = (undefined4)((ulonglong)in_stack_00000020 >> 0x20);

-  uVar10 = (undefined7)((ulonglong)in_RAX >> 8);

-  uVar5 = in((short)param_2);

-  puVar7 = (undefined1 *)CONCAT71(uVar10,uVar5);

-  *puVar7 = *puVar7;

-  *unaff_RBX = *unaff_RBX + (char)((ulonglong)param_2 >> 8);

-  *unaff_RDI = *unaff_RDI >> 7 | *unaff_RDI << 1;

-  *(char *)param_1 = (char)*param_1 << 5;

-  uVar5 = in((short)param_2);

-  uVar9 = CONCAT71(uVar10,uVar5);

-  *(ulonglong *)(unaff_RBP + 0x50) = *(ulonglong *)(unaff_RBP + 0x50) & uVar9;

-  *(ulonglong *)(unaff_RBP + 0x58) = *(ulonglong *)(unaff_RBP + 0x58) & uVar9;

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

-  *(uint *)(unaff_RBP + -0x2c) = *(uint *)(unaff_RBP + -0x2c) & (uint)uVar9;

-  *(int *)(unaff_RBP + -0x40) = (int)in_XMM0_Qa;

-  *(int *)(unaff_RBP + -0x3c) = (int)((ulonglong)in_XMM0_Qa >> 0x20);

-  *(undefined4 *)(unaff_RBP + -0x38) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + -0x34) = in_XMM0_Dd;

-  lVar8 = PsGetCurrentServerSiloGlobals();

-  puVar1 = *(ulonglong **)(lVar8 + 0x420);

-  uVar9 = puVar1[1];

-  if (uVar9 < 2) {

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

-    *(undefined **)(unaff_RBP + -0x20) = &NlsLocaleFilePathName;

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

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

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

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

-    uVar9 = ZwOpenFile(unaff_RBP + 0x50,0x100000,unaff_RBP + -0x30,unaff_RBP + -0x40,

-                       CONCAT44(uVar11,1));

-    if ((int)uVar9 < 0) {

-      return uVar9;

+  pvVar5 = SystemReserved1[0xf];

+  uVar7 = PspHashKeyValue();

+  *(short *)((longlong)pvVar5 + 0x1e4) = *(short *)((longlong)pvVar5 + 0x1e4) + -1;

+  lVar2 = PspQuotaBlockTable + (ulonglong)uVar7 * 0x18;

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

+    ExAcquirePushLockSharedEx();

+  }

+  else {

+    ExAcquirePushLockExclusiveEx(lVar2,0);

+  }

+  if (param_1 == 0) {

+    puVar10 = PspDefaultQuotaBlock;

+    if (param_3 != 0) {

+LAB_0:

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

+        uVar9 = FUN_1408fe64c();

+        return uVar9;

+      }

     }

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

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

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

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

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

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

-    uVar6 = ZwCreateSection(unaff_RBP + 0x58,4,unaff_RBP + -0x30,0,2);

-    ZwClose(*(undefined8 *)(unaff_RBP + 0x50));

-    uVar3 = MmSectionObjectType;

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

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

-      uVar6 = ObReferenceObjectByHandle

-                        (*(undefined8 *)(unaff_RBP + 0x58),0xf001f,uVar3,0,unaff_RBP + 0x48);

-      uVar9 = *(ulonglong *)(unaff_RBP + 0x48);

-      ZwClose(*(undefined8 *)(unaff_RBP + 0x58));

-      pvVar4 = SystemReserved1[0xf];

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

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

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

-        ExAcquirePushLockExclusiveEx(puVar1,0);

-        uVar2 = puVar1[1];

-        if (uVar2 == 1) {

-          uVar2 = *(ulonglong *)(unaff_RBP + 0x48);

-          ObfReferenceObject(uVar2);

-          puVar1[1] = uVar2;

-        }

-        else if (uVar2 != 0) {

-          ObfDereferenceObject(*(undefined8 *)(unaff_RBP + 0x48));

-          ObfReferenceObject(uVar2);

-          uVar9 = uVar2;

-        }

-        LOCK();

-        uVar2 = *puVar1;

-        *puVar1 = *puVar1 - 1;

-        UNLOCK();

-        if (((uVar2 & 2) != 0) && ((uVar2 & 4) == 0)) {

-          ExfTryToWakePushLock(puVar1);

-        }

-        KeAbPostRelease(puVar1);

-        KiLeaveCriticalRegionUnsafe(pvVar4);

+  }

+  else {

+    for (puVar10 = *(undefined8 **)(lVar2 + 8); puVar10 != (undefined8 *)(lVar2 + 8);

+        puVar10 = (undefined8 *)*puVar10) {

+      cVar6 = RtlEqualSid(param_1,puVar10 + 7);

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

+        puVar10 = puVar10 + -0x41;

         goto LAB_0;

       }

     }

-    uVar9 = (ulonglong)uVar6;

+  }

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

+    PspUnlockQuotaListShared(pvVar5,lVar2);

   }

   else {

-    ObfReferenceObject(uVar9);

-LAB_0:

-    *param_1 = uVar9;

-    uVar9 = 0;

+    plVar1 = param_4 + 0x41;

+    if (param_3 == 0) {

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

+      if (*plVar3 != lVar2 + 8) {

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

+        (*pcVar4)(3);

+        uVar9 = (ulonglong)param_4 & 0xffffffff;

+        lVar11 = (longlong)&PspDefaultResourceLimits - (longlong)unaff_R13;

+        do {

+          uVar7 = ZwQueryValueKey(*(undefined8 *)((longlong)pvVar5 + -0x51),

+                                  &PspDefaultResourceNames + (longlong)(int)param_4 * 0x10,2,

+                                  (longlong)pvVar5 + 7,0x14,(longlong)pvVar5 + -0x49);

+          if (((uVar7 + 0x80000000 & 0x80000000) == 0) && (uVar7 != (uint)lVar2)) {

+            ZwClose(*(undefined8 *)((longlong)pvVar5 + -0x51));

+            goto LAB_1;

+          }

+          if (((uVar7 == (uint)lVar2) || (*(int *)((longlong)pvVar5 + 0xf) != 4)) ||

+             (*(int *)((longlong)pvVar5 + 0xb) != 4)) {

+            uVar8 = *(undefined4 *)(lVar11 + (longlong)unaff_R13);

+            uVar9 = (ulonglong)((int)uVar9 + 1);

+          }

+          else {

+            uVar8 = *(undefined4 *)((longlong)pvVar5 + 0x13);

+          }

+          *unaff_R13 = uVar8;

+          uVar7 = (int)param_4 + 1;

+          param_4 = (undefined8 *)(ulonglong)uVar7;

+          unaff_R13 = unaff_R13 + 1;

+        } while ((int)uVar7 < 4);

+        ZwClose(*(undefined8 *)((longlong)pvVar5 + -0x51));

+        if ((uint)uVar9 < 4) {

+          uVar7 = PspSanitizeResourceLimits();

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

+          **(undefined4 **)((longlong)pvVar5 + -0x11) = 0;

+        }

+        uVar7 = 0;

+LAB_1:

+        return (ulonglong)uVar7;

+      }

+      *plVar1 = lVar2 + 8;

+      param_4[0x42] = plVar3;

+      *plVar3 = (longlong)plVar1;

+      *(longlong **)(lVar2 + 0x10) = plVar1;

+    }

+    else {

+      PspDefaultQuotaBlock = param_4;

+      *plVar1 = 1;

+    }

+    PspUnlockQuotaListExclusive(pvVar5,lVar2);

   }

-  return uVar9;

+  return 0;

 }
```

## `PfSnGetCompletedTrace`  (modified)

```diff
--- PfSnGetCompletedTrace
+++ PfSnGetCompletedTrace
@@ -1,22 +1,60 @@
 

-undefined8 PfSnGetCompletedTrace(longlong param_1)

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

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

+

+ulonglong PfSnGetCompletedTrace(void *param_1,uint param_2,uint *param_3)

 

 {

-  undefined2 *puVar1;

-  int iVar2;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  undefined2 unaff_R12W;

-  longlong *unaff_R14;

-  int *unaff_R15;

+  uint *puVar1;

+  undefined8 *puVar2;

+  code *pcVar3;

+  bool bVar4;

+  undefined8 *puVar5;

+  longlong lVar6;

+  ulonglong uVar7;

   

-  puVar1 = (undefined2 *)(unaff_RDI + param_1 * 2);

-  *puVar1 = unaff_R12W;

-  iVar2 = (int)((longlong)puVar1 - unaff_RSI >> 1) * 2 + 2;

-  *unaff_R15 = iVar2;

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

-    *unaff_R14 = (longlong)puVar1;

+  bVar4 = true;

+  ExAcquireFastMutex(&DAT_0);

+  puVar5 = DAT_1;

+  DAT_2 = 2;

+  if ((undefined8 **)DAT_1 == &DAT_1) {

+    uVar7 = 0x8000001a;

   }

-  return CONCAT71((uint7)(uint3)((uint)iVar2 >> 8),1);

+  else {

+    puVar1 = (uint *)(DAT_1 + 3);

+    if (param_2 < *puVar1) {

+      *param_3 = *puVar1;

+      uVar7 = 0xc0000023;

+    }

+    else {

+      puVar2 = (undefined8 *)*DAT_1;

+      if (((undefined8 **)DAT_1[1] != &DAT_1) ||

+         ((undefined8 *)puVar2[1] != DAT_1)) {

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

+        lVar6 = (*pcVar3)(3);

+        uVar7 = 0;

+        if (lVar6 != 0) {

+          uVar7 = KeAbPostReleaseEx(param_2,lVar6);

+        }

+        return uVar7 & 0xffffffffffffff00;

+      }

+      DAT_1 = puVar2;

+      puVar2[1] = &DAT_1;

+      DAT_3 = DAT_3 + -1;

+      ExReleaseFastMutex(&DAT_0);

+      bVar4 = false;

+      if (*(char *)((longlong)SystemReserved1[0xf] + 0x232) != '\0') {

+        ProbeForWrite(param_1,param_2,8);

+      }

+      RtlCopyMemory(param_1,puVar5 + 2,(ulonglong)*puVar1);

+      *param_3 = *puVar1;

+      ExFreePoolWithTag(puVar5,0);

+      uVar7 = 0;

+    }

+  }

+  if (bVar4) {

+    ExReleaseFastMutex(&DAT_0);

+  }

+  return uVar7;

 }
```

## `WbReleaseLeastRecentlyUsedHeapExecutedBlocks`  (modified)

```diff
--- WbReleaseLeastRecentlyUsedHeapExecutedBlocks
+++ WbReleaseLeastRecentlyUsedHeapExecutedBlocks
@@ -1,11 +1,246 @@
 

-void WbReleaseLeastRecentlyUsedHeapExecutedBlocks(void)

+longlong *

+WbReleaseLeastRecentlyUsedHeapExecutedBlocks

+          (undefined8 *param_1,int param_2,undefined8 param_3,undefined8 param_4,undefined8 param_5)

 

 {

-  code *pcVar1;

+  ulonglong *puVar1;

+  ulonglong *puVar2;

+  longlong *plVar3;

+  short *psVar4;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  short sVar7;

+  ulonglong *puVar8;

+  code *pcVar9;

+  int iVar10;

+  uint uVar11;

+  longlong *in_RAX;

+  longlong lVar12;

+  longlong *plVar13;

+  longlong unaff_RBX;

+  ulonglong *puVar14;

+  void *unaff_RBP;

+  void *unaff_RSI;

+  ulonglong *puVar15;

+  longlong local_res18;

+  undefined8 in_stack_00000070;

+  longlong *in_stack_00000080;

   

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

-  (*pcVar1)();

-  return;

+  if (param_2 < 1) {

+    return in_RAX;

+  }

+  puVar1 = param_1 + 6;

+  puVar2 = param_1 + 10;

+  puVar15 = param_1 + 8;

+  do {

+    param_2 = param_2 + -1;

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

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

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

+    LOCK();

+    uVar6 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar1,lVar12);

+    }

+    if (lVar12 != 0) {

+      *(undefined1 *)(lVar12 + 0x12) = 1;

+    }

+    lVar12 = KeAbPreAcquire(puVar2,0,0);

+    LOCK();

+    uVar6 = *puVar2;

+    *puVar2 = *puVar2 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar2,lVar12);

+    }

+    if (lVar12 != 0) {

+      *(undefined1 *)(lVar12 + 0x12) = 1;

+    }

+    puVar8 = (ulonglong *)*puVar15;

+    if (puVar8 == puVar15) {

+      puVar14 = (ulonglong *)0x0;

+    }

+    else {

+      if (((ulonglong *)puVar8[1] != puVar15) ||

+         (uVar6 = *puVar8, *(ulonglong **)(uVar6 + 8) != puVar8)) {

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

+        (*pcVar9)(3);

+        uVar11 = FUN_140784ea8(param_1 + 2,0xf8);

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        uVar11 = WbVerifyVirtualAddressSignature(param_1[0x29],0xf8,(ulonglong)puVar15 & 0xffffffff)

+        ;

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        uVar11 = WbAllocateUserMemory

+                           (in_stack_00000070,*(undefined4 *)(param_1 + 0x28),&stack0x00000020,

+                            &local_res18);

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        uVar11 = WbAlloc(*(undefined4 *)(param_1 + 0x28),&stack0x00000010);

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        if (*(uint *)((longlong)param_1 + 0x11c) != 0) {

+          uVar6 = param_1[0x22] + (ulonglong)*(uint *)((longlong)param_1 + 0x11c);

+          if ((0x7fffffff0000 < uVar6) || (uVar6 < (ulonglong)param_1[0x22])) {

+            DAT_1 = 0;

+          }

+        }

+        RtlCopyMemory((void *)((ulonglong)*(uint *)(param_1 + 0x24) + (longlong)unaff_RBP),

+                      (void *)param_1[0x22],(ulonglong)*(uint *)((longlong)param_1 + 0x11c));

+        if (*(int *)(param_1 + 1) == (int)puVar15) {

+          if (*(uint *)((longlong)param_1 + 0x11c) < 4) {

+            plVar13 = (longlong *)0xc000000d;

+            goto LAB_0;

+          }

+          *(undefined4 *)((ulonglong)*(uint *)(param_1 + 0x24) + (longlong)unaff_RBP) =

+               *(undefined4 *)((longlong)param_1 + 0x124);

+        }

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

+          plVar13 = (longlong *)0xc000000d;

+          goto LAB_0;

+        }

+        uVar11 = FUN_1407852c0(0,(ulonglong)*(uint *)(param_1 + 0x24) + (longlong)unaff_RBP,

+                               (ulonglong)*(uint *)(param_1 + 0x24) + (longlong)unaff_RBP,

+                               *(undefined4 *)((longlong)param_1 + 0x11c),param_1 + 0xb,

+                               *(undefined4 *)(param_1 + 0x23),param_1 + 0xc);

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        uVar11 = WbVerifyVirtualAddressSignature

+                           (param_1[0x22],*(undefined4 *)((longlong)param_1 + 0x11c),

+                            (ulonglong)puVar15 & 0xffffffff);

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+        uVar6 = param_1[0x25];

+        if (uVar6 != 0) {

+          if ((*(uint *)((longlong)param_1 + 0x134) != 0) &&

+             ((uVar5 = uVar6 + *(uint *)((longlong)param_1 + 0x134), 0x7fffffff0000 < uVar5 ||

+              (uVar5 < uVar6)))) {

+            DAT_1 = 0;

+          }

+          RtlCopyMemory((void *)((ulonglong)*(uint *)(param_1 + 0x27) + (longlong)unaff_RBP),

+                        (void *)param_1[0x25],(ulonglong)*(uint *)((longlong)param_1 + 0x134));

+          if (*(int *)(param_1 + 1) == (int)puVar15) {

+            if (*(uint *)((longlong)param_1 + 0x134) < 4) {

+              plVar13 = (longlong *)0xc000000d;

+              goto LAB_0;

+            }

+            *(undefined4 *)((ulonglong)*(uint *)(param_1 + 0x27) + (longlong)unaff_RBP) =

+                 *(undefined4 *)((longlong)param_1 + 0x13c);

+          }

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

+            plVar13 = (longlong *)0xc000000d;

+            goto LAB_0;

+          }

+          uVar11 = FUN_1407852c0(0,(ulonglong)*(uint *)(param_1 + 0x27) + (longlong)unaff_RBP,

+                                 (ulonglong)*(uint *)(param_1 + 0x27) + (longlong)unaff_RBP,

+                                 *(undefined4 *)((longlong)param_1 + 0x134),param_1 + 0xb,

+                                 *(undefined4 *)(param_1 + 0x26),param_1 + 0xc);

+          plVar13 = (longlong *)(ulonglong)uVar11;

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

+          uVar11 = WbVerifyVirtualAddressSignature

+                             (param_1[0x25],*(undefined4 *)((longlong)param_1 + 0x134),

+                              (ulonglong)puVar15 & 0xffffffff);

+          plVar13 = (longlong *)(ulonglong)uVar11;

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

+        }

+        RtlCopyMemory(unaff_RSI,unaff_RBP,(ulonglong)*(uint *)(param_1 + 0x28));

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

+        plVar13 = (longlong *)(unaff_RBX + 0x28);

+        *plVar13 = (longlong)unaff_RSI;

+        plVar3 = (longlong *)(unaff_RBX + 0x18);

+        *plVar3 = (ulonglong)*(uint *)(param_1 + 0x24) + local_res18;

+        if (*(uint *)(param_1 + 0x27) == 0) {

+          *(undefined8 *)(unaff_RBX + 0x20) = 0;

+        }

+        else {

+          *(ulonglong *)(unaff_RBX + 0x20) = (ulonglong)*(uint *)(param_1 + 0x27) + local_res18;

+        }

+        *(undefined4 *)(unaff_RBX + 0x48) = *(undefined4 *)(param_1 + 0x28);

+        *(undefined8 *)(unaff_RBX + 0x30) = param_1[0x22];

+        lVar12 = param_1[0x22];

+        *(longlong *)(unaff_RBX + 0x38) = lVar12 - *plVar3;

+        if (*(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x580) == 0) {

+LAB_2:

+          *(longlong *)*plVar13 = lVar12 - *plVar3;

+        }

+        else {

+          sVar7 = *(short *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x96c);

+          if ((sVar7 != 0x14c) && (sVar7 != 0x1c4)) {

+            puVar15 = (ulonglong *)0x0;

+          }

+          if ((char)puVar15 == '\0') goto LAB_2;

+          *(undefined8 *)*plVar13 = *(undefined8 *)(unaff_RBX + 0x40);

+        }

+        *(undefined8 *)(*plVar13 + 8) = param_5;

+        uVar11 = ZwFlushInstructionCache

+                           (0xffffffffffffffff,*plVar3,*(undefined4 *)((longlong)param_1 + 0x11c));

+        plVar13 = (longlong *)(ulonglong)uVar11;

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

+          if (param_1[0x25] != 0) {

+            uVar11 = ZwFlushInstructionCache

+                               (0xffffffffffffffff,*(undefined8 *)(unaff_RBX + 0x20),

+                                *(undefined4 *)((longlong)param_1 + 0x134));

+            plVar13 = (longlong *)(ulonglong)uVar11;

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

+          }

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

+            *in_stack_00000080 = unaff_RBX;

+            unaff_RBX = 0;

+          }

+        }

+LAB_0:

+        FUN_140784e48(in_stack_00000070,unaff_RBX);

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

+          ExFreePoolWithTag(unaff_RBP,0);

+        }

+        return plVar13;

+      }

+      *puVar15 = uVar6;

+      *(ulonglong **)(uVar6 + 8) = puVar15;

+      puVar14 = (ulonglong *)0x0;

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

+        *(uint *)(puVar8 + 2) = (uint)puVar8[2] & 0xfffffffe;

+        puVar14 = puVar8;

+      }

+    }

+    LOCK();

+    uVar6 = *puVar2;

+    *puVar2 = *puVar2 - 1;

+    UNLOCK();

+    if (((uVar6 & 2) != 0) && ((uVar6 & 4) == 0)) {

+      ExfTryToWakePushLock(puVar2);

+    }

+    KeAbPostRelease(puVar2);

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

+      local_res18 = 0;

+      iVar10 = FUN_140785bf0(param_1 + 1,puVar14[6],8,0xffffffff,&local_res18);

+      if (-1 < iVar10) {

+        FUN_140784e48(param_1,local_res18);

+      }

+    }

+    LOCK();

+    uVar6 = *puVar1;

+    *puVar1 = *puVar1 - 1;

+    UNLOCK();

+    if (((uVar6 & 2) != 0) && ((uVar6 & 4) == 0)) {

+      ExfTryToWakePushLock(puVar1);

+    }

+    KeAbPostRelease(puVar1);

+    plVar13 = SystemReserved1[0xf];

+    psVar4 = (short *)((longlong)SystemReserved1[0xf] + 0x1e6);

+    *psVar4 = *psVar4 + 1;

+    if ((*psVar4 == 0) &&

+       (plVar13 = (longlong *)((longlong)plVar13 + 0x98), (longlong *)*plVar13 != plVar13)) {

+      plVar13 = (longlong *)KiCheckForKernelApcDelivery();

+    }

+    if ((puVar14 == (ulonglong *)0x0) || (plVar13 = (longlong *)FUN_140784e48(param_1), param_2 < 1)

+       ) {

+      return plVar13;

+    }

+  } while( true );

 }
```

## `HalFreeAdapterObjectV3Internal`  (modified)

```diff
--- HalFreeAdapterObjectV3Internal
+++ IoFreeAdapterChannelV3Internal
@@ -1,15 +1,14 @@
 

-undefined8 HalFreeAdapterObjectV3Internal(undefined8 param_1,longlong param_2,undefined4 param_3)

+void IoFreeAdapterChannelV3Internal(longlong param_1)

 

 {

-  bool in_ZF;

-  

-  if (in_ZF) {

-    *(undefined4 *)(param_2 + 0x14) = 3;

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

+    IoFreeMapRegistersV3(param_1,*(undefined8 *)(param_1 + 0xf0));

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

   }

-  *(undefined4 *)(param_2 + 0xc) = 0xffffffff;

-  *(undefined4 *)(param_2 + 8) = param_3;

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

-  return 0;

+  if ((*(char *)(param_1 + 0x1b9) == '\0') && (*(int *)(param_1 + 0x188) != 0)) {

+    HalpFreeDmaChannels(param_1);

+  }

+  return;

 }
```

## `HalpContinueProcessingWaitQueue`  (modified)

```diff
--- HalpContinueProcessingWaitQueue
+++ IoFreeAdapterChannelV3Internal
@@ -1,14 +1,14 @@
 

-undefined4 HalpContinueProcessingWaitQueue(void)

+void IoFreeAdapterChannelV3Internal(longlong param_1)

 

 {

-  uint in_EAX;

-  undefined4 unaff_EBX;

-  uint in_R9D;

-  

-  wil_details_FeatureReporting_ReportUsageToService

-            (&Feature_Servicing_IommuCustomPassthroughDomainId__private_reporting,0x270d96d,

-             in_EAX >> 8 & 1,in_R9D >> 9 & 1,&Feature_Servicing_SoftParkingSmtPolicy_logged_traits);

-  return unaff_EBX;

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

+    IoFreeMapRegistersV3(param_1,*(undefined8 *)(param_1 + 0xf0));

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

+  }

+  if ((*(char *)(param_1 + 0x1b9) == '\0') && (*(int *)(param_1 + 0x188) != 0)) {

+    HalpFreeDmaChannels(param_1);

+  }

+  return;

 }
```

## `FUN_1408f0d1c`  (modified)

```diff
--- FUN_1408f0d1c
+++ FUN_1408f0b00
@@ -1,125 +1,184 @@
 

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

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

 

-uint FUN_1408f0d1c(longlong param_1)

+ulonglong FUN_1408f0b00(void)

 

 {

-  void *pvVar1;

+  undefined8 *puVar1;

   undefined4 uVar2;

-  int iVar3;

-  ulonglong uVar4;

-  ulonglong uVar5;

-  ulonglong uVar6;

-  int iVar7;

-  uint uVar8;

-  uint unaff_EBX;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  longlong *plVar5;

+  code *pcVar6;

+  short sVar7;

+  undefined4 uVar8;

+  undefined4 uVar9;

+  longlong lVar10;

+  char cVar11;

+  int iVar12;

+  uint uVar13;

+  ulonglong uVar14;

+  short *psVar15;

+  uint *puVar16;

+  longlong lVar17;

+  uint uVar18;

+  undefined8 *unaff_RBX;

   longlong unaff_RBP;

-  int iVar9;

-  int iVar10;

-  int unaff_EDI;

-  int iVar11;

-  byte *pbVar12;

-  longlong lVar13;

-  int iVar14;

-  int iVar15;

-  undefined4 unaff_R13D;

-  longlong lVar16;

-  int iVar17;

-  undefined4 unaff_R15D;

-  bool bVar18;

-  longlong unaff_retaddr;

+  undefined8 *puVar19;

+  longlong *unaff_RDI;

+  longlong unaff_R12;

+  longlong unaff_R13;

+  longlong unaff_R14;

+  short *unaff_R15;

+  undefined4 extraout_XMM0_Da;

+  undefined4 extraout_XMM0_Da_00;

+  undefined4 extraout_XMM0_Da_01;

+  undefined4 uVar20;

+  undefined8 *in_stack_00000040;

   

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

-  iVar9 = unaff_EBX + 0xd;

-  lVar16 = 0x4cb2f;

-  lVar13 = 8;

-  pbVar12 = *(byte **)(unaff_retaddr + 0x48);

   do {

-    lVar16 = (((((((lVar16 * 0x25 + (ulonglong)*pbVar12) * 0x25 + (ulonglong)pbVar12[1]) * 0x25 +

-                 (ulonglong)pbVar12[2]) * 0x25 + (ulonglong)pbVar12[3]) * 0x25 +

-               (ulonglong)pbVar12[4]) * 0x25 + (ulonglong)pbVar12[5]) * 0x25 + (ulonglong)pbVar12[6]

-             ) * 0x25 + (ulonglong)pbVar12[7];

-    lVar13 = lVar13 + -1;

-    pbVar12 = pbVar12 + 8;

-  } while (lVar13 != 0);

-  *(ulonglong *)(unaff_retaddr + 0x40) =

-       (ulonglong)_DAT_0 * _DAT_fffff78000000320 >> 0x18;

-  *(longlong *)(unaff_retaddr + 0x20) = unaff_retaddr + 0x30;

-  *(undefined8 *)(unaff_retaddr + -8) = 0x140791046;

-  MmQueryMemoryListInformation(0xffffffffffffffff,unaff_retaddr + 0x60,0xb0);

-  *(undefined8 *)(unaff_retaddr + -8) = 0x140791055;

-  uVar4 = PfpGetPageListCount(unaff_RBP + -0x38,0,7);

-  *(undefined8 *)(unaff_retaddr + -8) = 0x14079106c;

-  uVar5 = PfpGetPageListCount(unaff_RBP + -0x38,unaff_R13D);

-  *(undefined8 *)(unaff_retaddr + -8) = 0x140791083;

-  uVar6 = PfpGetPageListCount(unaff_RBP + -0x38,unaff_R15D);

-  *(undefined8 *)(unaff_retaddr + -8) = 0x140791098;

-  uVar2 = MmQueryTransitionPagesMadeColdCount();

-  *(undefined4 *)(unaff_retaddr + 0x30) = uVar2;

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

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

-  *(undefined8 *)(unaff_retaddr + -8) = 0x1407910bf;

-  ExAcquireResourceExclusiveLite(&DAT_1,1);

-  *(undefined8 *)(unaff_retaddr + -8) = 0x1407910d8;

-  lVar13 = PfSnPrefetchCacheEntryGet

-                     (&DAT_2,*(undefined8 *)(unaff_retaddr + 0x48),lVar16,

-                      unaff_retaddr + 0x34);

-  iVar10 = unaff_EDI;

-  if (lVar13 == 0) goto LAB_3;

-  iVar11 = (int)*(undefined8 *)(unaff_retaddr + 0x40);

-  iVar15 = (int)((uVar5 & 0xfffffffffffff) >> 6);

-  iVar17 = (int)((uVar6 & 0xfffffffffffff) >> 6);

-  iVar14 = (int)((uVar4 & 0xfffffffffffff) >> 6);

-  if (*(int *)(unaff_retaddr + 0x34) == 0) {

-    uVar8 = iVar11 - *(int *)(lVar13 + 0x70);

-    bVar18 = uVar8 < *(uint *)(lVar13 + 0x74);

-    if (bVar18) {

-      unaff_EBX = unaff_EBX & 0xfffffffe;

+    *(undefined8 *)(unaff_RBP + -0x41) = 0x200000000;

+    uVar20 = 0;

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

+    plVar5 = *(longlong **)(unaff_R13 + 0x20);

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

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

+    if (*plVar5 != unaff_R13 + 0x18) {

+LAB_0:

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

+      (*pcVar6)(3);

+      PfpOpenHandleClose(unaff_RBP + -0x41);

+      return (ulonglong)unaff_RBX & 0xffffffff;

     }

-    iVar10 = bVar18 + 4;

-    if ((unaff_EBX < 2) || (iVar9 = 4, (DAT_5 & 2) != 0)) goto LAB_1407910fc;

-    if (uVar8 < 1800000) {

-      iVar3 = iVar15 - *(int *)(lVar13 + 0x60);

+    *unaff_RDI = unaff_R13 + 0x18;

+    unaff_RDI[1] = (longlong)plVar5;

+    *plVar5 = (longlong)unaff_RDI;

+    *(longlong **)(unaff_R13 + 0x20) = unaff_RDI;

+LAB_1:

+    lVar17 = *(longlong *)(unaff_RBP + 0x7f);

+    uVar13 = *(int *)(unaff_RBP + 0x67) + 1;

+    *(uint *)(unaff_RBP + 0x67) = uVar13;

+    uVar18 = (uint)unaff_RBX;

+    if (*(uint *)(unaff_R14 + 0x70) <= uVar13) {

+      **(uint **)(unaff_RBP + 0x6f) = uVar18;

+      uVar20 = ExFreePoolWithTag(uVar20,0);

+      if ((*(ulonglong *)(unaff_RBP + -0x21) & 0x400000000) != 0) {

+        uVar20 = PfpOpenHandleClose(unaff_RBP + -0x39,*(undefined8 *)(unaff_R13 + 8));

+      }

+      while( true ) {

+        puVar19 = in_stack_00000040;

+        if ((undefined8 **)in_stack_00000040 == &stack0x00000040) {

+          if (unaff_R12 != 0) {

+            uVar20 = ExFreePoolWithTag(uVar20,0);

+          }

+          if (*(longlong *)(unaff_RBP + -0x71) != 0) {

+            uVar20 = NtClose();

+          }

+          PfSnLogOpenVolumesForPrefetch(uVar20,0);

+          return 0;

+        }

+        unaff_RBX = in_stack_00000040;

+        if (((undefined8 **)in_stack_00000040[1] != &stack0x00000040) ||

+           (puVar4 = (undefined8 *)*in_stack_00000040, (undefined8 *)puVar4[1] != in_stack_00000040)

+           ) break;

+        puVar4[1] = &stack0x00000040;

+        if ((in_stack_00000040[5] & 0x400000000) != 0) {

+          puVar1 = in_stack_00000040 + 2;

+          in_stack_00000040 = puVar4;

+          PfpOpenHandleClose(puVar1);

+          puVar4 = in_stack_00000040;

+        }

+        in_stack_00000040 = puVar4;

+        uVar20 = ExFreePoolWithTag(puVar19);

+      }

+      goto LAB_0;

     }

-    else if (uVar8 < 3600000) {

-      iVar3 = iVar17 - *(int *)(lVar13 + 100);

+    unaff_RDI = (longlong *)((ulonglong)uVar13 * 0x70 + *(longlong *)(unaff_R13 + 0x10));

+    puVar16 = (uint *)((ulonglong)uVar13 * 0x60 + lVar17);

+    unaff_RDI[2] = (ulonglong)*puVar16 + lVar17;

+    *(uint *)(unaff_RDI + 3) = puVar16[1];

+    *(undefined4 *)(unaff_RDI + 0xd) = 0;

+    unaff_RDI[0xc] = (ulonglong)puVar16[7] + lVar17;

+    puVar19 = in_stack_00000040;

+    while( true ) {

+      if ((undefined8 **)puVar19 == &stack0x00000040) {

+        uVar14 = FUN_1408f0b00();

+        return uVar14;

+      }

+      uVar2 = *(undefined4 *)((longlong)puVar19 + 0x3c);

+      *(undefined8 *)(unaff_RBP + -0x79) = puVar19[8];

+      cVar11 = PfMetadataRecordIsEqual(uVar20,unaff_RBP + -0x79,uVar2);

+      if (cVar11 != '\0') break;

+      puVar19 = (undefined8 *)*puVar19;

+      uVar20 = extraout_XMM0_Da;

     }

-    else {

-      iVar3 = iVar14 - *(int *)(lVar13 + 0x68);

-    }

-    iVar7 = *(int *)(unaff_retaddr + 0x30);

-    unaff_EDI = iVar9;

-    if ((iVar3 == 0) &&

-       ((*(int *)(unaff_retaddr + 0x38) == 0 || ((uint)(iVar7 - *(int *)(lVar13 + 0x6c)) < 0x100))))

-    {

-      unaff_EBX = unaff_EBX & 0xfffffffd;

-      unaff_EDI = 7;

+    RtlStringCbPrintfW(extraout_XMM0_Da,*(undefined8 *)(unaff_RBP + 0x77),&u__s_,puVar19[6]);

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

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

+    lVar17 = 0x7fff;

+    psVar15 = unaff_R15;

+    do {

+      if (*psVar15 == 0) {

+        *(short **)(unaff_RBP + -0x61) = unaff_R15;

+        sVar7 = (0x7fff - (short)lVar17) * 2;

+        *(short *)(unaff_RBP + -0x69) = sVar7;

+        *(short *)(unaff_RBP + -0x67) = sVar7 + 2;

+        break;

+      }

+      psVar15 = psVar15 + 1;

+      lVar17 = lVar17 + -1;

+    } while (lVar17 != 0);

+    iVar12 = PfpOpenHandleCreate(unaff_RBP + -0x59,*(undefined8 *)(unaff_R13 + 8),unaff_RBP + -0x69,

+                                 0,0x120089);

+  } while (iVar12 < 0);

+  lVar17 = puVar19[3];

+  unaff_RDI[4] = puVar19[2];

+  unaff_RDI[5] = lVar17;

+  lVar17 = puVar19[5];

+  unaff_RDI[6] = puVar19[4];

+  unaff_RDI[7] = lVar17;

+  uVar20 = *(undefined4 *)(unaff_RBP + -0x49);

+  uVar2 = *(undefined4 *)(unaff_RBP + -0x45);

+  uVar8 = *(undefined4 *)(unaff_RBP + -0x41);

+  uVar9 = *(undefined4 *)(unaff_RBP + -0x3d);

+  *(undefined8 *)(unaff_RBP + -0x41) = 0x200000000;

+  puVar19[2] = 0;

+  puVar19[3] = 0;

+  puVar19[4] = 0;

+  puVar19[5] = 0;

+  puVar19[5] = puVar19[5] | 0x200000000;

+  lVar17 = *(longlong *)(unaff_RBP + -0x59);

+  lVar10 = *(longlong *)(unaff_RBP + -0x51);

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

+  unaff_RDI[8] = lVar17;

+  unaff_RDI[9] = lVar10;

+  *(undefined4 *)(unaff_RDI + 10) = uVar20;

+  *(undefined4 *)((longlong)unaff_RDI + 0x54) = uVar2;

+  *(undefined4 *)(unaff_RDI + 0xb) = uVar8;

+  *(undefined4 *)((longlong)unaff_RDI + 0x5c) = uVar9;

+  plVar5 = *(longlong **)(unaff_R13 + 0x30);

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

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

+  if (*plVar5 != unaff_R13 + 0x28) goto LAB_0;

+  *unaff_RDI = unaff_R13 + 0x28;

+  unaff_RDI[1] = (longlong)plVar5;

+  *plVar5 = (longlong)unaff_RDI;

+  uVar3 = *(undefined8 *)(unaff_RBP + -0x71);

+  *(longlong **)(unaff_R13 + 0x30) = unaff_RDI;

+  uVar13 = PfSnVolumeCheckSeekPenalty(unaff_RDI + 4,uVar3);

+  *(uint *)((longlong)unaff_RDI + 0x6c) =

+       *(uint *)((longlong)unaff_RDI + 0x6c) ^ (uVar13 ^ *(uint *)((longlong)unaff_RDI + 0x6c)) & 1;

+  uVar20 = extraout_XMM0_Da_00;

+  if ((*(uint *)((longlong)unaff_RDI + 0x6c) & 1) == 0) {

+    if ((((ulonglong)unaff_RBX & 3) == 0) &&

+       (iVar12 = PfSnVolumeCheckIsSdBus(unaff_RDI + 4,*(undefined8 *)(unaff_RBP + -0x71)),

+       uVar20 = extraout_XMM0_Da_01, iVar12 == 0)) {

+      unaff_RBX = (undefined8 *)(ulonglong)(uVar18 | 2);

     }

   }

   else {

-    iVar10 = 0xd;

-    if (1 < unaff_EBX) {

-      iVar9 = 0xd;

-    }

-LAB_4:

-    iVar7 = *(int *)(unaff_retaddr + 0x30);

-    unaff_EDI = iVar9;

+    unaff_RBX = (undefined8 *)(ulonglong)(uVar18 | 1);

   }

-  *(int *)(lVar13 + 0x70) = iVar11;

-  *(int *)(lVar13 + 0x60) = iVar15;

-  *(int *)(lVar13 + 100) = iVar17;

-  *(int *)(lVar13 + 0x68) = iVar14;

-  *(int *)(lVar13 + 0x6c) = iVar7;

-LAB_3:

-  *(undefined8 *)(unaff_retaddr + -8) = 0x14079111f;

-  ExReleaseResourceLite(&DAT_1);

-  pvVar1 = SystemReserved1[0xf];

-  *(undefined8 *)(unaff_retaddr + -8) = 0x14079112d;

-  KiLeaveCriticalRegionUnsafe(pvVar1);

-  **(int **)(unaff_retaddr + 0x50) = iVar10;

-  **(int **)(unaff_retaddr + 0x58) = unaff_EDI;

-  *(undefined8 *)(unaff_retaddr + -8) = 0x140791149;

-  return unaff_EBX;

+  goto LAB_1;

 }
```

## `ObReferenceObjectByNameEx`  (modified)

```diff
--- ObReferenceObjectByNameEx
+++ CmObReferenceObjectByName
@@ -1,17 +1,46 @@
 

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

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

 

-void ObReferenceObjectByNameEx(char *param_1,undefined2 param_2)

+int CmObReferenceObjectByName(undefined8 param_1)

 

 {

-  char in_AL;

-  undefined6 in_register_00000002;

-  undefined2 in_ES;

+  undefined8 uVar1;

+  int iVar2;

+  int *piVar3;

+  undefined1 in_stack_00000028;

+  undefined8 *in_stack_00000030;

+  undefined1 auStack_198 [32];

+  undefined1 local_178;

+  undefined1 *local_170;

+  int **local_168;

+  int *local_158 [2];

+  undefined1 local_148 [304];

+  ulonglong local_18;

   

-  out(uRam0000000000000000,param_2);

-  *param_1 = *param_1 + (char)((ushort)param_2 >> 8);

-  *(undefined2 *)CONCAT62(in_register_00000002,(short)in_AL * (short)cRam0000000000000001) = in_ES;

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

-  halt_baddata();

+  uVar1 = CmKeyObjectType;

+  local_18 = __security_cookie ^ (ulonglong)auStack_198;

+  memset(local_148,0,0x128);

+  local_158[0] = (int *)0x0;

+  CmpInitializeParseContext(local_148);

+  local_168 = local_158;

+  local_170 = local_148;

+  local_178 = in_stack_00000028;

+  iVar2 = ObReferenceObjectByNameEx(param_1,0,0x10,uVar1);

+  piVar3 = local_158[0];

+  if (-1 < iVar2) {

+    if (*local_158[0] == 0x6b793032) {

+      *in_stack_00000030 = local_158[0];

+      piVar3 = (int *)0x0;

+      iVar2 = 0;

+    }

+    else {

+      iVar2 = -0x3ffffff8;

+    }

+  }

+  if (piVar3 != (int *)0x0) {

+    ObfDereferenceObject();

+  }

+  CmpCleanupParseContext(local_148,0);

+  return iVar2;

 }
```
