# CVE-2026-94522 — ntoskrnl.exe patch diff

`ntoskrnl.exe` 10.0.26100.9711 -> 10.0.26100.9974 (ghidriff).

## `PspGetMemoryPartitionImplicit`  (modified)

```diff
--- PspGetMemoryPartitionImplicit
+++ PspGetMemoryPartitionImplicit
@@ -1,10 +1,50 @@
 

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

-

-void PspGetMemoryPartitionImplicit(void)

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

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  void *pvVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  

+  uVar4 = 0;

+  *param_3 = 0;

+  pvVar2 = SystemReserved1[0xf];

+  PspLockJobChain(param_1,SystemReserved1[0xf],0);

+  lVar3 = param_1;

+  if ((param_2 >> 10 & 1) == 0) {

+    for (; lVar3 != 0; lVar3 = *(longlong *)(lVar3 + 0x518)) {

+      if ((*(uint *)(lVar3 + 0x100) >> 0xc & 1) == 0) {

+        if ((param_2 & 1) == 0) goto LAB_0;

+        if ((*(uint *)(lVar3 + 0x100) >> 0xb & 1) == 0) goto LAB_1;

+      }

+    }

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

+LAB_1:

+      if ((lVar3 == param_1) && ((*(uint *)(lVar3 + 0x610) & 0x40000000) == 0)) {

+        uVar4 = 0xc0000022;

+        goto LAB_2;

+      }

+    }

+  }

+  else {

+    lVar3 = PsGetEffectiveServerSilo(param_1);

+  }

+LAB_0:

+  if (lVar3 != 0) {

+    lVar1 = *(longlong *)(lVar3 + 0x700);

+    if (lVar1 == -1) {

+      uVar4 = 0xc0000476;

+    }

+    else {

+      if (lVar1 != 0) {

+        ObfReferenceObjectWithTag(lVar1,0x624a7350);

+      }

+      *param_3 = *(undefined8 *)(lVar3 + 0x700);

+    }

+  }

+LAB_2:

+  PspUnlockJobChain(param_1,pvVar2);

+  return uVar4;

 }
```

## `FsRtlpCancelExclusiveIrp`  (modified)

```diff
--- FsRtlpCancelExclusiveIrp
+++ FsRtlpCancelExclusiveIrp
@@ -1,13 +1,41 @@
 

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

-

-void FsRtlpCancelExclusiveIrp(void)

+void FsRtlpCancelExclusiveIrp(longlong param_1,char param_2,char param_3)

 

 {

-  longlong in_RAX;

+  longlong *plVar1;

   

-  *(undefined1 *)(in_RAX + -0x3f) = *(undefined1 *)(in_RAX + -0x3f);

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

-  halt_baddata();

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

+  LOCK();

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

+  UNLOCK();

+  KeReleaseQueuedSpinLock(7,*(undefined1 *)(param_1 + 0x45));

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

+    ExAcquireFastMutex(plVar1[0x13]);

+  }

+  if ((*plVar1 != 0) && (*(char *)(*plVar1 + 0x44) != '\0')) {

+    FsRtlpModifyThreadPriorities(plVar1,0,0);

+    FsRtlpClearOwner(plVar1,0);

+    *(undefined1 *)(plVar1 + 4) = 0;

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

+      *(undefined8 *)(*plVar1 + 0x38) = 0;

+    }

+    *(undefined4 *)(*plVar1 + 0x30) = 0xc0000120;

+    IofCompleteRequest(*plVar1,1);

+    *plVar1 = 0;

+    ObfDereferenceObjectWithTag(plVar1[1],0x746c6644);

+    plVar1[1] = 0;

+    *(uint *)(plVar1 + 0x12) = *(uint *)(plVar1 + 0x12) & 0x20 | 1;

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

+      FsRtlpSyncWithAckTimeout(plVar1 + 0x16);

+      FsRtlpOplockPerfSendData(plVar1 + 0x14);

+      while ((longlong *)plVar1[0xb] != plVar1 + 0xb) {

+        FsRtlpRemoveAndCompleteWaitingIrp();

+      }

+    }

+  }

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

+    ExReleaseFastMutex(plVar1[0x13]);

+  }

+  return;

 }
```

## `PopThermalSxExit`  (modified)

```diff
--- PopThermalSxExit
+++ PopThermalSxExit
@@ -1,12 +1,66 @@
 

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

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

 

-void PopThermalSxExit(byte param_1,longlong param_2)

+void PopThermalSxExit(void)

 

 {

-  in((short)param_2);

-  *(byte *)(param_2 + 0xd8d48d9) = *(byte *)(param_2 + 0xd8d48d9) ^ param_1;

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

-  halt_baddata();

+  undefined8 uVar1;

+  undefined1 uVar2;

+  int iVar3;

+  undefined8 *puVar4;

+  bool bVar5;

+  

+  iVar3 = PopThermalStateTransitionInProgress;

+  LOCK();

+  PopThermalStateTransitionInProgress = 0;

+  UNLOCK();

+  bVar5 = false;

+  if (iVar3 != 0) {

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

+      PopAcquireRwLockExclusive(&PopThermalStateTransitionContext);

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

+        DAT_0 = '\0';

+        iVar3 = Feature_Servicing_ThermalSxExitRereadZones__private_IsEnabledDeviceUsageNoInline();

+        bVar5 = iVar3 != 0;

+        if (bVar5) {

+          DAT_1 = '\0';

+          DAT_2 = '\0';

+        }

+        ZwUpdateWnfStateData(&WNF_PO_THERMAL_HIBERNATE_OCCURRED,0,0,0,0,0,0);

+      }

+      PopReleaseRwLock(&PopThermalStateTransitionContext);

+      uVar2 = KeAcquireSpinLockRaiseToDpc(&PopThermalEventTransitionContext);

+      DAT_3 = 0xffffffff;

+      DAT_4 = 1;

+      KeReleaseSpinLock(&PopThermalEventTransitionContext,uVar2);

+    }

+    PopAcquireRwLockShared(&PopPolicyDeviceLock);

+    puVar4 = PopThermal;

+    if ((undefined8 **)PopThermal != &PopThermal) {

+      do {

+        PopAcquireRwLockExclusive(puVar4 + 0x36);

+        uVar1 = _DAT_5;

+        puVar4[0x40] = _DAT_5;

+        puVar4[0x41] = uVar1;

+        *(undefined1 *)(puVar4 + 0x3f) = 0;

+        iVar3 = Feature_Servicing_ThermalSxExitRereadZones__private_IsEnabledDeviceUsageNoInline();

+        if ((iVar3 != 0) && (bVar5)) {

+          IoCancelIrp(puVar4[7]);

+        }

+        PopReleaseRwLock(puVar4 + 0x36);

+        puVar4 = (undefined8 *)*puVar4;

+      } while ((undefined8 **)puVar4 != &PopThermal);

+    }

+    PopReleaseRwLock(&PopPolicyDeviceLock);

+    PopCoolingSxTransition(0);

+    PopPowerLimitSxTransition(0);

+    PopAcquireRwLockExclusive(&PopThermalStateTransitionContext);

+    DAT_6 = 1;

+    if ((DAT_1 != '\0') || (DAT_140f0ad93 != '\0')) {

+      PopQueueWorkItem(&PopThermalStateTransitionWorkItem,1);

+    }

+    PopReleaseRwLock(&PopThermalStateTransitionContext);

+  }

+  return;

 }
```

## `FsRtlCheckOplockEx2`  (modified)

```diff
--- FsRtlCheckOplockEx2
+++ FsRtlCheckOplockEx2
@@ -1,55 +1,620 @@
 

-uint FsRtlCheckOplockEx2(undefined8 param_1,int param_2)

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

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

+

+ulonglong FsRtlCheckOplockEx2(longlong *param_1,longlong param_2,ulonglong param_3,int param_4,

+                             char *param_5,byte *param_6,undefined8 param_7,char *param_8,

+                             byte *param_9,undefined8 param_10)

 

 {

-  uint uVar1;

-  uint uVar2;

-  undefined8 *puVar3;

-  ulonglong unaff_RSI;

-  char unaff_DIL;

-  char in_R10B;

-  ulonglong in_R11;

-  longlong unaff_R13;

-  int unaff_R14D;

-  bool in_ZF;

-  undefined8 in_CR8;

-  uint uStack0000000000000040;

-  int iStack0000000000000044;

+  byte *pbVar1;

+  byte bVar2;

+  uint uVar3;

+  longlong lVar4;

+  uint *puVar5;

+  longlong *plVar6;

+  code *pcVar7;

+  byte *pbVar8;

+  char cVar9;

+  byte bVar10;

+  int iVar11;

+  uint uVar12;

+  uint uVar13;

+  ulonglong uVar14;

+  uint uVar15;

+  ulonglong uVar16;

+  uint uVar17;

+  byte *pbVar18;

+  uint *unaff_R14;

+  void *pvVar19;

+  char *pcVar20;

+  longlong lVar21;

+  bool bVar22;

+  undefined *apuStack_1f8 [4];

+  undefined8 local_1d8;

+  char *local_1d0;

+  byte *local_1c8;

+  undefined8 local_1c0;

+  undefined8 local_1b8;

+  byte *local_1b0;

+  undefined8 local_1a8;

+  char *local_1a0;

+  byte *local_198;

+  undefined8 local_190;

+  char *local_188;

+  byte *local_180;

+  byte local_178;

+  uint local_174;

+  char local_170;

+  byte local_16f;

+  bool local_16e;

+  byte local_16d;

+  uint local_16c;

+  uint local_168;

+  uint local_164;

+  char local_160;

+  char local_15f;

+  byte *local_158;

+  uint local_150;

+  undefined8 local_148;

+  char *local_140;

+  byte *local_138;

+  int local_130;

+  uint local_128;

+  uint local_120;

+  uint local_11c;

+  undefined8 local_118;

+  byte *local_110;

+  undefined8 local_108;

+  undefined4 local_100 [2];

+  longlong local_f8;

+  ulonglong local_f0;

+  ulonglong local_e8;

+  void *local_e0;

+  longlong local_d8;

+  longlong local_d0;

+  longlong local_c8;

+  undefined4 local_c0;

+  undefined4 uStack_bc;

+  undefined4 uStack_b8;

+  undefined4 uStack_b4;

+  char local_a8 [32];

+  uint *local_88;

+  undefined8 local_80;

+  undefined4 *local_78;

+  undefined8 local_70;

+  longlong *local_68;

+  undefined8 local_60;

+  byte **local_58;

+  undefined8 local_50;

+  ulonglong local_48;

   

-  if (!in_ZF) {

-    unaff_R14D = (int)unaff_R13;

+                    /* 0x3c8360  487  FsRtlCheckOplockEx2 */

+  local_48 = __security_cookie ^ (ulonglong)apuStack_1f8;

+  uVar17 = (uint)param_3;

+  local_140 = param_5;

+  local_158 = param_6;

+  local_108 = param_7;

+  local_110 = param_9;

+  local_118 = param_10;

+  uVar12 = 0;

+  local_164 = 0;

+  lVar21 = *param_1;

+  if (param_4 != 0) {

+    return 0xc000000d;

   }

-  func_0x00014039ba80();

-  if (iStack0000000000000044 == 3) {

-    func_0x00014039bbfc(in_R11 & 0xffffffff);

-    puVar3 = DAT_0;

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

-      if (unaff_RSI < (ulonglong)puVar3[3]) {

-        puVar3 = (undefined8 *)*puVar3;

+  pbVar18 = *(byte **)(param_2 + 0xb8);

+  local_138 = pbVar18;

+  local_130 = param_4;

+  local_128 = uVar17;

+  if ((param_3 & 4) != 0) {

+    local_158 = (byte *)0x0;

+    if (lVar21 == 0) {

+      return 0;

+    }

+    ExAcquireFastMutexUnsafe(*(undefined8 *)(lVar21 + 0x98));

+    if (*pbVar18 == 0) {

+      if (((*(uint *)(lVar21 + 0x90) & 0x10000) != 0) &&

+         (cVar9 = FsRtlpCallerIsAtomicRequestor(lVar21,*(undefined8 *)(pbVar18 + 0x30),&local_158),

+         pbVar8 = local_158, cVar9 != '\0')) {

+        FsRtlpOplockDequeueRH(local_158);

+        pbVar1 = pbVar8 + 0x38;

+        lVar4 = *(longlong *)pbVar1;

+        plVar6 = *(longlong **)(pbVar8 + 0x40);

+        if ((*(byte **)(lVar4 + 8) != pbVar1) || ((byte *)*plVar6 != pbVar1)) {

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

+          (*pcVar7)(3);

+          while( true ) {

+            local_1a8 = 0;

+            bVar10 = *pbVar18;

+            do {

+              LOCK();

+              bVar2 = *pbVar18;

+              bVar22 = bVar10 == bVar2;

+              if (bVar22) {

+                *pbVar18 = bVar10 | 1;

+                bVar2 = bVar10;

+              }

+              bVar10 = bVar2;

+              UNLOCK();

+            } while (!bVar22);

+            if ((bVar10 & 1) == 0) break;

+            while( true ) {

+              do {

+                do {

+                  local_1d0 = (char *)0x0;

+                  apuStack_1f8[0] = (undefined *)0x1403cc6c2;

+                  uVar14 = KeWaitForMutexObject(lVar21 + 0x18,0x1b,0);

+                  if ((int)uVar14 != 0x102) {

+                    return uVar14;

+                  }

+                  iVar11 = (int)local_1c0 + 1;

+                  local_1c0 = CONCAT44(local_1c0._4_4_,iVar11);

+                  local_1b8 = (char *)CONCAT44(iVar11,(undefined4)local_1b8);

+                  if ((DAT_0 & 0x20000) != 0) {

+                    apuStack_1f8[0] = (undefined *)0x1403cc772;

+                    PerfLogExecutiveResourceWait(local_130,0);

+                  }

+                } while ((*pbVar8 & 1) != 0);

+                uVar12 = *unaff_R14;

+                if (*unaff_R14 == 0xffffffff) {

+                  uVar12 = ExResourceTimeoutCount;

+                }

+                local_1c0 = CONCAT44(uVar12,(int)local_1c0);

+              } while (uVar12 == 0);

+              local_128 = local_128 + 1;

+              if (uVar12 < local_128) break;

+              _DAT_1 = ExpTimeout;

+            }

+          }

+          local_128 = 0;

+          local_1b8 = (char *)((ulonglong)local_1b8 & 0xffffffff00000000);

+                    /* WARNING: Subroutine does not return */

+          apuStack_1f8[0] = &UNK_2;

+          DbgPrintEx(0,0,"Possible deadlock. Use !locks %p to determine the resource owner\n",0);

+        }

+        *plVar6 = lVar4;

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

+        if (*(longlong **)(lVar21 + 0x78) == (longlong *)(lVar21 + 0x78)) {

+          *(uint *)(lVar21 + 0x90) = *(uint *)(lVar21 + 0x90) & 0xfffcffff;

+        }

+        if (*(longlong *)(pbVar8 + 0x28) != 0) {

+          FsRtlpClearOwner(lVar21,pbVar8);

+        }

+        FsRtlpFreeRHOpContext(pbVar8,1);

+        FsRtlpComputeShareableOplockState(lVar21);

+        FsRtlpReleaseIrpsWaitingForRH(lVar21);

+      }

+      ExReleaseFastMutexUnsafe(*(undefined8 *)(lVar21 + 0x98));

+      return 0;

+    }

+    ExReleaseFastMutexUnsafe(*(undefined8 *)(lVar21 + 0x98));

+    return 0xc000000d;

+  }

+  uVar13 = local_164;

+  if ((((uVar17 >> 0x1c & 1) == 0) && (uVar13 = uVar12, *pbVar18 == 0)) &&

+     ((*(longlong *)(*(longlong *)(pbVar18 + 0x30) + 0xd0) == 0 ||

+      ((lVar4 = *(longlong *)(*(longlong *)(*(longlong *)(pbVar18 + 0x30) + 0xd0) + 0x38),

+       lVar4 == 0 || ((*(byte *)(lVar4 + 2) & 3) == 0)))))) {

+    local_148 = 0;

+    local_f8 = 0;

+    FsRtlGetEcpListFromIrp(param_2,&local_f8);

+    lVar4 = local_f8;

+    pbVar18 = local_138;

+    if (local_f8 != 0) {

+      local_c0 = 0x41621a14;

+      uStack_bc = 0x4df1b08b;

+      uStack_b8 = 0x5fa076b6;

+      uStack_b4 = 0xea1bf0fd;

+      iVar11 = FsRtlFindExtraCreateParameter(local_f8,&local_c0,&local_148,0);

+      if (iVar11 == 0) {

+        local_168 = 2;

       }

       else {

-        if (unaff_RSI < puVar3[3] + 0x200) break;

-        puVar3 = (undefined8 *)puVar3[1];

-      }

-    }

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

-      if (param_2 != 0x10) {

-                    /* WARNING: Subroutine does not return */

-        KeBugCheckEx(0x1a,0x61949);

-      }

-      uStack0000000000000040 = 3;

-    }

-    else {

-      uVar2 = ((int)(unaff_R13 << (DAT_1 - 0xcU & 0x3f)) - (int)unaff_R13 & (uint)unaff_RSI)

-              - *(int *)(puVar3 + 3);

-      uVar1 = *(uint *)((longlong)puVar3 + (ulonglong)((uVar2 & 0x7fffffff) >> 4) * 4 + 0x2c);

-      func_0x00014039bb50(unaff_DIL,unaff_R14D);

-      uStack0000000000000040 = uVar1 >> ((char)uVar2 * '\x02' & 0x1fU) & 3;

+        local_c0 = 0x48850596;

+        uStack_bc = 0x4be73050;

+        uStack_b8 = 0xc3fe6398;

+        uStack_b4 = 0x7f8dce50;

+        iVar11 = FsRtlRemoveExtraCreateParameter(lVar4,&local_c0,&local_148,0);

+        pbVar18 = local_138;

+        if (iVar11 != 0) goto LAB_3;

+        local_168 = 1;

+      }

+      pbVar18 = local_138;

+      uVar13 = IoSetOplockKeyContext(*(undefined8 *)(local_138 + 0x30),local_148,local_168);

+      if ((short)local_168 == 1) {

+        FsRtlFreeExtraCreateParameter(local_148);

+        if (uVar13 == 0xc0000001) {

+          uVar13 = uVar12;

+        }

+      }

+      else {

+        if ((short)local_168 == 2) {

+          FsRtlAcknowledgeEcp(local_148);

+        }

+        if (uVar13 == 0xc0000001) {

+          uVar13 = uVar12;

+        }

+      }

     }

   }

-  else if ((unaff_DIL != in_R10B) && (KiIrqlFlags != 0)) {

-    KiLowerIrqlProcessIrqlFlags(in_CR8,unaff_DIL);

+LAB_3:

+  local_164 = uVar13;

+  FsRtlpOplockStoreKeyForDeleteOperation(param_1,param_2,param_3 & 0xffffffff);

+  if (lVar21 != *param_1) {

+    lVar21 = *param_1;

   }

-  return uStack0000000000000040;

+  if (((((param_3 & 2) == 0) && (lVar21 != 0)) && ((*(uint *)(param_2 + 0x10) & 2) == 0)) &&

+     (local_164 == 0)) {

+    uVar14 = param_3 >> 0x1d & 1;

+    local_170 = (char)uVar14;

+    uVar16 = CONCAT71((int7)((ulonglong)param_1 >> 8),1);

+    local_168 = (uint)uVar16;

+    local_16f = 1;

+    local_d0 = lVar21;

+    do {

+      pvVar19 = SystemReserved1[0xf];

+      local_16d = 0;

+      local_120 = uVar17 & 0x10;

+      if (((param_3 & 0x10) == 0) && (local_170 == '\0')) {

+        local_150 = *(uint *)(lVar21 + 0x90);

+        local_c8 = *(longlong *)(lVar21 + 8);

+        bVar10 = *pbVar18;

+        uVar14 = (ulonglong)local_150;

+        if (bVar10 == 3) {

+          uVar16 = (ulonglong)local_16f;

+          if ((local_150 & 0xffff4ffe) == 0) {

+            uVar16 = 0;

+          }

+          local_16f = (byte)uVar16;

+        }

+        else {

+          uVar16 = (ulonglong)local_16f;

+        }

+        local_168 = (uint)uVar16;

+        if (bVar10 == 4) {

+          uVar14 = uVar16;

+          if ((local_150 & 0xffffdffe) == 0) {

+            uVar14 = 0;

+          }

+          local_16f = (byte)uVar14;

+          local_168 = (uint)uVar14;

+          uVar16 = uVar14;

+        }

+        if ((((param_3 & 8) != 0) || (bVar10 == 0x12)) ||

+           ((local_c8 == 0 || (local_c8 != *(longlong *)(pbVar18 + 0x30))))) goto LAB_4;

+        uVar16 = 0;

+        local_168 = 0;

+        local_16f = 0;

+        goto LAB_5;

+      }

+LAB_4:

+      if ((char)uVar16 == '\0') goto LAB_5;

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

+        puVar5 = *(uint **)(lVar21 + 0x98);

+        local_e0 = SystemReserved1[0xf];

+        uVar14 = KeAbPreAcquire(puVar5,0,0);

+        LOCK();

+        uVar12 = *puVar5;

+        *puVar5 = *puVar5 & 0xfffffffe;

+        UNLOCK();

+        local_e8 = uVar14;

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

+          puVar5[4] = puVar5[4] + 1;

+          local_168 = 4;

+          local_f0 = uVar14;

+          uVar12 = 1;

+          uVar16 = uVar14;

+          do {

+            uVar14 = (ulonglong)*puVar5;

+            do {

+              while (uVar13 = (uint)uVar14, (uVar14 & 1) != 0) {

+                LOCK();

+                uVar15 = *puVar5;

+                if (uVar13 == uVar15) {

+                  *puVar5 = uVar13 ^ uVar12;

+                }

+                else {

+                  uVar14 = (ulonglong)uVar15;

+                }

+                UNLOCK();

+                pvVar19 = local_e0;

+                if (uVar13 == uVar15) goto LAB_6;

+              }

+              LOCK();

+              uVar15 = *puVar5;

+              if (uVar13 == uVar15) {

+                *puVar5 = local_168 + uVar13;

+              }

+              else {

+                uVar14 = (ulonglong)uVar15;

+              }

+              UNLOCK();

+            } while (uVar13 != uVar15);

+            if (uVar16 != 0) {

+              KeAbPreWait(uVar16);

+            }

+            local_1d8 = 0;

+            KeWaitForMutexObject(puVar5 + 6,0x22,0);

+            local_174 = 3;

+            local_168 = 2;

+            uVar12 = 3;

+            if (uVar16 != 0) {

+              local_f0 = KeAbPreAcquire(puVar5,uVar16);

+              uVar12 = local_174;

+              uVar16 = local_f0;

+            }

+          } while( true );

+        }

+LAB_6:

+        if (local_e8 != 0) {

+          *(undefined1 *)(local_e8 + 10) = 1;

+        }

+        *(void **)(puVar5 + 2) = pvVar19;

+        uVar16 = (ulonglong)local_16f;

+        local_168 = (uint)local_16f;

+      }

+      local_170 = '\x01';

+      uVar12 = *(uint *)(lVar21 + 0x90);

+      if (uVar12 == 1) goto LAB_5;

+      uVar14 = uVar14 & 0xffffffffffffff00;

+      local_174 = (uint)uVar14;

+      local_16e = false;

+      local_178 = 0;

+      uVar13 = 0;

+      local_16c = 0;

+      if (local_120 != 0) {

+        uVar15 = 0x5000;

+        local_16c = 0x5000;

+        goto LAB_7;

+      }

+      uVar14 = (ulonglong)*pbVar18;

+      cVar9 = '\0';

+      if (*pbVar18 == 3) {

+        local_16e = (uVar12 & 8) == 0;

+        local_16c = 0x4000;

+        uVar12 = (uint)local_16e;

+LAB_8:

+        cVar9 = (char)uVar12;

+        goto LAB_9;

+      }

+      uVar15 = 0;

+      switch(uVar14) {

+      case 0:

+        if ((((((uVar12 & 0x7000) == 0) ||

+              ((*(uint *)(*(longlong *)(pbVar18 + 8) + 0x10) & 0xffedfe7f) == 0)) &&

+             (((uVar12 & 0x1e) == 0 ||

+              ((*(uint *)(*(longlong *)(pbVar18 + 8) + 0x10) & 0xffeffe7f) == 0)))) &&

+            (uVar15 = uVar13, (*(uint *)(pbVar18 + 0x10) >> 0x14 & 1) == 0)) ||

+           ((((uVar12 & 8) != 0 &&

+             ((*(uint *)(*(longlong *)(pbVar18 + 8) + 0x10) & 0xffedfe56) == 0)) &&

+            (uVar15 = uVar13, (pbVar18[0x1a] & 1) != 0)))) goto switchD_1403c8a0b_default;

+        uVar14 = 0;

+        if (((pbVar18[0x13] & 0xfa) != 0) || (pbVar18[0x13] == 1)) {

+          uVar12 = *(uint *)(pbVar18 + 0x10);

+          uVar14 = (ulonglong)uVar12;

+          if ((uVar12 >> 0x14 & 1) == 0) {

+            local_174 = (uint)CONCAT71((uint7)(uint3)(uVar12 >> 8),1);

+LAB_10:

+            local_16e = SUB41(local_174,0);

+            uVar15 = 0x4000;

+            local_16c = uVar15;

+            goto switchD_1403c8a0b_default;

+          }

+        }

+        break;

+      case 1:

+      case 3:

+      case 5:

+      case 7:

+      case 8:

+      case 10:

+      case 0xb:

+      case 0xc:

+      case 0xe:

+      case 0xf:

+      case 0x10:

+      case 0x13:

+      case 0x14:

+        goto LAB_9;

+      case 2:

+        uVar15 = uVar13;

+        if ((*(uint *)(*(longlong *)(pbVar18 + 0x30) + 0x50) & 0x4000) == 0)

+        goto switchD_1403c8a0b_caseD_12;

+      default:

+switchD_1403c8a0b_default:

+        uVar14 = (ulonglong)local_178;

+LAB_7:

+        cVar9 = (char)local_174;

+        goto LAB_11;

+      case 4:

+        break;

+      case 6:

+        if (*(int *)(pbVar18 + 0x10) == 0x14) {

+          bVar22 = pbVar18[0x21] == 0;

+          uVar14 = 0;

+          goto LAB_12;

+        }

+        uVar14 = 0;

+        uVar15 = uVar13;

+        switch(*(int *)(pbVar18 + 0x10)) {

+        case 10:

+        case 0xb:

+        case 0x28:

+        case 0x41:

+switchD_1403c8b40_caseD_a:

+          uVar15 = 0x2000;

+          local_16c = 0x2000;

+          cVar9 = (char)local_174;

+          if ((uVar12 & 0xc) == 0) goto LAB_9;

+          uVar14 = CONCAT71((int7)(uVar14 >> 8),1);

+          local_178 = 1;

+          goto LAB_11;

+        default:

+          goto switchD_1403c8a0b_default;

+        case 0xd:

+          bVar22 = **(char **)(param_2 + 0x18) == '\0';

+          break;

+        case 0x13:

+        case 0x27:

+          goto switchD_1403c8a0b_caseD_4;

+        case 0x40:

+          bVar22 = (**(uint **)(param_2 + 0x18) & 1) == 0;

+        }

+        if (!bVar22) {

+          local_16c = 0x2000;

+          uVar12 = local_174;

+          goto LAB_8;

+        }

+LAB_9:

+        uVar14 = (ulonglong)local_178;

+        uVar15 = local_16c;

+        goto LAB_11;

+      case 9:

+        cVar9 = '\x01';

+        local_16e = true;

+        uVar15 = 0x4000;

+        local_16c = 0x4000;

+        uVar14 = 0;

+        goto LAB_11;

+      case 0xd:

+        uVar3 = *(uint *)(pbVar18 + 0x18);

+        uVar14 = (ulonglong)uVar3;

+        if (uVar3 < 0x98269) {

+          if (uVar3 != 0x98268) {

+            if (uVar3 == 0x900fc) {

+              uVar14 = FsRtlGetMarkHandleInfo(param_2);

+              uVar15 = uVar13;

+              if (((uint)uVar14 >> 0xe & 1) != 0) goto switchD_1403c8b40_caseD_a;

+            }

+            else {

+              if (uVar3 == 0x94264) {

+                local_174 = (uint)((uVar12 & 8) == 0);

+                goto LAB_10;

+              }

+              if ((uVar3 == 0x980c8) || (uVar15 = uVar13, uVar3 == 0x98208)) break;

+            }

+            goto switchD_1403c8a0b_default;

+          }

+        }

+        else if ((uVar3 != 0x98344) && (uVar3 != 0x983e8)) {

+          bVar22 = uVar3 == 0x9c2b4;

+          goto LAB_12;

+        }

+        break;

+      case 0x11:

+        bVar22 = (uVar12 & 8) == 0;

+LAB_12:

+        uVar15 = uVar13;

+        if (!bVar22) goto switchD_1403c8a0b_default;

+        break;

+      case 0x12:

+switchD_1403c8a0b_caseD_12:

+        FsRtlpOplockCleanup(lVar21,pbVar18,0);

+        uVar15 = uVar13;

+        if ((*pbVar18 == 0x12) && ((param_3 & 0x20) != 0)) {

+          local_16c = 0x2000;

+          uVar15 = 0x2000;

+          if (5 < DAT_13) {

+            local_88 = &local_11c;

+            local_80 = 4;

+            local_100[0] = 0x2000;

+            local_78 = local_100;

+            local_70 = 4;

+            local_68 = &local_d8;

+            local_60 = 8;

+            local_138 = (byte *)CONCAT44(local_138._4_4_,*(undefined4 *)(lVar21 + 0x90));

+            local_58 = &local_138;

+            local_50 = 4;

+            local_1d0 = local_a8;

+            local_1d8 = CONCAT44(local_1d8._4_4_,6);

+            local_11c = uVar17;

+            local_d8 = lVar21;

+            _tlgWriteTransfer_EtwWriteTransfer(&DAT_13,&DAT_140045165,0,0);

+          }

+        }

+        goto switchD_1403c8a0b_default;

+      case 0x15:

+        uVar15 = 0x2000;

+        local_16c = uVar15;

+        goto switchD_1403c8a0b_default;

+      }

+switchD_1403c8a0b_caseD_4:

+      uVar14 = CONCAT71((int7)(uVar14 >> 8),1);

+      local_178 = 1;

+      uVar15 = 0x5000;

+      local_16c = 0x5000;

+LAB_11:

+      pcVar20 = local_140;

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

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

+          if ((*(uint *)(lVar21 + 0x90) & 0x1f0ffdf) != 0x10) {

+            uVar14 = FsRtlpOplockKeysEqual

+                               (*(undefined8 *)(pbVar18 + 0x30),*(undefined8 *)(lVar21 + 8),0);

+            local_15f = (char)uVar14;

+            pcVar20 = local_140;

+            if (local_15f != '\0') goto LAB_14;

+          }

+          pcVar20 = local_140;

+          local_198 = &local_16d;

+          local_1a0 = &local_170;

+          local_1a8 = local_118;

+          local_1b0 = local_110;

+          local_1b8 = param_8;

+          local_1c0 = local_108;

+          local_1c8 = local_158;

+          local_1d0 = local_140;

+          uVar14 = FsRtlpOplockBreakToNone(lVar21,pbVar18,param_2,param_3 & 0xffffffff);

+          local_164 = (uint)uVar14;

+        }

+      }

+      else {

+        uVar12 = *(uint *)(lVar21 + 0x90) & 0x1f0ffdf;

+        uVar14 = (ulonglong)uVar12;

+        if (uVar12 != 0x10) {

+          uVar14 = FsRtlpOplockKeysEqual

+                             (*(undefined8 *)(pbVar18 + 0x30),*(undefined8 *)(lVar21 + 8),0);

+          pcVar20 = local_140;

+          local_160 = (char)uVar14;

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

+            local_198 = &local_16d;

+            local_1a0 = &local_170;

+            local_1a8 = local_118;

+            local_1b0 = local_110;

+            local_1b8 = param_8;

+            local_1c0 = local_108;

+            local_1c8 = local_158;

+            local_1d0 = local_140;

+            uVar14 = FsRtlpOplockBreakToII(lVar21,pbVar18,param_2,param_3 & 0xffffffff);

+            local_164 = (uint)uVar14;

+          }

+        }

+      }

+LAB_14:

+      if ((local_164 == 0) &&

+         (uVar14 = (ulonglong)*(uint *)(lVar21 + 0x90), (uVar15 & *(uint *)(lVar21 + 0x90)) != 0)) {

+        local_180 = &local_16d;

+        local_188 = &local_170;

+        local_190 = local_118;

+        local_198 = local_110;

+        local_1a0 = param_8;

+        local_1a8 = local_108;

+        local_1b0 = local_158;

+        local_1c0 = 0;

+        local_1c8 = (byte *)0x0;

+        local_1d0 = (char *)CONCAT44(local_1d0._4_4_,uVar15);

+        local_1d8 = CONCAT44(local_1d8._4_4_,local_130);

+        local_1b8 = pcVar20;

+        uVar14 = FsRtlpOplockBreakByCacheFlags(lVar21,pbVar18,param_2,param_3 & 0xffffffff);

+        local_164 = (uint)uVar14;

+      }

+      uVar16 = (ulonglong)local_168;

+LAB_5:

+      if ((local_170 != '\0') && ((uVar17 >> 0x1d & 1) == 0)) {

+        uVar14 = ExReleaseFastMutexUnsafe(*(undefined8 *)(lVar21 + 0x98));

+      }

+    } while (local_16d != 0);

+  }

+  return (ulonglong)local_164;

 }
```

## `NtCreateLowBoxToken`  (modified)

```diff
--- NtCreateLowBoxToken
+++ NtCreateLowBoxToken
@@ -1,73 +1,471 @@
 

-undefined8 NtCreateLowBoxToken(undefined8 param_1,undefined8 param_2)

+/* WARNING: Type propagation algorithm not settling */

+

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

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

+                             ulonglong param_9)

 

 {

   char cVar1;

-  int iVar2;

+  byte bVar2;

   undefined8 uVar3;

-  longlong unaff_RSI;

-  undefined8 unaff_RDI;

-  undefined1 unaff_R14B;

-  int *unaff_R15;

-  longlong in_stack_00000050;

+  bool bVar4;

+  bool bVar5;

+  bool bVar6;

+  longlong lVar7;

+  char cVar8;

+  int iVar9;

+  uint uVar10;

+  uint uVar11;

+  ulonglong uVar12;

+  undefined8 *puVar13;

+  byte *pbVar14;

+  uint *puVar15;

+  longlong *plVar16;

+  undefined4 *puVar17;

+  longlong lVar18;

+  ulonglong in_stack_fffffffffffffea8;

+  ulonglong uVar19;

+  undefined8 uVar20;

+  ulonglong uVar21;

+  undefined8 **ppuVar22;

+  undefined8 *local_120;

+  char local_118 [8];

+  undefined8 *local_110;

+  undefined8 *local_108;

+  longlong local_100;

+  int local_f8 [6];

+  longlong local_e0;

+  longlong local_d8;

+  longlong local_d0;

+  longlong local_c8;

+  longlong local_c0;

+  undefined8 local_b8;

+  int iStack_b4;

+  undefined8 local_b0;

+  undefined8 uStack_a8;

+  longlong local_a0;

+  longlong lStack_98;

+  undefined8 local_90;

+  undefined8 uStack_88;

+  undefined8 local_80;

+  undefined8 *puStack_78;

+  longlong local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 *puStack_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  longlong local_38;

+  undefined8 uStack_30;

   

-  if ((char)((ulonglong)param_2 >> 8) == '\0') {

-    iVar2 = *unaff_R15;

-    unaff_RSI = in_stack_00000050;

-  }

-  else {

-    iVar2 = RtlReadULongFromUser();

-  }

-  if (iVar2 == 0) {

-    if ((*(uint *)(unaff_RSI + 200) & 0x4000) == 0) {

-      uVar3 = 0xc000a200;

+  iVar9 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline();

+  if (iVar9 == 0) {

+    local_108 = (undefined8 *)0x0;

+    local_f8[3] = 0;

+    local_c8 = 0;

+    local_110 = (undefined8 *)0x0;

+    local_b8 = 0;

+    local_c0 = 0;

+    local_120 = (undefined8 *)0x0;

+    local_f8[4] = 1;

+    bVar4 = false;

+    bVar6 = false;

+    local_f8[0] = 0;

+    local_118[0] = '\0';

+    local_60 = 0;

+    puStack_58 = (undefined8 *)0x0;

+    local_50 = 0;

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

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

+      plVar16 = (longlong *)&DAT_0;

+      if (param_1 < &DAT_0) {

+        plVar16 = param_1;

+      }

+      *plVar16 = *plVar16;

+      if ((param_8 != 0) && ((param_9 & 7) != 0)) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

+      }

     }

-    else {

-      cVar1 = SeSinglePrivilegeCheck(SeTcbPrivilege,unaff_R14B);

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

-        uVar3 = 0xc0000061;

-      }

-      else {

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

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

-        ExAcquireResourceExclusiveLite(*(undefined8 *)(in_stack_00000050 + 0x30),1);

+    if (param_5 != 0) {

+      if (param_8 == 0) {

+        if (param_9 != 0) {

+          return 0xc0000030;

+        }

+      }

+      else if (param_9 == 0) {

+        return 0xc0000030;

+      }

+      local_100 = 0;

+      puVar13 = &stack0xffffffffffffff48;

+      plVar16 = &local_100;

+      uVar12 = ObReferenceObjectByHandle(param_2,2,SeTokenObjectType,cVar1,plVar16,puVar13);

+      uVar10 = 0;

+      if ((int)uVar12 < 0) {

+        return uVar12;

+      }

+      ppuVar22 = &local_110;

+      uVar20 = CONCAT71((int7)((ulonglong)puVar13 >> 8),1);

+      uVar11 = SeCaptureSid(param_5,cVar1);

+      uVar12 = (ulonglong)uVar11;

+      bVar5 = false;

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

+        uVar11 = SepCheckCreateAppContainer(local_110);

+        uVar12 = (ulonglong)uVar11;

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

+          if ((*(int *)(local_100 + 0xc0) == 1) || (1 < *(int *)(local_100 + 0xc4))) {

+            local_f8[5] = iStack_b4;

+            if (param_3 != 0) {

+              local_f8[5] = param_3;

+            }

+            if (param_7 != 0) {

+              plVar16 = (longlong *)((ulonglong)plVar16 & 0xffffffff00000000);

+              uVar11 = SeCaptureSidAndAttributesArray

+                                 (param_7,param_6,cVar1,0,plVar16,uVar20,ppuVar22,&local_108,

+                                  local_f8 + 3);

+              uVar12 = (ulonglong)uVar11;

+            }

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

+              uVar11 = SeCaptureHandles(param_8,param_9,&local_c8);

+              uVar12 = (ulonglong)uVar11;

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

+                cVar8 = RtlIsPackageSid(local_110);

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

+                  uVar12 = 0xc000000d;

+                }

+                else if ((*(char *)((longlong)local_110 + 1) - 8U & 0xfb) == 0) {

+                  puVar13 = local_108;

+                  bVar5 = bVar6;

+                  if (param_6 != 0) {

+                    do {

+                      uVar12 = 0;

+                      cVar8 = RtlIsCapabilitySid(*puVar13);

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

+                      if (uVar10 != 0) {

+                        uVar3 = *puVar13;

+                        do {

+                          cVar8 = RtlEqualSid(uVar3,local_108[uVar12 * 2]);

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

+                            uVar12 = 0xc000000d;

+                            goto LAB_2;

+                          }

+                          uVar11 = (int)uVar12 + 1;

+                          uVar12 = (ulonglong)uVar11;

+                        } while (uVar11 < uVar10);

+                      }

+                      uVar10 = uVar10 + 1;

+                      puVar13 = puVar13 + 2;

+                    } while (uVar10 < param_6);

+                  }

+                  puVar13 = local_108;

+                  uVar10 = 0;

+                  cVar8 = SepCapabilitiesHasAppSiloBaseSID(param_6,local_108);

+                  if ((cVar8 == '\0') && (param_6 != 0)) {

+                    do {

+                      cVar8 = SepIsAppSiloCapability(*puVar13);

+                      if (cVar8 != '\0') goto LAB_1;

+                      uVar10 = uVar10 + 1;

+                      puVar13 = puVar13 + 2;

+                    } while (uVar10 < param_6);

+                  }

+                  uVar10 = RtlGetAppContainerSidType(local_110,local_f8);

+                  uVar12 = (ulonglong)uVar10;

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

+                  if (local_f8[0] == 1) {

+                    plVar16 = (longlong *)local_118;

+                    uVar10 = SepCheckCapabilities(local_100,param_6,local_108);

+                    uVar12 = (ulonglong)uVar10;

+                    if (local_118[0] == '\0') {

+                      uVar12 = 0xc0000022;

+                      goto LAB_2;

+                    }

+                  }

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

+                  iVar9 = Feature_871661881__private_IsEnabledDeviceUsageNoInline();

+                  if (iVar9 != 0) {

+                    local_f8[1] = 0;

+                    RtlQueryElevationFlags(local_f8 + 1);

+                    lVar18 = local_100;

+                    if (((byte)local_f8[1] & 0x18) == 0x10) {

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

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

+                      ExAcquireResourceSharedLite(*(undefined8 *)(local_100 + 0x30),1);

+                      puVar13 = (undefined8 *)SepLocateTokenIntegrity(lVar18);

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

+                        uVar3 = *puVar13;

+                        pbVar14 = (byte *)RtlSubAuthorityCountSid(uVar3);

+                        if ((*pbVar14 != 0) &&

+                           (puVar15 = (uint *)RtlSubAuthoritySid(uVar3,*pbVar14 - 1),

+                           0x2fff < *puVar15)) {

+                          local_48 = 0;

+                          uStack_40 = 0;

+                          local_38 = 0;

+                          uStack_30 = 0;

+                          SeCaptureSubjectContext(&local_48);

+                          lVar7 = local_38;

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

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

+                          ExAcquireResourceSharedLite(*(undefined8 *)(local_38 + 0x30),1);

+                          puVar13 = (undefined8 *)SepLocateTokenIntegrity(lVar7);

+                          uVar3 = *puVar13;

+                          pbVar14 = (byte *)RtlSubAuthorityCountSid(uVar3);

+                          if ((*pbVar14 == 0) ||

+                             (puVar15 = (uint *)RtlSubAuthoritySid(uVar3,*pbVar14 - 1),

+                             *puVar15 < 0x3000)) {

+                            uVar12 = 0xc0000022;

+                          }

+                          ExReleaseResourceLite(*(undefined8 *)(lVar7 + 0x30));

+                          KeLeaveCriticalRegion();

+                          SeReleaseSubjectContext(&local_48);

+                        }

+                      }

+                      ExReleaseResourceLite(*(undefined8 *)(lVar18 + 0x30));

+                      KeLeaveCriticalRegion();

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

+                    }

+                  }

+                  uVar21 = CONCAT71((int7)((ulonglong)uVar20 >> 8),cVar1);

+                  uVar19 = (ulonglong)plVar16 & 0xffffffff00000000;

+                  uVar10 = SepDuplicateToken(local_100,param_4,0,1,uVar19,uVar21,

+                                             (ulonglong)ppuVar22 & 0xffffffffffffff00,&local_120);

+                  uVar12 = (ulonglong)uVar10;

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

+                  bVar6 = true;

+                  uVar10 = SeSetMandatoryPolicyToken(local_120,local_f8 + 4);

+                  uVar12 = (ulonglong)uVar10;

+                  bVar5 = true;

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

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

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

+                  ExAcquireResourceExclusiveLite(local_120[6],1);

+                  LOCK();

+                  UNLOCK();

+                  bVar4 = true;

+                  plVar16 = (longlong *)SepLocateTokenIntegrity(local_120);

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

+                    uVar12 = 0xc0000446;

+                  }

+                  else {

+                    bVar2 = *(byte *)(*plVar16 + 1);

+                    if (bVar2 != 0) {

+                      puVar17 = (undefined4 *)RtlSubAuthoritySid(*plVar16,bVar2 - 1);

+                      *puVar17 = 0x1000;

+                    }

+                    local_120[9] = local_120[9] & 0x200800000;

+                    local_120[10] = local_120[10] & 0x200800000;

+                    local_120[8] = local_120[8] & 0x200800000;

+                    iVar9 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

+                    if (iVar9 == 0) {

+                      *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) & 0xffffdfff;

+                    }

+                    else {

+                      *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) & 0xffffcfff;

+                    }

+                    *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) | 0x4000;

+                  }

+                  puVar13 = local_110;

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

+                  uVar10 = SepSetTokenCapabilities(local_120,local_110,local_108,param_6);

+                  uVar12 = (ulonglong)uVar10;

+                  bVar5 = bVar6;

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

+                  uVar10 = SepSetTokenLowboxNumber(local_120,puVar13);

+                  uVar12 = (ulonglong)uVar10;

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

+                  puStack_58 = puVar13;

+                  uVar10 = SepSetTokenCachedHandles(local_120,&local_60,param_8,local_c8);

+                  uVar12 = (ulonglong)uVar10;

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

+                  uVar10 = SepSetTokenPackage(local_120,puVar13);

+                  uVar12 = (ulonglong)uVar10;

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

+                  uVar10 = SepAppendAceToTokenDefaultDacl(local_120,puVar13);

+                  puVar13 = local_120;

+                  uVar12 = (ulonglong)uVar10;

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

+                  uVar21 = uVar21 & 0xffffffffffffff00;

+                  uVar12 = CONCAT71((int7)(uVar19 >> 8),1);

+                  cVar8 = SepSidInTokenSidHash

+                                    (local_120 + 0x65,0,SePermissiveLearningModeCapabilitySid,0,

+                                     uVar12,uVar21);

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

+                    *(uint *)(puVar13 + 0x19) = *(uint *)(puVar13 + 0x19) & 0xfcffffff;

+                    uVar12 = CONCAT71((int7)(uVar12 >> 8),1);

+                    cVar8 = SepSidInTokenSidHash

+                                      (local_120 + 0x65,0,SeLearningModeLoggingCapabilitySid,0,

+                                       uVar12,uVar21 & 0xffffffffffffff00);

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

+                      LOCK();

+                      SepLearningModeTokenCount = SepLearningModeTokenCount + 1;

+                      UNLOCK();

+                      *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) | 0x1000000;

+                    }

+                  }

+                  else {

+                    LOCK();

+                    SepLearningModeTokenCount = SepLearningModeTokenCount + 1;

+                    UNLOCK();

+                    *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) | 0x3000000;

+                  }

+                  LOCK();

+                  UNLOCK();

+                  lVar18 = ExpLuid + 1;

+                  ExpLuid = ExpLuid + 1;

+                  local_120[7] = lVar18;

+                  LOCK();

+                  UNLOCK();

+                  ExReleaseResourceLite(local_120[6]);

+                  KeLeaveCriticalRegion();

+                  bVar4 = false;

+                  uVar10 = ObInsertObjectEx(local_120,0,local_f8[5],1,uVar12 & 0xffffffff00000000,0,

+                                            &local_c0);

+                  uVar12 = (ulonglong)uVar10;

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

+                    uVar10 = SepAppendAceToTokenObjectAcl(local_120,0xf01ff,local_110);

+                    uVar12 = (ulonglong)uVar10;

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

+                    SepFinalizeTokenAcls(local_120);

+                    ObfDereferenceObject(local_120);

+                  }

+                }

+                else {

+                  uVar12 = 0xc000a202;

+                }

+              }

+            }

+            bVar4 = false;

+            bVar5 = false;

+          }

+          else {

+            uVar12 = 0xc00000a5;

+            bVar5 = false;

+          }

+        }

+      }

+LAB_2:

+      iVar9 = (int)uVar12;

+      if (bVar4) {

+        if (-1 < iVar9) {

+          LOCK();

+          UNLOCK();

+          lVar18 = ExpLuid + 1;

+          ExpLuid = ExpLuid + 1;

+          local_120[7] = lVar18;

+        }

         LOCK();

         UNLOCK();

-        SepRemoveAceFromTokenDefaultDacl(in_stack_00000050);

-        *(uint *)(unaff_RSI + 200) = *(uint *)(unaff_RSI + 200) & 0xffffbfff;

-        if (*(longlong *)(in_stack_00000050 + 0x310) != 0) {

-          ExFreePoolWithTag();

-          *(undefined8 *)(in_stack_00000050 + 0x310) = unaff_RDI;

-        }

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

-          ExFreePoolWithTag();

-          *(undefined8 *)(in_stack_00000050 + 0x318) = unaff_RDI;

-          *(int *)(in_stack_00000050 + 800) = (int)unaff_RDI;

-          memset((void *)(in_stack_00000050 + 0x328),0,0x110);

-        }

-        if (*(longlong *)(in_stack_00000050 + 0x438) != 0) {

-          SepDereferenceLowBoxNumberEntry(*(undefined4 *)(in_stack_00000050 + 0x78));

-          *(undefined8 *)(in_stack_00000050 + 0x438) = unaff_RDI;

-        }

-        if (*(longlong *)(in_stack_00000050 + 0x440) != 0) {

-          SepDereferenceCachedHandlesEntryInternal

-                    (*(longlong *)(in_stack_00000050 + 0xd8) + 0x60,0,

-                     *(longlong *)(in_stack_00000050 + 0x440),0);

-          *(undefined8 *)(in_stack_00000050 + 0x440) = unaff_RDI;

-        }

-        LOCK();

-        UNLOCK();

-        ExReleaseResourceLite(*(undefined8 *)(in_stack_00000050 + 0x30));

+        ExReleaseResourceLite(local_120[6]);

         KeLeaveCriticalRegion();

-        uVar3 = 0;

-        unaff_RSI = in_stack_00000050;

-      }

+      }

+      if (iVar9 < 0) {

+        if (bVar5) {

+          ObfDereferenceObject(local_120);

+        }

+        if (local_c0 != 0) {

+          ObCloseHandle(local_c0,cVar1);

+        }

+      }

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

+        SeReleaseSidAndAttributesArray(local_108,cVar1);

+      }

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

+        SeReleaseSid(local_110,cVar1,1);

+      }

+      if (local_100 != 0) {

+        ObfDereferenceObject(local_100);

+      }

+      if (local_c8 != 0) {

+        ExFreePoolWithTag(local_c8,0);

+      }

+      if (-1 < iVar9) {

+        *param_1 = local_c0;

+        return uVar12;

+      }

+      return uVar12;

     }

   }

   else {

-    uVar3 = 0xc00000bb;

+    local_e0 = 0;

+    local_f8[2] = 0;

+    local_d0 = 0;

+    local_d8 = 0;

+    local_b0 = 0;

+    uStack_a8 = 0;

+    local_a0 = 0;

+    lStack_98 = 0;

+    local_90 = 0;

+    uStack_88 = 0;

+    local_80 = 0;

+    puStack_78 = (undefined8 *)0x0;

+    local_70 = 0;

+    uStack_68 = 0;

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

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

+      plVar16 = (longlong *)&DAT_0;

+      if (param_1 < &DAT_0) {

+        plVar16 = param_1;

+      }

+      *plVar16 = *plVar16;

+      if ((param_8 != 0) && ((param_9 & 7) != 0)) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

+      }

+    }

+    if (param_5 != 0) {

+      if (param_8 == 0) {

+        if (param_9 != 0) {

+          return 0xc0000030;

+        }

+      }

+      else if (param_9 == 0) {

+        return 0xc0000030;

+      }

+      plVar16 = &local_d8;

+      uVar20 = 1;

+      uVar10 = SeCaptureSid(param_5,cVar1);

+      uVar12 = (ulonglong)uVar10;

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

+        if (param_7 != 0) {

+          uVar10 = SeCaptureSidAndAttributesArray

+                             (param_7,param_6,cVar1,0,in_stack_fffffffffffffea8 & 0xffffffff00000000

+                              ,uVar20,plVar16,&local_e0,local_f8 + 2);

+          uVar12 = (ulonglong)uVar10;

+        }

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

+          uVar10 = SeCaptureHandles(param_8,param_9,&local_d0);

+          uVar12 = (ulonglong)uVar10;

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

+            puStack_78 = &local_b0;

+            local_b0 = CONCAT44(local_b0._4_4_,0x30) | 0x100000000;

+            local_a0 = local_d8;

+            lStack_98 = local_e0;

+            local_90 = CONCAT44(local_90._4_4_,param_6);

+            local_70 = local_d0;

+            uStack_68 = CONCAT44(uStack_68._4_4_,param_8);

+            uStack_a8 = param_2;

+            uVar10 = SepCreateAppContainerToken(param_1,0,param_3,param_4,cVar1,&local_80);

+            uVar12 = (ulonglong)uVar10;

+          }

+        }

+      }

+      if (local_e0 != 0) {

+        SeReleaseSidAndAttributesArray(local_e0,cVar1);

+      }

+      if (local_d8 != 0) {

+        SeReleaseSid(local_d8,cVar1,1);

+      }

+      if (local_d0 != 0) {

+        ExFreePoolWithTag(local_d0,0);

+        return uVar12;

+      }

+      return uVar12;

+    }

   }

-  ObfDereferenceObject(unaff_RSI);

-  return uVar3;

+  return 0xc000000d;

+LAB_1:

+  uVar12 = 0xc000000d;

+  goto LAB_2;

 }
```

## `RtlpCreateUCREntry`  (modified)

```diff
--- RtlpCreateUCREntry
+++ RtlpCreateUCREntry
@@ -1,86 +1,53 @@
 

-undefined8 RtlpCreateUCREntry(undefined8 param_1)

+void RtlpCreateUCREntry(longlong param_1,longlong param_2,longlong param_3,undefined8 param_4,

+                       ulonglong param_5,longlong *param_6)

 

 {

-  char *pcVar1;

+  ulonglong uVar1;

   longlong lVar2;

-  longlong lVar3;

-  char cVar4;

-  int iVar5;

-  undefined8 in_RAX;

-  int *piVar6;

-  int *piVar7;

-  int *piVar8;

-  ulonglong uVar9;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  int *unaff_RSI;

-  undefined4 uVar10;

+  int iVar3;

+  ulonglong uVar4;

   

-  piVar6 = (int *)CONCAT44((int)((ulonglong)in_RAX >> 0x20),*unaff_RSI);

-  *piVar6 = *piVar6 + *unaff_RSI;

-  pcVar1 = (char *)(unaff_RBX + 0x2a87043);

-  *pcVar1 = *pcVar1 + (char)param_1 + (char)((ulonglong)param_1 >> 8);

-  if (*pcVar1 != '\0') {

-    piVar7 = *(int **)(unaff_RBX + 0xa0);

-    piVar6 = unaff_RSI + 0x801;

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

-    piVar8 = piVar6;

-    if (piVar6 <= piVar7) {

-      piVar8 = piVar7;

+  *(undefined8 *)(param_3 + 0x28) = param_4;

+  uVar1 = param_3 - 0x10;

+  *(undefined1 *)(param_3 + -1) = 3;

+  *(longlong *)(param_3 + 0x20) = param_3 + 0x30;

+  *(undefined4 *)(param_3 + -8) = 0x10004;

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

+    uVar4 = 0;

+  }

+  else {

+    uVar4 = (uVar1 - param_2 >> 0x10) + 1;

+    if (0xfd < uVar4) {

+      RtlpLogHeapFailure(3,*(longlong *)(param_2 + 0x28),uVar1,param_2,0,0);

     }

-    uVar9 = (longlong)piVar8 + 0xffffU & 0xffffffffffff0000;

-    *(ulonglong *)(unaff_RBP + 0x38) = uVar9;

-    if (0xfcffff < uVar9) {

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

-    }

-    while( true ) {

-      uVar10 = 0x2000;

-      iVar5 = ZwAllocateVirtualMemory(0xffffffffffffffff,unaff_RBP + 0x40,0,unaff_RBP + 0x38,0x2000)

-      ;

-      if (-1 < iVar5) break;

-      if (*(int **)(unaff_RBP + 0x38) == piVar6) {

-        *(int *)(unaff_RBX + 0x280) = *(int *)(unaff_RBX + 0x280) + 1;

-        return 0;

-      }

-      piVar7 = (int *)((ulonglong)*(int **)(unaff_RBP + 0x38) >> 1);

-      *(int **)(unaff_RBP + 0x38) = piVar7;

-      if (piVar7 < piVar6) {

-        *(int **)(unaff_RBP + 0x38) = piVar6;

-      }

-    }

-    *(longlong *)(unaff_RBX + 0xa0) =

-         *(longlong *)(unaff_RBX + 0xa0) + *(longlong *)(unaff_RBP + 0x38);

-    lVar2 = *(longlong *)(unaff_RBX + 0x240);

-    piVar6 = unaff_RSI + 0x401;

-    if (unaff_RSI + 0x401 <= *(int **)(unaff_RBX + 0xa8)) {

-      piVar6 = *(int **)(unaff_RBX + 0xa8);

-    }

-    lVar3 = *(longlong *)(unaff_RBX + 0x2a0);

-    uVar9 = (longlong)piVar6 + 0xfffU & 0xfffffffffffff000;

-    *(ulonglong *)(unaff_RBP + -0x10) = uVar9;

-    iVar5 = RtlpHpHeapCheckCommitLimit(uVar9,lVar2 - lVar3);

-    if (iVar5 != 0) {

-      uVar10 = 0x1000;

-      iVar5 = ZwAllocateVirtualMemory

-                        (0xffffffffffffffff,unaff_RBP + 0x40,0,unaff_RBP + -0x10,0x1000);

-      if (-1 < iVar5) {

-        uVar10 = 2;

-        cVar4 = RtlpInitializeHeapSegment();

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

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

-          if ((*(int *)(unaff_RBX + 0x7c) != 0) &&

-             (*(uint *)(lVar2 + 8) = *(uint *)(lVar2 + 8) ^ *(uint *)(unaff_RBX + 0x88),

-             *(byte *)(lVar2 + 0xb) !=

-             (byte)(*(byte *)(lVar2 + 10) ^ *(byte *)(lVar2 + 9) ^ *(byte *)(lVar2 + 8)))) {

-            RtlpAnalyzeHeapFailure();

-          }

-          return *(undefined8 *)(*(longlong *)(unaff_RBP + 0x40) + 0x40);

-        }

-      }

-    }

-    ZwFreeVirtualMemory(0xffffffffffffffff,unaff_RBP + 0x40,unaff_RBP + 0x38,0x8000,uVar10);

   }

-  return 0;

+  iVar3 = RtlpHeapErrorHandlerThreshold;

+  *(char *)(param_3 + -2) = (char)uVar4;

+  if ((0 < iVar3) && (uVar1 < param_5)) {

+                    /* WARNING: Subroutine does not return */

+    DbgPrint(&s___PHEAP_ENTRY_LastKnownEntry_<_);

+  }

+  if (param_5 != uVar1) {

+    *(undefined2 *)(param_3 + -4) = *(undefined2 *)(param_1 + 0x8c);

+  }

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

+    *(byte *)(param_3 + -5) =

+         *(byte *)(param_3 + -6) ^ *(byte *)(param_3 + -7) ^ *(byte *)(param_3 + -8);

+    *(uint *)(param_3 + -8) = *(uint *)(param_3 + -8) ^ *(uint *)(param_1 + 0x88);

+  }

+  RtlpInsertUCRBlock(param_1,param_3);

+  *(int *)(param_2 + 0x54) = *(int *)(param_2 + 0x54) + 1;

+  *(int *)(param_2 + 0x50) = *(int *)(param_2 + 0x50) + (int)(*(ulonglong *)(param_3 + 0x28) >> 0xc)

+  ;

+  lVar2 = *(longlong *)(param_3 + 0x28);

+  *(int *)(param_1 + 0x264) = *(int *)(param_1 + 0x264) + 1;

+  *(longlong *)(param_1 + 0x240) = *(longlong *)(param_1 + 0x240) - lVar2;

+  if (0xfefff < *(ulonglong *)(param_3 + 0x28)) {

+    *(longlong *)(param_1 + 0x248) = *(longlong *)(param_1 + 0x248) + *(ulonglong *)(param_3 + 0x28)

+    ;

+  }

+  *param_6 = (longlong)(uVar1 - param_5) >> 4;

+  return;

 }
```

## `MinCryptVerifySignedHash2`  (modified)

```diff
--- MinCryptVerifySignedHash2
+++ MinCryptVerifySignedHash2
@@ -1,10 +1,102 @@
 

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

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

 

-void MinCryptVerifySignedHash2(void)

+int MinCryptVerifySignedHash2

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

+              undefined8 param_5,longlong param_6)

 

 {

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

-  halt_baddata();

+  int iVar1;

+  int iVar2;

+  long lVar3;

+  uint uVar4;

+  undefined4 uVar5;

+  undefined1 auStack_538 [32];

+  ulonglong local_518;

+  uchar *local_510;

+  ulonglong local_508;

+  undefined8 local_500;

+  ulonglong local_4f8;

+  undefined4 local_4f0;

+  undefined1 local_4e8 [32];

+  ulong local_4c8;

+  uchar *local_4c0;

+  ulong local_4b8;

+  uchar *local_4b0;

+  undefined1 local_4a8 [32];

+  undefined1 local_488 [16];

+  int local_478 [2];

+  char *local_470;

+  uchar local_468 [1056];

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_538;

+  uVar5 = 0;

+  iVar1 = MinAsn1ParsePublicKeyInfo(param_5,local_4a8);

+  if (iVar1 < 0) {

+    return -0x3ffffbd8;

+  }

+  iVar1 = MinCryptDecodeSignatureAlgorithmIdentifier(local_488);

+  if (iVar1 == 0) {

+    return -0x3ffffbd8;

+  }

+  if (iVar1 == 0x2400) {

+    iVar1 = MinAsn1ParseRSAPublicKey(local_478,local_4e8);

+    if (iVar1 < 0) {

+      return -0x3ffffbd8;

+    }

+    if ((param_6 != 0) && (uVar5 = 0, (*(byte *)(param_6 + 4) & 0x40) != 0)) {

+      uVar5 = 1;

+    }

+    local_4f8 = (ulonglong)*param_4;

+    local_508 = (ulonglong)local_4c8;

+    local_518 = (ulonglong)local_4b8;

+    local_500 = *(undefined8 *)(param_4 + 2);

+    local_510 = local_4c0;

+    local_4f0 = uVar5;

+    iVar1 = HashpVerifyPkcs1Signature(param_1,param_2,param_3,local_4b0);

+    if (iVar1 < 0) {

+      return -0x3ffffbd8;

+    }

+    return iVar1;

+  }

+  if ((iVar1 == 0x2e01) || (iVar1 == 0x2e02)) {

+    if (iVar1 == 0x2e01) {

+      uVar4 = 0x20;

+      goto LAB_0;

+    }

+    if (iVar1 == 0x2e02) {

+      uVar4 = 0x30;

+      goto LAB_0;

+    }

+    if (iVar1 != 0x2e03) {

+      return -0x3ffffbd8;

+    }

+  }

+  else {

+    if (iVar1 != 0x2e03) {

+      return -0x3ffffbd8;

+    }

+    iVar2 = Feature_CodeIntegrity_EccSupport__private_IsEnabledDeviceUsageNoInline();

+    if (iVar2 == 0) {

+      return -0x3ffffbd8;

+    }

+  }

+  uVar4 = 0x42;

+LAB_0:

+  iVar2 = MinAsn1ParseECCSignature(param_4,local_4e8);

+  if ((((-1 < iVar2) && (iVar2 = uVar4 * 2, local_478[0] == iVar2 + 1)) && (*local_470 == '\x04'))

+     && ((lVar3 = MinCryptCopyAsn1IntToFixedBuffer(local_4c0,local_4c8,local_468,uVar4), -1 < lVar3

+         && (lVar3 = MinCryptCopyAsn1IntToFixedBuffer(local_4b0,local_4b8,local_468 + uVar4,uVar4),

+            -1 < lVar3)))) {

+    local_510 = local_468;

+    local_508 = CONCAT44(local_508._4_4_,iVar2);

+    local_518 = CONCAT44(local_518._4_4_,param_3);

+    iVar1 = HashpVerifyEcdsaSignature(iVar1,local_470 + 1,iVar2,param_2);

+    if (-1 < iVar1) {

+      return iVar1;

+    }

+  }

+  return -0x3ffffbd8;

 }
```

## `PpmParkCalculateCoreParkingMaskEx`  (modified)

```diff
--- PpmParkCalculateCoreParkingMaskEx
+++ PpmParkCalculateCoreParkingMaskEx
@@ -1,295 +1,347 @@
 

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

 

-undefined8 PpmParkCalculateCoreParkingMaskEx(uint param_1)

+undefined8 PpmParkCalculateCoreParkingMaskEx(void)

 

 {

   _KAFFINITY_EX *p_Var1;

-  byte bVar2;

-  ushort uVar3;

-  ushort uVar4;

-  ushort uVar5;

-  int iVar6;

-  undefined4 uVar7;

-  ulonglong uVar8;

-  longlong lVar9;

-  uint uVar10;

-  uint uVar11;

-  uint uVar12;

-  ulonglong uVar13;

-  longlong unaff_RBP;

-  uint unaff_ESI;

-  ulonglong uVar14;

+  _KAFFINITY_EX *p_Var2;

+  _KAFFINITY_EX *p_Var3;

+  _KAFFINITY_EX *p_Var4;

+  byte bVar5;

+  undefined1 uVar6;

+  ushort uVar7;

+  ushort uVar8;

+  undefined *puVar9;

+  _KAFFINITY_EX *p_Var10;

+  int iVar11;

+  ushort uVar12;

+  int iVar13;

+  uint uVar14;

   uint uVar15;

-  _KAFFINITY_EX *unaff_R12;

-  uint unaff_R13D;

-  _KAFFINITY_EX *p_Var16;

-  uint unaff_R14D;

-  uint uVar17;

-  ushort *puVar18;

-  bool bVar19;

-  undefined1 in_ZF;

-  undefined2 uVar20;

+  ulonglong uVar16;

+  longlong lVar17;

+  undefined1 uVar18;

+  uint uVar19;

+  uint uVar20;

+  uint uVar21;

+  longlong lVar22;

+  uint uVar23;

+  ulonglong uVar24;

+  _KAFFINITY_EX *p_Var25;

+  ushort *puVar26;

+  bool bVar27;

+  uint local_res8;

+  uint local_res10 [2];

+  undefined4 local_res18 [2];

+  uint local_res20;

+  undefined2 uVar28;

+  _KAFFINITY_EX *in_stack_ffffffffffffff20;

+  undefined4 uVar29;

+  _KAFFINITY_EX *p_Var30;

+  uint *puVar31;

+  undefined4 uVar32;

+  uint local_88;

+  uint local_84;

+  _KAFFINITY_EX *local_60;

+  ulong64 uStack_58;

+  ulonglong local_50;

   

-  uVar14 = (ulonglong)param_1;

-  do {

-    *(char *)(unaff_RBP + 0x67) = (char)param_1;

-    if (!(bool)in_ZF) {

-      *(undefined1 *)(unaff_RBP + 0x67) = *(undefined1 *)(uVar14 + 0x4ee);

+  p_Var10 = PpmParkPerfCheckAffinities;

+  local_60 = (_KAFFINITY_EX *)0x0;

+  uStack_58 = 0;

+  local_50 = 0;

+  local_res18[0] = 0;

+  local_res10[0] = 0;

+  if (PpmIsParkingEnabled != 0) {

+    p_Var25 = PpmParkPerfCheckAffinities + 1;

+    p_Var30 = PpmParkPerfCheckAffinities + 2;

+    p_Var1 = PpmParkPerfCheckAffinities + 3;

+    p_Var2 = PpmParkPerfCheckAffinities + 4;

+    p_Var3 = PpmParkPerfCheckAffinities + 6;

+    p_Var4 = PpmParkPerfCheckAffinities + 7;

+    memset(&PpmParkPerfCheckAffinities->field3_0x8,0,

+           (ulonglong)PpmParkPerfCheckAffinities->Count << 3);

+    p_Var10->Count = 1;

+    memset(&p_Var10[1].field3_0x8,0,(ulonglong)p_Var25->Count << 3);

+    p_Var25->Count = 1;

+    memset(&p_Var10[2].field3_0x8,0,(ulonglong)p_Var30->Count << 3);

+    p_Var30->Count = 1;

+    memset(&p_Var10[3].field3_0x8,0,(ulonglong)p_Var1->Count << 3);

+    p_Var1->Count = 1;

+    memset(&p_Var10[4].field3_0x8,0,(ulonglong)p_Var2->Count << 3);

+    p_Var2->Count = 1;

+    memset(&p_Var10[5].field3_0x8,0,(ulonglong)p_Var10[5].Count << 3);

+    p_Var10[5].Count = 1;

+    memset(&p_Var10[6].field3_0x8,0,(ulonglong)p_Var3->Count << 3);

+    p_Var3->Count = 1;

+    memset(&p_Var10[7].field3_0x8,0,(ulonglong)p_Var4->Count << 3);

+    p_Var4->Count = 1;

+    memset(&p_Var10[8].field3_0x8,0,(ulonglong)p_Var10[8].Count << 3);

+    p_Var10[8].Count = 1;

+    iVar11 = DAT_0;

+    puVar9 = PpmCurrentProfile;

+    PpmParkSoftParkCurrentRank = 0;

+    PpmParkSoftParkRankListChanged = 0;

+    bVar5 = PpmCurrentProfile[(longlong)DAT_0 * 0x1e8 + 0xb4];

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

+      memset(PpmParkNewSoftParkRankList,0xff,(ulonglong)KeMaximumProcessors << 2);

     }

-    KeAndAffinityEx2(unaff_R12 + 6,unaff_R12 + 3,unaff_R12 + 4);

-    p_Var1 = unaff_R12 + 6;

-    uVar12 = unaff_R13D;

-    func_0x0001405defbc(uVar14,p_Var1,uVar14 + 0x240,unaff_R12 + 4,unaff_R13D);

-    uVar20 = (undefined2)(uVar12 >> 0x10);

-    KeSubtractAffinityEx2(p_Var1,unaff_R12 + 5,unaff_R12 + 8);

-    KeSubtractAffinityEx2(unaff_R12 + 8,unaff_R12 + 7,unaff_R12 + 8);

-    lVar9 = uVar14 + 0x138;

-    KeSubtractAffinityEx2(lVar9,p_Var1,uVar14 + 0x138);

-    KeOrAffinityEx2(lVar9,unaff_R12 + 5,lVar9);

-    KeOrAffinityEx2(lVar9,unaff_R12 + 7,lVar9);

-    lVar9 = uVar14 + 0x348;

-    KeSubtractAffinityEx2(lVar9,unaff_R12 + 6,lVar9);

-    KeOrAffinityEx2(lVar9,unaff_R12 + 7,lVar9);

-    iVar6 = *(int *)(unaff_RBP + 0x7f);

-    PpmEventTraceSoftCoreParkingSelectionEx

-              (uVar14,iVar6,unaff_R13D & 0xffff,unaff_ESI & 0xffff,

-               CONCAT22(uVar20,(short)unaff_R14D));

-    bVar2 = *(byte *)(uVar14 + 0xc);

-    p_Var1 = unaff_R12 + 1;

-    uVar17 = iVar6 + 1;

-    uVar8 = (ulonglong)uVar17;

-    *(uint *)(unaff_RBP + 0x7f) = uVar17;

-    uVar12 = *(uint *)(unaff_RBP + -0x29);

-    if (uVar17 < bVar2) goto LAB_0;

-    do {

-      uVar13 = (ulonglong)*(uint *)(unaff_RBP + -0x25);

+    local_84 = 0;

+    if (PpmParkNumNodes != 0) {

       do {

-        do {

-          uVar12 = (int)uVar13 + 1;

-          uVar13 = (ulonglong)uVar12;

-          bVar19 = PpmParkNumNodes <= uVar12;

-          *(uint *)(unaff_RBP + -0x25) = uVar12;

-          if (bVar19) {

-            PpmParkComputeDiff();

-            uVar12 = (uint)(PpmParkLpiCap != 0);

-            if ((PpmParkLpiEngaged != uVar12) || (bVar19 = false, PpmParkLpiCapChanged != 0)) {

-              bVar19 = true;

+        lVar22 = (ulonglong)local_84 * 0x508 + PpmParkNodes;

+        if ((*(byte *)(lVar22 + 0x4a0) & 1) == 0) {

+          KiCopyAffinityEx((_KAFFINITY_EX *)(lVar22 + 0x240),*(ushort *)(lVar22 + 0x242),

+                           (_KAFFINITY_EX *)(lVar22 + 0x138));

+          *(undefined2 *)(lVar22 + 0x4dc) = 0;

+          *(undefined1 *)(lVar22 + 0x4de) = 0;

+          uVar12 = *(ushort *)(lVar22 + 0x492);

+          if (*(ushort *)(lVar22 + 0x496) <= *(ushort *)(lVar22 + 0x492)) {

+            uVar12 = *(ushort *)(lVar22 + 0x496);

+          }

+          local_88 = (uint)uVar12;

+          PpmParkFindOverUtilizedProcessorsEx(lVar22,(uint)bVar5 * 100,p_Var10 + 3);

+          uVar24 = 0;

+          *(undefined1 *)(lVar22 + 0x4c0) = 0;

+          if (PpmHeteroFavoredCoreRotationTimeoutMs != 0) {

+            uVar16 = _DAT_1 /

+                     ((ulonglong)PpmHeteroFavoredCoreRotationTimeoutMs * 10000);

+            *(ulonglong *)(lVar22 + 0x4b0) = uVar16;

+            if (uVar16 != *(ulonglong *)(lVar22 + 0x4b8)) {

+              *(undefined1 *)(lVar22 + 0x4c0) = 1;

+              *(ulonglong *)(lVar22 + 0x4b8) = uVar16;

             }

-            PpmParkLpiCapChanged = 0;

-            PpmParkLpiEngaged = uVar12;

-            if (bVar19) {

-              PpmEventLPICoreParking();

-            }

-            return 1;

           }

-          uVar14 = uVar13 * 0x508 + PpmParkNodes;

-          *(ulonglong *)(unaff_RBP + -0x11) = uVar14;

-        } while ((*(byte *)(uVar14 + 0x4a0) & 1) != 0);

-        KiCopyAffinityEx((_KAFFINITY_EX *)(uVar14 + 0x240),*(ushort *)(uVar14 + 0x242),

-                         (_KAFFINITY_EX *)(uVar14 + 0x138));

-        uVar7 = *(undefined4 *)(unaff_RBP + -0x21);

-        *(undefined2 *)(uVar14 + 0x4dc) = 0;

-        *(undefined1 *)(uVar14 + 0x4de) = 0;

-        uVar5 = *(ushort *)(uVar14 + 0x492);

-        if (*(ushort *)(uVar14 + 0x496) <= *(ushort *)(uVar14 + 0x492)) {

-          uVar5 = *(ushort *)(uVar14 + 0x496);

-        }

-        uVar12 = (uint)uVar5;

-        *(uint *)(unaff_RBP + -0x29) = uVar12;

-        PpmParkFindOverUtilizedProcessorsEx(uVar14,uVar7,unaff_R12 + 3);

-        *(undefined1 *)(uVar14 + 0x4c0) = 0;

-        if (PpmHeteroFavoredCoreRotationTimeoutMs != 0) {

-          uVar8 = _DAT_1 / ((ulonglong)PpmHeteroFavoredCoreRotationTimeoutMs * 10000)

-          ;

-          *(ulonglong *)(uVar14 + 0x4b0) = uVar8;

-          if (uVar8 != *(ulonglong *)(uVar14 + 0x4b8)) {

-            *(undefined1 *)(uVar14 + 0x4c0) = 1;

-            *(ulonglong *)(uVar14 + 0x4b8) = uVar8;

+          local_res20 = 0;

+          if (*(char *)(lVar22 + 0xc) != '\0') {

+            do {

+              p_Var30 = p_Var10 + 6;

+              p_Var25 = p_Var10 + 1;

+              puVar26 = (ushort *)(uVar24 * 0x280 + *(longlong *)(lVar22 + 0x500));

+              local_res10[0] = 0;

+              KiCopyAffinityEx(p_Var30,p_Var10[6].Size,(_KAFFINITY_EX *)(puVar26 + 0x14));

+              iVar13 = KeIsEmptyAffinityEx(p_Var30);

+              if (iVar13 != 0) break;

+              local_res10[0] = 0x100000;

+              if (PpmParkGranularity < 2) {

+                KiCopyAffinityEx(p_Var10,p_Var10->Size,(_KAFFINITY_EX *)(puVar26 + 0x98));

+              }

+              else {

+                memset(&p_Var10->field3_0x8,0,(ulonglong)p_Var10->Count << 3);

+                p_Var10->Count = 1;

+                local_50 = local_50 & 0xffffffffffff0000;

+                uStack_58 = *(ulong64 *)(puVar26 + 0x9c);

+                local_60 = (_KAFFINITY_EX *)(puVar26 + 0x98);

+                while (iVar13 = KeEnumerateNextProcessor(local_res18,&local_60), iVar13 == 0) {

+                  lVar17 = KeGetPrcb(local_res18[0]);

+                  KeAddGroupAffinityEx

+                            (p_Var10,*(undefined1 *)(lVar17 + 0xd0),*(undefined8 *)(lVar17 + 0x8e60)

+                            );

+                }

+              }

+              KeAndAffinityEx2(p_Var10,p_Var30,p_Var10);

+              iVar13 = KeIsEmptyAffinityEx(p_Var10);

+              if (iVar13 == 0) {

+                local_res10[0] = local_res10[0] | 0x10000;

+              }

+              iVar13 = KeCountSetBitsAffinityEx(p_Var10);

+              uVar20 = local_88;

+              if ((uint)*puVar26 - iVar13 <= local_88) {

+                uVar20 = (uint)*puVar26 - iVar13;

+              }

+              memset(&p_Var10[1].field3_0x8,0,(ulonglong)p_Var25->Count << 3);

+              bVar27 = KiClockTimerPerCpu == '\0';

+              p_Var25->Count = 1;

+              uVar29 = KiClockTimerOwner;

+              uVar14 = 0;

+              if (bVar27) {

+                local_res18[0] = KiClockTimerOwner;

+                iVar13 = KeCheckProcessorAffinityEx(p_Var10 + 6);

+                if (((iVar13 != 0) && (uVar14 = 0, uVar20 != 0)) &&

+                   (iVar13 = KeCheckProcessorAffinityEx(p_Var10), iVar13 == 0)) {

+                  lVar17 = KeGetPrcb(uVar29);

+                  if (PpmParkGranularity < 2) {

+                    KeAddProcessorAffinityEx(p_Var25);

+                  }

+                  else {

+                    KeAddGroupAffinityEx

+                              (p_Var25,*(undefined1 *)(lVar17 + 0xd0),

+                               *(undefined8 *)(lVar17 + 0x8e60));

+                  }

+                  local_res10[0] = local_res10[0] | 0x100;

+                  uVar14 = KeCountSetBitsAffinityEx(p_Var25);

+                }

+              }

+              memset(&p_Var10[2].field3_0x8,0,(ulonglong)p_Var10[2].Count << 3);

+              p_Var10[2].Count = 1;

+              uVar12 = KeCpuSetQueryUnparkRecommendationEx();

+              uVar29 = (undefined4)((ulonglong)in_stack_ffffffffffffff20 >> 0x20);

+              local_res8 = (uint)uVar12;

+              if (local_res8 != 0) {

+                p_Var25 = p_Var10 + 2;

+                if (1 < PpmParkGranularity) {

+                  local_50 = local_50 & 0xffffffffffff0000;

+                  uStack_58 = p_Var10[2].field3_0x8.Bitmap[0];

+                  local_60 = p_Var25;

+                  iVar13 = KeEnumerateNextProcessor(local_res18);

+                  while (iVar13 == 0) {

+                    lVar17 = KeGetPrcb(local_res18[0]);

+                    KeAddGroupAffinityEx

+                              (p_Var25,*(undefined1 *)(lVar17 + 0xd0),

+                               *(undefined8 *)(lVar17 + 0x8e60));

+                    iVar13 = KeEnumerateNextProcessor(local_res18);

+                  }

+                  local_res8 = KeCountSetBitsAffinityEx(p_Var25);

+                }

+                p_Var30 = p_Var10 + 1;

+                uStack_58 = p_Var10[2].field3_0x8.Bitmap[0];

+                local_50 = local_50 & 0xffffffffffff0000;

+                local_60 = p_Var25;

+                iVar13 = KeEnumerateNextProcessor();

+                uVar29 = (undefined4)((ulonglong)in_stack_ffffffffffffff20 >> 0x20);

+                uVar32 = local_res18[0];

+                while (local_res18[0] = uVar32, iVar13 == 0) {

+                  if ((uVar14 < uVar20) &&

+                     (iVar13 = KeCheckProcessorAffinityEx(p_Var10,uVar32), iVar13 == 0)) {

+                    lVar17 = KeGetPrcb(uVar32);

+                    if (PpmParkGranularity < 2) {

+                      KeAddProcessorAffinityEx(p_Var30,uVar32);

+                    }

+                    else {

+                      KeAddGroupAffinityEx

+                                (p_Var30,*(undefined1 *)(lVar17 + 0xd0),

+                                 *(undefined8 *)(lVar17 + 0x8e60));

+                    }

+                    local_res10[0] = local_res10[0] | 0x10;

+                    uVar14 = KeCountSetBitsAffinityEx(p_Var30);

+                  }

+                  iVar13 = KeEnumerateNextProcessor();

+                  uVar29 = (undefined4)((ulonglong)in_stack_ffffffffffffff20 >> 0x20);

+                  uVar32 = local_res18[0];

+                }

+              }

+              uVar12 = puVar26[1];

+              if ((uVar14 < uVar12) && (uVar14 < uVar20)) {

+                uVar14 = uVar20;

+                if (uVar12 < uVar20) {

+                  uVar14 = (uint)uVar12;

+                }

+                local_res10[0] = local_res10[0] | 4;

+              }

+              uVar12 = puVar26[2];

+              if (((uVar12 < uVar20) && (uVar14 < uVar20)) &&

+                 (local_res10[0] = local_res10[0] | 8, uVar20 = (uint)uVar12, uVar12 <= uVar14)) {

+                uVar20 = uVar14;

+              }

+              uVar12 = 0;

+              uVar21 = PpmHeteroHgsContainmentState & 8;

+              if (uVar21 != 0) {

+                uVar12 = *(ushort *)

+                          (*(longlong *)(lVar22 + 0x4f8) + 8 +

+                          (longlong)*(int *)(*(longlong *)(lVar22 + 0x4f8) + 4) * 2);

+              }

+              uVar7 = *puVar26;

+              uVar8 = puVar26[3];

+              if (uVar7 <= puVar26[3]) {

+                uVar8 = uVar7;

+              }

+              uVar23 = (uint)uVar8;

+              if ((PpmCheckLatencyBoostActive != 0) &&

+                 (uVar19 = ((uint)(byte)puVar9[(ulonglong)(local_res20 != 0) + 0x89 +

+                                               (longlong)iVar11 * 0x1e8] * (uint)uVar7 + 0x32) / 100

+                 , uVar8 < uVar19)) {

+                local_res10[0] = local_res10[0] | 0x40;

+                uVar23 = uVar19;

+              }

+              if (1 < PpmParkGranularity) {

+                uVar23 = uVar23 + (PpmParkGranularity - 1);

+                uVar23 = uVar23 - uVar23 % (uint)PpmParkGranularity;

+              }

+              uVar19 = 0;

+              if (((uVar21 != 0) && (uVar12 != 0)) && (uVar12 < (ushort)uVar23)) {

+                local_res10[0] = local_res10[0] | 0x400000;

+                uVar23 = (uint)uVar12;

+              }

+              puVar26[4] = (ushort)uVar23;

+              uVar15 = local_res8 + uVar23;

+              if (uVar20 <= local_res8 + uVar23) {

+                uVar15 = uVar20;

+              }

+              uVar23 = uVar14;

+              if (uVar14 < uVar15) {

+                uVar23 = uVar15;

+              }

+              local_88 = local_88 - uVar20;

+              uVar18 = 0;

+              bVar27 = PpmParkSoftParkingEnabled == '\0';

+              puVar26[5] = (ushort)uVar23;

+              if (bVar27) {

+                local_res10[0] = local_res10[0] | 0x200000;

+                uVar15 = uVar23;

+              }

+              else {

+                uVar15 = uVar20;

+                if (uVar21 != 0) {

+                  local_res10[0] = local_res10[0] | 0x800000;

+                  uVar15 = (uint)uVar12;

+                  if (uVar20 < uVar12) {

+                    uVar15 = uVar20;

+                  }

+                }

+              }

+              uVar6 = 0;

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

+                uVar6 = *(undefined1 *)(lVar22 + 0x4ee);

+                uVar19 = (uint)*(ushort *)(lVar22 + 0x4e8);

+                uVar18 = *(undefined1 *)(lVar22 + 0x4ef);

+              }

+              KeAndAffinityEx2(p_Var10 + 6,p_Var10 + 3,p_Var10 + 4);

+              p_Var25 = p_Var10 + 6;

+              puVar31 = local_res10;

+              p_Var30 = p_Var10 + 7;

+              uVar20 = uVar23;

+              PpmParkComputeUnparkMaskEx

+                        (lVar22,p_Var25,lVar22 + 0x240,p_Var10 + 4,uVar23,CONCAT44(uVar29,uVar15),

+                         p_Var10,p_Var10 + 1,p_Var10 + 5,p_Var30,puVar31,lVar22 + 0x4b0,uVar19,uVar6

+                         ,uVar18,local_res20);

+              uVar28 = (undefined2)(uVar20 >> 0x10);

+              uVar29 = (undefined4)((ulonglong)p_Var30 >> 0x20);

+              uVar32 = (undefined4)((ulonglong)puVar31 >> 0x20);

+              KeSubtractAffinityEx2(p_Var25,p_Var10 + 5,p_Var10 + 8);

+              KeSubtractAffinityEx2(p_Var10 + 8,p_Var10 + 7,p_Var10 + 8);

+              lVar17 = lVar22 + 0x138;

+              KeSubtractAffinityEx2(lVar17,p_Var25,lVar22 + 0x138);

+              KeOrAffinityEx2(lVar17,p_Var10 + 5,lVar17);

+              KeOrAffinityEx2(lVar17,p_Var10 + 7,lVar17);

+              lVar17 = lVar22 + 0x348;

+              KeSubtractAffinityEx2(lVar17,p_Var10 + 6,lVar17);

+              KeOrAffinityEx2(lVar17,p_Var10 + 7,lVar17);

+              uVar20 = local_res20;

+              in_stack_ffffffffffffff20 = p_Var10;

+              PpmEventTraceSoftCoreParkingSelectionEx

+                        (lVar22,local_res20,uVar23 & 0xffff,uVar15 & 0xffff,

+                         CONCAT22(uVar28,(short)uVar14),p_Var10,p_Var10 + 1,p_Var10 + 4,p_Var10 + 2,

+                         CONCAT44(uVar29,local_res10[0]),CONCAT44(uVar32,uVar19));

+              local_res20 = uVar20 + 1;

+              uVar24 = (ulonglong)local_res20;

+            } while (local_res20 < *(byte *)(lVar22 + 0xc));

           }

         }

-        uVar8 = 0;

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

-      } while (*(char *)(uVar14 + 0xc) == '\0');

-LAB_0:

-      uVar5 = unaff_R12[6].Size;

-      puVar18 = (ushort *)(uVar8 * 0x280 + *(longlong *)(uVar14 + 0x500));

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

-      KiCopyAffinityEx(unaff_R12 + 6,uVar5,(_KAFFINITY_EX *)(puVar18 + 0x14));

-      iVar6 = KeIsEmptyAffinityEx(unaff_R12 + 6);

-    } while (iVar6 != 0);

-    *(undefined4 *)(unaff_RBP + 0x6f) = 0x100000;

-    if (PpmParkGranularity < 2) {

-      KiCopyAffinityEx(unaff_R12,unaff_R12->Size,(_KAFFINITY_EX *)(puVar18 + 0x98));

+        local_84 = local_84 + 1;

+      } while (local_84 < PpmParkNumNodes);

     }

-    else {

-      memset(&unaff_R12->field3_0x8,0,(ulonglong)unaff_R12->Count << 3);

-      unaff_R12->Count = 1;

-      *(undefined2 *)(unaff_RBP + 0xf) = 0;

-      *(undefined8 *)(unaff_RBP + 7) = *(undefined8 *)(puVar18 + 0x9c);

-      *(_KAFFINITY_EX **)(unaff_RBP + -1) = (_KAFFINITY_EX *)(puVar18 + 0x98);

-      while (iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x77,unaff_RBP + -1), iVar6 == 0) {

-        KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x77));

-        KeAddGroupAffinityEx();

-      }

+    PpmParkComputeDiff();

+    uVar20 = (uint)(PpmParkLpiCap != 0);

+    if ((PpmParkLpiEngaged != uVar20) || (bVar27 = false, PpmParkLpiCapChanged != 0)) {

+      bVar27 = true;

     }

-    KeAndAffinityEx2();

-    iVar6 = KeIsEmptyAffinityEx();

-    if (iVar6 == 0) {

-      *(uint *)(unaff_RBP + 0x6f) = *(uint *)(unaff_RBP + 0x6f) | 0x10000;

+    PpmParkLpiCapChanged = 0;

+    PpmParkLpiEngaged = uVar20;

+    if (bVar27) {

+      PpmEventLPICoreParking();

     }

-    iVar6 = KeCountSetBitsAffinityEx();

-    if ((uint)*puVar18 - iVar6 <= uVar12) {

-      uVar12 = (uint)*puVar18 - iVar6;

-    }

-    memset(&unaff_R12[1].field3_0x8,0,(ulonglong)p_Var1->Count << 3);

-    bVar19 = KiClockTimerPerCpu == '\0';

-    p_Var1->Count = 1;

-    uVar7 = KiClockTimerOwner;

-    unaff_R14D = 0;

-    if (bVar19) {

-      *(undefined4 *)(unaff_RBP + 0x77) = KiClockTimerOwner;

-      iVar6 = KeCheckProcessorAffinityEx(unaff_R12 + 6);

-      if (((iVar6 != 0) && (unaff_R14D = 0, uVar12 != 0)) &&

-         (iVar6 = KeCheckProcessorAffinityEx(), iVar6 == 0)) {

-        lVar9 = KeGetPrcb(uVar7);

-        if (PpmParkGranularity < 2) {

-          KeAddProcessorAffinityEx(p_Var1);

-        }

-        else {

-          KeAddGroupAffinityEx(p_Var1,*(undefined1 *)(lVar9 + 0xd0),*(undefined8 *)(lVar9 + 0x8e60))

-          ;

-        }

-        *(uint *)(unaff_RBP + 0x6f) = *(uint *)(unaff_RBP + 0x6f) | 0x100;

-        unaff_R14D = KeCountSetBitsAffinityEx(p_Var1);

-      }

-    }

-    memset(&unaff_R12[2].field3_0x8,0,(ulonglong)unaff_R12[2].Count << 3);

-    unaff_R12[2].Count = 1;

-    uVar5 = KeCpuSetQueryUnparkRecommendationEx();

-    *(uint *)(unaff_RBP + 0x67) = (uint)uVar5;

-    if (uVar5 != 0) {

-      p_Var1 = unaff_R12 + 2;

-      if (1 < PpmParkGranularity) {

-        *(undefined2 *)(unaff_RBP + 0xf) = 0;

-        *(undefined8 *)(unaff_RBP + 7) = **(undefined8 **)(unaff_RBP + -0x19);

-        *(_KAFFINITY_EX **)(unaff_RBP + -1) = p_Var1;

-        iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x77);

-        while (iVar6 == 0) {

-          lVar9 = KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x77));

-          KeAddGroupAffinityEx(p_Var1,*(undefined1 *)(lVar9 + 0xd0),*(undefined8 *)(lVar9 + 0x8e60))

-          ;

-          iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x77);

-        }

-        uVar7 = KeCountSetBitsAffinityEx(p_Var1);

-        *(undefined4 *)(unaff_RBP + 0x67) = uVar7;

-      }

-      p_Var16 = unaff_R12 + 1;

-      *(ulong64 *)(unaff_RBP + 7) = unaff_R12[2].field3_0x8.Bitmap[0];

-      *(undefined2 *)(unaff_RBP + 0xf) = 0;

-      *(_KAFFINITY_EX **)(unaff_RBP + -1) = p_Var1;

-      iVar6 = KeEnumerateNextProcessor();

-      if (iVar6 == 0) {

-        do {

-          if (unaff_R14D < uVar12) {

-            uVar7 = *(undefined4 *)(unaff_RBP + 0x77);

-            iVar6 = KeCheckProcessorAffinityEx();

-            if (iVar6 == 0) {

-              lVar9 = KeGetPrcb(uVar7);

-              if (PpmParkGranularity < 2) {

-                KeAddProcessorAffinityEx(p_Var16,uVar7);

-              }

-              else {

-                KeAddGroupAffinityEx

-                          (p_Var16,*(undefined1 *)(lVar9 + 0xd0),*(undefined8 *)(lVar9 + 0x8e60));

-              }

-              *(uint *)(unaff_RBP + 0x6f) = *(uint *)(unaff_RBP + 0x6f) | 0x10;

-              unaff_R14D = KeCountSetBitsAffinityEx(p_Var16);

-            }

-          }

-          iVar6 = KeEnumerateNextProcessor();

-        } while (iVar6 == 0);

-        uVar14 = *(ulonglong *)(unaff_RBP + -0x11);

-      }

-    }

-    uVar5 = puVar18[1];

-    if ((unaff_R14D < uVar5) && (unaff_R14D < uVar12)) {

-      unaff_R14D = uVar12;

-      if (uVar5 < uVar12) {

-        unaff_R14D = (uint)uVar5;

-      }

-      uVar17 = *(uint *)(unaff_RBP + 0x6f) | 4;

-      *(uint *)(unaff_RBP + 0x6f) = uVar17;

-    }

-    else {

-      uVar17 = *(uint *)(unaff_RBP + 0x6f);

-    }

-    uVar5 = puVar18[2];

-    if ((uVar5 < uVar12) && (unaff_R14D < uVar12)) {

-      uVar17 = uVar17 | 8;

-      *(uint *)(unaff_RBP + 0x6f) = uVar17;

-      uVar12 = (uint)uVar5;

-      if (uVar5 <= unaff_R14D) {

-        uVar12 = unaff_R14D;

-      }

-    }

-    uVar5 = 0;

-    uVar11 = PpmHeteroHgsContainmentState & 8;

-    if (uVar11 != 0) {

-      uVar5 = *(ushort *)

-               (*(longlong *)(uVar14 + 0x4f8) + 8 +

-               (longlong)*(int *)(*(longlong *)(uVar14 + 0x4f8) + 4) * 2);

-    }

-    uVar3 = *puVar18;

-    uVar4 = puVar18[3];

-    if (uVar3 <= puVar18[3]) {

-      uVar4 = uVar3;

-    }

-    uVar15 = (uint)uVar4;

-    if ((PpmCheckLatencyBoostActive != 0) &&

-       (uVar10 = ((uint)*(byte *)((ulonglong)(*(int *)(unaff_RBP + 0x7f) != 0) + 0x89 +

-                                 *(longlong *)(unaff_RBP + -9)) * (uint)uVar3 + 0x32) / 100,

-       uVar4 < uVar10)) {

-      uVar17 = uVar17 | 0x40;

-      *(uint *)(unaff_RBP + 0x6f) = uVar17;

-      uVar15 = uVar10;

-    }

-    if (1 < PpmParkGranularity) {

-      uVar15 = uVar15 + (PpmParkGranularity - 1);

-      uVar15 = uVar15 - uVar15 % (uint)PpmParkGranularity;

-    }

-    param_1 = 0;

-    if (((uVar11 != 0) && (uVar5 != 0)) && (uVar5 < (ushort)uVar15)) {

-      uVar15 = (uint)uVar5;

-      *(uint *)(unaff_RBP + 0x6f) = uVar17 | 0x400000;

-    }

-    uVar17 = *(int *)(unaff_RBP + 0x67) + uVar15;

-    puVar18[4] = (ushort)uVar15;

-    if (uVar12 <= uVar17) {

-      uVar17 = uVar12;

-    }

-    unaff_R13D = unaff_R14D;

-    if (unaff_R14D < uVar17) {

-      unaff_R13D = uVar17;

-    }

-    *(int *)(unaff_RBP + -0x29) = *(int *)(unaff_RBP + -0x29) - uVar12;

-    bVar19 = PpmParkSoftParkingEnabled == '\0';

-    puVar18[5] = (ushort)unaff_R13D;

-    if (bVar19) {

-      *(uint *)(unaff_RBP + 0x6f) = *(uint *)(unaff_RBP + 0x6f) | 0x200000;

-      unaff_ESI = unaff_R13D;

-    }

-    else {

-      unaff_ESI = uVar12;

-      if (uVar11 != 0) {

-        *(uint *)(unaff_RBP + 0x6f) = *(uint *)(unaff_RBP + 0x6f) | 0x800000;

-        unaff_ESI = (uint)uVar5;

-        if (uVar12 < uVar5) {

-          unaff_ESI = uVar12;

-        }

-      }

-    }

-    in_ZF = PpmHeteroHgsParkingEnabled == '\0';

-  } while( true );

+  }

+  return 1;

 }
```

## `PpmEventHgsContainmentHwUpdate`  (modified)

```diff
--- PpmEventHgsContainmentHwUpdate
+++ PpmEventHgsContainmentHwUpdate
@@ -1,9 +1,47 @@
 

-void PpmEventHgsContainmentHwUpdate(char param_1,longlong param_2)

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

+

+void PpmEventHgsContainmentHwUpdate(longlong param_1,undefined8 param_2,char param_3)

 

 {

-  *(char *)(param_2 + -0x75) = *(char *)(param_2 + -0x75) + param_1;

-  MiReturnCrossPartitionSectionCharges();

+  char cVar1;

+  undefined *puVar2;

+  undefined1 auStack_78 [32];

+  undefined8 local_58;

+  undefined8 local_50;

+  undefined4 local_48;

+  longlong *local_40;

+  longlong local_38;

+  undefined4 local_30;

+  undefined4 local_2c;

+  undefined8 local_28;

+  undefined4 local_20;

+  undefined4 local_1c;

+  ulonglong local_18;

+  

+  local_18 = __security_cookie ^ (ulonglong)auStack_78;

+  if ((PpmHeteroHgsContainmentState & 4) != 0) {

+    puVar2 = &PPM_ETW_WPS_CONTAINMENT_HW_RUNDOWN;

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

+      puVar2 = &PPM_ETW_WPS_CONTAINMENT_HW_UPDATE;

+    }

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

+      cVar1 = EtwEventEnabled(PpmEtwHandle,puVar2);

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

+        local_2c = 0;

+        local_38 = param_1 + 8;

+        local_1c = 0;

+        local_40 = &local_38;

+        local_30 = 8;

+        local_48 = 2;

+        local_50 = 0;

+        local_58 = 0;

+        local_20 = 4;

+        local_28 = param_2;

+        EtwWriteEx(PpmEtwHandle,puVar2,0,0);

+      }

+    }

+  }

   return;

 }
```

## `PpmParkApplyPolicy`  (modified)

```diff
--- PpmParkApplyPolicy
+++ PpmParkApplyPolicy
@@ -1,122 +1,303 @@
 

-/* WARNING: Instruction at (ram,0x0001404e5e15) overlaps instruction at (ram,0x0001404e5e14)

-    */

-/* WARNING: This function may have set the stack pointer */

-

-void PpmParkApplyPolicy(undefined8 param_1,ulonglong param_2,uint param_3)

+void PpmParkApplyPolicy(void)

 

 {

   ushort *puVar1;

+  ulonglong uVar2;

+  bool bVar3;

+  undefined *puVar4;

   void *_Dst;

-  ulonglong in_RAX;

-  longlong lVar2;

-  ushort uVar3;

-  ulonglong uVar4;

-  uint uVar5;

-  char cVar6;

-  undefined4 uVar7;

-  ulonglong unaff_RDI;

-  char cVar8;

-  short in_R11W;

-  int unaff_R14D;

-  int unaff_R15D;

+  int iVar5;

+  int iVar6;

+  longlong lVar7;

+  longlong lVar8;

+  uint uVar9;

+  uint uVar10;

+  longlong lVar11;

+  ulonglong uVar12;

+  ulonglong uVar13;

+  ulonglong uVar14;

+  undefined8 uVar15;

+  byte bVar16;

+  ushort uVar17;

+  uint uVar18;

+  byte *pbVar19;

+  ulonglong uVar20;

+  byte bVar21;

+  uint uVar22;

+  byte bVar23;

+  char cVar24;

+  ulonglong uVar25;

+  uint uVar26;

+  uint uVar27;

+  char local_res10;

+  ushort local_res18;

+  undefined4 local_res20 [2];

+  ulonglong local_80;

+  ulonglong local_78;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

   

-  uVar7 = (undefined4)unaff_RDI;

-  do {

-    lVar2 = in_RAX * 0x508 + PpmParkNodes;

-    if ((*(ushort *)(lVar2 + 10) != 0) &&

-       ((ushort)(byte)(*(char *)(lVar2 + 0x490) + (char)PpmParkGranularity) <

-        *(ushort *)(lVar2 + 10))) {

-      *(short *)(lVar2 + 0x490) = *(short *)(lVar2 + 0x490) + PpmParkGranularity;

-      unaff_R14D = unaff_R14D - (uint)PpmParkGranularity;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_res20[0] = 0;

+  local_58 = 0;

+  iVar5 = Feature_PpmParkEx__private_IsEnabledDeviceUsageNoInline();

+  puVar4 = PpmCurrentProfile;

+  if (iVar5 == 0) {

+    if (PpmParkNodes == 0) {

+      KeSoftParkedQueueThreshold = 0;

     }

-    uVar3 = (short)param_2 + in_R11W;

-    in_RAX = (ulonglong)uVar3;

-    if (param_3 <= uVar3) {

-      do {

-        if (unaff_R14D == 0) goto LAB_0;

-        in_RAX = unaff_RDI & 0xffff;

-      } while (param_3 == 0);

-    }

-    param_2 = in_RAX;

-  } while (unaff_R14D != 0);

-LAB_0:

-  do {

-    if (unaff_R15D == 0) {

+    else {

+      lVar11 = (longlong)DAT_0 * 0x1e8;

+      PpmParkEvalualteSmtUnparkPolicy

+                (CONCAT71((int7)((ulonglong)lVar11 >> 8),PpmCurrentProfile[lVar11 + 0x1f2]));

+      bVar3 = false;

+      lVar7 = KeGetPrcb(0);

+      bVar23 = 0x40;

+      if (*(longlong *)(lVar7 + 0x89b0) == 0) {

+        bVar23 = (byte)PpmParkInitialClass1UnParkCount;

+        if (0x40 < PpmParkInitialClass1UnParkCount) {

+          bVar23 = 0x40;

+        }

+        bVar3 = true;

+      }

+      uVar13 = (ulonglong)PpmParkNumNodes;

+      uVar9 = (uint)PpmParkGranularity;

+      uVar14 = PpmParkLpiCap / uVar13;

+      uVar2 = PpmParkThermalCap / uVar13;

+      uVar12 = 0;

+      local_res18 = 0;

+      uVar26 = PpmParkLpiCap;

+      uVar27 = PpmParkThermalCap;

+      if (PpmParkNumNodes != 0) {

+        do {

+          uVar13 = 0;

+          uVar18 = (int)uVar14 - (int)(uVar14 % (ulonglong)uVar9) & 0xff;

+          lVar7 = uVar12 * 0x508 + PpmParkNodes;

+          if ((int)((uint)*(ushort *)(lVar7 + 10) - (uint)PpmParkGranularity) < (int)uVar18) {

+            uVar18 = (uint)(byte)(*(char *)(lVar7 + 10) - (char)PpmParkGranularity);

+          }

+          uVar26 = uVar26 - uVar18;

+          uVar10 = (int)uVar2 - (int)(uVar2 % (ulonglong)uVar9) & 0xff;

+          *(short *)(lVar7 + 0x490) = (short)uVar18;

+          if ((int)((uint)*(ushort *)(lVar7 + 10) - (uint)PpmParkGranularity) < (int)uVar10) {

+            uVar10 = (uint)(byte)(*(char *)(lVar7 + 10) - (char)PpmParkGranularity);

+          }

+          uVar27 = uVar27 - uVar10;

+          local_res10 = '\0';

+          cVar24 = '\0';

+          *(short *)(lVar7 + 0x494) = (short)uVar10;

+          local_80 = 0;

+          local_78 = 0;

+          uVar12 = uVar13;

+          uVar20 = uVar13;

+          if (*(char *)(lVar7 + 0xc) == '\0') {

 LAB_1:

-      uVar4 = unaff_RDI & 0xffff;

-      if (param_3 != 0) {

+            uVar17 = PpmParkGranularity;

+            lVar8 = *(longlong *)(lVar7 + 0x500);

+            *(ushort *)(lVar8 + 2) = PpmParkGranularity;

+            if (uVar17 <= *(ushort *)(lVar8 + 4)) {

+              uVar17 = *(ushort *)(lVar8 + 4);

+            }

+            *(ushort *)(lVar8 + 4) = uVar17;

+          }

+          else {

+            do {

+              uVar25 = 0;

+              iVar5 = (int)uVar12;

+              pbVar19 = (byte *)(uVar12 * 0x280 + *(longlong *)(lVar7 + 0x500));

+              uVar18 = (uint)(byte)puVar4[(ulonglong)(iVar5 != 0) + 0x9c + lVar11 + 0x28];

+              if ((bVar3) && (iVar5 != 0)) {

+                uVar18 = 0;

+              }

+              if (*pbVar19 != 0) {

+                uVar10 = (uint)*pbVar19;

+                uVar22 = ((byte)puVar4[(ulonglong)(iVar5 != 0) + 0x9e + lVar11 + 0x28] * uVar10 +

+                         0x32) / 100;

+                bVar21 = (char)uVar22 +

+                         (char)((int)(uVar10 - (uVar22 & 0xff)) % (int)(uint)PpmParkGranularity);

+                uVar18 = (uVar18 * uVar10 + 0x32) / 100;

+                bVar16 = (char)uVar18 +

+                         (char)((int)(uVar10 - (uVar18 & 0xff)) % (int)(uint)PpmParkGranularity);

+                if ((iVar5 != 0) && (bVar23 <= bVar21)) {

+                  bVar21 = bVar23;

+                }

+                if ((bVar16 != 0) && (bVar16 < (byte)PpmParkGranularity)) {

+                  bVar16 = (byte)PpmParkGranularity;

+                }

+                local_68 = 0;

+                if (bVar21 < bVar16) {

+                  bVar21 = bVar16;

+                }

+                uStack_60 = *(undefined8 *)(pbVar19 + 0x18);

+                local_58 = CONCAT62(local_58._2_6_,*(undefined2 *)(lVar7 + 4));

+                iVar6 = KeEnumerateNextProcessor(local_res20,&local_68);

+                while (iVar6 == 0) {

+                  lVar8 = KeGetPrcb(local_res20[0]);

+                  if (*(char *)(lVar8 + 0x8a4c) != '\0') {

+                    uVar25 = uVar25 | *(ulonglong *)(lVar8 + 200);

+                  }

+                  iVar6 = KeEnumerateNextProcessor(local_res20,&local_68);

+                }

+                uVar20 = local_80 | *(ulonglong *)(pbVar19 + 0x20);

+                uVar13 = local_78 | uVar25;

+                *(ulonglong *)(pbVar19 + 0x20) = uVar25;

+                cVar24 = local_res10 + bVar16;

+                *(ushort *)(pbVar19 + 4) = (ushort)bVar21;

+                *(ushort *)(pbVar19 + 2) = (ushort)bVar16;

+                local_res10 = cVar24;

+                local_80 = uVar20;

+                local_78 = uVar13;

+              }

+              uVar12 = (ulonglong)(iVar5 + 1U);

+            } while (iVar5 + 1U < (uint)*(byte *)(lVar7 + 0xc));

+            if (uVar20 != uVar13) {

+              PpmEventParkNodeParkHintChanged

+                        (*(undefined2 *)(lVar7 + 4),*(undefined8 *)(lVar7 + 0x10),uVar13);

+            }

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

+          }

+          if (PpmHeteroPolicy == 2) {

+            *(byte *)(lVar7 + 0x4a0) = *(byte *)(lVar7 + 0x4a0) | 4;

+            lVar8 = *(longlong *)(lVar7 + 0x500);

+            uVar17 = *(ushort *)(lVar8 + 2);

+            if (uVar17 < 2) {

+              uVar17 = 1;

+            }

+            *(ushort *)(lVar8 + 2) = uVar17;

+            uVar17 = *(ushort *)(lVar8 + 4);

+            if (uVar17 < 2) {

+              uVar17 = 1;

+            }

+            *(ushort *)(lVar8 + 4) = uVar17;

+            uVar12 = 1;

+            if (1 < *(byte *)(lVar7 + 0xc)) {

+              do {

+                uVar18 = (int)uVar12 + 1;

+                *(undefined8 *)(uVar12 * 0x280 + *(longlong *)(lVar7 + 0x500) + 2) = 0;

+                uVar12 = (ulonglong)uVar18;

+              } while (uVar18 < *(byte *)(lVar7 + 0xc));

+            }

+          }

+          else if ((PpmHeteroPolicy == 3) && (*(char *)(lVar7 + 0x4a1) != '\0')) {

+            *(byte *)(lVar7 + 0x4a0) = *(byte *)(lVar7 + 0x4a0) | 2;

+            uVar13 = 0;

+            uVar12 = uVar13;

+            if (1 < *(byte *)(lVar7 + 0xc)) {

+              do {

+                iVar5 = (int)uVar12;

+                uVar13 = (ulonglong)(iVar5 + 1);

+                *(undefined8 *)(uVar12 * 0x280 + *(longlong *)(lVar7 + 0x500) + 2) = 0;

+                uVar12 = uVar13;

+              } while (iVar5 + 2U < (uint)*(byte *)(lVar7 + 0xc));

+            }

+            lVar8 = uVar13 * 0x280 + *(longlong *)(lVar7 + 0x500);

+            uVar17 = *(ushort *)(lVar8 + 2);

+            if (uVar17 < 2) {

+              uVar17 = 1;

+            }

+            *(ushort *)(lVar8 + 2) = uVar17;

+            uVar17 = *(ushort *)(lVar8 + 4);

+            if (uVar17 < 2) {

+              uVar17 = 1;

+            }

+            *(ushort *)(lVar8 + 4) = uVar17;

+          }

+          PpmConfigureRestrictionPolicy(lVar7);

+          uVar13 = (ulonglong)PpmParkNumNodes;

+          local_res18 = local_res18 + 1;

+          uVar12 = (ulonglong)local_res18;

+        } while (local_res18 < PpmParkNumNodes);

+      }

+      while (uVar9 = (uint)uVar13, uVar26 != 0) {

+        uVar14 = 0;

+        if (uVar9 != 0) {

+          do {

+            if (uVar26 == 0) goto LAB_2;

+            lVar7 = uVar14 * 0x508 + PpmParkNodes;

+            if ((*(ushort *)(lVar7 + 10) != 0) &&

+               ((ushort)(byte)(*(char *)(lVar7 + 0x490) + (char)PpmParkGranularity) <

+                *(ushort *)(lVar7 + 10))) {

+              *(short *)(lVar7 + 0x490) = *(short *)(lVar7 + 0x490) + PpmParkGranularity;

+              uVar26 = uVar26 - PpmParkGranularity;

+            }

+            uVar17 = (short)uVar14 + 1;

+            uVar14 = (ulonglong)uVar17;

+          } while (uVar17 < uVar9);

+        }

+      }

+LAB_2:

+      if (uVar27 != 0) {

+        uVar14 = 0;

+        if (uVar9 != 0) {

+          do {

+            if (uVar27 == 0) goto LAB_3;

+            lVar7 = uVar14 * 0x508 + PpmParkNodes;

+            if ((*(ushort *)(lVar7 + 10) != 0) &&

+               ((ushort)(byte)(*(char *)(lVar7 + 0x494) + (char)PpmParkGranularity) <

+                *(ushort *)(lVar7 + 10))) {

+              *(short *)(lVar7 + 0x494) = *(short *)(lVar7 + 0x494) + PpmParkGranularity;

+              uVar27 = uVar27 - PpmParkGranularity;

+            }

+            uVar17 = (short)uVar14 + 1;

+            uVar14 = (ulonglong)uVar17;

+          } while (uVar17 < uVar9);

+        }

+        goto LAB_2;

+      }

+LAB_3:

+      uVar14 = 0;

+      if (uVar9 != 0) {

         do {

-          lVar2 = uVar4 * 0x508 + PpmParkNodes;

-          puVar1 = (ushort *)(lVar2 + 0x494);

-          if (((uint)*(ushort *)(lVar2 + 0x492) !=

-               (uint)*(ushort *)(lVar2 + 10) - (uint)*(ushort *)(lVar2 + 0x490)) ||

-             ((uint)*(ushort *)(lVar2 + 0x496) != (uint)*(ushort *)(lVar2 + 10) - (uint)*puVar1)) {

-            uRam000000000efffff8 = 0x1404e5f45;

+          lVar7 = uVar14 * 0x508 + PpmParkNodes;

+          puVar1 = (ushort *)(lVar7 + 0x494);

+          if (((uint)*(ushort *)(lVar7 + 0x492) !=

+               (uint)*(ushort *)(lVar7 + 10) - (uint)*(ushort *)(lVar7 + 0x490)) ||

+             ((uint)*(ushort *)(lVar7 + 0x496) != (uint)*(ushort *)(lVar7 + 10) - (uint)*puVar1)) {

             PpmEventParkNodeCapChange

-                      (*(undefined2 *)(lVar2 + 4),*(undefined8 *)(lVar2 + 0x10),

-                       *(undefined1 *)(lVar2 + 0x490),*(undefined1 *)puVar1);

-            in_R11W = 1;

-            *(ushort *)(lVar2 + 0x496) = *(short *)(lVar2 + 10) - *puVar1;

-            *(short *)(lVar2 + 0x492) = *(short *)(lVar2 + 10) - *(short *)(lVar2 + 0x490);

-          }

-          uVar3 = (short)uVar4 + in_R11W;

-          uVar4 = (ulonglong)uVar3;

-        } while (uVar3 < PpmParkNumNodes);

-        uVar7 = 0;

-      }

-      cVar6 = (char)uVar7;

-      uVar5 = *(uint *)(lRam000000000f000048 + 0xa0);

-      cVar8 = cVar6;

-      if (((PpmPerfMaxOverrideEnabled != cVar6) && (PpmHighPerfSoftParkLatencyUs != 0)) &&

-         ((uVar5 == 0 || (PpmHighPerfSoftParkLatencyUs < uVar5)))) {

-        cVar8 = (char)in_R11W;

-        uVar5 = PpmHighPerfSoftParkLatencyUs;

-      }

-      uRam000000000efffff8 = 0x1404e5fb4;

-      PpmEventSoftParkLatencyUpdate(0,cVar8,uVar5);

+                      (*(undefined2 *)(lVar7 + 4),*(undefined8 *)(lVar7 + 0x10),

+                       *(undefined1 *)(lVar7 + 0x490),*(undefined1 *)puVar1);

+            *(ushort *)(lVar7 + 0x496) = *(short *)(lVar7 + 10) - *puVar1;

+            *(short *)(lVar7 + 0x492) = *(short *)(lVar7 + 10) - *(short *)(lVar7 + 0x490);

+          }

+          uVar17 = (short)uVar14 + 1;

+          uVar14 = (ulonglong)uVar17;

+        } while (uVar17 < PpmParkNumNodes);

+      }

+      uVar15 = 0;

+      uVar26 = *(uint *)(puVar4 + lVar11 + 200);

+      if (((PpmPerfMaxOverrideEnabled != '\0') && (PpmHighPerfSoftParkLatencyUs != 0)) &&

+         ((uVar26 == 0 || (PpmHighPerfSoftParkLatencyUs < uVar26)))) {

+        uVar15 = 1;

+        uVar26 = PpmHighPerfSoftParkLatencyUs;

+      }

+      PpmEventSoftParkLatencyUpdate(0,uVar15,uVar26);

       _Dst = PpmParkOldSoftParkRankList;

-      if (uVar5 == 0) {

-        KeSoftParkedQueueThreshold = uVar7;

-        PpmParkSoftParkingEnabled = cVar6;

+      if (uVar26 == 0) {

+        PpmParkSoftParkingEnabled = 0;

+        KeSoftParkedQueueThreshold = 0;

         if ((PpmParkNewSoftParkRankList != (void *)0x0) &&

            (PpmParkOldSoftParkRankList != (void *)0x0)) {

-          uRam000000000efffff8 = 0x1404e5ff4;

           memset(PpmParkNewSoftParkRankList,0xff,(ulonglong)KeMaximumProcessors << 2);

-          uRam000000000efffff8 = 0x1404e6009;

           memset(_Dst,0xff,(ulonglong)KeMaximumProcessors << 2);

-          uRam000000000efffff8 = 0x1404e600e;

           KeUpdateSoftParkRankList();

-          uRam000000000efffff8 = 0x1404e6013;

           PpmEventSoftParkRankListChanged();

         }

       }

       else {

-        PpmParkSoftParkingEnabled = '\x01';

-        uRam000000000efffff8 = 0x1404e603c;

+        PpmParkSoftParkingEnabled = 1;

         KeSoftParkedQueueThreshold =

-             PpmConvertTime((ulonglong)*(uint *)((longlong)FiberData + 0x44) * 1000000,1000000,uVar5

-                           );

-      }

-      uRam000000000efffff8 = 0x1404e6047;

+             PpmConvertTime((ulonglong)*(uint *)((longlong)FiberData + 0x44) * 1000000,1000000,

+                            uVar26);

+      }

       PpmHeteroHgsCheckContainmentDecision();

-      return;

     }

-    uVar4 = unaff_RDI & 0xffff;

-    if (param_3 != 0) {

-      do {

-        if (unaff_R15D == 0) goto LAB_1;

-        lVar2 = uVar4 * 0x508 + PpmParkNodes;

-        if ((*(ushort *)(lVar2 + 10) != 0) &&

-           ((ushort)(byte)(*(char *)(lVar2 + 0x494) + (char)PpmParkGranularity) <

-            *(ushort *)(lVar2 + 10))) {

-          *(short *)(lVar2 + 0x494) = *(short *)(lVar2 + 0x494) + PpmParkGranularity;

-          unaff_R15D = unaff_R15D - (uint)PpmParkGranularity;

-        }

-        uVar3 = (short)uVar4 + in_R11W;

-        uVar4 = (ulonglong)uVar3;

-      } while (uVar3 < param_3);

-    }

-  } while( true );

+  }

+  else {

+    PpmParkApplyPolicyEx();

+  }

+  return;

 }
```

## `PpmPerfSetMaximumOverride`  (modified)

```diff
--- PpmPerfSetMaximumOverride
+++ PpmPerfSetMaximumOverride
@@ -1,414 +1,12 @@
 

-int PpmPerfSetMaximumOverride

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

-              undefined8 param_5,int param_6,ulonglong param_7,byte *param_8,ulonglong param_9)

+void PpmPerfSetMaximumOverride(void)

 

 {

-  int *piVar1;

-  uint uVar2;

-  undefined8 uVar3;

-  longlong lVar4;

-  undefined4 *puVar5;

-  undefined8 *puVar6;

-  undefined4 uVar7;

-  undefined4 uVar8;

-  undefined4 uVar9;

-  longlong lVar10;

-  longlong lVar11;

-  longlong lVar12;

-  char cVar13;

-  uint uVar14;

-  int iVar15;

-  longlong lVar16;

-  ulonglong *puVar17;

-  ulonglong uVar18;

-  uint uVar19;

-  ulonglong uVar20;

-  int unaff_EBX;

-  undefined8 *puVar21;

-  ulonglong uVar22;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  byte *pbVar23;

-  ulonglong uVar24;

-  longlong lVar25;

-  longlong lVar26;

-  undefined4 *puVar27;

-  uint in_R10D;

-  ulonglong in_R11;

-  ulonglong uVar28;

-  longlong *unaff_R12;

-  undefined4 *puVar29;

-  int unaff_R13D;

-  uint uVar30;

-  ulonglong unaff_R14;

-  longlong unaff_R15;

-  bool bVar31;

-  undefined8 in_stack_00000020;

-  undefined4 uVar32;

-  

-  uVar32 = (undefined4)((ulonglong)in_stack_00000020 >> 0x20);

-  while (uVar30 = (uint)unaff_R14, (uint)in_R11 < uVar30) {

-    piVar1 = (int *)(unaff_R15 + 8 + in_R11 * 0xc);

-    *piVar1 = *piVar1 + 1;

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

-    while (*(uint *)(param_2 + 0x28) <= (uint)param_4) {

-      uVar14 = *(uint *)(unaff_RBP + 0x67);

-      param_4 = 0;

-      uVar19 = in_R10D;

-      do {

-        iVar15 = (int)param_3;

-        if (((*(byte *)(param_2 + 0x10) & 4) != 0) &&

-           (bVar31 = unaff_EBX != unaff_R13D, unaff_EBX = iVar15, param_6 = iVar15, bVar31))

-        goto LAB_0;

-        param_3 = (ulonglong)(iVar15 + 1U);

-        if (uVar30 <= iVar15 + 1U) {

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

-          *(ulonglong *)(unaff_RBP + -0x21) = unaff_R14 * 8;

-          lVar26 = unaff_R14 * 0x1e0;

-          *(longlong *)(unaff_RBP + -0x61) = lVar26;

-          param_9 = 0;

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

-          param_8 = (byte *)0x0;

-          uVar22 = (ulonglong)uVar19 * 0x18 + lVar26;

-          uVar18 = uVar22;

-          uVar24 = uVar22 + 0x138;

-          if (*(char *)(unaff_RBP + 0x77) < '\x01') {

-            uVar18 = param_4;

-            uVar24 = uVar22;

-          }

-          *(ulonglong *)(unaff_RBP + -9) = uVar18;

-          uVar22 = uVar24;

-          if (uVar14 != 0) {

-            param_8 = (byte *)(uVar24 + (ulonglong)uVar14 * 8);

-            uVar22 = uVar24 + (ulonglong)uVar14 * 0x10;

-            param_9 = uVar24;

-          }

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

-          uVar14 = uVar30 * PopFxRuntimeLogNumberEntries;

-          *(uint *)(unaff_RBP + -0x59) = uVar14;

-          *(ulonglong *)(unaff_RBP + -0x41) = uVar22 + (ulonglong)uVar14 * 0x18;

-          lVar25 = (longlong)(int)(uVar30 * 8) + 0x10;

-          *(longlong *)(unaff_RBP + -0x19) = lVar25;

-          lVar25 = lVar25 + unaff_R14 * 0x28;

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

-          lVar25 = lVar25 + (ulonglong)uVar19 * 0x18;

-          *(longlong *)(unaff_RBP + -0x31) = lVar25;

-          iVar15 = PopFxFindAcpiDeviceByUniqueId(uVar3,unaff_RBP + -0x79);

-          if (iVar15 < 0) {

-            if (iVar15 == -0x3fffffaa) {

-              iVar15 = -0x3fffff5d;

-            }

-            else {

-              uVar32 = (undefined4)((ulonglong)&param_7 >> 0x20);

-              iVar15 = PopFxCreateDeviceCommon(uVar3);

-              if (param_7 != 0) {

-                lVar26 = *(longlong *)(unaff_RBP + -0x61);

-                goto LAB_1;

-              }

-            }

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

-            goto LAB_2;

-          }

-          param_7 = *(ulonglong *)(unaff_RBP + -0x79);

-          LOCK();

-          *(uint *)(param_7 + 0xe8) = *(uint *)(param_7 + 0xe8) | 1;

-          UNLOCK();

-LAB_1:

-          uVar24 = param_7;

-          IoInitializeRemoveLockEx(param_7 + 0xf0,0x4d584650,0,0,CONCAT44(uVar32,0x20));

-          lVar16 = ExAllocatePool2(0x40,*(undefined8 *)(unaff_RBP + -0x41),0x4d584650);

-          if (lVar16 != 0) {

-            puVar17 = (ulonglong *)ExAllocatePool2(0x40,lVar25,0x4d584650);

-            uVar18 = 0;

-            if (puVar17 != (ulonglong *)0x0) {

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

-              lVar4 = *unaff_R12;

-              lVar10 = unaff_R12[1];

-              lVar11 = unaff_R12[2];

-              lVar12 = unaff_R12[3];

-              lVar25 = *(longlong *)(unaff_RBP + -0x21);

-              *(uint *)(uVar24 + 0x364) = uVar30;

-              puVar27 = (undefined4 *)(lVar25 + lVar16);

-              *(longlong *)(uVar24 + 0x368) = lVar16;

-              *(longlong *)(uVar24 + 0x70) = lVar4;

-              *(longlong *)(uVar24 + 0x78) = lVar10;

-              *(undefined4 **)(unaff_RBP + -0x29) = puVar27;

-              lVar25 = unaff_R12[4];

-              lVar4 = unaff_R12[5];

-              *(longlong *)(uVar24 + 0x80) = lVar11;

-              *(longlong *)(uVar24 + 0x88) = lVar12;

-              lVar10 = unaff_R12[6];

-              lVar11 = unaff_R12[7];

-              *(longlong *)(uVar24 + 0x90) = lVar25;

-              *(longlong *)(uVar24 + 0x98) = lVar4;

-              lVar25 = unaff_R12[8];

-              uVar32 = *(undefined4 *)((longlong)unaff_R12 + 0x44);

-              lVar4 = unaff_R12[9];

-              uVar7 = *(undefined4 *)((longlong)unaff_R12 + 0x4c);

-              *(longlong *)(uVar24 + 0xa0) = lVar10;

-              *(longlong *)(uVar24 + 0xa8) = lVar11;

-              *(int *)(uVar24 + 0xb0) = (int)lVar25;

-              *(undefined4 *)(uVar24 + 0xb4) = uVar32;

-              *(int *)(uVar24 + 0xb8) = (int)lVar4;

-              *(undefined4 *)(uVar24 + 0xbc) = uVar7;

-              *(undefined8 *)(uVar24 + 0xc0) = uVar3;

-              *(int *)(uVar24 + 0x3b8) = param_6;

-              lVar25 = uVar24 + 0x518;

-              *(undefined8 *)(uVar24 + 0x280) = 0;

-              *(undefined8 *)(uVar24 + 0x28c) = 5;

-              *(longlong *)(uVar24 + 0x520) = lVar25;

-              *(longlong *)lVar25 = lVar25;

-              *puVar17 = *(ulonglong *)(unaff_RBP + 0x7f);

-              *(longlong *)(unaff_RBP + -0x71) = lVar26 + lVar16;

-              *(uint *)(puVar17 + 1) = uVar30;

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

-                *(ulonglong *)(unaff_RBP + -0x51) = param_9 + lVar16;

-                *(byte **)(unaff_RBP + -0x49) = param_8 + lVar16;

-              }

-              puVar21 = (undefined8 *)(puVar27 + 0xc);

-              *(byte **)(unaff_RBP + -0x61) =

-                   (byte *)(*(longlong *)(unaff_RBP + -0x19) + (longlong)puVar17);

-              lVar26 = -0x30 - lVar16;

-              param_8 = (byte *)(*(longlong *)(unaff_RBP + -0x39) + (longlong)puVar17);

-              *(longlong *)(unaff_RBP + -0x11) = lVar26;

-              param_9 = -(longlong)puVar17 - 0x10;

-              goto LAB_3;

-            }

-          }

-          iVar15 = -0x3fffff66;

-          goto LAB_4;

-        }

-        param_2 = param_3 * 0x38 + unaff_RDI;

-        uVar2 = *(uint *)(param_2 + 0x1c);

-        if ((uVar2 == 0) ||

-           (((1 < uVar2 &&

-             ((((*unaff_R12 == 0 || (unaff_R12[1] == 0)) || (unaff_R12[2] == 0)) ||

-              (uVar2 <= *(uint *)(param_2 + 0x18))))) ||

-            (in_R10D = uVar2 + uVar19, in_R10D < uVar19)))) goto LAB_0;

-        uVar2 = *(uint *)(param_2 + 0x28);

-        uVar19 = in_R10D;

-      } while (uVar2 == 0);

-      if ((uVar30 <= uVar2) || (uVar2 + uVar14 < uVar14)) goto LAB_0;

-      *(uint *)(unaff_RBP + 0x67) = uVar2 + uVar14;

-    }

-    in_R11 = (ulonglong)*(uint *)(*(longlong *)(param_2 + 0x30) + param_4 * 4);

-  }

-LAB_0:

-  iVar15 = -0x3ffffff3;

-  goto LAB_2;

-LAB_3:

-  uVar14 = (uint)uVar18;

-  if (uVar30 <= uVar14) goto LAB_5;

-  *(undefined4 **)(*(longlong *)(uVar24 + 0x368) + uVar18 * 8) = puVar27;

-  puVar29 = (undefined4 *)(uVar18 * 0x38 + *(longlong *)(unaff_RBP + 0x5f));

-  if (*(longlong *)(unaff_RBP + -0x41) - 0x1d8U < (ulonglong)(lVar26 + (longlong)puVar21))

-  goto LAB_6;

-  uVar32 = *puVar29;

-  uVar7 = puVar29[1];

-  uVar8 = puVar29[2];

-  uVar9 = puVar29[3];

-  *(uint *)(puVar21 + -4) = uVar14;

-  puVar21[4] = uVar24;

-  *puVar27 = uVar32;

-  puVar27[1] = uVar7;

-  puVar27[2] = uVar8;

-  puVar27[3] = uVar9;

-  puVar21[-1] = PopFxComponentWork;

-  *puVar21 = puVar27;

-  puVar21[-3] = 0;

-  KeInitializeEvent(puVar21 + 7,0,CONCAT71((int7)((ulonglong)lVar26 >> 8),1));

-  lVar26 = *(longlong *)(unaff_RBP + -0x71);

-  uVar28 = 0;

-  puVar21[10] = 0;

-  *(undefined4 *)((longlong)puVar21 + 0x6c) = puVar29[7];

-  puVar21[0xe] = lVar26;

-  uVar32 = puVar29[6];

-  *(undefined4 *)((longlong)puVar21 + 0xa4) = 0xffffffff;

-  *(undefined4 *)(puVar21 + 0xf) = uVar32;

-  puVar6 = puVar21 + 0x33;

-  puVar21[0x13] = 0;

-  *(undefined4 *)(puVar21 + 0x15) = 0;

-  puVar21[0x34] = puVar6;

-  *puVar6 = puVar6;

-  puVar6 = puVar21 + 0x31;

-  puVar21[0x32] = puVar6;

-  *puVar6 = puVar6;

-  iVar15 = puVar29[10];

-  if (iVar15 != 0) {

-    puVar27 = *(undefined4 **)(unaff_RBP + -0x51);

-    puVar21[0x10] = puVar27;

-    *(int *)((longlong)puVar21 + 0x7c) = iVar15;

-    uVar20 = uVar28;

-    do {

-      uVar19 = (int)uVar20 + 1;

-      *puVar27 = *(undefined4 *)(*(longlong *)(puVar29 + 0xc) + uVar20 * 4);

-      puVar27 = puVar27 + 2;

-      uVar20 = (ulonglong)uVar19;

-    } while (uVar19 < *(uint *)((longlong)puVar21 + 0x7c));

-    *(undefined4 **)(unaff_RBP + -0x51) = puVar27;

-  }

-  lVar25 = *(longlong *)(unaff_RBP + -0x69);

-  if (*(int *)(lVar25 + 8 + uVar18 * 0xc) != 0) {

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

-    puVar21[0x12] = lVar4;

-    *(ulonglong *)(unaff_RBP + -0x49) = lVar4 + (ulonglong)*(uint *)(lVar25 + 8 + uVar18 * 0xc) * 8;

-  }

-  puVar5 = *(undefined4 **)(unaff_RBP + -0x61);

-  lVar25 = *(longlong *)(unaff_RBP + -0x31);

-  puVar17[uVar18 + 2] = (ulonglong)puVar5;

-  if (lVar25 - 0x28U < param_9 + 0x10 + (longlong)puVar5) goto LAB_6;

-  uVar32 = puVar29[1];

-  uVar7 = puVar29[2];

-  uVar8 = puVar29[3];

-  *puVar5 = *puVar29;

-  puVar5[1] = uVar32;

-  puVar5[2] = uVar7;

-  puVar5[3] = uVar8;

-  *(undefined8 *)(puVar5 + 4) = *(undefined8 *)(puVar29 + 4);

-  puVar5[7] = puVar29[7];

-  *(byte **)(puVar5 + 8) = param_8;

-  puVar5[6] = puVar29[6];

-  lVar25 = -0x10 - lVar16;

-  param_9 = -(longlong)puVar17 - 0x10;

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

-  for (; (uint)uVar28 < *(uint *)((longlong)puVar21 + 0x6c); uVar28 = (ulonglong)((uint)uVar28 + 1))

-  {

-    if (*(longlong *)(unaff_RBP + -0x41) - 0x18U < (ulonglong)(lVar25 + 0x10 + lVar26))

-    goto LAB_6;

-    lVar25 = *(longlong *)(puVar29 + 8);

-    puVar6 = *(undefined8 **)(unaff_RBP + -0x71);

-    *(undefined4 *)(puVar6 + 2) = *(undefined4 *)(lVar25 + 0x10 + uVar28 * 0x18);

-    *puVar6 = *(undefined8 *)(lVar25 + uVar28 * 0x18);

-    puVar6[1] = *(undefined8 *)(lVar25 + 8 + uVar28 * 0x18);

-    *(undefined8 **)(unaff_RBP + -0x71) = puVar6 + 3;

-    if (*(longlong *)(unaff_RBP + -0x31) - 0x18U <

-        (ulonglong)((longlong)param_8 + -(longlong)puVar17)) goto LAB_6;

-    *(undefined4 *)(param_8 + 0x10) = *(undefined4 *)(lVar25 + 0x10 + uVar28 * 0x18);

-    *(undefined8 *)param_8 = *(undefined8 *)(lVar25 + uVar28 * 0x18);

-    lVar26 = *(longlong *)(unaff_RBP + -0x71);

-    *(undefined8 *)(param_8 + 8) = *(undefined8 *)(lVar25 + 8 + uVar28 * 0x18);

-    param_8 = param_8 + 0x18;

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

-  }

-  puVar27 = (undefined4 *)(*(longlong *)(unaff_RBP + -0x29) + 0x1d8);

-  *(undefined4 **)(unaff_RBP + -0x61) = puVar5 + 10;

-  lVar26 = *(longlong *)(unaff_RBP + -0x11);

-  puVar21 = puVar21 + 0x3b;

-  uVar18 = (ulonglong)(uVar14 + 1);

-  *(undefined4 **)(unaff_RBP + -0x29) = puVar27;

-  goto LAB_3;

-LAB_5:

-  *(undefined4 *)(uVar24 + 0x370) = *(undefined4 *)(unaff_RBP + -0x59);

-  uVar18 = 0;

-  *(ulonglong *)(uVar24 + 0x378) = uVar22 + lVar16;

-  if (*(int *)(unaff_RBP + 0x67) == 0) {

-LAB_7:

-    uVar22 = uVar18;

-    uVar28 = uVar18;

-    if (uVar30 != 0) {

-      do {

-        lVar26 = *(longlong *)(uVar28 + *(longlong *)(uVar24 + 0x368));

-        uVar20 = uVar18;

-        if (*(int *)(lVar26 + 0xac) != 0) {

-          do {

-            lVar25 = *(longlong *)

-                      (*(longlong *)(uVar24 + 0x368) +

-                      (ulonglong)*(uint *)(*(longlong *)(lVar26 + 0xb0) + uVar20 * 8) * 8);

-            uVar14 = *(uint *)(lVar25 + 0xbc);

-            *(int *)(*(longlong *)(lVar25 + 0xc0) + (ulonglong)uVar14 * 8) = (int)uVar22;

-            *(int *)(*(longlong *)(lVar25 + 0xc0) + 4 + (ulonglong)uVar14 * 8) = (int)uVar20;

-            uVar14 = (int)uVar20 + 1;

-            uVar20 = (ulonglong)uVar14;

-            *(int *)(lVar25 + 0xbc) = *(int *)(lVar25 + 0xbc) + 1;

-          } while (uVar14 < *(uint *)(lVar26 + 0xac));

-        }

-        PopFxActivateComponent(uVar24,lVar26,0,CONCAT71((int7)(uVar20 >> 8),1));

-        uVar14 = (int)uVar22 + 1;

-        uVar22 = (ulonglong)uVar14;

-        uVar28 = uVar28 + 8;

-      } while (uVar14 < uVar30);

-    }

-    cVar13 = *(char *)(unaff_RBP + 0x77);

-    if ('\0' < cVar13) {

-      *(longlong *)(uVar24 + 0x18) = *(longlong *)(unaff_RBP + -9) + lVar16;

-      lVar26 = IoAllocateIrp(cVar13 + '\x02',0);

-      *(longlong *)(uVar24 + 0x10) = lVar26;

-      if (lVar26 == 0) {

-LAB_6:

-        iVar15 = -0x3fffff66;

-        goto LAB_8;

-      }

-    }

-    cVar13 = PopFxRegisterDeviceWithPep

-                       (*(undefined8 *)(unaff_RBP + 0x47),*(undefined8 *)(unaff_RBP + 0x4f),uVar24,

-                        puVar17);

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

-                    /* WARNING: Subroutine does not return */

-      PopFxBugCheck(0x601,uVar24,puVar17,0);

-    }

-    PopPlRegisterDevice(uVar24);

-    if (((*puVar17 & 0x10) == 0) &&

-       (((*puVar17 & 8) != 0 || (PopPoFxSystemIrpWaitForReportDevicePoweredReg != 0)))) {

-      LOCK();

-      *(uint *)(uVar24 + 0x360) = *(uint *)(uVar24 + 0x360) | 0x80;

-      UNLOCK();

-      uVar24 = param_7;

-    }

-    if ((*puVar17 & 0x20) != 0) {

-      LOCK();

-      *(uint *)(uVar24 + 0x360) = *(uint *)(uVar24 + 0x360) | 0x1000;

-      UNLOCK();

-      uVar24 = param_7;

-    }

-    if ((*puVar17 & 0x40) != 0) {

-      LOCK();

-      *(uint *)(uVar24 + 0x360) = *(uint *)(uVar24 + 0x360) | 1;

-      UNLOCK();

-      uVar24 = param_7;

-    }

-    lVar16 = *(longlong *)(unaff_RBP + -0x21) + lVar16;

-    if (uVar30 != 0) {

-      pbVar23 = (byte *)(*(longlong *)(unaff_RBP + -0x19) + 0x1c + (longlong)puVar17);

-      do {

-        if ((pbVar23[-0xc] & 2) != 0) {

-          *(uint *)(lVar16 + 0x5c) = *(uint *)(lVar16 + 0x5c) | 2;

-        }

-        *(undefined4 *)(lVar16 + 0x9c) = *(undefined4 *)pbVar23;

-        PopPlRegisterComponent(lVar16);

-        lVar16 = lVar16 + 0x1d8;

-        pbVar23 = pbVar23 + 0x28;

-        unaff_R14 = unaff_R14 - 1;

-        uVar24 = param_7;

-      } while (unaff_R14 != 0);

-    }

-    lVar16 = 0;

-    **(ulonglong **)(unaff_RBP + 0x87) = uVar24;

-    uVar24 = uVar18;

-    iVar15 = 0;

-  }

-  else {

-    iVar15 = PopFxVerifyDependencies

-                       (*(undefined8 *)(unaff_RBP + -0x69),uVar24,unaff_R14 & 0xffffffff);

-    if (-1 < iVar15) goto LAB_7;

-  }

-LAB_8:

-  ExFreePoolWithTag(puVar17,0x4d584650);

-LAB_4:

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

-  if ((uVar24 != 0) && (unaff_RSI == 0)) {

-    ExFreePoolWithTag(uVar24,0x4d584650);

-  }

-  if (lVar16 != 0) {

-    ExFreePoolWithTag(lVar16,0x4d584650);

-  }

-  unaff_R15 = *(longlong *)(unaff_RBP + -0x69);

-LAB_2:

-  ExFreePoolWithTag(unaff_R15,0x4d584650);

-  if (unaff_RSI != 0) {

-    PopFxReleaseAcpiRefDevice(unaff_RSI,0x66466f50);

-  }

-  return iVar15;

+  PpmAcquireLock(&PpmPerfPolicyLock);

+  PpmPerfMaxOverrideEnabled = 1;

+  PpmHeteroHgsCheckContainmentDecision();

+  PpmParkApplyPolicy();

+  PpmPerfUpdateDomainPolicy(0);

+  return;

 }
```

## `SeSubProcessToken`  (modified)

```diff
--- SeSubProcessToken
+++ SeSubProcessToken
@@ -1,21 +1,304 @@
 

-undefined4 SeSubProcessToken(void)

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

+

+uint SeSubProcessToken(longlong param_1,ulonglong param_2,longlong *param_3,uint param_4,int param_5

+                      ,uint *param_6,uint param_7,longlong param_8,undefined4 param_9,

+                      longlong param_10,char *param_11)

 

 {

-  undefined4 uVar1;

-  longlong unaff_RBP;

+  char cVar1;

+  int iVar2;

+  uint uVar3;

+  longlong lVar4;

+  uint uVar5;

+  uint uVar6;

+  undefined1 auStack_2e8 [32];

+  uint **local_2c8;

+  char *local_2c0;

+  char *local_2b8;

+  longlong *local_2b0;

+  char local_2a8;

+  char local_2a7 [7];

+  longlong local_2a0;

+  char local_298;

+  char local_297;

+  char local_296;

+  char local_295;

+  char local_294 [4];

+  uint local_290;

+  int local_28c;

+  int local_288 [2];

+  longlong local_280;

+  char *local_278;

+  undefined8 uStack_270;

+  longlong local_268;

+  longlong *local_260;

+  undefined8 local_258;

+  undefined8 uStack_250;

+  undefined8 local_248;

+  ulonglong uStack_240;

+  undefined8 local_238;

+  ulonglong uStack_230;

+  undefined8 local_228;

+  undefined8 uStack_220;

+  undefined8 local_218;

+  undefined8 uStack_210;

+  undefined8 local_208;

+  undefined8 uStack_200;

+  undefined1 local_1f8 [160];

+  undefined1 local_158 [224];

+  uint *local_78;

+  ulonglong local_70;

+  longlong *local_68;

+  undefined8 local_60;

+  undefined8 local_58;

+  uint local_50;

+  undefined4 local_4c;

+  ulonglong local_48;

   

-  uVar1 = PsImpersonateClient(0);

-  SeReleaseSubjectContext(unaff_RBP + -0x19);

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

+  local_48 = __security_cookie ^ (ulonglong)auStack_2e8;

+  local_268 = param_8;

+  local_238 = 0;

+  uStack_230 = uStack_230 & 0xffffffff00000000;

+  local_278 = param_11;

+  local_2a0 = 0;

+  local_258 = 0;

+  uStack_250 = 0;

+  local_70 = (ulonglong)(uint)local_70;

+  local_248 = 0;

+  uStack_240 = 0;

+  local_290 = param_4;

+  local_260 = param_3;

+  memset(local_1f8,0,0xa0);

+  memset(local_158,0,0xe0);

+  *param_3 = 0;

+  local_298 = '\0';

+  param_11[0] = '\0';

+  param_11[1] = '\0';

+  local_208 = 0;

+  uStack_200 = (ulonglong)uStack_200._4_4_ << 0x20;

+  param_11[2] = '\0';

+  local_2a7[0] = '\0';

+  local_228 = 0;

+  uStack_220 = 0;

+  local_295 = '\0';

+  local_218 = 0;

+  uStack_210 = 0;

+  local_294[0] = '\0';

+  local_2a8 = '\0';

+  local_280 = 0;

+  local_296 = '\0';

+  local_297 = '\0';

+  SeTokenGetNoChildProcessRestricted(param_2,&local_298,&local_296,&local_297);

+  if ((local_298 != '\0') || (local_297 != '\0')) {

+    uVar5 = 0xc000049d;

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

+      local_2c8 = (uint **)&local_28c;

+      local_2c0 = (char *)0x0;

+      local_288[0] = 0;

+      local_28c = 0;

+      lVar4 = PsReferenceEffectiveToken(SystemReserved1[0xf],0x74726853,local_288,&local_297);

+      if ((local_288[0] != 2) || (1 < local_28c)) {

+        cVar1 = SeTokenIsNoChildProcessRestrictionEnforced();

+        uVar5 = -(uint)(cVar1 != '\0') & 0xc000049d;

+        if (local_288[0] == 1) {

+          ObFastDereferenceObject

+                    (*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x248,lVar4,0x74726853);

+          goto LAB_0;

+        }

+      }

+      if (lVar4 != 0) {

+        ObfDereferenceObjectWithTag(lVar4,0x74726853);

+      }

+    }

+LAB_0:

+    cVar1 = local_298;

+    uVar3 = 0;

+    if (param_6[2] != 1) {

+      uVar3 = uVar5;

+    }

+    if (((((*(uint *)(param_1 + 0x5fc) & 1) != 0) && (*(longlong *)(param_1 + 0x640) == 0)) ||

+        (-1 < (int)uVar3)) || ((local_296 != '\0' && (param_6[3] != 0)))) goto LAB_1;

+    lVar4 = *(longlong *)(param_6 + 6);

+    EtwTimLogProhibitChildProcessCreation

+              ((local_298 != '\0') + '\x01',*(undefined8 *)(param_6 + 4),

+               -(ulonglong)(lVar4 != 0) & lVar4 + 0x60U,-(ulonglong)(lVar4 != 0) & lVar4 + 0x70U);

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

+LAB_2:

+    local_2a0 = 0;

+    cVar1 = local_2a8;

+    goto LAB_3;

+  }

+LAB_1:

+  iVar2 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

+  if (iVar2 != 0) {

+    local_28c = 0;

+    RtlQueryElevationFlags(&local_28c);

+    if (((((byte)local_28c & 0x18) == 0x10) &&

+        ((*(uint *)(*(longlong *)(param_2 + 0xd8) + 0x28) & 4) != 0)) &&

+       (((*(uint *)(param_2 + 200) & 0x8001000) == 0x8001000 && ((local_290 & 2) != 0)))) {

+      if ((EtwAppCompatProvRegHandle != 0) &&

+         (cVar1 = EtwEventEnabled(EtwAppCompatProvRegHandle,&APPCOMPAT_AP_UIACCESS_REMOVAL_EVENT),

+         cVar1 != '\0')) {

+        lVar4 = *(longlong *)(param_6 + 6);

+        local_278 = (char *)0x0;

+        uStack_270 = 0;

+        if ((lVar4 == 0) || (*(short *)(lVar4 + 0x60) == 0)) {

+          RtlInitUnicodeString(&local_278,L"Unknown");

+        }

+        else {

+          local_278 = *(char **)(lVar4 + 0x60);

+          uStack_270 = *(undefined8 *)(lVar4 + 0x68);

+        }

+        local_78 = &local_290;

+        local_68 = &local_280;

+        local_50 = (uint)(ushort)local_278;

+        local_280 = CONCAT44(local_280._4_4_,local_50);

+        local_58 = uStack_270;

+        local_2c8 = &local_78;

+        local_290 = 0;

+        local_70 = 4;

+        local_60 = 4;

+        local_4c = 0;

+        EtwWrite(EtwAppCompatProvRegHandle,&APPCOMPAT_AP_UIACCESS_REMOVAL_EVENT,0,3);

+      }

+      return 0xc0000022;

+    }

+  }

+  uVar5 = local_290;

+  uStack_250 = 0;

+  local_258 = CONCAT44(local_258._4_4_,0x30);

+  local_238 = 0;

+  uStack_230 = 0;

+  uStack_240 = uStack_240 & 0xffffffff00000000;

+  local_248 = 0;

+  iVar2 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar2 == 0) || (*(char **)(param_6 + 8) == (char *)0x0)) {

+    local_2b0 = &local_2a0;

+    local_2b8 = (char *)CONCAT71(local_2b8._1_7_,1);

+    local_2c0 = (char *)((ulonglong)local_2c0 & 0xffffffffffffff00);

+    local_2c8 = (uint **)((ulonglong)local_2c8 & 0xffffffff00000000);

+    uVar3 = SepDuplicateToken(param_2,&local_258,0,1);

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

+  }

+  else {

+    local_228 = CONCAT44(local_228._4_4_,0x30);

+    uStack_220 = 0;

+    uStack_210 = CONCAT44(uStack_210._4_4_,0x600);

+    local_218 = 0;

+    local_208 = 0;

+    uStack_200 = 0;

+    local_2c8 = (uint **)((ulonglong)local_2c8 & 0xffffffffffffff00);

+    local_2c0 = *(char **)(param_6 + 8);

+    uVar3 = SepCreateAppContainerToken(0,&local_2a0,0xf01ff,&local_228);

+    cVar1 = local_2a8;

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

+  }

+  if (((*(uint *)(local_2a0 + 200) & 0x4000) == 0) || (*(int *)(local_2a0 + 0x78) == param_5)) {

+LAB_4:

+    local_2c8 = (uint **)0x0;

+    SepSetTokenSessionById(local_2a0,param_5,0,0);

+    *(int *)(local_2a0 + 0x78) = param_5;

+    *(uint *)(local_2a0 + 200) = *(uint *)(local_2a0 + 200) & 0xffdfffff;

+    if (((*param_6 & 1) != 0) &&

+       (*(uint *)(local_2a0 + 200) = *(uint *)(local_2a0 + 200) | 0x80000, (*param_6 & 4) != 0)) {

+      *(uint *)(local_2a0 + 200) = *(uint *)(local_2a0 + 200) | 0x100000;

+    }

+    local_2c8 = (uint **)0x0;

+    uVar3 = SepSetTokenBnoIsolation(local_2a0,0,0,0);

+    if ((int)uVar3 < 0) goto LAB_5;

+    local_2b8 = local_294;

+    local_2c0 = &local_295;

+    uVar6 = uVar5 & 2;

+    local_2c8 = (uint **)CONCAT44(local_2c8._4_4_,param_6[1]);

+    uVar3 = SepDesktopAppxSubProcessToken(local_2a0,param_1,0);

+    if ((int)uVar3 < 0) goto LAB_5;

+    uVar3 = SepMandatorySubProcessToken

+                      (-(ulonglong)(uVar6 != 0) & param_2,local_2a0,param_1,&local_280);

+    cVar1 = '\0';

+    if ((((-1 < (int)uVar3) &&

+         (uVar3 = SepSetTrustLevelForProcessToken(local_2a0,param_1,local_2a7), -1 < (int)uVar3)) &&

+        ((((byte)SepTokenSingletonAttributesConfig & 3) != 3 ||

+         (uVar3 = SepSetProcessUniqueAttribute(local_2a0), -1 < (int)uVar3)))) &&

+       ((((*(uint *)(local_2a0 + 200) & 0x4000) == 0 || ((param_7 & 1) == 0)) ||

+        (uVar3 = SepSetTokenAllApplicationPackagesPolicy(), -1 < (int)uVar3)))) {

+      if (local_268 != 0) {

+        SepAddTokenOriginClaim(local_268,param_9,local_2a0,0);

+      }

+      if (param_10 != 0) {

+        local_2c8 = *(uint ***)(param_10 + 0x18);

+        uVar3 = SepSetTokenBnoIsolation

+                          (local_2a0,*(undefined1 *)(param_10 + 0x20),param_10,

+                           *(undefined4 *)(param_10 + 0x10));

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

+      }

+      if ((uVar6 == 0) || (local_280 != 0)) {

+        local_2a7[0] = '\x01';

+      }

+      if (local_2a7[0] == '\0') {

+        SeCreateAccessState(local_1f8,local_158,0,0);

+      }

+      else {

+        local_78 = (uint *)0x0;

+        local_70 = local_70 & 0xffffffff00000000;

+        local_2c8 = (uint **)0x0;

+        local_60 = *(undefined8 *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x1d0);

+        local_68 = (longlong *)local_2a0;

+        SepCreateAccessStateFromSubjectContext(&local_78,local_1f8,local_158,0);

+      }

+      local_2b8 = (char *)0x0;

+      local_2c0 = (char *)0x0;

+      local_2c8 = (uint **)((ulonglong)local_2c8 & 0xffffffff00000000);

+      cVar1 = '\x01';

+      uVar3 = ObInsertObjectEx(local_2a0,local_1f8,0,0);

+      if ((int)uVar3 < 0) {

+        local_2a0 = 0;

+        cVar1 = '\x01';

+      }

+      else {

+        iVar2 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline

+                          ();

+        if (((iVar2 == 0) || (*(longlong *)(param_6 + 8) == 0)) ||

+           (uVar3 = SepAppendAceToTokenObjectAcl

+                              (local_2a0,0xf01ff,

+                               *(undefined8 *)(*(longlong *)(*(longlong *)(param_6 + 8) + 8) + 0x10)

+                              ), -1 < (int)uVar3)) {

+          SepFinalizeTokenAcls(local_2a0);

+          *(byte *)(local_2a0 + 0xcc) = (byte)uVar5 & 1;

+          *local_260 = local_2a0;

+          *local_278 = local_2a7[0];

+          local_278[1] = local_295;

+          local_278[2] = local_294[0];

+          if (-1 < (int)uVar3) goto LAB_6;

+        }

+      }

+    }

+  }

+  else {

+    SepDereferenceLowBoxNumberEntry(*(int *)(local_2a0 + 0x78),*(undefined8 *)(local_2a0 + 0x438));

+    local_2c8 = (uint **)0x0;

+    *(undefined8 *)(local_2a0 + 0x438) = 0;

+    SepSetTokenSessionById(local_2a0,param_5,0,0);

+    *(int *)(local_2a0 + 0x78) = param_5;

+    uVar3 = SepSetTokenLowboxNumber(local_2a0,*(undefined8 *)(local_2a0 + 0x310));

+    if (-1 < (int)uVar3) goto LAB_4;

+LAB_5:

+    cVar1 = '\0';

+  }

+LAB_3:

+  if (local_2a0 != 0) {

     ObfDereferenceObject();

   }

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

-    ObfDereferenceObject();

-  }

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

-    ObfDereferenceObject();

-  }

-  return uVar1;

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

+    return uVar3;

+  }

+LAB_6:

+  if (local_2a7[0] == '\0') {

+    SeDeleteAccessState(local_1f8);

+  }

+  else {

+    SepDeleteAccessState();

+  }

+  return uVar3;

 }
```

## `WmipQuerySingleMultiple`  (modified)

```diff
--- WmipQuerySingleMultiple
+++ WmipQuerySingleMultiple
@@ -1,11 +1,232 @@
 

-void WmipQuerySingleMultiple(void)

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

+

+void * WmipQuerySingleMultiple

+                 (undefined8 param_1,char param_2,uint *param_3,uint param_4,longlong param_5,

+                 uint param_6,longlong param_7,longlong param_8,uint *param_9)

 

 {

-  code *pcVar1;

+  ulonglong *puVar1;

+  ushort uVar2;

+  char cVar3;

+  uint uVar4;

+  int iVar5;

+  void *_Dst;

+  void *pvVar6;

+  ulonglong uVar7;

+  uint *_Dst_00;

+  undefined1 *_Src;

+  uint uVar8;

+  void *pvVar9;

+  uint uVar10;

+  uint *puVar11;

+  void *pvVar12;

+  undefined1 auStack_378 [32];

+  uint *local_358;

+  uint local_350;

+  uint *local_348;

+  char local_338;

+  char local_337;

+  uint local_334;

+  uint local_330;

+  uint local_32c;

+  int local_328;

+  uint *local_320;

+  uint local_318;

+  uint local_314;

+  uint local_310;

+  uint local_30c;

+  undefined1 *local_308;

+  uint *local_300;

+  longlong local_2f8;

+  uint *local_2f0;

+  uint local_2e8;

+  undefined8 local_2e0;

+  undefined8 local_2d8;

+  void *local_2d0;

+  uint *local_2c8;

+  uint *local_2c0;

+  ulonglong local_2b8;

+  undefined1 *puStack_2b0;

+  longlong local_2a8;

+  undefined8 local_2a0;

+  uint *local_298;

+  uint *local_290;

+  uint local_288 [148];

+  ulonglong local_38;

   

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

-  (*pcVar1)();

-  return;

+  local_38 = __security_cookie ^ (ulonglong)auStack_378;

+  local_2e8 = param_6;

+  local_2f8 = param_7;

+  local_2a8 = param_8;

+  local_2c0 = param_9;

+  local_290 = param_9;

+  pvVar6 = (void *)0x0;

+  local_314 = 0;

+  local_337 = param_2;

+  local_330 = param_4;

+  local_2f0 = param_3;

+  local_2a0 = param_1;

+  local_298 = param_3;

+  memset(local_288,0,0x248);

+  local_328 = 0;

+  pvVar9 = pvVar6;

+  if (local_2f8 == 0) {

+    _Dst = (void *)ExAllocatePool2(0x100,(ulonglong)param_6 * 0x18,0x70696d57);

+    local_2d0 = _Dst;

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

+      pvVar9 = (void *)0xc000009a;

+      param_3 = local_2f0;

+    }

+    else {

+      RtlCopyMemory(_Dst,(void *)(param_5 + 8),(ulonglong)param_6 * 0x18);

+      param_3 = local_2f0;

+    }

+  }

+  else {

+    local_2d0 = (void *)0x0;

+    _Dst = pvVar6;

+  }

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

+    local_32c = 0;

+    local_338 = '\0';

+    local_300 = (uint *)0x0;

+    puVar11 = local_288;

+    local_30c = 0x244;

+    local_2d8 = 0;

+    pvVar12 = pvVar6;

+    local_320 = param_3;

+    local_2c8 = puVar11;

+    while( true ) {

+      cVar3 = local_338;

+      local_310 = (uint)pvVar6;

+      uVar10 = (uint)pvVar12;

+      _Dst_00 = puVar11;

+      if (local_2e8 <= local_310) break;

+      if (local_2f8 == 0) {

+        uVar2 = *(ushort *)((longlong)_Dst + (longlong)pvVar6 * 0x18 + 8);

+        local_334 = (uint)uVar2;

+        local_2b8 = CONCAT62(local_2b8._2_6_,uVar2);

+        puStack_2b0 = *(undefined1 **)((longlong)_Dst + (longlong)pvVar6 * 0x18 + 0x10);

+        local_2e0 = *(undefined8 *)((longlong)_Dst + (longlong)pvVar6 * 0x18);

+      }

+      else {

+        puVar1 = (ulonglong *)(local_2a8 + (longlong)pvVar6 * 0x10);

+        local_2b8 = *puVar1;

+        puStack_2b0 = (undefined1 *)puVar1[1];

+        local_334 = (uint)local_2b8;

+        local_2d8 = *(undefined8 *)(local_2f8 + (longlong)pvVar6 * 8);

+        local_2e0 = 0;

+      }

+      uVar8 = (local_334 & 0xffff) + 0x49 & 0xfffffff8;

+      local_308 = puStack_2b0;

+      if ((local_338 == '\0') && (uVar8 <= local_330)) {

+        local_318 = local_330;

+        _Dst_00 = local_320;

+      }

+      else {

+        uVar4 = local_30c;

+        if (local_30c < uVar8) {

+          if (puVar11 != local_288) {

+            ExFreePoolWithTag(puVar11,0);

+          }

+          _Dst_00 = (uint *)ExAllocatePool2(0x40,uVar8,0x70696d57);

+          uVar4 = uVar8;

+          local_2c8 = _Dst_00;

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

+            pvVar9 = (void *)0xc000009a;

+            break;

+          }

+        }

+        local_30c = uVar4;

+        local_300 = (uint *)0x0;

+        local_338 = '\x01';

+        puVar11 = _Dst_00;

+        local_318 = uVar8;

+      }

+      memset(_Dst_00,0,0x40);

+      cVar3 = local_337;

+      _Dst_00[0xb] = 2;

+      *_Dst_00 = uVar8;

+      *(undefined8 *)(_Dst_00 + 4) = local_2e0;

+      _Dst_00[0xc] = 0x40;

+      _Dst_00[0xe] = uVar8;

+      uVar7 = (ulonglong)local_334;

+      *(short *)(_Dst_00 + 0x10) = (short)local_334;

+      _Src = local_308;

+      if ((local_337 == '\x01') && ((short)local_334 != 0)) {

+        if (((ulonglong)local_308 & 1) != 0) {

+                    /* WARNING: Subroutine does not return */

+          ExRaiseDatatypeMisalignment();

+        }

+        if ((&DAT_0 < local_308 + (local_334 & 0xffff)) ||

+           (local_308 + (local_334 & 0xffff) < local_308)) {

+          uVar7 = local_2b8 & 0xffff;

+          _Src = puStack_2b0;

+        }

+      }

+      RtlCopyMemory((void *)((longlong)_Dst_00 + 0x42),_Src,uVar7 & 0xffff);

+      local_334 = *_Dst_00;

+      local_348 = &local_334;

+      local_350 = local_318;

+      local_358 = _Dst_00;

+      iVar5 = WmipQuerySetExecuteSI(local_2d8,local_2a0,cVar3,1);

+      if ((-1 < iVar5) && ((_Dst_00[0xb] >> 8 & 1) == 0)) {

+        local_328 = local_328 + 1;

+        if ((_Dst_00[0xb] & 0x20) == 0) {

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

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

+              local_300[3] = local_314;

+            }

+            uVar8 = _Dst_00[3];

+            while (uVar8 != 0) {

+              _Dst_00 = (uint *)((longlong)_Dst_00 + (ulonglong)uVar8);

+              uVar8 = _Dst_00[3];

+            }

+            uVar8 = local_334 + 7 & 0xfffffff8;

+            local_32c = uVar10 + uVar8;

+            pvVar12 = (void *)(ulonglong)local_32c;

+            uVar10 = local_330 - uVar8;

+            local_300 = _Dst_00;

+            iVar5 = Feature_1045423416__private_IsEnabledDeviceUsageNoInline();

+            if (iVar5 != 0) {

+              uVar10 = -(uint)(uVar8 < local_330) & uVar10;

+            }

+            local_330 = uVar10;

+            local_320 = (uint *)((longlong)local_320 + (ulonglong)uVar8);

+            local_314 = (int)local_320 - (int)local_300;

+          }

+          else {

+            local_32c = uVar10 + (local_334 + 7 & 0xfffffff8);

+            pvVar12 = (void *)(ulonglong)local_32c;

+          }

+        }

+        else {

+          local_32c = uVar10 + (_Dst_00[0xc] + 7 & 0xfffffff8);

+          pvVar12 = (void *)(ulonglong)local_32c;

+          local_338 = '\x01';

+        }

+      }

+      pvVar6 = (void *)(ulonglong)(local_310 + 1);

+    }

+    puVar11 = local_2f0;

+    if (_Dst_00 != local_288) {

+      ExFreePoolWithTag(_Dst_00,0);

+    }

+    if (local_328 == 0) {

+      pvVar9 = (void *)0xc0000295;

+    }

+    if ((-1 < (int)pvVar9) && (cVar3 != '\0')) {

+      *puVar11 = 0x38;

+      puVar11[0xb] = 0x20;

+      puVar11[0xc] = uVar10;

+      uVar10 = 0x38;

+    }

+    *local_2c0 = uVar10;

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

+      ExFreePoolWithTag(_Dst,0);

+    }

+  }

+  return pvVar9;

 }
```

## `SeCodeIntegrityInitializePolicy`  (modified)

```diff
--- SeCodeIntegrityInitializePolicy
+++ SeCodeIntegrityInitializePolicy
@@ -1,965 +1,31 @@
 

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

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

 

-undefined8

-SeCodeIntegrityInitializePolicy

-          (char param_1,char *param_2,undefined8 param_3,undefined8 param_4,undefined8 param_5,

-          longlong param_6,longlong param_7,longlong param_8,longlong param_9,longlong param_10,

-          longlong param_11,longlong param_12,longlong param_13,longlong param_14,longlong param_15)

+int SeCodeIntegrityInitializePolicy(longlong param_1)

 

 {

-  longlong lVar1;

+  int iVar1;

   longlong lVar2;

-  longlong lVar3;

-  longlong lVar4;

-  void *_Dst;

-  longlong lVar5;

-  longlong lVar6;

-  longlong lVar7;

-  undefined4 uVar8;

-  undefined4 uVar9;

-  uint uVar10;

-  undefined4 uVar11;

-  int iVar12;

-  int *in_RAX;

-  longlong lVar13;

-  longlong lVar14;

-  longlong lVar15;

-  undefined8 *puVar16;

-  char unaff_BL;

-  longlong unaff_RBP;

-  char *unaff_RSI;

+  undefined4 local_res8 [2];

+  undefined8 local_res10;

   

-  iVar12 = (int)in_RAX;

-  *in_RAX = *in_RAX + iVar12;

-  *unaff_RSI = *unaff_RSI + unaff_BL;

-  *(char *)in_RAX = (char)*in_RAX + (char)((ulonglong)in_RAX >> 8);

-  *(char *)((longlong)in_RAX + -0x39) = *(char *)((longlong)in_RAX + -0x39) + param_1;

-  *in_RAX = *in_RAX + iVar12;

-  *(char *)in_RAX = (char)*in_RAX + unaff_BL;

-  *param_2 = *param_2 + unaff_BL;

-  *(char *)((longlong)in_RAX + -0x39) = *(char *)((longlong)in_RAX + -0x39) + param_1;

-  *in_RAX = *in_RAX + iVar12;

-  *param_2 = *param_2 + unaff_BL;

-  *(char *)((longlong)in_RAX * 2) = *(char *)((longlong)in_RAX * 2) + unaff_BL;

-  *(undefined8 *)(unaff_RBP + 0x138) = 0x10000e;

-  *(undefined8 *)(unaff_RBP + 0x148) = 0x380036;

-  *(undefined8 *)(unaff_RBP + 0x158) = 0x220020;

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

-  *(undefined8 *)(unaff_RBP + 0x18) = 0x2e002c;

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

-  *(undefined8 *)(unaff_RBP + 0x28) = 0x320030;

-  *(undefined8 *)(unaff_RBP + 0x168) = 0x40003e;

-  *(undefined8 *)(unaff_RBP + 0x178) = 0x440042;

-  *(undefined8 *)(unaff_RBP + -0x18) = 0x3c003a;

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

-  param_6._0_6_ = (uint6)(uint)param_6;

-  param_7 = CONCAT26((short)((ulonglong)param_7 >> 0x30),0x10000000000);

-  param_8 = CONCAT26((short)((ulonglong)param_8 >> 0x30),0x20000000000);

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

-  *(undefined2 *)(unaff_RBP + 0x244) = 0x300;

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

-  *(undefined2 *)(unaff_RBP + 0x234) = 0x500;

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

-  *(undefined2 *)(unaff_RBP + 0x24c) = 0x1000;

-  param_5 = CONCAT26((short)((ulonglong)param_5 >> 0x30),0xf0000000000);

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

-  *(undefined2 *)(unaff_RBP + 0x23c) = 0x1300;

-  uVar10 = *(uint *)(*(longlong *)(KeLoaderBlock + 0xf0) + 0x84);

-  if ((((byte)((byte)param_2 & (byte)uVar10) == 0) && (_DAT_0 == 1)) &&

-     (_DAT_1 < 0x83401)) {

-    SepTokenCapabilitySidSharingEnabled = 1;

+  local_res10 = 0;

+  iVar1 = 0;

+  local_res8[0] = 0;

+  lVar2 = 0;

+  if ((((*(longlong *)(param_1 + 0xf0) != 0) &&

+       (lVar2 = *(longlong *)(*(longlong *)(param_1 + 0xf0) + 0xb58), lVar2 != 0)) &&

+      (*(int *)(lVar2 + 0x40) != 0)) &&

+     (iVar1 = SeSecureBootRegisterPolicy((ulonglong)*(uint *)(lVar2 + 0x3c) + 0x88 + lVar2),

+     iVar1 < 0)) {

+    return iVar1;

   }

-  else {

-    SepTokenCapabilitySidSharingEnabled = 0;

+  SepInitializeDebugOptions();

+  if ((DAT_0 != (code *)0x0) &&

+     (iVar1 = (*DAT_0)(lVar2,&local_res10,local_res8), -1 < iVar1)) {

+    SeCiStateElements = local_res10;

+    SeCiStateElementCount = local_res8[0];

   }

-  SepOsLoaderTpmDriverLoaded = (byte)(uVar10 >> 7) & 1;

-  SepTokenSidSharingEnabled = SepTokenCapabilitySidSharingEnabled;

-  uVar8 = RtlLengthRequiredSid(1);

-  SeNullSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-  SeCreatorOwnerSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  SeCreatorGroupSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  SeCreatorOwnerServerSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  SeCreatorGroupServerSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  SeWorldSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  SeLocalSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-  lVar13 = ExAllocatePool2(0x60,uVar8,0x69536553);

-  lVar7 = SeNullSid;

-  SeOwnerRightsSid = lVar13;

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

-  lVar6 = SeCreatorOwnerSid;

-  lVar3 = SeCreatorGroupSid;

-  lVar2 = SeCreatorGroupServerSid;

-  lVar14 = SeCreatorOwnerServerSid;

-  lVar1 = SeWorldSid;

-  lVar15 = SeLocalSid;

-  if (((((lVar7 != 0) && (SeWorldSid != 0)) &&

-       ((SeLocalSid != 0 && ((SeCreatorOwnerSid != 0 && (SeCreatorGroupSid != 0)))))) &&

-      (SeCreatorOwnerServerSid != 0)) && ((lVar13 != 0 && (SeCreatorGroupServerSid != 0)))) {

-    RtlInitializeSid(lVar7,&param_6,1);

-    RtlInitializeSid(lVar1,&param_7,1);

-    RtlInitializeSid(lVar15,&param_8,1);

-    RtlInitializeSid(lVar6,unaff_RBP + 0x240,1);

-    RtlInitializeSid(lVar3,unaff_RBP + 0x240,1);

-    RtlInitializeSid(lVar14,unaff_RBP + 0x240,1);

-    RtlInitializeSid(lVar2,unaff_RBP + 0x240,1);

-    RtlInitializeSid(lVar13,unaff_RBP + 0x240,1);

-    *(undefined4 *)(*(longlong *)(unaff_RBP + -0x48) + 8) = 0;

-    *(undefined4 *)(lVar1 + 8) = 0;

-    *(undefined4 *)(lVar15 + 8) = 0;

-    *(undefined4 *)(lVar6 + 8) = 0;

-    *(undefined4 *)(lVar3 + 8) = 1;

-    *(undefined4 *)(lVar14 + 8) = 2;

-    *(undefined4 *)(lVar2 + 8) = 3;

-    *(undefined4 *)(lVar13 + 8) = 4;

-    uVar9 = RtlLengthRequiredSid();

-    SeNtAuthoritySid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeDialupSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeNetworkSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeBatchSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeInteractiveSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SePrincipalSelfSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeServiceSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLocalSystemSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeAuthenticatedUsersSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeRestrictedSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeAnonymousLogonSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLocalServiceSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeNetworkServiceSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeIUserSid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    uVar9 = RtlLengthRequiredSid(2);

-    SeAliasAdminsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasUsersSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasGuestsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasPowerUsersSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasAccountOpsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasSystemOpsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasPrintOpsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeAliasBackupOpsSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeUntrustedMandatorySid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeLowMandatorySid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeMediumMandatorySid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeHighMandatorySid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeSystemMandatorySid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SePackagePrefixSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeCapabilityPrefixSid = ExAllocatePool2(0x60,uVar8,0x69536553);

-    SeAllAppPackagesSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeAllRestrictedAppPackagesSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    uVar8 = RtlLengthRequiredSid(10);

-    SeLpacAppExperienceCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacComCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacCryptoServicesCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacIdentityServicesCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacInstrumentationCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacEnterprisePolicyChangeNotificationsCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553)

-    ;

-    SeLpacMediaCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacPnpNotificationsCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeRegistryReadCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacServicesManagementCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacSessionManagementCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacPrintingCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacWebPlatformCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacPaymentsCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacClipboardCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacImeCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacPackageManagerOperationCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeLpacDeviceAccessCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    uVar10 = RtlLengthRequiredSid(6);

-    *(ulonglong *)(unaff_RBP + 400) = (ulonglong)uVar10;

-    SeUserModeDriversSid = (void *)ExAllocatePool2(0x60,uVar10,0x69536553);

-    SeTrustedInstallerSid = ExAllocatePool2(0x60,(ulonglong)uVar10,0x69536553);

-    SeProcTrustWinTcbSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustWinSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustAuthenticodeSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustLiteAntimalwareSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustLiteWinTcbSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustLiteWinSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustLiteAppSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeProcTrustNoneSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeDefaultAccountAliasSid = ExAllocatePool2(0x120,uVar9,0x69536553);

-    SeLearningModeLoggingCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SePermissiveLearningModeCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    uVar11 = RtlLengthRequiredSid(9);

-    SeConstrainedImpersonationCapabilityGroupSid = ExAllocatePool2(0x120,uVar11,0x69536553);

-    SeConstrainedImpersonationCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeSessionImpersonationCapabilityGroupSid = ExAllocatePool2(0x120,uVar11,0x69536553);

-    SeSessionImpersonationCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeAppSiloSid = ExAllocatePool2(0x60,uVar9,0x69536553);

-    SeAppSiloVolumeRootMinimalCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeAppSiloProfilesRootMinimalCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    SeAppSiloPromptForAccessCapabilitySid = ExAllocatePool2(0x120,uVar8,0x69536553);

-    lVar14 = ExAllocatePool2(0x120,uVar8);

-    lVar1 = SeNtAuthoritySid;

-    lVar15 = SeDialupSid;

-    SeAppSiloAccessToPublisherDirectoryCapabilitySid = lVar14;

-    if (SeNtAuthoritySid != 0) {

-      *(longlong *)(unaff_RBP + 0x240) = SeDialupSid;

-      lVar3 = SeNetworkSid;

-      lVar2 = SeBatchSid;

-      if ((lVar15 != 0) && (SeNetworkSid != 0)) {

-        *(longlong *)(unaff_RBP + -0x50) = SeBatchSid;

-        lVar15 = SeInteractiveSid;

-        if (lVar2 != 0) {

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

-          lVar2 = SeServiceSid;

-          if (lVar15 != 0) {

-            *(longlong *)(unaff_RBP + -0x60) = SeServiceSid;

-            lVar15 = SePrincipalSelfSid;

-            if (lVar2 != 0) {

-              *(longlong *)(unaff_RBP + -0x68) = SePrincipalSelfSid;

-              lVar2 = SeLocalSystemSid;

-              if (lVar15 != 0) {

-                *(longlong *)(unaff_RBP + -0x70) = SeLocalSystemSid;

-                lVar15 = SeAuthenticatedUsersSid;

-                if (lVar2 != 0) {

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

-                  lVar2 = SeRestrictedSid;

-                  if (lVar15 != 0) {

-                    *(longlong *)(unaff_RBP + -0x80) = SeRestrictedSid;

-                    lVar13 = SeAliasPrintOpsSid;

-                    lVar7 = SeAliasBackupOpsSid;

-                    lVar6 = SeAliasSystemOpsSid;

-                    lVar15 = SeLowMandatorySid;

-                    if (lVar2 != 0) {

-                      param_15 = SeAnonymousLogonSid;

-                      if (SeAnonymousLogonSid != 0) {

-                        param_14 = SeLocalServiceSid;

-                        if (SeLocalServiceSid != 0) {

-                          param_13 = SeNetworkServiceSid;

-                          if (SeNetworkServiceSid != 0) {

-                            param_12 = SeIUserSid;

-                            if (SeIUserSid != 0) {

-                              param_11 = SeAliasAdminsSid;

-                              if (SeAliasAdminsSid != 0) {

-                                param_10 = SeAliasUsersSid;

-                                if (SeAliasUsersSid != 0) {

-                                  param_9 = SeAliasGuestsSid;

-                                  if (SeAliasGuestsSid != 0) {

-                                    param_8 = SeAliasPowerUsersSid;

-                                    if ((((SeAliasPowerUsersSid != 0) &&

-                                         (param_7 = SeAliasAccountOpsSid, SeAliasAccountOpsSid != 0)

-                                         ) && (SeAliasSystemOpsSid != 0)) &&

-                                       ((SeAliasPrintOpsSid != 0 && (SeAliasBackupOpsSid != 0)))) {

-                                      param_6 = SeUntrustedMandatorySid;

-                                      if (SeUntrustedMandatorySid != 0) {

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

-                                        lVar2 = SeMediumMandatorySid;

-                                        if (lVar15 != 0) {

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

-                                          lVar15 = SeHighMandatorySid;

-                                          if (lVar2 != 0) {

-                                            *(longlong *)(unaff_RBP + -0x30) = SeHighMandatorySid;

-                                            lVar2 = SeSystemMandatorySid;

-                                            if (lVar15 != 0) {

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

-                                                   SeSystemMandatorySid;

-                                              lVar15 = SePackagePrefixSid;

-                                              if (lVar2 != 0) {

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

-                                                     SePackagePrefixSid;

-                                                lVar2 = SeCapabilityPrefixSid;

-                                                if ((((lVar15 != 0) &&

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

-                                                           SeCapabilityPrefixSid,

-                                                     lVar5 = SeProcTrustWinTcbSid,

-                                                     _Dst = SeUserModeDriversSid,

-                                                     lVar4 = SeAllRestrictedAppPackagesSid,

-                                                     lVar15 = SeAllAppPackagesSid, lVar2 != 0)) &&

-                                                    ((SeAllAppPackagesSid != 0 &&

-                                                     ((((SeAllRestrictedAppPackagesSid != 0 &&

-                                                        (SeLpacAppExperienceCapabilitySid != 0)) &&

-                                                       (SeLpacComCapabilitySid != 0)) &&

-                                                      ((SeLpacCryptoServicesCapabilitySid != 0 &&

-                                                       (SeLpacIdentityServicesCapabilitySid != 0))))

-                                                     )))) && ((((SeLpacInstrumentationCapabilitySid

-                                                                 != 0 && ((

-                                                  SeLpacEnterprisePolicyChangeNotificationsCapabilitySid

-                                                  != 0 && (SeLpacMediaCapabilitySid != 0)))) &&

-                                                  (((SeLpacPnpNotificationsCapabilitySid != 0 &&

-                                                    (((SeRegistryReadCapabilitySid != 0 &&

-                                                      (SeLpacServicesManagementCapabilitySid != 0))

-                                                     && (SeLpacSessionManagementCapabilitySid != 0))

-                                                    )) && (((SeLpacPrintingCapabilitySid != 0 &&

-                                                            (SeLpacWebPlatformCapabilitySid != 0))

-                                                           && (SeLpacPaymentsCapabilitySid != 0)))))

-                                                  ) && (((SeLpacClipboardCapabilitySid != 0 &&

-                                                         (SeLpacImeCapabilitySid != 0)) &&

-                                                        ((SeLpacPackageManagerOperationCapabilitySid

-                                                          != 0 && ((SeLpacDeviceAccessCapabilitySid

-                                                                    != 0 && (SeUserModeDriversSid !=

-                                                                             (void *)0x0)))))))))) {

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

-                                                       SeProcTrustWinTcbSid;

-                                                  lVar2 = SeProcTrustWinSid;

-                                                  if (lVar5 != 0) {

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

-                                                         SeProcTrustWinSid;

-                                                    lVar5 = SeProcTrustAuthenticodeSid;

-                                                    if (lVar2 != 0) {

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

-                                                           SeProcTrustAuthenticodeSid;

-                                                      lVar2 = SeProcTrustLiteAntimalwareSid;

-                                                      if (lVar5 != 0) {

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

-                                                             SeProcTrustLiteAntimalwareSid;

-                                                        lVar5 = SeProcTrustLiteWinTcbSid;

-                                                        if (lVar2 != 0) {

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

-                                                               SeProcTrustLiteWinTcbSid;

-                                                          lVar2 = SeProcTrustLiteWinSid;

-                                                          if (lVar5 != 0) {

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

-                                                                 SeProcTrustLiteWinSid;

-                                                            lVar5 = SeProcTrustLiteAppSid;

-                                                            if (lVar2 != 0) {

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

-                                                                   SeProcTrustLiteAppSid;

-                                                              lVar2 = SeProcTrustNoneSid;

-                                                              if (lVar5 != 0) {

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

-                                                                     SeProcTrustNoneSid;

-                                                                lVar5 = SeTrustedInstallerSid;

-                                                                if (((((lVar2 != 0) &&

-                                                                      (*(longlong *)

-                                                                        (unaff_RBP + 0x188) =

-                                                                            SeTrustedInstallerSid,

-                                                                      lVar2 = 

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  lVar5 != 0)) && (SeDefaultAccountAliasSid != 0))

-                                                  && ((SeLearningModeLoggingCapabilitySid != 0 &&

-                                                      (SePermissiveLearningModeCapabilitySid != 0)))

-                                                  ) && ((((SeConstrainedImpersonationCapabilitySid

-                                                           != 0 && ((*(longlong *)

-                                                                      (unaff_RBP + 0x1d0) =

-                                                                                                                                                    

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  lVar5 = SeAppSiloSid, lVar2 != 0 &&

-                                                  (SeSessionImpersonationCapabilitySid != 0)))) &&

-                                                  (SeSessionImpersonationCapabilityGroupSid != 0))

-                                                  && ((((SeAppSiloSid != 0 &&

-                                                        (SeAppSiloProfilesRootMinimalCapabilitySid

-                                                         != 0)) &&

-                                                       (SeAppSiloVolumeRootMinimalCapabilitySid != 0

-                                                       )) && ((SeAppSiloPromptForAccessCapabilitySid

-                                                               != 0 && (lVar14 != 0)))))))) {

-                                                    RtlInitializeSid(lVar1,unaff_RBP + 0x230);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x240),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(lVar3,unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x50),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x58),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x60),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x68),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x70),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x78),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x80),

-                                                                     unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(param_15,unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(param_14,unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(param_13,unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(param_12,unaff_RBP + 0x230,1);

-                                                    RtlInitializeSid(param_11,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(param_10,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(param_9,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(param_8,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(param_7,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(lVar6,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(lVar13,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(lVar7,unaff_RBP + 0x230,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x188),

-                                                                     unaff_RBP + 0x230,6);

-                                                    RtlInitializeSid(param_6,unaff_RBP + 0x248,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x40),

-                                                                     unaff_RBP + 0x248,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x38),

-                                                                     unaff_RBP + 0x248,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x30),

-                                                                     unaff_RBP + 0x248,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x28),

-                                                                     unaff_RBP + 0x248,1);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x20),&param_5,1

-                                                                    );

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + -0x48),&param_5,1

-                                                                    );

-                                                    RtlInitializeSid(lVar15,&param_5,2);

-                                                    RtlInitializeSid(lVar4,&param_5,2);

-                                                    memset(_Dst,0,*(size_t *)(unaff_RBP + 400));

-                                                    RtlInitializeSid(_Dst,unaff_RBP + 0x230,6);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x198),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1a0),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1a8),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1b0),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1c0),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1d8),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1b8),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(*(undefined8 *)

-                                                                      (unaff_RBP + 0x1c8),

-                                                                     unaff_RBP + 0x238,2);

-                                                    RtlInitializeSid(lVar5,&param_5,2);

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + 0x240) + 8) = 1;

-                                                    *(undefined4 *)(lVar3 + 8) = 2;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x50) + 8) = 3;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x58) + 8) = 4;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x60) + 8) = 6;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x68) + 8) = 10;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x70) + 8) = 0x12;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x78) + 8) = 0xb;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x80) + 8) = 0xc;

-                                                    *(undefined4 *)(param_15 + 8) = 7;

-                                                    *(undefined4 *)(param_14 + 8) = 0x13;

-                                                    *(undefined4 *)(param_13 + 8) = 0x14;

-                                                    *(undefined4 *)(param_12 + 8) = 0x11;

-                                                    *(undefined4 *)(param_11 + 8) = 0x20;

-                                                    *(undefined4 *)(param_10 + 8) = 0x20;

-                                                    *(undefined4 *)(param_9 + 8) = 0x20;

-                                                    *(undefined4 *)(param_8 + 8) = 0x20;

-                                                    *(undefined4 *)(param_7 + 8) = 0x20;

-                                                    *(undefined4 *)(lVar6 + 8) = 0x20;

-                                                    *(undefined4 *)(lVar13 + 8) = 0x20;

-                                                    *(undefined4 *)(lVar7 + 8) = 0x20;

-                                                    *(undefined4 *)(param_11 + 0xc) = 0x220;

-                                                    *(undefined4 *)(param_10 + 0xc) = 0x221;

-                                                    *(undefined4 *)(param_9 + 0xc) = 0x222;

-                                                    *(undefined4 *)(param_8 + 0xc) = 0x223;

-                                                    *(undefined4 *)(param_7 + 0xc) = 0x224;

-                                                    *(undefined4 *)(lVar6 + 0xc) = 0x225;

-                                                    *(undefined4 *)(lVar13 + 0xc) = 0x226;

-                                                    *(undefined4 *)(lVar7 + 0xc) = 0x227;

-                                                    *(undefined4 *)(param_6 + 8) = 0;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x40) + 8) = 0x1000

-                                                    ;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x38) + 8) = 0x2000

-                                                    ;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x30) + 8) = 0x3000

-                                                    ;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x28) + 8) = 0x4000

-                                                    ;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x20) + 8) = 2;

-                                                    *(undefined4 *)

-                                                     (*(longlong *)(unaff_RBP + -0x48) + 8) = 3;

-                                                    *(undefined4 *)(lVar15 + 8) = 2;

-                                                    *(undefined4 *)(lVar15 + 0xc) = 1;

-                                                    *(undefined4 *)(lVar4 + 8) = 2;

-                                                    *(undefined4 *)(lVar4 + 0xc) = 2;

-                                                    *(undefined4 *)(lVar5 + 8) = 3;

-                                                    *(undefined4 *)(lVar5 + 0xc) = 0x10000;

-                                                    iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                       (unaff_RBP + 0x58,

-                                                                        *(undefined8 *)

-                                                                         (unaff_RBP + 0x1d0),

-                                                                                                                                                

-                                                  SeLpacAppExperienceCapabilitySid);

-                                                  if (((((-1 < iVar12) &&

-                                                        ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                             (unaff_RBP + 0x68,

-                                                                                                                                                            

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacComCapabilitySid), -1 < iVar12 &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x48,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacCryptoServicesCapabilitySid), -1 < iVar12)))

-                                                  ) && ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                            (unaff_RBP + 0x78,

-                                                                                                                                                          

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacIdentityServicesCapabilitySid), -1 < iVar12

-                                                  && (((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                           (unaff_RBP + 0x88,

-                                                                                                                                                        

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacInstrumentationCapabilitySid), -1 < iVar12

-                                                  && (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                         (unaff_RBP + 0x98,

-                                                                                                                                                    

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacEnterprisePolicyChangeNotificationsCapabilitySid

-                                                  ), -1 < iVar12)) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0xa8,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacMediaCapabilitySid), -1 < iVar12)))))) &&

-                                                  ((((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                         (unaff_RBP + 0xb8,

-                                                                                                                                                    

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacPnpNotificationsCapabilitySid), -1 < iVar12

-                                                  && (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                         (unaff_RBP + 200,

-                                                                                                                                                    

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeRegistryReadCapabilitySid), -1 < iVar12)) &&

-                                                  ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                       (unaff_RBP + 0xd8,

-                                                                                                                                                

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacServicesManagementCapabilitySid),

-                                                  -1 < iVar12 &&

-                                                  ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                       (unaff_RBP + 0xe8,

-                                                                                                                                                

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacSessionManagementCapabilitySid), -1 < iVar12

-                                                  && (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                         (unaff_RBP + 0xf8,

-                                                                                                                                                    

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacPrintingCapabilitySid), -1 < iVar12)))))) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x108,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacWebPlatformCapabilitySid), -1 < iVar12))))

-                                                  && ((((((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                              (unaff_RBP + 0x118,

-                                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacPaymentsCapabilitySid), -1 < iVar12 &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x128,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacClipboardCapabilitySid), -1 < iVar12)) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x138,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacImeCapabilitySid), -1 < iVar12)) &&

-                                                  ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                       (unaff_RBP + 0x148,

-                                                                                                                                                

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacPackageManagerOperationCapabilitySid),

-                                                  -1 < iVar12 &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x158,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeLpacDeviceAccessCapabilitySid), -1 < iVar12))))

-                                                  && ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                          (unaff_RBP + 0x168,

-                                                                                                                                                      

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeAppSiloVolumeRootMinimalCapabilitySid),

-                                                  -1 < iVar12 &&

-                                                  ((iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                       (unaff_RBP + 0x178,

-                                                                                                                                                

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeAppSiloProfilesRootMinimalCapabilitySid),

-                                                  -1 < iVar12 &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + -0x18,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeAppSiloPromptForAccessCapabilitySid),

-                                                  -1 < iVar12)))))) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + -8,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeAppSiloAccessToPublisherDirectoryCapabilitySid),

-                                                  lVar15 = SeDefaultAccountAliasSid, -1 < iVar12))))

-                                                  {

-                                                    *(undefined4 *)

-                                                     ((longlong)SeUserModeDriversSid + 8) = 0x54;

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

-                                                    lVar1 = SeProcTrustWinTcbSid;

-                                                    *(undefined4 *)(SeProcTrustWinTcbSid + 8) =

-                                                         0x400;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x2000;

-                                                    lVar1 = SeProcTrustWinSid;

-                                                    *(undefined4 *)(SeProcTrustWinSid + 8) = 0x400;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x1000;

-                                                    lVar1 = SeProcTrustAuthenticodeSid;

-                                                    *(undefined4 *)(SeProcTrustAuthenticodeSid + 8)

-                                                         = 0x400;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x400;

-                                                    lVar1 = SeProcTrustLiteAntimalwareSid;

-                                                    *(undefined4 *)

-                                                     (SeProcTrustLiteAntimalwareSid + 8) = 0x200;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x600;

-                                                    lVar1 = SeProcTrustLiteWinTcbSid;

-                                                    *(undefined4 *)(SeProcTrustLiteWinTcbSid + 8) =

-                                                         0x200;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x2000;

-                                                    lVar1 = SeProcTrustLiteWinSid;

-                                                    *(undefined4 *)(SeProcTrustLiteWinSid + 8) =

-                                                         0x200;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x1000;

-                                                    lVar1 = SeProcTrustLiteAppSid;

-                                                    *(undefined4 *)(SeProcTrustLiteAppSid + 8) =

-                                                         0x200;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x800;

-                                                    lVar1 = SeTrustedInstallerSid;

-                                                    *(undefined4 *)(SeTrustedInstallerSid + 8) =

-                                                         0x50;

-                                                    *(undefined4 *)(lVar1 + 0xc) = 0x38fb89b5;

-                                                    *(undefined4 *)(lVar1 + 0x10) = 0xcbc28419;

-                                                    *(undefined4 *)(lVar1 + 0x14) = 0x6d236c5c;

-                                                    *(undefined4 *)(lVar1 + 0x18) = 0x6e770057;

-                                                    *(undefined4 *)(lVar1 + 0x1c) = 0x876402c0;

-                                                    RtlInitializeSid(lVar15,unaff_RBP + 0x230,2);

-                                                    lVar14 = 

-                                                  SeConstrainedImpersonationCapabilityGroupSid;

-                                                  lVar1 = SeLearningModeLoggingCapabilitySid;

-                                                  *(undefined4 *)(lVar15 + 8) = 0x20;

-                                                  *(undefined4 *)(lVar15 + 0xc) = 0x245;

-                                                  iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                     (unaff_RBP + 8,lVar14,lVar1);

-                                                  if ((((-1 < iVar12) &&

-                                                       (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                           (unaff_RBP + 0x18,

-                                                                                                                                                        

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SePermissiveLearningModeCapabilitySid),

-                                                  -1 < iVar12)) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x28,

-                                                                                                                                              

-                                                  SeConstrainedImpersonationCapabilityGroupSid,

-                                                  SeConstrainedImpersonationCapabilitySid),

-                                                  -1 < iVar12)) &&

-                                                  (iVar12 = RtlDeriveCapabilitySidsFromName

-                                                                      (unaff_RBP + 0x38,

-                                                                                                                                              

-                                                  SeSessionImpersonationCapabilityGroupSid,

-                                                  SeSessionImpersonationCapabilitySid), -1 < iVar12)

-                                                  ) {

-                                                    SepInitSystemDacls();

-                                                    *(undefined8 *)(unaff_RBP + 0x238) = 3;

-                                                    SeCreateTokenPrivilege = 2;

-                                                    SeAssignPrimaryTokenPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + 0x238);

-                                                    *(undefined8 *)(unaff_RBP + 0x240) = 4;

-                                                    SeLockMemoryPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + 0x240);

-                                                    *(undefined8 *)(unaff_RBP + 0x248) = 5;

-                                                    SeIncreaseQuotaPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + 0x248);

-                                                    param_8 = 6;

-                                                    _SeUnsolicitedInputPrivilege = 6;

-                                                    param_7 = 7;

-                                                    SeTcbPrivilege = 7;

-                                                    param_6 = 8;

-                                                    SeSecurityPrivilege = 8;

-                                                    param_5 = 9;

-                                                    SeTakeOwnershipPrivilege = 9;

-                                                    param_9 = 10;

-                                                    SeLoadDriverPrivilege = 10;

-                                                    param_10 = 0xf;

-                                                    SeCreatePagefilePrivilege = 0xf;

-                                                    param_11 = 0xe;

-                                                    SeIncreaseBasePriorityPrivilege = 0xe;

-                                                    param_12 = 0xb;

-                                                    SeSystemProfilePrivilege = 0xb;

-                                                    param_13 = 0xc;

-                                                    _SeSystemtimePrivilege = 0xc;

-                                                    param_14 = 0xd;

-                                                    SeProfileSingleProcessPrivilege = 0xd;

-                                                    param_15 = 0x10;

-                                                    SeCreatePermanentPrivilege = 0x10;

-                                                    *(undefined8 *)(unaff_RBP + -0x80) = 0x11;

-                                                    SeBackupPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + -0x80);

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

-                                                    SeRestorePrivilege =

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

-                                                    *(undefined8 *)(unaff_RBP + -0x70) = 0x13;

-                                                    SeShutdownPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + -0x70);

-                                                    *(undefined8 *)(unaff_RBP + -0x68) = 0x14;

-                                                    SeDebugPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + -0x68);

-                                                    *(undefined8 *)(unaff_RBP + 0x230) = 2;

-                                                    *(undefined8 *)(unaff_RBP + -0x60) = 0x15;

-                                                    _SeAuditPrivilege =

-                                                         *(undefined8 *)(unaff_RBP + -0x60);

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

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

-                                                    _SeChangeNotifyPrivilege =

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

-                                                    SeSystemEnvironmentPrivilege =

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

-                                                    _SeRemoteShutdownPrivilege = 0x18;

-                                                    SeUndockPrivilege = 0x19;

-                                                    _SeSyncAgentPrivilege = 0x1a;

-                                                    _SeEnableDelegationPrivilege = 0x1b;

-                                                    _DAT_2 = SeNullSid;

-                                                    _DAT_3 = SeWorldSid;

-                                                    _DAT_4 = SeLocalSid;

-                                                    _DAT_5 = SeCreatorOwnerSid;

-                                                    _DAT_6 = SeCreatorGroupSid;

-                                                    _DAT_7 = SeOwnerRightsSid;

-                                                    _DAT_8 = SeNtAuthoritySid;

-                                                    _DAT_9 = SeDialupSid;

-                                                    _DAT_10 = SeNetworkSid;

-                                                    _DAT_11 = SeBatchSid;

-                                                    _DAT_12 = SeInteractiveSid;

-                                                    _DAT_13 = SeLocalSystemSid;

-                                                    _DAT_14 = SeAuthenticatedUsersSid;

-                                                    _DAT_15 = SeRestrictedSid;

-                                                    _DAT_16 = SeAnonymousLogonSid;

-                                                    _DAT_17 = SeLocalServiceSid;

-                                                    _DAT_18 = SeNetworkServiceSid;

-                                                    _DAT_19 = SeIUserSid;

-                                                    _DAT_20 = SeAliasAdminsSid;

-                                                    _DAT_21 = SeAliasUsersSid;

-                                                    _DAT_22 = SeAliasGuestsSid;

-                                                    _DAT_23 = SeAliasPowerUsersSid;

-                                                    _DAT_24 = SeAliasAccountOpsSid;

-                                                    _DAT_25 = SeAliasSystemOpsSid;

-                                                    _DAT_26 = SeAliasPrintOpsSid;

-                                                    _DAT_27 = SeAliasBackupOpsSid;

-                                                    _DAT_28 = SeUntrustedMandatorySid;

-                                                    _DAT_29 = SeLowMandatorySid;

-                                                    SeManageVolumePrivilege = 0x1c;

-                                                    SeImpersonatePrivilege = 0x1d;

-                                                    SeCreateGlobalPrivilege = 0x1e;

-                                                    SeTrustedCredManAccessPrivilege = 0x1f;

-                                                    SeRelabelPrivilege = 0x20;

-                                                    SeIncreaseWorkingSetPrivilege = 0x21;

-                                                    SeTimeZonePrivilege = 0x22;

-                                                    SeCreateSymbolicLinkPrivilege = 0x23;

-                                                    SeDelegateSessionUserImpersonatePrivilege = 0x24

-                                                    ;

-                                                    _DAT_30 = SeMediumMandatorySid;

-                                                    _DAT_31 = SeHighMandatorySid;

-                                                    _DAT_32 = SeSystemMandatorySid;

-                                                    _DAT_33 = SeAllAppPackagesSid;

-                                                    _DAT_34 = SeUserModeDriversSid;

-                                                    _DAT_35 = SeProcTrustWinTcbSid;

-                                                    _DAT_36 = SeTrustedInstallerSid;

-                                                    _DAT_37 = SeAppSiloSid;

-                                                    _DAT_38 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + 0x230) >> 0x20

-                                                         );

-                                                    _DAT_39 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + 0x238) >> 0x20

-                                                         );

-                                                    _DAT_40 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + 0x240) >> 0x20

-                                                         );

-                                                    _DAT_41 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + 0x248) >> 0x20

-                                                         );

-                                                    _DAT_42 = 0;

-                                                    _DAT_43 = 0;

-                                                    _DAT_44 = 0;

-                                                    _DAT_45 = 0;

-                                                    _DAT_46 = 0;

-                                                    _DAT_47 = 0;

-                                                    _DAT_48 = 0;

-                                                    _DAT_49 = 0;

-                                                    _DAT_50 = 0;

-                                                    _DAT_51 = 0;

-                                                    _DAT_52 = 0;

-                                                    _DAT_53 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x80) >> 0x20

-                                                         );

-                                                    _SepExports = 2;

-                                                    _DAT_54 = 3;

-                                                    _DAT_55 = 4;

-                                                    _DAT_56 = 5;

-                                                    _DAT_57 = 6;

-                                                    _DAT_58 = 7;

-                                                    _DAT_59 = 8;

-                                                    _DAT_60 = 9;

-                                                    _DAT_61 = 10;

-                                                    _DAT_62 = 0xf;

-                                                    _DAT_63 = 0xe;

-                                                    _DAT_64 = 0xb;

-                                                    _DAT_65 = 0xc;

-                                                    _DAT_66 = 0xd;

-                                                    _DAT_67 = 0x10;

-                                                    _DAT_68 = 0x11;

-                                                    _DAT_69 = 0x12;

-                                                    _DAT_70 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x78) >> 0x20

-                                                         );

-                                                    _DAT_71 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x70) >> 0x20

-                                                         );

-                                                    _DAT_72 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x68) >> 0x20

-                                                         );

-                                                    _DAT_73 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x60) >> 0x20

-                                                         );

-                                                    _DAT_74 =

-                                                         (undefined4)

-                                                         ((ulonglong)

-                                                          *(undefined8 *)(unaff_RBP + -0x58) >> 0x20

-                                                         );

-                                                    _DAT_75 = 0;

-                                                    _DAT_76 =

-                                                         SeAppSiloVolumeRootMinimalCapabilitySid;

-                                                    _DAT_77 =

-                                                         SeAppSiloProfilesRootMinimalCapabilitySid;

-                                                    _DAT_78 =

-                                                         SeAppSiloPromptForAccessCapabilitySid;

-                                                    _DAT_79 =

-                                                                                                                  

-                                                  SeAppSiloAccessToPublisherDirectoryCapabilitySid;

-                                                  _DAT_80 = 0x13;

-                                                  _DAT_81 = 0x14;

-                                                  _DAT_82 = 0x15;

-                                                  _DAT_83 = 0x16;

-                                                  _DAT_84 = 0x17;

-                                                  _DAT_85 =

-                                                       (undefined4)

-                                                       ((ulonglong)

-                                                        *(undefined8 *)(unaff_RBP + -0x50) >> 0x20);

-                                                  _DAT_86 = 0x18;

-                                                  _DAT_87 = 0;

-                                                  _DAT_88 = 0x19;

-                                                  _DAT_89 = 0;

-                                                  _DAT_90 = 0x1a;

-                                                  _DAT_91 = 0;

-                                                  _DAT_92 = 0x1b;

-                                                  _DAT_93 = 0;

-                                                  _DAT_94 = 0x1c;

-                                                  _DAT_95 = 0;

-                                                  _DAT_96 = 0x1d;

-                                                  _DAT_97 = 0;

-                                                  _DAT_98 = 0x1e;

-                                                  _DAT_99 = 0;

-                                                  _DAT_100 = 0x1f;

-                                                  _DAT_101 = 0;

-                                                  _DAT_102 = 0x20;

-                                                  _DAT_103 = 0;

-                                                  _DAT_104 = 0x21;

-                                                  _DAT_105 = 0;

-                                                  _DAT_106 = 0x22;

-                                                  _DAT_107 = 0;

-                                                  _DAT_108 = 0x23;

-                                                  _DAT_109 = 0;

-                                                  _DAT_110 = 0x24;

-                                                  iVar12 = 

-                                                  Feature_AgenticAppContainerBfsSupport__private_IsEnabledDeviceUsageNoInline

-                                                            ();

-                                                  if (iVar12 != 0) {

-                                                    _DAT_111 = SeAllRestrictedAppPackagesSid;

-                                                  }

-                                                  SeExports = &SepExports;

-                                                  puVar16 = &DAT_112;

-                                                  lVar15 = 5;

-                                                  do {

-                                                    *(undefined1 *)(puVar16 + 1) = 0;

-                                                    *puVar16 = 0;

-                                                    puVar16[-3] = 0;

-                                                    puVar16 = puVar16 + 5;

-                                                    lVar15 = lVar15 + -1;

-                                                  } while (lVar15 != 0);

-                                                  LowboxSessionMapLock = 0;

-                                                  g_SessionLowboxMap = 0;

-                                                  iVar12 = SepInitializeSharedSidMap();

-                                                  if (-1 < iVar12) {

-                                                    return 1;

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                  }

-                                                }

-                                              }

-                                            }

-                                          }

-                                        }

-                                      }

-                                    }

-                                  }

-                                }

-                              }

-                            }

-                          }

-                        }

-                      }

-                    }

-                  }

-                }

-              }

-            }

-          }

-        }

-      }

-    }

-  }

-  return 0;

+  return iVar1;

 }
```

## `MiAsyncSlabReplenish`  (modified)

```diff
--- MiAsyncSlabReplenish
+++ MiAsyncSlabReplenish
@@ -1,220 +1,397 @@
 

-ulonglong MiAsyncSlabReplenish

-                    (longlong param_1,longlong *param_2,longlong param_3,int param_4,

-                    longlong param_5,char *param_6)

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

+

+ulonglong MiAsyncSlabReplenish(ulonglong param_1,longlong *param_2,uint param_3)

 

 {

-  ulonglong *puVar1;

-  char *pcVar2;

-  char *pcVar3;

-  undefined7 uVar4;

-  uint uVar5;

-  uint uVar6;

-  ulonglong uVar7;

-  ulonglong *puVar8;

-  short *psVar9;

-  ulonglong *puVar10;

-  ulonglong *unaff_RBP;

+  longlong lVar1;

+  undefined4 uVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  undefined8 uVar5;

+  ulonglong *puVar6;

+  char cVar7;

+  undefined1 uVar8;

+  int iVar9;

+  undefined1 *puVar10;

   ulonglong uVar11;

-  short *unaff_RSI;

-  longlong unaff_RDI;

-  int *piVar12;

-  longlong *plVar13;

-  ulonglong in_R11;

-  longlong *unaff_R12;

-  longlong *unaff_R13;

-  longlong lVar14;

-  longlong *unaff_R14;

-  int iVar15;

-  int iVar16;

-  short *psVar17;

-  int *local_res20;

-  uint *puStack0000000000000038;

-  longlong *plStack0000000000000050;

-  longlong in_stack_000000c0;

-  int *in_stack_000000c8;

-  int in_stack_000000d0;

-  uint uStack00000000000000d8;

-  uint uStack00000000000000e0;

-  int iStack00000000000000e8;

+  undefined1 *puVar12;

+  longlong lVar13;

+  ulonglong uVar14;

+  undefined1 *puVar15;

+  uint uVar16;

+  int iVar17;

+  undefined1 *puVar18;

+  ulonglong *puVar19;

+  ulonglong *puVar20;

+  ulonglong uVar21;

+  uint uVar22;

+  longlong in_R10;

+  longlong *plVar23;

+  undefined1 *puVar24;

+  longlong *plVar25;

+  undefined1 *puVar26;

+  char cVar27;

+  uint uVar28;

+  undefined1 local_res20;

+  longlong *plStack_b8;

+  undefined1 *puStack_b0;

+  undefined1 *puStack_a8;

+  longlong lStack_a0;

+  undefined8 uStack_98;

+  ulonglong uStack_90;

+  longlong lStack_88;

+  longlong *plStack_80;

+  longlong *local_78;

+  undefined1 *puStack_70;

+  uint local_68;

+  undefined4 uStack_64;

+  ulonglong local_60;

+  ulonglong *local_58;

+  undefined1 *local_50;

+  undefined8 *****local_48;

+  undefined8 local_40;

   

-  uVar7 = param_1 * param_3;

+  puVar10 = &stack0xffffffffffffffc8;

+  local_60 = 0;

+  plVar25 = (longlong *)(ulonglong)param_3;

+  local_58 = (ulonglong *)0x0;

+  if (((byte)MiFlags & 0x30) < 0x10) {

+    return 1;

+  }

+  uVar16 = 1;

+  local_40 = &local_48;

+  lVar1 = param_1 + 0x10;

+  local_48 = &local_48;

+  local_50 = (undefined1 *)0x60000;

+  uVar28 = param_3 & 1;

+  uVar14 = (ulonglong)uVar28;

+  uVar8 = 0x11;

+  uVar11 = (ulonglong)(uVar28 ^ 1);

+  local_68 = param_3 & 4;

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

+    local_res20 = ExAcquireSpinLockExclusive(lVar1);

+  }

+  else {

+    local_res20 = 0x11;

+    ExAcquireSpinLockExclusiveAtDpcLevel();

+  }

+  uVar21 = param_1;

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

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

+      *(ulonglong *)(param_1 + 0xd0) = param_1;

+      ExQueueWorkItemToPartition

+                (param_1 + 0xb8,1,*(undefined4 *)(param_1 + 0x84),

+                 *(undefined8 *)(*(longlong *)(param_1 + 0x18) + 0xb8));

+      goto LAB_0;

+    }

+    uVar11 = 0;

+  }

+  else {

 LAB_0:

-  iStack00000000000000e8 = 1;

-  iVar15 = 0x40;

-  do {

-    plStack0000000000000050 = param_2;

-    uStack00000000000000e0 = (int)plStack0000000000000050 - param_4;

-    puStack0000000000000038 = (uint *)(in_stack_000000c0 + (uVar7 >> 0x34) * 4);

-    uStack00000000000000d8 = *puStack0000000000000038;

-    param_2 = (longlong *)((longlong)plStack0000000000000050 + (longlong)iStack00000000000000e8);

-    iVar16 = iVar15 + 1;

-    iStack00000000000000e8 = iVar15 >> 6;

-    if (unaff_R14 < param_2) goto LAB_1;

-    local_res20 = (int *)((ulonglong)uStack00000000000000d8 + param_5);

-    uVar7 = *param_2 * -0x30e4432345000000;

-    *puStack0000000000000038 = uStack00000000000000e0;

-    iVar15 = iVar16;

-    param_4 = (int)param_5;

-  } while ((uStack00000000000000d8 + 0xffff < uStack00000000000000e0) ||

-          (*local_res20 != (int)*plStack0000000000000050));

-  if ((in_stack_000000c8 < local_res20) &&

-     (piVar12 = local_res20, plVar13 = plStack0000000000000050,

-     *(char *)((longlong)plStack0000000000000050 + -1) == *(char *)((longlong)local_res20 + -1))) {

-    do {

-      plStack0000000000000050 = (longlong *)((longlong)plVar13 + -1);

-      uVar4 = (undefined7)(in_R11 >> 8);

-      local_res20 = (int *)((longlong)piVar12 + -1);

-      if (((uint)CONCAT71(uVar4,in_stack_000000c8 < local_res20) &

-          (uint)CONCAT71(uVar4,unaff_R13 < plStack0000000000000050)) == 0) break;

-      pcVar3 = (char *)((longlong)piVar12 + -2);

-      pcVar2 = (char *)((longlong)plVar13 + -2);

-      piVar12 = local_res20;

-      plVar13 = plStack0000000000000050;

-    } while (*pcVar2 == *pcVar3);

-  }

-  psVar17 = (short *)((longlong)unaff_RSI + 1);

-  uVar5 = (int)plStack0000000000000050 - (int)unaff_R13;

-  if ((char *)((ulonglong)uVar5 / 0xff + 8 + (ulonglong)uVar5 + (longlong)psVar17) <= param_6) {

-    if (uVar5 < 0xf) {

-      *(char *)unaff_RSI = (char)uVar5 << 4;

+    if ((uVar28 ^ 1) != 0) {

+      uVar21 = param_1 + 0xd8;

+      puVar20 = *(ulonglong **)(param_1 + 0xe0);

+      if (*puVar20 != uVar21) goto LAB_1;

+      *puVar20 = (ulonglong)&local_60;

+      *(ulonglong **)(param_1 + 0xe0) = &local_60;

+      local_60 = uVar21;

+      local_58 = puVar20;

+    }

+  }

+  MiReleaseSpinLockExclusive(lVar1,local_res20);

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

+    local_78 = param_2;

+    iVar9 = KeWaitForMutexObject(&local_50,0x1a,0);

+    if (iVar9 != 0x102) {

+      uVar16 = uVar28;

+    }

+    uVar14 = (ulonglong)uVar16;

+    if (local_68 == 0) {

+      uVar8 = ExAcquireSpinLockExclusive(lVar1);

     }

     else {

-      uVar6 = uVar5 - 0xf;

-      *(char *)unaff_RSI = -0x10;

-      uStack00000000000000e0 = uVar6;

-      if (0xfe < (int)uVar6) {

-        uVar7 = (ulonglong)uVar6 / 0xff;

-        memset(psVar17,(int)CONCAT71((int7)(uVar7 >> 8),0xff),uVar7);

-        psVar17 = (short *)((longlong)psVar17 + uVar7);

-        uVar6 = uStack00000000000000e0 + (int)uVar7 * -0xff;

-        in_R11 = 0;

+      ExAcquireSpinLockExclusiveAtDpcLevel();

+    }

+    if ((*(ulonglong **)(local_60 + 8) != &local_60) || ((ulonglong *)*local_58 != &local_60)) {

+LAB_1:

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

+      (*pcVar4)(3);

+      puVar19 = &uStack_90;

+      puVar20 = &uStack_90;

+      uStack_90 = (ulonglong)(~(uint)((ulonglong)KeFeatureBits >> 0x25) & (uint)in_R10);

+      lVar13 = 4;

+      do {

+        *(undefined8 *)(puVar10 + 0x10) = 0;

+        *(undefined1 **)(puVar10 + 8) = puVar10;

+        *(undefined1 **)puVar10 = puVar10;

+        puVar10 = puVar10 + 0x18;

+        lVar13 = lVar13 - in_R10;

+      } while (lVar13 != 0);

+      local_58 = (ulonglong *)((ulonglong)local_58 & 0xffffffff00000000);

+      local_68 = CONCAT31(local_68._1_3_,(char)uVar21);

+      puStack_70 = (undefined1 *)CONCAT44(puStack_70._4_4_,uVar16);

+      local_60 = uVar11;

+      local_50 = &stack0xffffffffffffffc8;

+      uVar11 = MiCreateLargePfnList(&local_50,plStack_80);

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

+        puVar10 = (undefined1 *)0x0;

+        cVar7 = '\x11';

+        lStack_a0 = 0;

+        puVar26 = (undefined1 *)0x0;

+        puStack_a8 = (undefined1 *)0x0;

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

+        uVar2 = *(undefined4 *)

+                 (&MmMakeProtectNotWriteCopy + (ulonglong)(*(uint *)(uVar14 + 0x30) >> 7 & 0x1f) * 4

+                 );

+        plStack_b8 = plStack_80;

+        puStack_b0 = (undefined1 *)(((ulonglong)plStack_80 >> 9 & 0x7ffffffff8) - 0x98000000000);

+        puVar12 = (undefined1 *)0x0;

+        puVar20 = &uStack_90;

+        lVar13 = 0;

+        plVar23 = plStack_80;

+        cVar27 = '\x11';

+        if (plStack_80 < plVar25) {

+LAB_2:

+          puVar12 = (undefined1 *)(ulonglong)*(uint *)((longlong)puVar19 + 0x5c);

+          puVar18 = puVar26;

+          plVar23 = plStack_b8;

+          puVar24 = puStack_b0;

+          puVar26 = (undefined1 *)0x1;

+          uVar16 = (uint)uStack_90;

+          cVar7 = cVar27;

+          do {

+            uVar22 = (uint)puVar12;

+            uVar28 = uVar16;

+            if (uVar22 < uVar16) {

+LAB_3:

+              iVar9 = (int)puVar10;

+              uVar14 = (ulonglong)uVar28;

+              puStack_70 = (undefined1 *)(uVar14 * 3);

+              local_78 = (longlong *)(&stack0xffffffffffffffc8 + uVar14 * 0x18);

+              plVar23 = (longlong *)*local_78;

+              puVar12 = puStack_70;

+              if (((longlong *)plVar23[1] == local_78) &&

+                 (lVar13 = *plVar23, *(longlong **)(lVar13 + 8) == plVar23)) {

+                *local_78 = lVar13;

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

+                lStack_88 = (&MiPageSizes)[uVar14];

+                *(longlong *)(&stack0xffffffffffffffd8 + uVar14 * 0x18) =

+                     *(longlong *)(&stack0xffffffffffffffd8 + uVar14 * 0x18) - (longlong)puVar26;

+                puVar12 = (undefined1 *)((longlong)puVar19 + 0x60);

+                puVar20 = *(ulonglong **)((longlong)puVar19 + 0x68);

+                puVar15 = &DAT_4;

+                if (uVar28 != 2) {

+                  puVar15 = (undefined1 *)((ulonglong)puVar26 & 0xffffffff);

+                }

+                *(int *)((longlong)puVar19 + 0x70) = (int)puVar15;

+                if ((undefined1 *)*puVar20 == puVar12) {

+                  plVar23[1] = (longlong)puVar20;

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

+                  *puVar20 = (ulonglong)plVar23;

+                  *(longlong **)((longlong)puVar19 + 0x68) = plVar23;

+                  puVar26 = puVar24;

+                  if (uVar28 < 2) {

+                    uVar14 = (ulonglong)(2 - uVar28);

+                    do {

+                      puVar26 = (undefined1 *)

+                                (((ulonglong)puVar26 >> 9 & 0x7ffffffff8) - 0x98000000000);

+                      uVar14 = uVar14 - 1;

+                    } while (uVar14 != 0);

+                    iVar9 = *(int *)((longlong)puVar19 + 0x54);

+                  }

+                  if ((*(int *)((longlong)puVar19 + 0x58) != 0) ||

+                     ((((ulonglong)puVar18 ^ (ulonglong)puVar26) & 0xfffffffffffff000) != 0)) {

+                    if ((*(int *)((longlong)puVar19 + 0x78) == 0x4200000) && (iVar9 != 0)) {

+                      *(undefined8 *)((longlong)puVar19 + -8) = 0x14039787e;

+                      MiFlushGraphicsPtes(puStack_a8,iVar9);

+                      puStack_a8 = (undefined1 *)0x0;

+                    }

+                    if (lStack_a0 != 0) {

+                      *(undefined8 *)((longlong)puVar19 + -8) = 0x140397893;

+                      MiUnlockPageTableInternal(uVar8,lStack_a0);

+                      lStack_a0 = 0;

+                    }

+                    iVar9 = *(int *)((longlong)puVar19 + 0x50);

+                    if (*(int *)((longlong)puVar19 + 0x58) == 0) {

+                      if (iVar9 == 1) {

+                        if (uVar28 != 0) goto LAB_5;

+                      }

+                      else if (uVar28 == 0) goto LAB_5;

+                      if (cVar7 == '\x11') goto LAB_6;

+LAB_7:

+                      if (iVar9 == 0) goto LAB_8;

+                    }

+                    else {

+LAB_5:

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

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

+                        if (iVar9 == 1) {

+                          *(undefined8 *)((longlong)puVar19 + -8) = 0x1403978c8;

+                          MiUnlockWorkingSetExclusive();

+                        }

+                        else {

+                          *(undefined8 *)((longlong)puVar19 + -8) = 0x1406de97d;

+                          MiUnlockWorkingSetShared(uVar8,cVar7);

+                        }

+                        cVar7 = '\x11';

+                      }

+LAB_6:

+                      if (uVar28 == 0) {

+                        *(undefined4 *)((longlong)puVar19 + 0x50) = 1;

+                        *(undefined8 *)((longlong)puVar19 + -8) = 0x1403978e1;

+                        cVar7 = MiLockWorkingSetForLargeMapping(uVar8);

+                      }

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

+                        iVar9 = *(int *)((longlong)puVar19 + 0x50);

+                        goto LAB_7;

+                      }

+                      *(undefined4 *)((longlong)puVar19 + 0x50) = 0;

+                      *(undefined8 *)((longlong)puVar19 + -8) = 0x14039775a;

+                      cVar7 = MiLockWorkingSetShared(uVar8);

+                      iVar9 = *(int *)((longlong)puVar19 + 0x50);

+LAB_8:

+                      lStack_a0 = ((ulonglong)puVar26 >> 9 & 0x7ffffffff8) - 0x98000000000;

+                    }

+                    *(undefined8 *)((longlong)puVar19 + -8) = 0x14039779a;

+                    MiMakeSystemAddressValid(puVar26,(int)lVar1 + 1,cVar7,iVar9);

+                    puVar15 = (undefined1 *)(ulonglong)*(uint *)((longlong)puVar19 + 0x70);

+                    puVar24 = puStack_b0;

+                  }

+                  puVar18 = (undefined1 *)0x0;

+                  plStack_b8 = plStack_b8 + lStack_88 * 0x200;

+                  if (plVar25 <= plStack_b8) goto LAB_9;

+                  puVar10 = (undefined1 *)((longlong)plVar25 - (longlong)plStack_b8);

+                  if (((ulonglong)(puVar26 + 8) & 0xfff) == 0) {

+                    uVar14 = 0;

+                  }

+                  else {

+                    uVar14 = 0x200 - (ulonglong)((int)puVar26 + 8U >> 3 & 0x1ff);

+                  }

+                  puVar12 = (undefined1 *)((uVar14 / (ulonglong)puVar15) * lStack_88 * 0x1000);

+                  if (puVar10 < puVar12) {

+                    puVar12 = puVar10;

+                  }

+                  puVar12 = (undefined1 *)((ulonglong)puVar12 / (ulonglong)(lStack_88 * 0x1000));

+                  while( true ) {

+                    if ((puVar12 <= puVar18) ||

+                       (plVar23 = (longlong *)*local_78, plVar23 == local_78)) goto LAB_9;

+                    if (((longlong *)plVar23[1] != local_78) ||

+                       (lVar13 = *plVar23, *(longlong **)(lVar13 + 8) != plVar23)) break;

+                    *local_78 = lVar13;

+                    puVar10 = (undefined1 *)((longlong)puVar19 + 0x60);

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

+                    plVar3 = *(longlong **)((longlong)puVar19 + 0x68);

+                    *(longlong *)(&stack0xffffffffffffffd8 + (longlong)puStack_70 * 8) =

+                         *(longlong *)(&stack0xffffffffffffffd8 + (longlong)puStack_70 * 8) + -1;

+                    if ((undefined1 *)*plVar3 != puVar10) break;

+                    plVar23[1] = (longlong)plVar3;

+                    puVar10 = (undefined1 *)((longlong)puVar19 + 0x60);

+                    *plVar23 = (longlong)puVar10;

+                    puVar18 = puVar18 + 1;

+                    *plVar3 = (longlong)plVar23;

+                    *(longlong **)((longlong)puVar19 + 0x68) = plVar23;

+                  }

+                }

+              }

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

+              plVar23 = local_78;

+              (*pcVar4)(3);

+              puVar19 = (ulonglong *)((longlong)puVar19 + 8);

+            }

+            else if (((ulonglong)plVar23 % (ulonglong)((&MiPageSizes)[uVar16] << 0xc) == 0) &&

+                    ((ulonglong)((&MiPageSizes)[uVar16] << 0xc) <=

+                     (ulonglong)((longlong)plVar25 - (longlong)plVar23))) {

+              do {

+                if (*(longlong **)(&stack0xffffffffffffffc8 + (ulonglong)uVar28 * 0x18) !=

+                    (longlong *)(&stack0xffffffffffffffc8 + (ulonglong)uVar28 * 0x18)) break;

+                uVar28 = uVar28 + (int)puVar26;

+              } while (uVar28 <= uVar22);

+              if (uVar22 < uVar28) {

+                *(undefined8 *)((longlong)puVar19 + -8) = 0x14039785b;

+                MiDemotePfnListChain(&stack0xffffffffffffffc8,uVar16);

+                puVar10 = (undefined1 *)(ulonglong)*(uint *)((longlong)puVar19 + 0x54);

+                puVar24 = puStack_b0;

+                uVar28 = uVar16;

+              }

+              goto LAB_3;

+            }

+            uVar16 = uVar28 + (int)puVar26;

+          } while( true );

+        }

+LAB_10:

+        if ((*(int *)((longlong)puVar20 + 0x78) == 0x4200000) && ((int)puVar10 != 0)) {

+          *(undefined8 *)((longlong)puVar20 + -8) = 0x140397954;

+          MiFlushGraphicsPtes(puVar12,puVar10);

+        }

+        if (lVar13 != 0) {

+          *(undefined8 *)((longlong)puVar20 + -8) = 0x140397964;

+          MiUnlockPageTableInternal(uVar8,lVar13);

+        }

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

+          if (*(int *)((longlong)puVar20 + 0x50) == 1) {

+            *(undefined8 *)((longlong)puVar20 + -8) = 0x14039797f;

+            MiUnlockWorkingSetExclusive();

+          }

+          else {

+            *(undefined8 *)((longlong)puVar20 + -8) = 0x1406dea27;

+            MiUnlockWorkingSetShared(uVar8,cVar7);

+          }

+        }

+        puVar6 = local_58;

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

+          uVar2 = *(undefined4 *)(local_60 + 0x1d0);

+          *(undefined8 *)((longlong)puVar20 + -8) = 0x1403979a0;

+          MiLogPerfMemoryRangeEvent(plVar23,uVar2,0x1b,puVar6);

+        }

+        uVar11 = 0;

       }

-      *(char *)psVar17 = (char)uVar6;

-      psVar17 = (short *)((longlong)psVar17 + 1);

-    }

-    psVar9 = (short *)((ulonglong)uVar5 + (longlong)psVar17);

-    lVar14 = (longlong)unaff_R13 - (longlong)psVar17;

-    do {

-      *(undefined8 *)psVar17 = *(undefined8 *)((longlong)psVar17 + lVar14);

-      psVar17 = psVar17 + 4;

-    } while (psVar17 < psVar9);

-    psVar17 = unaff_RSI;

-    unaff_R13 = plStack0000000000000050;

-    do {

-      puVar1 = (ulonglong *)((longlong)unaff_R13 + 4);

-      *psVar9 = (short)unaff_R13 - (short)local_res20;

-      unaff_RSI = psVar9 + 1;

-      puVar10 = (ulonglong *)(local_res20 + 1);

-      puVar8 = puVar1;

-      if ((ulonglong *)((longlong)unaff_RBP - 7U) <= puVar1) goto LAB_2;

-      uVar7 = *puVar1 ^ *puVar10;

-      if (uVar7 == 0) {

-        puVar8 = (ulonglong *)((longlong)unaff_R13 + 0xc);

-        while( true ) {

-          puVar10 = puVar10 + 1;

-LAB_2:

-          if ((ulonglong *)((longlong)unaff_RBP - 7U) <= puVar8) {

-            if ((puVar8 < (ulonglong *)((longlong)unaff_RBP - 3U)) &&

-               ((int)*puVar10 == (int)*puVar8)) {

-              puVar8 = (ulonglong *)((longlong)puVar8 + 4);

-              puVar10 = (ulonglong *)((longlong)puVar10 + 4);

-            }

-            if ((puVar8 < (ulonglong *)((longlong)unaff_RBP - 1U)) &&

-               ((short)*puVar10 == (short)*puVar8)) {

-              puVar8 = (ulonglong *)((longlong)puVar8 + 2);

-              puVar10 = (ulonglong *)((longlong)puVar10 + 2);

-            }

-            if ((puVar8 < unaff_RBP) && ((char)*puVar10 == (char)*puVar8)) {

-              puVar8 = (ulonglong *)((longlong)puVar8 + 1);

-            }

-            uVar5 = (int)puVar8 - (int)puVar1;

-            goto LAB_3;

-          }

-          uVar7 = *puVar8 ^ *puVar10;

-          if (uVar7 != 0) break;

-          puVar8 = puVar8 + 1;

-        }

-        uVar5 = 0;

-        for (; (uVar7 & 1) == 0; uVar7 = uVar7 >> 1 | 0x8000000000000000) {

-          uVar5 = uVar5 + 1;

-        }

-        uVar5 = ((uVar5 >> 3) - (int)puVar1) + (int)puVar8;

-      }

-      else {

-        uVar5 = 0;

-        for (; (uVar7 & 1) == 0; uVar7 = uVar7 >> 1 | 0x8000000000000000) {

-          uVar5 = uVar5 + 1;

-        }

-        uVar5 = uVar5 >> 3;

-      }

-LAB_3:

-      unaff_R13 = (longlong *)((longlong)unaff_R13 + (ulonglong)uVar5 + 4);

-      if (param_6 < (char *)((ulonglong)(uVar5 + 0xf0) / 0xff + 6 + (longlong)unaff_RSI)) break;

-      if (uVar5 < 0xf) {

-        *(char *)psVar17 = (char)*psVar17 + (char)uVar5;

-      }

-      else {

-        uVar5 = uVar5 - 0xf;

-        *(char *)psVar17 = (char)*psVar17 + '\x0f';

-        unaff_RSI[0] = -1;

-        unaff_RSI[1] = -1;

-        if (0x3fb < uVar5) {

-          uVar7 = (ulonglong)uVar5 / 0x3fc;

-          do {

-            unaff_RSI = unaff_RSI + 2;

-            uVar5 = uVar5 - 0x3fc;

-            unaff_RSI[0] = -1;

-            unaff_RSI[1] = -1;

-            uVar7 = uVar7 - 1;

-          } while (uVar7 != 0);

-        }

-        pcVar3 = (char *)((ulonglong)uVar5 / 0xff + (longlong)unaff_RSI);

-        unaff_RSI = (short *)(pcVar3 + 1);

-        *pcVar3 = (char)((ulonglong)uVar5 / 0xff) + (char)uVar5;

-      }

-      if (unaff_R12 <= unaff_R13) goto LAB_1;

-      uVar6 = (int)unaff_R13 - (int)param_5;

-      *(uint *)(in_stack_000000c0 +

-               ((ulonglong)(*(longlong *)((longlong)unaff_R13 + -2) * -0x30e4432345000000) >> 0x34)

-               * 4) = uVar6 - 2;

-      uVar7 = (ulonglong)(*unaff_R13 * -0x30e4432345000000) >> 0x34;

-      uVar5 = *(uint *)(in_stack_000000c0 + uVar7 * 4);

-      *(uint *)(in_stack_000000c0 + uVar7 * 4) = uVar6;

-      local_res20 = (int *)((ulonglong)uVar5 + param_5);

-      if ((uVar5 + 0xffff < uVar6) || (*local_res20 != (int)*unaff_R13)) goto LAB_4;

-      psVar9 = (short *)((longlong)unaff_RSI + 1);

-      *(char *)unaff_RSI = '\0';

-      psVar17 = unaff_RSI;

-    } while( true );

-  }

-  goto LAB_5;

-LAB_4:

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

-  uVar7 = *(longlong *)((longlong)unaff_R13 + 1) * -0x30e4432345000000;

-  goto LAB_0;

-LAB_1:

-  uVar7 = unaff_RDI - (longlong)unaff_R13;

-  if ((char *)((longlong)unaff_RSI + (uVar7 + 0xf0) / 0xff + uVar7 + 1) <= param_6) {

-    if (uVar7 < 0xf) {

-      *(char *)unaff_RSI = (char)uVar7 << 4;

-    }

-    else {

-      *(char *)unaff_RSI = -0x10;

-      uVar11 = uVar7 - 0xf;

-      unaff_RSI = (short *)((longlong)unaff_RSI + 1);

-      if (0xfe < uVar11) {

-        memset(unaff_RSI,(int)CONCAT71((int7)(uVar11 / 0x1fe),0xff),uVar11 / 0xff);

-        unaff_RSI = (short *)((longlong)unaff_RSI + uVar11 / 0xff);

-        uVar11 = uVar11 % 0xff;

-      }

-      *(char *)unaff_RSI = (char)uVar11;

-    }

-    RtlCopyMemory((char *)((longlong)unaff_RSI + 1),unaff_R13,uVar7);

-    in_R11 = (ulonglong)

-             (uint)(((int)(char *)((longlong)unaff_RSI + 1) + (int)uVar7) - in_stack_000000d0);

-  }

-LAB_5:

-  return in_R11 & 0xffffffff;

+      *(undefined8 *)((longlong)puVar20 + -8) = 0x140397670;

+      return uVar11;

+    }

+    *local_58 = local_60;

+    *(ulonglong **)(local_60 + 8) = local_58;

+    MiReleaseSpinLockExclusive(lVar1,uVar8);

+  }

+  return uVar14;

+LAB_9:

+  uVar5 = CONCAT44(uStack_64,local_68);

+  *(undefined4 *)((longlong)puVar19 + 0x20) = uVar2;

+  *(undefined8 *)((longlong)puVar19 + -8) = 0x1403977df;

+  MiInsertLargeUserMapping(uVar5,puVar24,(undefined1 *)((longlong)puVar19 + 0x60),uVar28);

+  iVar17 = (int)(puVar18 + 1);

+  iVar9 = *(int *)((longlong)puVar19 + 0x70) * iVar17;

+  plStack_b8 = plStack_b8 + (longlong)puVar18 * lStack_88 * 0x200;

+  if (puStack_a8 == (undefined1 *)0x0) {

+    *(int *)((longlong)puVar19 + 0x54) = iVar9;

+    puStack_a8 = puVar26;

+  }

+  else {

+    *(int *)((longlong)puVar19 + 0x54) = *(int *)((longlong)puVar19 + 0x54) + iVar9;

+  }

+  puStack_b0 = puStack_b0 + (longlong)(puVar18 + 1) * lStack_88 * 8;

+  uVar16 = *(int *)((longlong)puVar19 + 0x74) + iVar17;

+  *(uint *)((longlong)puVar19 + 0x74) = uVar16;

+  if ((uVar16 & 0xf) == 0) {

+    *(undefined8 *)((longlong)puVar19 + -8) = 0x14039791e;

+    iVar9 = MiWorkingSetIsContended(uVar8,*(uint *)((longlong)puVar19 + 0x50) & 1);

+    if (iVar9 == 0) goto LAB_12;

+  }

+  else {

+LAB_12:

+    *(undefined8 *)((longlong)puVar19 + -8) = 0x14039760a;

+    iVar9 = KeShouldYieldProcessor();

+    if (iVar9 == 0) goto LAB_13;

+  }

+  *(undefined4 *)((longlong)puVar19 + 0x58) = 1;

+LAB_13:

+  puVar10 = (undefined1 *)(ulonglong)*(uint *)((longlong)puVar19 + 0x54);

+  puVar12 = puStack_a8;

+  puVar20 = puVar19;

+  lVar13 = lStack_a0;

+  plVar23 = plStack_80;

+  cVar27 = cVar7;

+  if (plVar25 <= plStack_b8) goto LAB_10;

+  goto LAB_2;

 }
```

## `PpmHeteroUpdateHgsConfiguration`  (modified)

```diff
--- PpmHeteroUpdateHgsConfiguration
+++ PpmHeteroUpdateHgsConfiguration
@@ -1,16 +1,312 @@
 

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

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

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

 

-void PpmHeteroUpdateHgsConfiguration(void)

+byte PpmHeteroUpdateHgsConfiguration(void)

 

 {

-  undefined8 local_res18;

+  char cVar1;

+  byte bVar2;

+  byte bVar3;

+  char cVar4;

+  int iVar5;

+  int iVar6;

+  uint uVar7;

+  longlong lVar8;

+  ulonglong uVar9;

+  ulonglong uVar10;

+  undefined8 *puVar11;

+  longlong lVar12;

+  byte *pbVar13;

+  void *pvVar14;

+  int iVar15;

+  ulonglong _Size;

+  ulonglong uVar16;

+  ushort uVar17;

+  uint uVar18;

+  byte bVar19;

+  bool bVar20;

+  char cVar21;

+  undefined1 auStack_908 [32];

+  int local_8e8;

+  uint local_8e4;

+  undefined4 local_8e0 [2];

+  undefined2 *local_8d8;

+  undefined8 local_8d0;

+  undefined2 local_8c8;

+  undefined4 local_8c6;

+  undefined2 local_8c2;

+  _KAFFINITY_EX local_8b8;

+  _KAFFINITY_EX local_7a8;

+  _KAFFINITY_EX local_698;

+  undefined8 local_588;

+  undefined1 local_580 [264];

+  undefined8 local_478;

+  undefined1 local_470 [264];

+  undefined8 local_368;

+  undefined1 local_360 [264];

+  undefined8 local_258;

+  undefined1 local_250 [264];

+  undefined8 local_148;

+  undefined1 local_140 [264];

+  ulonglong local_38;

   

-  func_0x0001402e0f40(0);

-  func_0x0001402e0d9c();

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

-    func_0x0001402e10a4(local_res18);

+  local_38 = __security_cookie ^ (ulonglong)auStack_908;

+  uVar16 = 0;

+  local_8e0[0] = 0;

+  memset(&local_368,0,0x108);

+  memset(&local_478,0,0x108);

+  local_8c6 = 0;

+  uVar17 = 0;

+  local_8c2 = 0;

+  memset(&local_698.field3_0x8,0,0x100);

+  local_8e8 = 0;

+  memset(&local_7a8.field3_0x8,0,0x100);

+  memset(&local_8b8,0,0x108);

+  memset(local_140,0,0x100);

+  memset(&local_258,0,0x108);

+  memset(&local_588,0,0x108);

+  bVar2 = 0;

+  bVar19 = 0;

+  if ((((PpmHeteroHgsEnabled != '\0') &&

+       (iVar5 = KeIsEmptyAffinityEx(&PpmCheckRegistered), iVar5 == 0)) &&

+      (PpmHeteroCheckWpsTableUpdated != (code *)0x0)) &&

+     (cVar1 = (*PpmHeteroCheckWpsTableUpdated)(PpmHeteroWpsUpdateInterfaceHandle), cVar1 != '\0')) {

+    bVar20 = PpmHeteroHgsPopulated == '\0';

+    PpmHeteroHgsPopulated = '\x01';

+    local_698.Count = 1;

+    local_698.Size = 0x20;

+    local_698.Reserved = 0;

+    local_8e4 = (uint)bVar20;

+    memset(&local_698.field3_0x8,0,0x100);

+    _PpmParkNewForceParkingMask = 0x200001;

+    memset(&DAT_0,0,0x100);

+    KiCopyAffinityEx(&local_698,local_698.Size,(_KAFFINITY_EX *)&PpmCheckRegistered);

+    uVar10 = uVar16;

+    uVar7 = (uint)bVar20;

+    if (*(int *)(PpmHeteroCapability + 4) != 0) {

+      do {

+        local_368 = 0x200001;

+        memset(local_360,0,0x100);

+        local_258 = 0x200001;

+        memset(local_250,0,0x100);

+        local_478 = 0x200001;

+        memset(local_470,0,0x100);

+        local_588 = 0x200001;

+        memset(local_580,0,0x100);

+        local_148 = 0x200001;

+        memset(local_140,0,0x100);

+        local_8d0 = DAT_1;

+        local_8c8 = 0;

+        local_8d8 = &PpmCheckRegistered;

+        iVar6 = KeEnumerateNextProcessor(&local_8e8,&local_8d8);

+        iVar15 = (int)uVar10;

+        iVar5 = local_8e8;

+        while (local_8e8 = iVar5, iVar6 == 0) {

+          lVar8 = KeGetPrcb(iVar5);

+          if ((PpmHeteroCapabilitySimulation == 0) || ((PpmHeteroSimulationStateConfig & 2) == 0)) {

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

+              uVar9 = (ulonglong)

+                      ((uint)*(ushort *)(lVar8 + 0x8a4a) + iVar15 * PpmHeteroHgsCapabilityBits);

+              cVar1 = *(char *)(PpmHeteroHgsTableEntry + 1 + uVar9);

+              cVar4 = *(char *)(PpmHeteroHgsTableEntry + uVar9);

+              iVar5 = local_8e8;

+            }

+            else if (PpmHeteroHgsVendor == '\x01') {

+              uVar9 = (ulonglong)(uint)(iVar15 * PpmHeteroHgsCapabilityBits * 4);

+              lVar12 = (ulonglong)*(ushort *)(lVar8 + 0x8a4a) + PpmHeteroHgsTableEntry;

+              cVar1 = *(char *)(lVar12 + uVar9);

+              cVar4 = *(char *)(lVar12 + 4 + uVar9);

+              iVar5 = local_8e8;

+            }

+            else {

+              cVar1 = '\x01';

+              cVar4 = '\x01';

+            }

+          }

+          else {

+            uVar9 = (ulonglong)(uint)(iVar5 * *(int *)(PpmHeteroCapabilitySimulation + 4) + iVar15);

+            cVar1 = *(char *)(PpmHeteroCapabilitySimulation + 0x18 + uVar9 * 4);

+            cVar4 = *(char *)(PpmHeteroCapabilitySimulation + 0x19 + uVar9 * 4);

+          }

+          bVar20 = PpmHeteroHgsParkingHintEnabled == '\0';

+          lVar8 = *(longlong *)(lVar8 + 0x8a50);

+          *(char *)(lVar8 + 6 + uVar10 * 4) = cVar4;

+          *(char *)(lVar8 + 7 + uVar10 * 4) = cVar1;

+          if (bVar20) {

+            KeAddProcessorAffinityEx(&local_588,iVar5);

+LAB_2:

+            puVar11 = &local_478;

+          }

+          else if ((PpmHeteroHgsThreadEnabled == '\0') ||

+                  (PpmHeteroHgsEePerfHintsIndependentEnabled == 0)) {

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

+              KeAddProcessorAffinityEx(&local_368,iVar5);

+              puVar11 = &local_258;

+            }

+            else {

+              KeAddProcessorAffinityEx(&local_478,iVar5);

+              puVar11 = &local_588;

+            }

+          }

+          else {

+            puVar11 = &local_258;

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

+              puVar11 = &local_588;

+            }

+            KeAddProcessorAffinityEx(puVar11,iVar5);

+            if (cVar1 != '\0') goto LAB_2;

+            puVar11 = &local_368;

+          }

+          KeAddProcessorAffinityEx(puVar11,iVar5);

+          iVar6 = KeEnumerateNextProcessor(&local_8e8,&local_8d8);

+          iVar5 = local_8e8;

+        }

+        bVar2 = PPmHeteroHgsUpdateOrderValue(&local_588,&local_258,uVar10,1);

+        bVar3 = PPmHeteroHgsUpdateOrderValue(&local_478,&local_368,uVar10,0);

+        bVar19 = bVar19 | bVar2 | bVar3;

+        KeAndAffinityEx2(&local_258,&local_368,&local_148);

+        KeAndAffinityEx2(&local_698,&local_148,&local_698);

+        uVar10 = (ulonglong)(iVar15 + 1U);

+        uVar7 = local_8e4;

+      } while (iVar15 + 1U < *(uint *)(PpmHeteroCapability + 4));

+    }

+    cVar1 = (char)uVar7;

+    bVar2 = bVar19;

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

+      local_8d0 = DAT_1;

+      local_8d8 = &PpmCheckRegistered;

+      local_8c8 = 0;

+      while (iVar5 = KeEnumerateNextProcessor(&local_8e8), iVar5 == 0) {

+        lVar8 = KeGetPrcb(local_8e8);

+        cVar4 = KeCheckProcessorAffinityEx(&local_698,local_8e8);

+        if (*(char *)(lVar8 + 0x8a4c) != cVar4) {

+          bVar2 = 1;

+          *(char *)(lVar8 + 0x8a4c) = cVar4;

+        }

+      }

+    }

+    if ((((PpmHeteroHgsDynamicUpdateEnabled != '\0') &&

+         (PpmHeteroHgsDynamicUpdateReasonEnabled != '\0')) &&

+        (PpmHeteroHgsNewUpdateReason != (void *)0x0)) &&

+       (PpmHeteroHgsOldUpdateReason != (void *)0x0)) {

+      _Size = (ulonglong)(PpmHeteroWorkloadClasses * 2);

+      pvVar14 = PpmHeteroHgsNewUpdateReason;

+      uVar10 = uVar16;

+      uVar9 = uVar16;

+      if (PpmHeteroWorkloadClasses != 0) {

+        do {

+          pvVar14 = PpmHeteroHgsNewUpdateReason;

+          pbVar13 = (byte *)(PpmHeteroHgsTableEntry +

+                            (ulonglong)

+                            (uint)((int)uVar10 * PpmHeteroHgsCapabilityBits +

+                                  _PpmHgsUpdateChangeReasonOffset));

+          bVar19 = *pbVar13;

+          *(byte *)((longlong)PpmHeteroHgsNewUpdateReason + uVar10 * 2) = bVar19;

+          bVar3 = pbVar13[1];

+          *(byte *)((longlong)pvVar14 + uVar10 * 2 + 1) = bVar3;

+          if (((bVar19 & 2) != 0) && ((bVar3 & 2) != 0)) {

+            uVar9 = (ulonglong)((int)uVar9 + 1);

+          }

+          uVar18 = (int)uVar10 + 1;

+          uVar10 = (ulonglong)uVar18;

+        } while (uVar18 < PpmHeteroWorkloadClasses);

+      }

+      cVar21 = (uint)uVar9 == PpmHeteroWorkloadClasses;

+      cVar4 = KeIsForceParkingEnabled();

+      if ((cVar4 != '\0') && (cVar21 != '\0')) {

+        KiCopyAffinityEx((_KAFFINITY_EX *)&PpmParkNewForceParkingMask,DAT_3,&local_698);

+      }

+      uVar10 = RtlCompareMemory(pvVar14,PpmHeteroHgsOldUpdateReason,_Size);

+      if (uVar10 != _Size) {

+        RtlCopyMemory(PpmHeteroHgsOldUpdateReason,PpmHeteroHgsNewUpdateReason,_Size);

+        PpmEventHgsHardwareTableResonChanged(0);

+      }

+    }

+    if (((PpmHeteroHgsContainmentState & 4) != 0) || (cVar1 != '\0')) {

+      local_8b8.Count = 1;

+      local_8b8.Size = 0x20;

+      local_8b8.Reserved = 0;

+      memset(&local_8b8.field3_0x8,0,0x100);

+      if (*(int *)(PpmHeteroCapability + 4) != 0) {

+        do {

+          cVar1 = (char)uVar7;

+          local_7a8.Count = 1;

+          local_7a8.Size = 0x20;

+          local_7a8.Reserved = 0;

+          uVar18 = 0xffffffff;

+          memset(&local_7a8.field3_0x8,0,0x100);

+          local_8d0 = DAT_1;

+          local_8c8 = 0;

+          local_8d8 = &PpmCheckRegistered;

+          iVar5 = KeEnumerateNextProcessor(&local_8e8);

+          if (iVar5 != 0) {

+LAB_4:

+            local_8b8.Count = 1;

+            local_8b8.Size = 0x20;

+            local_8b8.Reserved = 0;

+            memset(&local_8b8.field3_0x8,0,0x100);

+            break;

+          }

+          do {

+            lVar8 = KeGetPrcb(local_8e8);

+            bVar19 = *(byte *)(PpmHeteroHgsTableEntry + 1 +

+                              (ulonglong)

+                              ((int)uVar16 * PpmHeteroHgsCapabilityBits +

+                              (uint)*(ushort *)(lVar8 + 0x8a4a)));

+            uVar7 = (uint)bVar19;

+            if (bVar19 != 0) {

+              if ((uVar18 == 0xffffffff) || (uVar18 < uVar7)) {

+                local_7a8.Count = 1;

+                local_7a8.Size = 0x20;

+                local_7a8.Reserved = 0;

+                memset(&local_7a8.field3_0x8,0,0x100);

+                uVar18 = uVar7;

+              }

+              else if (uVar7 != uVar18) goto LAB_5;

+              KeAddProcessorAffinityEx(&local_7a8,local_8e8);

+            }

+LAB_5:

+            iVar5 = KeEnumerateNextProcessor(&local_8e8);

+            uVar7 = local_8e4;

+          } while (iVar5 == 0);

+          cVar1 = (char)local_8e4;

+          if (uVar18 == 0xffffffff) goto LAB_4;

+          KiOrAffinityEx(&local_8b8,&local_7a8,&local_8b8,local_8b8.Size);

+          uVar18 = (int)uVar16 + 1;

+          uVar16 = (ulonglong)uVar18;

+        } while (uVar18 < *(uint *)(PpmHeteroCapability + 4));

+      }

+      iVar5 = KeIsEmptyAffinityEx(&local_8b8);

+      if (iVar5 == 0) {

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

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

+            PpmHeteroHgsDetectContainmentPresence(&local_8b8,cVar1);

+            PpmHeteroHgsEvalAndRegisterContainmentGroups();

+          }

+        }

+        else {

+          PpmHeteroHgsGetContainmentType(&local_8b8,local_8e0);

+          PpmEventHgsContainmentHwUpdate(&local_8b8,local_8e0,0);

+        }

+      }

+      iVar5 = KeIsEmptyAffinityEx(&local_698);

+      uVar7 = PpmParkNumNodes;

+      if (((PpmHeteroHgsContainmentState & 4) != 0) && (PpmParkNumNodes != 0)) {

+        do {

+          lVar8 = *(longlong *)((ulonglong)uVar17 * 0x508 + 0x4f8 + PpmParkNodes);

+          if (lVar8 != 0) {

+            *(bool *)(lVar8 + 0x33b) = iVar5 == 0;

+          }

+          uVar17 = uVar17 + 1;

+        } while (uVar17 < uVar7);

+      }

+      PpmHeteroHgsCheckContainmentDecision();

+    }

+    PpmEventHgsHardwareTable(0);

+    (*PpmHeteroAcknowledgeWpsUpdate)(PpmHeteroWpsUpdateInterfaceHandle);

   }

-  return;

+  return bVar2;

 }
```

## `RtlpQueryLowBoxId`  (modified)

```diff
--- RtlpQueryLowBoxId
+++ RtlpQueryLowBoxId
@@ -1,82 +1,69 @@
 

-int RtlpQueryLowBoxId(void)

+ulonglong RtlpQueryLowBoxId(void)

 

 {

-  longlong *plVar1;

-  char cVar2;

-  longlong lVar3;

-  undefined4 unaff_EBX;

-  int unaff_ESI;

-  int iVar4;

-  void *unaff_R12;

-  undefined2 *unaff_R14;

-  int iStack0000000000000044;

-  uint in_stack_00000048;

-  longlong in_stack_00000050;

-  longlong in_stack_00000058;

-  longlong *in_stack_00000060;

+  ulonglong *puVar1;

+  longlong lVar2;

+  int iVar3;

+  ulonglong uVar4;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  bool bVar7;

+  undefined1 local_res8 [8];

+  uint local_res10 [2];

+  int local_res18 [2];

+  int local_res20 [2];

+  int local_28 [4];

   

-  iStack0000000000000044 = RtlpHashStringToAtom();

-  plVar1 = in_stack_00000060;

-  iVar4 = iStack0000000000000044;

-  if (-1 < iStack0000000000000044) {

-    if (in_stack_00000058 == 0) {

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

-        iVar4 = -0x3ffffff3;

-        iStack0000000000000044 = -0x3ffffff3;

+  local_28[0] = 0;

+  local_res18[0] = 0;

+  local_res20[0] = 0;

+  uVar4 = PsReferenceEffectiveToken

+                    (SystemReserved1[0xf],0x6d6f7441,local_res18,local_res8,local_res20,0);

+  if ((local_res18[0] == 2) && (local_res20[0] < 2)) {

+    uVar6 = PsReferencePrimaryTokenWithTag

+                      (*(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8),0x6d6f7441);

+    SeQueryInformationToken(uVar6,0x1d,local_28);

+    if (local_28[0] == 1) {

+      if (uVar4 != 0) {

+        ObfDereferenceObjectWithTag(uVar4,0x6d6f7441);

+        uVar4 = FUN_1406e5f9a();

+        return uVar4;

       }

-      else {

-        iVar4 = -0x3fffffe9;

-        iStack0000000000000044 = -0x3fffffe9;

-        lVar3 = RtlpAllocateAtomTableEntry(in_stack_00000048,&stack0x00000050,unaff_EBX);

-        in_stack_00000058 = lVar3;

-        if (lVar3 != 0) {

-          RtlCopyMemory((void *)(lVar3 + 0x2a),unaff_R12,(ulonglong)in_stack_00000048);

-          *(char *)(lVar3 + 0x28) = (char)(in_stack_00000048 >> 1);

-          *(undefined2 *)(lVar3 + 0x2a + ((ulonglong)(in_stack_00000048 >> 1) & 0xff) * 2) = 0;

-          cVar2 = RtlpInsertStringAtom();

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

-            if ((in_stack_00000050 != 0) && (in_stack_00000050 != lVar3 + 0x10)) {

-              RtlpFreeAtom();

-            }

-            RtlpFreeAtom(lVar3);

-          }

-          else {

-            *(ushort *)(lVar3 + 10) = *(ushort *)(lVar3 + 8) | 0xc000;

-            *plVar1 = lVar3;

-            if (unaff_R14 != (undefined2 *)0x0) {

-              *unaff_R14 = *(undefined2 *)(lVar3 + 10);

-            }

-            iVar4 = 0;

-            iStack0000000000000044 = 0;

-          }

-        }

-      }

+      local_res18[0] = 1;

+      uVar4 = uVar6;

     }

     else {

-      if ((in_stack_00000050 != in_stack_00000058 + 0x10) &&

-         (*(short *)(in_stack_00000050 + 0x14) == (short)unaff_ESI)) {

-        if (*(short *)(in_stack_00000058 + 0x24) == -1) {

-          *(ushort *)(in_stack_00000058 + 0x26) = *(ushort *)(in_stack_00000058 + 0x26) | 1;

-        }

-        else {

-          *(short *)(in_stack_00000058 + 0x24) = *(short *)(in_stack_00000058 + 0x24) + 1;

-        }

-      }

-      if (*(short *)(in_stack_00000050 + 0x14) == -1) {

-        *(ushort *)(in_stack_00000050 + 0x16) = *(ushort *)(in_stack_00000050 + 0x16) | 1;

-      }

-      else {

-        *(short *)(in_stack_00000050 + 0x14) = *(short *)(in_stack_00000050 + 0x14) + 1;

-      }

-      iStack0000000000000044 = unaff_ESI;

-      iVar4 = unaff_ESI;

-      if (unaff_R14 != (undefined2 *)0x0) {

-        *unaff_R14 = *(undefined2 *)(in_stack_00000058 + 10);

-      }

+      ObfDereferenceObjectWithTag(uVar6,0x6d6f7441);

     }

   }

-  RtlpUnlockAtomTable();

-  return iVar4;

+  iVar3 = local_res18[0];

+  local_res10[0] = 0;

+  SeQueryInformationToken(uVar4,0x20,local_res10);

+  if (iVar3 == 1) {

+    lVar2 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+    uVar6 = *(ulonglong *)(lVar2 + 0x248);

+    do {

+      if (0xe < (uVar6 ^ uVar4)) goto LAB_0;

+      puVar1 = (ulonglong *)(lVar2 + 0x248);

+      LOCK();

+      uVar5 = *puVar1;

+      bVar7 = uVar6 == uVar5;

+      if (bVar7) {

+        *puVar1 = uVar6 + 1;

+        uVar5 = uVar6;

+      }

+      UNLOCK();

+      uVar6 = uVar5;

+    } while (!bVar7);

+    if (ObpTraceFlags != 0) {

+      ObpPushStackInfo(uVar4 - 0x30,0,1,0x6d6f7441);

+    }

+  }

+  else if (uVar4 != 0) {

+LAB_0:

+    ObfDereferenceObjectWithTag(uVar4,0x6d6f7441);

+  }

+  return (ulonglong)local_res10[0];

 }
```

## `CmFcpPopulateModuleFeatures`  (modified)

```diff
--- CmFcpPopulateModuleFeatures
+++ CmFcpPopulateModuleFeatures
@@ -1,11 +1,45 @@
 

-void CmFcpPopulateModuleFeatures(void)

+void CmFcpPopulateModuleFeatures

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

 

 {

-  code *pcVar1;

+  uint *puVar1;

+  char cVar2;

+  uint uVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  undefined8 *puVar6;

   

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

-  (*pcVar1)();

+  uVar4 = 0;

+  puVar6 = param_1 + 7;

+  while ((puVar6 <= param_2 && (uVar4 < param_4))) {

+    cVar2 = CmFcpIsValidMemoryRange(param_1,0x38);

+    if ((cVar2 == '\0') || (puVar1 = (uint *)*param_1, puVar1 == (uint *)0x0)) {

+      param_1 = param_1 + 1;

+      puVar6 = puVar6 + 1;

+    }

+    else {

+      uVar5 = (ulonglong)uVar4;

+      *(undefined8 *)(param_3 + 8 + uVar5 * 0x10) = 0;

+      *(undefined4 *)(param_3 + uVar5 * 0x10) = *(undefined4 *)(param_1 + 3);

+      cVar2 = CmFcpIsValidMemoryRange(puVar1,8);

+      uVar3 = *(uint *)(param_3 + 8 + uVar5 * 0x10);

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

+        *(uint *)(param_3 + 8 + uVar5 * 0x10) = uVar3 | 0x100;

+      }

+      else {

+        uVar3 = (*puVar1 >> 0x11 ^ uVar3) & 2 ^ uVar3;

+        *(uint *)(param_3 + 8 + uVar5 * 0x10) = uVar3;

+        uVar3 = (uVar3 ^ *puVar1) & 1 ^ uVar3;

+        *(uint *)(param_3 + 8 + uVar5 * 0x10) = uVar3;

+        *(uint *)(param_3 + 8 + uVar5 * 0x10) = (*puVar1 >> 10 ^ uVar3) & 0xfc ^ uVar3;

+        *(uint *)(param_3 + 0xc + uVar5 * 0x10) = puVar1[1];

+      }

+      uVar4 = uVar4 + 1;

+      param_1 = param_1 + 7;

+      puVar6 = puVar6 + 7;

+    }

+  }

   return;

 }
```

## `RtlpAllocateHeap`  (modified)

```diff
--- RtlpAllocateHeap
+++ RtlpAllocateHeap
@@ -1,10 +1,365 @@
 

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

-

-void RtlpAllocateHeap(void)

+longlong *

+RtlpAllocateHeap(longlong param_1,uint param_2,ulonglong param_3,ulonglong param_4,

+                undefined8 param_5,undefined4 *param_6)

 

 {

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

-  halt_baddata();

+  byte bVar1;

+  longlong *plVar2;

+  bool bVar3;

+  char cVar4;

+  uint uVar5;

+  int iVar6;

+  longlong *plVar7;

+  longlong *plVar8;

+  ulonglong uVar9;

+  longlong *plVar10;

+  ulonglong uVar11;

+  longlong *plVar12;

+  byte bVar13;

+  ulonglong uVar14;

+  longlong lVar15;

+  ulonglong uVar16;

+  bool bVar17;

+  bool bVar18;

+  ulonglong local_res20;

+  longlong *in_stack_fffffffffffffef8;

+  longlong local_80;

+  longlong *local_78;

+  longlong *local_70;

+  longlong *local_68;

+  longlong local_60;

+  longlong *local_58;

+  longlong local_50;

+  longlong *local_48;

+  ulonglong local_40;

+  

+  local_68 = (longlong *)0x0;

+  bVar18 = true;

+  local_78 = (longlong *)0x0;

+  local_60 = 0;

+  local_70 = (longlong *)0x0;

+  local_48 = (longlong *)0x0;

+  local_80 = 0;

+  local_50 = 0;

+  if (((param_2 & 0x3c010f60) == 0) && (param_3 < 0x80000000)) {

+    bVar13 = 1;

+    uVar16 = param_4 >> 4;

+    if (uVar16 < 2) {

+      param_4 = param_4 + 0x10;

+      uVar16 = 2;

+    }

+    *param_6 = 3;

+    local_res20 = param_4;

+  }

+  else {

+    bVar18 = false;

+    *param_6 = 4;

+    if (0x7fffffffffffffff < param_3) {

+      return (longlong *)0x0;

+    }

+    uVar16 = param_3;

+    if (param_3 == 0) {

+      uVar16 = 1;

+    }

+    local_res20 = uVar16 + *(longlong *)(param_1 + 0x100) & *(ulonglong *)(param_1 + 0x108);

+    if (local_res20 < 0x20) {

+      local_res20 = 0x20;

+    }

+    bVar1 = (byte)(param_2 >> 4) & 0xe1;

+    bVar13 = bVar1 | 1;

+    if (((param_2 & 0x3c000100) != 0) || (*(longlong *)(param_1 + 0x148) != 0)) {

+      bVar13 = bVar1 | 3;

+      local_res20 = local_res20 + 0x10;

+    }

+    uVar16 = local_res20 >> 4;

+  }

+  uVar11 = local_res20;

+  if (((param_2 >> 0x17 & 1) != 0) && (uVar5 = RtlGetNtGlobalFlags(), (uVar5 >> 0xb & 1) == 0)) {

+    bVar13 = bVar13 | 8;

+  }

+  bVar17 = (param_2 & 1) == 0;

+  if (bVar17) {

+    ExAcquireResourceExclusiveLite(*(undefined8 *)(param_1 + 0x160),1);

+  }

+  if (*(uint *)(param_1 + 0x94) < uVar16) {

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

+      local_res20 = uVar11 + 0x38;

+      iVar6 = RtlpHpHeapCheckCommitLimit

+                        (uVar11 + 0x1037 & 0xfffffffffffff000,

+                         *(longlong *)(param_1 + 0x240) - *(longlong *)(param_1 + 0x2a0),param_1,

+                         param_1 + 0x178);

+      uVar16 = DAT_0;

+      if (iVar6 != 0) {

+        do {

+          uVar14 = uVar16 >> 0xc ^ uVar16;

+          uVar14 = uVar14 << 0x19 ^ uVar14;

+          uVar14 = uVar14 >> 0x1b ^ uVar14;

+          LOCK();

+          bVar18 = uVar16 != DAT_0;

+          uVar11 = uVar14;

+          if (bVar18) {

+            uVar16 = DAT_0;

+            uVar11 = DAT_0;

+          }

+          DAT_0 = uVar11;

+          UNLOCK();

+        } while (bVar18);

+        local_50 = (ulonglong)((int)uVar14 * -3 & 0xf) << 0xc;

+        plVar7 = (longlong *)RtlpHpAllocVirtBlockCommitFirst(uVar14,&local_res20,local_50,&local_80)

+        ;

+        local_48 = plVar7;

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

+          *(int *)(param_1 + 0x280) = *(int *)(param_1 + 0x280) + 1;

+          plVar7 = (longlong *)0x0;

+        }

+        else {

+          *(short *)(plVar7 + 7) = (short)local_res20 - (short)param_3;

+          *(byte *)((longlong)plVar7 + 0x3a) = bVar13 | 2;

+          plVar7[4] = local_res20;

+          plVar7[5] = local_80;

+          *(undefined1 *)((longlong)plVar7 + 0x3f) = 4;

+          *(ulonglong *)(param_1 + 600) = local_res20 + *(longlong *)(param_1 + 600);

+          *(longlong *)(param_1 + 0x250) = *(longlong *)(param_1 + 0x250) + local_80;

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

+            *(byte *)((longlong)plVar7 + 0x3b) =

+                 *(byte *)((longlong)plVar7 + 0x3a) ^ *(byte *)((longlong)plVar7 + 0x39) ^

+                 *(byte *)(plVar7 + 7);

+            *(uint *)(plVar7 + 7) = *(uint *)(plVar7 + 7) ^ *(uint *)(param_1 + 0x88);

+          }

+          lVar15 = param_1 + 0x110;

+          plVar8 = *(longlong **)(param_1 + 0x118);

+          if (*plVar8 == lVar15) {

+            *plVar7 = lVar15;

+            plVar7[1] = (longlong)plVar8;

+            *plVar8 = (longlong)plVar7;

+            *(longlong **)(param_1 + 0x118) = plVar7;

+          }

+          else {

+            RtlpLogHeapFailure(0xd,0,lVar15,0,*plVar8,0);

+          }

+          plVar7 = plVar7 + 8;

+        }

+        goto LAB_1;

+      }

+    }

+LAB_2:

+    plVar7 = (longlong *)0x0;

+    goto LAB_1;

+  }

+  local_78 = (longlong *)(param_1 + 0x150);

+  plVar7 = (longlong *)RtlpFindEntry(param_1,uVar16);

+  local_70 = plVar7;

+  if ((longlong *)(param_1 + 0x150) == plVar7) {

+LAB_3:

+    plVar8 = (longlong *)RtlpExtendHeap(param_1,uVar11);

+    if (plVar8 == (longlong *)0x0) goto LAB_2;

+    plVar7 = plVar8 + 2;

+    lVar15 = *plVar7;

+    plVar2 = (longlong *)plVar8[3];

+    plVar10 = (longlong *)*plVar2;

+    if ((plVar10 != *(longlong **)(lVar15 + 8)) || (plVar10 != plVar7)) {

+      RtlpLogHeapFailure(0xd,param_1,plVar7,*(longlong **)(lVar15 + 8),plVar10,0);

+      goto LAB_4;

+    }

+    *(ulonglong *)(param_1 + 0xc0) =

+         *(longlong *)(param_1 + 0xc0) - (ulonglong)*(ushort *)(plVar8 + 1);

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

+      uVar5 = (uint)*(ushort *)(plVar8 + 1);

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

+      do {

+        plVar12 = plVar10;

+        if (uVar5 < *(uint *)(plVar12 + 1)) goto LAB_5;

+        plVar10 = (longlong *)*plVar12;

+      } while ((longlong *)*plVar12 != (longlong *)0x0);

+      uVar5 = *(uint *)(plVar12 + 1) - 1;

+LAB_5:

+      in_stack_fffffffffffffef8 =

+           (longlong *)CONCAT44((int)((ulonglong)in_stack_fffffffffffffef8 >> 0x20),uVar5);

+      RtlpHeapRemoveListEntry

+                (param_1,plVar12,plVar7,plVar7,in_stack_fffffffffffffef8,(short)plVar8[1]);

+    }

+    *plVar2 = lVar15;

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

+LAB_6:

+    bVar3 = true;

+    plVar10 = in_stack_fffffffffffffef8;

+  }

+  else {

+    plVar8 = plVar7 + -2;

+    if ((*(int *)(param_1 + 0x7c) != 0) &&

+       (*(uint *)(plVar7 + -1) = *(uint *)(plVar7 + -1) ^ *(uint *)(param_1 + 0x88),

+       *(byte *)((longlong)plVar7 + -5) !=

+       (byte)(*(byte *)((longlong)plVar7 + -6) ^ *(byte *)((longlong)plVar7 + -7) ^

+             *(byte *)(plVar7 + -1)))) {

+      RtlpAnalyzeHeapFailure(param_1,plVar8);

+    }

+    if (*(ushort *)(plVar7 + -1) < uVar16) {

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

+        *(byte *)((longlong)plVar7 + -5) =

+             *(byte *)((longlong)plVar7 + -6) ^ *(byte *)((longlong)plVar7 + -7) ^

+             *(byte *)(plVar7 + -1);

+        *(uint *)(plVar7 + -1) = *(uint *)(plVar7 + -1) ^ *(uint *)(param_1 + 0x88);

+      }

+      goto LAB_3;

+    }

+    lVar15 = *plVar7;

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

+    plVar10 = (longlong *)*plVar2;

+    if ((plVar10 == *(longlong **)(lVar15 + 8)) && (plVar10 == plVar7)) {

+      *(ulonglong *)(param_1 + 0xc0) =

+           *(longlong *)(param_1 + 0xc0) - (ulonglong)*(ushort *)(plVar7 + -1);

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

+        uVar5 = (uint)*(ushort *)(plVar7 + -1);

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

+        do {

+          plVar12 = plVar10;

+          if (uVar5 < *(uint *)(plVar12 + 1)) goto LAB_7;

+          plVar10 = (longlong *)*plVar12;

+        } while ((longlong *)*plVar12 != (longlong *)0x0);

+        uVar5 = *(uint *)(plVar12 + 1) - 1;

+LAB_7:

+        in_stack_fffffffffffffef8 =

+             (longlong *)CONCAT44((int)((ulonglong)in_stack_fffffffffffffef8 >> 0x20),uVar5);

+        RtlpHeapRemoveListEntry

+                  (param_1,plVar12,plVar2,plVar7,in_stack_fffffffffffffef8,(short)plVar7[-1]);

+      }

+      *plVar2 = lVar15;

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

+      goto LAB_6;

+    }

+    RtlpLogHeapFailure(0xd,param_1,plVar7,*(longlong **)(lVar15 + 8),plVar10,0);

+LAB_4:

+    bVar3 = false;

+  }

+  plVar7 = (longlong *)0x0;

+  if (!bVar3) goto LAB_1;

+  bVar1 = *(byte *)((longlong)plVar8 + 10);

+  if ((!bVar18) && ((bVar1 & 4) != 0)) {

+    uVar14 = (ulonglong)*(ushort *)(plVar8 + 1) * 0x10 - 0x20;

+    if (((bVar1 & 2) != 0) && (4 < uVar14)) {

+      uVar14 = (ulonglong)*(ushort *)(plVar8 + 1) * 0x10 - 0x24;

+    }

+    uVar9 = RtlCompareMemoryUlong(plVar8 + 4,uVar14,0xfeeefeee);

+    if (uVar9 != uVar14) {

+                    /* WARNING: Subroutine does not return */

+      DbgPrint("HEAP: Free Heap block %p modified at %p after it was freed\n",plVar8,

+               uVar9 + 0x20 + (longlong)plVar8);

+    }

+  }

+  plVar7 = (longlong *)0x0;

+  local_68 = plVar8;

+  if ((*(byte *)((longlong)plVar8 + 10) & 1) != 0) {

+    RtlpLogHeapFailure(3,param_1,plVar8,0,0,0);

+    goto LAB_1;

+  }

+  *(byte *)((longlong)plVar8 + 10) = bVar13;

+  local_60 = *(ushort *)(plVar8 + 1) - uVar16;

+  *(short *)(plVar8 + 1) = (short)uVar16;

+  uVar14 = uVar11 - param_3;

+  if (uVar14 < 0x3f) {

+    *(char *)((longlong)plVar8 + 0xf) = (char)uVar14;

+  }

+  else {

+    plVar8[uVar16 * 2] = uVar14;

+    *(undefined1 *)((longlong)plVar8 + 0xf) = 0x3f;

+  }

+  *(undefined1 *)((longlong)plVar8 + 0xb) = 0;

+  if (local_60 != 0) {

+    if (local_60 == 1) {

+      *(short *)(plVar8 + 1) = (short)plVar8[1] + 1;

+      local_40 = (uVar11 - param_3) + 0x10;

+      if (local_40 < 0x3f) {

+        *(char *)((longlong)plVar8 + 0xf) = (char)local_40;

+      }

+      else {

+        plVar8[uVar16 * 2 + 2] = local_40;

+        *(undefined1 *)((longlong)plVar8 + 0xf) = 0x3f;

+      }

+    }

+    else {

+      lVar15 = param_1;

+      if (*(byte *)((longlong)plVar8 + 0xe) != 0) {

+        lVar15 = (1 - (ulonglong)*(byte *)((longlong)plVar8 + 0xe)) * 0x10000 +

+                 ((ulonglong)plVar8 & 0xffffffffffff0000);

+      }

+      cVar4 = RtlpCreateSplitBlock

+                        (param_1,lVar15,plVar8 + uVar16 * 2,

+                         CONCAT71((int7)((ulonglong)local_60 >> 8),bVar1),

+                         CONCAT71((int7)((ulonglong)plVar10 >> 8),bVar18) ^ 1,uVar16 & 0xffff,

+                         local_60);

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

+    }

+  }

+  plVar7 = plVar8 + 2;

+  lVar15 = (ulonglong)*(ushort *)(plVar8 + 1) * 0x10;

+  if ((*(byte *)((longlong)plVar8 + 0xf) & 0x3f) == 0x3f) {

+    lVar15 = lVar15 + -8;

+  }

+  if (bVar18) {

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

+      *(byte *)((longlong)plVar8 + 0xb) =

+           *(byte *)((longlong)plVar8 + 10) ^ *(byte *)((longlong)plVar8 + 9) ^

+           *(byte *)(plVar8 + 1);

+      *(uint *)(plVar8 + 1) = *(uint *)(plVar8 + 1) ^ *(uint *)(param_1 + 0x88);

+    }

+    if (bVar17) {

+      ExReleaseResourceLite(*(undefined8 *)(param_1 + 0x160));

+    }

+    bVar17 = false;

+    if ((param_2 & 8) != 0) {

+      memset(plVar7,0,lVar15 - 8);

+    }

+    goto LAB_1;

+  }

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

+    if (((*(uint *)(param_1 + 0x70) & 0x40) != 0) &&

+       (uVar16 = param_3 >> 2, local_58 = plVar7, uVar16 != 0)) {

+      if (((ulonglong)plVar7 & 4) != 0) {

+        *(undefined4 *)plVar7 = 0xbaadf00d;

+        uVar16 = uVar16 - 1;

+        if (uVar16 == 0) goto LAB_8;

+        local_58 = (longlong *)((longlong)plVar8 + 0x14);

+      }

+      plVar10 = local_58;

+      for (uVar11 = uVar16 >> 1; uVar11 != 0; uVar11 = uVar11 - 1) {

+        *plVar10 = -0x45520ff245520ff3;

+        plVar10 = plVar10 + 1;

+      }

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

+        *(undefined4 *)((longlong)local_58 + uVar16 * 4 + -4) = 0xbaadf00d;

+      }

+    }

+  }

+  else {

+    memset(plVar7,0,lVar15 - 8);

+  }

+LAB_8:

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

+    *(undefined8 *)((longlong)plVar7 + param_3) = 0xabababababababab;

+    ((undefined8 *)((longlong)plVar7 + param_3))[1] = 0xabababababababab;

+    *(byte *)((longlong)plVar8 + 10) = *(byte *)((longlong)plVar8 + 10) | 4;

+  }

+  *(undefined1 *)((longlong)plVar8 + 0xb) = 0;

+  if ((*(byte *)((longlong)plVar8 + 10) & 2) != 0) {

+    if (*(char *)((longlong)plVar8 + 0xf) == '\x04') {

+      plVar10 = plVar8 + -4;

+    }

+    else {

+      plVar10 = plVar8 + (ulonglong)*(ushort *)(plVar8 + 1) * 2 + -2;

+    }

+    *plVar10 = 0;

+    plVar10[1] = 0;

+  }

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

+    *(byte *)((longlong)plVar8 + 0xb) =

+         *(byte *)((longlong)plVar8 + 10) ^ *(byte *)((longlong)plVar8 + 9) ^ *(byte *)(plVar8 + 1);

+    *(uint *)(plVar8 + 1) = *(uint *)(plVar8 + 1) ^ *(uint *)(param_1 + 0x88);

+  }

+LAB_1:

+  if (bVar17) {

+    ExReleaseResourceLite(*(undefined8 *)(param_1 + 0x160));

+  }

+  return plVar7;

 }
```

## `FsRtlpCancelOplockRHIrp`  (modified)

```diff
--- FsRtlpCancelOplockRHIrp
+++ FsRtlpCancelOplockRHIrp
@@ -1,10 +1,124 @@
 

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

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

 

-void FsRtlpCancelOplockRHIrp(void)

+void FsRtlpCancelOplockRHIrp(longlong param_1,char param_2,char param_3)

 

 {

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

-  halt_baddata();

+  undefined8 *puVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  undefined8 *puVar4;

+  char cVar5;

+  undefined1 auStack_168 [32];

+  undefined4 local_148;

+  undefined1 *local_140;

+  undefined2 local_138;

+  undefined1 local_130;

+  char local_128;

+  char local_127 [3];

+  undefined4 local_124;

+  undefined4 local_120 [2];

+  longlong local_118;

+  undefined8 *local_110;

+  longlong local_108;

+  longlong local_100;

+  undefined1 local_f8 [32];

+  char *local_d8;

+  undefined8 local_d0;

+  char *local_c8;

+  undefined8 local_c0;

+  longlong *local_b8;

+  undefined8 local_b0;

+  undefined4 *local_a8;

+  undefined8 local_a0;

+  undefined1 local_98 [32];

+  char *local_78;

+  undefined8 local_70;

+  longlong *local_68;

+  undefined8 local_60;

+  undefined4 *local_58;

+  undefined8 local_50;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_168;

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

+  LOCK();

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

+  UNLOCK();

+  local_108 = lVar2;

+  KeReleaseQueuedSpinLock(7,*(undefined1 *)(param_1 + 0x45));

+  if (5 < DAT_0) {

+    local_78 = local_127 + 2;

+    local_70 = 1;

+    local_68 = &local_100;

+    local_60 = 8;

+    local_120[0] = *(undefined4 *)(lVar2 + 0x90);

+    local_58 = local_120;

+    local_50 = 4;

+    local_140 = local_98;

+    local_148 = 5;

+    local_127[2] = param_3;

+    local_100 = lVar2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043b8e,0,0);

+  }

+  cVar5 = '\0';

+  local_127[1] = 0;

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

+    ExAcquireFastMutex(*(undefined8 *)(lVar2 + 0x98));

+  }

+  puVar1 = (undefined8 *)(lVar2 + 0x38);

+  local_110 = (undefined8 *)*puVar1;

+  while (local_110 != puVar1) {

+    puVar4 = local_110;

+    if ((local_110[7] == 0) && (*(char *)(local_110[2] + 0x44) != '\0')) {

+      puVar4 = (undefined8 *)local_110[1];

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

+        local_110[0xb] = 0;

+        local_110 = puVar4;

+      }

+      else {

+        puVar3 = local_110 + 9;

+        local_110 = puVar4;

+        FsRtlpOplockPerfSendData(puVar3);

+      }

+      local_130 = 0;

+      local_138 = 0;

+      local_140 = (undefined1 *)((ulonglong)local_140 & 0xffffffff00000000);

+      local_148 = 0;

+      FsRtlpRemoveAndCompleteRHIrp(*puVar4,lVar2);

+      cVar5 = '\x01';

+      local_127[1] = 1;

+    }

+    local_110 = (undefined8 *)*puVar4;

+  }

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

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

+      FsRtlpReleaseIrpsWaitingForRH(lVar2);

+    }

+    if ((undefined8 *)*puVar1 == puVar1) {

+      FsRtlpComputeShareableOplockState(lVar2);

+    }

+  }

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

+    ExReleaseFastMutex(*(undefined8 *)(lVar2 + 0x98));

+  }

+  if (5 < DAT_0) {

+    local_d8 = &local_128;

+    local_d0 = 1;

+    local_c8 = local_127;

+    local_c0 = 1;

+    local_b8 = &local_118;

+    local_b0 = 8;

+    local_124 = *(undefined4 *)(lVar2 + 0x90);

+    local_a8 = &local_124;

+    local_a0 = 4;

+    local_140 = local_f8;

+    local_148 = 6;

+    local_128 = param_3;

+    local_127[0] = cVar5;

+    local_118 = lVar2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043c72,0,0);

+  }

+  return;

 }
```

## `FsRtlpGrantAnyOplockFromExclusive`  (modified)

```diff
--- FsRtlpGrantAnyOplockFromExclusive
+++ FsRtlpGrantAnyOplockFromExclusive
@@ -1,11 +1,190 @@
 

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

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

 

-void FsRtlpGrantAnyOplockFromExclusive(longlong param_1)

+undefined4

+FsRtlpGrantAnyOplockFromExclusive

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

+          char param_6,longlong *param_7,undefined1 *param_8,undefined1 *param_9,undefined4 param_10

+          )

 

 {

-  *(char *)(param_1 + -0x75) = *(char *)(param_1 + -0x75) + (char)param_1;

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

-  halt_baddata();

+  byte *pbVar1;

+  uint uVar2;

+  undefined8 *puVar3;

+  undefined8 uVar4;

+  code *pcVar5;

+  void *pvVar6;

+  undefined1 uVar7;

+  undefined4 uVar8;

+  longlong *plVar9;

+  longlong *plVar10;

+  longlong lVar11;

+  undefined1 *puVar12;

+  undefined1 *puVar13;

+  undefined1 auStack_f8 [8];

+  undefined1 auStack_f0 [56];

+  longlong *local_b8;

+  undefined4 local_b0 [2];

+  undefined8 local_a8;

+  longlong *local_a0;

+  undefined1 local_98 [32];

+  undefined8 *local_78;

+  undefined4 local_70;

+  undefined4 local_6c;

+  longlong **local_68;

+  undefined4 local_60;

+  undefined4 local_5c;

+  undefined4 *local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  ulonglong local_48;

+  

+  puVar13 = auStack_f8;

+  puVar12 = auStack_f8;

+  local_48 = __security_cookie ^ (ulonglong)auStack_f8;

+  local_b8 = param_1;

+  if ((*(char *)(*(longlong *)(param_3 + 0x30) + 0x49) != '\0') && ((param_4 >> 0xd & 1) != 0)) {

+    puVar3 = *(undefined8 **)(param_2 + 0x18);

+    *puVar3 = 0;

+    puVar3[1] = 0;

+    puVar3[2] = 0;

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

+    *(uint *)((longlong)puVar3 + 0xc) = *(uint *)((longlong)puVar3 + 0xc) | 1;

+    *(uint *)(puVar3 + 1) = param_4 >> 0xc & 5;

+    *(uint *)((longlong)puVar3 + 4) = uVar2 >> 0xc & 7;

+    *(undefined8 *)(param_2 + 0x38) = 0x18;

+    *(undefined4 *)(param_2 + 0x30) = 0x8000002e;

+    IofCompleteRequest(param_2,CONCAT71((int7)((ulonglong)puVar3 >> 8),1));

+    uVar8 = 0x8000002e;

+    puVar13 = auStack_f8;

+    goto LAB_0;

+  }

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

+    *param_8 = 1;

+    if (param_4 == 0) {

+      *param_9 = 1;

+      goto LAB_1;

+    }

+    puVar13 = auStack_f8;

+    if (((param_4 & 0x3010) == 0) || (puVar13 = auStack_f8, (param_4 & 0x4040) != 0))

+    goto LAB_2;

+    param_1[1] = 0;

+    puVar13 = auStack_f8;

+LAB_3:

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

+      *(undefined8 *)(puVar13 + -8) = 0x14057ddf6;

+      FsRtlpSyncWithAckTimeout(local_b8 + 0x16);

+      *(undefined8 *)(puVar13 + -8) = 0x14057de06;

+      FsRtlpOplockPerfSendData(local_b8 + 0x14);

+    }

+    else {

+      lVar11 = *param_5;

+      *(undefined8 *)(puVar13 + -8) = 0x14057ddd1;

+      FsRtlpOplockPerfMoveData(local_b8 + 0x14,lVar11 + 0x48);

+      lVar11 = *param_5;

+      *(undefined8 *)(puVar13 + -8) = 0x14057dde8;

+      FsRtlpOplockMoveAckTimeout(local_b8 + 0x16,lVar11 + 0x58);

+    }

+    *(undefined4 *)(puVar13 + 0x38) = param_10;

+    puVar13[0x30] = 1;

+    puVar13[0x28] = param_6;

+    *(longlong **)(puVar13 + 0x20) = param_5;

+    *(undefined8 *)(puVar13 + -8) = 0x14057de31;

+    uVar8 = FsRtlpRequestShareableOplock(&local_b8,param_3,param_2,param_4);

+  }

+  else {

+    *(longlong *)(*param_7 + 0x10) = param_1[1];

+    FsRtlpOplockPerfMoveData(param_1 + 0x14,*param_7 + 0x18);

+    FsRtlpOplockMoveAckTimeout(local_b8 + 0x16,*param_7 + 0x28);

+    plVar10 = (longlong *)*param_7;

+    plVar9 = local_b8 + 0xd;

+    lVar11 = *plVar9;

+    if (*(longlong **)(lVar11 + 8) != plVar9) {

+      plVar10 = (longlong *)0x3;

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

+      plVar9 = (longlong *)(*pcVar5)();

+      puVar12 = auStack_f0;

+    }

+    *plVar10 = lVar11;

+    plVar10[1] = (longlong)plVar9;

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

+    *plVar9 = (longlong)plVar10;

+    if (5 < DAT_4) {

+      local_a8 = *(undefined8 *)(*param_7 + 0x10);

+      local_78 = &local_a8;

+      local_6c = 0;

+      local_5c = 0;

+      local_68 = &local_a0;

+      local_a0 = local_b8;

+      local_70 = 8;

+      local_60 = 8;

+      local_b0[0] = (undefined4)local_b8[0x12];

+      local_4c = 0;

+      local_58 = local_b0;

+      *(undefined1 **)(puVar12 + 0x28) = local_98;

+      *(undefined4 *)(puVar12 + 0x20) = 5;

+      local_50 = 4;

+      *(undefined8 *)(puVar12 + -8) = 0x14057dd13;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_4,&DAT_140044ab3,0,0);

+    }

+    *param_7 = 0;

+    local_b8[1] = 0;

+    puVar13 = puVar12;

+LAB_2:

+    if (param_4 == 0) {

+LAB_1:

+      uVar8 = 0;

+      *(uint *)(local_b8 + 0x12) = *(uint *)(local_b8 + 0x12) & 0x20 | 1;

+      *(undefined4 *)(param_2 + 0x30) = 0;

+      *(undefined8 *)(puVar13 + -8) = 0x14057dd58;

+      IofCompleteRequest(param_2,1);

+      *(undefined8 *)(puVar13 + -8) = 0x14057dd68;

+      FsRtlpSyncWithAckTimeout(local_b8 + 0x16);

+      *(undefined8 *)(puVar13 + -8) = 0x14057dd78;

+      FsRtlpOplockPerfSendData(local_b8 + 0x14);

+    }

+    else {

+      if (((param_4 & 0x3010) != 0) && ((param_4 & 0x4040) == 0)) goto LAB_3;

+      *local_b8 = param_2;

+      uVar8 = 0x103;

+      pbVar1 = (byte *)(*(longlong *)(param_2 + 0xb8) + 3);

+      *pbVar1 = *pbVar1 | 1;

+      *(longlong **)(param_2 + 0x38) = local_b8;

+      local_b8[2] = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+      pvVar6 = SystemReserved1[0xf];

+      local_b8[3] = (longlong)SystemReserved1[0xf];

+      *(undefined8 *)(puVar13 + -8) = 0x14057de8c;

+      ObfReferenceObjectWithTag(pvVar6,0x746c6644);

+      *(undefined1 *)(local_b8 + 4) = 0;

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

+        uVar4 = *(undefined8 *)(param_3 + 0x30);

+        *(undefined8 *)(puVar13 + -8) = 0x14057dea5;

+        ObfReferenceObjectWithTag(uVar4,0x746c6644);

+        local_b8[1] = *(longlong *)(param_3 + 0x30);

+      }

+      *(uint *)(local_b8 + 0x12) = *(uint *)(local_b8 + 0x12) & 0x20 | param_4 | 0x40;

+      *(undefined8 *)(puVar13 + -8) = 0x14057ded7;

+      uVar7 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(param_2 + 0x45) = uVar7;

+      if (*(char *)(param_2 + 0x44) == '\0') {

+        LOCK();

+        *(code **)(param_2 + 0x68) = FsRtlpExclusiveIrpCancelRoutine;

+        UNLOCK();

+        uVar7 = *(undefined1 *)(param_2 + 0x45);

+        *(undefined8 *)(puVar13 + -8) = 0x14057df0b;

+        KeReleaseQueuedSpinLock(7,uVar7);

+      }

+      else {

+        *(undefined8 *)(puVar13 + -8) = 0x14057def1;

+        FsRtlpCancelExclusiveIrp(param_2,1,param_6 == '\0');

+      }

+    }

+  }

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

+    *(uint *)(local_b8 + 0x12) = *(uint *)(local_b8 + 0x12) | 0x1000000;

+  }

+LAB_0:

+  *(undefined8 *)(puVar13 + -8) = 0x14057df2b;

+  return uVar8;

 }
```

## `EtwpCoverageEnsureContext`  (modified)

```diff
--- EtwpCoverageEnsureContext
+++ EtwpCoverageEnsureContext
@@ -1,10 +1,192 @@
 

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

+/* WARNING: Type propagation algorithm not settling */

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

 

-void EtwpCoverageEnsureContext(void)

+int EtwpCoverageEnsureContext(void)

 

 {

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

-  halt_baddata();

+  longlong *plVar1;

+  longlong lVar2;

+  int iVar3;

+  longlong *_Dst;

+  void *_Dst_00;

+  longlong lVar4;

+  byte bVar5;

+  uint uVar6;

+  ulonglong uVar7;

+  undefined4 uVar8;

+  undefined4 local_res8 [2];

+  longlong local_res10 [2];

+  undefined8 local_48;

+  undefined8 local_40;

+  

+  if ((EtwpBootPhase < 2) || (EtwpCoverageEntryCount == 0)) {

+    iVar3 = -0x3fffff45;

+  }

+  else {

+    if (0x7ffff < EtwpCoverageEntryCount) {

+      EtwpCoverageEntryCount = 0x80000;

+    }

+    if (EtwpCoverageEntryCount < 0x41) {

+      EtwpCoverageEntryCount = 0x40;

+    }

+    if ((EtwpCoverageEntryCount & EtwpCoverageEntryCount - 1) != 0) {

+      bVar5 = 0xff;

+      for (; EtwpCoverageEntryCount != 0; EtwpCoverageEntryCount = EtwpCoverageEntryCount >> 1) {

+        bVar5 = bVar5 + 1;

+      }

+      EtwpCoverageEntryCount = 1 << (bVar5 & 0x1f);

+    }

+    if (EtwpCoverageFlushPeriod < 0x3e9) {

+      EtwpCoverageFlushPeriod = 1000;

+    }

+    if (EtwpCoverageResetPeriod < 0x36ee81) {

+      EtwpCoverageResetPeriod = 3600000;

+    }

+    _Dst = (longlong *)ExAllocatePool2(0x100,0x48,0x56777445);

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

+      iVar3 = -0x3fffff66;

+    }

+    else {

+      memset(_Dst,0,0x48);

+      plVar1 = _Dst + 6;

+      _Dst[7] = (longlong)plVar1;

+      *plVar1 = (longlong)plVar1;

+      _Dst_00 = (void *)ExAllocatePool2(0x40,0x1b8,0x56777445);

+      *_Dst = (longlong)_Dst_00;

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

+        iVar3 = -0x3fffff66;

+      }

+      else {

+        memset(_Dst_00,0,0x1b8);

+        lVar2 = *_Dst;

+        *(undefined8 *)(lVar2 + 0x18) = 0;

+        lVar4 = lVar2 + 0x28;

+        *(longlong *)(lVar2 + 0x30) = lVar4;

+        *(longlong *)lVar4 = lVar4;

+        *(code **)(lVar2 + 0x48) = EtwpCoverageHighIrqlCPWorkItemCallback;

+        *(longlong **)(lVar2 + 0x50) = _Dst;

+        *(undefined8 *)(lVar2 + 0x38) = 0;

+        *(uint *)((longlong)_Dst + 0x1c) = EtwpCoverageFlushPeriod;

+        uVar8 = (undefined4)((ulonglong)_DAT_0 * _DAT_fffff78000000320 >> 0x18);

+        *(undefined4 *)(*_Dst + 0x10) = uVar8;

+        *(undefined4 *)(_Dst + 3) = uVar8;

+        KeInitializeTimer2(*_Dst + 0x68,EtwpCoverageResetTimerCallback,*_Dst,8);

+        KeInitializeTimer2(*_Dst + 0xf0,EtwpCoverageFlushTimerCallback,*_Dst,8);

+        lVar4 = *_Dst;

+        *(code **)(lVar4 + 0x1a8) = EtwpCoverageResetWorkItemCallback;

+        *(longlong **)(lVar4 + 0x1b0) = _Dst;

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

+        lVar4 = *_Dst;

+        *(code **)(lVar4 + 0x188) = EtwpCoverageFlushWorkItemCallback;

+        *(longlong **)(lVar4 + 400) = _Dst;

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

+        iVar3 = EtwpCoverageEnsureStringBuffer(_Dst);

+        if (-1 < iVar3) {

+          uVar7 = (ulonglong)EtwpCoverageEntryCount;

+          local_res10[0] = uVar7 << 2;

+          iVar3 = MmCreateSection(_Dst + 1,0xf001f,0,local_res10,4,0x8000000,0,0);

+          if (-1 < iVar3) {

+            plVar1 = _Dst + 2;

+            local_res10[1] = 0;

+            iVar3 = MmMapViewInSessionSpace(_Dst[1],plVar1,local_res10 + 1);

+            if (-1 < iVar3) {

+              uVar6 = (int)(uVar7 << 2) - 0x34;

+              *(undefined1 *)*plVar1 = 2;

+              *(undefined1 *)(*plVar1 + 1) = 1;

+              *(undefined4 *)(*plVar1 + 0x18) = 1;

+              *(undefined4 *)*_Dst = *(undefined4 *)(*plVar1 + 0x18);

+              *(undefined4 *)(MmWriteableSharedUserData + 0x37c) = *(undefined4 *)(*plVar1 + 0x18);

+              *(undefined4 *)(*plVar1 + 0x14) = uVar8;

+              *(undefined4 *)(*_Dst + 0x14) = *(undefined4 *)(*plVar1 + 0x14);

+              *(uint *)(*plVar1 + 8) = EtwpCoverageEntryCount - 1;

+              lVar4 = 2;

+              do {

+                *(uint *)(*plVar1 + 4) = uVar6 >> 2;

+                lVar4 = lVar4 + -1;

+              } while (lVar4 != 0);

+              *(uint *)(_Dst + 4) = (uVar6 >> 4) * 3;

+              *(int *)(*plVar1 + 0x10) = *(int *)(*plVar1 + 4) * 4 + 0x34;

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

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

+              lVar4 = KeAbPreAcquire(&EtwpCoverageLock,0,0);

+              LOCK();

+              uVar7 = EtwpCoverageLock & 1;

+              EtwpCoverageLock = EtwpCoverageLock | 1;

+              UNLOCK();

+              if (uVar7 != 0) {

+                ExfAcquirePushLockExclusiveEx(&EtwpCoverageLock,lVar4,&EtwpCoverageLock);

+              }

+              if (lVar4 != 0) {

+                *(undefined1 *)(lVar4 + 10) = 1;

+              }

+              EtwpCoverageLockOwner = SystemReserved1[0xf];

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

+                EtwpCoverageNonPagedContext = *_Dst;

+                EtwpCoverageContext = _Dst;

+                if (EtwpCoverageCoreTracingEnabled != 0) {

+                  *(ushort *)(_Dst[2] + 2) = *(ushort *)(_Dst[2] + 2) | 1;

+                  *(undefined4 *)(MmWriteableSharedUserData + 0x37c) = 0xffffff00;

+                }

+                local_48 = 0;

+                local_40 = 0xffffffffffffffff;

+                KeSetTimer2(*EtwpCoverageContext + 0x68,(ulonglong)EtwpCoverageResetPeriod * -10000,

+                            (ulonglong)EtwpCoverageResetPeriod * 10000,&local_48);

+                _Dst = (longlong *)0x0;

+              }

+              EtwpCoverageLockOwner = (void *)0x0;

+              LOCK();

+              uVar7 = EtwpCoverageLock - 1;

+              UNLOCK();

+              bVar5 = (byte)EtwpCoverageLock;

+              EtwpCoverageLock = uVar7;

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

+                ExfTryToWakePushLock(&EtwpCoverageLock);

+              }

+              KeAbPostRelease(&EtwpCoverageLock);

+              KeLeaveCriticalRegion();

+              if (DAT_1 < _DAT_fffff7800000037c) {

+                if (DAT_2 == 0) {

+                  local_res8[0] = 0;

+                  DAT_2 =

+                       TelemetryCoverageStringHashInternal

+                                 (PTR_s_ETW_TelCov_Boot_140e091f0,local_res8);

+                }

+                EtwTelemetryCoverageReport(&PTR_s_ETW_TelCov_Boot_140e091f0);

+              }

+              if ((EtwpCoverageCoreTracingEnabled != 0) && (DAT_3 < _DAT_fffff7800000037c))

+              {

+                if (DAT_4 == 0) {

+                  local_res8[0] = 0;

+                  DAT_4 =

+                       TelemetryCoverageStringHashInternal

+                                 (PTR_s_ETW_TelCov_Trace_140e091a0,local_res8);

+                }

+                EtwTelemetryCoverageReport(&PTR_s_ETW_TelCov_Trace_140e091a0);

+              }

+              iVar3 = 0;

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

+                return 0;

+              }

+            }

+          }

+        }

+      }

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

+        MiRemoveFromSystemSpace(_Dst[2],1);

+        _Dst[2] = 0;

+      }

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

+        ObfDereferenceObject();

+        _Dst[1] = 0;

+      }

+      if (*_Dst != 0) {

+        ExFreePoolWithTag(*_Dst,0x56777445);

+      }

+      EtwpCoverageFreeStringBuffers(_Dst,0);

+      ExFreePoolWithTag(_Dst,0x56777445);

+    }

+  }

+  return iVar3;

 }
```

## `KiCopyAffinityEx`  (modified)

```diff
--- KiCopyAffinityEx
+++ PopAcquireRwLockShared
@@ -1,10 +1,38 @@
 

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

+/* WARNING: Instruction at (ram,0x0001403aef3d) overlaps instruction at (ram,0x0001403aef3b)

+    */

 

-void __cdecl KiCopyAffinityEx(_KAFFINITY_EX *param_1,ushort param_2,_KAFFINITY_EX *param_3)

+undefined8 PopAcquireRwLockShared(byte param_1,char param_2)

 

 {

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

-  halt_baddata();

+  byte *pbVar1;

+  longlong in_RAX;

+  undefined8 *puVar2;

+  uint uVar3;

+  longlong unaff_RDI;

+  ulonglong uVar4;

+  

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

+  *pbVar1 = *pbVar1 | param_1;

+  if (*pbVar1 != 0) {

+    *(char *)(unaff_RDI + 0x48) = *(char *)(unaff_RDI + 0x48) + param_2;

+    puVar2 = PpmPerfDomainHead;

+    if (PpmCheckLatencyBoostActive != 0) {

+      for (; (undefined8 **)puVar2 != &PpmPerfDomainHead; puVar2 = (undefined8 *)*puVar2) {

+        uVar4 = 0;

+        if (*(int *)(puVar2 + 0x25) != 0) {

+          do {

+            if (*(longlong *)(uVar4 * 0x4a8 + puVar2[0x27]) != 0) {

+              *(undefined8 *)((ulonglong)((int)&stack0x00000000 - 0x20) - 8) = 0x1403aef76;

+              PpmPerfApplyLatencyHint();

+            }

+            uVar3 = (int)uVar4 + 1;

+            uVar4 = (ulonglong)uVar3;

+          } while (uVar3 < *(uint *)(puVar2 + 0x25));

+        }

+      }

+    }

+  }

+  return 1;

 }
```

## `FsRtlpRequestShareableOplock`  (modified)

```diff
--- FsRtlpRequestShareableOplock
+++ FsRtlpRequestShareableOplock
@@ -1,115 +1,494 @@
 

-int FsRtlpRequestShareableOplock

-              (undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4,

-              undefined8 param_5,undefined4 param_6,undefined8 param_7,undefined1 *param_8)

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

+

+ulonglong FsRtlpRequestShareableOplock

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

+                    undefined8 param_5,undefined8 param_6,char param_7)

 

 {

-  char cVar1;

-  bool bVar2;

-  undefined1 uVar3;

-  undefined1 uVar4;

-  int iVar5;

-  int iVar6;

-  undefined1 *puVar7;

-  longlong lVar8;

-  longlong lVar9;

-  longlong lVar10;

-  undefined8 in_CR8;

-  undefined8 unaff_retaddr;

-  longlong local_70;

-  int local_68;

-  longlong local_60;

-  longlong local_58;

-  byte *local_50;

-  longlong local_48;

+  longlong lVar1;

+  undefined8 uVar2;

+  undefined8 uVar3;

+  code *pcVar4;

+  bool bVar5;

+  undefined1 *puVar6;

+  char cVar7;

+  undefined1 uVar8;

+  int iVar9;

+  uint uVar10;

+  uint uVar11;

+  undefined8 *puVar12;

+  longlong *plVar13;

+  longlong lVar14;

+  longlong *plVar15;

+  undefined8 *puVar16;

+  undefined1 *puVar17;

+  undefined1 *puVar18;

+  undefined8 **ppuVar19;

+  longlong *plVar20;

+  char cVar21;

+  undefined8 *puVar22;

+  undefined8 uStack_1b0;

+  undefined1 auStack_1a8 [8];

+  undefined1 auStack_1a0 [24];

+  longlong alStack_188 [4];

+  undefined4 local_168;

+  char local_164 [4];

+  undefined8 local_160;

+  undefined8 *local_158;

+  uint local_150 [6];

+  undefined8 local_138;

+  undefined8 auStack_130 [9];

+  longlong alStack_e8 [12];

+  longlong alStack_88 [10];

   

-  uVar3 = 0;

-  bVar2 = false;

-  lVar9 = 0;

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

-  local_70 = 0;

-  iVar5 = ObReferenceObjectByHandle(param_1,1,IopWaitCompletionPacketObjectType,cVar1,&local_70,0);

-  lVar8 = local_70;

-  lVar10 = lVar9;

-  if (-1 < iVar5) {

-    local_58 = 0;

-    iVar5 = ObReferenceObjectByHandle(param_2,2,IoCompletionObjectType,cVar1,&local_58,0);

-    lVar9 = local_58;

-    lVar10 = 0;

-    if (-1 < iVar5) {

-      local_60 = 0;

-      iVar5 = ObReferenceObjectByHandle(param_3,0x100000,0,cVar1,&local_60,0);

-      lVar10 = local_60;

-      local_68 = iVar5;

-      if (-1 < iVar5) {

-        local_50 = (byte *)ObGetAssociatedWaitObject(local_60);

-        if ((local_50 == (byte *)0x0) || (((*local_50 & 0x7f) - 2 & 0xfd) == 0)) {

-          iVar5 = -0x3fffff0f;

-        }

-        else {

-          bVar2 = true;

-          local_48 = lVar8 + 0x60;

-          uVar3 = KeAcquireSpinLockRaiseToDpc(local_48);

-          if (*(char *)(lVar8 + 0x68) == '\0') {

-            iVar6 = Feature_1806129466__private_IsEnabledDeviceUsageNoInline();

-            if ((iVar6 == 0) || (*(char *)(local_70 + 0x69) == '\0')) {

-              *(undefined1 *)(local_70 + 0x68) = 1;

-              *(undefined8 *)(local_70 + 0x30) = param_4;

-              *(undefined8 *)(local_70 + 0x38) = param_5;

-              *(undefined4 *)(local_70 + 0x48) = param_6;

-              *(undefined8 *)(local_70 + 0x40) = param_7;

-              *(longlong *)(local_70 + 0x50) = local_60;

-              *(longlong *)(local_70 + 0x58) = local_58;

-              uVar4 = KeRegisterObjectNotification(local_50);

-              KeReleaseSpinLock(local_48,uVar3);

-              bVar2 = false;

-              if (param_8 != (undefined1 *)0x0) {

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

-                  puVar7 = &DAT_0;

-                  if (param_8 < &DAT_0) {

-                    puVar7 = param_8;

-                  }

-                  *puVar7 = *puVar7;

-                }

-                *param_8 = uVar4;

-              }

-              lVar9 = 0;

-              lVar10 = 0;

-              lVar8 = 0;

-            }

-            else {

-              iVar5 = -0x3fff5ffd;

-            }

-          }

-          else {

-            iVar5 = -0x3fffff11;

-          }

-        }

-      }

-    }

-  }

-  if (bVar2) {

-    if (((DAT_1._2_1_ & 1) == 0) || (PopHibernateInProgress != 0)) {

-      LOCK();

-      *(undefined8 *)(lVar8 + 0x60) = 0;

-      UNLOCK();

+  puVar17 = auStack_1a8;

+  puVar18 = auStack_1a8;

+  alStack_88[8] = __security_cookie ^ (ulonglong)auStack_1a8;

+  local_150[4] = param_4;

+  local_160 = param_5;

+  local_168 = 0;

+  local_158 = (undefined8 *)0x0;

+  local_138 = 0;

+  local_164[0] = 0;

+  local_164[1] = 0;

+  puVar12 = (undefined8 *)*param_1;

+  ppuVar19 = param_3;

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

+    puVar12 = (undefined8 *)FsRtlpAllocateOplock();

+    *param_1 = (longlong)puVar12;

+  }

+  if ((param_7 == '\0') && (param_4 != 0x10000)) {

+    local_138 = puVar12[0x13];

+    ExAcquireFastMutexUnsafe(local_138);

+    local_164[0] = 1;

+  }

+  uVar11 = *(uint *)(puVar12 + 0x12);

+  plVar15 = (undefined8 *)0x0;

+  puVar6 = auStack_1a8;

+  if (((uVar11 >> 0x10 & 1) != 0) &&

+     (plVar15 = (undefined8 *)0x0, puVar6 = auStack_1a8, *param_2 == '\r')) {

+    ppuVar19 = &local_158;

+    cVar7 = FsRtlpCallerIsAtomicRequestor(puVar12,*(undefined8 *)(param_2 + 0x30));

+    puVar16 = local_158;

+    puVar6 = auStack_1a8;

+    if (cVar7 == '\0') goto LAB_0;

+    plVar15 = (undefined8 *)0x0;

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

+LAB_1:

+      puVar16 = (undefined8 *)puVar12[0xb];

+      while (puVar16 != puVar12 + 0xb) {

+        if ((*(char *)((longlong)puVar16 + 0x35) == '\0') || (puVar22 = puVar16, param_4 != 0x3000))

+        {

+          puVar22 = (undefined8 *)puVar16[1];

+          *(undefined8 *)(puVar17 + -8) = 0x1404dc5b1;

+          FsRtlpRemoveAndCompleteWaitingIrp(puVar16);

+        }

+        puVar16 = (undefined8 *)*puVar22;

+      }

+      lVar14 = *(longlong *)(puVar17 + 0x50);

+      *(undefined8 *)(puVar17 + -8) = 0x1404dc5c3;

+      FsRtlpOplockDequeueRH(lVar14);

+      plVar20 = (longlong *)(lVar14 + 0x38);

+      lVar1 = *plVar20;

+      plVar13 = *(longlong **)(lVar14 + 0x40);

+      if ((*(longlong **)(lVar1 + 8) == plVar20) && ((longlong *)*plVar13 == plVar20)) {

+        *plVar13 = lVar1;

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

+        if ((longlong *)puVar12[0xf] == puVar12 + 0xf) {

+          *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) & 0xfffcffff;

+        }

+        if (*(longlong *)(lVar14 + 0x28) != 0) {

+          *(undefined8 *)(puVar17 + -8) = 0x1404dc60d;

+          FsRtlpClearOwner(puVar12,lVar14);

+        }

+        *(undefined8 *)(puVar17 + -8) = 0x1404dc617;

+        FsRtlpFreeRHOpContext(lVar14,1);

+        *(undefined8 *)(puVar17 + 0x50) = 0;

+        *(undefined8 *)(puVar17 + -8) = 0x1404dc628;

+        FsRtlpComputeShareableOplockState(puVar12);

+        param_7 = puVar17[0x1e0];

+        puVar6 = puVar17;

+        goto LAB_0;

+      }

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

+      (*pcVar4)(3);

+      puVar18 = puVar17 + 8;

+LAB_2:

+      puVar16 = param_3[3];

+      *(undefined4 *)(puVar16 + 1) = 0;

+      *(uint *)((longlong)puVar16 + 0xc) = *(uint *)((longlong)puVar16 + 0xc) | 4;

+      if (5 < DAT_3) {

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

+        cVar7 = _tlgKeywordOn(&DAT_3,0x400000000000);

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

+          *(undefined8 *)(puVar18 + 0x78) = 1;

+          *(undefined1 **)(puVar18 + 0xc0) = puVar18 + 0x78;

+          *(undefined8 *)(puVar18 + 200) = 8;

+          *(uint *)(puVar18 + 0x58) = param_4;

+          *(undefined1 **)(puVar18 + 0xd0) = puVar18 + 0x58;

+          *(undefined8 *)(puVar18 + 0xd8) = 4;

+          *(undefined4 *)(puVar18 + 0x5c) = *(undefined4 *)(puVar12 + 0x12);

+          *(undefined1 **)(puVar18 + 0xe0) = puVar18 + 0x5c;

+          *(undefined8 *)(puVar18 + 0xe8) = 4;

+          *(undefined8 *)(puVar18 + 0x80) = 0x1000000;

+          *(undefined1 **)(puVar18 + 0xf0) = puVar18 + 0x80;

+          *(undefined8 *)(puVar18 + 0xf8) = 8;

+          *(undefined1 **)(puVar18 + 0x20) = puVar18 + 0xa0;

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

+          _tlgWriteAgg(&DAT_3,&DAT_140045012);

+        }

+      }

     }

     else {

-      KiReleaseSpinLockInstrumented((undefined8 *)(lVar8 + 0x60),unaff_retaddr);

+      FsRtlpOplockDequeueRH(local_158);

+      plVar15 = puVar16 + 7;

+      lVar14 = *plVar15;

+      plVar20 = (longlong *)puVar16[8];

+      if ((*(longlong **)(lVar14 + 8) != plVar15) || ((longlong *)*plVar20 != plVar15)) {

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

+        (*pcVar4)(3);

+        puVar17 = auStack_1a0;

+        plVar15 = puVar16;

+        goto LAB_1;

+      }

+      *plVar20 = lVar14;

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

+      if ((longlong *)puVar12[0xf] == puVar12 + 0xf) {

+        *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) & 0xfffcffff;

+      }

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

+        FsRtlpClearOwner(puVar12,puVar16);

+      }

+      FsRtlpFreeRHOpContext(puVar16,1);

+      local_158 = (undefined8 *)0x0;

+      FsRtlpComputeShareableOplockState(puVar12);

     }

-    if (KiIrqlFlags != 0) {

-      KiLowerIrqlProcessIrqlFlags(in_CR8,uVar3);

+    goto LAB_4;

+  }

+LAB_0:

+  puVar18 = puVar6;

+  bVar5 = false;

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

+  cVar7 = FsRtlpOplockUpperLowerCompatible(param_4,*(undefined4 *)(puVar18 + 0x1e8));

+  if (cVar7 == '\0') goto LAB_4;

+  if ((((param_4 >> 0xc & 1) == 0) && (param_4 != 0x10000)) ||

+     (*(longlong *)(*(longlong *)(param_2 + 0x30) + 0x28) == 0)) {

+LAB_5:

+    if ((param_7 != '\0') || ((*(uint *)(puVar12 + 0x12) & 0x40) == 0)) {

+      if (param_4 == 0x10) {

+        if ((((*(uint *)(puVar12 + 0x12) & 1) == 0) &&

+            (uVar11 = *(uint *)(puVar12 + 0x12) & 0x1f0ffdf, uVar11 != 0x10)) &&

+           ((uVar11 != 0x1000 && (uVar11 != 0x1010)))) goto LAB_4;

+      }

+      else if (param_4 != 0x1000) {

+        if ((param_4 != 0x3000) && (param_4 != 0x10000)) goto LAB_6;

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

+             (((((uVar11 = *(uint *)(puVar12 + 0x12), (uVar11 & 1) == 0 &&

+                 (uVar10 = uVar11 & 0x1f0ffdf, uVar10 != 0x1000)) && (uVar10 != 0x3000)) &&

+               ((uVar10 != 0xb000 && (uVar10 != 0x103000)))) && (uVar10 != 0x803000)))) &&

+            ((uVar11 >> 0x10 & 1) == 0)) ||

+           (*(char *)(*(longlong *)(param_2 + 0x30) + 0x49) != '\0')) goto LAB_7;

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

+          if (((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) == 0x1000) ||

+             ((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) == 0xb000)) {

+            for (puVar16 = (undefined8 *)puVar12[5]; puVar16 != puVar12 + 5;

+                puVar16 = (undefined8 *)*puVar16) {

+              uVar2 = *(undefined8 *)(puVar16[2] + 0x30);

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

+              ppuVar19 = (undefined8 **)0x0;

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

+              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

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

+                if (param_4 == 0x10000) {

+                  plVar15 = (undefined8 *)0xc00000e3;

+                  goto LAB_8;

+                }

+                ppuVar19 = (undefined8 **)0x3000;

+                uVar2 = *(undefined8 *)puVar16[1];

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

+                FsRtlpRemoveAndCompleteReadOnlyIrp(uVar2,0x215,0x3000,puVar12);

+                break;

+              }

+            }

+          }

+          if (((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) - 0x3000 & 0xffff7fff) == 0) {

+            for (puVar16 = (undefined8 *)puVar12[7]; puVar16 != puVar12 + 7;

+                puVar16 = (undefined8 *)*puVar16) {

+              uVar2 = puVar16[3];

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

+              ppuVar19 = (undefined8 **)0x0;

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

+              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

+              if ((cVar7 != '\0') && (puVar16[7] == 0)) {

+                if (param_4 == 0x10000) {

+                  plVar15 = (undefined8 *)0xc00000e3;

+                  goto LAB_8;

+                }

+                puVar16 = (undefined8 *)puVar16[1];

+                puVar18[0x38] = 0;

+                *(undefined2 *)(puVar18 + 0x30) = 0;

+                *(undefined4 *)(puVar18 + 0x28) = 0;

+                *(undefined4 *)(puVar18 + 0x20) = 0;

+                ppuVar19 = (undefined8 **)0x215;

+                uVar2 = *puVar16;

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

+                FsRtlpRemoveAndCompleteRHIrp(uVar2,puVar12,0x215,0x3000);

+                break;

+              }

+            }

+          }

+          plVar15 = (longlong *)puVar12[9];

+          if (plVar15 != puVar12 + 9) {

+            for (; plVar15 != puVar12 + 9; plVar15 = (longlong *)*plVar15) {

+              uVar2 = plVar15[3];

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

+              ppuVar19 = (undefined8 **)0x0;

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

+              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2);

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

+                plVar15 = (undefined8 *)0xc00000e2;

+                if (param_4 != 0x10000) goto LAB_4;

+                goto LAB_8;

+              }

+            }

+          }

+        }

+        plVar20 = *(longlong **)(puVar18 + 0x48);

+        *(undefined8 *)(*plVar20 + 0x20) = *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

+        *(undefined8 *)(*plVar20 + 0x18) = *(undefined8 *)(param_2 + 0x30);

+        lVar14 = *plVar20;

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

+        uVar11 = FsRtlpOplockEnqueueRH(puVar12 + 7,lVar14);

+        plVar15 = (longlong *)(ulonglong)uVar11;

+        *(uint *)(puVar18 + 0x40) = uVar11;

+        if ((int)uVar11 < 0) {

+          if (param_4 != 0x10000) {

+            *(uint *)(param_3 + 6) = uVar11;

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

+            IofCompleteRequest(param_3,1);

+          }

+          goto LAB_9;

+        }

+        bVar5 = false;

+        if (param_4 == 0x10000) {

+          plVar13 = (longlong *)(*plVar20 + 0x38);

+          plVar15 = puVar12 + 0xf;

+          lVar14 = *plVar15;

+          if (*(longlong **)(lVar14 + 8) != plVar15) {

+            plVar15 = (longlong *)0x3;

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

+            plVar13 = (longlong *)(*pcVar4)();

+            puVar18 = puVar18 + 8;

+          }

+          *plVar13 = lVar14;

+          plVar13[1] = (longlong)plVar15;

+          *(longlong **)(lVar14 + 8) = plVar13;

+          *plVar15 = (longlong)plVar13;

+          plVar15 = (undefined8 *)0x0;

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

+LAB_10:

+          cVar21 = puVar18[0x1e0];

+          bVar5 = true;

+        }

+        else {

+          *(void **)(puVar18 + 0x90) = SystemReserved1[0xf];

+          *(void **)(*plVar20 + 0x28) = SystemReserved1[0xf];

+          uVar2 = *(undefined8 *)(*plVar20 + 0x28);

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

+          ObfReferenceObjectWithTag(uVar2,0x746c6644);

+          *(undefined8 ***)(*plVar20 + 0x10) = param_3;

+          *(byte *)((longlong)param_3[0x17] + 3) = *(byte *)((longlong)param_3[0x17] + 3) | 1;

+          plVar15 = (undefined8 *)0x103;

+          *(undefined4 *)(puVar18 + 0x40) = 0x103;

+          *(undefined4 *)(param_3 + 6) = 0;

+          param_3[7] = puVar12;

+          cVar7 = puVar18[0x1d8];

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

+            uVar2 = *(undefined8 *)(**(longlong **)(puVar18 + 0x48) + 0x18);

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

+            ObfReferenceObjectWithTag(uVar2,0x746c6644);

+          }

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

+          uVar8 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)((longlong)param_3 + 0x45) = uVar8;

+          if (*(char *)((longlong)param_3 + 0x44) == '\0') {

+            LOCK();

+            param_3[0xd] = (undefined8 *)FsRtlpOplockRHIrpCancelRoutine;

+            UNLOCK();

+            uVar8 = *(undefined1 *)((longlong)param_3 + 0x45);

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

+            KeReleaseQueuedSpinLock(7,uVar8);

+            plVar15 = (longlong *)(ulonglong)*(uint *)(puVar18 + 0x40);

+            plVar20 = *(longlong **)(puVar18 + 0x48);

+            goto LAB_10;

+          }

+          cVar21 = puVar18[0x1e0];

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

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

+            FsRtlpCancelOplockRHIrp(param_3,1);

+            plVar20 = *(longlong **)(puVar18 + 0x48);

+          }

+          else {

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

+            FsRtlpCancelOplockRHIrp(param_3,1,(ulonglong)ppuVar19 & 0xffffffffffffff00);

+            plVar20 = *(longlong **)(puVar18 + 0x48);

+          }

+        }

+        if (5 < DAT_3) {

+          *(uint *)(puVar18 + 0x60) = param_4;

+          *(undefined1 **)(puVar18 + 0x120) = puVar18 + 0x60;

+          *(undefined8 *)(puVar18 + 0x128) = 4;

+          puVar18[0x45] = cVar21;

+          *(undefined1 **)(puVar18 + 0x130) = puVar18 + 0x45;

+          *(undefined8 *)(puVar18 + 0x138) = 1;

+          *(undefined8 **)(puVar18 + 0x88) = puVar12;

+          *(undefined1 **)(puVar18 + 0x140) = puVar18 + 0x88;

+          *(undefined8 *)(puVar18 + 0x148) = 8;

+          *(undefined4 *)(puVar18 + 0x48) = *(undefined4 *)(puVar12 + 0x12);

+          *(undefined1 **)(puVar18 + 0x150) = puVar18 + 0x48;

+          *(undefined8 *)(puVar18 + 0x158) = 4;

+          *(undefined1 **)(puVar18 + 0x28) = puVar18 + 0x100;

+          *(undefined4 *)(puVar18 + 0x20) = 6;

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

+          _tlgWriteTransfer_EtwWriteTransfer(&DAT_3,&DAT_140044faa,0,0);

+        }

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

+        FsRtlpComputeShareableOplockState(puVar12);

+        if (bVar5) {

+          lVar14 = *plVar20;

+          *(longlong *)(puVar18 + 0x20) = lVar14 + 0x58;

+          uVar2 = *(undefined8 *)(lVar14 + 0x18);

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

+          FsRtlpOplockTryPrepForAckTimeout(puVar12,uVar2,param_3,lVar14 + 0x48);

+        }

+        *plVar20 = 0;

+        if (param_4 == 0x10000) {

+          *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) | 0x10000;

+        }

+        goto LAB_9;

+      }

+      if (param_7 != '\0') goto LAB_11;

+      uVar11 = *(uint *)(puVar12 + 0x12);

+      if ((((((uVar11 & 1) != 0) || (uVar10 = uVar11 & 0x1f0ffdf, uVar10 == 0x10)) ||

+           (uVar10 == 0x1000)) ||

+          (((uVar10 == 0x1010 || (uVar10 == 0x3000)) ||

+           ((uVar10 == 0xb000 || ((uVar10 == 0x103000 || (uVar10 == 0x803000)))))))) ||

+         ((uVar11 >> 0x10 & 1) != 0)) {

+        plVar15 = (longlong *)puVar12[7];

+        if ((plVar15 != puVar12 + 7) || ((longlong *)puVar12[9] != puVar12 + 9)) {

+          for (; plVar15 != puVar12 + 7; plVar15 = (longlong *)*plVar15) {

+            uVar2 = plVar15[3];

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

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

+            cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

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

+          }

+          for (plVar15 = (longlong *)puVar12[9]; plVar15 != puVar12 + 9;

+              plVar15 = (longlong *)*plVar15) {

+            uVar2 = plVar15[3];

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

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

+            cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

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

+          }

+        }

+        uVar11 = *(uint *)(puVar12 + 0x12) & 0x1f0ffdf;

+        if ((((uVar11 != 0x10) && (uVar11 != 0x1000)) && (uVar11 != 0x1010)) && (uVar11 != 0xb000))

+        goto LAB_11;

+        plVar15 = (longlong *)puVar12[5];

+        do {

+          if (plVar15 == puVar12 + 5) {

+LAB_11:

+            *(byte *)((longlong)param_3[0x17] + 3) = *(byte *)((longlong)param_3[0x17] + 3) | 1;

+            *(undefined4 *)(param_3 + 6) = 0;

+            ppuVar19 = param_3 + 0x15;

+            plVar20 = puVar12 + 5;

+            puVar16 = (undefined8 *)*plVar20;

+            if ((longlong *)puVar16[1] == plVar20) goto LAB_12;

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

+            (*pcVar4)(3);

+            puVar18 = puVar18 + 8;

+          }

+          else {

+            plVar20 = (longlong *)(plVar15[2] + 0x30);

+            if ((*(int *)(plVar15[2] + 0x18) == 0x90240) ||

+               (*plVar20 != *(longlong *)(param_2 + 0x30))) {

+              lVar14 = *plVar20;

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

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

+              cVar7 = FsRtlpOplockKeysEqual(uVar2,lVar14,0);

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

+                uVar2 = *(undefined8 *)plVar15[1];

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

+                FsRtlpRemoveAndCompleteReadOnlyIrp(uVar2,0x215,param_4 & 0x7000,puVar12);

+                goto LAB_11;

+              }

+            }

+          }

+          plVar15 = (longlong *)*plVar15;

+        } while( true );

+      }

+      goto LAB_4;

     }

-  }

-  if (lVar9 != 0) {

-    ObfDereferenceObjectWithTag(lVar9,0x746c6644);

-  }

-  if (lVar10 != 0) {

-    ObfDereferenceObjectWithTag(lVar10,0x746c6644);

-  }

-  if (lVar8 != 0) {

-    ObfDereferenceObjectWithTag(lVar8,0x746c6644);

-  }

-  return iVar5;

+LAB_7:

+    if (param_4 != 0x10000) goto LAB_4;

+    plVar15 = (undefined8 *)0xc0000909;

+  }

+  else {

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

+    iVar9 = MmDoesFileHaveUserWritableReferences();

+    if (iVar9 == 0) goto LAB_5;

+    if (param_4 != 0x10000) goto LAB_2;

+    plVar15 = (undefined8 *)0xc00000e2;

+  }

+  goto LAB_8;

+LAB_12:

+  *ppuVar19 = puVar16;

+  param_3[0x16] = plVar20;

+  puVar16[1] = ppuVar19;

+  *plVar20 = (longlong)ppuVar19;

+  param_3[7] = puVar12;

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

+  FsRtlpComputeShareableOplockState(puVar12);

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

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

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

+    ObfReferenceObjectWithTag(uVar2,0x746c6644);

+  }

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

+  uVar8 = KeAcquireQueuedSpinLock(7);

+  *(undefined1 *)((longlong)param_3 + 0x45) = uVar8;

+  if (*(char *)((longlong)param_3 + 0x44) == '\0') {

+    LOCK();

+    param_3[0xd] = (undefined8 *)FsRtlpReadOnlyOplockIrpCancelRoutine;

+    UNLOCK();

+    uVar8 = *(undefined1 *)((longlong)param_3 + 0x45);

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

+    KeReleaseQueuedSpinLock(7,uVar8);

+  }

+  else {

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

+    FsRtlpCancelReadOnlyOplockIrp(param_3,1);

+  }

+  bVar5 = true;

+  plVar15 = (undefined8 *)0x103;

+  *(undefined4 *)(puVar18 + 0x40) = 0x103;

+LAB_6:

+  if (bVar5) goto LAB_9;

+LAB_4:

+  plVar15 = (undefined8 *)0xc00000e2;

+  *(undefined4 *)(param_3 + 6) = 0xc00000e2;

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

+  IofCompleteRequest(param_3,1);

+LAB_8:

+  *(int *)(puVar18 + 0x40) = (int)plVar15;

+LAB_9:

+  if ((puVar18[0x44] != '\0') && (param_4 != 0x10000)) {

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

+    ExReleaseFastMutexUnsafe(*(undefined8 *)(puVar18 + 0x70));

+  }

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

+  return (ulonglong)plVar15 & 0xffffffff;

 }
```

## `SeValidSecurityDescriptor`  (modified)

```diff
--- SeValidSecurityDescriptor
+++ SeValidSecurityDescriptor
@@ -1,33 +1,63 @@
 

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

-

-void SeValidSecurityDescriptor(undefined8 param_1,undefined8 param_2,undefined8 param_3)

+undefined8 SeValidSecurityDescriptor(uint param_1,char *param_2)

 

 {

-  char *pcVar1;

-  char in_AL;

+  char cVar1;

   int iVar2;

-  longlong lVar3;

-  longlong unaff_RBX;

-  longlong in_R11;

-  undefined2 uStackX_20;

-  undefined2 uStackX_22;

-  longlong lVar4;

+  uint uVar3;

+  ulonglong uVar4;

+  uint uVar5;

+  char *pcVar6;

+  char *pcVar7;

+  char *pcVar8;

   

-  *(char *)(unaff_RBX + 0x242464) = *(char *)(unaff_RBX + 0x242464) + in_AL;

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

-  iVar2 = RtlLargeIntegerToChar(in_R11 + -0x78,param_2,0x41,in_R11 + -0x68);

-  if (-1 < iVar2) {

-    uStackX_22 = 0x41;

-    lVar4 = -1;

-    do {

-      lVar3 = lVar4 + 1;

-      pcVar1 = &stack0x00000041 + lVar4;

-      lVar4 = lVar3;

-    } while (*pcVar1 != '\0');

-    uStackX_20 = (undefined2)lVar3;

-    RtlAnsiStringToUnicodeString(param_3,&uStackX_20,0);

+                    /* 0x8355a0  2803  SeValidSecurityDescriptor */

+  pcVar7 = (char *)0x0;

+  if (((0x13 < param_1) && (*param_2 == '\x01')) && (*(short *)(param_2 + 2) < 0)) {

+    uVar5 = *(uint *)(param_2 + 4);

+    uVar4 = (ulonglong)uVar5;

+    if (((((uVar5 != 0) && ((uVar4 + 3 & 0xfffffffffffffffc) == uVar4)) &&

+         ((uVar5 <= param_1 && ((0xb < param_1 - uVar5 && (param_2[uVar4] == '\x01')))))) &&

+        ((byte)param_2[uVar4 + 1] < 0x10)) &&

+       ((uint)(byte)param_2[uVar4 + 1] * 4 + 8 <= param_1 - uVar5)) {

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

+      uVar4 = (ulonglong)uVar3;

+      pcVar6 = pcVar7;

+      if ((uVar3 == 0) ||

+         ((((((uVar4 + 3 & 0xfffffffffffffffc) == uVar4 && (uVar3 <= param_1)) &&

+            (0xb < param_1 - uVar3)) &&

+           ((pcVar6 = param_2 + uVar4, *pcVar6 == '\x01' && ((byte)pcVar6[1] < 0x10)))) &&

+          ((uint)(byte)pcVar6[1] * 4 + 8 <= param_1 - uVar3)))) {

+        uVar3 = *(uint *)(param_2 + 0x10);

+        uVar4 = (ulonglong)uVar3;

+        pcVar8 = pcVar7;

+        if ((uVar3 == 0) ||

+           ((((uVar4 + 3 & 0xfffffffffffffffc) == uVar4 && (uVar3 <= param_1)) &&

+            ((7 < param_1 - uVar3 &&

+             ((pcVar8 = param_2 + uVar4, (uint)*(ushort *)(pcVar8 + 2) <= param_1 - uVar3 &&

+              (cVar1 = RtlValidAcl(pcVar8), cVar1 != '\0')))))))) {

+          uVar3 = *(uint *)(param_2 + 0xc);

+          uVar4 = (ulonglong)uVar3;

+          if (((uVar3 == 0) ||

+              (((((uVar4 + 3 & 0xfffffffffffffffc) == uVar4 && (uVar3 <= param_1)) &&

+                (7 < param_1 - uVar3)) &&

+               ((pcVar7 = param_2 + uVar4, (uint)*(ushort *)(pcVar7 + 2) <= param_1 - uVar3 &&

+                (cVar1 = RtlValidAcl(pcVar7), cVar1 != '\0')))))) &&

+             ((iVar2 = Feature_2077227322__private_IsEnabledDeviceUsageNoInline(), iVar2 == 0 ||

+              ((((uVar5 = (uint)(byte)param_2[(ulonglong)uVar5 + 1] * 4 + 0x1c, 0x13 < uVar5 &&

+                 ((uVar3 = uVar5, pcVar6 == (char *)0x0 ||

+                  (uVar3 = (uint)(byte)pcVar6[1] * 4 + 8 + uVar5, uVar5 <= uVar3)))) &&

+                ((uVar5 = uVar3, pcVar8 == (char *)0x0 ||

+                 (uVar5 = (*(ushort *)(pcVar8 + 2) + 3 & 0xfffffffc) + uVar3, uVar3 <= uVar5)))) &&

+               (((uVar3 = uVar5, pcVar7 == (char *)0x0 ||

+                 (uVar3 = (*(ushort *)(pcVar7 + 2) + 3 & 0xfffffffc) + uVar5, uVar5 <= uVar3)) &&

+                (uVar3 <= param_1)))))))) {

+            return 1;

+          }

+        }

+      }

+    }

   }

-  return;

+  return 0;

 }
```

## `PopAdaptiveStandbyInitialize`  (modified)

```diff
--- PopAdaptiveStandbyInitialize
+++ PopAdaptiveStandbyInitialize
@@ -1,22 +1,164 @@
 

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

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

 

-undefined1 PopAdaptiveStandbyInitialize(void)

+void PopAdaptiveStandbyInitialize(void)

 

 {

-  longlong *in_RAX;

-  undefined8 uVar1;

-  longlong unaff_RBP;

-  undefined1 unaff_R14B;

+  char cVar1;

+  int iVar2;

+  undefined **ppuVar3;

+  uint uVar4;

+  undefined8 **ppuVar5;

+  undefined4 uVar6;

+  undefined4 uVar7;

+  undefined1 auStack_b8 [32];

+  undefined **local_98;

+  undefined1 *local_90;

+  undefined4 local_88;

+  int local_78 [2];

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 *local_58 [3];

+  undefined1 local_40 [32];

+  int *local_20;

+  undefined4 local_18;

+  undefined4 local_14;

+  ulonglong local_10;

   

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

-  *(char *)((longlong)in_RAX * 2) = *(char *)((longlong)in_RAX * 2) + (char)in_RAX;

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

-  *(undefined8 *)(unaff_RBP + 0x158) = 4;

-  *(undefined8 *)(unaff_RBP + -0x70) = 0x1000000;

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

-  uVar1 = IoGetActivityIdThread();

-  _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e889,uVar1,0,0x1c);

-  return unaff_R14B;

+  local_10 = __security_cookie ^ (ulonglong)auStack_b8;

+  local_60 = 0;

+  local_58[0] = &WNF_PO_COMPOSITE_BATTERY;

+  local_58[1] = &WNF_SEB_AUDIO_ACTIVITY;

+  local_58[2] = &WNF_PO_SLEEPSTUDY_SESSION_CHANGE;

+  local_70 = 0;

+  uStack_68 = 0;

+  TraceLoggingRegisterEx_EtwRegister_EtwSetInformation(&DAT_0,0,0);

+  EtwActivityIdControl(3,&local_70);

+  local_60 = IoSetActivityIdThread(&local_70);

+  if (5 < DAT_0) {

+    local_90 = local_40;

+    local_98 = (undefined **)CONCAT44(local_98._4_4_,2);

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e1e8,&local_70,local_60);

+  }

+  _DAT_1 = 0;

+  _PopAdaptiveStandbyLock = 0;

+  PopAcquireRwLockExclusive(&PopAdaptiveStandbyLock);

+  cVar1 = SSHSupportIsPlatformAoAc();

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

+    cVar1 = RtlIsMultiSessionSku();

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

+      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 == 0) {

+        _DAT_2 = 1;

+        _DAT_3 = 0xffffffff;

+        _DAT_4 = 1;

+        _DAT_5 = 0x2a30;

+      }

+      else {

+        _DAT_6 = 1;

+        DAT_7 = 0xffffffff;

+        DAT_8 = 1;

+        DAT_9 = 0x2a30;

+      }

+      _DAT_10 = _DAT_10 | 1;

+      _DAT_11 = 0;

+      _DAT_12 = 0;

+      _DAT_13 = 0xffffffff;

+      _DAT_14 = 0xffffffff;

+      _DAT_15 = PopAdaptiveStandbyActionWorker;

+      DAT_16 = 100;

+      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 != 0) {

+        local_88 = 0x22;

+        local_90 = (undefined1 *)CONCAT44(local_90._4_4_,6);

+        PopInitializeIRTimer(&DAT_17,PopAdaptiveStandbyPolicyTimerCallback);

+      }

+      uVar4 = 0;

+      ppuVar3 = &PopAdaptiveStandbyPowerSettings;

+      do {

+        local_98 = ppuVar3 + 2;

+        iVar2 = PoRegisterPowerSettingCallback

+                          (0,*ppuVar3,PopAdaptiveStandbyPowerSettingCallback,ppuVar3);

+        if (iVar2 < 0) goto LAB_18;

+        uVar4 = uVar4 + 1;

+        ppuVar3 = ppuVar3 + 3;

+      } while (uVar4 < 7);

+      uVar4 = 0;

+      ppuVar5 = local_58;

+      do {

+        local_90 = (undefined1 *)0x0;

+        local_98 = (undefined **)PopAdaptiveStandbyWnfCallback;

+        iVar2 = ExSubscribeWnfStateChange(local_78,*ppuVar5,1);

+        if (iVar2 < 0) goto LAB_18;

+        uVar4 = uVar4 + 1;

+        ppuVar5 = ppuVar5 + 1;

+      } while (uVar4 < 3);

+      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 != 0) {

+        iVar2 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

+        if (iVar2 == 6) {

+          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsOEM;

+          _DAT_19 = uRam0000000140e0c330;

+          _DAT_20 = _DAT_140e0c348;

+          uRam0000000140e0c410 = uRam0000000140e0c350;

+          uVar6 = (undefined4)DAT_21;

+          uVar7 = (undefined4)((ulonglong)DAT_21 >> 0x20);

+          DAT_22 = _DAT_140e0c338;

+          DAT_23 = uRam0000000140e0c33c;

+          _DAT_24 = uRam0000000140e0c340;

+          _DAT_25 = uRam0000000140e0c344;

+          _DAT_26 = DAT_140e0c360;

+        }

+        else if ((iVar2 == 7) || (iVar2 == 8)) {

+          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsT3;

+          _DAT_19 = uRam0000000140e0c370;

+          _DAT_20 = _DAT_140e0c388;

+          uRam0000000140e0c410 = uRam0000000140e0c390;

+          uVar6 = (undefined4)DAT_27;

+          uVar7 = (undefined4)((ulonglong)DAT_27 >> 0x20);

+          DAT_22 = _DAT_140e0c378;

+          DAT_23 = uRam0000000140e0c37c;

+          _DAT_24 = uRam0000000140e0c380;

+          _DAT_25 = uRam0000000140e0c384;

+          _DAT_26 = DAT_140e0c3a0;

+        }

+        else {

+          if ((iVar2 != 9) && (iVar2 != 10)) goto LAB_28;

+          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsT35;

+          _DAT_19 = uRam0000000140e0c3b0;

+          _DAT_20 = _DAT_140e0c3c8;

+          uRam0000000140e0c410 = uRam0000000140e0c3d0;

+          uVar6 = (undefined4)DAT_29;

+          uVar7 = (undefined4)((ulonglong)DAT_29 >> 0x20);

+          DAT_22 = _DAT_140e0c3b8;

+          DAT_23 = uRam0000000140e0c3bc;

+          _DAT_24 = uRam0000000140e0c3c0;

+          _DAT_25 = uRam0000000140e0c3c4;

+          _DAT_26 = DAT_140e0c3e0;

+        }

+        _DAT_30 = CONCAT44(uVar7,uVar6);

+      }

+LAB_28:

+      PopAdaptiveStandbyContext = 1;

+      iVar2 = 0;

+      goto LAB_18;

+    }

+  }

+  iVar2 = -0x3fffff45;

+LAB_18:

+  PopReleaseRwLock(&PopAdaptiveStandbyLock);

+  if (5 < DAT_0) {

+    local_14 = 0;

+    local_20 = local_78;

+    local_90 = local_40;

+    local_98 = (undefined **)CONCAT44(local_98._4_4_,3);

+    local_18 = 4;

+    local_78[0] = iVar2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e212,&local_70,local_60);

+  }

+  IoClearActivityIdThread(local_60);

+  return;

 }
```

## `PpmPerfRemoveMaximumOverride`  (modified)

```diff
--- PpmPerfRemoveMaximumOverride
+++ PpmPerfRemoveMaximumOverride
@@ -1,11 +1,12 @@
 

 void PpmPerfRemoveMaximumOverride(void)

 

 {

-  code *pcVar1;

-  

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

-  (*pcVar1)();

+  PpmAcquireLock(&PpmPerfPolicyLock);

+  PpmPerfMaxOverrideEnabled = 0;

+  PpmHeteroHgsCheckContainmentDecision();

+  PpmParkApplyPolicy();

+  PpmPerfUpdateDomainPolicy(0);

   return;

 }
```

## `FsRtlUninitializeOplock`  (modified)

```diff
--- FsRtlUninitializeOplock
+++ FsRtlUninitializeOplock
@@ -1,80 +1,216 @@
 

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

-

-undefined1 FsRtlUninitializeOplock(undefined8 param_1)

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

+

+void FsRtlUninitializeOplock(undefined8 *param_1)

 

 {

-  longlong lVar1;

-  ulonglong uVar2;

-  longlong *plVar3;

-  undefined1 uVar4;

-  longlong unaff_RDI;

-  ulonglong uVar5;

-  char unaff_R13B;

-  longlong unaff_R15;

-  ulonglong in_CR8;

-  undefined8 in_stack_00000040;

-  char cStack0000000000000048;

-  char cStack0000000000000049;

-  undefined1 uStack000000000000004b;

-  undefined8 in_stack_00000050;

-  uint in_stack_00000090;

-  undefined8 in_stack_000000c0;

-  longlong *in_stack_000000c8;

-  undefined1 in_stack_000000d0;

-  longlong in_stack_00000118;

-  ulonglong in_stack_00000180;

-  longlong in_stack_00000198;

-  undefined8 in_stack_000001b0;

+  longlong *plVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  longlong lVar4;

+  undefined8 *puVar5;

+  undefined8 uVar6;

+  code *pcVar7;

+  undefined1 uVar8;

+  longlong *plVar9;

+  undefined1 *puVar10;

+  longlong *plVar11;

+  undefined8 uStack_60;

+  undefined1 auStack_58 [64];

   

-  KeSetEvent(param_1,0,0);

-  LOCK();

-  *(int *)(unaff_RDI + 0x228) = *(int *)(unaff_RDI + 0x228) + -1;

-  UNLOCK();

-  if ((in_stack_00000040._1_1_ != '\0') && (in_stack_00000050._4_4_ != 0)) {

-    CcSetDirtyInMask();

-  }

-  if ((((CcRemoteFileDPInlineFlushThreshold != 0xffffffff) &&

-       ((*(uint *)(in_stack_00000198 + 0x50) & 0x1000000) != 0)) && (unaff_R13B == '\0')) &&

-     (CcRemoteFileDPInlineFlushThreshold <= *(uint *)(unaff_R15 + 0x70))) {

-    in_stack_00000040._3_1_ = '\x01';

-    in_stack_00000040._5_1_ = '\x01';

-  }

-  if ((cStack0000000000000048 != '\0') || (in_stack_00000040._5_1_ != '\0')) {

-    uVar5 = 0;

-    if ((unaff_R13B == '\0') || ((*(uint *)(unaff_R15 + 0x98) & 0x40000000) == 0)) {

-      uVar2 = uVar5;

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

-        uVar5 = (ulonglong)in_stack_00000090;

-        uVar2 = in_stack_00000180;

-      }

-      CcFlushCachePriv(*(undefined8 *)(in_stack_00000198 + 0x28),uVar2,uVar5);

-    }

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

-      plVar3 = (longlong *)(in_stack_00000118 + 0x300);

-      in_stack_000000c0 = 0;

-      uVar4 = (undefined1)in_CR8;

-      in_stack_000000c8 = plVar3;

-      if (KiIrqlFlags != 0) {

-        KiRaiseIrqlProcessIrqlFlags(in_CR8 & 0xff,2);

-      }

-      in_stack_000000d0 = uVar4;

-      if (((DAT_0._2_1_ & 0x21) == 0) || (PopHibernateInProgress != 0)) {

+                    /* 0x4da600  682  FsRtlUninitializeOplock */

+  puVar10 = auStack_58;

+  plVar1 = (longlong *)*param_1;

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

+    return;

+  }

+  *param_1 = 0;

+  ExAcquireFastMutexUnsafe(plVar1[0x13]);

+  do {

+    plVar9 = plVar1 + 0xb;

+    plVar11 = (longlong *)*plVar9;

+    if (plVar11 == plVar9) {

+      while( true ) {

+        plVar9 = plVar1 + 5;

+        plVar2 = (longlong *)*plVar9;

+        if (plVar2 == plVar9) goto LAB_0;

+        plVar11 = plVar2 + -0x15;

+        lVar3 = plVar2[2];

+        lVar4 = *plVar2;

+        if (((longlong *)plVar2[1] != plVar9) || (*(longlong **)(lVar4 + 8) != plVar2)) break;

+        *plVar9 = lVar4;

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

+        *(undefined8 *)(puVar10 + -8) = 0x1404da8c0;

+        uVar8 = KeAcquireQueuedSpinLock(7);

+        *(undefined1 *)((longlong)plVar2 + -99) = uVar8;

         LOCK();

-        lVar1 = *plVar3;

-        *plVar3 = (longlong)&stack0x000000c0;

+        plVar2[-8] = 0;

         UNLOCK();

-        if (lVar1 != 0) {

-          KxWaitForLockOwnerShip(&stack0x000000c0);

+        uVar8 = *(undefined1 *)((longlong)plVar2 + -99);

+        *(undefined8 *)(puVar10 + -8) = 0x1404da8d8;

+        KeReleaseQueuedSpinLock(7,uVar8);

+        uVar6 = *(undefined8 *)(lVar3 + 0x30);

+        *(undefined8 *)(puVar10 + -8) = 0x1404da8e6;

+        ObfDereferenceObjectWithTag(uVar6,0x746c6644);

+        if (*(int *)(lVar3 + 0x18) == 0x90240) {

+          puVar5 = (undefined8 *)plVar2[-0x12];

+          *puVar5 = 0;

+          puVar5[1] = 0;

+          puVar5[2] = 0;

+          *(undefined4 *)puVar5 = 0x180001;

+          *(uint *)((longlong)puVar5 + 4) = *(uint *)(plVar1 + 0x12) >> 0xc & 7;

+          plVar2[-0xe] = 0x18;

         }

+        else {

+          plVar2[-0xe] = 8;

+        }

+        *(undefined4 *)(plVar2 + -0xf) = 0;

+        *(undefined8 *)(puVar10 + -8) = 0x1404da930;

+        IofCompleteRequest(plVar11,1);

+      }

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

+      plVar9 = (longlong *)(*pcVar7)(3);

+      puVar10 = puVar10 + 8;

+    }

+    lVar3 = *plVar11;

+    if (((longlong *)plVar11[1] != plVar9) || (*(longlong **)(lVar3 + 8) != plVar11)) {

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

+      (*pcVar7)(3);

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

+      (*pcVar7)();

+      return;

+    }

+    *plVar9 = lVar3;

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

+    lVar3 = plVar11[2];

+    if (lVar3 != 0) {

+      *(undefined8 *)(puVar10 + -8) = 0x1404da965;

+      uVar8 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(lVar3 + 0x45) = uVar8;

+      LOCK();

+      *(undefined8 *)(lVar3 + 0x68) = 0;

+      UNLOCK();

+      uVar8 = *(undefined1 *)(lVar3 + 0x45);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da97d;

+      KeReleaseQueuedSpinLock(7,uVar8);

+      *(undefined8 *)(lVar3 + 0x38) = 0;

+    }

+    pcVar7 = (code *)plVar11[3];

+    lVar3 = plVar11[2];

+    lVar4 = plVar11[4];

+    *(undefined8 *)(puVar10 + -8) = 0x1404da992;

+    (*pcVar7)(lVar4,lVar3);

+    *(undefined8 *)(puVar10 + -8) = 0x1404da99c;

+    ExFreePoolWithTag(plVar11,0);

+  } while( true );

+LAB_0:

+  plVar9 = (longlong *)plVar1[7];

+  if (plVar9 == plVar1 + 7) {

+    while (plVar9 = (longlong *)plVar1[9], plVar9 != plVar1 + 9) {

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7b1;

+      FsRtlpOplockDequeueRH(plVar9);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7bf;

+      FsRtlpModifyThreadPriorities(plVar1,plVar9,0);

+      lVar3 = plVar9[3];

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7cd;

+      ObfDereferenceObjectWithTag(lVar3,0x746c6644);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7d8;

+      FsRtlpClearOwner(plVar1,plVar9);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7e1;

+      FsRtlpOplockPerfSendData(plVar9 + 9);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da7eb;

+      FsRtlpFreeRHOpContext(plVar9,1);

+    }

+    lVar3 = *plVar1;

+    if (lVar3 == 0) {

+      *(undefined8 *)(puVar10 + -8) = 0x1404da74a;

+      FsRtlpOplockPerfSendData(plVar1 + 0x14);

+    }

+    else {

+      lVar4 = *(longlong *)(lVar3 + 0xb8);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da6ad;

+      uVar8 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(lVar3 + 0x45) = uVar8;

+      LOCK();

+      *(undefined8 *)(lVar3 + 0x68) = 0;

+      UNLOCK();

+      uVar8 = *(undefined1 *)(lVar3 + 0x45);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da6c5;

+      KeReleaseQueuedSpinLock(7,uVar8);

+      if (*(int *)(lVar4 + 0x18) == 0x90240) {

+        puVar5 = *(undefined8 **)(lVar3 + 0x18);

+        *puVar5 = 0;

+        puVar5[1] = 0;

+        puVar5[2] = 0;

+        *(undefined4 *)puVar5 = 0x180001;

+        *(uint *)((longlong)puVar5 + 4) = *(uint *)(plVar1 + 0x12) >> 0xc & 7;

+        *(undefined8 *)(lVar3 + 0x38) = 0x18;

       }

       else {

-        KiAcquireQueuedSpinLockInstrumented(&stack0x000000c0,plVar3);

-      }

-      *(int *)(unaff_R15 + 0x20c) = *(int *)(unaff_R15 + 0x20c) + -1;

-      KeReleaseInStackQueuedSpinLock(&stack0x000000c0);

-    }

-  }

-  return uStack000000000000004b;

+        *(undefined8 *)(lVar3 + 0x38) = 8;

+      }

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

+      *(undefined8 *)(puVar10 + -8) = 0x1404da70f;

+      IofCompleteRequest(lVar3,1);

+      *plVar1 = 0;

+      lVar3 = plVar1[1];

+      if (lVar3 != 0) {

+        *(undefined8 *)(puVar10 + -8) = 0x1404da725;

+        ObfDereferenceObjectWithTag(lVar3,0x746c6644);

+      }

+      *(undefined8 *)(puVar10 + -8) = 0x1404da732;

+      FsRtlpModifyThreadPriorities(plVar1,0,0);

+      *(undefined8 *)(puVar10 + -8) = 0x1404da73c;

+      FsRtlpClearOwner(plVar1,0);

+    }

+    *(undefined8 *)(puVar10 + -8) = 0x1404da756;

+    FsRtlpSyncWithAckTimeout(plVar1 + 0x16);

+    lVar3 = plVar1[0x13];

+    *(undefined8 *)(puVar10 + -8) = 0x1404da763;

+    ExReleaseFastMutexUnsafe(lVar3);

+    lVar3 = plVar1[0x11];

+    if (lVar3 != 0) {

+      *(undefined8 *)(puVar10 + -8) = 0x1404da776;

+      ExFreePoolWithTag(lVar3,0);

+    }

+    lVar3 = plVar1[0x13];

+    *(undefined8 *)(puVar10 + -8) = 0x1404da784;

+    ExFreePoolWithTag(lVar3,0);

+    *(undefined8 *)(puVar10 + -8) = 0x1404da78e;

+    ExFreePoolWithTag(plVar1,0);

+    return;

+  }

+  if (((*(uint *)(plVar1 + 0x12) & 0x10000) == 0) || (plVar11 = plVar9 + 7, *plVar11 == 0)) {

+LAB_1:

+    puVar10[0x38] = 0;

+    *(undefined2 *)(puVar10 + 0x30) = 0;

+    *(undefined4 *)(puVar10 + 0x28) = 0;

+    *(undefined4 *)(puVar10 + 0x20) = 0;

+    *(undefined8 *)(puVar10 + -8) = 0x1404da885;

+    FsRtlpRemoveAndCompleteRHIrp(plVar9,plVar1,0,0);

+    goto LAB_0;

+  }

+  *(undefined8 *)(puVar10 + -8) = 0x1404da80e;

+  FsRtlpOplockDequeueRH(plVar9);

+  lVar3 = *plVar11;

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

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

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

+    (*pcVar7)(3);

+    puVar10 = puVar10 + 8;

+    goto LAB_1;

+  }

+  *plVar2 = lVar3;

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

+  if ((longlong *)plVar1[0xf] == plVar1 + 0xf) {

+    *(uint *)(plVar1 + 0x12) = *(uint *)(plVar1 + 0x12) & 0xfffcffff;

+  }

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

+    *(undefined8 *)(puVar10 + -8) = 0x1404da84c;

+    FsRtlpClearOwner(plVar1,plVar9);

+  }

+  *(undefined8 *)(puVar10 + -8) = 0x1404da856;

+  FsRtlpFreeRHOpContext(plVar9,1);

+  goto LAB_0;

 }
```

## `PopUmpoProcessPowerMessage`  (modified)

```diff
--- PopUmpoProcessPowerMessage
+++ PopUmpoProcessPowerMessage
@@ -1,46 +1,61 @@
 

-/* WARNING: Instruction at (ram,0x000140a19235) overlaps instruction at (ram,0x000140a19234)

-    */

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

 

-undefined4 PopUmpoProcessPowerMessage(longlong param_1,undefined8 param_2)

+undefined8 PopUmpoProcessPowerMessage(int *param_1,undefined1 *param_2)

 

 {

-  byte *pbVar1;

-  char cVar2;

-  undefined4 uVar3;

-  longlong in_RAX;

-  undefined8 *puVar4;

-  undefined8 *unaff_RBP;

-  undefined8 *puVar5;

-  undefined8 unaff_RDI;

-  char in_ZF;

-  undefined1 auStack_d263 [53811];

-  undefined1 *puStack_30;

-  undefined8 uStack_18;

+  int iVar1;

+  undefined8 uVar2;

+  undefined8 uVar3;

   

-  puVar5 = unaff_RBP;

-  if (param_1 + -1 != 0 && in_ZF == '\0') {

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

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

-    *pbVar1 = *pbVar1 >> 5 | *pbVar1 << 3;

-    puStack_30 = &stack0xfffffffffffffff0;

-    puVar4 = (undefined8 *)&stack0xfffffffffffffff0;

-    puVar5 = (undefined8 *)&stack0xfffffffffffffff0;

-    cVar2 = '\x03';

-    do {

-      unaff_RBP = unaff_RBP + -1;

-      puVar4 = puVar4 + -1;

-      *puVar4 = *unaff_RBP;

-      cVar2 = cVar2 + -1;

-    } while ('\0' < cVar2);

-    register0x00000020 = (BADSPACEBASE *)auStack_d263;

-    in_RAX = CONCAT71((int7)((ulonglong)in_RAX >> 8),(char)(param_1 + -1));

+  iVar1 = *param_1;

+  if (iVar1 == 4) {

+    uVar3 = PopSetNewPolicyValue(param_1 + 2);

+    if ((int)uVar3 < 0) {

+      return uVar3;

+    }

   }

-  puVar5[-8] = param_2;

-  puVar5[-7] = unaff_RDI;

-  *(longlong *)((longlong)register0x00000020 + 0x20) = in_RAX;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140a19250;

-  uVar3 = _CmGetMatchingDeviceListForSubkey();

-  return uVar3;

+  else if (iVar1 == 7) {

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

+      PfIoPowerEventNotify(param_1[3],param_2,1);

+    }

+  }

+  else if (iVar1 == 8) {

+    PopPowerRequestHandleRequestOverrideQueryResponse(param_1 + 2);

+  }

+  else if (iVar1 == 10) {

+    if ((char)param_1[2] != '\0') {

+      PopPowerRequestNotificationsBegin();

+    }

+    PopPowerRequestOverrideInitialize();

+    PopAcquireRwLockExclusive(&PopPowerAggregatorLock);

+    PopPowerAggregatorUmpoInitialized = 1;

+    PopPowerAggregatorScheduleWorker(&PopPowerAggregatorContext);

+    PopReleaseRwLock(&PopPowerAggregatorLock);

+    if (DAT_0 != (code *)0x0) {

+      (*DAT_0)();

+    }

+  }

+  else if (iVar1 == 0x12) {

+    uVar3 = *(undefined8 *)(param_1 + 6);

+    uVar2 = *(undefined8 *)(param_1 + 8);

+    iVar1 = param_1[4];

+    if (param_1[2] == 0) {

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

+      *(undefined8 *)(param_2 + 0x20) = uVar3;

+      *(undefined8 *)(param_2 + 0x28) = uVar2;

+      *(int *)(param_2 + 8) = iVar1;

+    }

+    else if (param_1[2] == 1) {

+      param_2[2] = (char)param_1[3];

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

+      *(undefined8 *)(param_2 + 0x38) = uVar2;

+      *(int *)(param_2 + 0xc) = iVar1;

+    }

+  }

+  else if ((iVar1 == 0x13) || (iVar1 == 0x14)) {

+    PopAdaptiveStandbyHandlePowerMessage();

+  }

+  return 0;

 }
```

## `IoWritePartitionTable`  (modified)

```diff
--- IoWritePartitionTable
+++ IoWritePartitionTable
@@ -1,21 +1,63 @@
 

-undefined8

-IoWritePartitionTable(undefined8 param_1,undefined8 *param_2,undefined8 param_3,undefined4 param_4)

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

+/* WARNING: Enum "_POOL_TYPE": Some values do not have unique names */

+/* WARNING: Struct "_MMSUPPORT_FLAGS": ignoring multiple overlapping fields */

+/* WARNING: Enum "_NT_IORING_OP_FLAGS": Some values do not have unique names */

+/* WARNING: Enum "_POWER_LIMIT_TYPES": Some values do not have unique names */

+

+long IoWritePartitionTable

+               (_DEVICE_OBJECT *param_1,ulong param_2,uchar param_3,undefined8 param_4,uint *param_5

+               )

 

 {

-  undefined8 uStack0000000000000028;

-  undefined4 uStack0000000000000030;

-  undefined4 uStack0000000000000038;

-  undefined4 uStack0000000000000040;

-  undefined4 in_stack_00000080;

-  undefined4 in_stack_00000088;

-  undefined8 in_stack_00000090;

+  long lVar1;

+  SC_DISK_LAYOUT *pSVar2;

+  longlong lVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  undefined1 auStack_1c8 [32];

+  undefined **local_1a8 [49];

+  undefined8 local_20;

+  ulonglong local_18;

   

-  uStack0000000000000040 = in_stack_00000088;

-  uStack0000000000000038 = in_stack_00000080;

-  uStack0000000000000028 = param_3;

-  uStack0000000000000030 = param_4;

-  McTemplateK0xxxqqqq_EtwWriteTransfer(param_1,param_2,in_stack_00000090,*param_2,param_2[1]);

-  return 0;

+                    /* 0x70c250  1176  IoWritePartitionTable */

+  local_18 = __security_cookie ^ (ulonglong)auStack_1c8;

+  SC_DISK::SC_DISK((SC_DISK *)local_1a8);

+  local_20 = 0;

+  local_1a8[0] = &NT_DISK::_vftable_;

+  pSVar2 = SC_ENV::Allocate((ulonglong)(*param_5 * 0x90 + 0x30),param_2,param_3,0);

+  if (pSVar2 == (SC_DISK_LAYOUT *)0x0) {

+    lVar1 = -0x3fffff66;

+  }

+  else {

+    *(undefined4 *)pSVar2 = 0;

+    *(uint *)(pSVar2 + 4) = *param_5;

+    *(uint *)(pSVar2 + 8) = param_5[1];

+    uVar5 = 0;

+    if (*param_5 != 0) {

+      do {

+        lVar3 = uVar5 * 0x20;

+        uVar4 = (int)uVar5 + 1;

+        *(undefined4 *)(pSVar2 + uVar5 * 0x90 + 0x30) = 0;

+        *(undefined8 *)(pSVar2 + uVar5 * 0x90 + 0x38) = *(undefined8 *)(param_5 + uVar5 * 8 + 2);

+        *(undefined8 *)(pSVar2 + uVar5 * 0x90 + 0x40) = *(undefined8 *)(param_5 + uVar5 * 8 + 4);

+        *(uint *)(pSVar2 + uVar5 * 0x90 + 0x48) = param_5[uVar5 * 8 + 7];

+        pSVar2[uVar5 * 0x90 + 0x4c] = *(SC_DISK_LAYOUT *)(lVar3 + 0x23 + (longlong)param_5);

+        pSVar2[uVar5 * 0x90 + 0x50] = *(SC_DISK_LAYOUT *)(param_5 + uVar5 * 8 + 8);

+        pSVar2[uVar5 * 0x90 + 0x51] = *(SC_DISK_LAYOUT *)(lVar3 + 0x21 + (longlong)param_5);

+        pSVar2[uVar5 * 0x90 + 0x52] = *(SC_DISK_LAYOUT *)(lVar3 + 0x22 + (longlong)param_5);

+        *(uint *)(pSVar2 + uVar5 * 0x90 + 0x54) = param_5[uVar5 * 8 + 6];

+        uVar5 = (ulonglong)uVar4;

+      } while (uVar4 < *param_5);

+    }

+    lVar1 = NT_DISK::Initialize((NT_DISK *)local_1a8,param_1);

+    if (-1 < lVar1) {

+      lVar1 = SC_DISK::WritePartitionTable((SC_DISK *)local_1a8,pSVar2);

+    }

+    ExFreePoolWithTag(pSVar2,0);

+  }

+  local_1a8[0] = &NT_DISK::_vftable_;

+  SC_DISK::~SC_DISK((SC_DISK *)local_1a8);

+  return lVar1;

 }
```

## `VslpEnterIumSecureMode`  (modified)

```diff
--- VslpEnterIumSecureMode
+++ VslpEnterIumSecureMode
@@ -1,131 +1,244 @@
 

-/* WARNING: Instruction at (ram,0x0001403c3ec6) overlaps instruction at (ram,0x0001403c3ec5)

-    */

-

-int VslpEnterIumSecureMode(char param_1,undefined8 param_2,undefined8 param_3,int param_4)

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

+

+ulonglong VslpEnterIumSecureMode(byte param_1,undefined2 param_2,int param_3,byte *param_4)

 

 {

   int *piVar1;

-  byte bVar2;

-  undefined2 uVar3;

-  undefined8 uVar4;

-  code *pcVar5;

-  char cVar6;

-  int iVar7;

-  char *in_RAX;

-  ulonglong uVar8;

-  longlong *plVar9;

-  longlong *plVar10;

-  longlong lVar11;

-  int unaff_EBX;

-  ulonglong unaff_RBP;

-  undefined8 *unaff_RSI;

-  longlong unaff_RDI;

-  longlong lVar12;

-  longlong *unaff_R12;

-  longlong *unaff_R13;

-  int unaff_R14D;

-  int unaff_R15D;

+  undefined1 uVar2;

+  undefined4 uVar3;

+  code *pcVar4;

+  bool bVar5;

+  bool bVar6;

+  void *pvVar7;

+  char cVar8;

+  byte bVar9;

+  uint uVar10;

+  int iVar11;

+  ulonglong uVar12;

+  undefined8 unaff_R13;

+  ulonglong in_CR8;

+  ulonglong uVar13;

+  undefined1 auStack_b8 [32];

+  undefined8 local_98;

+  undefined1 *local_90;

+  char local_88;

+  undefined2 local_86;

+  ushort local_84;

+  undefined2 local_82;

+  ushort local_80;

+  undefined2 local_7e;

+  undefined4 local_7c;

+  ulonglong local_78;

+  undefined1 local_70 [8];

+  ushort *local_68;

+  undefined8 local_60;

+  ushort *local_58;

+  undefined8 local_50;

+  ulonglong local_48;

   

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

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

-  uVar8 = CONCAT71((int7)((ulonglong)in_RAX >> 8),(char)in_RAX + -0x24);

-  do {

-    unaff_R12 = (longlong *)*unaff_R12;

-    if (((int)uVar8 != 0) && (lVar12 = *(longlong *)((longlong)unaff_R13 + 0x30), lVar12 != 0)) {

-      uVar4 = *(undefined8 *)(lVar12 + (ulonglong)(*(byte *)(lVar12 + 8) & 0x3f) * -0x58 + -0x10);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3efb;

-      KiAbConvertWaiterToOwnerEntry(uVar4,lVar12,param_4);

-    }

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3f04;

-    KiAcquireKobjectLockSafe((longlong)unaff_R13 + 0x18);

-    *(int *)((longlong)unaff_R13 + 0x1c) = unaff_R15D;

-    plVar9 = *(longlong **)((longlong)unaff_R13 + 0x20);

-    plVar10 = (longlong *)((longlong)unaff_R13 + 0x20);

-    *(longlong **)((longlong)register0x00000020 + 0x30) = plVar10;

-    do {

-      do {

-        while( true ) {

-          lVar12 = (longlong)unaff_R13 + 0x18;

-          if (plVar9 == plVar10) goto LAB_0;

-          lVar11 = *plVar9;

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

-          *(longlong *)((longlong)register0x00000020 + 0xa8) = lVar11;

-          if ((*(longlong **)(lVar11 + 8) != plVar9) || ((longlong *)*plVar10 != plVar9)) {

-            plVar10 = (longlong *)0x3;

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

-            plVar9 = (longlong *)(*pcVar5)();

-            register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-          }

-          *plVar10 = lVar11;

-          *(longlong **)(lVar11 + 8) = plVar10;

-          bVar2 = *(byte *)(plVar9 + 2);

-          if (bVar2 == (byte)unaff_R15D) break;

-          if (bVar2 == 2) {

-            *(undefined1 *)((longlong)plVar9 + 0x11) = 5;

-            lVar12 = plVar9[3];

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3ffb;

-            KiInsertQueueInternal(lVar12,plVar9);

-            piVar1 = (int *)((longlong)unaff_R13 + 0x1c);

-            *piVar1 = *piVar1 - unaff_R15D;

-            if (*piVar1 == 0) goto LAB_0;

-            plVar9 = *(longlong **)((longlong)register0x00000020 + 0xa8);

-            plVar10 = *(longlong **)((longlong)register0x00000020 + 0x30);

-          }

-          else if (bVar2 == 4) {

-            *(undefined1 *)((longlong)plVar9 + 0x11) = 5;

-            *(undefined4 *)(lVar12 + 4) = 0;

-            lVar11 = plVar9[3];

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c40b1;

-            KeInsertQueueDpc(lVar11,lVar12,plVar9);

-            plVar9 = *(longlong **)((longlong)register0x00000020 + 0xa8);

-            plVar10 = *(longlong **)((longlong)register0x00000020 + 0x30);

-          }

-          else {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c407b;

-            KiTryUnwaitThread(*(undefined8 *)((longlong)register0x00000020 + 0x38),plVar9,0x100,0);

-            plVar9 = *(longlong **)((longlong)register0x00000020 + 0xa8);

-            plVar10 = *(longlong **)((longlong)register0x00000020 + 0x30);

+  local_48 = __security_cookie ^ (ulonglong)auStack_b8;

+  bVar5 = false;

+  bVar6 = false;

+  local_78 = CONCAT71((int7)((ulonglong)unaff_R13 >> 8),0xf);

+  local_88 = '\0';

+  if (HvlpVsmVtlCallVa == 0) {

+    return 0xc000009d;

+  }

+  *param_4 = param_1;

+  *(undefined2 *)(param_4 + 2) = param_2;

+  uVar3 = *(undefined4 *)((longlong)SystemReserved1[0xf] + 0x510);

+  local_86 = param_2;

+  local_7c = uVar3;

+  if (2 < param_1) {

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

+      HvlSwitchToVsmVtl1(0,param_4,uVar3);

+    }

+    else {

+      EtwTraceEnterVtl1(param_1);

+      HvlSwitchToVsmVtl1(0,param_4,uVar3);

+      EtwTraceExitVtl1(param_1,param_2);

+    }

+    if (-1 < (char)param_4[1]) {

+      return 0;

+    }

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

+    uVar12 = (*pcVar4)();

+    return uVar12;

+  }

+  cVar8 = KeAreInterruptsEnabled();

+  uVar12 = in_CR8;

+  if ((cVar8 == '\0') && (VslVsmEnabled != '\0')) {

+    uVar13 = 0xf;

+    uVar12 = 0xf;

+    local_78 = in_CR8;

+    if (KiIrqlFlags != 0) {

+      KiRaiseIrqlProcessIrqlFlags(in_CR8 & 0xff,0xf);

+      uVar12 = uVar13;

+    }

+  }

+  pvVar7 = SystemReserved1[0xf];

+  bVar9 = (byte)uVar12;

+  if (param_1 == 1) {

+    *(int *)(param_4 + 4) = param_3;

+  }

+  else {

+    piVar1 = (int *)((longlong)SystemReserved1[0xf] + 0x31c);

+    if (param_3 == 0) {

+      if (bVar9 < 2) {

+        iVar11 = *piVar1;

+        if (iVar11 == 0) {

+          param_4[4] = 0;

+          param_4[5] = 0;

+          param_4[6] = 0;

+          param_4[7] = 0;

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

+            bVar6 = true;

           }

         }

-        uVar3 = *(undefined2 *)((longlong)plVar9 + 0x12);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3f6b;

-        cVar6 = KiTryUnwaitThread(*(undefined8 *)((longlong)register0x00000020 + 0x38),plVar9,uVar3,

-                                  0);

-        plVar9 = *(longlong **)((longlong)register0x00000020 + 0xa8);

-        plVar10 = *(longlong **)((longlong)register0x00000020 + 0x30);

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

-      piVar1 = (int *)((longlong)unaff_R13 + 0x1c);

-      *piVar1 = *piVar1 - unaff_R15D;

-    } while (*piVar1 != 0);

-LAB_0:

-    LOCK();

-    *(uint *)((longlong)unaff_R13 + 0x18) = *(uint *)((longlong)unaff_R13 + 0x18) & 0xffffff7f;

-    UNLOCK();

-    unaff_EBX = unaff_EBX + 1;

-    if (unaff_R12 == (longlong *)unaff_RDI) {

-      lVar12 = *(longlong *)((longlong)register0x00000020 + 0x38);

-      if ((byte)((byte)unaff_R15D & (byte)unaff_RBP) != 0) {

-        uVar4 = *(undefined8 *)(lVar12 + 8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3fb4;

-        iVar7 = KiRemoveBoostThread(lVar12,uVar4);

-        if ((unaff_R14D != 0) && (unaff_R15D = 2, unaff_R14D < iVar7)) {

-          unaff_R14D = iVar7;

+        else {

+          *(int *)(param_4 + 4) = iVar11;

+          param_3 = iVar11;

         }

       }

-      if (((unaff_RBP & 2) != 0) && (unaff_R15D == 1)) {

-        unaff_R14D = 1;

-      }

-      *(char *)((longlong)register0x00000020 + 0x20) =

-           (char)*(undefined8 *)((longlong)register0x00000020 + 0x40);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1403c3fdc;

-      KiExitDispatcher(lVar12,0,unaff_R15D,unaff_R14D);

-      *unaff_RSI = 0;

-      return unaff_EBX;

-    }

-    uVar8 = (ulonglong)*(uint *)((longlong)register0x00000020 + 0x90);

-    unaff_R13 = unaff_R12;

-    param_4 = unaff_R15D;

-  } while( true );

+      else {

+        param_4[4] = 0;

+        param_4[5] = 0;

+        param_4[6] = 0;

+        param_4[7] = 0;

+        param_3 = 1;

+      }

+    }

+    else {

+      *(int *)(param_4 + 4) = param_3;

+    }

+    bVar5 = false;

+    if (*piVar1 == 0) {

+      bVar5 = true;

+    }

+  }

+  if (bVar9 == 1) {

+    bVar5 = true;

+LAB_1:

+    *(short *)((longlong)pvVar7 + 0x1e4) = *(short *)((longlong)pvVar7 + 0x1e4) + -1;

+  }

+  else if (bVar9 < 2) {

+    if (bVar5) goto LAB_1;

+  }

+  else {

+    bVar5 = false;

+  }

+  uVar13 = uVar12;

+  if (bVar6) {

+    local_98 = 0;

+    uVar10 = KeWaitForMutexObject(&VslpIumThreadSemaphore,0,0,0);

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

+    local_88 = '\x01';

+    uVar13 = uVar12;

+    param_2 = local_86;

+  }

+  while( true ) {

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

+      HvlSwitchToVsmVtl1(0,param_4);

+      uVar10 = *(uint *)(param_4 + 8);

+    }

+    else {

+      local_68 = &local_84;

+      local_60 = 4;

+      local_98._0_4_ = 0x501902;

+      local_84 = (ushort)param_1;

+      local_82 = param_2;

+      EtwTraceKernelEvent(&local_68,1,0xa0000008,0x549);

+      HvlSwitchToVsmVtl1(0,param_4,local_7c);

+      uVar10 = *(uint *)(param_4 + 8);

+      local_7e = local_86;

+      local_58 = &local_80;

+      local_50 = 4;

+      local_98 = CONCAT44(local_98._4_4_,0x501902);

+      local_80 = (ushort)param_1;

+      EtwTraceKernelEvent(&local_58,1,0xa0000008,0x54a);

+    }

+    bVar9 = param_4[1];

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

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

+      uVar12 = (*pcVar4)();

+      return uVar12;

+    }

+    uVar12 = uVar13;

+    if (bVar9 == 1) goto LAB_3;

+    if (bVar9 == 6) break;

+    if ((param_1 == 1) || (param_3 == 0)) {

+      *(undefined4 *)((longlong)pvVar7 + 0x31c) = *(undefined4 *)(param_4 + 4);

+    }

+    bVar9 = param_4[1];

+    if (bVar9 == 3) {

+LAB_4:

+      if (*(ushort *)(param_4 + 2) < (uint)DAT_5) {

+        uVar2 = *(undefined1 *)((longlong)pvVar7 + 0x232);

+        if (bVar9 == 3) {

+          *(undefined1 *)((longlong)pvVar7 + 0x232) = 0;

+        }

+        iVar11 = VslpDispatchIumSyscall

+                           ((*(int *)(KeServiceDescriptorTable +

+                                     (ulonglong)*(ushort *)(param_4 + 2) * 4) >> 4) +

+                            KeServiceDescriptorTable,param_4 + 8);

+        *(longlong *)(param_4 + 8) = (longlong)iVar11;

+        *(undefined1 *)((longlong)pvVar7 + 0x232) = uVar2;

+      }

+      else {

+        param_4[8] = 0x1c;

+        param_4[9] = 0;

+        param_4[10] = 0;

+        param_4[0xb] = 0xc0;

+        param_4[0xc] = 0xff;

+        param_4[0xd] = 0xff;

+        param_4[0xe] = 0xff;

+        param_4[0xf] = 0xff;

+      }

+    }

+    else if (bVar9 == 0) {

+LAB_6:

+      PsDispatchIumService();

+    }

+    else if (bVar9 == 2) {

+      if (*(char *)((longlong)pvVar7 + 0x232) != '\0') goto LAB_4;

+      param_4[8] = 0x30;

+      param_4[9] = 0;

+      param_4[10] = 0;

+      param_4[0xb] = 0xc0;

+      param_4[0xc] = 0xff;

+      param_4[0xd] = 0xff;

+      param_4[0xe] = 0xff;

+      param_4[0xf] = 0xff;

+    }

+    else if (bVar9 == 5) goto LAB_6;

+    if ((param_3 == 0) && (param_1 != 1)) {

+      *(undefined4 *)((longlong)pvVar7 + 0x31c) = 0;

+    }

+    *param_4 = 0;

+    param_4[2] = 0;

+    param_4[3] = 0;

+    param_2 = local_86;

+  }

+  uVar12 = 0;

+  if (KiIrqlFlags != 0) {

+    KiLowerIrqlProcessIrqlFlags(uVar13,0);

+  }

+LAB_3:

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

+    local_90 = local_70;

+    local_98 = CONCAT44(local_98._4_4_,8);

+    KeReleaseSemaphoreEx(&VslpIumThreadSemaphore,0,1);

+  }

+LAB_2:

+  if (bVar5) {

+    KeLeaveCriticalRegionThread(pvVar7);

+  }

+  if (((char)local_78 != '\x0f') && (KiIrqlFlags != 0)) {

+    KiLowerIrqlProcessIrqlFlags(uVar12,local_78 & 0xff);

+    uVar12 = FUN_1406e16fc();

+    return uVar12;

+  }

+  return (ulonglong)uVar10;

 }
```

## `PdcPoCurrentPdcPhase`  (modified)

```diff
--- PdcPoCurrentPdcPhase
+++ PdcPoCurrentPdcPhase
@@ -1,57 +1,68 @@
 

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

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

 

-void PdcPoCurrentPdcPhase(void)

+undefined4 PdcPoCurrentPdcPhase(int param_1,char param_2,undefined4 param_3,undefined4 param_4)

 

 {

-  undefined1 uVar1;

-  undefined8 uVar2;

-  undefined8 uVar3;

-  undefined8 uVar4;

-  undefined8 uVar5;

-  undefined8 uVar6;

-  longlong unaff_RBX;

-  undefined4 uStack0000000000000038;

-  undefined4 uStack000000000000003c;

-  code *pcStack0000000000000040;

-  undefined8 in_stack_00000048;

-  undefined8 in_stack_00000050;

-  undefined8 uStack0000000000000058;

-  undefined8 uStack0000000000000060;

-  undefined4 in_stack_00000070;

-  undefined8 uStack00000000000000a8;

+  int iVar1;

+  int iVar2;

+  undefined4 uVar3;

+  longlong lVar4;

+  undefined4 uVar5;

   

-  uStack0000000000000058 = *(undefined8 *)(unaff_RBX + 0xf8);

-  uStack0000000000000060 = *(undefined8 *)(unaff_RBX + 0x100);

-  pcStack0000000000000040 = *(code **)(unaff_RBX + 0x110);

-  uStack0000000000000038 = (undefined4)*(undefined8 *)(unaff_RBX + 0x108);

-  uStack000000000000003c = (undefined4)((ulonglong)*(undefined8 *)(unaff_RBX + 0x108) >> 0x20);

-  uStack00000000000000a8 = *(undefined8 *)(unaff_RBX + 0x118);

-  KeReleaseSpinLock();

-  uVar2 = PopResolveWatchdogParam(in_stack_00000048,uStack0000000000000038);

-  uVar3 = PopResolveWatchdogParam

-                    (in_stack_00000050,

-                     CONCAT44(uStack000000000000003c,uStack0000000000000038) >> 8 & 0xffffffff);

-  uVar4 = PopResolveWatchdogParam

-                    (uStack0000000000000058,

-                     CONCAT44(uStack000000000000003c,uStack0000000000000038) >> 0x10 & 0xffffffff);

-  uVar5 = PopResolveWatchdogParam

-                    (uStack0000000000000060,

-                     CONCAT44(uStack000000000000003c,uStack0000000000000038) >> 0x18 & 0xffffffff);

-  uVar6 = RtlGetInterruptTimePrecise(&stack0x000000d8);

-  *(undefined8 *)(unaff_RBX + 0x180) = uVar6;

-  *(undefined1 *)(unaff_RBX + 0xd1) = 1;

-  if (pcStack0000000000000040 != (code *)0x0) {

-    (*pcStack0000000000000040)(uStack00000000000000a8,in_stack_00000070,uVar2,uVar3,uVar4,uVar5);

-    uVar1 = KeAcquireSpinLockRaiseToDpc(&PopWatchdogLock);

-    *(undefined1 *)(unaff_RBX + 0x15) = 0;

-    PopUpdateWatchdogNoWorkersEvent();

-    KeReleaseSpinLock(&PopWatchdogLock,uVar1);

-    uVar2 = RtlGetInterruptTimePrecise(&stack0x000000d8);

-    *(undefined8 *)(unaff_RBX + 0x188) = uVar2;

-    return;

+  iVar1 = Feature_ExpandSTEIgnoreReasons__private_IsEnabledDeviceUsageNoInline();

+  uVar3 = 0;

+  uVar5 = 0;

+  iVar2 = param_1;

+  if (iVar1 != 0) {

+    iVar2 = _PopBsdCurrentCsPhase;

+    PopCurrentPdcCsPhase = param_1;

   }

-                    /* WARNING: Subroutine does not return */

-  KeBugCheckEx(in_stack_00000070,uVar2,uVar3,uVar4,uVar5);

+  _PopBsdCurrentCsPhase = iVar2;

+  if (param_1 == 1) {

+    PopDisarmIdlePhaseWatchdog();

+    uVar3 = uVar5;

+  }

+  else if (param_1 == 2) {

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

+      PopAcquirePolicyLock();

+      PopSmartSuspendMakePredictions(1);

+      PopReleasePolicyLock();

+    }

+    PopPowerAggregatorNotifyPdcPhaseState(2,param_2);

+    PopIdleCsStateChanged(param_2 != '\0');

+    PopAdaptiveStandbyNotifyShellPhaseState(param_2);

+    uVar3 = uVar5;

+  }

+  else if (param_1 == 6) {

+    uVar3 = PopPowerAggregatorNotifyPdcSleepTransition(param_2,param_3,param_4);

+  }

+  else if (param_1 == 7) {

+    lVar4 = KeQueryPerformanceCounter(0);

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

+      DAT_0 = DAT_0 + (lVar4 - _DAT_140e27c80);

+      if (PopFxAccountingGroup == 2) {

+        PopFxPauseDeviceAccounting();

+      }

+      PopDeepSleepResiliencyPhaseAccountingEnd(3);

+      uVar3 = uVar5;

+    }

+    else {

+      _DAT_1 = lVar4;

+      PopDeepSleepResiliencyPhaseAccountingBegin(3);

+      if (PopFxAccountingGroup == 2) {

+        PopFxResumeDeviceAccounting();

+        uVar3 = uVar5;

+      }

+    }

+  }

+  else if (param_1 == 8) {

+    iVar2 = Feature_PdcResiliencyV2__private_IsEnabledDeviceUsageNoInline();

+    if (iVar2 != 0) {

+      PopNetResiliencyPhaseStateChanged(param_2);

+    }

+    PopPowerAggregatorNotifyResiliencyReached();

+  }

+  return uVar3;

 }
```

## `SepFilterToken`  (modified)

```diff
--- SepFilterToken
+++ SepFilterToken
@@ -1,25 +1,613 @@
 

-undefined8 SepFilterToken(undefined8 param_1,undefined8 param_2,uint param_3)

+int SepFilterToken(undefined4 *param_1,undefined1 param_2,uint param_3,undefined4 param_4,

+                  undefined8 param_5,undefined4 param_6,undefined8 param_7,uint param_8,

+                  undefined8 *param_9,int param_10,longlong *param_11)

 

 {

-  uint uVar1;

-  uint in_EAX;

-  longlong unaff_RBX;

-  uint unaff_EDI;

-  uint in_R11D;

-  bool bVar2;

+  longlong *plVar1;

+  uint *puVar2;

+  undefined1 uVar3;

+  int iVar4;

+  undefined4 uVar5;

+  longlong lVar6;

+  code *pcVar7;

+  undefined4 uVar8;

+  undefined4 uVar9;

+  undefined4 *puVar10;

+  char cVar11;

+  int iVar12;

+  int iVar13;

+  undefined4 *puVar14;

+  undefined4 *puVar15;

+  longlong lVar16;

+  undefined8 uVar17;

+  void *_Dst;

+  uint uVar18;

+  undefined8 *puVar19;

+  undefined1 *puVar20;

+  undefined1 *puVar21;

+  uint uVar22;

+  undefined4 *puVar23;

+  bool bVar24;

+  byte bVar25;

+  undefined8 in_CR8;

+  undefined8 uStack_170;

+  undefined1 auStack_168 [8];

+  undefined1 auStack_160 [24];

+  undefined4 *local_148;

+  undefined4 **local_140;

+  uint *local_138;

+  longlong *local_130;

+  undefined4 **local_128;

+  undefined8 local_120;

+  char local_118 [8];

+  undefined4 *local_110;

+  undefined1 local_108 [4];

+  uint uStack_104;

+  longlong local_100;

+  undefined4 *local_f8;

+  undefined8 *local_f0;

+  undefined8 local_e8;

+  undefined8 local_e0;

+  undefined8 uStack_d8;

+  longlong local_d0;

+  undefined8 uStack_c8;

+  undefined8 local_c0;

+  undefined8 uStack_b8;

+  undefined8 local_b0;

+  undefined8 uStack_a8;

+  undefined8 local_a0;

+  ulonglong uStack_98;

+  undefined4 local_90;

+  undefined4 local_8c;

+  undefined8 local_88;

+  undefined8 local_80;

+  undefined4 local_78;

+  undefined4 local_74;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 uStack_58;

+  longlong local_50;

+  undefined8 uStack_48;

   

-  bVar2 = (uint)unaff_RBX < in_EAX;

-  while( true ) {

-    if (!bVar2) {

-      return 1;

+  bVar25 = (byte)in_CR8;

+  puVar20 = auStack_168;

+  puVar21 = auStack_168;

+  puVar15 = (undefined4 *)0x0;

+  local_110 = (undefined4 *)0x0;

+  local_8c = 0;

+  local_74 = 0;

+  local_108[0] = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+  local_118[0] = '\0';

+  local_118[1] = 0;

+  local_e0 = 0;

+  uStack_d8 = 0;

+  local_d0 = 0;

+  uStack_c8 = 0;

+  local_60 = 0;

+  uStack_58 = 0;

+  local_50 = 0;

+  uStack_48 = 0;

+  if (((param_3 & 8) != 0) && ((param_1[0x32] & 0x58) != 0)) {

+    return -0x3ffffff3;

+  }

+  puVar19 = param_9;

+  puVar14 = puVar15;

+  if (param_8 != 0) {

+    do {

+      cVar11 = RtlIsPackageSid(*puVar19);

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

+        return -0x3ffffff3;

+      }

+      cVar11 = RtlIsCapabilitySid(*puVar19);

+      bVar25 = (byte)in_CR8;

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

+        return -0x3ffffff3;

+      }

+      uVar22 = (int)puVar14 + 1;

+      puVar19 = puVar19 + 2;

+      puVar14 = (undefined4 *)(ulonglong)uVar22;

+    } while (uVar22 < param_8);

+  }

+  puVar14 = (undefined4 *)ExAllocatePool2(0x100,0x30,0x74416553);

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

+    return -0x3fffff66;

+  }

+  puVar23 = puVar14 + 2;

+  *puVar14 = 0;

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

+  *(undefined4 **)puVar23 = puVar23;

+  puVar23 = puVar14 + 8;

+  *(undefined4 **)(puVar14 + 10) = puVar23;

+  *(undefined4 **)puVar23 = puVar23;

+  puVar14[6] = 0;

+  if ((SeTokenLeakTracking != 0) &&

+     (puVar15 = (undefined4 *)ExAllocatePool2(0x100,0x120,0x74416553), puVar15 == (undefined4 *)0x0)

+     ) {

+LAB_0:

+    ExFreePoolWithTag(puVar14,0);

+    return -0x3fffff66;

+  }

+  lVar16 = ExAllocatePool2(0x40);

+  if (lVar16 == 0) {

+    ExFreePoolWithTag(puVar14,0);

+    puVar14 = puVar15;

+    if (SeTokenLeakTracking == 0) {

+      return -0x3fffff66;

     }

-    uVar1 = *(uint *)(unaff_RBX + 0x10 + (ulonglong)in_R11D * 4);

-    if (((unaff_EDI < uVar1) || (unaff_EDI - uVar1 < 8)) ||

-       (1 < *(ulonglong *)((ulonglong)uVar1 + unaff_RBX))) break;

-    in_R11D = in_R11D + 1;

-    bVar2 = in_R11D < param_3;

+    goto LAB_0;

   }

-  return 0;

+  uVar22 = param_10 + param_1[0x21];

+  if ((uint)param_1[0x21] <= uVar22) {

+    uVar18 = uVar22 + 4;

+    uStack_104 = 0xffffffff;

+    if ((uVar22 <= uVar18) && (uVar22 = uVar22 + 0x49c, uStack_104 = uVar18, 0x497 < uVar22)) {

+      local_120 = 0;

+      local_88 = 0;

+      local_78 = 0;

+      local_80 = 0;

+      local_128 = &local_110;

+      local_130 = (longlong *)CONCAT44(local_130._4_4_,uVar22);

+      local_138 = (uint *)CONCAT44(local_138._4_4_,param_1[0x22]);

+      local_140 = (undefined4 **)CONCAT44(local_140._4_4_,uVar22);

+      local_90 = 0x30;

+      local_70 = 0;

+      uStack_68 = 0;

+      iVar12 = ObCreateObjectEx(CONCAT71((int7)((ulonglong)local_128 >> 8),param_2),

+                                SeTokenObjectType,0,param_2);

+      puVar23 = local_110;

+      if (iVar12 < 0) {

+        ExFreePoolWithTag(lVar16,0);

+        ExFreePoolWithTag(puVar14,0);

+        goto LAB_1;

+      }

+      *(longlong *)(local_110 + 0xc) = lVar16;

+      ExInitializeResourceLite(lVar16);

+      puVar10 = local_110;

+      LOCK();

+      UNLOCK();

+      lVar16 = ExpLuid + 1;

+      ExpLuid = ExpLuid + 1;

+      *(longlong *)(puVar23 + 0xe) = lVar16;

+      LOCK();

+      UNLOCK();

+      lVar16 = ExpLuid + 1;

+      ExpLuid = ExpLuid + 1;

+      *(longlong *)(local_110 + 4) = lVar16;

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

+      *(undefined8 *)(local_110 + 6) = *(undefined8 *)(param_1 + 6);

+      uVar5 = param_1[1];

+      uVar8 = param_1[2];

+      uVar9 = param_1[3];

+      *local_110 = *param_1;

+      local_110[1] = uVar5;

+      local_110[2] = uVar8;

+      local_110[3] = uVar9;

+      local_110[0x23] = 0;

+      local_110[0x20] = 0;

+      local_110[0x21] = uVar18;

+      *(undefined8 *)(local_110 + 8) = *(undefined8 *)(param_1 + 4);

+      local_110[0x30] = param_1[0x30];

+      local_110[0x31] = param_1[0x31];

+      *(undefined8 *)(local_110 + 10) = *(undefined8 *)(param_1 + 10);

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

+      *(undefined8 *)(local_110 + 0x118) = 0;

+      *(undefined8 *)(local_110 + 0x11a) = 0;

+      *(undefined8 *)(local_110 + 0x112) = 0;

+      *(undefined4 **)(local_110 + 0x11e) = puVar15;

+      local_110[0x1e] = 0;

+      *(undefined8 *)(local_110 + 0x122) = 0;

+      if ((SeTokenLeakTracking != 0) &&

+         (uVar22 = RtlWalkFrameChain(puVar15 + 10,0x1e,0), bVar25 < 2)) {

+        RtlWalkFrameChain(*(longlong *)(puVar10 + 0x11e) + 0x28 + (ulonglong)uVar22 * 8,

+                          0x1e - uVar22,1);

+      }

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

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

+      ExAcquireResourceSharedLite(*(undefined8 *)(param_1 + 0xc),1);

+      puVar15 = local_110;

+      local_148 = (undefined4 *)0x0;

+      local_110[0x22] = param_1[0x22];

+      local_110[0x24] = param_1[0x24];

+      SepSetTokenSessionById(local_110,param_1[0x1e],0,0);

+      puVar10[0x1e] = param_1[0x1e];

+      iVar12 = Feature_2045735225__private_IsEnabledDeviceUsageNoInline();

+      if (iVar12 == 0) {

+        uVar22 = param_1[0x32] & 0xfffffbd7;

+      }

+      else {

+        uVar22 = param_1[0x32] & 0xeffffbd7;

+      }

+      puVar2 = puVar15 + 0x32;

+      puVar15[0x32] = uVar22;

+      if ((*puVar2 & 0x1000000) != 0) {

+        LOCK();

+        SepLearningModeTokenCount = SepLearningModeTokenCount + 1;

+        UNLOCK();

+        puVar15 = local_110;

+      }

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

+      *(undefined8 *)(puVar15 + 0x16) = *(undefined8 *)(param_1 + 0x16);

+      *(undefined8 *)(puVar15 + 0x18) = uVar17;

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

+      *(undefined8 *)(puVar15 + 0x1a) = *(undefined8 *)(param_1 + 0x1a);

+      *(undefined8 *)(puVar15 + 0x1c) = uVar17;

+      puVar15[0x34] = param_1[0x34];

+      puVar15[0x35] = param_1[0x35];

+      uVar5 = param_1[0x11];

+      uVar8 = param_1[0x12];

+      uVar9 = param_1[0x13];

+      puVar15[0x10] = param_1[0x10];

+      puVar15[0x11] = uVar5;

+      puVar15[0x12] = uVar8;

+      puVar15[0x13] = uVar9;

+      *(undefined8 *)(puVar15 + 0x14) = *(undefined8 *)(param_1 + 0x14);

+      iVar12 = Feature_ShadowAdminAppCompat__private_IsEnabledDeviceUsageNoInline();

+      if (iVar12 != 0) {

+        *(undefined8 *)(puVar15 + 0x124) = *(undefined8 *)(param_1 + 0x124);

+      }

+      *(undefined4 **)(puVar15 + 0xc2) = puVar14;

+      if (*(char *)((longlong)puVar15 + 0x77) == '\x02') {

+        SepModifyTokenPolicyCounter(puVar15 + 0x16);

+      }

+      *(undefined8 *)(puVar15 + 0x10e) = 0;

+      *(undefined8 *)(puVar15 + 0x110) = 0;

+      *(undefined8 *)(puVar15 + 0x120) = 0;

+      *(undefined8 *)(puVar15 + 0xc6) = 0;

+      *(undefined8 *)(puVar15 + 0xc4) = 0;

+      puVar15[200] = 0;

+      memset(puVar15 + 0xca,0,0x110);

+      *(undefined8 *)(puVar15 + 0x2c) = 0;

+      *(undefined8 *)(puVar15 + 0x114) = 0;

+      *(undefined8 *)(puVar15 + 0x116) = 0;

+      *(undefined8 *)(puVar15 + 0x11c) = 0;

+      iVar12 = SepDuplicateLogonSessionReference(puVar15,param_1);

+      if (iVar12 < 0) {

+LAB_2:

+        ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+        KeLeaveCriticalRegion();

+        ObfDereferenceObject(puVar15);

+        return iVar12;

+      }

+      iVar12 = Feature_2045735225__private_IsEnabledDeviceUsageNoInline();

+      if ((iVar12 != 0) && ((param_1[0x32] & 0x10000000) != 0)) {

+        local_e8 = 0;

+        iVar12 = SepReferenceLogonSession(*(longlong *)(puVar15 + 0x36) + 0x10,&local_e8);

+        if (iVar12 < 0) goto LAB_2;

+        *puVar2 = *puVar2 | 0x10000000;

+      }

+      SepRefDerefLuidToIndexEntryIfNecessary(param_1,0);

+      *(undefined8 *)(puVar15 + 0x11c) = *(undefined8 *)(param_1 + 0x11c);

+      if (((**(int **)(param_1 + 0xc2) != 0) &&

+          (iVar12 = AuthzBasepDuplicateSecurityAttributes

+                              (*(int **)(param_1 + 0xc2),*(undefined8 *)(puVar15 + 0xc2),0),

+          iVar12 < 0)) ||

+         ((*(longlong *)(param_1 + 0x112) != 0 &&

+          (iVar12 = SepDuplicateTokenClaims(param_1,puVar15), iVar12 < 0)))) goto LAB_2;

+      puVar14 = local_110;

+      if (SeTokenLeakTracking != 0) {

+        **(undefined8 **)(puVar10 + 0x11e) = *(undefined8 *)((longlong)SystemReserved1[0xf] + 0x508)

+        ;

+        *(undefined8 *)(*(longlong *)(puVar10 + 0x11e) + 8) =

+             *(undefined8 *)((longlong)SystemReserved1[0xf] + 0x510);

+        *(undefined4 *)(*(longlong *)(puVar10 + 0x11e) + 0x20) = 0xf;

+        *(undefined4 *)(*(longlong *)(puVar10 + 0x11e) + 0x118) = 0;

+        *(undefined4 *)(*(longlong *)(puVar10 + 0x11e) + 0x11c) = 0;

+        lVar16 = *(longlong *)(puVar10 + 0x11e);

+        lVar6 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+        *(undefined8 *)(lVar16 + 0x10) = *(undefined8 *)(lVar6 + 0x338);

+        *(undefined4 *)(lVar16 + 0x18) = *(undefined4 *)(lVar6 + 0x340);

+        *(undefined2 *)(lVar16 + 0x1c) = *(undefined2 *)(lVar6 + 0x344);

+        *(undefined1 *)(lVar16 + 0x1e) = *(undefined1 *)(lVar6 + 0x346);

+        SepAddTokenLogonSession(local_110);

+        puVar15 = puVar14;

+      }

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

+        uVar17 = PsReferencePrimaryTokenWithTag

+                           (*(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8),0x746c6644);

+        iVar12 = SeIsSystemContext(uVar17,local_118);

+        if ((-1 < iVar12) && (local_118[0] != '\0')) {

+          *puVar2 = *puVar2 | 0x40;

+        }

+        ObfDereferenceObject(uVar17);

+        puVar15 = local_110;

+      }

+      puVar14 = puVar15 + 0x126;

+      if (((ulonglong)puVar14 & 7) != 0) {

+        uStack_104 = 8 - ((uint)puVar14 & 7);

+        puVar14 = (undefined4 *)((longlong)puVar14 + (ulonglong)uStack_104);

+        uStack_104 = uVar18 - uStack_104;

+      }

+      uVar22 = param_1[0x20];

+      iVar12 = param_1[0x1f];

+      *(undefined4 **)(puVar15 + 0x26) = puVar14;

+      uVar18 = param_8;

+      if (param_8 < uVar22) {

+        uVar18 = uVar22;

+      }

+      puVar23 = puVar14 + (ulonglong)(iVar12 + uVar18) * 4;

+      local_f8 = puVar23;

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

+        puVar15[0x1f] = param_1[0x1f];

+        local_138 = &uStack_104;

+        local_140 = &local_f8;

+        local_148 = puVar23;

+        iVar12 = RtlCopySidAndAttributesArray

+                           (param_1[0x1f],*(undefined8 *)(param_1 + 0x26),uStack_104,puVar14);

+        puVar23 = local_f8;

+LAB_3:

+        uVar22 = 0;

+        lVar16 = (longlong)puVar14 + (ulonglong)(uint)(param_1[0x1f] << 4);

+        *(longlong *)(puVar15 + 0x28) = lVar16;

+        if (param_8 != 0) {

+          local_f0 = param_9;

+          do {

+            if ((param_1[0x20] == 0) ||

+               (cVar11 = SepSidInSidAndAttributes(*(undefined8 *)(param_1 + 0x28)), cVar11 != '\0'))

+            {

+              local_138 = &uStack_104;

+              local_140 = &local_f8;

+              local_148 = puVar23;

+              iVar12 = RtlCopySidAndAttributesArray

+                                 (1,param_9 + (ulonglong)uVar22 * 2,uStack_104,lVar16);

+              lVar16 = lVar16 + 0x10;

+              *(undefined4 *)

+               (*(longlong *)(puVar15 + 0x28) + 8 + (ulonglong)(uint)puVar10[0x20] * 0x10) = 7;

+              puVar10[0x20] = puVar10[0x20] + 1;

+              puVar23 = local_f8;

+            }

+            uVar22 = uVar22 + 1;

+            local_f0 = local_f0 + 2;

+          } while (uVar22 < param_8);

+        }

+        uVar22 = (uint)*(byte *)(*(longlong *)(param_1 + 0x2a) + 1) * 4 + 8;

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

+          uVar22 = uVar22 + *(ushort *)(*(longlong *)(param_1 + 0x2e) + 2);

+        }

+        _Dst = (void *)ExAllocatePool2(0x100,uVar22,0x64546553);

+        *(void **)(puVar15 + 0x2c) = _Dst;

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

+          ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+          iVar12 = -0x3fffff66;

+          puVar21 = auStack_168;

+          goto LAB_4;

+        }

+        if ((param_1[0x20] != 0) && (puVar15[0x20] == 0)) {

+          ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+          iVar12 = -0x3ffffff3;

+          goto LAB_4;

+        }

+        if (puVar15[0x20] == 0) {

+          *(undefined8 *)(puVar15 + 0x28) = 0;

+        }

+        else {

+          puVar15[0x32] = puVar15[0x32] | 0x810;

+        }

+        bVar24 = (param_3 & 8) != 0;

+        if (bVar24) {

+          puVar15[0x32] = puVar15[0x32] | 0x18;

+        }

+        if (bVar24 || puVar15[0x20] != 0) {

+          local_100 = 0;

+          local_a0 = 0;

+          uStack_98 = uStack_98 & 0xffffffff00000000;

+          local_c0 = 0;

+          uStack_b8 = 0;

+          local_b0 = 0;

+          uStack_a8 = 0;

+          if ((*(longlong *)(*(longlong *)(param_1 + 0x36) + 0x38) == 0) &&

+             ((param_1[0x32] & 0x18) == 0)) {

+            local_130 = &local_100;

+            local_c0 = 0x30;

+            local_138 = (uint *)((ulonglong)local_138 & 0xffffffffffffff00);

+            local_140 = (undefined4 **)((ulonglong)local_140 & 0xffffffffffffff00);

+            local_148 = (undefined4 *)((ulonglong)local_148 & 0xffffffff00000000);

+            uStack_b8 = 0;

+            uStack_a8 = 0;

+            local_b0 = 0;

+            local_a0 = 0;

+            uStack_98 = 0;

+            iVar13 = SepDuplicateToken(param_1,&local_c0,0,1);

+            if (-1 < iVar13) {

+              iVar13 = SepStopReferencingLogonSession(local_100);

+              if (iVar13 < 0) {

+                ObfDereferenceObject();

+              }

+              else {

+                LOCK();

+                bVar24 = *(longlong *)(*(longlong *)(param_1 + 0x36) + 0x38) == 0;

+                if (bVar24) {

+                  *(longlong *)(*(longlong *)(param_1 + 0x36) + 0x38) = local_100;

+                }

+                UNLOCK();

+                puVar15 = local_110;

+                if (!bVar24) {

+                  ObfDereferenceObject(local_100);

+                  puVar15 = local_110;

+                }

+              }

+            }

+          }

+        }

+        RtlCopyMemory(_Dst,*(void **)(param_1 + 0x2c),(ulonglong)uVar22);

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

+          *(undefined8 *)(puVar15 + 0x2e) = 0;

+        }

+        else {

+          *(ulonglong *)(puVar15 + 0x2e) =

+               (ulonglong)(uint)(param_1[0x2e] - param_1[0x2c]) + (longlong)_Dst;

+        }

+        iVar13 = param_1[0x2a];

+        iVar4 = param_1[0x2c];

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

+          iVar12 = SepSetTokenCapabilities

+                             (puVar15,*(undefined8 *)(param_1 + 0xc4),

+                              *(undefined8 *)(param_1 + 0xc6));

+        }

+        if ((-1 < iVar12) &&

+           ((*(longlong *)(param_1 + 0xc4) == 0 ||

+            (iVar12 = SepSetTokenPackage(puVar15), -1 < iVar12)))) {

+          uVar17 = 0xe;

+          lVar16 = 1;

+          puVar21 = auStack_168;

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

+            LOCK();

+            plVar1 = (longlong *)(*(longlong *)(param_1 + 0x10e) + 0x18);

+            lVar6 = *plVar1;

+            *plVar1 = *plVar1 + 1;

+            UNLOCK();

+            if (lVar6 + 1 < 2) {

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

+              (*pcVar7)(0xe);

+              puVar20 = auStack_160;

+            }

+            puVar15 = *(undefined4 **)(puVar20 + 0x58);

+            *(undefined8 *)(puVar15 + 0x10e) = *(undefined8 *)(param_1 + 0x10e);

+            puVar21 = puVar20;

+          }

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

+            LOCK();

+            plVar1 = (longlong *)(*(longlong *)(param_1 + 0x110) + 0x18);

+            lVar6 = *plVar1;

+            *plVar1 = *plVar1 + lVar16;

+            UNLOCK();

+            if (lVar6 + lVar16 <= lVar16) {

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

+              (*pcVar7)(uVar17);

+              puVar21 = puVar21 + 8;

+            }

+            puVar15 = *(undefined4 **)(puVar21 + 0x58);

+            *(undefined8 *)(puVar15 + 0x110) = *(undefined8 *)(param_1 + 0x110);

+          }

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

+            LOCK();

+            plVar1 = (longlong *)(*(longlong *)(param_1 + 0x120) + 0x18);

+            lVar6 = *plVar1;

+            *plVar1 = *plVar1 + lVar16;

+            UNLOCK();

+            if (lVar6 + lVar16 <= lVar16) {

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

+              (*pcVar7)(uVar17);

+              puVar21 = puVar21 + 8;

+            }

+            puVar15 = *(undefined4 **)(puVar21 + 0x58);

+            *(undefined8 *)(puVar15 + 0x120) = *(undefined8 *)(param_1 + 0x120);

+          }

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

+          *(undefined8 *)(puVar21 + -8) = 0x14098ce05;

+          iVar12 = SepSetTokenTrust(puVar15,uVar17);

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

+          if (-1 < iVar12) {

+            *(undefined8 *)(puVar21 + -8) = 0x14098ce2f;

+            ExReleaseResourceLite(uVar17);

+            *(undefined8 *)(puVar21 + -8) = 0x14098ce34;

+            KeLeaveCriticalRegion();

+            *(ulonglong *)(puVar15 + 0x2a) = (ulonglong)(uint)(iVar13 - iVar4) + (longlong)_Dst;

+            *(undefined8 *)(puVar21 + 0x28) = param_7;

+            *(undefined4 *)(puVar21 + 0x20) = param_6;

+            *(undefined8 *)(puVar21 + -8) = 0x14098ce70;

+            SepRemoveDisabledGroupsAndPrivileges(puVar15,param_3,param_4,param_5);

+            uVar5 = puVar15[0x1f];

+            uVar17 = *(undefined8 *)(puVar15 + 0x26);

+            *(undefined8 *)(puVar21 + -8) = 0x14098ce86;

+            RtlSidHashInitialize(uVar17,uVar5,puVar15 + 0x3a);

+            uVar5 = puVar15[0x20];

+            uVar17 = *(undefined8 *)(puVar15 + 0x28);

+            *(undefined8 *)(puVar21 + -8) = 0x14098ce9f;

+            RtlSidHashInitialize(uVar17,uVar5,puVar15 + 0x7e);

+            *(undefined8 *)(puVar21 + -8) = 0x14098cea8;

+            SeCaptureSubjectContext(&local_e0);

+            uVar3 = puVar21[0x60];

+            local_50 = local_d0;

+            *(undefined8 *)(puVar21 + -8) = 0x14098cebf;

+            cVar11 = RtlIsSandboxedToken(&local_e0,uVar3);

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

+              *(undefined8 *)(puVar21 + -8) = 0x14098cece;

+              cVar11 = RtlIsSandboxedToken(&local_60,uVar3);

+              lVar16 = local_d0;

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

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

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

+                uVar17 = *(undefined8 *)(local_d0 + 0x30);

+                *(undefined8 *)(puVar21 + -8) = 0x14098cef2;

+                ExAcquireResourceSharedLite(uVar17,1);

+                puVar15 = *(undefined4 **)(puVar21 + 0x58);

+                *(undefined8 *)(puVar21 + -8) = 0x14098cf07;

+                iVar12 = SepNewTokenAsRestrictedAsProcessToken(puVar15,lVar16,puVar21 + 0x51);

+                uVar17 = *(undefined8 *)(lVar16 + 0x30);

+                *(undefined8 *)(puVar21 + -8) = 0x14098cf13;

+                ExReleaseResourceLite(uVar17);

+                *(undefined8 *)(puVar21 + -8) = 0x14098cf18;

+                KeLeaveCriticalRegion();

+                if ((iVar12 < 0) || (puVar21[0x51] == '\0')) {

+                  *(undefined8 *)(puVar21 + -8) = 0x14098cf2c;

+                  ObfDereferenceObject(puVar15);

+                  *(undefined8 *)(puVar21 + -8) = 0x14098cf35;

+                  SeReleaseSubjectContext(&local_e0);

+                  return iVar12;

+                }

+              }

+            }

+            *(undefined8 *)(puVar21 + -8) = 0x14098cf43;

+            SeReleaseSubjectContext(&local_e0);

+            lVar16 = *(longlong *)(puVar15 + 0xc6);

+            if (lVar16 != 0) {

+              uVar5 = puVar15[200];

+              *(undefined8 *)(puVar21 + -8) = 0x14098cf61;

+              RtlSidHashInitialize(lVar16,uVar5,puVar15 + 0xca);

+            }

+            if ((SeTokenLeakTracking != 0) && (SepTokenLeakMethodWatch == 0xf)) {

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

+                  SepTokenLeakProcessCid) {

+                LOCK();

+                UNLOCK();

+                puVar15 = *(undefined4 **)(puVar21 + 0x58);

+                iVar13 = SepTokenLeakMethodCount + 1;

+                SepTokenLeakMethodCount = SepTokenLeakMethodCount + 1;

+                *(int *)(*(longlong *)(puVar15 + 0x11e) + 0x118) = iVar13;

+                iVar13 = *(int *)(*(longlong *)(puVar15 + 0x11e) + 0x118);

+                if (SepTokenLeakBreakCount <= iVar13) {

+                    /* WARNING: Subroutine does not return */

+                  *(undefined **)(puVar21 + -8) = &UNK_5;

+                  DbgPrint("\nToken number 0x%x = 0x%p\n",iVar13,puVar15);

+                }

+              }

+              else {

+                puVar15 = *(undefined4 **)(puVar21 + 0x58);

+              }

+            }

+            *param_11 = (longlong)puVar15;

+            return iVar12;

+          }

+          *(undefined8 *)(puVar21 + -8) = 0x14098ce15;

+          ExReleaseResourceLite(uVar17);

+          goto LAB_4;

+        }

+      }

+      else {

+        iVar12 = SepDuplicateTokenUserAndGroups(param_1,puVar15);

+        if (-1 < iVar12) goto LAB_3;

+        *(undefined8 *)(puVar15 + 0x26) = 0;

+      }

+      ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+      puVar21 = auStack_168;

+LAB_4:

+      *(undefined8 *)(puVar21 + -8) = 0x14098ce1d;

+      KeLeaveCriticalRegion();

+      *(undefined8 *)(puVar21 + -8) = 0x14098ce25;

+      ObfDereferenceObject(puVar15);

+      return iVar12;

+    }

+  }

+  iVar12 = -0x3fffff6b;

+  ExFreePoolWithTag(lVar16,0);

+  ExFreePoolWithTag(puVar14,0);

+LAB_1:

+  if (SeTokenLeakTracking != 0) {

+    ExFreePoolWithTag(puVar15,0);

+    return iVar12;

+  }

+  return iVar12;

 }
```

## `FsRtlpOplockFsctrlInternal`  (modified)

```diff
--- FsRtlpOplockFsctrlInternal
+++ FsRtlpOplockFsctrlInternal
@@ -1,30 +1,283 @@
 

-/* WARNING: Instruction at (ram,0x000140a16253) overlaps instruction at (ram,0x000140a16250)

-    */

-

-undefined4 FsRtlpOplockFsctrlInternal(void)

+ulonglong FsRtlpOplockFsctrlInternal

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

+                    undefined4 param_5)

 

 {

-  longlong lVar1;

-  char in_AL;

-  byte bVar2;

-  undefined4 unaff_EDI;

-  char in_CF;

-  char in_stack_00000050;

+  char *pcVar1;

+  ushort *puVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  char cVar6;

+  uint uVar7;

+  uint uVar8;

+  uint uVar9;

+  longlong lVar10;

+  uint uVar11;

+  longlong *plVar12;

+  uint uVar13;

+  int iVar14;

+  ulonglong uVar15;

+  undefined8 uVar16;

+  undefined8 local_res10;

+  undefined4 local_res20;

+  undefined8 in_stack_ffffffffffffff88;

+  undefined8 in_stack_ffffffffffffff90;

+  undefined4 uVar17;

+  uint in_stack_ffffffffffffff98;

+  longlong local_48 [2];

   

-  cRambffffffea6e9ff80 = in_AL + 'O' + in_CF;

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

-    LOCK();

-    lVar1 = PopBlackBoxLock + 0xffffffff;

-    UNLOCK();

-    bVar2 = (byte)PopBlackBoxLock;

-    PopBlackBoxLock = lVar1;

-    if ((bVar2 & 6) == 2) {

-      ExfTryToWakePushLock(&PopBlackBoxLock);

-    }

-    KeAbPostRelease(&PopBlackBoxLock);

-    KeLeaveCriticalRegion();

-  }

-  return unaff_EDI;

+  uVar17 = (undefined4)((ulonglong)in_stack_ffffffffffffff90 >> 0x20);

+  uVar8 = (uint)((ulonglong)in_stack_ffffffffffffff88 >> 0x20);

+  lVar10 = 0;

+  local_48[0] = 0;

+  pcVar1 = *(char **)(param_2 + 0xb8);

+  local_res20 = param_4;

+  if (*pcVar1 == '\0') {

+    if ((*(uint *)(pcVar1 + 0x10) >> 0x14 & 1) == 0) {

+      if ((*(uint *)(pcVar1 + 0x10) >> 0x10 & 1) == 0) {

+        return 0;

+      }

+      uVar8 = FsRtlpAttachOplockKey(param_2);

+      if (uVar8 != 0) {

+        return (ulonglong)uVar8;

+      }

+      lVar10 = *param_1;

+      if (lVar10 == 0) {

+        lVar10 = FsRtlpAllocateOplock();

+        *param_1 = lVar10;

+      }

+      local_res10 = lVar10;

+      ExAcquireFastMutexUnsafe(*(undefined8 *)(lVar10 + 0x98));

+      uVar8 = FsRtlCheckOplockEx(param_1,param_2,0x30000000,0,0,0);

+      if (uVar8 == 0) {

+        local_48[0] = ExAllocatePool2(0x120,0x60,0x6f725346);

+        uVar8 = FsRtlpRequestShareableOplock(param_1,pcVar1,0,0x10000,local_48,0,0,param_5);

+      }

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

+        lVar3 = *(longlong *)(local_48[0] + 0x28);

+        *(undefined8 *)(local_48[0] + 0x28) = 0;

+        *(undefined8 *)(local_48[0] + 0x20) = 0;

+        if (lVar3 != 0) {

+          ObDereferenceObjectDeferDelete();

+        }

+        FsRtlpFreeRHOpContext(local_48[0],0);

+      }

+      ExReleaseFastMutexUnsafe(*(undefined8 *)(lVar10 + 0x98));

+      return (ulonglong)uVar8;

+    }

+    if (((param_3 != 1) || ((*(uint *)(*(longlong *)(pcVar1 + 8) + 0x10) & 0xffffff7f) != 0)) ||

+       ((pcVar1[0x1a] & 7U) != 7)) {

+      return 0xc00000e2;

+    }

+    uVar9 = FsRtlpAttachOplockKey(param_2);

+    if (uVar9 != 0) {

+      return (ulonglong)uVar9;

+    }

+    uVar8 = FsRtlpRequestExclusiveOplock(param_1,pcVar1,0,1,(ulonglong)uVar8 << 0x20,200,param_5);

+    goto LAB_0;

+  }

+  iVar14 = 2;

+  if (*(int *)(pcVar1 + 0x18) == 0x90240) {

+    puVar2 = *(ushort **)(param_2 + 0x18);

+    if ((*(uint *)(pcVar1 + 0x10) < 0xc) || (*(uint *)(pcVar1 + 8) < 0x18)) {

+      uVar15 = 0xc0000023;

+    }

+    else {

+      if (*puVar2 < 2) {

+        if ((*(uint *)(puVar2 + 4) & 1) != 0) {

+          uVar9 = *(uint *)(puVar2 + 2);

+          uVar11 = (uVar9 & 1) << 0xc;

+          local_res10 = CONCAT44(local_res10._4_4_,uVar9) & 0xffffffff00000004;

+          uVar13 = (uVar9 & 2) << 0xc;

+          uVar7 = -(uint)((uVar9 & 4) != 0) & 0x4000 | uVar13 | uVar11;

+          if (uVar7 == 0x3000) {

+LAB_1:

+            if (((param_3 == 0) && (cVar6 = IoIsOperationSynchronous(param_2), cVar6 == '\0')) &&

+               ((*(uint *)(*(longlong *)(pcVar1 + 0x30) + 0x50) & 0x4000) == 0)) {

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

+                lVar10 = ExAllocatePool2(0x120,0x60,0x6f725346);

+                uVar9 = *(uint *)(puVar2 + 2);

+                local_48[0] = lVar10;

+              }

+              plVar12 = local_48;

+              if (lVar10 == 0) {

+                plVar12 = (longlong *)0x0;

+              }

+              uVar8 = FsRtlpRequestShareableOplock

+                                (param_1,pcVar1,param_2,(uVar9 & 7) << 0xc,plVar12,1,

+                                 in_stack_ffffffffffffff98 & 0xffffff00,param_5);

+              if (local_48[0] == 0) {

+                return (ulonglong)uVar8;

+              }

+              lVar10 = *(longlong *)(local_48[0] + 0x28);

+              *(undefined8 *)(local_48[0] + 0x28) = 0;

+              *(undefined8 *)(local_48[0] + 0x20) = 0;

+              if (lVar10 != 0) {

+                ObDereferenceObjectDeferDelete();

+              }

+              FsRtlpFreeRHOpContext(local_48[0],0);

+              return (ulonglong)uVar8;

+            }

+          }

+          else {

+            if (uVar7 == 0) {

+              lVar10 = *param_1;

+              if (((lVar10 != 0) && (local_res10 = 0, (*(uint *)(lVar10 + 0x90) & 0x10000) != 0)) &&

+                 (cVar6 = FsRtlpCallerIsAtomicRequestor

+                                    (lVar10,*(undefined8 *)(pcVar1 + 0x30),&local_res10),

+                 uVar15 = local_res10, cVar6 != '\0')) {

+                FsRtlpOplockDequeueRH(local_res10);

+                plVar12 = (longlong *)(uVar15 + 0x38);

+                lVar3 = *plVar12;

+                plVar4 = *(longlong **)(uVar15 + 0x40);

+                if ((*(longlong **)(lVar3 + 8) != plVar12) || ((longlong *)*plVar4 != plVar12)) {

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

+                  (*pcVar5)(3);

+                  KeAbPostRelease(uVar15);

+                  return param_2 & 0xffffffff;

+                }

+                *plVar4 = lVar3;

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

+                if (*(longlong **)(lVar10 + 0x78) == (longlong *)(lVar10 + 0x78)) {

+                  *(uint *)(lVar10 + 0x90) = *(uint *)(lVar10 + 0x90) & 0xfffcffff;

+                }

+                if (*(longlong *)(uVar15 + 0x28) != 0) {

+                  FsRtlpClearOwner(lVar10,uVar15);

+                }

+                FsRtlpFreeRHOpContext(uVar15,1);

+                FsRtlpComputeShareableOplockState(lVar10);

+                FsRtlpReleaseIrpsWaitingForRH(lVar10);

+              }

+              goto LAB_2;

+            }

+            if (uVar7 != 0x7000) {

+              if (uVar7 == 0x1000) goto LAB_1;

+              if (uVar7 != 0x5000) goto switchD_1409eab77_caseD_90001;

+            }

+            cVar6 = IoIsOperationSynchronous(param_2);

+            if ((cVar6 == '\0') && ((*(uint *)(*(longlong *)(pcVar1 + 0x30) + 0x50) & 0x4000) == 0))

+            {

+              uVar9 = 0x4040;

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

+                uVar9 = 0x40;

+              }

+              uVar8 = FsRtlpRequestExclusiveOplock

+                                (param_1,pcVar1,param_2,param_3,CONCAT44(uVar8,local_res20),

+                                 uVar9 | uVar13 | uVar11,param_5);

+              goto LAB_0;

+            }

+          }

+          goto LAB_3;

+        }

+        if ((*(uint *)(puVar2 + 4) & 2) != 0) {

+          uVar8 = *(uint *)(puVar2 + 2);

+          uVar9 = uVar8 & 7;

+          if (((uVar9 == 7) || ((uVar8 & 7) == 0)) ||

+             ((uVar9 == 1 || ((uVar9 == 3 || (uVar9 == 5)))))) {

+            cVar6 = IoIsOperationSynchronous(param_2);

+            if (cVar6 != '\0') goto switchD_1409eab77_caseD_90001;

+            if ((*(uint *)(*(longlong *)(pcVar1 + 0x30) + 0x50) & 0x4000) == 0) {

+              if (((uVar8 & 7) >> 1 & 1) != 0) {

+                lVar10 = ExAllocatePool2(0x120,0x60,0x6f725346);

+                uVar8 = *(uint *)(puVar2 + 2);

+                local_48[0] = lVar10;

+              }

+              plVar12 = local_48;

+              if (lVar10 == 0) {

+                plVar12 = (longlong *)0x0;

+              }

+              uVar8 = FsRtlpAcknowledgeOplockBreakByCacheFlags

+                                (*param_1,pcVar1,param_2,(uVar8 & 7) << 0xc,plVar12,

+                                 CONCAT44(uVar17,param_5));

+              if (local_48[0] == 0) {

+                return (ulonglong)uVar8;

+              }

+              FsRtlpClearOwner(*param_1);

+              FsRtlpFreeRHOpContext(local_48[0],0);

+              return (ulonglong)uVar8;

+            }

+            puVar2[0] = 0;

+            puVar2[1] = 0;

+            puVar2[2] = 0;

+            puVar2[3] = 0;

+            puVar2[4] = 0;

+            puVar2[5] = 0;

+            puVar2[6] = 0;

+            puVar2[7] = 0;

+            puVar2[8] = 0;

+            puVar2[9] = 0;

+            puVar2[10] = 0;

+            puVar2[0xb] = 0;

+            puVar2[0] = 1;

+            puVar2[1] = 0x18;

+            *(undefined8 *)(param_2 + 0x38) = 0x18;

+LAB_2:

+            *(undefined4 *)(param_2 + 0x30) = 0;

+            IofCompleteRequest(param_2,1);

+            return 0;

+          }

+        }

+      }

+      uVar15 = 0xc000000d;

+    }

+    *(int *)(param_2 + 0x30) = (int)uVar15;

+    goto LAB_4;

+  }

+  switch(*(int *)(pcVar1 + 0x18)) {

+  case 0x90000:

+    goto switchD_1409eab77_caseD_90000;

+  default:

+switchD_1409eab77_caseD_90001:

+    *(undefined4 *)(param_2 + 0x30) = 0xc000000d;

+    IofCompleteRequest(param_2,1);

+    return 0xc000000d;

+  case 0x90004:

+    if ((((param_3 == 0) && (cVar6 = IoIsOperationSynchronous(param_2), cVar6 == '\0')) &&

+        ((*(uint *)(param_2 + 0x10) & 0x40) == 0)) &&

+       ((*(uint *)(*(longlong *)(pcVar1 + 0x30) + 0x50) & 0x4000) == 0)) {

+      uVar8 = FsRtlpRequestShareableOplock

+                        (param_1,pcVar1,param_2,0x10,0,1,in_stack_ffffffffffffff98 & 0xffffff00,

+                         param_5);

+      goto LAB_0;

+    }

+    goto LAB_3;

+  case 0x9000c:

+    uVar16 = 1;

+    break;

+  case 0x90010:

+    uVar8 = FsRtlpOpBatchBreakClosePending(*param_1,pcVar1,param_2);

+    goto LAB_0;

+  case 0x90014:

+    uVar8 = FsRtlpOplockBreakNotify(*param_1,&switchD_1402e6bd6::caseD_4,param_2);

+    goto LAB_0;

+  case 0x90050:

+    uVar16 = 0;

+    break;

+  case 0x9005c:

+    iVar14 = 4;

+  case 0x90008:

+    iVar14 = iVar14 * 2;

+    goto switchD_1409eab77_caseD_90000;

+  }

+  uVar8 = FsRtlpAcknowledgeOplockBreak(*param_1,pcVar1,param_2,uVar16,CONCAT44(uVar8,param_5));

+LAB_0:

+  return (ulonglong)uVar8;

+switchD_1409eab77_caseD_90000:

+  if (((param_3 == 1) && (cVar6 = IoIsOperationSynchronous(param_2), cVar6 == '\0')) &&

+     (((*(uint *)(param_2 + 0x10) & 0x40) == 0 &&

+      ((*(uint *)(*(longlong *)(pcVar1 + 0x30) + 0x50) & 0x4000) == 0)))) {

+    uVar8 = FsRtlpRequestExclusiveOplock

+                      (param_1,pcVar1,param_2,1,(ulonglong)uVar8 << 0x20,

+                       CONCAT44(uVar17,iVar14) | 0x40,param_5);

+    return (ulonglong)uVar8;

+  }

+LAB_3:

+  uVar15 = 0xc00000e2;

+  *(undefined4 *)(param_2 + 0x30) = 0xc00000e2;

+LAB_4:

+  IofCompleteRequest(param_2,1);

+  return uVar15;

 }
```

## `IopAllocateAndPopulateWriteIrp`  (modified)

```diff
--- IopAllocateAndPopulateWriteIrp
+++ IopAllocateAndPopulateWriteIrp
@@ -1,149 +1,144 @@
 

-byte IopAllocateAndPopulateWriteIrp(char param_1,undefined8 param_2)

+undefined8 IopAllocateAndPopulateWriteIrp(undefined8 *param_1,longlong *param_2)

 

 {

-  undefined4 in_EAX;

-  int iVar1;

-  uint uVar2;

-  char cVar3;

-  int iVar4;

-  ulonglong unaff_RBX;

-  char unaff_BPL;

-  undefined4 *unaff_RSI;

-  char *unaff_RDI;

-  uint uVar5;

-  uint uVar6;

-  ulonglong uVar7;

-  char unaff_R12B;

-  int unaff_R13D;

-  undefined4 *unaff_R14;

-  int unaff_R15D;

-  uint in_stack_00000030;

+  uint uVar1;

+  undefined8 uVar2;

+  undefined8 *puVar3;

+  longlong lVar4;

+  void *_Dst;

+  longlong lVar5;

+  undefined1 uVar6;

+  uint uVar7;

+  longlong lVar8;

   

-  *(char *)(unaff_RBX - 10) = *(char *)(unaff_RBX - 10) + (char)((ulonglong)param_2 >> 8);

-  LOCK();

-  *unaff_RSI = in_EAX;

-  UNLOCK();

-  *unaff_RDI = *unaff_RDI + param_1;

-  if (*unaff_RDI != '\0') {

-    *(undefined4 *)(unaff_RDI + 0x368) = *unaff_R14;

-    *(ushort *)(unaff_RDI + 0x206) = *(ushort *)(unaff_RDI + 0x206) & 0xfff0;

+  if ((param_1[0xc] == 0) &&

+     (((*(uint *)(param_1[2] + 0x50) & 2) == 0 || (-1 < *(int *)(param_1 + 0xe))))) {

+    IopResetEvent();

   }

-  iVar1 = KiComputeThreadPriority();

-  iVar4 = (int)unaff_RDI[0x233];

-  if (0 < unaff_R15D) {

-    iVar4 = unaff_RDI[0x233] + -1 + unaff_R15D;

-  }

-  if (iVar1 < iVar4) {

-    iVar1 = iVar4;

-  }

-  *(ushort *)(unaff_RDI + 0x206) = *(ushort *)(unaff_RDI + 0x206) & 0xf00f;

-  if (unaff_RDI[0x366] < unaff_BPL) {

-    unaff_RDI[0x366] = '\0';

-  }

-  else {

-    unaff_RDI[0x366] = unaff_RDI[0x366] + -1;

-  }

-  cVar3 = (char)unaff_RSI;

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

-    cVar3 = (char)iVar1;

-  }

-  in_stack_00000030 = CONCAT31(in_stack_00000030._1_3_,cVar3);

-  uVar7 = (ulonglong)(byte)((byte)unaff_RBX | 2);

-  if ((*(uint *)(*(longlong *)(unaff_RDI + 0x220) + 0x88) >> 0xd & 1) == 0) {

-    uVar7 = unaff_RBX & 0xff;

-  }

-  if ((((uVar7 & 1) == 0) && ((*(uint *)(unaff_RDI + 0x78) & 8) == 0)) && ('\0' < unaff_RDI[0xc3]))

-  {

-    if (unaff_RDI[0x366] < (char)unaff_R13D) {

-      iVar1 = Feature_StackingDecayBoosts__private_IsEnabledNoReportingNoInline();

-      cVar3 = unaff_RDI[0x233];

-      if (iVar1 == 0) {

-        iVar1 = cVar3 + unaff_R13D;

-        if (0xf < iVar1) {

-          iVar1 = 0xf;

-        }

-        cVar3 = (char)iVar1 - cVar3;

-      }

-      else {

-        iVar1 = (*(ushort *)(unaff_RDI + 0x206) & 0xf) + (int)cVar3;

-        if (0xf < iVar1) {

-          iVar1 = 0xf;

-        }

-        iVar4 = iVar1 + unaff_R13D;

-        if (0xf < iVar4) {

-          iVar4 = 0xf;

-        }

-        cVar3 = (char)iVar4 - (char)iVar1;

-      }

-      Feature_StackingDecayBoosts__private_IsEnabledNoReportingNoInline();

-      unaff_RDI[0x366] = cVar3;

-      iVar1 = Feature_StackingDecayBoosts__private_IsEnabledNoReportingNoInline();

-      uVar5 = (uint)unaff_RDI[0x233];

-      if (iVar1 == 0) {

-        if ((int)uVar5 < 0x10) {

-          uVar2 = (*(ushort *)(unaff_RDI + 0x206) & 0xf) + uVar5;

-          if ((int)uVar2 <= (int)uVar5) {

-            uVar2 = uVar5;

-          }

-          uVar6 = (int)unaff_RDI[0x366] + uVar5;

-          if ((int)((int)unaff_RDI[0x366] + uVar5) <= (int)uVar2) {

-            uVar6 = uVar2;

-          }

-          uVar5 = *(ushort *)(unaff_RDI + 0x206) >> 4 & 0xff;

-          if ((int)uVar6 < (int)uVar5) {

-            uVar6 = uVar5;

-          }

-          uVar5 = uVar6;

-          if ((0xf < (int)uVar6) && ((*(uint *)(unaff_RDI + 0x78) & 0x400000) == 0)) {

-            uVar5 = 0xf;

+  lVar4 = IopAllocateIrpExReturn

+                    (param_1[3],*(undefined1 *)(param_1[3] + 0x4c),

+                     *(char *)((longlong)param_1 + 9) == '\0');

+  if (lVar4 != 0) {

+    *(undefined8 *)(lVar4 + 0xc0) = param_1[2];

+    *(undefined8 *)(lVar4 + 0x98) = *param_1;

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

+    *(undefined1 *)(lVar4 + 0x40) = *(undefined1 *)(param_1 + 1);

+    *(undefined1 *)(lVar4 + 0x41) = 0;

+    *(undefined1 *)(lVar4 + 0x44) = 0;

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

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

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

+    lVar8 = param_1[0xc];

+    if (lVar8 == 0) {

+      *(undefined8 *)(lVar4 + 0x48) = param_1[7];

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

+      lVar8 = param_1[6];

+    }

+    else {

+      uVar2 = param_1[0xd];

+      ObfReferenceObjectWithTag(lVar8,0x49526f49);

+      *(uint *)(lVar4 + 0x10) = *(uint *)(lVar4 + 0x10) | 0x200000;

+      *(undefined8 *)(lVar4 + 0x48) = uVar2;

+    }

+    *(longlong *)(lVar4 + 0x60) = lVar8;

+    lVar8 = *(longlong *)(lVar4 + 0xb8);

+    *(undefined4 *)(lVar8 + -0x48) = 4;

+    *(undefined8 *)(lVar8 + -0x18) = param_1[2];

+    if (((*(uint *)(param_1[2] + 0x50) & 0x10) != 0) || ((*(uint *)(param_1 + 0xe) & 1) != 0)) {

+      *(undefined1 *)(lVar8 + -0x46) = 4;

+    }

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

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

+    if ((*(uint *)(param_1[3] + 0x30) & 4) == 0) {

+      if ((*(uint *)(param_1[3] + 0x30) & 0x10) == 0) {

+        *(undefined8 *)(lVar4 + 0x70) = param_1[8];

+        if (((longlong *)param_1[0xf] != (longlong *)0x0) &&

+           (lVar5 = *(longlong *)param_1[0xf], lVar5 != 0)) {

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

+          *(undefined8 *)param_1[0xf] = 0;

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

+            *(ulonglong *)(lVar4 + 0x60) = *(ulonglong *)(lVar4 + 0x60) | 1;

           }

         }

       }

-      else if ((int)uVar5 < 0x10) {

-        uVar2 = (*(ushort *)(unaff_RDI + 0x206) & 0xf) + uVar5;

-        if ((int)uVar2 <= (int)uVar5) {

-          uVar2 = uVar5;

+      else if (*(int *)(param_1 + 9) != 0) {

+        lVar5 = IopAllocateMdl(param_1[8],*(int *)(param_1 + 9),0,1,lVar4,0);

+        if (lVar5 == 0) {

+                    /* WARNING: Subroutine does not return */

+          ExRaiseStatus(0xc000009a);

         }

-        cVar3 = '\0';

-        if ('\0' < unaff_RDI[0x366]) {

-          cVar3 = unaff_RDI[0x366];

+        if (param_1[0x10] == 0) {

+          uVar6 = *(undefined1 *)(param_1 + 1);

         }

-        uVar5 = uVar2 + (int)cVar3;

-        if (0xf < (int)uVar5) {

-          uVar5 = 0xf;

+        else {

+          uVar6 = 0;

         }

-        uVar2 = *(ushort *)(unaff_RDI + 0x206) >> 4 & 0xff;

-        if ((int)uVar5 < (int)uVar2) {

-          uVar5 = uVar2;

-        }

+        IopProbeAndLockPages(lVar5,uVar6);

       }

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

-      if (uVar2 != 0) {

-        uVar6 = 0x1f;

-        if (uVar2 != 0) {

-          for (; uVar2 >> uVar6 == 0; uVar6 = uVar6 - 1) {

-          }

-        }

-        if ((int)uVar5 < (int)uVar6) {

-          uVar5 = uVar6;

-        }

-      }

-      cVar3 = (char)uVar5;

-      in_stack_00000030 = CONCAT31(in_stack_00000030._1_3_,cVar3);

     }

+    else if (*(int *)(param_1 + 9) == 0) {

+      *(uint *)(lVar4 + 0x10) = *(uint *)(lVar4 + 0x10) | 0x10;

+    }

+    else if (param_1[0x10] == 0) {

+      _Dst = (void *)ExAllocatePool2(0x69,*(int *)(param_1 + 9),0x42536f49);

+      *(void **)(lVar4 + 0x18) = _Dst;

+      RtlCopyMemory(_Dst,(void *)param_1[8],(ulonglong)*(uint *)(param_1 + 9));

+      *(uint *)(lVar4 + 0x10) = *(uint *)(lVar4 + 0x10) | 0x30;

+    }

+    else {

+      *(undefined8 *)(lVar4 + 0x18) = param_1[8];

+      *(uint *)(lVar4 + 0x10) = *(uint *)(lVar4 + 0x10) | 0x10;

+      *(undefined8 *)(lVar4 + 0x70) = param_1[8];

+    }

+    uVar1 = *(uint *)(lVar4 + 0x10);

+    uVar7 = uVar1 | 0x200;

+    *(uint *)(lVar4 + 0x10) = uVar7;

+    if ((*(uint *)(param_1[2] + 0x50) & 8) != 0) {

+      uVar7 = uVar1 | 0x201;

+      *(uint *)(lVar4 + 0x10) = uVar7;

+    }

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

+      uVar7 = uVar7 | 0x800;

+      *(uint *)(lVar4 + 0x10) = uVar7;

+    }

+    if (((*(uint *)(param_1[2] + 0x50) & 2) != 0) && (*(int *)(param_1 + 0xe) < 0)) {

+      *(uint *)(lVar4 + 0x10) = uVar7 | 0x1000;

+    }

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

+      *(undefined1 *)(lVar4 + 0x40) = 0;

+      *(undefined8 *)(lVar4 + 0x70) = param_1[8];

+      puVar3 = (undefined8 *)param_1[0x10];

+      lVar5 = IopAllocateIrpExtension(lVar4,9);

+      if (lVar5 == 0) goto LAB_0;

+      uVar2 = puVar3[1];

+      *(undefined8 *)(lVar5 + 0x40) = *puVar3;

+      *(undefined8 *)(lVar5 + 0x48) = uVar2;

+    }

+    *(undefined4 *)(lVar8 + -0x40) = *(undefined4 *)(param_1 + 9);

+    *(undefined4 *)(lVar8 + -0x38) = *(undefined4 *)(param_1 + 0xb);

+    *(undefined8 *)(lVar8 + -0x30) = param_1[10];

+    if ((*(uint **)(param_1[2] + 0xd0) != (uint *)0x0) &&

+       ((**(uint **)(param_1[2] + 0xd0) & 0x10) != 0)) {

+      *(undefined4 *)(lVar8 + -0x34) = *(undefined4 *)(param_1[7] + 8);

+    }

+    *param_2 = lVar4;

+    return 0;

   }

-  else if (((KiSchedulerForegroundBoostDecayPolicy != 0) && (3 < (byte)uVar7)) &&

-          (((uVar7 & 2) != 0 &&

-           (((*(uint *)(unaff_RDI + 0x78) & 8) == 0 && ('\0' < unaff_RDI[0xc3])))))) {

-    in_stack_00000030 = CONCAT11(unaff_BPL,cVar3) | 0x200;

+LAB_0:

+  if (lVar4 != 0) {

+    IopExceptionCleanupEx(param_1[2],lVar4,param_1[4],0,*(char *)((longlong)param_1 + 9));

+    return 0xc000009a;

   }

-  if (cVar3 != '?') {

-    KiUpdateThreadPriority(0);

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

+    IopReleaseFileObjectLock(param_1[2]);

   }

-  if ((in_stack_00000030 >> 8 & 2) != 0) {

-    KiScheduleNextForegroundBoost();

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

+    ObfDereferenceObjectWithTag(param_1[4],0x746c6644);

+    param_1[4] = 0;

   }

-  return (byte)(in_stack_00000030 >> 8) & 1;

+  ObfDereferenceObjectWithTag(param_1[2],0x746c6644);

+  param_1[2] = 0;

+  return 0xc000009a;

 }
```

## `PpmEventTraceControlCallback`  (modified)

```diff
--- PpmEventTraceControlCallback
+++ PpmEventTraceControlCallback
@@ -1,132 +1,150 @@
 

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

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

 

-void PpmEventTraceControlCallback(char param_1)

+void PpmEventTraceControlCallback(undefined8 param_1,uint param_2)

 

 {

-  char *pcVar1;

-  uint uVar2;

-  code *pcVar3;

-  longlong lVar4;

-  longlong lVar5;

-  longlong lVar6;

-  char cVar7;

-  int iVar8;

-  char *in_RAX;

-  undefined7 uVar9;

-  uint uVar10;

-  longlong unaff_RBP;

-  longlong lVar11;

-  undefined1 *unaff_RDI;

-  longlong lVar12;

-  longlong lVar13;

-  longlong unaff_R13;

-  uint uVar14;

-  longlong unaff_R14;

-  longlong lVar15;

-  ulonglong uVar16;

-  longlong unaff_retaddr;

-  undefined8 uStack0000000000000028;

-  undefined1 uStack0000000000000030;

-  ulonglong uStack0000000000000038;

-  uint in_stack_00000048;

-  longlong in_stack_00000050;

-  uint in_stack_00000058;

-  longlong in_stack_00000060;

-  longlong in_stack_00000068;

-  longlong in_stack_00000070;

-  undefined8 in_stack_00000078;

-  undefined4 *in_stack_00000080;

+  char cVar1;

+  int iVar2;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  uint uVar5;

+  undefined8 *puVar6;

+  longlong lVar7;

+  longlong lVar8;

+  undefined1 auStack_198 [32];

+  undefined1 local_178;

+  undefined1 local_170;

+  undefined4 local_168;

+  undefined4 local_164;

+  undefined2 *local_160;

+  undefined8 local_158;

+  undefined2 local_150;

+  undefined4 local_14e;

+  undefined2 local_14a;

+  undefined8 local_148;

+  undefined1 local_140 [264];

+  ulonglong local_38;

   

-  *unaff_RDI = *unaff_RDI;

-  uVar9 = (undefined7)((ulonglong)in_RAX >> 8);

-  cVar7 = (char)in_RAX + *in_RAX;

-  pcVar1 = (char *)(CONCAT71(uVar9,cVar7) + -0x73);

-  *pcVar1 = *pcVar1 + param_1;

-  uStack0000000000000038 = CONCAT71(uVar9,cVar7) & 0xffffffffffffff48;

-  uStack0000000000000030 = 0;

-  uStack0000000000000028 = PsProcessType;

-  iVar8 = ObOpenObjectByPointer(unaff_retaddr,0,0,0x400);

-  if ((-1 < iVar8) && (in_stack_00000050 != 0)) {

-    uVar16 = 0;

-    lVar11 = 0;

-    in_stack_00000058 = 0;

-    if (*(int *)(unaff_R13 + 0x288) != 0) {

+  local_38 = __security_cookie ^ (ulonglong)auStack_198;

+  local_14e = 0;

+  local_14a = 0;

+  local_168 = 0;

+  memset(&local_148,0,0x108);

+  local_164 = 0;

+  if ((param_2 & 0xfffffffd) == 0) {

+    PpmAcquireLock(&PpmPerfPolicyLock);

+    local_158 = DAT_0;

+    local_150 = 0;

+    local_160 = &KeActiveProcessors;

+    while( true ) {

+      iVar2 = KeEnumerateNextProcessor(&local_168,&local_160);

+      puVar6 = PpmPerfDomainHead;

+      if (iVar2 != 0) break;

+      uVar3 = KeGetPrcb(local_168);

+      PpmEventTraceProcessorPerformance(uVar3);

+    }

+    for (; (undefined8 **)puVar6 != &PpmPerfDomainHead; puVar6 = (undefined8 *)*puVar6) {

+      if (param_2 == 2) {

+        PpmEventTraceProcessorPerformanceDomainRundown(puVar6);

+        PpmEventQosClassPolicy(puVar6,1);

+        PpmEventQosClassPerfSelection(puVar6,1);

+      }

+      uVar5 = 0;

+      if (*(int *)(puVar6 + 0x25) != 0) {

+        do {

+          puVar4 = (undefined8 *)((ulonglong)uVar5 * 0x4a8 + puVar6[0x27]);

+          if (*(int *)(puVar4 + 2) == 1) {

+            PpmEventTraceProcessorPerformanceRundownHv(*puVar4);

+          }

+          uVar5 = uVar5 + 1;

+        } while (uVar5 < *(uint *)(puVar6 + 0x25));

+      }

+    }

+    if (param_2 == 2) {

+      PpmEventTraceLPIState();

+      PpmEventStaticPolicyRundown();

+      PpmEventQosSupport(1);

+      PpmEventHeteroPolicy(1);

+      PpmEventSoftParkLatencyUpdate(1,1,PpmHighPerfSoftParkLatencyUs);

+      PpmEventTraceHeteroSets(0);

+      if ((PpmHeteroHgsEnabled != '\0') || (PpmHeteroHgsThreadEnabled != '\0')) {

+        PpmEventHgsHardwareTable(1);

+        PpmEventHgsNormalizedTable();

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

+          PpmEventHgsHardwareTableResonChanged(1);

+          PpmEventHgsHardwareTableResonMapTable();

+        }

+        if (((PpmHeteroHgsContainmentState & 4) != 0) && (uVar5 = 0, PpmParkNumNodes != 0)) {

+          do {

+            lVar7 = (ulonglong)uVar5 * 0x508;

+            PpmEventHgsContainmentGroupInfo(PpmParkNodes + lVar7);

+            lVar8 = PpmParkNodes + lVar7;

+            PpmHeteroHgsEvaluateContainmentMinPolicyDecision(lVar8);

+            local_178 = 0;

+            if (*(longlong *)(lVar8 + 0x4f8) != 0) {

+              local_178 = *(undefined1 *)(*(longlong *)(lVar8 + 0x4f8) + 0x33b);

+            }

+            local_170 = 1;

+            PpmEventHgsContainmentPolicyChange();

+            local_148 = 0x200001;

+            memset(local_140,0,0x100);

+            local_164 = 3;

+            PpmHeteroHgsGetWpsHint(PpmParkNodes + lVar7,&local_148,&local_164);

+            PpmEventHgsContainmentHwUpdate(&local_148,&local_164,1);

+            uVar5 = uVar5 + 1;

+          } while (uVar5 < PpmParkNumNodes);

+        }

+      }

+    }

+    uVar5 = 0;

+    if (PpmParkNumNodes != 0) {

       do {

-        lVar4 = in_stack_00000050;

-        memset((void *)(unaff_RBP + 0x600),0,0x328);

-        lVar12 = uVar16 * 5;

-        lVar13 = *(longlong *)(unaff_R13 + 0x290);

-        lVar15 = *(longlong *)(PopEtGlobals + 0x440);

-        in_stack_00000048 = 0;

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

-        in_stack_00000078 = 0;

-        in_stack_00000080 = (undefined4 *)0x0;

-        *(undefined8 *)(unaff_RBP + 0x604) = *(undefined8 *)(lVar13 + 4 + uVar16 * 0x14);

-        *(longlong *)(unaff_RBP + 0x610) = lVar4;

-        in_stack_00000060 = lVar15;

-        in_stack_00000068 = lVar13;

-        in_stack_00000070 = lVar12;

-        iVar8 = (**(code **)(lVar15 + 0x268))(unaff_RBP + 0x600);

-        if (-1 < iVar8) {

-          in_stack_00000080 = &stack0x00000048;

-          in_stack_00000078 = CONCAT44(0x1e,*(undefined4 *)(lVar13 + uVar16 * 0x14));

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

-          iVar8 = (**(code **)(lVar15 + 0x158))(&stack0x00000078,0,0);

-          if ((-1 < iVar8) && (uVar10 = 0, in_stack_00000048 != 0)) {

-            do {

-              memset((void *)(unaff_RBP + 0x2d0),0,0x328);

-              *(undefined8 *)(unaff_RBP + 0x2d4) = *(undefined8 *)(lVar13 + 4 + lVar12 * 4);

-              *(longlong *)(unaff_RBP + 0x2e0) = in_stack_00000050;

-              pcVar3 = *(code **)(lVar15 + 0x268);

-              *(undefined4 *)(unaff_RBP + 0x2d0) = 0xb;

-              *(short *)(unaff_RBP + 0x5f0) = (short)uVar10;

-              iVar8 = (*pcVar3)(unaff_RBP + 0x2d0);

-              lVar6 = in_stack_00000070;

-              lVar5 = in_stack_00000068;

-              lVar4 = in_stack_00000060;

-              if (-1 < iVar8) {

-                uVar2 = *(uint *)(unaff_RBP + 0x2ec);

-                uVar14 = 0;

-                lVar13 = lVar5;

-                lVar15 = lVar4;

-                if (uVar2 != 0) {

-                  do {

-                    memset((void *)(unaff_RBP + -0x60),0,0x328);

-                    *(undefined8 *)(unaff_RBP + -0x5c) = *(undefined8 *)(lVar5 + 4 + lVar6 * 4);

-                    *(longlong *)(unaff_RBP + -0x50) = in_stack_00000050;

-                    pcVar3 = *(code **)(lVar4 + 0x268);

-                    *(undefined4 *)(unaff_RBP + -0x60) = 0x13;

-                    *(short *)(unaff_RBP + 0x2c0) = (short)uVar10;

-                    *(short *)(unaff_RBP + 0x2c2) = (short)uVar14;

-                    iVar8 = (*pcVar3)(unaff_RBP + -0x60);

-                    if (-1 < iVar8) {

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

-                    }

-                    uVar14 = uVar14 + 1;

-                    lVar12 = lVar6;

-                  } while (uVar14 < uVar2);

-                }

-              }

-              uVar10 = uVar10 + 1;

-            } while (uVar10 < in_stack_00000048);

-            uVar16 = (ulonglong)in_stack_00000058;

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

-          }

+        lVar7 = (ulonglong)uVar5 * 0x508 + PpmParkNodes;

+        iVar2 = Feature_PpmParkEx__private_IsEnabledDeviceUsageNoInline();

+        if (iVar2 == 0) {

+          PpmEventTraceParkNodeRundown(lVar7);

         }

-        in_stack_00000058 = (int)uVar16 + 1;

-        uVar16 = (ulonglong)in_stack_00000058;

-      } while (in_stack_00000058 < *(uint *)(unaff_R13 + 0x288));

-      unaff_retaddr = *(longlong *)(unaff_RBP + -0x70);

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

+        else {

+          PpmEventTraceParkNodeRundownEx(uVar5 & 0xffff,lVar7);

+        }

+        PpmEventParkNodeRestriction(1,lVar7);

+        uVar5 = uVar5 + 1;

+      } while (uVar5 < PpmParkNumNodes);

     }

-    ObCloseHandle(in_stack_00000050,1);

-    if (lVar11 != 0) {

-      *(longlong *)(unaff_R14 + 0x1b0) = lVar11;

+    PopAcquireRwLockExclusive(&PpmIdlePolicyLock);

+    PpmEventTracePpmProfileStatusRundown();

+    PpmEventTraceProfiles(1);

+    if ((PpmEtwRegistered != '\0') &&

+       (cVar1 = EtwEventEnabled(PpmEtwHandle,&PPM_ETW_PROCESSOR_PROFILE_SETTING_RUNDOWN),

+       cVar1 != '\0')) {

+      PpmInfoTraceProfileSettings();

+    }

+    PopReleaseRwLock(&PpmIdlePolicyLock);

+    PpmReleaseLock(&PpmPerfPolicyLock);

+    if (param_2 == 2) {

+      PpmEventTraceAccountingBucketIntervalsRundown();

+      PopAcquireRwLockShared(&PpmIdlePolicyLock);

+      PpmEventTraceCoordinatedIdleStates();

+      PpmEventTracePlatformIdleAccounting();

+      PpmEventVetoReasonRundown();

+      PpmEventPlatformVetoRundown();

+      local_158 = DAT_0;

+      local_150 = 0;

+      local_160 = &KeActiveProcessors;

+      while (iVar2 = KeEnumerateNextProcessor(&local_168,&local_160), iVar2 == 0) {

+        uVar3 = KeGetPrcb(local_168);

+        PpmEventProcessorVetoRundown(uVar3);

+        PpmEventTraceProcessorIdle(uVar3);

+      }

+      PopExecuteOnTargetProcessors(&KeActiveProcessors,PpmEventTraceProcessorIdleAccounting,0,0);

+      PopReleaseRwLock(&PpmIdlePolicyLock);

+      cVar1 = PoEnergyEstimationEnabled();

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

+        PpmEventEnergyEstimationRundown();

+      }

     }

   }

-  ExReleaseRundownProtection(unaff_retaddr + 0x1e8);

   return;

 }
```

## `PspValidateJobAssignmentUILimits`  (modified)

```diff
--- PspValidateJobAssignmentUILimits
+++ PspValidateJobAssignmentUILimits
@@ -1,76 +1,24 @@
 

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

-

-int PspValidateJobAssignmentUILimits(uint param_1)

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

 

 {

-  short *psVar1;

-  char in_AL;

-  int iVar2;

-  undefined8 *puVar3;

-  char unaff_BL;

-  char *unaff_RBP;

-  longlong unaff_R13;

-  char unaff_R15B;

-  char in_CF;

-  undefined8 in_stack_00000040;

-  undefined4 in_stack_00000058;

-  longlong in_stack_00000080;

-  undefined8 in_stack_000000b0;

-  undefined1 uStack0000000000000180;

-  undefined8 uStack0000000000000190;

-  undefined8 uStack0000000000000198;

-  undefined8 uStack00000000000001a0;

-  undefined8 uStack00000000000001a8;

-  undefined4 uStack00000000000001b0;

-  undefined4 uStack00000000000001b4;

-  undefined4 uStack00000000000001b8;

-  undefined4 uStack00000000000001bc;

-  undefined8 uStack00000000000001c0;

+  uint uVar1;

   

-  *unaff_RBP = *unaff_RBP + in_AL + in_CF;

-  uStack0000000000000190 = *(undefined8 *)(unaff_R13 + 0x10);

-  uStack0000000000000198 = *(undefined8 *)(unaff_R13 + 0x18);

-  uStack00000000000001a0 = *(undefined8 *)(unaff_R13 + 0x20);

-  uStack00000000000001a8 = *(undefined8 *)(unaff_R13 + 0x28);

-  uStack00000000000001b0 = *(undefined4 *)(unaff_R13 + 0x30);

-  uStack00000000000001b4 = *(undefined4 *)(unaff_R13 + 0x34);

-  uStack00000000000001b8 = *(undefined4 *)(unaff_R13 + 0x38);

-  uStack00000000000001bc = *(undefined4 *)(unaff_R13 + 0x3c);

-  uStack00000000000001c0 = *(undefined8 *)(unaff_R13 + 0x40);

-  _uStack0000000000000180 = param_1;

-  if (((param_1 & 0xfffffffc) == 0) && ((param_1 & 3) != 0)) {

-    PspLockRootJobExclusive(in_stack_00000040,in_stack_00000080,&stack0x000000b0);

-    puVar3 = &stack0x000000b0;

-    PspLockJobConditionally(in_stack_00000040,puVar3);

-    iVar2 = PspSetJobIoAttribution

-                      (in_stack_00000040,

-                       CONCAT71((int7)((ulonglong)puVar3 >> 8),uStack0000000000000180) &

-                       0xffffffffffffff01,1,1);

-    unaff_BL = '\b';

-    if (-1 < iVar2) {

-      PspUnlockJobConditionally(in_stack_00000040,&stack0x000000b0);

-      PspUnlockJob(in_stack_000000b0,in_stack_00000080);

-      unaff_BL = unaff_R15B;

+  if ((param_3 == 4) && ((*(uint *)(param_1 + 0x610) & 0x10) != 0)) {

+    uVar1 = *(uint *)(param_1 + 0x614) & 0x10;

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

+      uVar1 = PspDoesJobHierarchyPermitUILimits(param_2,(-(uint)(uVar1 != 0) & 0xfffffffe) + 3);

+    }

+    else if (uVar1 == 0) {

+      uVar1 = *(uint *)(param_2 + 0x614) >> 4 & 0xffffff01;

+    }

+    else {

+      uVar1 = 0;

     }

   }

   else {

-    iVar2 = -0x3ffffff3;

+    uVar1 = 1;

   }

-  if (unaff_BL == '\b') {

-    PspUnlockJobConditionally(in_stack_00000040,&stack0x000000b0);

-    PspUnlockJob(in_stack_000000b0,in_stack_00000080);

-  }

-  psVar1 = (short *)(in_stack_00000080 + 0x1e6);

-  *psVar1 = *psVar1 + 1;

-  if ((*psVar1 == 0) &&

-     (*(longlong **)(in_stack_00000080 + 0x98) != (longlong *)(in_stack_00000080 + 0x98))) {

-    KiCheckForKernelApcDelivery();

-  }

-  if ((iVar2 != 0) && ((PerfGlobalGroupMask & 0x80000) != 0)) {

-    EtwTraceJobSetQuery(in_stack_00000040,in_stack_00000058,0,0,iVar2);

-  }

-  ObfDereferenceObjectWithTag(in_stack_00000040,0x79517350);

-  return iVar2;

+  return uVar1;

 }
```

## `WmipQueryAllDataMultiple`  (modified)

```diff
--- WmipQueryAllDataMultiple
+++ WmipQueryAllDataMultiple
@@ -1,12 +1,168 @@
 

-void WmipQueryAllDataMultiple(longlong param_1)

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

+

+undefined8

+WmipQueryAllDataMultiple

+          (uint param_1,undefined8 *param_2,undefined8 param_3,undefined1 param_4,

+          undefined4 *param_5,uint param_6,uint *param_7,int *param_8)

 

 {

-  code *pcVar1;

+  int *piVar1;

+  bool bVar2;

+  int iVar3;

+  int iVar4;

+  undefined8 uVar5;

+  undefined8 *puVar6;

+  undefined4 *puVar7;

+  int iVar8;

+  ulonglong uVar9;

+  uint uVar10;

+  ulonglong uVar11;

+  longlong lVar12;

+  undefined1 auStack_138 [32];

+  uint local_118;

+  int *local_110;

+  undefined1 local_108;

+  int local_104;

+  int local_100;

+  undefined4 *local_f8;

+  undefined8 *local_f0;

+  int local_e8;

+  undefined8 *local_e0;

+  undefined8 local_d8;

+  ulonglong local_d0;

+  undefined8 *local_c8;

+  undefined8 local_b8;

+  undefined4 *local_b0;

+  int *local_a8;

+  undefined4 local_98;

+  undefined1 local_94 [76];

+  ulonglong local_48;

   

-  *(char *)(param_1 + -0x75) = *(char *)(param_1 + -0x75) + (char)param_1;

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

-  (*pcVar1)();

-  return;

+  local_48 = __security_cookie ^ (ulonglong)auStack_138;

+  uVar11 = (ulonglong)param_1;

+  local_98 = 0;

+  local_b0 = param_5;

+  local_a8 = param_8;

+  local_108 = param_4;

+  local_e0 = param_2;

+  local_b8 = param_3;

+  memset(local_94,0,0x44);

+  local_104 = 0;

+  iVar4 = 0;

+  local_e8 = 0;

+  local_d8 = 0;

+  local_100 = 0;

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

+    uVar10 = *param_7;

+    uVar11 = (ulonglong)uVar10;

+    local_c8 = (undefined8 *)ExAllocatePool2(0x100,uVar11 * 8,0x70696d57);

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

+      return 0xc000009a;

+    }

+    if (uVar10 == 0) goto LAB_0;

+    puVar6 = local_c8;

+    uVar9 = uVar11;

+    do {

+      *puVar6 = *(undefined8 *)((longlong)param_7 + (8 - (longlong)local_c8) + (longlong)puVar6);

+      puVar6 = puVar6 + 1;

+      uVar9 = uVar9 - 1;

+    } while (uVar9 != 0);

+  }

+  else {

+    local_c8 = (undefined8 *)0x0;

+LAB_0:

+    iVar8 = 0;

+    bVar2 = false;

+    local_f8 = param_5;

+    if ((int)uVar11 == 0) goto LAB_1;

+  }

+  iVar8 = 0;

+  local_f8 = param_5;

+  puVar7 = (undefined4 *)0x0;

+  bVar2 = false;

+  lVar12 = (longlong)local_c8 - (longlong)local_e0;

+  local_f0 = local_e0;

+  iVar4 = local_e8;

+  local_d0 = uVar11;

+  do {

+    if ((param_5 == &local_98) || (param_5 = local_f8, uVar10 = param_6, param_6 < 0x48)) {

+      param_5 = &local_98;

+      puVar7 = (undefined4 *)0x0;

+      uVar10 = 0x48;

+    }

+    memset(param_5,0,0x48);

+    param_5[0xb] = 1;

+    *param_5 = 0x30;

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

+      *(undefined8 *)(param_5 + 4) = *(undefined8 *)(lVar12 + (longlong)local_f0);

+    }

+    else {

+      local_d8 = *local_f0;

+    }

+    local_110 = &local_104;

+    local_118 = uVar10;

+    iVar3 = WmipQueryAllData(local_d8,local_b8,local_108,param_5);

+    if ((-1 < iVar3) && (((uint)param_5[0xb] >> 8 & 1) == 0)) {

+      local_100 = local_100 + 1;

+      if ((param_5[0xb] & 0x20) == 0) {

+        iVar3 = local_104;

+        if (param_5 != &local_98) {

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

+            puVar7[3] = iVar4;

+          }

+          uVar10 = param_5[3];

+          puVar7 = param_5;

+          while (uVar10 != 0) {

+            puVar7 = (undefined4 *)((longlong)puVar7 + (ulonglong)uVar10);

+            uVar10 = puVar7[3];

+          }

+          uVar10 = local_104 + 7U & 0xfffffff8;

+          iVar8 = iVar8 + uVar10;

+          iVar4 = Feature_1045423416__private_IsEnabledDeviceUsageNoInline();

+          if (iVar4 == 0) {

+            param_6 = param_6 - uVar10;

+          }

+          else {

+            param_6 = -(uint)(uVar10 < param_6) & param_6 - uVar10;

+          }

+          local_f8 = (undefined4 *)((longlong)local_f8 + (ulonglong)uVar10);

+          iVar4 = (int)local_f8 - (int)puVar7;

+          goto LAB_2;

+        }

+      }

+      else {

+        piVar1 = param_5 + 0xc;

+        param_5 = &local_98;

+        iVar3 = *piVar1;

+      }

+      bVar2 = true;

+      iVar8 = iVar8 + (iVar3 + 7U & 0xfffffff8);

+    }

+LAB_2:

+    local_f0 = local_f0 + 1;

+    local_d0 = local_d0 - 1;

+  } while (local_d0 != 0);

+  local_d0 = 0;

+  param_5 = local_b0;

+  iVar4 = local_100;

+LAB_1:

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

+    ExFreePoolWithTag(local_c8,0);

+  }

+  if (iVar4 == 0) {

+    uVar5 = 0xc0000295;

+  }

+  else {

+    if (bVar2) {

+      param_5[0xb] = 0x20;

+      *param_5 = 0x38;

+      param_5[0xc] = iVar8;

+      iVar8 = 0x38;

+    }

+    *local_a8 = iVar8;

+    uVar5 = 0;

+  }

+  return uVar5;

 }
```

## `PpmParkApplyPolicyEx`  (modified)

```diff
--- PpmParkApplyPolicyEx
+++ PpmParkApplyPolicyEx
@@ -1,73 +1,324 @@
 

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

 

-void PpmParkApplyPolicyEx(short param_1)

+void PpmParkApplyPolicyEx(void)

 

 {

+  void *_Dst;

   short sVar1;

-  char cVar2;

-  void *_Dst;

-  short in_AX;

-  uint uVar3;

+  int iVar2;

+  int iVar3;

   longlong lVar4;

-  undefined8 unaff_RBX;

-  ushort *unaff_RSI;

-  ushort uVar5;

-  ulonglong unaff_RDI;

-  char cVar6;

-  undefined4 unaff_R12D;

-  ushort *unaff_R14;

-  short unaff_R15W;

-  longlong in_stack_00000030;

+  longlong lVar5;

+  ushort uVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  uint uVar9;

+  ushort *puVar10;

+  undefined1 uVar11;

+  ushort uVar12;

+  uint uVar13;

+  uint uVar14;

+  short sVar15;

+  ushort uVar16;

+  ushort uVar17;

+  uint uVar18;

+  undefined *puVar19;

+  undefined1 auStack_2c8 [32];

+  char local_2a8;

+  short local_2a6;

+  ushort local_2a4;

+  undefined4 local_2a0 [2];

+  undefined *local_298;

+  uint local_290;

+  uint local_28c;

+  uint local_288;

+  uint local_284;

+  ushort *local_280;

+  undefined8 uStack_278;

+  ulonglong local_270;

+  longlong local_268;

+  _KAFFINITY_EX local_258;

+  _KAFFINITY_EX local_148;

+  ulonglong local_38;

   

-  lVar4 = CONCAT62((int6)((ulonglong)unaff_RBX >> 0x10),CONCAT11(0xc1,(char)unaff_RBX));

-  do {

-    sVar1 = *(short *)(lVar4 + 0x490);

-    *unaff_R14 = param_1 - *unaff_RSI;

-    *(short *)(lVar4 + 0x492) = in_AX - sVar1;

-    do {

-      uVar5 = (short)unaff_RDI + unaff_R15W;

-      unaff_RDI = (ulonglong)uVar5;

-      if (PpmParkNumNodes <= uVar5) {

-        cVar6 = (char)unaff_R12D;

-        uVar3 = *(uint *)(in_stack_00000030 + 0xa0);

-        cVar2 = cVar6;

-        if (((PpmPerfMaxOverrideEnabled != cVar6) && (PpmHighPerfSoftParkLatencyUs != 0)) &&

-           ((uVar3 == 0 || (PpmHighPerfSoftParkLatencyUs < uVar3)))) {

-          uVar3 = PpmHighPerfSoftParkLatencyUs;

-          cVar2 = '\x01';

-        }

-        PpmEventSoftParkLatencyUpdate(0,cVar2,uVar3);

-        _Dst = PpmParkOldSoftParkRankList;

-        if (uVar3 == 0) {

-          KeSoftParkedQueueThreshold = unaff_R12D;

-          PpmParkSoftParkingEnabled = cVar6;

-          if ((PpmParkNewSoftParkRankList != (void *)0x0) &&

-             (PpmParkOldSoftParkRankList != (void *)0x0)) {

-            memset(PpmParkNewSoftParkRankList,0xff,(ulonglong)KeMaximumProcessors << 2);

-            memset(_Dst,0xff,(ulonglong)KeMaximumProcessors << 2);

-            KeUpdateSoftParkRankList();

-            PpmEventSoftParkRankListChanged();

-          }

-        }

-        else {

-          PpmParkSoftParkingEnabled = '\x01';

-          KeSoftParkedQueueThreshold =

-               PpmConvertTime((ulonglong)*(uint *)((longlong)FiberData + 0x44) * 1000000,1000000,

-                              uVar3);

-        }

-        PpmHeteroHgsCheckContainmentDecision();

-        return;

+  local_38 = __security_cookie ^ (ulonglong)auStack_2c8;

+  local_270 = 0;

+  local_2a0[0] = 0;

+  local_280 = (ushort *)0x0;

+  uStack_278 = 0;

+  memset(&local_258.field3_0x8,0,0x100);

+  memset(&local_148.field3_0x8,0,0x100);

+  if (PpmParkNodes == 0) {

+    KeSoftParkedQueueThreshold = 0;

+  }

+  else {

+    puVar19 = PpmCurrentProfile + (longlong)DAT_0 * 0x1e8 + 0x28;

+    local_298 = puVar19;

+    PpmParkEvalualteSmtUnparkPolicy

+              (CONCAT71((int7)((ulonglong)((longlong)DAT_0 * 0x1e8) >> 8),puVar19[0x1ca]));

+    local_2a8 = '\0';

+    lVar4 = KeGetPrcb(0);

+    uVar18 = PpmParkNumNodes;

+    uVar14 = PpmParkThermalCap;

+    uVar13 = PpmParkLpiCap;

+    uVar12 = 0x40;

+    if (*(longlong *)(lVar4 + 0x89b0) == 0) {

+      uVar12 = 0x40;

+      if (PpmParkInitialClass1UnParkCount < 0x41) {

+        uVar12 = (ushort)PpmParkInitialClass1UnParkCount;

       }

-      lVar4 = unaff_RDI * 0x508 + PpmParkNodes;

-      unaff_RSI = (ushort *)(lVar4 + 0x494);

-      unaff_R14 = (ushort *)(lVar4 + 0x496);

-    } while (((uint)*(ushort *)(lVar4 + 0x492) ==

-              (uint)*(ushort *)(lVar4 + 10) - (uint)*(ushort *)(lVar4 + 0x490)) &&

-            ((uint)*unaff_R14 == (uint)*(ushort *)(lVar4 + 10) - (uint)*unaff_RSI));

-    PpmEventParkNodeCapChangeEx(unaff_RDI,lVar4 + 0x30,*(ushort *)(lVar4 + 0x490),*unaff_RSI);

-    in_AX = *(short *)(lVar4 + 10);

-    param_1 = in_AX;

-  } while( true );

+      local_2a8 = '\x01';

+    }

+    local_258.Count = 1;

+    local_258.Size = 0x20;

+    local_258.Reserved = 0;

+    local_290 = (int)((ulonglong)PpmParkLpiCap / (ulonglong)PpmParkNumNodes) -

+                (int)(((ulonglong)PpmParkLpiCap / (ulonglong)PpmParkNumNodes) %

+                     (ulonglong)(uint)PpmParkGranularity);

+    uVar9 = (int)((ulonglong)PpmParkThermalCap / (ulonglong)PpmParkNumNodes) -

+            (int)(((ulonglong)PpmParkThermalCap / (ulonglong)PpmParkNumNodes) %

+                 (ulonglong)(uint)PpmParkGranularity);

+    local_284 = uVar9;

+    memset(&local_258.field3_0x8,0,0x100);

+    local_148.Count = 1;

+    local_148.Size = 0x20;

+    local_148.Reserved = 0;

+    memset(&local_148.field3_0x8,0,0x100);

+    local_2a4 = 0;

+    if (uVar18 != 0) {

+      do {

+        uVar17 = local_2a4;

+        uVar8 = 0;

+        lVar4 = (ulonglong)local_2a4 * 0x508 + PpmParkNodes;

+        uVar16 = *(ushort *)(lVar4 + 10);

+        uVar6 = (ushort)local_290;

+        if ((int)((uint)uVar16 - (uint)PpmParkGranularity) < (int)(local_290 & 0xffff)) {

+          uVar6 = uVar16 - PpmParkGranularity;

+        }

+        *(ushort *)(lVar4 + 0x490) = uVar6;

+        uVar9 = uVar9 & 0xffff;

+        if ((int)((uint)uVar16 - (uint)PpmParkGranularity) < (int)uVar9) {

+          uVar9 = (uint)(ushort)(uVar16 - PpmParkGranularity);

+        }

+        *(short *)(lVar4 + 0x494) = (short)uVar9;

+        sVar15 = 0;

+        local_28c = uVar13 - uVar6;

+        local_288 = uVar14 - uVar9;

+        local_268 = lVar4;

+        memset(&local_258.field3_0x8,0,(local_258._0_8_ & 0xffff) << 3);

+        local_258.Count = 1;

+        memset(&local_148.field3_0x8,0,(local_148._0_8_ & 0xffff) << 3);

+        local_148.Count = 1;

+        puVar19 = local_298;

+        uVar13 = uVar13 - uVar6;

+        uVar14 = uVar14 - uVar9;

+        sVar1 = local_2a6;

+        if (*(char *)(lVar4 + 0xc) != '\0') {

+          do {

+            iVar3 = (int)uVar8;

+            puVar10 = (ushort *)(uVar8 * 0x280 + *(longlong *)(lVar4 + 0x500));

+            uVar13 = (uint)(byte)puVar19[(ulonglong)(iVar3 != 0) + 0x9c];

+            if ((local_2a8 != '\0') && (iVar3 != 0)) {

+              uVar13 = 0;

+            }

+            if (*puVar10 != 0) {

+              uVar14 = (uint)*puVar10;

+              uVar18 = ((byte)puVar19[(ulonglong)(iVar3 != 0) + 0x9e] * uVar14 + 0x32) / 100;

+              uVar16 = (short)uVar18 +

+                       (short)((int)(uVar14 - (uVar18 & 0xffff)) % (int)(uint)PpmParkGranularity);

+              uVar13 = (uVar13 * uVar14 + 0x32) / 100;

+              uVar6 = (short)uVar13 +

+                      (short)((int)(uVar14 - (uVar13 & 0xffff)) % (int)(uint)PpmParkGranularity);

+              if ((iVar3 != 0) && (uVar12 <= uVar16)) {

+                uVar16 = uVar12;

+              }

+              if ((uVar6 != 0) && (uVar6 < PpmParkGranularity)) {

+                uVar6 = PpmParkGranularity;

+              }

+              if (uVar16 < uVar6) {

+                uVar16 = uVar6;

+              }

+              KiOrAffinityEx(&local_148,(_KAFFINITY_EX *)(puVar10 + 0x98),&local_148,local_148.Size)

+              ;

+              memset(puVar10 + 0x9c,0,(ulonglong)puVar10[0x98] << 3);

+              puVar10[0x98] = 1;

+              local_280 = puVar10 + 0x14;

+              local_270 = local_270 & 0xffffffffffff0000;

+              uStack_278 = *(undefined8 *)(puVar10 + 0x18);

+              iVar2 = KeEnumerateNextProcessor(local_2a0,&local_280);

+              while (iVar2 == 0) {

+                lVar4 = KeGetPrcb(local_2a0[0]);

+                if (*(char *)(lVar4 + 0x8a4c) != '\0') {

+                  KeAddProcessorAffinityEx(puVar10 + 0x98,local_2a0[0]);

+                }

+                iVar2 = KeEnumerateNextProcessor(local_2a0,&local_280);

+                lVar4 = local_268;

+              }

+              local_258.Size = (ushort)((ulonglong)local_258._0_8_ >> 0x10);

+              uVar17 = local_258.Size;

+              KiOrAffinityEx(&local_258,(_KAFFINITY_EX *)(puVar10 + 0x98),&local_258,uVar17);

+              sVar15 = sVar15 + uVar6;

+              puVar10[2] = uVar16;

+              puVar10[1] = uVar6;

+              puVar19 = local_298;

+            }

+            uVar8 = (ulonglong)(iVar3 + 1U);

+            uVar13 = local_28c;

+            uVar14 = local_288;

+            uVar17 = local_2a4;

+            sVar1 = sVar15;

+          } while (iVar3 + 1U < (uint)*(byte *)(lVar4 + 0xc));

+        }

+        local_2a6 = sVar1;

+        iVar3 = KeIsEqualAffinityEx(&local_148,&local_258);

+        uVar8 = 0;

+        if (iVar3 == 0) {

+          PpmEventParkNodeParkHintChangedEx(lVar4 + 0x30,&local_258);

+        }

+        if (sVar15 == 0) {

+          lVar5 = *(longlong *)(lVar4 + 0x500);

+          *(ushort *)(lVar5 + 2) = PpmParkGranularity;

+          uVar16 = PpmParkGranularity;

+          if (PpmParkGranularity <= *(ushort *)(lVar5 + 4)) {

+            uVar16 = *(ushort *)(lVar5 + 4);

+          }

+          *(ushort *)(lVar5 + 4) = uVar16;

+        }

+        if (PpmHeteroPolicy == 2) {

+          *(byte *)(lVar4 + 0x4a0) = *(byte *)(lVar4 + 0x4a0) | 4;

+          lVar5 = *(longlong *)(lVar4 + 0x500);

+          uVar16 = *(ushort *)(lVar5 + 2);

+          if (uVar16 < 2) {

+            uVar16 = 1;

+          }

+          *(ushort *)(lVar5 + 2) = uVar16;

+          uVar16 = *(ushort *)(lVar5 + 4);

+          if (uVar16 < 2) {

+            uVar16 = 1;

+          }

+          *(ushort *)(lVar5 + 4) = uVar16;

+          uVar8 = 1;

+          if (1 < *(byte *)(lVar4 + 0xc)) {

+            do {

+              uVar18 = (int)uVar8 + 1;

+              *(undefined8 *)(uVar8 * 0x280 + *(longlong *)(lVar4 + 0x500) + 2) = 0;

+              uVar8 = (ulonglong)uVar18;

+            } while (uVar18 < *(byte *)(lVar4 + 0xc));

+          }

+        }

+        else if ((PpmHeteroPolicy == 3) && (*(char *)(lVar4 + 0x4a1) != '\0')) {

+          *(byte *)(lVar4 + 0x4a0) = *(byte *)(lVar4 + 0x4a0) | 2;

+          uVar7 = uVar8;

+          if (1 < *(byte *)(lVar4 + 0xc)) {

+            do {

+              iVar3 = (int)uVar7;

+              uVar8 = (ulonglong)(iVar3 + 1);

+              *(undefined8 *)(uVar7 * 0x280 + *(longlong *)(lVar4 + 0x500) + 2) = 0;

+              uVar7 = uVar8;

+            } while (iVar3 + 2U < (uint)*(byte *)(lVar4 + 0xc));

+          }

+          lVar5 = uVar8 * 0x280 + *(longlong *)(lVar4 + 0x500);

+          uVar16 = *(ushort *)(lVar5 + 2);

+          if (uVar16 < 2) {

+            uVar16 = 1;

+          }

+          *(ushort *)(lVar5 + 2) = uVar16;

+          uVar16 = *(ushort *)(lVar5 + 4);

+          if (uVar16 < 2) {

+            uVar16 = 1;

+          }

+          *(ushort *)(lVar5 + 4) = uVar16;

+        }

+        PpmConfigureRestrictionPolicy(lVar4);

+        local_2a4 = uVar17 + 1;

+        uVar9 = local_284;

+        puVar19 = local_298;

+        uVar18 = PpmParkNumNodes;

+      } while (local_2a4 < PpmParkNumNodes);

+    }

+    while (uVar13 != 0) {

+      uVar8 = 0;

+      if (uVar18 != 0) {

+        do {

+          if (uVar13 == 0) goto LAB_1;

+          lVar4 = uVar8 * 0x508 + PpmParkNodes;

+          if ((*(ushort *)(lVar4 + 10) != 0) &&

+             (uVar12 = PpmParkGranularity + *(short *)(lVar4 + 0x490),

+             uVar12 < *(ushort *)(lVar4 + 10))) {

+            *(ushort *)(lVar4 + 0x490) = uVar12;

+            uVar13 = uVar13 - PpmParkGranularity;

+          }

+          uVar12 = (short)uVar8 + 1;

+          uVar8 = (ulonglong)uVar12;

+        } while (uVar12 < uVar18);

+      }

+    }

+LAB_1:

+    if (uVar14 != 0) {

+      uVar8 = 0;

+      if (uVar18 != 0) {

+        do {

+          if (uVar14 == 0) goto LAB_2;

+          lVar4 = uVar8 * 0x508 + PpmParkNodes;

+          if ((*(ushort *)(lVar4 + 10) != 0) &&

+             (uVar12 = *(short *)(lVar4 + 0x494) + PpmParkGranularity,

+             uVar12 < *(ushort *)(lVar4 + 10))) {

+            *(ushort *)(lVar4 + 0x494) = uVar12;

+            uVar14 = uVar14 - PpmParkGranularity;

+          }

+          uVar12 = (short)uVar8 + 1;

+          uVar8 = (ulonglong)uVar12;

+        } while (uVar12 < uVar18);

+      }

+      goto LAB_1;

+    }

+LAB_2:

+    uVar8 = 0;

+    if (uVar18 != 0) {

+      do {

+        lVar4 = uVar8 * 0x508 + PpmParkNodes;

+        puVar10 = (ushort *)(lVar4 + 0x494);

+        if (((uint)*(ushort *)(lVar4 + 0x492) !=

+             (uint)*(ushort *)(lVar4 + 10) - (uint)*(ushort *)(lVar4 + 0x490)) ||

+           ((uint)*(ushort *)(lVar4 + 0x496) != (uint)*(ushort *)(lVar4 + 10) - (uint)*puVar10)) {

+          PpmEventParkNodeCapChangeEx(uVar8,lVar4 + 0x30,*(ushort *)(lVar4 + 0x490),*puVar10);

+          *(ushort *)(lVar4 + 0x496) = *(short *)(lVar4 + 10) - *puVar10;

+          *(short *)(lVar4 + 0x492) = *(short *)(lVar4 + 10) - *(short *)(lVar4 + 0x490);

+        }

+        uVar12 = (short)uVar8 + 1;

+        uVar8 = (ulonglong)uVar12;

+        puVar19 = local_298;

+      } while (uVar12 < PpmParkNumNodes);

+    }

+    uVar11 = 0;

+    uVar13 = *(uint *)(puVar19 + 0xa0);

+    if (((PpmPerfMaxOverrideEnabled != '\0') && (PpmHighPerfSoftParkLatencyUs != 0)) &&

+       ((uVar13 == 0 || (PpmHighPerfSoftParkLatencyUs < uVar13)))) {

+      uVar11 = 1;

+      uVar13 = PpmHighPerfSoftParkLatencyUs;

+    }

+    PpmEventSoftParkLatencyUpdate(0,uVar11,uVar13);

+    _Dst = PpmParkOldSoftParkRankList;

+    if (uVar13 == 0) {

+      PpmParkSoftParkingEnabled = 0;

+      KeSoftParkedQueueThreshold = 0;

+      if ((PpmParkNewSoftParkRankList != (void *)0x0) && (PpmParkOldSoftParkRankList != (void *)0x0)

+         ) {

+        memset(PpmParkNewSoftParkRankList,0xff,(ulonglong)KeMaximumProcessors << 2);

+        memset(_Dst,0xff,(ulonglong)KeMaximumProcessors << 2);

+        KeUpdateSoftParkRankList();

+        PpmEventSoftParkRankListChanged();

+      }

+    }

+    else {

+      PpmParkSoftParkingEnabled = 1;

+      KeSoftParkedQueueThreshold =

+           PpmConvertTime((ulonglong)*(uint *)((longlong)FiberData + 0x44) * 1000000,1000000,uVar13)

+      ;

+    }

+    PpmHeteroHgsCheckContainmentDecision();

+  }

+  return;

 }
```

## `PoInitSystem`  (modified)

```diff
--- PoInitSystem
+++ PoInitSystem
@@ -1,111 +1,525 @@
 

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

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

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

 

-void PoInitSystem(int param_1,int param_2,ulonglong param_3,uint param_4)

+byte PoInitSystem(int param_1,longlong param_2)

 

 {

-  ushort uVar1;

-  undefined8 uVar2;

-  int iVar3;

-  undefined *in_RAX;

-  uint uVar4;

-  uint uVar5;

-  longlong unaff_RBX;

-  longlong *unaff_RBP;

-  longlong lVar6;

-  ulonglong unaff_RSI;

-  undefined8 *puVar7;

-  uint uVar8;

-  ushort *puVar9;

+  longlong lVar1;

+  char cVar2;

+  uint uVar3;

+  int iVar4;

+  int iVar5;

+  undefined1 uVar6;

+  uint uVar7;

+  int local_res8 [4];

+  undefined4 local_res18 [2];

+  undefined8 local_res20;

+  undefined8 in_stack_ffffffffffffff88;

+  undefined4 uVar8;

+  undefined8 in_stack_ffffffffffffff90;

+  uint uVar9;

+  undefined4 in_stack_ffffffffffffff98;

   ushort uVar10;

-  undefined8 *in_R10;

-  int in_R11D;

-  undefined8 *puVar11;

-  longlong unaff_R12;

-  longlong unaff_R13;

-  undefined4 unaff_R14D;

-  longlong lVar12;

-  uint uVar13;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined4 local_40;

   

-  lVar6 = *unaff_RBP;

-  while( true ) {

-    uVar8 = *(uint *)(in_RAX + (ulonglong)(uint)(param_1 + (int)param_3) * 4);

-    iVar3 = uVar8 - param_2;

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

-      iVar3 = param_2 - uVar8;

+  uVar9 = (uint)((ulonglong)in_stack_ffffffffffffff90 >> 0x20);

+  uVar8 = (undefined4)((ulonglong)in_stack_ffffffffffffff88 >> 0x20);

+  uVar10 = (ushort)((uint)in_stack_ffffffffffffff98 >> 0x10);

+  iVar4 = 0;

+  local_res20 = 0;

+  local_48 = 0;

+  local_40 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  uVar7 = 0;

+  uVar6 = 1;

+  PopOsInitPhase = param_1;

+  if (param_1 == 0) {

+    KeQueryPerformanceCounter(&local_res20);

+    PopQpcFrequency = local_res20;

+    PopComputeCounterShifts

+              (local_res20,&PpmPerformanceDistributionShift,&PpmPerformanceCounterShift);

+    PopComputeCounterShifts

+              (10000000,&PpmHvPerformanceDistributionShift,&PpmHvPerformanceCounterShift);

+    _PopCsResiliencyStatsLock = 0;

+    PopSleepstudyInitialize(0);

+    uVar3 = PopPowerAggregatorInitialize(0);

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

+      _DAT_0 = &DAT_140f0a068;

+      _DAT_1 = &DAT_1;

+      DAT_2 = &PopIrpList;

+      PopIrpList = &PopIrpList;

+      DAT_3 = &PopInrushIrpList;

+      PopInrushIrpList = &PopInrushIrpList;

+      _DAT_4 = 0;

+      _PopPowerEventLock = 0;

+      _DAT_5 = 0;

+      _PopSystemIdleLock = 0;

+      _DAT_6 = 0;

+      _PopCoalRegistrationListLock = 0;

+      _PopIdleLoopExecuted = 0;

+      DAT_7 = 6;

+      DAT_8 = 0;

+      _PopDeepSleepDisengageReasonLock = 0;

+      PopIrpLock = 0;

+      ExInitializeNPagedLookasideListInternal

+                (&PopIrpDataLookaside,0,0,0x200,0x138,CONCAT44(uVar9,0x72496f50),

+                 (uint)uVar10 << 0x10,0);

+      _PopShutdownNotificationCallbackLock = 0;

+      DAT_9 = &PopShutdownNotificationCallbackList;

+      PopShutdownNotificationCallbackList = &PopShutdownNotificationCallbackList;

+      memset(&PopStateTransitonBlameStack,0,0xc18);

+      DAT_10 = 0xffffffff;

+      _DAT_11 = PopDevicePowerTransitionInProgressWorker;

+      BootStatDisableFlush = DAT_12 >> 2 & 1;

+      _PopPendingPowerTransitionLock = 0;

+      _DAT_13 = 0;

+      uRam0000000140f0d0b0 = 0;

+      _DAT_14 = &DAT_140f0e488;

+      _DAT_15 = &DAT_15;

+      _DAT_16 = 0;

+      _PopDevicePowerTransitionInProgressWorkItem = 0;

+      BootStatFileHandle = 0;

+      BootStatFileHandleAcquired = 0;

+      BootStatKeepHandleOpen = 0;

+      BootStatDataCache = 0;

+      PopBsdSkipLogging = 0;

+      _DAT_17 = 0;

+      _PopBsdUpdateLock = 0;

+      _PopBsdFlushInactiveEvent = 1;

+      DAT_18 = 6;

+      DAT_19 = 1;

+      PopInitializeWorkItem(&PopSetUserShutdownMarkerWorkItem,PopSetUserShutdownMarkerWorker,0);

+      PopInitializeWorkItem(&PopClearUserShutdownMarkerWorkItem,PopClearUserShutdownMarkerWorker);

+      PopInitializeWorkItem(&PopBsdFlushWorkItem,PopBsdFlushWorker);

+      PopInitializeWorkItem(&PopBsdUpdateWorkItem,PopBsdUpdateWorker);

+      PopWdiCurrentScenarioInstanceId = 0;

+      PopWdiCurrentScenario = &PARTITION_ENTRY_UNUSED_GUID;

+      PopInitializeWorkItem(&PopExternalMonitorUpdatedWorkItem,PopExternalMonitorUpdatedWorker);

+      iVar4 = Feature_NU4MP__private_IsEnabledDeviceUsageNoInline();

+      if (iVar4 != 0) {

+        PopInitializeWorkItem

+                  (&PopUsb4DisplayPresenceUpdatedWorkItem,PopUsb4DisplayPresenceUpdatedWorker,0);

+      }

+      PopInitializeWorkItem(&PopRecordLidStateWorkItem,PopRecordLidStateWorker,0);

+      _DAT_20 = 0;

+      DAT_21 = &PopTransitionCheckpoints;

+      PopTransitionCheckpoints = &PopTransitionCheckpoints;

+      _PopInputSuppressionLock = 0;

+      _DAT_22 = 0;

+      _PopPowerButtonSuppressionLock = 0;

+      _DAT_23 = 0;

+      _PopTransitionCheckpointLock = 0;

+      PopMonitorOffDueToSleep = 0;

+      PpmCheckInit();

+      uVar3 = PopInitializeIrpWorkers();

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

+        _PopIrpSerialLock = 0;

+        _DAT_24 = &DAT_140f0ba50;

+        _DAT_25 = &DAT_25;

+        _DAT_26 = &PopIrpSerialList;

+        _PopIrpSerialList = &PopIrpSerialList;

+        _DAT_27 = &PopRequestedIrps;

+        _PopRequestedIrps = &PopRequestedIrps;

+        _DAT_28 = &DAT_140f0ac48;

+        _DAT_29 = &DAT_29;

+        DAT_30 = &PowerStateDisableReasonListHead;

+        PowerStateDisableReasonListHead = &PowerStateDisableReasonListHead;

+        _DAT_31 = &DAT_140f0db40;

+        _DAT_32 = &DAT_32;

+        DAT_33 = &PopDisableSleepList;

+        PopDisableSleepList = &PopDisableSleepList;

+        DAT_34 = 0;

+        PpmIdlePolicyLock = 0;

+        _PpmIdleVetoLock = 0;

+        _PpmParkStateLock = 0;

+        _DAT_35 = 0;

+        _DAT_36 = 1;

+        DAT_37 = 6;

+        _DAT_38 = 1;

+        _PopWorkerLock = 0;

+        _PopTransitionLock = 1;

+        DAT_39 = 6;

+        _DAT_40 = 1;

+        _PopDisableSleepMutex = 1;

+        _DAT_41 = 0;

+        _DAT_42 = 0;

+        _DAT_43 = 1;

+        DAT_44 = 6;

+        _DAT_45 = 0;

+        PopInitShutdownList();

+        DAT_46 = &PopIdleDetectList;

+        PopIdleDetectList = &PopIdleDetectList;

+        _PopDopeGlobalLock = 0;

+        if (PopIdleScanInterval != 0) {

+          if (PopIdleScanInterval == 0xffffffff) {

+            PopIdleScanInterval = 0x1e;

+          }

+          else if (300 < PopIdleScanInterval) {

+            PopIdleScanInterval = 300;

+          }

+          PopIdleBackgroundIgnoreCount = (PopIdleScanInterval + 0x3b) / PopIdleScanInterval;

+          PopBackgroundTaskIgnoreCount = (PopIdleScanInterval + 0xb3) / PopIdleScanInterval;

+        }

+        _PopWorkerSpinLock = 0;

+        _DAT_47 = PopPolicyWorkerThread;

+        _PopPolicyWorker = 0;

+        _DAT_48 = 0x80000000;

+        PopWorkerStatus = 0xffffffff;

+        ExInitializeResourceLite2(&PopPolicyLock,0xffffffff);

+        PopAwaymodeLock = 0;

+        _DAT_49 = &DAT_140f0bca0;

+        _DAT_50 = &DAT_50;

+        _PopVolumeLock = 1;

+        _DAT_51 = &DAT_140f0d2e8;

+        _DAT_52 = &DAT_52;

+        DAT_53 = &PopVolumeDevices;

+        PopVolumeDevices = &PopVolumeDevices;

+        _DAT_54 = &PopSwitches;

+        _PopSwitches = &PopSwitches;

+        _DAT_55 = &PopFans;

+        PopFans = &PopFans;

+        _DAT_56 = 0;

+        _DAT_57 = 0;

+        _DAT_58 = 1;

+        DAT_59 = 6;

+        _DAT_60 = 0;

+        _PopPowerSettingCallbackReturned = 0;

+        DAT_61 = 6;

+        _DAT_62 = 0;

+        _DAT_63 = &PopThermal;

+        PopThermal = &PopThermal;

+        PopWaitingForTransitionLock = 0;

+        _DAT_64 = 0;

+        _PopUnlockAfterSleepLock = 0;

+        IoAddTriageDumpDataBlock(&PopThermal,0x10);

+        DAT_65 = &PopActionWaiters;

+        PopActionWaiters = &PopActionWaiters;

+        PopResetActionDefaults();

+        PopPolicy = &DAT_66;

+        PopDefaultPolicy();

+        PopAdminPolicy = 2;

+        _DAT_67 = 5;

+        DAT_68 = 0xffffffff;

+        DAT_69 = 0;

+        DAT_70 = 0xffffffff;

+        PopFullWake = 1;

+        iVar4 = Feature_VpciVscBootDiskHibernation__private_IsEnabledDeviceUsageNoInline();

+        if (iVar4 != 0) {

+          _PopSstNotificationHandlerListLock = 0;

+          DAT_71 = &PopSstNotificationHandlerList;

+          PopSstNotificationHandlerList = &PopSstNotificationHandlerList;

+        }

+        PopCoolingMode = 0;

+        DAT_72 = 0xffffffff;

+        DAT_73 = 2;

+        PpmInitPolicyConfiguration();

+        PpmInitIdlePolicy();

+        PpmPerfInitialize();

+        PpmInitCoreParkingPolicy();

+        PpmInitHeteroPolicy();

+        PpmIdleRegisterDefaultStates();

+        PopDeepSleepInitialize(0);

+        PopInitializePowerSettings();

+        PopInitilizeAcDcSettings();

+        _DAT_74 = 0;

+        _PopPolicyDeviceLock = 0;

+        PopBatteryInit();

+        PopThermalInit();

+        DAT_75 = &PopCoolingExtensionList;

+        PopCoolingExtensionList = &PopCoolingExtensionList;

+        DAT_76 = &PopPowerLimitExtensionList;

+        PopPowerLimitExtensionList = &PopPowerLimitExtensionList;

+        DAT_77 = PopShutdownHandler;

+        DAT_78 = &PopWakeInfoList;

+        PopWakeInfoList = &PopWakeInfoList;

+        _DAT_79 = &DAT_140f0d1e8;

+        _DAT_80 = &DAT_80;

+        DAT_81 = &PopWakeSourceWorkList;

+        PopWakeSourceWorkList = &PopWakeSourceWorkList;

+        _DAT_82 = &DAT_140f082a8;

+        _DAT_83 = &DAT_83;

+        _DAT_84 = PpmWmiIdleAccountingProcedure;

+        _DAT_85 = PopUserPresentSetWorker;

+        _DAT_86 = &DAT_140e67518;

+        _DAT_87 = &DAT_87;

+        _DAT_88 = &DAT_140f0c488;

+        _DAT_89 = &DAT_89;

+        _DAT_90 = 0;

+        _PopCoolingExtensionLock = 0;

+        _DAT_91 = 0;

+        _PopPowerLimitExtensionLock = 0;

+        _DAT_92 = 4;

+        DAT_93 = 0;

+        PopWakeInfoCount = 0;

+        PopCurrentWakeInfo = 0;

+        _PopWakeSourceLock = 0;

+        _PopWakeSourceAvailable = 0;

+        DAT_94 = 6;

+        _DAT_95 = 1;

+        PopWakeSourceWorkState = 0;

+        _PpmWmiIdleAccountingTimer = 8;

+        _DAT_96 = 0;

+        _DAT_97 = 0;

+        _DAT_98 = 0;

+        _PpmWmiIdleAccountingDpc = 0x113;

+        _DAT_99 = 0;

+        _DAT_100 = 0;

+        _DAT_101 = 0;

+        _PopUserPresentLock = 0;

+        _DAT_102 = 0;

+        _PopUserPresentWorkItem = 0;

+        _PopAwayModeUserPresenceTimer = 8;

+        _DAT_103 = 0;

+        _DAT_104 = 0;

+        _DAT_105 = 0;

+        _PopUserPresentCompletedEvent = 1;

+        DAT_106 = 6;

+        _DAT_107 = 0;

+        PopSmartSuspendInit();

+        _DAT_108 = 1;

+        _DAT_109 = &DAT_140f0d970;

+        _DAT_110 = &DAT_110;

+        DAT_111 = 6;

+        _DAT_112 = 1;

+        PoFxInitPowerManagement();

+        DAT_113 = 0;

+        _DAT_114 = 100;

+        _DAT_115 = 100;

+        DAT_116 = 100;

+        PopNetInitialize(0);

+        PopInitializePowerButtonHold(0);

+        _DAT_117 = 0;

+        _PopSleepReliabilityDiagLock = 0;

+        PopRecorderInit();

+        PopRecordFirmwareResetReason(param_2);

+        uVar3 = PopCreateTimebrokerServiceSid();

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

+          PopInitializeDirectedDrips(0);

+          SshInitialize(0);

+          uVar3 = uVar7;

+        }

+      }

     }

-    uVar5 = (uint)unaff_RBX;

-    if (uVar8 < (uint)((ulonglong)(uint)(iVar3 * 100) / (unaff_RSI & 0xffffffff))) break;

-    do {

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

-      while (uVar8 = (uint)param_3, uVar5 <= uVar8) {

-        param_3 = 0;

-        do {

-          param_4 = param_4 + 1;

-          in_R10 = in_R10 + 1;

-          if (uVar5 <= param_4) goto LAB_0;

-        } while (*(short *)*in_R10 != ((short *)*in_R10)[1]);

-        in_R11D = uVar5 * param_4;

+    goto LAB_118;

+  }

+  if (param_1 == 1) {

+    cVar2 = HviIsAnyHypervisorPresent();

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

+      _PpmExitLatencyCheckEnabled = 0;

+      PpmExitLatencySamplingPercentage = 0;

+    }

+    _DAT_119 = 0;

+    _PopFanLock = 0;

+    DAT_120 = 0;

+    PopSendFanNoiseChangeWnf(0);

+    if (PopAggressiveStandbyActionsRegValue < 0x10) {

+      PopAggressiveStandbyEnabledActions = PopAggressiveStandbyActionsRegValue;

+    }

+    _DAT_121 = 0;

+    _DAT_122 = 0;

+    _DAT_123 = 0;

+    _PopSuspendResumeNotification = 0;

+    SshInitialize(1);

+    PopUmpoInitializeChannel();

+    PopUmpoInitializeMonitorChannel();

+    PopPdcDeviceListLock = 0;

+    _DAT_124 = PopDelayedPdcRegistrationWorker;

+    _DAT_125 = 0;

+    _PopDelayedPdcRegistrationWorkItem = 0;

+    PopEsInit(1);

+    PopInitializePowerSettingCallbacks();

+    uVar3 = PopEtInit();

+    if ((((-1 < (int)uVar3) && (uVar3 = PopPowerRequestInitialize(), -1 < (int)uVar3)) &&

+        (uVar3 = PopPowerAggregatorInitialize(1), -1 < (int)uVar3)) &&

+       (uVar3 = PopInitializeHighPerfPowerRequest(), -1 < (int)uVar3)) {

+      PopCheckPowerSourceAfterRtcWakeInitialize();

+      PopWatchdogInit();

+      PopInitializePowerButtonHold(1);

+      PopInitDripsWakeAccounting();

+      uVar3 = EmpProviderRegister(0,&PopEmEntry,1,&PopEmCallback,CONCAT44(uVar8,2),&local_res20);

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

+        local_res8[0] = 1;

+        PopErrataDisablePrimaryDeviceFastResume = 0;

+        EmClientQueryRuleState(&GUID_EM_RULE_DISABLE_DEVICE_FAST_RESUME,local_res8);

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

+          PopErrataDisablePrimaryDeviceFastResume = 1;

+        }

+        PopDetectSimulatedHeteroProcessors();

+        PpmHeteroHgsDetectContainmentPresence(0,0);

+        uVar3 = uVar7;

       }

-    } while ((*(short *)(&KeNodeBlock)[param_3] != ((short *)(&KeNodeBlock)[param_3])[1]) ||

-            (param_4 == uVar8));

-    param_2 = *(int *)(unaff_R13 + (ulonglong)(in_R11D + uVar8) * 8);

-    param_1 = KeNumberNodes * param_4;

-    in_RAX = KeNodeDistance;

-  }

-  if (*(longlong *)(lVar6 + -0x69) != -1) {

-    *unaff_RBP = 0x140c60b2b;

-    RtlInitUnicodeString(lVar6 + -0x41,L"Node Distance");

-    uVar2 = *(undefined8 *)(lVar6 + -0x69);

-    *(undefined4 *)(unaff_RBP + 6) = unaff_R14D;

-    unaff_RBP[5] = unaff_R12;

-    *unaff_RBP = 0x140c60b4b;

-    ZwSetValueKey(uVar2,lVar6 + -0x41,0,3);

-  }

-  uVar13 = (uint)KeNumberNodes;

-  puVar11 = &KeNodeBlock;

-  uVar8 = 0;

-  do {

-    puVar9 = (ushort *)*puVar11;

-    if (*puVar9 != puVar9[1]) {

-      puVar9 = (ushort *)(&KeNodeBlock)[puVar9[1]];

     }

-    uVar4 = uVar13 * uVar8;

-    puVar7 = &KeNodeBlock;

-    lVar12 = unaff_RBX;

-    do {

-      uVar10 = *(ushort *)*puVar7;

-      uVar1 = ((ushort *)*puVar7)[1];

-      if (uVar10 != uVar1) {

-        uVar10 = *(ushort *)(&KeNodeBlock)[uVar1];

+    goto LAB_118;

+  }

+  if (param_1 == 2) {

+    PoFxRegisterDebugger();

+    HalReportResourceUsage(1);

+    PopBatteryInitPhaseTwo();

+    uVar3 = PpmEventInitialize();

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

+      KeRegisterProcessorChangeCallback(PopNewProcessorCallback,0,0);

+      PpmAcquireLock(&PpmPerfPolicyLock);

+      PopInitializeHeteroProcessors(1);

+      PpmReleaseLock(&PpmPerfPolicyLock);

+      if (PpmPerfArtificialDomainSetting != -1) {

+        PpmPerfArtificialDomainEnabled = (uint)(PpmPerfArtificialDomainSetting != 0);

       }

-      if (*puVar9 == uVar10) {

-        *(undefined4 *)(KeNodeDistance + (ulonglong)uVar4 * 4) = 0;

+      PpmIdleRegisterDefaultStates();

+      uVar3 = PpmParkInitialize();

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

+        PpmCheckInitProcessors(0,1);

+        PpmAcquireLock(&PopFxSystemLatencyLock);

+        PoFxSendSystemLatencyUpdate();

+        PpmReleaseLock(&PopFxSystemLatencyLock);

+        PopPdcCsCheckSystemVolumeDevice();

+        PopUpdateBackgroundCoolingStatus(0);

+        ZwUpdateWnfStateData

+                  (&WNF_PO_MULTIMEDIA_POWER_MODEL,&PpmPerfMultimediaPowerModel,4,0,0,

+                   (ulonglong)uVar9 << 0x20,0);

+        PopInitVideoWnfState();

+        uVar3 = uVar7;

       }

-      else {

-        *(undefined4 *)(KeNodeDistance + (ulonglong)uVar4 * 4) =

-             *(undefined4 *)(unaff_R13 + (ulonglong)(*puVar9 * uVar5 + (uint)uVar10) * 8);

-      }

-      uVar4 = uVar4 + 1;

-      puVar7 = puVar7 + 1;

-      lVar12 = lVar12 + -1;

-    } while (lVar12 != 0);

-    uVar8 = uVar8 + 1;

-    puVar11 = puVar11 + 1;

-  } while (uVar8 < uVar5);

-  unaff_R12 = *(longlong *)(lVar6 + -0x31);

-LAB_0:

-  *unaff_RBP = 0x140c60c03;

-  ExFreePoolWithTag();

-  if (unaff_R12 != 0) {

-    *unaff_RBP = 0x140c60c12;

-    ExFreePoolWithTag(unaff_R12,0);

-  }

-  if (*(longlong *)(lVar6 + -0x69) != -1) {

-    *unaff_RBP = 0x140c60c21;

-    ZwClose();

-  }

-  *unaff_RBP = 0x140c60c2d;

-  return;

+    }

+    goto LAB_118;

+  }

+  uVar3 = uVar7;

+  if ((param_1 != 3) || (uVar3 = PopDiagInitialize(), (int)uVar3 < 0)) goto LAB_118;

+  SshInitialize(3);

+  PopSleepstudyInitialize(3);

+  PopTriggerDiagTraceAoAcCapability(-(PopPlatformAoAcCapabilityInitialized != 0) & PopPlatformAoAc);

+  PopFanReportBootStartDevices();

+  PopInitializeWin32kActivator();

+  iVar5 = Feature_EE_MPTF_Functionality__private_IsEnabledDeviceUsageNoInline();

+  if (iVar5 != 0) {

+    PopModernStandbyNotificationInit();

+  }

+  PopPowerAggregatorInitialize(3);

+  uVar3 = PopUserShutdownScenarioInitialize();

+  if ((int)uVar3 < 0) goto LAB_118;

+  if (PopSkipTickPolicy == 0) {

+LAB_126:

+    uVar3 = 2;

+LAB_127:

+    PoSkipTickMode = uVar3;

+    PopDiagTraceSkipTick(uVar3 == 2,uVar6);

+  }

+  else {

+    uVar3 = uVar7;

+    if (PopSkipTickPolicy != 1) goto LAB_127;

+    uVar6 = 0;

+    iVar5 = HalGetInterruptTargetInformation(2,0,&local_58);

+    if (iVar5 < 0) goto LAB_126;

+    PopApicMode = local_48._4_4_;

+    if (local_48._4_4_ == 3) {

+      PopApicClusterSize = local_40;

+      PoSkipTickMaxOpportunisticProcessors = 8;

+    }

+    cVar2 = PopCheckSkipTick();

+    PoSkipTickMode = (uint)(cVar2 == '\0');

+  }

+  PpmInitIllegalThrottleLogging();

+  PopCheckShutdownMarker(param_2);

+  PopCheckAndClearBootError();

+  cVar2 = (*(code *)PTR_IopDmaOverrideConflict_140e00b10)();

+  if ((cVar2 != '\0') || ((PoOffCrashConfigTable - 1U < 3 && (DAT_128 != 0)))) {

+    PopDiagTraceAbnormalReset(DAT_128);

+  }

+  PopIdleWakeInitialize();

+  PopAcquirePolicyLock();

+  PopUpdateUpgradeInProgress(0);

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

+    PopLogSleepDisabled(0x10,0xf,0);

+  }

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

+    PopLogSleepDisabled(0x11,7,0);

+  }

+  if ((*(byte *)(*(longlong *)(param_2 + 0xf0) + 0xa58) & 8) != 0) {

+    PopSecureLaunched = 1;

+    iVar4 = 4;

+  }

+  if (((HvlpFlags & 2) == 0) && (VslVsmEnabled != '\0')) {

+    iVar4 = 0x17;

+LAB_130:

+    PopLogSleepDisabled(0x15,iVar4,0);

+  }

+  else if (iVar4 != 0) goto LAB_130;

+  PopDeepSleepInitialize(3);

+  PopInitializePowerPolicySimulate();

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

+    DAT_131 = 1;

+    _DAT_132 = 100;

+    _DAT_133 = 400;

+    _DAT_134 = 10;

+    _DAT_135 = 0xffff;

+    _DAT_136 = 4;

+    _DAT_137 = 2;

+  }

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

+    _PopCapabilities = 0x1010101;

+    _DAT_138 = 0x101;

+    DAT_139 = 1;

+    _DAT_140 = 0x101;

+  }

+  PopResetCurrentPolicies();

+  PopInitializeAdpm();

+  PopEsInit(3);

+  PopInitilizeAcDcSettings();

+  local_res18[0] = 1;

+  PopUpdateConsoleDisplayState(1);

+  ZwUpdateWnfStateData

+            (&WNF_PO_PRIMARY_DISPLAY_VISIBLE_STATE,local_res18,4,0,0,(ulonglong)uVar9 << 0x20,0);

+  PopNetInitialize(3);

+  PopReleasePolicyLock();

+  PopIdleInitAoAcDozeS4Timer();

+  PopCreateIdlePhaseWatchdog();

+  PopInitializeSystemIdleDetection();

+  PopHiberResumeXhciHandoffSkip =

+       (byte)((uint)*(undefined4 *)(*(longlong *)(param_2 + 0xf0) + 0x84) >> 0x1c) & 1;

+  PopSetupHighPerfPowerRequest();

+  PpmEnableWmiInterface();

+  lVar1 = *(longlong *)(param_2 + 0xf0);

+  if ((*(uint *)(lVar1 + 0xa58) >> 0xf & 1) != 0) {

+    PopFasr = 1;

+  }

+  BootAppSvnInfo._0_4_ = *(undefined4 *)(lVar1 + 0x1120);

+  BootAppSvnInfo._4_4_ = *(undefined4 *)(lVar1 + 0x1124);

+  DAT_141 = *(undefined4 *)(lVar1 + 0x1128);

+  uRam0000000140f0d19c = *(undefined4 *)(lVar1 + 0x112c);

+  PopAcquirePolicyLock();

+  PopCoalescingInitialize();

+  PopReleasePolicyLock();

+  PopInitializeDirectedDrips(3);

+  PopDripsWatchdogInitialize();

+  PopSetupAudioEventNotification();

+  PopSetupMixedRealitytNotification();

+  PopSetupFullScrenVideoNotification();

+  PopSetupUserPresencePredictionNotification();

+  PopSetupSprActiveSessionChangeNotification();

+  PopSetupAirplaneModeNotification();

+  PopSetupBluetoothChargingNotification();

+  PopSetupMobileHotspotNotification();

+  PopThermalHandlePreviousShutdown();

+  PopCheckpointEfiRuntimeRedirected = (byte)(*(uint *)(param_2 + 0x108) >> 1) & 1;

+  TtmInit();

+  PopReadErrataForIncorrectLidNotification();

+  PopLidReliabilityInit();

+  PopEvaluateInputSuppressionRequired();

+  iVar4 = Feature_NU4MP__private_IsEnabledDeviceUsageNoInline();

+  if (iVar4 != 0) {

+    PopSetupUsb4DisplayPresenceNotification();

+  }

+  PopPowerButtonSuppressionInit();

+  PopBatteryQueueWork(1);

+  PopSetupKsrCallbacks();

+  PopHiberEvaluateSkippingMemoryMapValidation();

+  PopReadErrataSkipMemoryOverwriteRequestControlLockAction();

+  uVar3 = uVar7;

+LAB_118:

+  return (byte)(uVar3 >> 0x1f) ^ 1;

 }
```

## `CmFcpComputeLatestMarker`  (modified)

```diff
--- CmFcpComputeLatestMarker
+++ CmFcpComputeLatestMarker
@@ -1,9 +1,59 @@
 

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

-

-void CmFcpComputeLatestMarker(void)

+int CmFcpComputeLatestMarker(void)

 

 {

-  return;

+  int iVar1;

+  

+  iVar1 = Feature_ExpToc__private_IsEnabledNoReportingNoInline();

+  if (iVar1 == 0) {

+    iVar1 = Feature_ValUxPerf2__private_IsEnabledNoReportingNoInline();

+    if (iVar1 == 0) {

+      iVar1 = Feature_ConfAccImp__private_IsEnabledNoReportingNoInline();

+      if (iVar1 == 0) {

+        iVar1 = Feature_TestUxGate__private_IsEnabledNoReportingNoInline();

+        if (iVar1 == 0) {

+          iVar1 = Feature_LocPerfVal__private_IsEnabledNoReportingNoInline();

+          if (iVar1 == 0) {

+            iVar1 = Feature_TestLoc03__private_IsEnabledNoReportingNoInline();

+            if (iVar1 == 0) {

+              iVar1 = Feature_TestLoc02__private_IsEnabledNoReportingNoInline();

+              if (iVar1 == 0) {

+                iVar1 = Feature_TestUex12__private_IsEnabledNoReportingNoInline();

+                if (iVar1 == 0) {

+                  iVar1 = Feature_UexTest7__private_IsEnabledNoReportingNoInline();

+                  iVar1 = (iVar1 != 0) + 0xa2a;

+                }

+                else {

+                  iVar1 = 0xa2c;

+                }

+              }

+              else {

+                iVar1 = 0xa2d;

+              }

+            }

+            else {

+              iVar1 = 0xa2e;

+            }

+          }

+          else {

+            iVar1 = 0xa2f;

+          }

+        }

+        else {

+          iVar1 = 0xa30;

+        }

+      }

+      else {

+        iVar1 = 0xa31;

+      }

+    }

+    else {

+      iVar1 = 0xa32;

+    }

+  }

+  else {

+    iVar1 = 0xa33;

+  }

+  return iVar1;

 }
```

## `MiMapViewOfImageSection`  (modified)

```diff
--- MiMapViewOfImageSection
+++ MiMapViewOfImageSection
@@ -1,157 +1,680 @@
 

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

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

 

-ulonglong MiMapViewOfImageSection(void)

+ulonglong MiMapViewOfImageSection

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

+                    longlong param_5,int param_6,int param_7,uint param_8)

 

 {

-  int iVar1;

-  uint uVar2;

-  char *in_RAX;

-  longlong unaff_RBX;

-  ulonglong unaff_RDI;

-  int unaff_R12D;

-  uint unaff_R14D;

-  char unaff_R15B;

+  undefined1 uVar1;

+  ulonglong uVar2;

+  code *pcVar3;

   undefined4 uVar4;

-  ulonglong uVar3;

-  char cStack0000000000000060;

-  char cStack0000000000000061;

-  char cStack0000000000000062;

-  longlong in_stack_00000068;

-  char in_stack_00000070;

-  int in_stack_00000080;

-  ulonglong in_stack_00000088;

-  ulonglong in_stack_00000090;

-  undefined8 *in_stack_000000b0;

-  undefined1 *in_stack_000000b8;

-  longlong in_stack_000000c0;

-  undefined1 *puStack00000000000000d0;

-  longlong lStack00000000000000d8;

-  longlong in_stack_00000100;

-  longlong in_stack_00000108;

-  longlong in_stack_00000110;

-  undefined8 *in_stack_00000118;

-  longlong in_stack_00000130;

-  undefined8 in_stack_00000138;

-  undefined8 *in_stack_00000140;

-  undefined1 *in_stack_00000148;

-  longlong in_stack_00000198;

-  ulonglong uStack00000000000001b0;

-  undefined4 in_stack_000004a0;

+  undefined4 uVar5;

+  char cVar6;

+  int iVar7;

+  undefined4 uVar8;

+  ulonglong uVar9;

+  ulonglong uVar10;

+  undefined8 *puVar11;

+  undefined8 *puVar12;

+  longlong lVar13;

+  uint uVar14;

+  _exception *_Except;

+  longlong *plVar15;

+  ushort uVar16;

+  uint uVar17;

+  uint uVar18;

+  undefined8 uVar19;

+  longlong lVar20;

+  uint uVar21;

+  longlong lVar22;

+  ulonglong uVar23;

+  void *pvVar24;

+  ushort local_res10;

+  ulonglong in_stack_fffffffffffffe68;

+  uint local_168;

+  ulonglong local_160;

+  uint local_158;

+  ulonglong local_148;

+  void *local_140;

+  ulonglong local_138;

+  ulonglong local_130;

+  ushort local_128;

+  ulonglong local_120;

+  ulonglong local_118;

+  ulonglong local_110;

+  ulonglong local_108;

+  longlong local_100;

+  ulonglong local_f8;

+  longlong local_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  ulonglong local_d8;

+  ulonglong uStack_d0;

+  ulonglong local_c8;

+  ulonglong uStack_c0;

+  undefined8 local_b8;

+  longlong *local_b0;

+  undefined1 local_a8 [8];

+  void *local_a0;

+  undefined4 local_58;

   

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

-  puStack00000000000000d0 = &stack0x000001f0;

-  lStack00000000000000d8 = in_stack_000000c0;

-  uVar2 = CmpCallCallBacksEx(0x20,&stack0x000001f0,&stack0x000000d0,1,0x21);

-  uStack00000000000001b0 = (ulonglong)uVar2;

-  if ((int)uVar2 < 0) {

-    if (uVar2 == 0xc0000503) {

-      uStack00000000000001b0 = unaff_RDI & 0xffffffff;

-      cStack0000000000000061 = '\x01';

-    }

+  memset(local_a8,0,0x58);

+  lVar20 = *param_1;

+  uVar9 = param_1[0xc];

+  uVar2 = param_2[0xb];

+  local_b8 = 0;

+  uVar17 = (uint)param_2[5] >> 0x16 & 2;

+  local_168 = 0;

+  local_e8 = 0;

+  uStack_e0 = 0;

+  local_d8 = 0;

+  uStack_d0 = 0;

+  local_c8 = 0;

+  uStack_c0 = 0;

+  lVar13 = *(longlong *)(lVar20 + 0x38);

+  local_f0 = lVar13;

+  if (((DAT_0 != 0) && (DAT_140e2d7bc == *(int *)(lVar13 + 0x3c))) &&

+     (DAT_1 == *(int *)(*(longlong *)(lVar20 + 0x38) + 0x44))) {

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

+    uVar9 = (*pcVar3)();

+    return uVar9;

+  }

+  local_120 = *(ulonglong *)(lVar20 + 0x30);

+  uVar10 = *(ulonglong *)(lVar20 + 0x20);

+  if ((((*(uint *)(param_1 + 7) & 0x20000000) != 0) ||

+      (uVar21 = 0, (*(uint *)(uVar2 + 0x5fc) & 0x2000) != 0)) &&

+     (uVar21 = 0, (*(ushort *)(lVar20 + 0xc) >> 0xe & 1) == 0)) {

+    uVar21 = 1;

+    uVar17 = uVar17 | 5;

+    local_168 = 1;

+  }

+  uVar16 = *(ushort *)((longlong)param_2 + 0x3a);

+  local_128 = *(ushort *)(uVar2 + 0x6ec);

+  local_res10 = uVar16;

+  if ((uVar16 == 0) &&

+     (((*(uint *)(uVar2 + 0x5fc) >> 0xc & 1) != 0 ||

+      (local_res10 = local_128, (*(uint *)(uVar2 + 0x5fc) & 1) != 0)))) {

+    local_res10 = *(ushort *)(lVar13 + 0x30);

+  }

+  _Except = (_exception *)(ulonglong)*(ushort *)(lVar13 + 0x30);

+  lVar22 = lVar20;

+  local_118 = uVar10;

+  if (local_res10 != *(ushort *)(lVar13 + 0x30)) {

+    iVar7 = _GetStoragePropertyPost_SC_DEVICE__MEAAJW4_STORAGE_PROPERTY_ID__PEAU_STORAGE_DESCRIPTOR_HEADER___Z

+                      (_Except);

+    if (iVar7 == 0) {

+      if (uVar16 != 0) {

+        return 0xc00000bb;

+      }

+      local_res10 = (ushort)_Except;

+    }

+    else {

+      uVar17 = uVar17 | 4;

+      uVar21 = uVar21 | 2;

+      local_168 = uVar21;

+    }

+  }

+  if (((*(byte *)(uVar2 + 0x170) & 1) != 0) && ((param_2[8] & 0x2000000) == 0)) {

+    return 0xc0000022;

+  }

+  local_138 = param_2[2];

+  uVar23 = param_2[3];

+  if (((uint)param_2[5] >> 0x1d & 1) != 0) {

+    if (uVar10 < 0x100000000) {

+      return 0xc0000018;

+    }

+    if (3 < uVar17) {

+      return 0xc0000018;

+    }

+    uVar17 = uVar17 & 0xfffffffd | 1;

+    local_168 = 0;

+    uVar21 = 0;

+    if ((*(byte *)(lVar13 + 0x2c) & 1) != 0) {

+      return 0xc0000269;

+    }

+    uVar23 = uVar23 + 0x1fffff & 0xffffffffffe00000;

+    local_138 = 0x200000;

+  }

+  if (((param_5 == 0) || ((*(uint *)(param_5 + 0x38) & 0x80000) != 0)) ||

+     (((uint)param_2[5] >> 0x12 & 1) != 0)) {

+    if (param_7 != 1) {

+      return 0xc0000045;

+    }

+    uVar17 = uVar17 | 0x400;

+  }

+  uVar14 = 0;

+  lVar13 = *(longlong *)(lVar22 + 0x38);

+  local_130 = uVar23;

+  if (((DAT_2 == 0) || ((*(uint *)(lVar13 + 0x4c) & 0x40) == 0)) || (0x3ff < uVar17)) {

+LAB_3:

+    uVar18 = 0;

+    if (uVar17 < 0x400) goto LAB_4;

   }

   else {

-    func_0x000140936238(&stack0x00000128,unaff_R14D);

-    cStack0000000000000060 = '\x01';

-    if (unaff_R12D == 0) {

-      uVar3 = in_stack_00000088;

-      uVar2 = CmLoadKey(&stack0x00000150,&stack0x00000128,unaff_R14D,0,in_stack_00000088);

-      uVar4 = (undefined4)(uVar3 >> 0x20);

+    uVar18 = uVar14;

+    if (local_138 != 0x200000) {

+      if ((((ulonglong)((uVar23 & 0xfff) != 0) + (uVar23 >> 0xc) == (ulonglong)*(uint *)(lVar22 + 8)

+           ) && ((*(uint *)(uVar2 + 0x7dc) & 4) == 0)) && ((param_8 & 0x10) == 0)) {

+        local_130 = DAT_2 + uVar23;

+        if (local_130 < uVar23) {

+          return 0xc000001f;

+        }

+        uVar18 = 0x20;

+      }

+      else {

+        iVar7 = MiDoesImageContainFunctionOverrideFixups(param_1);

+        if ((iVar7 != 0) &&

+           ((*param_4 != 0 ||

+            (((ulonglong)*(uint *)(lVar13 + 0x40) + 0xfff & 0xfffffffffffff000) < uVar23)))) {

+          uVar17 = uVar17 | 4;

+          local_168 = uVar21 | 1;

+          goto LAB_3;

+        }

+      }

+    }

+LAB_4:

+    lVar13 = local_f0;

+    uVar10 = MiAllowImageMap(uVar2,param_5,param_1);

+    if ((int)uVar10 < 0) {

+      return uVar10;

+    }

+    lVar22 = lVar20;

+    uVar14 = uVar18;

+    if (((*(uint *)(uVar2 + 0x750) & 0x10) != 0) && ((*(byte *)(lVar13 + 0x33) & 4) == 0)) {

+      if ((*(byte *)(lVar13 + 0x2c) & 1) == 0) {

+        uVar17 = uVar17 | 1;

+      }

+      else if ((*(uint *)(uVar2 + 0x750) & 8) != 0) {

+        return 0xc0000269;

+      }

+    }

+  }

+  if ((uVar17 >> 10 != 0) ||

+     (((*(ushort *)(lVar22 + 0xc) >> 0xe & 1) != 0 && ((*(uint *)(uVar2 + 0x750) & 0x40) == 0)))) {

+    uVar17 = uVar17 & 0xfffffffd | 1;

+  }

+  if (((param_8 & 4) != 0) || (uVar2 == PsSecureSystemProcess)) {

+    local_168 = 0;

+    uVar17 = uVar17 & 0xfffffff9;

+  }

+  if ((*(longlong *)((uVar9 & 0xfffffffffffffff8) + 0x20) == 0) ||

+     ((*(uint *)(param_1 + 7) >> 0xb & 1) != 0)) {

+    if ((uVar17 & 4) != 0) {

+      return 0xc0000018;

+    }

+    local_168 = 0;

+    uVar17 = uVar17 & 0xfffffffd;

+  }

+  local_f8 = 0;

+  if (uVar17 >> 10 == 0) {

+    for (plVar15 = param_1 + 0x10; plVar15 != (longlong *)0x0; plVar15 = (longlong *)plVar15[2]) {

+      if (0xb < ((byte)(int)plVar15[4] & 0xe)) {

+        uVar9 = MiArbitraryCodeBlocked(param_2[0xc]);

+        if ((int)uVar9 < 0) {

+          return uVar9;

+        }

+        break;

+      }

+    }

+  }

+  local_b0 = param_1 + 0x10;

+  MiCheckPurgeAndUpMapCount(param_1);

+  if (local_168 == 0) {

+    iVar7 = 0x88;

+    uVar19 = 0x20646156;

+  }

+  else {

+    uVar19 = 0x49646156;

+    iVar7 = (((*(uint *)(*param_1 + 8) & 0x3f) != 0) + 0x15 + (*(uint *)(*param_1 + 8) >> 6)) * 8;

+  }

+  puVar11 = (undefined8 *)MiAllocatePool(0x40,iVar7,uVar19);

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

+    MiDereferenceControlArea(param_1);

+    return 0xc000009a;

+  }

+  if (local_168 != 0) {

+    uVar17 = uVar17 | 8;

+  }

+  puVar11[2] = 0xfffffffffffffffe;

+  *puVar11 = 0xfffffffffffffffe;

+  puVar11[1] = 0xfffffffffffffffe;

+  uVar21 = 0;

+  if (param_6 == 1) {

+    uVar21 = 4;

+  }

+  uVar14 = uVar14 | uVar21;

+  uVar21 = *(uint *)(puVar11 + 6) & 0xffffffaf | 0x20;

+  *(uint *)(puVar11 + 6) = uVar21;

+  *(uint *)(puVar11 + 6) = (*(int *)((longlong)param_2 + 0x34) << 0xc ^ uVar21) & 0x7f000 ^ uVar21;

+  if (param_5 != 0) {

+    uVar19 = MiReferenceFileObjectForMap(param_5);

+    puVar11[0x10] = uVar19;

+    if (*(int *)(param_5 + 0x3c) < 0) {

+      uVar14 = uVar14 | 8;

+    }

+  }

+  uVar21 = *(uint *)(puVar11 + 6);

+  puVar11[5] = 0;

+  *(uint *)(puVar11 + 6) = uVar21 & 0xfffff0ff | 0x80;

+  uVar18 = uVar14;

+  if (uVar17 >> 10 == 0) {

+    *(uint *)(puVar11 + 6) = uVar21 & 0xfffff0ff | 0x380;

+    uVar9 = *(ulonglong *)(uVar2 + 0x170);

+    *(int *)((longlong)puVar11 + 0x34) = (int)local_120;

+    *(char *)((longlong)puVar11 + 0x22) = (char)(local_120 >> 0x20);

+    uVar18 = uVar14 | 0x10;

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

+      uVar18 = uVar14;

+    }

+  }

+  local_100 = 0;

+  local_158 = 0;

+  local_140 = SystemReserved1[0xf];

+  if (((*(uint *)((longlong)param_2 + 0x3c) & 1) == 0) || (local_138 == 0x200000)) {

+    local_160 = (uint)*param_4 + local_118;

+    local_148 = local_160;

+    if (local_138 == 0x200000) {

+      *(int *)((longlong)puVar11 + 0x34) = (int)(local_130 >> 0xc);

+      *(char *)((longlong)puVar11 + 0x22) = (char)((local_130 >> 0xc) >> 0x20);

+      uVar18 = uVar18 | 1;

+      uVar21 = MiCreateLargePageVad(uVar2,puVar11,0);

+      if ((int)uVar21 < 0) {

+        if (puVar11[0x10] != 0) {

+          ObfDereferenceObjectWithTag(puVar11[0x10],0x63536d4d);

+        }

+        MiDereferenceControlArea(param_1);

+        ExFreePoolWithTag(puVar11,0);

+        return (ulonglong)uVar21;

+      }

+    }

+  }

+  else {

+    local_160 = *param_3;

+    local_148 = local_160;

+  }

+  pvVar24 = local_140;

+  MiWriteVadFlags2(puVar11,uVar18,1);

+  uVar9 = 0;

+  local_110 = uVar9;

+  if (((((*(uint *)(puVar11 + 6) & 0xf80) == 0x380) && (*(longlong *)(uVar2 + 0x1d0) != 0)) &&

+      ((*(uint *)(uVar2 + 0x5fc) & 0x1000) == 0)) &&

+     ((local_110 = 0, (*(byte *)(uVar2 + 0x170) & 1) == 0 &&

+      (cVar6 = PsIsImageNotifyEnabled(), local_110 = uVar9, cVar6 != '\0')))) {

+    uVar17 = uVar17 | 0x800;

+  }

+  local_58 = 0x20;

+  local_108 = local_110;

+  LOCK_ADDRESS_SPACE(pvVar24,uVar2);

+  uVar9 = local_130;

+  if ((*(uint *)(uVar2 + 500) & 0x20) != 0) {

+    uVar9 = 0xc000010a;

+    goto LAB_5;

+  }

+  if (((*(uint *)((longlong)param_2 + 0x3c) & 1) == 0) || (local_138 == 0x200000)) {

+    if (0x7fffffff0000 < local_130) {

+      uVar9 = 0xc0000017;

+      goto LAB_5;

+    }

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

+      in_stack_fffffffffffffe68 = param_2[1];

+      iVar7 = MiIsVaRangeAvailable(uVar2,local_160,local_130,*param_2,in_stack_fffffffffffffe68);

+      if (iVar7 != 0) goto LAB_6;

+    }

+    uVar10 = param_2[1];

+    local_120 = 0;

+    if (((local_118 < 0x100000000) && (0xffffffff < uVar10)) &&

+       ((*(ushort *)(lVar20 + 0xc) & 0x4000) == 0)) {

+      uVar10 = 0xffffffff;

+    }

+    uVar19 = 0;

+    if ((*(short *)(lVar20 + 0xc) < 0) &&

+       ((*(longlong *)(uVar2 + 0x310) == 0 ||

+        ((*(short *)(uVar2 + 0x6ec) != 0x14c && (uVar19 = 0, *(short *)(uVar2 + 0x6ec) != 0x1c4)))))

+       ) {

+      uVar19 = 0x100000000;

+      local_120 = 0x100000000;

+    }

+    if (*param_2 < uVar10) {

+      in_stack_fffffffffffffe68 = local_138;

+      uVar21 = MiSelectUserAddress((int)param_2[5],*param_2,uVar10,uVar9,local_138,uVar19,

+                                   *(uint *)(puVar11 + 6) >> 7 & 0x1f,0,&local_100,&local_148);

+      uVar9 = (ulonglong)uVar21;

+      local_160 = local_148;

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

     }

     else {

-      uVar3 = in_stack_00000088;

-      uVar2 = func_0x0001409362fc();

-      uVar4 = (undefined4)(uVar3 >> 0x20);

-    }

-    uStack00000000000001b0 = (ulonglong)uVar2;

-    if (((CmpCallBackCount != 0) && (iVar1 = CmpIsRegistryLockAcquired(), iVar1 == 0)) &&

-       ((undefined8 **)in_stack_00000118 != &stack0x00000118)) {

-      uStack00000000000001b0 = (ulonglong)uVar2;

-      in_stack_00000140 = &stack0x00000198;

-      in_stack_00000148 = (undefined1 *)&stack0x000000d0;

-      in_stack_00000198 = unaff_RBX;

-      CmpCallCallBacksEx(0x21,&stack0x00000198,&stack0x00000140,0,CONCAT44(uVar4,0x21));

-    }

-  }

-  if (unaff_RBX != 0) {

-    ObfDereferenceObject();

-  }

-  if (in_stack_00000088 != 0) {

-    ObfDereferenceObject();

-    in_stack_00000088 = unaff_RDI;

-  }

-  if (((-1 < (int)uStack00000000000001b0) && (in_stack_00000080 != (int)unaff_RDI)) &&

-     (cStack0000000000000061 == '\0')) {

-    if (in_stack_000000b8 == (undefined1 *)0x0) {

-      in_stack_000000b8 = &stack0x000000a0;

-    }

-    uVar2 = ObReferenceObjectByName(in_stack_000000b8,0x40,0,0,CmKeyObjectType);

-    uStack00000000000001b0 = (ulonglong)uVar2;

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

-      func_0x000140936190(unaff_RDI);

-      uVar2 = ObOpenObjectByPointer

-                        (unaff_RDI,(-(uint)(unaff_R15B != '\0') & 0xfffffe00) + 0x240,0,

-                         in_stack_000004a0,CmKeyObjectType);

-      uStack00000000000001b0 = (ulonglong)uVar2;

-      ObfDereferenceObject(unaff_RDI);

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

-        *in_stack_000000b0 = in_stack_00000138;

-      }

-    }

-    if (in_stack_00000090 != 0) {

-      if (unaff_R12D == 0) {

-        CmpLockRegistry();

-        CmpDereferenceKeyControlBlock(in_stack_00000090);

-        CmpUnlockRegistry();

-        in_stack_00000090 = unaff_RDI;

+      uVar9 = 0xc0000017;

+LAB_7:

+      if (uVar10 != param_2[1]) {

+        in_stack_fffffffffffffe68 = local_138;

+        uVar21 = MiSelectUserAddress((int)param_2[5],*param_2,param_2[1],local_130,local_138,

+                                     local_120,*(uint *)(puVar11 + 6) >> 7 & 0x1f,0,&local_100,

+                                     &local_148);

+        uVar9 = (ulonglong)uVar21;

+        local_160 = local_148;

+      }

+      if ((int)uVar9 < 0) goto LAB_5;

+    }

+    uVar9 = local_130;

+    if (local_138 == 0x200000) {

+      uVar10 = param_2[3];

+      if (0xffff < local_130 - uVar10) {

+        uVar21 = ExGenRandom(1);

+        uVar10 = param_2[3];

+        local_f8 = (ulonglong)uVar21 % (uVar9 - uVar10 >> 0x10);

+      }

+      lVar13 = MiLocateLockedVadEvent(puVar11,0x10);

+      *(ulonglong *)(lVar13 + 0x10) = uVar10 >> 0xc;

+      *(char *)(lVar13 + 8) = (char)local_f8;

+    }

+  }

+  else {

+    in_stack_fffffffffffffe68 = param_2[1];

+    iVar7 = MiIsVaRangeAvailable(uVar2,local_160,local_130,*param_2,in_stack_fffffffffffffe68);

+    if (iVar7 == 0) {

+      uVar9 = 0xc0000018;

+      goto LAB_5;

+    }

+  }

+LAB_6:

+  uVar21 = uVar17;

+  if ((local_160 - (uint)*param_4 != local_118) && (local_158 = 0x40000003, (uVar17 & 2) != 0)) {

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

+      puVar12 = (undefined8 *)

+                MiAllocatePool(0x40,(((*(uint *)(*param_1 + 8) & 0x3f) != 0) + 0x15 +

+                                    (*(uint *)(*param_1 + 8) >> 6)) * 8,0x49646156);

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

+        uVar19 = puVar11[1];

+        *puVar12 = *puVar11;

+        puVar12[1] = uVar19;

+        uVar19 = puVar11[3];

+        puVar12[2] = puVar11[2];

+        puVar12[3] = uVar19;

+        uVar19 = puVar11[5];

+        puVar12[4] = puVar11[4];

+        puVar12[5] = uVar19;

+        uVar19 = puVar11[7];

+        puVar12[6] = puVar11[6];

+        puVar12[7] = uVar19;

+        uVar19 = puVar11[9];

+        puVar12[8] = puVar11[8];

+        puVar12[9] = uVar19;

+        uVar19 = puVar11[0xb];

+        puVar12[10] = puVar11[10];

+        puVar12[0xb] = uVar19;

+        uVar8 = *(undefined4 *)((longlong)puVar11 + 100);

+        uVar4 = *(undefined4 *)(puVar11 + 0xd);

+        uVar5 = *(undefined4 *)((longlong)puVar11 + 0x6c);

+        *(undefined4 *)(puVar12 + 0xc) = *(undefined4 *)(puVar11 + 0xc);

+        *(undefined4 *)((longlong)puVar12 + 100) = uVar8;

+        *(undefined4 *)(puVar12 + 0xd) = uVar4;

+        *(undefined4 *)((longlong)puVar12 + 0x6c) = uVar5;

+        uVar8 = *(undefined4 *)((longlong)puVar11 + 0x74);

+        uVar4 = *(undefined4 *)(puVar11 + 0xf);

+        uVar5 = *(undefined4 *)((longlong)puVar11 + 0x7c);

+        *(undefined4 *)(puVar12 + 0xe) = *(undefined4 *)(puVar11 + 0xe);

+        *(undefined4 *)((longlong)puVar12 + 0x74) = uVar8;

+        *(undefined4 *)(puVar12 + 0xf) = uVar4;

+        *(undefined4 *)((longlong)puVar12 + 0x7c) = uVar5;

+        puVar12[0x10] = puVar11[0x10];

+        ExFreePoolWithTag(puVar11,0);

+        uVar17 = uVar17 | 8;

+        puVar11 = puVar12;

+      }

+      uVar21 = uVar17;

+      if ((uVar17 & 8) == 0) goto LAB_8;

+    }

+    local_168 = local_168 | 1;

+    local_158 = 0x40000036;

+    uVar21 = uVar17;

+  }

+LAB_8:

+  uVar10 = (ulonglong)local_168;

+  local_118 = local_160 >> 0xc;

+  local_120 = (local_130 - 1) + local_160 >> 0xc;

+  uVar19 = MiUpdateVadStartVpn(puVar11,local_118,param_4,uVar10);

+  *(int *)((longlong)puVar11 + 0x1c) = (int)uVar19;

+  *(char *)((longlong)puVar11 + 0x21) = (char)((ulonglong)uVar19 >> 0x20);

+  uVar9 = *param_4 >> 0xc;

+  for (plVar15 = local_b0; *(uint *)((longlong)plVar15 + 0x2c) <= uVar9;

+      plVar15 = (longlong *)plVar15[2]) {

+    uVar9 = uVar9 - *(uint *)((longlong)plVar15 + 0x2c);

+  }

+  puVar11[9] = plVar15;

+  puVar11[10] = plVar15[1] + uVar9 * 8;

+  puVar11[0xb] = *(longlong *)(lVar20 + 0x40) + ((ulonglong)*(uint *)(lVar20 + 8) - 1) * 8;

+  if ((uVar21 & 8) != 0) {

+    MiInitializeFixupVad(puVar11,uVar10 & 0xffffffff,*(uint *)(uVar2 + 0x5fc) >> 0xd & 1);

+  }

+  if (*(int *)((longlong)param_2 + 0x34) != 0) {

+    *(undefined1 *)(*(longlong *)(uVar2 + 0x410) + 0x424) = 1;

+  }

+  if ((*(uint *)(param_1 + 7) & 0x8000000) != 0) {

+    uVar8 = PsGetProcessSessionIdEx(uVar2);

+    uVar14 = MiCreatePerSessionProtos(param_1,uVar8);

+    uVar9 = (ulonglong)uVar14;

+    uVar17 = uVar21;

+    if ((int)uVar14 < 0) goto LAB_5;

+    uVar21 = uVar21 | 0x100;

+  }

+  if ((uVar18 & 0x10) != 0) {

+    uVar8 = *(undefined4 *)((longlong)puVar11 + 0x34);

+    uVar1 = *(undefined1 *)((longlong)puVar11 + 0x22);

+    lVar13 = MiUpdatePrivateDemandZeroView(uVar2,puVar11,0);

+    lVar13 = lVar13 + (ulonglong)CONCAT14(uVar1,uVar8);

+    *(int *)((longlong)puVar11 + 0x34) = (int)lVar13;

+    *(char *)((longlong)puVar11 + 0x22) = (char)((ulonglong)lVar13 >> 0x20);

+    local_a0 = local_140;

+    MiInsertVadEvent(puVar11,local_a8,0);

+    uVar21 = uVar21 | 0x40;

+    local_160 = local_148;

+    local_108 = local_110;

+  }

+  uVar14 = MiInsertSharedCommitNode(param_1,uVar2,0);

+  uVar9 = (ulonglong)uVar14;

+  uVar17 = uVar21;

+  if ((int)uVar14 < 0) {

+LAB_5:

+    if ((uVar17 >> 8 & 1) != 0) {

+      uVar8 = PsGetProcessSessionIdEx(uVar2);

+      MiDereferencePerSessionProtos(param_1,uVar8);

+    }

+    if ((uVar17 >> 9 & 1) != 0) {

+      MiReturnCrossPartitionControlAreaCharges(param_1);

+    }

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

+      MiRemoveSharedCommitNode(param_1,uVar2,0);

+    }

+    UNLOCK_ADDRESS_SPACE_UNORDERED(local_140,uVar2);

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

+      MiRemoveVadEvent(puVar11,local_a8);

+    }

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

+      if (local_138 == 0x200000) {

+        MiReleaseVadEventBlocks(puVar11,0);

+      }

+      if (puVar11[0x10] != 0) {

+        ObfDereferenceObjectWithTag(puVar11[0x10],0x63536d4d);

+      }

+      ExFreePoolWithTag(puVar11,0);

+    }

+    MiDereferenceControlArea(param_1);

+    return uVar9;

+  }

+  uVar17 = uVar21 | 0x80;

+  iVar7 = MiControlAreaRequiresCharge(param_1,(param_8 & 8) != 0);

+  if (iVar7 == 0) {

+    uVar9 = 0xc000060b;

+    goto LAB_5;

+  }

+  if (iVar7 == 2) {

+    uVar14 = MiReferenceActiveSubsection

+                       (param_1 + 0x10,(-(uint)((param_8 & 8) != 0) & 0x100) + 8,0x11);

+    uVar9 = (ulonglong)uVar14;

+    if ((int)uVar14 < 0) goto LAB_5;

+    uVar17 = uVar21 | 0x280;

+  }

+  uVar21 = MiInsertVadCharges(puVar11,uVar2);

+  uVar9 = (ulonglong)uVar21;

+  if ((int)uVar21 < 0) goto LAB_5;

+  if ((uVar17 & 8) != 0) {

+    *(longlong *)(*(longlong *)(uVar2 + 0x410) + 0x440) =

+         *(longlong *)(*(longlong *)(uVar2 + 0x410) + 0x440) + 1;

+    local_160 = local_148;

+    local_108 = local_110;

+  }

+  MiInsertVad(puVar11,uVar2,0);

+  lVar13 = 0;

+  if (local_138 == 0x200000) {

+    MiLockVad(local_140,puVar11);

+    uVar21 = MiMapUserLargePages(puVar11,0,0,0);

+    uVar9 = (ulonglong)uVar21;

+    if ((int)uVar21 < 0) {

+      UNLOCK_ADDRESS_SPACE_UNORDERED(local_140,uVar2);

+      goto LAB_9;

+    }

+    MiUnlockVad(local_140,puVar11);

+  }

+  if (local_100 != 0) {

+    MiAdvanceVadHint(local_118,local_120);

+  }

+  local_160 = local_160 + local_f8 * 0x10000;

+  *param_3 = local_160;

+  if ((*(char *)(local_f0 + 0x32) != '\0') && (local_res10 != local_128)) {

+    uVar21 = uVar17 | 0x1000;

+    if ((*(longlong *)(uVar2 + 0x310) != 0) && (*(short *)(local_f0 + 0x30) == -0x799c)) {

+      uVar21 = uVar17;

+    }

+    uVar17 = uVar21;

+    if ((uVar17 & 0x1000) != 0) {

+      local_158 = 0x4000000e;

+    }

+  }

+  local_148 = local_160;

+  if ((PerfGlobalGroupMask & 0x8000) != 0) {

+    MiLogMapFileEvent(puVar11,0x425);

+  }

+  if (((uVar18 & 0x20) != 0) &&

+     (iVar7 = MiDoesImageContainFunctionOverrideFixups(param_1), iVar7 != 0)) {

+    MiMapImageScpCfgPages(uVar2,puVar11);

+  }

+  uVar21 = uVar17 | 0x10;

+  if ((uVar17 & 0x400) == 0) {

+    if ((((NtGlobalFlag & 0x40000) != 0) &&

+        (((0x33 < local_158 + 0xbffffffd ||

+          ((0x8000000000801U >> ((ulonglong)(local_158 + 0xbffffffd) & 0x3f) & 1) == 0)) &&

+         ((*(byte *)((longlong)local_140 + 0x5a8) & 0x20) == 0)))) &&

+       (((*(ushort *)(lVar20 + 0xc) & 0x800) == 0 && ((*(byte *)(lVar20 + 0xe) & 0x20) != 0)))) {

+      *(ushort *)(lVar20 + 0xc) = *(ushort *)(lVar20 + 0xc) | 0x800;

+      MiLoadUserSymbols(param_1,local_160,uVar2);

+    }

+    uVar9 = MiReadVadFlags2();

+    uVar19 = uStack_e0;

+    if ((uVar17 & 0x800) != 0) {

+      uStack_e0 = CONCAT71(uStack_e0._1_7_,3);

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

+        uVar14 = (uint)*(byte *)(lVar20 + 0xf) << 0xc;

+        uStack_e0._0_4_ = ((uint)uStack_e0 ^ uVar14) & 0xf000 ^ (uint)uStack_e0;

+        uStack_e0._0_4_ = ((uint)uStack_e0 ^ uVar14) & 0x70000 ^ (uint)uStack_e0;

+        local_160 = local_148;

       }

       else {

-        CmReleaseLoadKeyContext(in_stack_00000090,uStack00000000000001b0);

-        in_stack_00000090 = unaff_RDI;

-      }

-    }

-    if (((int)uStack00000000000001b0 < 0) && ((unaff_R14D >> 0xb & 1) != 0)) {

-      uStack00000000000001b0 = unaff_RDI & 0xffffffff;

-    }

-  }

-  if (in_stack_00000090 != 0) {

-    CmReleaseLoadKeyContext(in_stack_00000090,uStack00000000000001b0);

-  }

-  if ((in_stack_000000b8 != (undefined1 *)0x0) && (in_stack_000000b8 != &stack0x000000a0)) {

-    CmpFreePoolWithTag(in_stack_000000b8,0x624e4d43);

-  }

-  if (in_stack_00000100 != 0) {

-    ZwClose();

-  }

-  if (cStack0000000000000062 != (char)unaff_RDI) {

-    KeLeaveCriticalRegion();

-  }

-  if (in_stack_00000108 != 0) {

-    ObfDereferenceObject();

-  }

-  if (in_stack_000000c0 != 0) {

-    ObfDereferenceObject();

-  }

-  if (in_stack_00000068 != 0) {

-    ObfDereferenceObject(in_stack_00000068);

-  }

-  if (in_stack_00000088 != 0) {

-    ObfDereferenceObject();

-  }

-  if (in_stack_00000110 != 0) {

-    SeFreePrivileges(in_stack_00000110);

-  }

-  if (in_stack_00000130 != 0) {

-    ExFreePoolWithTag(in_stack_00000130,0);

-  }

-  func_0x000140935c10(&stack0x00000250,0);

-  if (in_stack_00000070 != (char)unaff_RDI) {

-    CmpReleaseHiveLoadUnloadRundown();

-  }

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

-    func_0x000140935cf0(uStack00000000000001b0);

-  }

-  CmpCleanupThreadInfo(&stack0x000001d0);

-  return uStack00000000000001b0;

+        uStack_e0._0_4_ = (uint)uStack_e0 & 0xfff80fff;

+      }

+      uStack_e0._0_4_ = (uVar21 >> 1 ^ (uint)uStack_e0) & 0x800 ^ (uint)uStack_e0;

+      uStack_e0._4_4_ = SUB84(uVar19,4);

+      local_d8 = local_160;

+      local_c8 = param_2[3];

+      LOCK();

+      uVar10 = *(ulonglong *)(lVar20 + 0x18);

+      if (uVar10 == 0xffffffffffffffff) {

+        *(ulonglong *)(lVar20 + 0x18) = 0xffffffffffffffff;

+        uVar10 = 0xffffffffffffffff;

+      }

+      UNLOCK();

+      if (param_2[3] != uVar10) {

+        uStack_e0._0_4_ = (uint)uStack_e0 | 0x80000;

+      }

+      uStack_d0 = uStack_d0 & 0xffffffff00000000;

+      uStack_c0 = uStack_c0 & 0xffffffff00000000;

+      lVar13 = MiReferenceControlAreaFile(param_1);

+      uVar21 = uVar17 | 0x30;

+      local_160 = local_148;

+      local_108 = local_110;

+    }

+    if ((((int)param_2[0xf] != 0) || ((uVar9 & 0x10) != 0)) ||

+       ((param_2[9] != 0 || ((param_2[8] & 2) != 0)))) {

+      uVar21 = uVar21 | 0x20;

+    }

+  }

+  pvVar24 = local_140;

+  if ((uVar21 & 0x20) != 0) {

+    MiLockVad(local_140,puVar11);

+    UNLOCK_ADDRESS_SPACE_UNORDERED(local_140);

+    uVar9 = MiReadVadFlags2(puVar11);

+    uVar17 = uVar21 & 0xffffffef;

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

+      MiUpdatePrivateDemandZeroView(uVar2,puVar11,1);

+      MiRemoveVadEvent(puVar11);

+      uVar17 = uVar21 & 0xffffffaf;

+    }

+    uVar21 = uVar17;

+    if (((uVar21 >> 10 & 1) == 0) && ((int)param_2[0xf] != 0)) {

+      uVar17 = MiCommitVadMetadataBits(puVar11);

+      uVar9 = (ulonglong)uVar17;

+      if ((int)uVar17 < 0) goto LAB_9;

+    }

+    uVar9 = local_108;

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

+      iVar7 = *(int *)((longlong)param_2 + 0x44);

+      if (((1 < iVar7 - 1U) && (iVar7 != -0x7fffffff)) && (iVar7 != 4)) {

+        uVar9 = 0xc0000045;

+        goto LAB_9;

+      }

+      in_stack_fffffffffffffe68 = in_stack_fffffffffffffe68 & 0xffffffff00000000;

+      uVar17 = MiSecureVad(puVar11,local_160,param_2[3],iVar7,in_stack_fffffffffffffe68,&local_110);

+      uVar9 = (ulonglong)uVar17;

+      if ((int)uVar17 < 0) goto LAB_9;

+      *(ulonglong *)param_2[9] = uVar2 ^ local_110 ^ _DAT_10;

+      uVar9 = 0;

+    }

+    if (((uVar21 & 0x800) != 0) &&

+       (uVar9 = MiAddSecureEntry(puVar11,local_118 << 0xc,local_120 << 0xc | 0xfff,0x80000001,

+                                 in_stack_fffffffffffffe68 & 0xffffffff00000000), uVar9 == 0)) {

+      uVar9 = 0xc000009a;

+LAB_9:

+      MiReferenceVad(puVar11);

+      if (lVar13 != 0) {

+        ObfDereferenceObjectWithTag(lVar13,0x63536d4d);

+      }

+      MiUnmapVad(puVar11,0,0);

+      if ((undefined8 *)param_2[9] != (undefined8 *)0x0) {

+        *(undefined8 *)param_2[9] = 0;

+        return uVar9;

+      }

+      return uVar9;

+    }

+    if ((param_2[8] & 2) != 0) {

+      MiSoftFaultMappedView(puVar11);

+    }

+    pvVar24 = local_140;

+    MiUnlockVad(local_140,puVar11);

+    if ((uVar21 & 0x800) != 0) {

+      PsCallImageNotifyRoutines(lVar13 + 0x58,uVar2,&local_e8,lVar13);

+      ObfDereferenceObjectWithTag(lVar13,0x63536d4d);

+    }

+    if (uVar9 != 0) {

+      MmUnsecureVirtualMemory(uVar2 ^ uVar9 ^ _DAT_10);

+    }

+  }

+  if ((uVar21 & 0x10) != 0) {

+    UNLOCK_ADDRESS_SPACE_UNORDERED(pvVar24,uVar2);

+  }

+  if ((((uVar21 >> 10 & 1) == 0) && (param_5 != 0)) && ((*(byte *)(uVar2 + 0x170) & 1) == 0)) {

+    *(uint *)((longlong)param_2 + 0x3c) = *(uint *)((longlong)param_2 + 0x3c) | 4;

+  }

+  return (ulonglong)local_158;

 }
```

## `PspBuildCreateProcessContext`  (modified)

```diff
--- PspBuildCreateProcessContext
+++ PspBuildCreateProcessContext
@@ -1,10 +1,898 @@
 

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

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

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

 

-void PspBuildCreateProcessContext(void)

+ulonglong PspBuildCreateProcessContext(ulonglong *param_1,char param_2,int param_3,char *param_4)

 

 {

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

-  halt_baddata();

+  ushort uVar1;

+  uint uVar2;

+  void *pvVar3;

+  ushort *puVar4;

+  undefined1 *_Src;

+  ulonglong uVar5;

+  char cVar6;

+  int iVar7;

+  char *_Dst;

+  void *pvVar8;

+  undefined8 *puVar9;

+  longlong lVar10;

+  undefined4 *puVar11;

+  undefined1 *puVar12;

+  undefined8 *puVar13;

+  ulonglong uVar14;

+  char *pcVar15;

+  bool bVar16;

+  undefined4 uVar17;

+  undefined4 uVar18;

+  undefined4 uVar19;

+  undefined4 uVar20;

+  undefined8 uVar21;

+  undefined1 auStack_2d8 [32];

+  undefined4 local_2b8;

+  undefined8 *local_2b0;

+  longlong local_2a8;

+  longlong local_2a0;

+  undefined4 *local_298;

+  uint local_288;

+  ulonglong *local_280;

+  char *local_278;

+  ulonglong local_270;

+  ulonglong local_268;

+  undefined8 *local_260;

+  undefined4 local_258;

+  uint local_254;

+  undefined4 local_250;

+  undefined4 local_24c;

+  ushort local_248;

+  int local_244;

+  void *local_240;

+  undefined8 local_238;

+  void *pvStack_230;

+  undefined8 local_228;

+  undefined4 local_220;

+  char *local_218;

+  ulonglong local_208;

+  undefined8 local_200;

+  char *local_1f8;

+  undefined1 *local_1f0;

+  undefined1 *local_1e8;

+  ushort *local_1e0;

+  void *local_1d8;

+  undefined8 local_1d0;

+  undefined8 uStack_1c8;

+  undefined8 local_1c0;

+  longlong lStack_1b8;

+  ulonglong local_1b0;

+  undefined8 uStack_1a8;

+  undefined4 *local_1a0;

+  char *local_198;

+  void *local_190;

+  void *local_188;

+  undefined1 *local_180;

+  undefined1 *local_178;

+  undefined1 *local_170;

+  undefined8 *local_168;

+  undefined4 *local_160;

+  undefined4 *local_158;

+  ulonglong local_150;

+  void *local_148;

+  ushort *local_140;

+  void *local_138;

+  undefined4 *local_130;

+  undefined4 *local_128;

+  uint *local_120;

+  undefined4 *local_118;

+  void *local_110;

+  ulonglong *local_100;

+  ulonglong *local_f0;

+  void *local_e8;

+  void *local_e0;

+  ulonglong local_d8;

+  undefined4 local_c8;

+  undefined4 uStack_c4;

+  undefined4 uStack_c0;

+  undefined4 uStack_bc;

+  undefined8 local_b8;

+  undefined4 local_a8;

+  undefined4 uStack_a4;

+  undefined4 uStack_a0;

+  undefined4 uStack_9c;

+  undefined8 local_98;

+  ulonglong local_88;

+  ulonglong local_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  undefined8 local_60;

+  undefined8 uStack_58;

+  undefined8 local_50;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_2d8;

+  local_1d0 = 0;

+  uStack_1c8 = 0;

+  local_1c0 = 0;

+  lStack_1b8 = 0;

+  local_1b0 = 0;

+  uStack_1a8 = 0;

+  local_238 = 0;

+  pvStack_230 = (void *)0x0;

+  local_228 = 0;

+  local_220 = 0;

+  local_60 = 0;

+  uStack_58 = 0;

+  local_50 = 0;

+  local_78 = 0;

+  uStack_70 = 0;

+  local_68 = 0;

+  local_258 = 0;

+  local_250 = 0;

+  local_200 = 0;

+  local_270 = 0;

+  local_208 = 0;

+  local_254 = 0;

+  *param_4 = param_2;

+  local_278 = param_4;

+  local_244 = param_3;

+  local_218 = param_4;

+  local_1f8 = param_4;

+  if ((param_2 != '\0') && (((ulonglong)param_1 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+    ExRaiseDatatypeMisalignment();

+  }

+  local_268 = *param_1;

+  if (0x27 < local_268) {

+    if (((param_2 != '\0') && (local_268 != 0x28)) && (((ulonglong)param_1 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+      ExRaiseDatatypeMisalignment();

+    }

+    if ((local_268 - 8 & 0x1f) == 0) {

+      local_268 = local_268 - 8 >> 5;

+      param_1 = param_1 + 1;

+      pcVar15 = param_4;

+LAB_0:

+      local_280 = param_1;

+      if (local_268 == 0) {

+        uVar14 = 0;

+LAB_1:

+        local_288 = (uint)uVar14;

+LAB_2:

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

+          if ((*(uint *)(param_4 + 8) >> 0xb & 1) != 0) {

+            qsort(*(void **)(param_4 + 0x128),(ulonglong)*(uint *)(param_4 + 0x124),8,

+                  PspSortHandleList);

+            if (**(int **)(param_4 + 0x128) < 0) {

+              uVar14 = 0xc000000d;

+            }

+            param_4[0x10] = local_244 != 0 | param_4[0x10] & 0xfeU;

+          }

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

+            return uVar14;

+          }

+        }

+        PspDeleteCreateProcessContext(param_4);

+        return uVar14;

+      }

+      local_d8 = *param_1;

+      if (((param_3 == 0) || ((local_d8 >> 0x10 & 1) != 0)) &&

+         (((local_d8 >> 0x11 & 1) == 0 || (param_1[3] == 0)))) {

+        local_88 = 1L << ((byte)local_d8 & 0x3f);

+        if ((local_88 & *(ulonglong *)(param_4 + 8)) != 0) goto LAB_3;

+        *(ulonglong *)(param_4 + 8) = *(ulonglong *)(param_4 + 8) | local_88;

+        if (local_d8 < 0x20018) {

+          if (local_d8 == 0x20017) {

+            local_270 = param_1[1];

+            if (local_270 == 0x20c) {

+              pvVar3 = (void *)param_1[2];

+              local_138 = pvVar3;

+              pvVar8 = (void *)ExAllocatePool2(0x41,0x20c,0x634f7350);

+              *(void **)(param_4 + 400) = pvVar8;

+              if (pvVar8 == (void *)0x0) goto LAB_4;

+              RtlCopyMemory(pvVar8,pvVar3,0x20c);

+              param_4[0x18c] = '\f';

+              param_4[0x18d] = '\x02';

+              param_4[0x18e] = '\0';

+              param_4[399] = '\0';

+              pcVar15 = local_278;

+              if ((**(uint **)(param_4 + 400) & 0x40) == 0) goto LAB_5;

+            }

+          }

+          else if (local_d8 < 0x2000c) {

+            if (local_d8 == 0x2000b) {

+              uVar14 = param_1[1];

+              local_270 = uVar14;

+              if (((uVar14 != 0) && ((uVar14 & 7) == 0)) &&

+                 ((uVar14 & 0xfffffffffffffff8) < 0x7fffffff9)) {

+                pvVar3 = (void *)param_1[2];

+                local_240 = pvVar3;

+                if ((param_2 != '\0') && (((ulonglong)pvVar3 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                pvVar8 = (void *)ExAllocatePool2(0x41,uVar14,0x6c487350);

+                *(void **)(param_4 + 0x128) = pvVar8;

+                if (pvVar8 == (void *)0x0) goto LAB_4;

+                RtlCopyMemory(pvVar8,pvVar3,uVar14);

+                *(int *)(param_4 + 0x124) = (int)(uVar14 >> 3);

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 6) {

+              if (param_1[1] == 0x40) {

+                local_170 = (undefined1 *)param_1[2];

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

+                  if (((ulonglong)local_170 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                    ExRaiseDatatypeMisalignment();

+                  }

+                  puVar12 = local_170;

+                  if ((undefined1 *)0x7ffffffeffff < local_170) {

+                    puVar12 = &DAT_6;

+                  }

+                  *puVar12 = *puVar12;

+                  puVar12[0x3f] = puVar12[0x3f];

+                }

+                *(undefined1 **)(param_4 + 0x28) = local_170;

+                local_260 = (undefined8 *)param_1[3];

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

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

+                    if (((ulonglong)local_260 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                      ExRaiseDatatypeMisalignment();

+                    }

+                    puVar13 = local_260;

+                    if ((undefined8 *)0x7ffffffeffff < local_260) {

+                      puVar13 = (undefined8 *)&DAT_6;

+                    }

+                    *(undefined1 *)puVar13 = *(undefined1 *)puVar13;

+                    *(undefined1 *)((longlong)puVar13 + 7) = *(undefined1 *)((longlong)puVar13 + 7);

+                  }

+                  *local_260 = 0x40;

+                }

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x10003) {

+              if (param_1[1] == 0x10) {

+                local_178 = (undefined1 *)param_1[2];

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

+                  if (((ulonglong)local_178 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                    ExRaiseDatatypeMisalignment();

+                  }

+                  puVar12 = local_178;

+                  if ((undefined1 *)0x7ffffffeffff < local_178) {

+                    puVar12 = &DAT_6;

+                  }

+                  *puVar12 = *puVar12;

+                  puVar12[0xf] = puVar12[0xf];

+                }

+                *(undefined1 **)(param_4 + 0x18) = local_178;

+                local_260 = (undefined8 *)param_1[3];

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

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

+                    if (((ulonglong)local_260 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                      ExRaiseDatatypeMisalignment();

+                    }

+                    puVar13 = local_260;

+                    if ((undefined8 *)0x7ffffffeffff < local_260) {

+                      puVar13 = (undefined8 *)&DAT_6;

+                    }

+                    *(undefined1 *)puVar13 = *(undefined1 *)puVar13;

+                    *(undefined1 *)((longlong)puVar13 + 7) = *(undefined1 *)((longlong)puVar13 + 7);

+                  }

+                  *local_260 = 0x10;

+                }

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x10004) {

+              if (param_1[1] == 8) {

+                local_180 = (undefined1 *)param_1[2];

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

+                  if (((ulonglong)local_180 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                    ExRaiseDatatypeMisalignment();

+                  }

+                  puVar12 = local_180;

+                  if ((undefined1 *)0x7ffffffeffff < local_180) {

+                    puVar12 = &DAT_6;

+                  }

+                  *puVar12 = *puVar12;

+                  puVar12[7] = puVar12[7];

+                }

+                *(undefined1 **)(param_4 + 0x20) = local_180;

+                local_260 = (undefined8 *)param_1[3];

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

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

+                    if (((ulonglong)local_260 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                      ExRaiseDatatypeMisalignment();

+                    }

+                    puVar13 = local_260;

+                    if ((undefined8 *)0x7ffffffeffff < local_260) {

+                      puVar13 = (undefined8 *)&DAT_6;

+                    }

+                    *(undefined1 *)puVar13 = *(undefined1 *)puVar13;

+                    *(undefined1 *)((longlong)puVar13 + 7) = *(undefined1 *)((longlong)puVar13 + 7);

+                  }

+                  *local_260 = 8;

+                }

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x20005) {

+              uVar14 = param_1[1];

+              local_270 = uVar14;

+              if (((uVar14 != 0) && ((uVar14 & 1) == 0)) && (uVar14 < 0x10000)) {

+                pvVar3 = (void *)param_1[2];

+                local_188 = pvVar3;

+                local_e8 = (void *)ExAllocatePool2(0x41,uVar14,0x6e467350);

+                if (local_e8 == (void *)0x0) goto LAB_4;

+                param_4[0xf0] = '\0';

+                param_4[0xf1] = '\0';

+                param_4[0xf2] = '\0';

+                param_4[0xf3] = '\0';

+                param_4[0xf4] = '\0';

+                param_4[0xf5] = '\0';

+                param_4[0xf6] = '\0';

+                param_4[0xf7] = '\0';

+                param_4[0xf8] = '\0';

+                param_4[0xf9] = '\0';

+                param_4[0xfa] = '\0';

+                param_4[0xfb] = '\0';

+                param_4[0xfc] = '\0';

+                param_4[0xfd] = '\0';

+                param_4[0xfe] = '\0';

+                param_4[0xff] = '\0';

+                *(short *)(param_4 + 0xf2) = (short)uVar14;

+                *(void **)(param_4 + 0xf8) = local_e8;

+                RtlCopyMemory(local_e8,pvVar3,uVar14);

+                *(short *)(param_4 + 0xf0) = (short)uVar14;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x20007) {

+              uVar14 = param_1[1];

+              local_270 = uVar14;

+              if ((uVar14 != 0) && ((uVar14 & 0xf) == 0)) {

+                pvVar3 = (void *)param_1[2];

+                local_190 = pvVar3;

+                if ((param_2 != '\0') && (((ulonglong)pvVar3 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                if (uVar14 < 0x11) {

+                  _Dst = param_4 + 0x108;

+                  *(char **)(pcVar15 + 0x118) = _Dst;

+                }

+                else {

+                  _Dst = (char *)ExAllocatePool2(0x41,uVar14,0x6c527350);

+                  *(char **)(local_278 + 0x118) = _Dst;

+                  if (_Dst == (char *)0x0) goto LAB_4;

+                }

+                RtlCopyMemory(_Dst,pvVar3,uVar14);

+                *(ulonglong *)(param_4 + 0x100) = uVar14 >> 4;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x20008) {

+              if (param_1[1] == 1) {

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

+                param_4[2] = *local_198;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x20009) {

+              if (param_1[1] == 4) {

+                local_1a0 = (undefined4 *)param_1[2];

+                if ((param_2 != '\0') && (((ulonglong)local_1a0 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                *(undefined4 *)(param_4 + 0x13c) = *local_1a0;

+                goto LAB_5;

+              }

+            }

+            else if ((local_d8 == 0x2000a) && (param_1[1] == 8)) {

+              local_f0 = (ulonglong *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_f0 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              local_208 = *local_f0;

+              if ((local_208 & 0x1c) == 0) {

+                local_254 = (uint)local_208 & 3;

+                if ((byte)local_254 < 3) {

+                  param_4[0x11] = (byte)local_254 << 2 | param_4[0x11] & 0xf3U;

+                  if (local_254 == 1) {

+                    *(int *)(param_4 + 0x120) = (int)(local_208 >> 0x20);

+                  }

+                  goto LAB_5;

+                }

+                goto LAB_3;

+              }

+              uVar14 = 0xc00000bb;

+              goto LAB_1;

+            }

+          }

+          else if (local_d8 == 0x2000d) {

+            if (param_1[1] == 2) {

+              local_140 = (ushort *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_140 & 1) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              uVar1 = *local_140;

+              local_248 = uVar1;

+              if ((uVar1 < KeNumberNodes) &&

+                 (iVar7 = KeIsEmptyGroupMask((&KeNodeBlock)[uVar1] + 0x10), iVar7 == 0)) {

+                *(ushort *)(param_4 + 0xaa) = uVar1;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+            }

+          }

+          else if (local_d8 == 0x20010) {

+            local_270 = param_1[1];

+            if (local_270 < 0x19) {

+              local_78 = 0;

+              uStack_70 = 0;

+              local_68 = 0;

+              puVar12 = (undefined1 *)param_1[2];

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

+                RtlCopyMemory(&local_78,puVar12,local_270);

+              }

+              else {

+                if ((undefined1 *)0x7ffffffeffff < puVar12) {

+                  puVar12 = &DAT_6;

+                }

+                RtlCopyVolatileMemory(&local_78,puVar12,local_270);

+              }

+              local_c8 = (undefined4)local_78;

+              uStack_c4 = local_78._4_4_;

+              uStack_c0 = (undefined4)uStack_70;

+              uStack_bc = uStack_70._4_4_;

+              local_b8 = local_68;

+              uVar17 = (undefined4)local_78;

+              uVar18 = local_78._4_4_;

+              uVar19 = (undefined4)uStack_70;

+              uVar20 = uStack_70._4_4_;

+              uVar21 = local_68;

+              local_288 = PspValidateMitigationOptions(&local_c8,0);

+              uVar14 = (ulonglong)local_288;

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

+                *(undefined4 *)(param_4 + 0x150) = uVar17;

+                *(undefined4 *)(param_4 + 0x154) = uVar18;

+                *(undefined4 *)(param_4 + 0x158) = uVar19;

+                *(undefined4 *)(param_4 + 0x15c) = uVar20;

+                *(undefined8 *)(param_4 + 0x160) = uVar21;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+              goto LAB_2;

+            }

+          }

+          else if (local_d8 == 0x20012) {

+            uVar14 = param_1[1];

+            local_270 = uVar14;

+            if (((uVar14 != 0) && ((uVar14 & 7) == 0)) && (uVar14 < 0x89)) {

+              pvVar3 = (void *)param_1[2];

+              local_148 = pvVar3;

+              if ((param_2 != '\0') && (((ulonglong)pvVar3 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              pvVar8 = (void *)ExAllocatePool2(0x41,uVar14,0x61547350);

+              *(void **)(param_4 + 0x168) = pvVar8;

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

+                RtlCopyMemory(pvVar8,pvVar3,uVar14);

+                *(int *)(param_4 + 0x178) = (int)uVar14;

+                cVar6 = IsTrustletCreateAttributeWellFormed(*(undefined8 *)(param_4 + 0x168),uVar14)

+                ;

+                goto LAB_7;

+              }

+LAB_4:

+              uVar14 = 0xc000009a;

+              goto LAB_1;

+            }

+          }

+          else if (local_d8 == 0x20013) {

+            uVar14 = param_1[1];

+            local_270 = uVar14;

+            if (((uVar14 != 0) && ((uVar14 & 7) == 0)) &&

+               ((uVar14 & 0xfffffffffffffff8) < 0x7fffffff9)) {

+              pvVar3 = (void *)param_1[2];

+              local_240 = pvVar3;

+              if ((param_2 != '\0') && (((ulonglong)pvVar3 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              lVar10 = ExAllocatePool2(0x41,uVar14,0x6c4a7350);

+              *(longlong *)(param_4 + 0x170) = lVar10;

+              if (lVar10 == 0) goto LAB_4;

+              *(int *)(param_4 + 0x17c) = (int)(uVar14 >> 3);

+              local_150 = 0;

+              while (uVar5 = local_150, pcVar15 = local_278, local_150 < *(uint *)(param_4 + 0x17c))

+              {

+                local_2a0 = 0;

+                local_2a8 = 0;

+                local_2b0 = &local_200;

+                local_2b8 = 0x6c4a7350;

+                local_288 = ObpReferenceObjectByHandleWithTag

+                                      (*(undefined8 *)((longlong)pvVar3 + local_150 * 8),1,PsJobType

+                                       ,param_2);

+                uVar14 = (ulonglong)local_288;

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

+                *(undefined8 *)(*(longlong *)(param_4 + 0x170) + uVar5 * 8) = local_200;

+                local_150 = uVar5 + 1;

+              }

+              goto LAB_5;

+            }

+          }

+          else if (local_d8 == 0x20014) {

+            if (param_1[1] == 4) {

+              local_158 = (undefined4 *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_158 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              *(undefined4 *)(param_4 + 0x180) = *local_158;

+              goto LAB_5;

+            }

+          }

+          else if (local_d8 == 0x20015) {

+            if (param_1[1] == 4) {

+              local_160 = (undefined4 *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_160 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              *(undefined4 *)(param_4 + 0x184) = *local_160;

+              goto LAB_5;

+            }

+          }

+          else if ((local_d8 == 0x20016) && (param_1[1] == 8)) {

+            puVar13 = (undefined8 *)param_1[2];

+            local_168 = puVar13;

+            if ((param_2 != '\0') && (((ulonglong)puVar13 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+              ExRaiseDatatypeMisalignment();

+            }

+            puVar9 = (undefined8 *)ExAllocatePool2(0x41,8,0x77736350);

+            *(undefined8 **)(param_4 + 0x1b0) = puVar9;

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

+              uVar14 = 0xc0000017;

+              goto LAB_1;

+            }

+            *puVar9 = *puVar13;

+            if (((**(uint **)(param_4 + 0x1b0) & 3) != 0) &&

+               (pcVar15 = local_278, (*(uint **)(param_4 + 0x1b0))[1] - 1 < 6)) goto LAB_5;

+          }

+        }

+        else {

+          if (0x3001e < local_d8) {

+            if (local_d8 == 0x60000) {

+              if (param_1[1] == 8) {

+                *(ulonglong *)(param_4 + 0x80) = param_1[2];

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x60001) {

+              if (param_1[1] == 8) {

+                *(ulonglong *)(param_4 + 0x90) = param_1[2];

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x60002) {

+              if (param_1[1] == 8) {

+                *(ulonglong *)(param_4 + 0x98) = param_1[2];

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x60011) {

+              if (param_1[1] == 1) {

+                param_4[1] = (char)param_1[2];

+                cVar6 = RtlValidProcessProtection();

+LAB_7:

+                bVar16 = cVar6 == '\0';

+LAB_8:

+                pcVar15 = local_278;

+                if (!bVar16) goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x6001a) {

+              if (param_1[1] == 1) {

+                param_4[0x11] = -(param_1[2] != 0) & 0x80U | param_4[0x11] & 0x7fU;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x6001c) {

+              if (param_1[1] == 2) {

+                *(short *)(param_4 + 0xa8) = (short)param_1[2];

+                goto LAB_5;

+              }

+            }

+            else if (((local_d8 == 0x6001f) && (param_1[1] == 4)) &&

+                    ((param_1[2] & 0xfffffffffffffff8) == 0)) {

+              *(int *)(param_4 + 0x1e8) = (int)param_1[2];

+              goto LAB_5;

+            }

+            goto LAB_3;

+          }

+          if (local_d8 == 0x3001e) {

+            if ((param_3 != 0) && (param_1[1] == 8)) {

+              local_100 = (ulonglong *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_100 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              uVar14 = *local_100;

+              *(ulonglong *)(param_4 + 0x1e0) = uVar14;

+              local_80 = _DAT_9 | _DAT_fffff780000003d8;

+              if ((uVar14 & ~local_80) == 0) {

+                *(ulonglong *)(param_4 + 0x1e0) = (ulonglong)((uint)uVar14 & 0x40000);

+                goto LAB_5;

+              }

+            }

+            goto LAB_3;

+          }

+          if (local_d8 == 0x20018) {

+            local_270 = param_1[1];

+            if (local_270 != 0x28) goto LAB_3;

+            pvVar3 = (void *)param_1[2];

+            local_110 = pvVar3;

+            if ((param_2 != '\0') && (((ulonglong)pvVar3 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+              ExRaiseDatatypeMisalignment();

+            }

+            pvVar8 = (void *)ExAllocatePool2(0x41,0x28,0x70426e50);

+            *(void **)(param_4 + 0x198) = pvVar8;

+            if (pvVar8 == (void *)0x0) goto LAB_4;

+            local_24c = 0;

+            RtlCopyMemory(pvVar8,pvVar3,0x28);

+            puVar4 = *(ushort **)(param_4 + 0x198);

+            puVar12 = *(undefined1 **)(puVar4 + 4);

+            _Src = *(undefined1 **)(puVar4 + 0xc);

+            puVar4[4] = 0;

+            puVar4[5] = 0;

+            puVar4[6] = 0;

+            puVar4[7] = 0;

+            *(undefined8 *)(*(longlong *)(param_4 + 0x198) + 0x18) = 0;

+            uVar1 = puVar4[1];

+            local_1f0 = puVar12;

+            local_1e8 = _Src;

+            local_1e0 = puVar4;

+            if (uVar1 != 0) {

+              if ((((uVar1 < *puVar4) || ((*puVar4 & 1) != 0)) || ((uVar1 & 1) != 0)) ||

+                 ((uVar1 == 0xffff || (puVar12 == (undefined1 *)0x0)))) goto LAB_3;

+              if ((param_2 != '\0') &&

+                 ((&DAT_6 < puVar12 + uVar1 || (puVar12 + uVar1 < puVar12)))) {

+                param_1 = local_280;

+              }

+            }

+            lVar10 = *(longlong *)(param_4 + 0x198);

+            uVar2 = *(uint *)(lVar10 + 0x10);

+            if (uVar2 != 0) {

+              if ((_Src == (undefined1 *)0x0) || (0xffff < uVar2)) goto LAB_3;

+              if ((param_2 != '\0') && ((ulonglong)uVar2 != 0)) {

+                if (((ulonglong)_Src & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                if ((&DAT_6 < _Src + (ulonglong)uVar2 * 8) ||

+                   (_Src + (ulonglong)uVar2 * 8 < _Src)) {

+                  lVar10 = *(longlong *)(local_1f8 + 0x198);

+                  param_1 = local_280;

+                }

+              }

+            }

+            local_1d8 = (void *)0x0;

+            if ((puVar4[1] != 0) || (*(int *)(lVar10 + 0x10) != 0)) {

+              local_1d8 = (void *)ExAllocatePool2(0x41,(ulonglong)puVar4[1] +

+                                                       (ulonglong)*(uint *)(lVar10 + 0x10) * 8,

+                                                  0x70426e50);

+            }

+            pvVar3 = local_1d8;

+            if (puVar4[1] != 0) {

+              *(void **)(puVar4 + 4) = local_1d8;

+              RtlCopyMemory(local_1d8,puVar12,(ulonglong)puVar4[1]);

+              local_1d8 = (void *)((longlong)pvVar3 + (ulonglong)puVar4[1]);

+            }

+            pcVar15 = local_278;

+            if (*(int *)(*(longlong *)(param_4 + 0x198) + 0x10) != 0) {

+              *(void **)(*(longlong *)(param_4 + 0x198) + 0x18) = local_1d8;

+              RtlCopyMemory(*(void **)(*(longlong *)(param_4 + 0x198) + 0x18),_Src,

+                            (ulonglong)*(uint *)(*(longlong *)(param_4 + 0x198) + 0x10) << 3);

+              pcVar15 = local_278;

+            }

+LAB_5:

+            param_1 = param_1 + 4;

+            local_268 = local_268 - 1;

+            goto LAB_0;

+          }

+          if (local_d8 == 0x20019) {

+            if (param_1[1] == 4) {

+              local_118 = (undefined4 *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_118 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              *(undefined4 *)(param_4 + 0x188) = *local_118;

+              goto LAB_5;

+            }

+          }

+          else {

+            if (local_d8 == 0x2001b) {

+              local_270 = param_1[1];

+              if (0x18 < local_270) goto LAB_3;

+              local_60 = 0;

+              uStack_58 = 0;

+              local_50 = 0;

+              puVar12 = (undefined1 *)param_1[2];

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

+                RtlCopyMemory(&local_60,puVar12,local_270);

+              }

+              else {

+                if ((undefined1 *)0x7ffffffeffff < puVar12) {

+                  puVar12 = &DAT_6;

+                }

+                RtlCopyVolatileMemory(&local_60,puVar12,local_270);

+              }

+              local_a8 = (undefined4)local_60;

+              uStack_a4 = local_60._4_4_;

+              uStack_a0 = (undefined4)uStack_58;

+              uStack_9c = uStack_58._4_4_;

+              local_98 = local_50;

+              uVar17 = (undefined4)local_60;

+              uVar18 = local_60._4_4_;

+              uVar19 = (undefined4)uStack_58;

+              uVar20 = uStack_58._4_4_;

+              uVar21 = local_50;

+              local_288 = PspValidateMitigationAuditOptions(&local_a8);

+              uVar14 = (ulonglong)local_288;

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

+                *(undefined4 *)(param_4 + 0x1c0) = uVar17;

+                *(undefined4 *)(param_4 + 0x1c4) = uVar18;

+                *(undefined4 *)(param_4 + 0x1c8) = uVar19;

+                *(undefined4 *)(param_4 + 0x1cc) = uVar20;

+                *(undefined8 *)(param_4 + 0x1d0) = uVar21;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+              goto LAB_2;

+            }

+            if (local_d8 == 0x2001d) {

+              if (param_1[1] == 4) {

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

+                if ((param_2 != '\0') && (((ulonglong)local_120 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                if ((*local_120 & 0xfffffffe) != 0) {

+                  return 0xc000000d;

+                }

+                *(uint **)(param_4 + 0x1b8) = local_120;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x20021) {

+              iVar7 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline

+                                ();

+              if ((iVar7 != 0) && (0x1f < param_1[1])) {

+                local_e0 = (void *)param_1[2];

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

+LAB_10:

+                  RtlCopyVolatileMemory(&local_238,local_e0,0x20);

+                }

+                else {

+                  if (((ulonglong)local_e0 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                    ExRaiseDatatypeMisalignment();

+                  }

+                  if (param_2 == '\0') goto LAB_10;

+                  RtlCopyFromUser(&local_238,local_e0,0x20);

+                }

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

+                  return 0xc000000d;

+                }

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

+LAB_11:

+                  RtlCopyVolatileMemory(&local_1d0,pvStack_230,0x30);

+                }

+                else {

+                  if (((ulonglong)pvStack_230 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+                    ExRaiseDatatypeMisalignment();

+                  }

+                  if (param_2 == '\0') goto LAB_11;

+                  RtlCopyFromUser(&local_1d0,pvStack_230,0x30);

+                }

+                if (0x30 < (uint)local_1d0) {

+                  return 0xc000000d;

+                }

+                puVar11 = (undefined4 *)ExAllocatePool2(0x100,0x30,0x63437350);

+                *(undefined4 **)(param_4 + 0x1f8) = puVar11;

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

+                  return 0xc0000017;

+                }

+                *(int *)(param_4 + 0x1f0) = (int)local_238;

+                *puVar11 = (int)local_1d0;

+                *(undefined4 *)(*(longlong *)(param_4 + 0x1f8) + 4) = local_1d0._4_4_;

+                *(undefined8 *)(*(longlong *)(param_4 + 0x1f8) + 8) = uStack_1c8;

+                *(undefined4 *)(*(longlong *)(param_4 + 0x1f8) + 0x28) = (undefined4)uStack_1a8;

+                local_2a8 = *(longlong *)(param_4 + 0x1f8) + 0x10;

+                local_2b0 = (undefined8 *)CONCAT71(local_2b0._1_7_,1);

+                uVar14 = SeCaptureSid(local_1c0,param_2);

+                local_288 = (uint)uVar14;

+                if ((int)local_288 < 0) {

+                  return uVar14;

+                }

+                if (lStack_1b8 != 0) {

+                  local_2a0 = *(longlong *)(param_4 + 0x1f8) + 0x18;

+                  local_298 = &local_250;

+                  local_2b8 = 0;

+                  uVar14 = SeCaptureSidAndAttributesArray

+                                     (lStack_1b8,local_1b0 & 0xffffffff,param_2,0);

+                  local_288 = (uint)uVar14;

+                  if ((int)local_288 < 0) {

+                    return uVar14;

+                  }

+                  *(undefined4 *)(*(longlong *)(param_4 + 0x1f8) + 0x20) = (undefined4)local_1b0;

+                }

+                uVar14 = SeCaptureHandles(local_220,local_228,param_4 + 0x200);

+                local_288 = (uint)uVar14;

+                if ((int)local_288 < 0) {

+                  return uVar14;

+                }

+                *(undefined4 *)(param_4 + 0x208) = local_220;

+                pcVar15 = local_278;

+                goto LAB_5;

+              }

+            }

+            else if (local_d8 == 0x3000c) {

+              if ((param_3 != 0) && (param_1[1] == 0x10)) {

+                local_128 = (undefined4 *)param_1[2];

+                if ((param_2 != '\0') && (((ulonglong)local_128 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                  ExRaiseDatatypeMisalignment();

+                }

+                uVar17 = local_128[1];

+                uVar18 = local_128[2];

+                uVar19 = local_128[3];

+                *(undefined4 *)(param_4 + 0x140) = *local_128;

+                *(undefined4 *)(param_4 + 0x144) = uVar17;

+                *(undefined4 *)(param_4 + 0x148) = uVar18;

+                *(undefined4 *)(param_4 + 0x14c) = uVar19;

+                cVar6 = KeVerifyGroupAffinity(param_4 + 0x140,0x1001);

+                goto LAB_7;

+              }

+            }

+            else if (((local_d8 == 0x3000e) && (param_3 != 0)) && (param_1[1] == 4)) {

+              local_130 = (undefined4 *)param_1[2];

+              if ((param_2 != '\0') && (((ulonglong)local_130 & 1) != 0)) {

+                    /* WARNING: Subroutine does not return */

+                ExRaiseDatatypeMisalignment();

+              }

+              local_258 = *local_130;

+              iVar7 = KeGetProcessorIndexFromNumber(&local_258);

+              *(int *)(param_4 + 0x14) = iVar7;

+              bVar16 = iVar7 == -1;

+              goto LAB_8;

+            }

+          }

+        }

+      }

+LAB_3:

+      uVar14 = 0xc000000d;

+      goto LAB_1;

+    }

+  }

+  return 0xc000000d;

 }
```

## `PspSetUILimitJobObject`  (modified)

```diff
--- PspSetUILimitJobObject
+++ PspSetUILimitJobObject
@@ -1,41 +1,43 @@
 

-int PspSetUILimitJobObject(undefined8 param_1)

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

 

 {

   char cVar1;

-  int iVar2;

-  longlong in_RAX;

-  ushort *puVar3;

-  ulonglong uVar4;

-  uint local_res18 [4];

+  undefined8 uVar2;

   

-  *(undefined4 *)(in_RAX + 0x10) = 0;

-  *(undefined1 *)(in_RAX + -0x18) = 0;

-  iVar2 = ObQueryNameStringMode(param_1,0,0,in_RAX + 0x10);

-  if (iVar2 == -0x3ffffffc) {

-    puVar3 = (ushort *)ExAllocatePool2(0x100,local_res18[0],0x50707350);

-    if (puVar3 == (ushort *)0x0) {

-      iVar2 = -0x3fffff66;

+  if ((param_3 & 0xfffffc00) == 0) {

+    PspLockJobChain(param_1,param_2,0);

+    cVar1 = PspDoesJobHierarchyPermitUILimits(param_1,(param_4 & 1 ^ 1) * 2);

+    uVar2 = 0;

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

+      uVar2 = 0xc00000bb;

+    }

+    else if (*(int *)(param_1 + 0x240) == -2) {

+      uVar2 = 0xc0000022;

     }

     else {

-      iVar2 = ObQueryNameStringMode(param_1,puVar3,local_res18[0],local_res18,0);

-      if (-1 < iVar2) {

-        cVar1 = RtlPrefixUnicodeString("8",puVar3,1);

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

-LAB_0:

-          iVar2 = -0x3ffffff3;

+      PspBindProcessSessionToJob(param_1,*(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8));

+      if (((*(uint *)(param_1 + 0x240) < 0xfffffffe) && (*(uint *)(param_1 + 0x220) != param_3)) &&

+         (cVar1 = IsWin32kJobNotifyCallOutPresent(), cVar1 != '\0')) {

+        *(uint *)(param_1 + 0x220) = param_3;

+        LOCK();

+        *(uint *)(param_1 + 0x610) = *(uint *)(param_1 + 0x610) | 0x10;

+        UNLOCK();

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

+          LOCK();

+          *(uint *)(param_1 + 0x614) = *(uint *)(param_1 + 0x614) | 0x10;

+          UNLOCK();

         }

-        else {

-          for (uVar4 = 0x1d; (uint)uVar4 < (uint)(*puVar3 >> 1);

-              uVar4 = (ulonglong)((uint)uVar4 + 1)) {

-            if (*(short *)(*(longlong *)(puVar3 + 4) + uVar4 * 2) == 0x5c) goto LAB_0;

-          }

-          iVar2 = 0;

-        }

+        PspUnlockJobChain(param_1,param_2);

+        Win32kJobUpdateUIRestrictionsNotify(param_1);

+        return 0;

       }

-      ExFreePoolWithTag(puVar3,0);

     }

+    PspUnlockJobChain(param_1,param_2);

   }

-  return iVar2;

+  else {

+    uVar2 = 0xc000000d;

+  }

+  return uVar2;

 }
```

## `RtlQueryAtomInAtomTable`  (modified)

```diff
--- RtlQueryAtomInAtomTable
+++ RtlQueryAtomInAtomTable
@@ -1,1477 +1,167 @@
 

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

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

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

 

-ulonglong RtlQueryAtomInAtomTable(void)

+undefined4

+RtlQueryAtomInAtomTable

+          (longlong param_1,uint param_2,uint *param_3,uint *param_4,void *param_5,uint *param_6)

 

 {

-  uint *puVar1;

-  undefined1 uVar2;

-  void *_Src;

-  undefined4 *puVar3;

-  undefined8 uVar4;

-  undefined8 uVar5;

-  code *pcVar6;

-  undefined7 uVar7;

-  undefined4 uVar8;

-  undefined4 uVar9;

-  undefined8 *puVar10;

-  char cVar11;

-  byte bVar12;

-  undefined1 uVar13;

-  byte bVar14;

-  ushort uVar15;

-  ushort uVar16;

-  uint uVar17;

-  int iVar18;

-  uint uVar19;

-  uint uVar20;

-  int iVar21;

-  longlong lVar22;

-  longlong *plVar23;

-  void *_Dst;

-  longlong lVar24;

-  undefined8 uVar25;

-  undefined8 *puVar26;

-  undefined8 *puVar27;

-  uint uVar28;

-  ulonglong uVar29;

-  uint unaff_EBX;

-  byte bVar30;

-  undefined8 *unaff_RSI;

-  undefined2 uVar31;

-  undefined4 unaff_EDI;

-  ulonglong uVar32;

-  undefined8 *puVar33;

-  uint uVar34;

-  ushort uVar35;

-  ulonglong unaff_R13;

-  longlong unaff_R14;

-  longlong unaff_R15;

-  undefined4 extraout_XMM0_Da;

-  undefined4 extraout_XMM0_Da_00;

-  undefined4 extraout_XMM0_Da_01;

-  undefined4 uVar36;

-  undefined4 extraout_XMM0_Da_02;

-  undefined4 extraout_XMM0_Da_03;

-  undefined4 extraout_XMM0_Da_04;

-  undefined1 auStackX_8 [32];

-  longlong in_stack_00000098;

-  uint in_stack_00000110;

-  longlong in_stack_00000148;

-  uint in_stack_00000160;

-  longlong in_stack_000001a0;

+  ulonglong uVar1;

+  undefined8 uVar2;

+  ulonglong uVar3;

+  longlong lVar4;

+  char cVar5;

+  int iVar6;

+  ulonglong *puVar7;

+  longlong lVar8;

+  longlong *plVar9;

+  uint uVar10;

+  uint uVar11;

+  ushort uVar12;

+  undefined1 local_e8 [32];

+  uint local_c8;

+  undefined4 local_b8;

+  uint *local_b0;

+  uint local_a8;

+  ulonglong local_a0;

+  uint *local_98;

+  uint *local_90;

+  ulonglong local_88;

+  longlong local_80;

+  void *local_78;

+  void *local_70;

+  longlong local_68;

+  wchar_t local_60 [16];

+  ulonglong local_40;

   

-  *(longlong *)(unaff_R14 + 0x638) = unaff_R14 + in_stack_000001a0;

-  *(ulonglong *)(unaff_R14 + 0x7f0) = unaff_R14 + (ulonglong)in_stack_00000160;

-  if ((unaff_EBX >> 0x11 & 1) != 0) {

-    *(ulonglong *)(unaff_R14 + 0x668) = unaff_R14 + (ulonglong)in_stack_00000110;

-    PoEnergyContextInitialize();

+                    /* 0x993410  2536  RtlQueryAtomInAtomTable */

+  local_40 = __security_cookie ^ (ulonglong)local_e8;

+  local_98 = param_6;

+  local_b0 = param_3;

+  local_90 = param_4;

+  local_80 = param_1;

+  cVar5 = RtlpLockAtomTable();

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

+    return 0xc000000d;

   }

-  if ((unaff_R15 == 0) || ((*(uint *)(unaff_R15 + 8) >> 9 & 1) == 0)) {

-    if (in_stack_00000098 == 0) {

-      uVar36 = 5;

-    }

-    else {

-      uVar36 = *(undefined4 *)(in_stack_00000098 + 0x388);

-    }

-  }

-  else {

-    uVar36 = *(undefined4 *)(unaff_R15 + 0x13c);

-  }

-  *(undefined4 *)(unaff_R14 + 0x388) = uVar36;

-  *(undefined4 *)(unaff_R14 + 0x554) = 0x103;

-  if (in_stack_00000098 == 0) {

-    uVar28 = 2;

-    uVar34 = KeQueryHeteroCpuPolicyThread();

-  }

-  else {

-    uVar28 = *(uint *)(in_stack_00000098 + 500) >> 0x1b & 7;

-    uVar34 = *(uint *)(in_stack_00000098 + 0x1f0) >> 0xc & 7;

-    *(undefined8 *)(unaff_R14 + 0x2d0) = *(undefined8 *)(in_stack_00000098 + 0x1d0);

-  }

-  *(uint *)(unaff_R14 + 500) = uVar28 << 0x1b | *(uint *)(unaff_R14 + 500) & 0xc7ffffff;

-  *(uint *)(unaff_R14 + 0x1f0) = *(uint *)(unaff_R14 + 0x1f0) & 0xffff8fff | uVar34 << 0xc;

-  lVar22 = PspSystemPartition;

-  if (in_stack_00000148 != 0) {

-    cVar11 = PsReferencePartitionSafe(in_stack_00000148);

-    if (cVar11 != '\0') goto LAB_0;

-    uVar32 = 0xc00004a0;

-    goto LAB_1;

-  }

-  LOCK();

-  plVar23 = (longlong *)(PspSystemPartition + 0x28);

-  lVar24 = *plVar23;

-  *plVar23 = *plVar23 + unaff_R13;

-  UNLOCK();

-  if ((longlong)(lVar24 + unaff_R13) <= (longlong)unaff_R13) {

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

-    (*pcVar6)(0xe);

-    register0x00000020 = (BADSPACEBASE *)auStackX_8;

-  }

-  *(undefined4 *)((longlong)register0x00000020 + 0x90) =

-       *(undefined4 *)((longlong)register0x00000020 + 0x880);

-  unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-  in_stack_00000148 = lVar22;

+  uVar11 = *param_6 & 0xfffffffe;

+  uVar12 = (ushort)param_2;

+  local_a8 = uVar11;

+  if (0xbfff < uVar12) {

+    local_b8 = 0xc0000008;

+    uVar11 = (param_2 & 0x3fff) << 2;

+    local_a0 = (ulonglong)uVar11;

+    local_78 = SystemReserved1[0xf];

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

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

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

+    local_88 = local_a0;

+    if (((uVar11 & 0x3fc) == 0) ||

+       (puVar7 = (ulonglong *)ExpLookupHandleTableEntry(uVar2), puVar7 == (ulonglong *)0x0)) {

 LAB_0:

-  *(longlong *)(unaff_R14 + 0x758) = in_stack_00000148;

-  lVar22 = 0;

-  if (*(longlong *)((longlong)register0x00000020 + 0xf8) != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995d16;

-    ObfReferenceObject();

-    lVar22 = *(longlong *)((longlong)register0x00000020 + 0xf8);

-  }

-  uVar34 = (uint)unaff_RSI;

-  if (((byte)((byte)unaff_EDI & (byte)unaff_EBX) != 0) &&

-     (*(uint *)((longlong)register0x00000020 + 200) = (uint)*(ushort *)(in_stack_00000098 + 0x6ec),

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

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995d50;

-    cVar11 = ExAcquireRundownProtection(in_stack_00000098 + 0x1e8);

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

-      lVar22 = *(longlong *)(in_stack_00000098 + 0x2a8);

-      *(longlong *)((longlong)register0x00000020 + 0xf8) = lVar22;

-      if (lVar22 != 0) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995d71;

-        ObfReferenceObject(lVar22);

-      }

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995d79;

-      ExReleaseRundownProtection(in_stack_00000098 + 0x1e8);

-    }

-    lVar22 = *(longlong *)((longlong)register0x00000020 + 0xf8);

-    if (lVar22 == 0) {

-      uVar32 = 0xc000010a;

+      local_90 = SystemReserved1[0xf];

+      KeLeaveCriticalRegionThread();

       goto LAB_1;

     }

-    lVar24 = *(longlong *)(in_stack_00000098 + 0x310);

-    if (lVar24 != 0) {

-      unaff_EBX = unaff_EBX | 0x40;

-      *(uint *)((longlong)register0x00000020 + 0x84) = unaff_EBX;

-      *(undefined4 *)((longlong)register0x00000020 + 0x120) = *(undefined4 *)(lVar24 + 8);

+    do {

+      while (uVar3 = *puVar7, (uVar3 & 1) == 0) {

+        if (uVar3 == 0) goto LAB_0;

+        ExpBlockOnLockedHandleEntry(uVar2,puVar7);

+      }

+      LOCK();

+      uVar1 = *puVar7;

+      if (uVar3 == uVar1) {

+        *puVar7 = uVar3 - 1;

+      }

+      UNLOCK();

+    } while (uVar3 != uVar1);

+    lVar8 = ExGetHandlePointer(puVar7);

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

+    LOCK();

+    *puVar7 = *puVar7 + 1;

+    UNLOCK();

+    plVar9 = (longlong *)(lVar4 + 0x30);

+    LOCK();

+    UNLOCK();

+    if (*plVar9 != 0) {

+      ExfUnblockPushLock(plVar9,0);

     }

-    uVar28 = uVar34;

-    if ((*(uint *)(in_stack_00000098 + 500) & 0x20000) != 0) {

-      uVar28 = 0x20000;

+    local_70 = SystemReserved1[0xf];

+    KeLeaveCriticalRegionThread();

+    if (((lVar8 == 0) || (*(ushort *)(lVar8 + 10) != uVar12)) ||

+       (local_68 = RtlpLookupLowBox(param_1,lVar8,0), local_68 == 0)) goto LAB_1;

+    local_b8 = 0;

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

+      *local_b0 = (uint)*(ushort *)(lVar8 + 0x24);

     }

-    *(uint *)((longlong)register0x00000020 + 0xb0) = uVar28;

-    unaff_EDI = 4;

-  }

-  *(longlong *)(unaff_R14 + 0x2a8) = lVar22;

-  uVar16 = (ushort)unaff_RSI;

-  bVar30 = (byte)unaff_RSI;

-  uVar28 = (uint)unaff_R13;

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

-    uVar17 = unaff_EBX;

-    if (lVar22 != 0) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996384;

-      uVar17 = MmGetSectionInformation

-                         (lVar22,4,(undefined1 *)((longlong)register0x00000020 + 0x380));

-      uVar32 = (ulonglong)uVar17;

-      if ((int)uVar17 < 0) goto LAB_1;

-      uVar17 = ((((*(uint *)((longlong)register0x00000020 + 0x3c0) & 0xfa) * 2 |

-                 *(uint *)((longlong)register0x00000020 + 0x3c0) & uVar28) << 5 |

-                *(byte *)((longlong)register0x00000020 + 0x3b3) & 2) << 2 |

-               *(byte *)((longlong)register0x00000020 + 0x3b3) & 4) << 0xb | unaff_EBX & 0xf82b9fff;

-      *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-      *(undefined2 *)((longlong)register0x00000020 + 0xa8) =

-           *(undefined2 *)((longlong)register0x00000020 + 0x3ae);

-      *(uint *)((longlong)register0x00000020 + 0xec) =

-           (uint)*(ushort *)((longlong)register0x00000020 + 0x3a6);

-      *(uint *)((longlong)register0x00000020 + 0xe8) =

-           (uint)*(ushort *)((longlong)register0x00000020 + 0x3a4);

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

-        *(uint *)((longlong)register0x00000020 + 0xb0) =

-             *(uint *)((longlong)register0x00000020 + 0xb0) | 8;

-        uVar17 = uVar17 | 0x18;

-        *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-      }

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

+      *local_90 = (uint)*(ushort *)(lVar8 + 0x26);

     }

-    goto LAB_2;

-  }

-  *(undefined8 *)(unaff_R14 + 0x5f0) = *(undefined8 *)(unaff_R15 + 0x1a8);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995e04;

-  uVar17 = MmGetSectionInformation(lVar22,unaff_EDI,unaff_R15 + 0x38);

-  uVar32 = (ulonglong)uVar17;

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

-    uVar17 = ((((*(uint *)(unaff_R15 + 0x78) & 0xfa) * 2 | *(uint *)(unaff_R15 + 0x78) & uVar28) <<

-               5 | *(byte *)(unaff_R15 + 0x6b) & 2) << 2 | *(byte *)(unaff_R15 + 0x6b) & 4) << 0xb |

-             unaff_EBX;

-    *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-    *(uint *)((longlong)register0x00000020 + 0xec) = (uint)*(ushort *)(unaff_R15 + 0x5e);

-    *(uint *)((longlong)register0x00000020 + 0xe8) = (uint)*(ushort *)(unaff_R15 + 0x5c);

-    if ((*(ushort *)(unaff_R15 + 0x12) & *(ushort *)(unaff_R15 + 100)) == 0) {

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

-        uVar25 = *(undefined8 *)(unaff_R15 + 0xb8);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995ea3;

-        ObfReferenceObjectWithTag(uVar25,0x72437350);

-        *(undefined8 *)(unaff_R14 + 0x330) = *(undefined8 *)(unaff_R15 + 0xb8);

-        *(undefined2 *)((longlong)register0x00000020 + 0xa8) = *(undefined2 *)(unaff_R15 + 0x66);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995ed4;

-        iVar18 = RtlpOpenImageFileOptionsKeyEx(unaff_R15 + 0xf0);

-        if (iVar18 < 0) {

-          if (iVar18 == -0x3fffffcc) {

-            *(byte *)(unaff_R15 + 0x10) = *(byte *)(unaff_R15 + 0x10) | 0x40;

-          }

-          *(undefined8 **)(unaff_R15 + 200) = unaff_RSI;

-        }

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995eff;

-        uVar19 = PspSelectMachineForProcess(*(undefined8 *)((longlong)register0x00000020 + 0x98));

-        uVar32 = (ulonglong)uVar19;

-        if ((int)uVar19 < 0) {

-          uVar25 = 4;

-          goto LAB_3;

-        }

-        *(uint *)((longlong)register0x00000020 + 200) =

-             (uint)*(ushort *)((longlong)register0x00000020 + 0xd0);

-        if (*(byte *)((longlong)register0x00000020 + 0xd2) != bVar30) {

-          uVar17 = uVar17 | 0x40;

-          *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-        }

-        if (*(byte *)((longlong)register0x00000020 + 0xd3) != bVar30) {

-          *(uint *)((longlong)register0x00000020 + 0xb0) =

-               *(uint *)((longlong)register0x00000020 + 0xb0) | 0x20000;

-        }

-        lVar22 = *(longlong *)(unaff_R15 + 200);

-        if (lVar22 == 0) goto LAB_2;

-        if ((char)bVar30 <= *(char *)(unaff_R15 + 0x10)) {

-          *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-               (undefined1 *)((longlong)register0x00000020 + 0xac);

-          *(undefined4 *)((longlong)register0x00000020 + 0x20) = 2;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995f89;

-          iVar18 = RtlQueryImageFileKeyOption

-                             (lVar22,L"Debugger",unaff_R13 & 0xffffffff,

-                              (undefined1 *)((longlong)register0x00000020 + 0xc0));

-          if ((iVar18 != -0x7ffffffb) &&

-             (((iVar18 < 0 || (*(int *)((longlong)register0x00000020 + 0xac) != 2)) ||

-              (*(ushort *)((longlong)register0x00000020 + 0xc0) == uVar16)))) {

-            *(uint *)((longlong)register0x00000020 + 0x114) = uVar34;

-            *(undefined8 **)((longlong)register0x00000020 + 0x28) = unaff_RSI;

-            *(undefined4 *)((longlong)register0x00000020 + 0x20) = 4;

-            uVar25 = *(undefined8 *)(unaff_R15 + 200);

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995fd7;

-            iVar18 = RtlQueryImageFileKeyOption

-                               (uVar25,L"AppExecutionAliasRedirect",4,

-                                (undefined1 *)((longlong)register0x00000020 + 0x114));

-            if ((iVar18 < 0) || (*(uint *)((longlong)register0x00000020 + 0x114) != uVar28))

-            goto LAB_4;

-          }

-          uVar32 = 0xc0000039;

-          uVar25 = 5;

-          goto LAB_3;

-        }

-LAB_4:

-        *(uint *)((longlong)register0x00000020 + 0xc4) = uVar34;

-        *(undefined8 **)((longlong)register0x00000020 + 0x28) = unaff_RSI;

-        *(undefined4 *)((longlong)register0x00000020 + 0x20) = 4;

-        uVar25 = *(undefined8 *)(unaff_R15 + 200);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996023;

-        iVar18 = RtlQueryImageFileKeyOption

-                           (uVar25,L"UseLargePages",4,

-                            (undefined1 *)((longlong)register0x00000020 + 0xc4));

-        uVar20 = *(uint *)((longlong)register0x00000020 + 0x90);

-        uVar19 = uVar20;

-        if ((-1 < iVar18) && (*(uint *)((longlong)register0x00000020 + 0xc4) != uVar34)) {

-          uVar19 = uVar20 | 0x10;

-          *(uint *)((longlong)register0x00000020 + 0x90) = uVar19;

-          *(uint *)((longlong)register0x00000020 + 0x880) = uVar19;

-          if ((uVar17 & 0x40) == 0) {

-            *(undefined4 *)((longlong)register0x00000020 + 0x220) = 0x30;

-            *(undefined8 *)((longlong)register0x00000020 + 0x228) = *(undefined8 *)(unaff_R15 + 200)

-            ;

-            *(undefined4 *)((longlong)register0x00000020 + 0x238) = 0x240;

-            *(undefined **)((longlong)register0x00000020 + 0x230) = &PspLargePageDLLKeyName;

-            *(undefined8 *)((longlong)register0x00000020 + 0x240) = 0;

-            *(undefined8 *)((longlong)register0x00000020 + 0x248) = 0;

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409960b5;

-            iVar18 = ZwOpenKey((undefined1 *)((longlong)register0x00000020 + 0x168),

-                               unaff_R13 & 0xffffffff,

-                               (undefined1 *)((longlong)register0x00000020 + 0x220));

-            if (-1 < iVar18) {

-              *(uint *)((longlong)register0x00000020 + 0xc4) = uVar34;

-              *(undefined8 **)((longlong)register0x00000020 + 0x28) = unaff_RSI;

-              *(undefined4 *)((longlong)register0x00000020 + 0x20) = 4;

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409960ed;

-              iVar18 = RtlQueryImageFileKeyOption

-                                 (*(undefined8 *)((longlong)register0x00000020 + 0x168),&u_ntdll_dll

-                                  ,4,(undefined1 *)((longlong)register0x00000020 + 0xc4));

-              if ((-1 < iVar18) && (*(uint *)((longlong)register0x00000020 + 0xc4) != uVar34)) {

-                uVar19 = uVar20 | 0x30;

-                *(uint *)((longlong)register0x00000020 + 0x90) = uVar19;

-                *(uint *)((longlong)register0x00000020 + 0x880) = uVar19;

-              }

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099611d;

-              ObCloseHandle(*(undefined8 *)((longlong)register0x00000020 + 0x168),0);

-            }

-          }

-        }

-        if (*(undefined8 **)((longlong)register0x00000020 + 0x138) == unaff_RSI) {

-          uVar25 = *(undefined8 *)(unaff_R15 + 200);

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996145;

-          PspReadIFEONodeOptions

-                    (unaff_R14,uVar25,(undefined1 *)((longlong)register0x00000020 + 0xb8));

-        }

-        *(uint *)((longlong)register0x00000020 + 0x118) = uVar34;

-        *(undefined8 **)((longlong)register0x00000020 + 0x28) = unaff_RSI;

-        *(undefined4 *)((longlong)register0x00000020 + 0x20) = 4;

-        uVar25 = *(undefined8 *)(unaff_R15 + 200);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996173;

-        iVar18 = RtlQueryImageFileKeyOption

-                           (uVar25,L"ForceWakeCharge",4,

-                            (undefined1 *)((longlong)register0x00000020 + 0x118));

-        if ((-1 < iVar18) && (*(uint *)((longlong)register0x00000020 + 0x118) != uVar34)) {

-          *(uint *)((longlong)register0x00000020 + 0xb4) =

-               *(uint *)((longlong)register0x00000020 + 0xb4) | 0x40;

-        }

-        *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-             (undefined1 *)((longlong)register0x00000020 + 0xac);

-        *(uint *)((longlong)register0x00000020 + 0x20) = uVar34;

-        uVar25 = *(undefined8 *)(unaff_R15 + 200);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409961b3;

-        iVar18 = RtlQueryImageFileKeyOption(uVar25,L"AllowedCpuSets",3);

-        if (((iVar18 != -0x7ffffffb) ||

-            (uVar20 = *(uint *)((longlong)register0x00000020 + 0xac), 0x100 < uVar20)) ||

-           ((uVar20 & 7) != 0)) {

-LAB_5:

-          *(undefined4 *)((longlong)register0x00000020 + 0x250) = 0x30;

-          *(undefined8 *)((longlong)register0x00000020 + 600) = *(undefined8 *)(unaff_R15 + 200);

-          *(undefined4 *)((longlong)register0x00000020 + 0x268) = 0x240;

-          *(undefined **)((longlong)register0x00000020 + 0x260) = &PspPerfOptionsKeyName;

-          *(undefined8 *)((longlong)register0x00000020 + 0x270) = 0;

-          *(undefined8 *)((longlong)register0x00000020 + 0x278) = 0;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409962b3;

-          iVar18 = ZwOpenKey((undefined1 *)((longlong)register0x00000020 + 0x170),

-                             unaff_R13 & 0xffffffff,

-                             (undefined1 *)((longlong)register0x00000020 + 0x250));

-          if (-1 < iVar18) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409962cc;

-            PspReadIFEOPerfOptions

-                      (*(undefined8 *)((longlong)register0x00000020 + 0x170),

-                       (undefined1 *)((longlong)register0x00000020 + 0x400));

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409962db;

-            ObCloseHandle(*(undefined8 *)((longlong)register0x00000020 + 0x170),0);

-          }

-          *(undefined8 **)((longlong)register0x00000020 + 0x28) = unaff_RSI;

-          *(undefined4 *)((longlong)register0x00000020 + 0x20) = 4;

-          uVar25 = *(undefined8 *)(unaff_R15 + 200);

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996307;

-          iVar18 = RtlQueryImageFileKeyOption

-                             (uVar25,L"ImageExpansionMitigation",4,

-                              (undefined1 *)((longlong)register0x00000020 + 0x11c));

-          if ((-1 < iVar18) && (*(int *)((longlong)register0x00000020 + 0x11c) == 2)) {

-            LOCK();

-            *(uint *)(unaff_R14 + 0x7dc) = *(uint *)(unaff_R14 + 0x7dc) | 4;

-            UNLOCK();

-            uVar19 = *(uint *)((longlong)register0x00000020 + 0x880);

-            *(uint *)((longlong)register0x00000020 + 0x90) = uVar19;

-            unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-          }

-          if ((uVar19 >> 0x13 & 1) != 0) {

-            LOCK();

-            *(uint *)(unaff_R14 + 0x7dc) = *(uint *)(unaff_R14 + 0x7dc) | 4;

-            UNLOCK();

-            uVar19 = *(uint *)((longlong)register0x00000020 + 0x880);

-            *(uint *)((longlong)register0x00000020 + 0x90) = uVar19;

-            unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-          }

-          goto LAB_6;

-        }

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409961ed;

-        lVar22 = ExAllocatePool2(0x40,uVar20,0x73437350);

-        *(longlong *)((longlong)register0x00000020 + 0x188) = lVar22;

-        if (lVar22 != 0) {

-          *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-               (undefined1 *)((longlong)register0x00000020 + 0xac);

-          *(uint *)((longlong)register0x00000020 + 0x20) = uVar20;

-          uVar25 = *(undefined8 *)(unaff_R15 + 200);

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996231;

-          iVar18 = RtlQueryImageFileKeyOption(uVar25,L"AllowedCpuSets",3,lVar22);

-          if ((-1 < iVar18) && ((*(byte *)((longlong)register0x00000020 + 0xac) & 7) == 0)) {

-            uVar17 = uVar17 | 0x200000;

-            *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-            *(uint *)((longlong)register0x00000020 + 0xcc) =

-                 *(uint *)((longlong)register0x00000020 + 0xac) >> 3;

-          }

-          goto LAB_5;

-        }

-LAB_7:

-        uVar32 = 0xc0000017;

-      }

-      else {

+    if (param_5 == (void *)0x0) goto LAB_1;

+    uVar11 = (uint)*(byte *)(lVar8 + 0x28) * 2;

+    local_b0 = (uint *)CONCAT44(local_b0._4_4_,uVar11);

+    if (uVar11 < local_a8) {

 LAB_2:

-        uVar19 = *(uint *)((longlong)register0x00000020 + 0x90);

-LAB_6:

-        if ((uVar17 & 0x40) == 0) {

-          uVar31 = (undefined2)*(undefined4 *)((longlong)register0x00000020 + 200);

-        }

-        else {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099643c;

-          lVar22 = ExAllocatePool2(0x40,0x10,0x50776f57);

-          *(longlong *)(unaff_R14 + 0x310) = lVar22;

-          if (lVar22 == 0) goto LAB_7;

-          iVar18 = *(int *)((longlong)register0x00000020 + 0x120);

-          uVar31 = (undefined2)*(uint *)((longlong)register0x00000020 + 200);

-          if (iVar18 == 0) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099646c;

-            iVar18 = PspWow64PickBestNtdll

-                               (extraout_XMM0_Da,

-                                *(uint *)((longlong)register0x00000020 + 200) & 0xffff);

-          }

-          *(int *)(lVar22 + 8) = iVar18;

-          if (*(ulonglong **)(unaff_R14 + 0x310) != (ulonglong *)0x0) {

-            **(ulonglong **)(unaff_R14 + 0x310) = unaff_R13;

-          }

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996484;

-          iVar18 = Feature_Servicing_LargeAddressAwareShim__private_IsEnabledDeviceUsageNoInline();

-          if ((iVar18 != 0) && ((uVar19 >> 0x17 & 1) != 0)) {

-            LOCK();

-            *(uint *)(unaff_R14 + 500) = *(uint *)(unaff_R14 + 500) | 0x200;

-            UNLOCK();

-            uVar19 = *(uint *)((longlong)register0x00000020 + 0x880);

-            *(uint *)((longlong)register0x00000020 + 0x90) = uVar19;

-            unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-          }

-        }

-        *(undefined2 *)(unaff_R14 + 0x6ec) = uVar31;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409964de;

-        uVar20 = SeQueryInformationToken

-                           (*(undefined8 *)((longlong)register0x00000020 + 0x130),0x1d,

-                            (undefined1 *)((longlong)register0x00000020 + 0xd8));

-        uVar32 = (ulonglong)uVar20;

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

-          uVar32 = (ulonglong)unaff_RSI & 0xffffffff;

-          uVar7 = (undefined7)((ulonglong)unaff_RSI >> 8);

-          if (*(char *)((longlong)register0x00000020 + 0x80) != '\0') {

-            if (((unaff_R15 != 0) && ((*(uint *)(unaff_R15 + 8) >> 8 & 1) != 0)) &&

-               (*(char *)(unaff_R15 + 2) == '\x04')) {

-              *(undefined4 *)((longlong)register0x00000020 + 0x790) = 0xe;

-              uVar32 = unaff_R13 & 0xffffffff;

-            }

-            iVar18 = *(int *)((longlong)register0x00000020 + 0x898);

-            if (iVar18 != 0) {

-              *(undefined4 *)((longlong)register0x00000020 + uVar32 * 4 + 0x790) = 3;

-              uVar32 = (ulonglong)((int)uVar32 + uVar28);

-            }

-            if ((uVar19 & 0x30) != 0) {

-              *(undefined4 *)((longlong)register0x00000020 + uVar32 * 4 + 0x790) = 4;

-              uVar32 = (ulonglong)((int)uVar32 + uVar28);

-            }

-            if ((char)uVar19 < '\0') {

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996564;

-              iVar21 = PspIsSessionLeaderProcess

-                                 (*(undefined8 *)((longlong)register0x00000020 + 0xf0));

-              iVar18 = *(int *)((longlong)register0x00000020 + 0x898);

-              if (iVar21 == 0) {

-                *(undefined4 *)((longlong)register0x00000020 + (uVar32 & 0xffffffff) * 4 + 0x790) =

-                     10;

-                uVar32 = (ulonglong)((int)uVar32 + uVar28);

-              }

-            }

-            iVar21 = (int)uVar32;

-            if ((uVar19 & 0x8400) != 0) {

-              *(undefined4 *)((longlong)register0x00000020 + (uVar32 & 0xffffffff) * 4 + 0x790) = 7;

-              iVar21 = iVar21 + uVar28;

-            }

-            if (iVar21 != 0) {

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409965c0;

-              iVar18 = RtlAcquirePrivilege((undefined1 *)((longlong)register0x00000020 + 0x790),

-                                           iVar21,CONCAT71(uVar7,iVar18 != 0) & 0xffffffff,

-                                           (undefined1 *)((longlong)register0x00000020 + 0x180));

-              if (-1 < iVar18) {

-                uVar17 = uVar17 | 0x400;

-                *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-              }

-            }

-          }

-          if ((uVar19 & 0x8400) != 0) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409965fa;

-            cVar11 = SeSinglePrivilegeCheck(SeTcbPrivilege);

-            if (cVar11 != '\0') goto LAB_8;

-            goto LAB_9;

-          }

-LAB_8:

-          *(undefined2 *)((longlong)register0x00000020 + 0x8c) = 0xffff;

-          *(undefined8 *)((longlong)register0x00000020 + 0x460) = 0x200001;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409966a9;

-          memset((undefined1 *)((longlong)register0x00000020 + 0x468),0,0x100);

-          if (*(longlong *)((longlong)register0x00000020 + 0x138) == 0) {

-            if (*(undefined8 **)((longlong)register0x00000020 + 0xb8) == unaff_RSI) {

-              lVar22 = *(longlong *)((longlong)register0x00000020 + 0x98);

-              if (lVar22 == 0) {

-                *(ushort *)((longlong)register0x00000020 + 0x8c) = uVar16;

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996776;

-                KeAddProcessorAffinityEx((undefined1 *)((longlong)register0x00000020 + 0x460),0);

-              }

-              else {

-                if ((*(uint *)(lVar22 + 0x1f0) & 0x100000) != 0) {

-                  *(uint *)((longlong)register0x00000020 + 0xb4) =

-                       *(uint *)((longlong)register0x00000020 + 0xb4) | 0x100000;

-                  uVar25 = (&KeNodeBlock)[*(ushort *)(lVar22 + 0x104)];

-                  *(undefined8 *)((longlong)register0x00000020 + 0xb8) = uVar25;

-                  goto LAB_10;

-                }

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996712;

-                uVar25 = PspSelectNodeForProcess();

-                *(undefined8 *)((longlong)register0x00000020 + 0xb8) = uVar25;

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996722;

-                uVar16 = KeSelectGroupFromNode(uVar25);

-                *(ushort *)((longlong)register0x00000020 + 0x8c) = uVar16;

-                if (KeForceGroupAwareness != bVar30) {

-                  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099673b;

-                  uVar15 = KeQueryActiveGroupCount();

-                  uVar35 = (ushort)unaff_R13;

-                  if ((uVar35 < uVar15) && (uVar16 == 0)) {

-                    *(undefined8 **)((longlong)register0x00000020 + 0xb8) = unaff_RSI;

-                    *(ushort *)((longlong)register0x00000020 + 0x8c) = uVar35;

-                    uVar16 = uVar35;

-                  }

-                }

-              }

-            }

-            else {

-              uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0xb8);

-LAB_10:

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996785;

-              uVar16 = KeSelectGroupFromNode(uVar25);

-              *(ushort *)((longlong)register0x00000020 + 0x8c) = uVar16;

-            }

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409967ac;

-            KiCopyAffinityEx((_KAFFINITY_EX *)((longlong)register0x00000020 + 0x460),

-                             *(ushort *)((longlong)register0x00000020 + 0x462),

-                             (_KAFFINITY_EX *)&KeActiveProcessors);

-            if (*(undefined8 **)((longlong)register0x00000020 + 0xb8) == unaff_RSI) {

-              *(undefined8 *)((longlong)register0x00000020 + 0x200) = 0;

-              *(undefined8 *)((longlong)register0x00000020 + 0x208) = 0;

-              *(ushort *)((longlong)register0x00000020 + 0x208) = uVar16;

-              puVar26 = unaff_RSI;

-              if (uVar16 < *(ushort *)((longlong)register0x00000020 + 0x460)) {

-                puVar26 = *(undefined8 **)

-                           ((longlong)register0x00000020 + (ulonglong)uVar16 * 8 + 0x468);

-              }

-              *(undefined8 **)((longlong)register0x00000020 + 0x200) = puVar26;

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409967fc;

-              uVar25 = KeSelectNodeForAffinity((undefined1 *)((longlong)register0x00000020 + 0x200))

-              ;

-              goto LAB_11;

-            }

-          }

-          else {

-            *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x8c);

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996826;

-            KeQueryAffinityProcess

-                      (*(longlong *)((longlong)register0x00000020 + 0x138),

-                       (undefined1 *)((longlong)register0x00000020 + 0x460),0,

-                       (undefined1 *)((longlong)register0x00000020 + 0x7b0));

-            uVar25 = (&KeNodeBlock)

-                     [*(ushort *)

-                       ((longlong)register0x00000020 +

-                       (ulonglong)*(ushort *)((longlong)register0x00000020 + 0x8c) * 2 + 0x7b0)];

-LAB_11:

-            *(undefined8 *)((longlong)register0x00000020 + 0xb8) = uVar25;

-          }

-          *(uint *)(unaff_R14 + 500) =

-               *(uint *)(unaff_R14 + 500) | *(uint *)((longlong)register0x00000020 + 0xb0);

-          *(uint *)(unaff_R14 + 0x1f0) =

-               *(uint *)(unaff_R14 + 0x1f0) | *(uint *)((longlong)register0x00000020 + 0xb4);

-          if (*(longlong *)((longlong)register0x00000020 + 0x98) == 0) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996ae0;

-            PspInheritQuota(unaff_R14,0);

-            *(char *)(unaff_R14 + 0x160) = (char)unaff_R13;

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996aec;

-            uVar28 = MmInitializeHandBuiltProcess();

-            uVar32 = (ulonglong)uVar28;

-            uVar29 = 0;

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

-LAB_12:

-              LOCK();

-              *(uint *)(unaff_R14 + 500) = *(uint *)(unaff_R14 + 500) | 0x40000;

-              UNLOCK();

-              unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-              uVar28 = *(uint *)((longlong)register0x00000020 + 0xe4);

-              uVar19 = (uint)unaff_R13;

-              if ((*(uint *)(unaff_R14 + 0x388) & 4) != 0) {

-                uVar28 = uVar28 | uVar19;

-              }

-              lVar22 = unaff_R14 + (ulonglong)*(uint *)((longlong)register0x00000020 + 0x158);

-              uVar20 = uVar28 | 2;

-              if ((uVar17 >> 0x10 & 1) == 0) {

-                uVar20 = uVar28;

-              }

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996b41;

-              uVar25 = PsGetSessionSchedulingGroupByProcess(unaff_R14);

-              *(longlong *)((longlong)register0x00000020 + 0x40) = lVar22;

-              *(uint *)((longlong)register0x00000020 + 0x38) = uVar20;

-              *(undefined8 *)((longlong)register0x00000020 + 0x28) = uVar25;

-              *(undefined8 *)((longlong)register0x00000020 + 0x20) =

-                   *(undefined8 *)((longlong)register0x00000020 + 0xb8);

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996b78;

-              uVar28 = KeInitializeProcess(extraout_XMM0_Da_00,8,

-                                           *(undefined2 *)((longlong)register0x00000020 + 0x8c),

-                                           (undefined1 *)((longlong)register0x00000020 + 0x460));

-              uVar32 = (ulonglong)uVar28;

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

-                puVar26 = unaff_RSI;

-                if ((unaff_R15 != 0) && ((uVar17 & 2) == 0)) {

-                  *(undefined4 *)((longlong)register0x00000020 + 300) =

-                       *(undefined4 *)(unaff_R15 + 0x180);

-                  *(undefined4 *)((longlong)register0x00000020 + 0x128) =

-                       *(undefined4 *)(unaff_R15 + 0x184);

-                  *(undefined8 *)((longlong)register0x00000020 + 0x1b8) =

-                       *(undefined8 *)(unaff_R15 + 0x198);

-                  *(undefined4 *)((longlong)register0x00000020 + 0x124) =

-                       *(undefined4 *)(unaff_R15 + 0x188);

-                  *(undefined8 *)((longlong)register0x00000020 + 0x1b0) =

-                       *(undefined8 *)(unaff_R15 + 0xd8);

-                  puVar26 = *(undefined8 **)(unaff_R15 + 400);

-                  *(undefined4 *)((longlong)register0x00000020 + 0xd4) =

-                       *(undefined4 *)(unaff_R15 + 0x18c);

-                  lVar22 = *(longlong *)(unaff_R15 + 0xb8);

-                  if ((lVar22 != 0) && (DAT_13 != (code *)0x0)) {

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996c1e;

-                    iVar18 = (*DAT_13)(lVar22,(undefined1 *)

-                                                     ((longlong)register0x00000020 + 0x570));

-                    if (-1 < iVar18) {

-                      if (((*(uint *)((longlong)register0x00000020 + 0x570) == uVar34) &&

-                          (puVar26 != (undefined8 *)0x0)) &&

-                         (*(int *)((longlong)register0x00000020 + 0xd4) == 0x20c)) {

-                        lVar22 = 4;

-                        puVar10 = (undefined8 *)((longlong)register0x00000020 + 0x570);

-                        do {

-                          puVar33 = puVar26;

-                          puVar27 = puVar10;

-                          uVar25 = puVar33[1];

-                          *puVar27 = *puVar33;

-                          puVar27[1] = uVar25;

-                          uVar25 = puVar33[3];

-                          puVar27[2] = puVar33[2];

-                          puVar27[3] = uVar25;

-                          uVar25 = puVar33[5];

-                          puVar27[4] = puVar33[4];

-                          puVar27[5] = uVar25;

-                          uVar25 = puVar33[7];

-                          puVar27[6] = puVar33[6];

-                          puVar27[7] = uVar25;

-                          uVar25 = puVar33[9];

-                          puVar27[8] = puVar33[8];

-                          puVar27[9] = uVar25;

-                          uVar25 = puVar33[0xb];

-                          puVar27[10] = puVar33[10];

-                          puVar27[0xb] = uVar25;

-                          uVar36 = *(undefined4 *)((longlong)puVar33 + 100);

-                          uVar8 = *(undefined4 *)(puVar33 + 0xd);

-                          uVar9 = *(undefined4 *)((longlong)puVar33 + 0x6c);

-                          *(undefined4 *)(puVar27 + 0xc) = *(undefined4 *)(puVar33 + 0xc);

-                          *(undefined4 *)((longlong)puVar27 + 100) = uVar36;

-                          *(undefined4 *)(puVar27 + 0xd) = uVar8;

-                          *(undefined4 *)((longlong)puVar27 + 0x6c) = uVar9;

-                          uVar25 = puVar33[0xf];

-                          puVar27[0xe] = puVar33[0xe];

-                          puVar27[0xf] = uVar25;

-                          lVar22 = lVar22 + -1;

-                          puVar10 = puVar27 + 0x10;

-                          puVar26 = puVar33 + 0x10;

-                        } while (lVar22 != 0);

-                        puVar27[0x10] = puVar33[0x10];

-                        *(undefined4 *)(puVar27 + 0x11) = *(undefined4 *)(puVar33 + 0x11);

-                      }

-                      *(undefined4 *)((longlong)register0x00000020 + 0xd4) = 0x218;

-                      puVar26 = (undefined8 *)((longlong)register0x00000020 + 0x570);

-                    }

-                  }

-                }

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996cc9;

-                iVar18 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline

-                                   ();

-                if (((iVar18 != 0) && (unaff_R15 != 0)) &&

-                   ((*(ulonglong *)(unaff_R15 + 8) >> 0x21 & 1) != 0)) {

-                  *(longlong *)((longlong)register0x00000020 + 0x1a8) = unaff_R15 + 0x1f0;

-                }

-                *(undefined8 *)((longlong)register0x00000020 + 0x70) =

-                     *(undefined8 *)((longlong)register0x00000020 + 0x1f0);

-                *(undefined8 *)((longlong)register0x00000020 + 0x68) =

-                     *(undefined8 *)((longlong)register0x00000020 + 0x1a8);

-                *(undefined8 *)((longlong)register0x00000020 + 0x60) =

-                     *(undefined8 *)((longlong)register0x00000020 + 0x1b0);

-                *(undefined4 *)((longlong)register0x00000020 + 0x58) =

-                     *(undefined4 *)((longlong)register0x00000020 + 0x124);

-                *(undefined8 *)((longlong)register0x00000020 + 0x50) =

-                     *(undefined8 *)((longlong)register0x00000020 + 0x1b8);

-                *(undefined4 *)((longlong)register0x00000020 + 0x48) =

-                     *(undefined4 *)((longlong)register0x00000020 + 0xd4);

-                *(undefined8 **)((longlong)register0x00000020 + 0x40) = puVar26;

-                *(undefined4 *)((longlong)register0x00000020 + 0x38) =

-                     *(undefined4 *)((longlong)register0x00000020 + 0x128);

-                *(uint *)((longlong)register0x00000020 + 0x30) = uVar17 >> 0x10 & uVar19;

-                *(uint *)((longlong)register0x00000020 + 0x28) = uVar17 >> 4 & uVar19;

-                *(undefined4 *)((longlong)register0x00000020 + 0x20) =

-                     *(undefined4 *)((longlong)register0x00000020 + 300);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996d81;

-                uVar28 = PspInitializeProcessSecurity

-                                   (uVar29,unaff_R14,

-                                    *(undefined8 *)((longlong)register0x00000020 + 0x130),

-                                    *(undefined4 *)((longlong)register0x00000020 + 0x898));

-                uVar32 = (ulonglong)uVar28;

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

-                  *(undefined1 *)(unaff_R14 + 0x347) = 2;

-                  bVar12 = (byte)unaff_R13;

-                  if (uVar29 == 0) {

-                    *(undefined8 *)(unaff_R14 + 0x300) =

-                         *(undefined8 *)(*(longlong *)((longlong)register0x00000020 + 0xf0) + 0x300)

-                    ;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996e0b;

-                    uVar28 = MmInitializeHandBuiltProcess2(unaff_R14);

-                  }

-                  else {

-                    if ((*(char *)(uVar29 + 0x347) - bVar12 & 0xfb) == 0) {

-                      *(char *)(unaff_R14 + 0x347) = *(char *)(uVar29 + 0x347);

-                    }

-                    if (unaff_R15 == 0) {

-                      uVar32 = (ulonglong)unaff_RSI & 0xffffffff;

-                    }

-                    else {

-                      uVar32 = (ulonglong)*(uint *)(unaff_R15 + 0x124);

-                    }

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996deb;

-                    uVar28 = ObInitProcess(-(ulonglong)

-                                            ((*(uint *)((longlong)register0x00000020 + 0x880) & 4)

-                                            != 0) & uVar29,unaff_R14,uVar32);

-                  }

-                  uVar32 = (ulonglong)uVar28;

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

-                    uVar13 = *(undefined1 *)((longlong)register0x00000020 + 0x80);

-                    if ((*(byte *)((longlong)register0x00000020 + 0x400) & 7) != 0) {

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996e3a;

-                      PspApplyIFEOPerfOptions

-                                (unaff_R14,(undefined1 *)((longlong)register0x00000020 + 0x400),

-                                 uVar13);

-                    }

-                    if ((uVar17 >> 0x15 & 1) != 0) {

-                      *(byte *)((longlong)register0x00000020 + 0x20) = bVar30;

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996e5f;

-                      KeSetCpuSetsProcess(unaff_R14,

-                                          *(undefined4 *)((longlong)register0x00000020 + 0xcc),

-                                          *(undefined8 *)((longlong)register0x00000020 + 0x188),

-                                          unaff_R13 & 0xff);

-                    }

-                    if ((*(byte *)((longlong)register0x00000020 + 0x404) & 2) != 0) {

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996e78;

-                      KeSetExpectedConcurrencyCountProcess

-                                (unaff_R14,*(undefined4 *)((longlong)register0x00000020 + 0x420));

-                    }

-                    if ((unaff_R15 != 0) && ((*(uint *)(unaff_R15 + 8) >> 8 & 1) != 0)) {

-                      uVar2 = *(undefined1 *)(unaff_R15 + 2);

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996e9a;

-                      uVar28 = PspSetProcessPriorityClass(unaff_R14,uVar2,0,uVar13);

-                      uVar32 = (ulonglong)uVar28;

-                      if ((int)uVar28 < 0) goto LAB_14;

-                    }

-                    *(undefined8 **)((longlong)register0x00000020 + 0x20) = unaff_RSI;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996ebe;

-                    uVar13 = PspComputeQuantumAndPriority

-                                       (unaff_R14,0,

-                                        (undefined1 *)((longlong)register0x00000020 + 0x94),0);

-                    *(undefined1 *)(unaff_R14 + 0x90) = uVar13;

-                    *(undefined1 *)(unaff_R14 + 0x91) =

-                         *(undefined1 *)((longlong)register0x00000020 + 0x94);

-                    uVar32 = (ulonglong)unaff_RSI & 0xffffffff;

-                    *(uint *)((longlong)register0x00000020 + 0xcc) = uVar34;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996eec;

-                    PspReadIFEOMitigationOptions

-                              (extraout_XMM0_Da_01,

-                               (undefined1 *)((longlong)register0x00000020 + 0x3d0));

-                    *(undefined8 *)((longlong)register0x00000020 + 0x280) =

-                         *(undefined8 *)((longlong)register0x00000020 + 0x3d0);

-                    *(undefined8 *)((longlong)register0x00000020 + 0x288) =

-                         *(undefined8 *)((longlong)register0x00000020 + 0x3d8);

-                    *(undefined8 *)((longlong)register0x00000020 + 0x290) =

-                         *(undefined8 *)((longlong)register0x00000020 + 0x3e0);

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2a0) =

-                         (undefined4)PspSystemMitigationOptions;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2a4) =

-                         PspSystemMitigationOptions._4_4_;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2a8) = uRam0000000140fc6148;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2ac) = uRam0000000140fc614c;

-                    *(undefined8 *)((longlong)register0x00000020 + 0x2b0) = DAT_15;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996f4b;

-                    uVar36 = PspInheritMitigationOptions

-                                       ((undefined1 *)((longlong)register0x00000020 + 0x2a0),

-                                        (undefined1 *)((longlong)register0x00000020 + 0x280),

-                                        (undefined1 *)((longlong)register0x00000020 + 0x3d0));

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996f5b;

-                    PspReadIFEOMitigationAuditOptions

-                              (uVar36,(undefined1 *)((longlong)register0x00000020 + 1000));

-                    *(undefined8 *)((longlong)register0x00000020 + 0x2c0) =

-                         *(undefined8 *)((longlong)register0x00000020 + 1000);

-                    *(undefined8 *)((longlong)register0x00000020 + 0x2c8) =

-                         *(undefined8 *)((longlong)register0x00000020 + 0x3f0);

-                    *(undefined8 *)((longlong)register0x00000020 + 0x2d0) =

-                         *(undefined8 *)((longlong)register0x00000020 + 0x3f8);

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2e0) =

-                         _PspSystemMitigationAuditOptions;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2e4) = uRam0000000140fc63b4;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2e8) = uRam0000000140fc63b8;

-                    *(undefined4 *)((longlong)register0x00000020 + 0x2ec) = uRam0000000140fc63bc;

-                    *(undefined8 *)((longlong)register0x00000020 + 0x2f0) = DAT_16;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996fba;

-                    PspInheritMitigationAuditOptions

-                              ((undefined1 *)((longlong)register0x00000020 + 0x2e0),

-                               (undefined1 *)((longlong)register0x00000020 + 0x2c0),

-                               (undefined1 *)((longlong)register0x00000020 + 1000));

-                    uVar28 = ((ushort)((ulonglong)

-                                       *(undefined8 *)((longlong)register0x00000020 + 0x3d0) >> 0x30

-                                      ) & 3) << 0xe;

-                    if (unaff_R15 != 0) {

-                      if ((*(uint *)(unaff_R15 + 8) >> 0x10 & 1) != 0) {

-                        uVar25 = *(undefined8 *)(unaff_R15 + 0x158);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x300) =

-                             *(undefined8 *)(unaff_R15 + 0x150);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x308) = uVar25;

-                        *(undefined8 *)((longlong)register0x00000020 + 0x310) =

-                             *(undefined8 *)(unaff_R15 + 0x160);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x360) =

-                             *(undefined8 *)((longlong)register0x00000020 + 0x3d0);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x368) =

-                             *(undefined8 *)((longlong)register0x00000020 + 0x3d8);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x370) =

-                             *(undefined8 *)((longlong)register0x00000020 + 0x3e0);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997043;

-                        PspInheritMitigationOptions

-                                  ((undefined1 *)((longlong)register0x00000020 + 0x360),

-                                   (undefined1 *)((longlong)register0x00000020 + 0x300),

-                                   (undefined1 *)((longlong)register0x00000020 + 0x3d0));

-                      }

-                      if ((unaff_R15 != 0) && ((*(uint *)(unaff_R15 + 8) >> 0x1b & 1) != 0)) {

-                        uVar25 = *(undefined8 *)(unaff_R15 + 0x1c8);

-                        *(undefined8 *)((longlong)register0x00000020 + 800) =

-                             *(undefined8 *)(unaff_R15 + 0x1c0);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x328) = uVar25;

-                        *(undefined8 *)((longlong)register0x00000020 + 0x330) =

-                             *(undefined8 *)(unaff_R15 + 0x1d0);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x340) =

-                             *(undefined8 *)((longlong)register0x00000020 + 1000);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x348) =

-                             *(undefined8 *)((longlong)register0x00000020 + 0x3f0);

-                        *(undefined8 *)((longlong)register0x00000020 + 0x350) =

-                             *(undefined8 *)((longlong)register0x00000020 + 0x3f8);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409970b4;

-                        PspInheritMitigationAuditOptions

-                                  ((undefined1 *)((longlong)register0x00000020 + 0x340),

-                                   (undefined1 *)((longlong)register0x00000020 + 800),

-                                   (undefined1 *)((longlong)register0x00000020 + 1000));

-                      }

-                    }

-                    if (*(uint *)((longlong)register0x00000020 + 0xd8) != uVar34) {

-                      uVar28 = uVar28 | 4;

-                    }

-                    uVar20 = uVar28 | 0x40;

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

-                      uVar20 = uVar28;

-                    }

-                    if ((uVar20 & 0x3fc0) != 0) {

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409970e6;

-                      PspHardenMitigationOptions

-                                ((undefined1 *)((longlong)register0x00000020 + 0x3d0));

-                    }

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409970eb;

-                    cVar11 = KeIsUserCetAllowed();

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

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d8) =

-                           *(ulonglong *)((longlong)register0x00000020 + 0x3d8) & 0xefffffffffffffff

-                           | 0x2000000000000000;

-                    }

-                    uVar16 = *(ushort *)((longlong)register0x00000020 + 0xa8) & 0x4000;

-                    if ((uVar16 == 0) || ((uVar17 >> 0x12 & 1) == 0)) {

-                      *(uint *)((longlong)register0x00000020 + 0x108) = uVar34;

-                    }

-                    uVar28 = (uVar17 >> 1 & 0x3e00000 | uVar17 & 0x100000) >> 4 |

-                             (uint)CONCAT71(uVar7,(uVar17 & 0x6000) != 0) |

-                             *(ushort *)((longlong)register0x00000020 + 0xa8) >> 4 & 2 |

-                             -(uint)(uVar16 != 0) & 8 | uVar20 |

-                             *(uint *)((longlong)register0x00000020 + 0x108);

-                    if ((bVar12 & (byte)(uVar17 >> 1)) != 0) {

-                      uVar29 = *(ulonglong *)((longlong)register0x00000020 + 0x3d0);

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d0) =

-                           uVar29 & 0xfffffeffffffffff | 0x20000000000;

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d8) =

-                           *(ulonglong *)((longlong)register0x00000020 + 0x3d8) & 0xeffffffffffffffe

-                           | 0x2000000000000002;

-                      if ((*(byte *)((longlong)register0x00000020 + 0x888) & 2) == 0) {

-                        uVar29 = uVar29 & 0xfffffeffffccffff | 0x20000110000;

-                      }

-                      else {

-                        uVar29 = uVar29 & 0xfffffeffffecffff | 0x20000220000;

-                      }

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d0) = uVar29;

-                    }

-                    lVar22 = *(longlong *)((longlong)register0x00000020 + 0x98);

-                    if (((uVar17 & 4) != 0) && ((*(uint *)(lVar22 + 0x754) & 0x4000) == 0)) {

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d8) =

-                           *(ulonglong *)((longlong)register0x00000020 + 0x3d8) & 0xefffffffffffffff

-                           | 0x2000000000000000;

-                    }

-                    if ((uVar17 & 0x40) != 0) {

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3d8) =

-                           *(ulonglong *)((longlong)register0x00000020 + 0x3d8) & 0xefffffffffffffff

-                           | 0x2000000000000000;

-                    }

-                    uVar29 = *(ulonglong *)((longlong)register0x00000020 + 0x3e0) &

-                             0xffffffffffffefff | 0x2000;

-                    *(ulonglong *)((longlong)register0x00000020 + 0x3e0) = uVar29;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997289;

-                    cVar11 = KeIsCoreIsolationMitigationPolicyEnforceable();

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

-                      *(ulonglong *)((longlong)register0x00000020 + 0x3e0) =

-                           uVar29 & 0xfffffffffeffffff | 0x2000000;

-                    }

-                    *(undefined4 *)((longlong)register0x00000020 + 0x30) =

-                         *(undefined4 *)((longlong)register0x00000020 + 0xe8);

-                    *(undefined4 *)((longlong)register0x00000020 + 0x28) =

-                         *(undefined4 *)((longlong)register0x00000020 + 0xec);

-                    *(uint *)((longlong)register0x00000020 + 0x20) = uVar28;

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409972d4;

-                    PspApplyMitigationOptions

-                              (unaff_R14,lVar22,(undefined1 *)((longlong)register0x00000020 + 0x3d0)

-                               ,(undefined1 *)((longlong)register0x00000020 + 1000));

-                    if (unaff_R15 != 0) {

-                      if (*(undefined4 **)(unaff_R15 + 0x1b0) != (undefined4 *)0x0) {

-                        puVar1 = (uint *)(unaff_R14 + 0x750);

-                        if ((bVar12 & (byte)**(undefined4 **)(unaff_R15 + 0x1b0)) != 0) {

-                          LOCK();

-                          *puVar1 = *puVar1 | 0x4000;

-                          UNLOCK();

-                          unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-                        }

-                        if ((**(uint **)(unaff_R15 + 0x1b0) & 2) != 0) {

-                          LOCK();

-                          *puVar1 = *puVar1 | 0x8000;

-                          UNLOCK();

-                          unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-                        }

-                        *(undefined4 *)(unaff_R14 + 0x6e8) =

-                             *(undefined4 *)(*(longlong *)(unaff_R15 + 0x1b0) + 4);

-                      }

-                      if (unaff_R15 != 0) {

-                        if (*(undefined4 **)(unaff_R15 + 0x1b8) != (undefined4 *)0x0) {

-                          *(undefined4 *)(unaff_R14 + 0x7a0) = **(undefined4 **)(unaff_R15 + 0x1b8);

-                        }

-                        if (unaff_R15 != 0) {

-                          uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0x3d8);

-                          *(undefined8 *)(unaff_R15 + 0x150) =

-                               *(undefined8 *)((longlong)register0x00000020 + 0x3d0);

-                          *(undefined8 *)(unaff_R15 + 0x158) = uVar25;

-                          *(undefined8 *)(unaff_R15 + 0x160) =

-                               *(undefined8 *)((longlong)register0x00000020 + 0x3e0);

-                          uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0x3f0);

-                          *(undefined8 *)(unaff_R15 + 0x1c0) =

-                               *(undefined8 *)((longlong)register0x00000020 + 1000);

-                          *(undefined8 *)(unaff_R15 + 0x1c8) = uVar25;

-                          *(undefined8 *)(unaff_R15 + 0x1d0) =

-                               *(undefined8 *)((longlong)register0x00000020 + 0x3f8);

-                        }

-                      }

-                    }

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409973a9;

-                    PsQueryProcessAttributes

-                              (unaff_R14,0,(undefined1 *)((longlong)register0x00000020 + 0x95));

-                    uVar28 = uVar34;

-                    if (*(uint *)((longlong)register0x00000020 + 0xd8) != uVar34) {

-                      uVar28 = uVar19;

-                    }

-                    uVar20 = uVar28 | 2;

-                    if ((*(uint *)((longlong)register0x00000020 + 0x880) & 0x20000) == 0) {

-                      uVar20 = uVar28;

-                    }

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409973d1;

-                    uVar36 = SmProcessCreateNotification(unaff_R14,uVar20);

-                    if ((*(uint *)(unaff_R14 + 0x754) & 0x4000) != 0) {

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409973e6;

-                      uVar28 = KeInitializeProcessUserCetLogging();

-                      uVar32 = (ulonglong)uVar28;

-                      uVar36 = extraout_XMM0_Da_02;

-                      if ((int)uVar28 < 0) goto LAB_14;

-                    }

-                    if ((*(byte *)((longlong)register0x00000020 + 0x880) & 0x80) != 0) {

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997407;

-                      iVar18 = PspIsSessionLeaderProcess();

-                      uVar36 = extraout_XMM0_Da_03;

-                      if (iVar18 == 0) {

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099741e;

-                        cVar11 = SeSinglePrivilegeCheck

-                                           (SeLoadDriverPrivilege,

-                                            *(undefined1 *)((longlong)register0x00000020 + 0x80));

-                        uVar36 = extraout_XMM0_Da_04;

-                        if (cVar11 == '\0') goto LAB_9;

-                      }

-                    }

-                    uVar28 = uVar17;

-                    if ((bVar12 & (byte)uVar17) != 0) {

-LAB_17:

-                      if ((uVar28 >> 10 & 1) != 0) {

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409975e0;

-                        RtlReleasePrivilege();

-                      }

-                      if (*(short *)(unaff_R14 + 0x6ec) == 0x14c) {

-                        *(uint *)(unaff_R14 + 0x88) = *(uint *)(unaff_R14 + 0x88) | uVar19;

-                      }

-                      cVar11 = (char)uVar28;

-                      if (((cVar11 < '\0') && (unaff_R15 != 0)) && ((uVar28 & 2) == 0)) {

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997617;

-                        uVar29 = PspSetupReservedUserMappings

-                                           (unaff_R14,

-                                            (undefined1 *)((longlong)register0x00000020 + 0x428));

-                        uVar32 = uVar29 & 0xffffffff;

-                        if ((int)uVar29 < 0) goto LAB_1;

-                      }

-                      if ((uVar28 >> 8 & 1) != 0) {

-                        *(undefined8 *)((longlong)register0x00000020 + 400) = 0;

-                        *(undefined8 *)((longlong)register0x00000020 + 0x198) = 0xffffffffffffffff;

-                        bVar14 = *(byte *)(unaff_R14 + 0x5fa) & 7;

-                        bVar12 = (*(byte *)((longlong)register0x00000020 + 0x95) & bVar12 |

-                                 -(*(int *)((longlong)register0x00000020 + 0xd8) != 0) & 2U) << 4 |

-                                 (((byte)(uVar28 >> 0xc) & bVar12 | -(bVar30 < bVar14) & 2U |

-                                  *(byte *)((longlong)register0x00000020 + 0x193) & 0xfc) & 0xbb |

-                                 ((byte)(uVar28 >> 0xd) & bVar12 |

-                                 (bVar14 != bVar12) - bVar12 & 0x10) << 2) & 0xcf;

-                        *(byte *)((longlong)register0x00000020 + 0x193) = bVar12;

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

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409976db;

-                          uVar34 = MmCreatePeb(unaff_R14,

-                                               (undefined1 *)((longlong)register0x00000020 + 400),

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

-                                               (undefined1 *)((longlong)register0x00000020 + 0x210))

-                          ;

-                          uVar32 = (ulonglong)uVar34;

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

-                            if (*(undefined8 **)((longlong)register0x00000020 + 0x210) != unaff_RSI)

-                            {

-                              LOCK();

-                              *(uint *)(unaff_R14 + 0x1f0) =

-                                   *(uint *)(unaff_R14 + 0x1f0) & 0xffcfffff;

-                              UNLOCK();

-                              *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-                                   (undefined1 *)((longlong)register0x00000020 + 0x15c);

-                              unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-                              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099772b;

-                              PspSetProcessAffinitySafe

-                                        (unaff_R14,unaff_R13 & 0xffffffff,0,

-                                         (undefined1 *)((longlong)register0x00000020 + 0x210));

-                            }

-                            goto LAB_18;

-                          }

-                          *(undefined8 *)(unaff_R14 + 0x2e0) = unaff_RSI;

-                        }

-                        else {

-                          lVar22 = *(longlong *)((longlong)register0x00000020 + 0x98);

-                          puVar3 = *(undefined4 **)(lVar22 + 0x2e0);

-                          *(undefined4 **)(unaff_R14 + 0x2e0) = puVar3;

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

-                            uVar13 = 1;

-                            goto LAB_19;

-                          }

-                          *(undefined1 *)((longlong)register0x00000020 + 400) = 1;

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409977fc;

-                          KiStackAttachProcess

-                                    (unaff_R14,0,

-                                     (undefined1 *)((longlong)register0x00000020 + 0x428));

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099780f;

-                          lVar22 = MmSecureVirtualMemory(puVar3,2000,4);

-                          if (lVar22 == 0) {

-                            uVar32 = 0xc0000141;

-                          }

-                          else {

-                            uVar36 = *(undefined4 *)((longlong)register0x00000020 + 0x194);

-                            uVar8 = *(undefined4 *)((longlong)register0x00000020 + 0x198);

-                            uVar9 = *(undefined4 *)((longlong)register0x00000020 + 0x19c);

-                            *puVar3 = *(undefined4 *)((longlong)register0x00000020 + 400);

-                            puVar3[1] = uVar36;

-                            puVar3[2] = uVar8;

-                            puVar3[3] = uVar9;

-                          }

-                          if ((-1 < (int)uVar32) &&

-                             (*(undefined8 **)(unaff_R14 + 0x310) != (undefined8 *)0x0)) {

-                            if ((*(short *)(unaff_R14 + 0x6ec) == 0x14c) ||

-                               (*(short *)(unaff_R14 + 0x6ec) == 0x1c4)) {

-                              bVar30 = 1;

-                            }

-                            if (bVar30 != 0) {

-                              puVar26 = (undefined8 *)**(undefined8 **)(unaff_R14 + 0x310);

-                              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409978db;

-                              lVar22 = MmSecureVirtualMemory(puVar26,0x488,4);

-                              if (lVar22 == 0) {

-                                uVar32 = 0xc0000141;

-                              }

-                              else {

-                                *(undefined4 *)((longlong)register0x00000020 + 0x150) = 0;

-                                *(undefined4 *)((longlong)register0x00000020 + 0x154) = 0xffffffff;

-                                *(undefined1 *)((longlong)register0x00000020 + 0x150) = 1;

-                                *(byte *)((longlong)register0x00000020 + 0x153) = bVar12;

-                                *puVar26 = *(undefined8 *)((longlong)register0x00000020 + 0x150);

-                              }

-                            }

-                          }

-                          unaff_R13 = 1;

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997968;

-                          KiUnstackDetachProcess

-                                    ((undefined1 *)((longlong)register0x00000020 + 0x428),0);

-                          if (-1 < (int)uVar32) goto LAB_18;

-                        }

-                        goto LAB_1;

-                      }

-LAB_18:

-                      uVar13 = (undefined1)unaff_R13;

-                      lVar22 = *(longlong *)((longlong)register0x00000020 + 0x98);

-LAB_19:

-                      if (((cVar11 < '\0') && (unaff_R15 != 0)) && ((uVar28 & 2) == 0)) {

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997763;

-                        uVar34 = PspSetupUserProcessAddressSpace

-                                           (lVar22,unaff_R14,

-                                            (undefined1 *)((longlong)register0x00000020 + 0x428));

-                        uVar32 = (ulonglong)uVar34;

-LAB_20:

-                        uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0x140);

-                      }

-                      else {

-                        if (((uVar28 >> 8 & 1) == 0) || ((uVar28 & 0x10) != 0)) goto LAB_20;

-                        uVar32 = (ulonglong)unaff_RSI & 0xffffffff;

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979a7;

-                        KiStackAttachProcess

-                                  (unaff_R14,0,(undefined1 *)((longlong)register0x00000020 + 0x428))

-                        ;

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979af;

-                        KeCopyXfdMaskToPeb(unaff_R14);

-                        uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0x140);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979c2;

-                        PspUpdatePebForAffinityChange(uVar25,unaff_R14);

-                        if (cVar11 < '\0') {

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979ce;

-                          uVar34 = MmMapApiSetView(unaff_R14);

-                          uVar32 = (ulonglong)uVar34;

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

-                            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979dc;

-                            uVar34 = PspMapSiloSharedDataView(unaff_R14);

-                            uVar32 = (ulonglong)uVar34;

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

-                              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409979eb;

-                              uVar34 = PspPrepareSystemDllInitBlock(0,0);

-                              uVar32 = (ulonglong)uVar34;

-                              if ((-1 < (int)uVar34) &&

-                                 (*(undefined8 **)(unaff_R14 + 0x310) != unaff_RSI)) {

-                                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a02;

-                                uVar36 = PsWow64GetProcessNtdllType(unaff_R14);

-                                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a0b;

-                                uVar34 = PspPrepareSystemDllInitBlock(uVar36,0);

-                                uVar32 = (ulonglong)uVar34;

-                              }

-                            }

-                          }

-                        }

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a1c;

-                        KiUnstackDetachProcess

-                                  ((undefined1 *)((longlong)register0x00000020 + 0x428),0);

-                      }

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

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997780;

-                        PspLockProcessExclusive(unaff_R14,uVar25);

-                        *(undefined8 **)((longlong)register0x00000020 + 0x20) = unaff_RSI;

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099779a;

-                        lVar22 = ExCreateHandleEx(PspCidTable,unaff_R14,0,0);

-                        *(longlong *)((longlong)register0x00000020 + 0x100) = lVar22;

-                        if (lVar22 == 0) {

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409977b9;

-                          PspUnlockProcessExclusive(unaff_R14,uVar25);

-                          uVar32 = 0xc000009a;

-                        }

-                        else {

-                          if ((uVar28 >> 0x10 & 1) == 0) {

-LAB_21:

-                            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997ab1;

-                            lVar24 = KeQuerySystemTimeUnsafe();

-                            if (lVar24 == 0) {

-                              unaff_R14 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-                              *(undefined8 *)(unaff_R14 + 0x1f8) = _DAT_22;

-                            }

-                            else {

-                              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997ac2;

-                              KeQuerySystemTimePrecise(unaff_R14 + 0x1f8);

-                            }

-                            *(longlong *)(unaff_R14 + 0x1d0) = lVar22;

-                            *(undefined8 *)(unaff_R14 + 0x680) = _DAT_23;

-                            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997afd;

-                            uVar25 = KiQueryUnbiasedInterruptTime(uVar13);

-                            lVar22 = *(longlong *)((longlong)register0x00000020 + 0xa0);

-                            *(undefined8 *)(lVar22 + 0x688) = uVar25;

-                            *(undefined8 *)(lVar22 + 0x698) = *(undefined8 *)(unaff_R14 + 0x680);

-                            **(longlong **)((longlong)register0x00000020 + 0x1f8) = lVar22;

-                            uVar32 = (ulonglong)*(uint *)((longlong)register0x00000020 + 0xcc);

-                            goto LAB_24;

-                          }

-                          uVar4 = *(undefined8 *)(unaff_R14 + 0x2a8);

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a43;

-                          uVar34 = MmGetSectionStrongImageReference

-                                             (0,0,uVar4,

-                                              (undefined1 *)((longlong)register0x00000020 + 0x1e0));

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

-                            *(ulonglong *)((longlong)register0x00000020 + 0x30) =

-                                 (ulonglong)*(uint *)(unaff_R15 + 0x178);

-                            *(undefined8 *)((longlong)register0x00000020 + 0x28) =

-                                 *(undefined8 *)(unaff_R15 + 0x168);

-                            *(undefined8 *)((longlong)register0x00000020 + 0x20) =

-                                 *(undefined8 *)((longlong)register0x00000020 + 0x1e0);

-                            uVar4 = *(undefined8 *)(unaff_R15 + 0xc0);

-                            uVar5 = *(undefined8 *)(unaff_R14 + 0x2e0);

-                            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a99;

-                            uVar34 = KeSecureProcess(unaff_R14,uVar5,

-                                                     *(undefined8 *)

-                                                      ((longlong)register0x00000020 + 0x100),uVar4);

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

-                              lVar22 = *(longlong *)((longlong)register0x00000020 + 0x100);

-                              goto LAB_21;

-                            }

-                          }

-                          uVar32 = (ulonglong)uVar34;

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997a54;

-                          PspUnlockProcessExclusive(unaff_R14,uVar25);

-                        }

-                      }

-                      goto LAB_1;

-                    }

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

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997443;

-                      uVar28 = PspInitializeFullProcessImageName(uVar36,unaff_R14);

-                      uVar32 = (ulonglong)uVar28;

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

-                        *(uint *)((longlong)register0x00000020 + 0x20) = uVar34;

-                        uVar25 = *(undefined8 *)((longlong)register0x00000020 + 0xf8);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099746e;

-                        uVar34 = MmInitializeProcessAddressSpace

-                                           (unaff_R14,0,uVar25,

-                                            (undefined1 *)((longlong)register0x00000020 + 0x880));

-                        uVar32 = (ulonglong)uVar34;

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

-                          *(uint *)((longlong)register0x00000020 + 0xcc) = uVar34;

-                          if ((unaff_R15 != 0) && ((uVar17 & 2) == 0)) {

-                            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997491;

-                            plVar23 = (longlong *)MiSectionControlArea(uVar25);

-                            if (*(longlong *)(*plVar23 + 0x20) != *(longlong *)(unaff_R14 + 0x2b0))

-                            {

-                              *(longlong *)(unaff_R15 + 0x38) =

-                                   *(longlong *)(unaff_R15 + 0x38) +

-                                   (*(longlong *)(unaff_R14 + 0x2b0) -

-                                   *(longlong *)(*plVar23 + 0x20));

-                            }

-                          }

-                          uVar17 = uVar17 | 0x80;

-                          *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-                          goto LAB_25;

-                        }

-                      }

-                    }

-                    else {

-                      *(undefined8 *)(unaff_R14 + 0x2b0) = *(undefined8 *)(lVar22 + 0x2b0);

-                      *(uint *)((longlong)register0x00000020 + 0x20) = uVar17 >> 3 & uVar19;

-                      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409974ec;

-                      uVar34 = MmInitializeProcessAddressSpace

-                                         (unaff_R14,lVar22,0,

-                                          (undefined1 *)((longlong)register0x00000020 + 0x880));

-                      uVar32 = (ulonglong)uVar34;

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

-                        uVar29 = (ulonglong)*(ushort *)(*(longlong *)(lVar22 + 0x350) + 2);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997518;

-                        _Dst = (void *)ExAllocatePool2(0x40,uVar29 + 0x10,0x61506553);

-                        *(void **)(unaff_R14 + 0x350) = _Dst;

-                        if (_Dst == (void *)0x0) goto LAB_26;

-                        lVar22 = *(longlong *)((longlong)register0x00000020 + 0x98);

-                        _Src = *(void **)(lVar22 + 0x350);

-                        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997545;

-                        RtlCopyMemory(_Dst,_Src,uVar29 + 0x10);

-                        *(longlong *)(*(longlong *)(unaff_R14 + 0x350) + 8) =

-                             *(longlong *)(unaff_R14 + 0x350) + 0x10;

-                        *(undefined4 *)(unaff_R14 + 0x2b8) = *(undefined4 *)(lVar22 + 0x2b8);

-                        if ((*(uint *)(lVar22 + 0x1f0) & 0x1000000) != 0) {

-                          *(uint *)(unaff_R14 + 0x1f0) = *(uint *)(unaff_R14 + 0x1f0) | 0x1000000;

-                        }

-                        if ((*(uint *)((longlong)register0x00000020 + 0x880) & 0x1000) != 0) {

-                          *(undefined8 **)(unaff_R14 + 0x2a8) = unaff_RSI;

-                          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099759a;

-                          ObfDereferenceObject();

-                        }

-LAB_25:

-                        uVar28 = uVar17;

-                        if ((bVar12 & (byte)uVar17) == 0) {

-                          uVar28 = (*(uint *)((longlong)register0x00000020 + 0x880) & 0x10) << 8 |

-                                   uVar17 & 0xffffefff;

-                          *(uint *)((longlong)register0x00000020 + 0x84) = uVar28;

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

-                            uVar28 = uVar28 | 0x100;

-                            *(uint *)((longlong)register0x00000020 + 0x84) = uVar28;

-                          }

-                        }

-                        goto LAB_17;

-                      }

-                    }

-                  }

-                }

-              }

-            }

-          }

-          else {

-            *(undefined8 **)((longlong)register0x00000020 + 0x178) = unaff_RSI;

-            uVar32 = (ulonglong)unaff_RSI & 0xffffffff;

-            *(uint *)((longlong)register0x00000020 + 0xe0) = uVar34;

-            uVar28 = uVar17 & 0xffffffdf;

-            *(byte *)((longlong)register0x00000020 + 0x88) = bVar30;

-            if (*(uint *)((longlong)register0x00000020 + 0x898) == uVar34) {

-              uVar19 = uVar17 & 4;

-              uVar17 = uVar28;

-              bVar12 = bVar30;

-              if (uVar19 != 0) {

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996999;

-                uVar17 = PsGetProcessSessionIdEx(*(longlong *)((longlong)register0x00000020 + 0x98))

-                ;

-                uVar32 = (ulonglong)uVar17;

-                *(uint *)((longlong)register0x00000020 + 0xe0) = uVar17;

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409969af;

-                uVar19 = PsGetProcessSessionIdEx

-                                   (*(undefined8 *)((longlong)register0x00000020 + 0xf0));

-                uVar17 = -(uint)(uVar17 != uVar19) & 0x20 | uVar28;

-              }

-LAB_27:

-              if ((uVar17 & 0x20) != 0) {

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099697e;

-                uVar28 = PspAttachSession(uVar32,(undefined1 *)

-                                                 ((longlong)register0x00000020 + 0x428),

-                                          (undefined1 *)((longlong)register0x00000020 + 0x178));

-                uVar32 = (ulonglong)uVar28;

-                if ((int)uVar28 < 0) {

-                  uVar17 = uVar17 & 0xffffffdf;

-                  goto LAB_14;

-                }

-                *(uint *)(unaff_R14 + 0x1f0) = *(uint *)(unaff_R14 + 0x1f0) | 0x80;

-              }

-              if ((*(uint *)((longlong)register0x00000020 + 0x898) == uVar34) || (bVar12 != 0)) {

-                uVar29 = *(ulonglong *)((longlong)register0x00000020 + 0x98);

-                uVar32 = uVar29;

-                if (bVar12 != 0) {

-                  uVar32 = *(ulonglong *)((longlong)register0x00000020 + 0xf0);

-                }

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996a36;

-                PspInheritQuota(unaff_R14,uVar32);

-              }

-              else {

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409969ee;

-                uVar28 = PspAssignProcessQuotaBlock

-                                   (0,unaff_R14,

-                                    *(undefined8 *)((longlong)register0x00000020 + 0x130));

-                uVar32 = (ulonglong)uVar28;

-                if ((int)uVar28 < 0) {

-                  if ((uVar17 & 0x20) != 0) {

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996a12;

-                    PspDetachSession(*(undefined8 *)((longlong)register0x00000020 + 0x178),

-                                     (undefined1 *)((longlong)register0x00000020 + 0x428));

-                  }

-                  goto LAB_14;

-                }

-                uVar29 = *(ulonglong *)((longlong)register0x00000020 + 0x98);

-              }

-              unaff_R13 = 1;

-              uVar16 = **(ushort **)((longlong)register0x00000020 + 0xb8);

-              *(longlong *)((longlong)register0x00000020 + 0x28) = unaff_R14;

-              *(uint *)((longlong)register0x00000020 + 0x20) = uVar16 + 1;

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996a96;

-              bVar12 = MmCreateProcessAddressSpace

-                                 (*(undefined8 *)((longlong)register0x00000020 + 0x148));

-              uVar17 = uVar17 ^ ((uint)bVar12 << 0xb ^ uVar17) & 0x800;

-              *(uint *)((longlong)register0x00000020 + 0x84) = uVar17;

-              if ((uVar17 & 0x20) != 0) {

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996ac8;

-                PspDetachSession(*(undefined8 *)((longlong)register0x00000020 + 0x178),

-                                 (undefined1 *)((longlong)register0x00000020 + 0x428));

-              }

-              if ((uVar17 & 0x800) != 0) goto LAB_12;

-LAB_26:

-              uVar32 = 0xc000009a;

-            }

-            else {

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409968b5;

-              cVar11 = SeSinglePrivilegeCheck

-                                 (SeAssignPrimaryTokenPrivilege,

-                                  *(undefined1 *)((longlong)register0x00000020 + 0x80));

-              uVar19 = uVar17 & 0xfffffddf;

-              uVar17 = uVar28 | 0x200;

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

-                uVar17 = uVar19;

-              }

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409968d9;

-              uVar28 = SeIsTokenAssignableToProcess

-                                 (*(undefined8 *)((longlong)register0x00000020 + 0x130),

-                                  (undefined1 *)((longlong)register0x00000020 + 0x88));

-              uVar32 = (ulonglong)uVar28;

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

-                if ((*(byte *)((longlong)register0x00000020 + 0x88) == bVar30) &&

-                   ((uVar17 >> 9 & 1) == 0)) {

-LAB_9:

-                  uVar32 = 0xc0000061;

-                }

-                else {

-                  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996913;

-                  uVar28 = SeQuerySessionIdToken

-                                     (*(undefined8 *)((longlong)register0x00000020 + 0x130),

-                                      (undefined1 *)((longlong)register0x00000020 + 0xe0));

-                  uVar32 = (ulonglong)uVar28;

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

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099692a;

-                    uVar28 = PsGetProcessSessionIdEx

-                                       (*(undefined8 *)((longlong)register0x00000020 + 0xf0));

-                    uVar32 = (ulonglong)*(uint *)((longlong)register0x00000020 + 0xe0);

-                    if (*(uint *)((longlong)register0x00000020 + 0xe0) != uVar28) {

-                      if ((uVar17 >> 9 & 1) == 0) goto LAB_9;

-                      if ((*(byte *)((longlong)register0x00000020 + 0x90) & 0x80) != 0) {

-                        uVar32 = 0xc000000d;

-                        goto LAB_14;

-                      }

-                      uVar17 = uVar17 | 0x20;

-                    }

-                    bVar12 = *(byte *)((longlong)register0x00000020 + 0x88);

-                    goto LAB_27;

-                  }

-                }

-              }

-            }

-          }

-LAB_14:

-          if ((uVar17 >> 10 & 1) != 0) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996616;

-            RtlReleasePrivilege(*(undefined8 *)((longlong)register0x00000020 + 0x180));

-          }

-        }

+      if (uVar11 != 0) {

+        RtlCopyMemory(param_5,(void *)(lVar8 + 0x2a),(ulonglong)uVar11);

+        *(undefined2 *)((longlong)param_5 + (ulonglong)(uVar11 >> 1) * 2) = 0;

+        *local_98 = uVar11;

+        goto LAB_1;

       }

     }

     else {

-      uVar32 = 0xc000007b;

-      uVar25 = 3;

+      if (1 < local_a8) {

+        uVar11 = local_a8 - 2;

+        local_b0 = (uint *)CONCAT44(local_b0._4_4_,uVar11);

+        goto LAB_2;

+      }

+      *local_98 = uVar11;

+    }

+    local_b8 = 0xc0000023;

+    goto LAB_1;

+  }

+  if (uVar12 == 0) {

+    local_b8 = 0xc000000d;

+    goto LAB_1;

+  }

+  local_b8 = 0;

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

+    *param_3 = 1;

+  }

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

+    *param_4 = 1;

+  }

+  if (param_5 == (void *)0x0) goto LAB_1;

+  local_c8 = param_2 & 0xffff;

+  iVar6 = _snwprintf_s(local_60,0x10,0xffffffffffffffff,L"#%u");

+  uVar10 = iVar6 * 2;

+  local_b0 = (uint *)CONCAT44(local_b0._4_4_,uVar10);

+  if (uVar10 < uVar11) {

 LAB_3:

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140995e7e;

-      PspUpdateCreateInfo(uVar25);

+    if (uVar10 != 0) {

+      RtlCopyMemory(param_5,local_60,(ulonglong)uVar10);

+      *(undefined2 *)((longlong)param_5 + (ulonglong)(uVar10 >> 1) * 2) = 0;

+      *local_98 = uVar10;

+      goto LAB_1;

     }

   }

+  else if (1 < uVar11) {

+    uVar10 = uVar11 - 2;

+    local_b0 = (uint *)CONCAT44(local_b0._4_4_,uVar10);

+    goto LAB_3;

+  }

+  local_b8 = 0xc0000023;

 LAB_1:

-  if (*(longlong *)((longlong)register0x00000020 + 0x100) != 0) {

-    *(longlong *)(unaff_R14 + 0x1d0) = *(longlong *)((longlong)register0x00000020 + 0x100);

+  LOCK();

+  plVar9 = (longlong *)(param_1 + 8);

+  lVar4 = *plVar9;

+  *plVar9 = *plVar9 + -1;

+  UNLOCK();

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

+    ExfTryToWakePushLock(param_1 + 8);

   }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996634;

-  PspRundownSingleProcess(unaff_R14,0);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996641;

-  ObfDereferenceObjectWithTag(unaff_R14,0x72437350);

-LAB_24:

-  if (*(longlong *)((longlong)register0x00000020 + 0x188) != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14099665b;

-    ExFreePoolWithTag(*(longlong *)((longlong)register0x00000020 + 0x188),0x73437350);

-  }

-  if (DAT_28 != (code *)0x0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140996674;

-    (*DAT_28)((undefined1 *)((longlong)register0x00000020 + 0x570));

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997b46;

-  return uVar32;

+  KeAbPostRelease(param_1 + 8);

+  KeLeaveCriticalRegionThread(SystemReserved1[0xf]);

+  return local_b8;

 }
```

## `FsRtlpOplockBreakToNone`  (modified)

```diff
--- FsRtlpOplockBreakToNone
+++ FsRtlpOplockBreakToNone
@@ -1,15 +1,134 @@
 

-undefined4 FsRtlpOplockBreakToNone(void)

+undefined4

+FsRtlpOplockBreakToNone

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

+          undefined8 param_5,undefined8 param_6,undefined8 param_7,undefined8 param_8,

+          undefined8 param_9,undefined8 param_10,undefined8 param_11,undefined1 *param_12,

+          undefined8 param_13)

 

 {

-  undefined4 uVar1;

-  undefined1 *puStack0000000000000028;

-  undefined8 in_stack_000000c8;

-  undefined8 in_stack_000000d0;

-  undefined8 in_stack_000000d8;

+  longlong lVar1;

+  undefined1 uVar2;

+  char cVar3;

+  undefined4 uVar4;

+  uint uVar5;

+  longlong *plVar6;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

   

-  puStack0000000000000028 = &stack0x00000060;

-  uVar1 = FsRtlpWaitOnIrp();

-  return uVar1;

+  local_38 = 0;

+  uStack_30 = 0;

+  local_28 = 0;

+  param_5._0_4_ = 0;

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

+    return 0;

+  }

+  uVar5 = *(uint *)(param_1 + 0x12);

+  if (uVar5 == 1) {

+    return 0;

+  }

+  if ((uVar5 & 0x6000) != 0) {

+    return 0;

+  }

+  if ((uVar5 & 0x1f00f90) == 0) {

+    lVar1 = *param_1;

+    if ((uVar5 >> 0xc & 1) != 0) {

+      return 0;

+    }

+    if ((param_4 & 0x10010000) != 0) {

+      return 0xc0000909;

+    }

+    uVar2 = KeAcquireQueuedSpinLock(7);

+    *(undefined1 *)(lVar1 + 0x45) = uVar2;

+    LOCK();

+    *(undefined8 *)(lVar1 + 0x68) = 0;

+    UNLOCK();

+    KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+    if (*(char *)(lVar1 + 0x44) != '\0') {

+      *(undefined8 *)(lVar1 + 0x38) = 8;

+      FsRtlpModifyThreadPriorities(param_1,0,0);

+      FsRtlpClearOwner(param_1,0);

+      *(undefined1 *)(param_1 + 4) = 0;

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

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

+      }

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

+      IofCompleteRequest(*param_1,1);

+      *param_1 = 0;

+      ObfDereferenceObjectWithTag(param_1[1],0x746c6644);

+      param_1[1] = 0;

+      *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+      while ((longlong *)param_1[0xb] != param_1 + 0xb) {

+        FsRtlpRemoveAndCompleteWaitingIrp();

+      }

+      return 0;

+    }

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

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

+    IofCompleteRequest(*param_1,1);

+    *param_1 = 0;

+    *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) | 0x200;

+  }

+  else {

+    if (((uVar5 & 0x1f0ffdf) == 0x10) || ((uVar5 & 0x1f0ffdf) == 0x1010)) {

+      if ((param_4 & 0x10010000) != 0) {

+        return 0xc0000909;

+      }

+      for (plVar6 = (longlong *)param_1[5]; plVar6 != param_1 + 5; plVar6 = (longlong *)*plVar6) {

+        if (*(int *)(plVar6[2] + 0x18) != 0x90240) {

+          plVar6 = (longlong *)plVar6[1];

+          FsRtlpRemoveAndCompleteReadOnlyIrp(*plVar6,0,0,param_1);

+        }

+      }

+      if ((*(uint *)(param_1 + 0x12) & 0x1f0ffdf) == 0x1010) {

+        uVar5 = *(uint *)(param_1 + 0x12) & 0x20 | 0x1000;

+      }

+      else {

+        uVar5 = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+      }

+      *(uint *)(param_1 + 0x12) = uVar5;

+      return 0;

+    }

+    if ((uVar5 >> 8 & 1) == 0) {

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

+        if ((param_4 & 0x10010000) != 0) {

+          return 0xc0000909;

+        }

+        *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+        param_1[1] = 0;

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

+          FsRtlpClearOwner(param_1,0);

+          *(undefined1 *)(param_1 + 4) = 0;

+          return 0;

+        }

+        return 0;

+      }

+    }

+    else {

+      if ((param_4 & 0x10010000) != 0) {

+        return 0xc0000909;

+      }

+      *(uint *)(param_1 + 0x12) = uVar5 & 0xfffffeff;

+      *(uint *)(param_1 + 0x12) = uVar5 & 0xfffffeff | 0x400;

+    }

+  }

+  if (((param_4 & 8) == 0) &&

+     (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(param_2 + 0x30),param_1[1],0), cVar3 != '\0')) {

+    return 0;

+  }

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

+    return 0x108;

+  }

+  if ((param_4 & 0x10010000) != 0) {

+    return 0xc0000909;

+  }

+  FsRtlpOplockTryStartBreakAckTimeout(param_1 + 0x14,param_1[0x16]);

+  FsRtlpModifyThreadPriorities(param_1,0,1);

+  FsRtlpOplockSendModernAppTermination(param_1,0);

+  *param_12 = 0;

+  uVar4 = FsRtlpWaitOnIrp(param_1,param_3,param_6,param_7,param_8,&local_38,0,param_9,param_10,

+                          param_11,param_13);

+  return uVar4;

 }
```

## `PopIdleChooseDozeS4Time`  (modified)

```diff
--- PopIdleChooseDozeS4Time
+++ PopIdleChooseDozeS4Time
@@ -1,135 +1,61 @@
 

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

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

 

-void PopIdleChooseDozeS4Time(void)

+undefined8 PopIdleChooseDozeS4Time(ulonglong *param_1,int *param_2)

 

 {

-  undefined8 uVar1;

-  undefined8 uVar2;

-  uint uVar3;

+  longlong lVar1;

+  int iVar2;

+  ulonglong uVar3;

   undefined1 uVar4;

-  uint in_EAX;

-  undefined4 uVar5;

-  undefined4 uVar6;

-  uint uVar7;

-  longlong unaff_RBP;

-  uint uVar8;

-  undefined8 unaff_RSI;

-  byte bVar9;

-  ulonglong unaff_R12;

-  uint uVar10;

-  int iVar11;

-  uint unaff_XMM6_Da;

-  int unaff_XMM6_Db;

-  undefined8 in_stack_00000020;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  int iVar7;

   

-  do {

-    bVar9 = (byte)unaff_R12;

-    uVar8 = (uint)unaff_RSI;

-    if (((bVar9 & (byte)in_EAX) != 0) &&

-       (((bVar9 & (byte)unaff_XMM6_Da) == 0 || (unaff_XMM6_Db != DAT_0)))) {

-      PopRecordPhysicalPowerButton(0);

-      DAT_1 = (undefined1)unaff_RSI;

-      DAT_2 = uVar8;

-      PopPublishPowerButtonState(&DAT_2);

-      KeDisableTimer2(&DAT_3,unaff_R12 & 0xff,unaff_R12 & 0xff,0);

+  lVar1 = _DAT_0;

+  uVar6 = 0;

+  uVar4 = 0;

+  iVar7 = 0;

+  uVar5 = (ulonglong)*(uint *)(PopPolicy + 0x58) * 10000000;

+  if (*(char *)(PopSmartSuspendDecision + 2) == '\0') {

+    if ((DAT_1 <= _DAT_fffff78000000014) || (PopSmartUserPresenceAction != 1))

+    goto LAB_2;

+    if ((ulonglong)(_DAT_3 - _DAT_140f0c268) <=

+        (ulonglong)PopSmartUserPresenceGracePeriod * 10000000) {

+      uVar6 = (ulonglong)PopSmartUserPresenceGracePeriod * 10000000 -

+              (_DAT_3 - _DAT_140f0c268);

     }

-    uVar5 = (undefined4)((ulonglong)in_stack_00000020 >> 0x20);

-    iVar11 = unaff_XMM6_Db;

-    uVar10 = unaff_XMM6_Da;

-    if ((bVar9 & (byte)unaff_XMM6_Da) != 0) {

-      if ((bVar9 & (byte)DAT_2) == 0) {

-        ExUuidCreate(unaff_RBP + -0x11);

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

-        uVar2 = *(undefined8 *)(unaff_RBP + -9);

-        _DAT_4 = uVar1;

-        uRam0000000140f079a8 = uVar2;

-        PopRecordPhysicalPowerButton(unaff_R12 & 0xff);

-        iVar11 = *(int *)(unaff_RBP + -0x15);

-        DAT_0 = iVar11;

-        _DAT_5 = uVar1;

-        uRam0000000140f07940 = uVar2;

-        DAT_6 = PopQueryPowerButtonBugcheckEnabled();

-        *(undefined4 *)(unaff_RBP + -0x45) = 0x10008;

-        in_stack_00000020 = CONCAT44(uVar5,2);

-        KeInitializeIRTimer(&DAT_3,PopPowerButtonTimerCallback,iVar11,unaff_RBP + -0x45,

-                            in_stack_00000020);

-        KeSetTimer2(&DAT_3,0xffffffffff676980,10000000);

-        uVar10 = *(uint *)(unaff_RBP + -0x19);

-      }

-      DAT_2 = uVar10;

-      PopPublishPowerButtonState(&DAT_2);

-      uVar7 = uVar10 >> 1;

-      if (6999 < uVar7) {

-        PopDiagTracePowerButtonBugcheck(uVar7);

-        PopRecordPoBlackboxInformation();

-        if (DAT_6 != uVar8) {

-          PopBsdPowerTransitionToParam1(unaff_RBP + -0x49);

-                    /* WARNING: Subroutine does not return */

-          KeBugCheckEx(0x1c8,*(undefined4 *)(unaff_RBP + -0x49),&PopPowerButtonTriageBlock,

-                       uVar10 >> 1);

-        }

-      }

-      uVar3 = DAT_7;

-      if ((((bVar9 & (byte)DAT_7) != 0) && (DAT_140f07948 == uVar8)) &&

-         (uVar7 == (DAT_7 >> 4 & 0xf) * 1000)) {

-        PopBsdPowerTransitionToParam1(unaff_RBP + -0x49);

-        uVar7 = (uint)unaff_R12;

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

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

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

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

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

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

-          *(ulonglong *)(unaff_RBP + 7) =

-               uVar3 >> 8 & unaff_R12 | *(ulonglong *)(unaff_RBP + 7) & 0xfffffffffffffffe;

-          *(longlong *)(unaff_RBP + -0x21) = unaff_RBP + -1;

-          *(uint *)(unaff_RBP + -0x29) = uVar8 | 0x18;

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

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

-          *(uint *)(unaff_RBP + -1) = uVar7;

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

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

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

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

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

-          uVar5 = DbgkWerCaptureLiveKernelDump2

-                            (L"PopPowerButton",0x11c8,*(undefined4 *)(unaff_RBP + -0x49),

-                             &PopPowerButtonTriageBlock,uVar10 >> 1);

-                    /* WARNING: Subroutine does not return */

-          DbgPrintEx(0x92,2,

-                     "PopPowerButtonWorkCallback: DbgkWerCaptureLiveKernelDump2 completed with Status: %08x, SelectiveThreadKernelStacks: %01x\n"

-                     ,uVar5,uVar3 >> 8 & uVar7);

-        }

-        uVar6 = 0;

-        uVar5 = DbgkWerCaptureLiveKernelDump(L"PopPowerButton");

-                    /* WARNING: Subroutine does not return */

-        DbgPrintEx(0x92,2,

-                   "PopPowerButtonWorkCallback: DbgkWerCaptureLiveKernelDump completed with Status: %08x, UserPages:  %08x, HypervisorPages:  %08x\n"

-                   ,uVar5,CONCAT44(uVar6,((uVar3 & 2 | 0x10) >> 1 | uVar3 & 4) & uVar7));

-      }

+    iVar2 = 0;

+    if (((longlong)(uVar6 + _DAT_0) <

+         (longlong)(DAT_1 + ((ulonglong)PopSmartUserPresenceWakeOffset + 0x3c) * -10000000))

+       && (((uVar6 == 0 || (uVar5 == 0)) || (iVar2 = iVar7, uVar6 < uVar5)))) {

+      iVar7 = 2;

+      goto LAB_4;

     }

-    uVar4 = KeAcquireSpinLockRaiseToDpc(&PopPowerButtonHold);

-    uVar1 = DAT_8;

-    uVar6 = uRam0000000140f07924;

-    uVar5 = uRam0000000140f07920;

-    unaff_XMM6_Db = DAT_9;

-    unaff_XMM6_Da = DAT_10;

-    if ((uVar10 == DAT_10) && (iVar11 == DAT_140f0791c)) {

-      LOCK();

-      UNLOCK();

-      DAT_11 = uVar8;

-      KeReleaseSpinLock(&PopPowerButtonHold,uVar4);

-      return;

+  }

+  else {

+    iVar7 = 6;

+    if (*(longlong *)(PopSmartSuspendDecision + 0x30) == 0) goto LAB_2;

+    uVar3 = *(longlong *)(PopSmartSuspendDecision + 0x30) - _DAT_0;

+    if (-1 < (longlong)uVar3) {

+      uVar6 = uVar3;

     }

-    *(uint *)(unaff_RBP + -0x19) = DAT_10;

-    *(int *)(unaff_RBP + -0x15) = unaff_XMM6_Db;

-    *(undefined4 *)(unaff_RBP + -0x11) = uVar5;

-    *(undefined4 *)(unaff_RBP + -0xd) = uVar6;

-    *(undefined8 *)(unaff_RBP + -9) = uVar1;

-    KeReleaseSpinLock(&PopPowerButtonHold,uVar4);

-    in_EAX = DAT_2;

-  } while( true );

+LAB_4:

+    uVar4 = 1;

+    iVar2 = iVar7;

+  }

+  iVar7 = iVar2;

+  uVar6 = -uVar6;

+LAB_2:

+  if ((uVar5 != 0) && (iVar7 == 0)) {

+    uVar4 = 1;

+    uVar6 = (ulonglong)*(uint *)(PopPolicy + 0x58) * -10000000;

+    iVar7 = 1;

+  }

+  *param_1 = uVar6;

+  if (param_2 != (int *)0x0) {

+    *param_2 = iVar7;

+  }

+  return CONCAT71((int7)((ulonglong)lVar1 >> 8),uVar4);

 }
```

## `PopPowerAggregatorTriggerAdaptiveAction`  (modified)

```diff
--- PopPowerAggregatorTriggerAdaptiveAction
+++ PopPowerAggregatorTriggerAdaptiveAction
@@ -1,52 +1,60 @@
 

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

-

-uint PopPowerAggregatorTriggerAdaptiveAction(byte param_1)

+void PopPowerAggregatorTriggerAdaptiveAction(int param_1)

 

 {

-  byte *pbVar1;

-  byte bVar2;

-  uint uVar3;

-  longlong in_RAX;

-  longlong lVar4;

-  uint unaff_EBX;

-  longlong unaff_RBP;

-  uint uVar5;

-  uint *unaff_RDI;

-  undefined4 unaff_R14D;

-  uint auStackX_20 [2];

+  int iVar1;

+  int iVar2;

+  undefined4 local_38;

+  undefined4 local_34;

+  undefined4 local_30;

+  int local_28 [8];

   

-  pbVar1 = (byte *)(unaff_RBP + -0x7b);

-  *pbVar1 = *pbVar1 | param_1;

-  bVar2 = *pbVar1;

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

-  *pbVar1 = *pbVar1 >> 5 | *pbVar1 << 3;

-  in(0x44);

-  PpmAcquireLock();

-  if (((int)unaff_RBP == 4) && (unaff_RDI != (uint *)0x0)) {

-    uVar3 = *unaff_RDI;

-    if (100 < *unaff_RDI) {

-      uVar3 = 100;

+  local_28[6] = 0;

+  local_28[7] = 0;

+  local_28[0] = 0x11;

+  local_28[2] = 0;

+  local_28[3] = 0;

+  local_28[4] = 0;

+  local_28[5] = 0;

+  PopAcquireRwLockExclusive(&PopPowerAggregatorLock);

+  iVar1 = DAT_0;

+  if ((DAT_2 != 1) || (iVar1 = param_1, DAT_140f08b4c == '\0')) goto LAB_140758589;

+  if (param_1 == 1) {

+LAB_3:

+    local_28[0] = 0xd;

+    iVar1 = DAT_0;

+  }

+  else {

+    if (param_1 == 2) {

+      local_28[0] = 0xe;

+      iVar1 = DAT_0;

+      goto LAB_1;

     }

-    lVar4 = KeGetPrcb(unaff_R14D);

-    if (lVar4 != 0) {

-      lVar4 = *(longlong *)(lVar4 + 0x89b8);

-      uVar5 = unaff_EBX;

-      if (lVar4 != 0) {

-        if (CONCAT31((int3)(unaff_EBX >> 8),bVar2 == 0) == 0) {

-          *(uint *)(lVar4 + 0x34) = uVar3;

-        }

-        else {

-          *(uint *)(lVar4 + 0x30) = uVar3;

-        }

+    if (param_1 != 3) {

+      if (param_1 == 4) {

+        iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+        iVar1 = DAT_0;

+        if (iVar2 == 0) goto LAB_1;

+        goto LAB_3;

       }

-      goto LAB_0;

+      iVar1 = DAT_0;

+      if ((param_1 != 5) ||

+         (iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline(),

+         iVar1 = DAT_0, iVar2 == 0)) goto LAB_140758589;

     }

+    PopPowerAggregatorHandleIntentUnsafe(3,0,0,0x35);

+    iVar1 = DAT_0;

   }

-  uVar5 = 0xc000000d;

-LAB_0:

-  auStackX_20[0] = unaff_EBX | 0xe;

-  PpmReapplyPerfPolicy(auStackX_20);

-  return uVar5;

+LAB_1:

+  DAT_0 = iVar1;

+  PopReleaseRwLock(&PopPowerAggregatorLock);

+  if (local_28[0] != 0x11) {

+    local_30 = 0;

+    local_28[1] = 0x80;

+    local_38 = 3;

+    local_34 = 0x80000024;

+    PopExecutePowerAction(local_28,0,&local_38,5,1);

+  }

+  return;

 }
```

## `CmFcpManagerAllocateUsageProviderSubscription`  (modified)

```diff
--- CmFcpManagerAllocateUsageProviderSubscription
+++ CmFcpManagerAllocateUsageProviderSubscription
@@ -1,10 +1,26 @@
 

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

-

-void CmFcpManagerAllocateUsageProviderSubscription(void)

+undefined * CmFcpManagerAllocateUsageProviderSubscription(void)

 

 {

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

-  halt_baddata();

+  undefined *puVar1;

+  

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

+    LOCK();

+    UNLOCK();

+    if (3 < DAT_1 + 1) {

+      DAT_1 = DAT_1 + 1;

+      return (undefined *)0x0;

+    }

+    puVar1 = &DAT_2 + (ulonglong)DAT_140ef7568 * 0x88;

+    DAT_1 = DAT_1 + 1;

+  }

+  else {

+    puVar1 = (undefined *)ExAllocatePool2(0x40,0x88,0x63466d43);

+    if (puVar1 == (undefined *)0x0) {

+      return (undefined *)0x0;

+    }

+  }

+  CmFcpInitializeFeatureUsageProviderSubscription(puVar1);

+  return puVar1;

 }
```

## `MiIsUserQueryVmCallerTrusted`  (modified)

```diff
--- MiIsUserQueryVmCallerTrusted
+++ MiIsUserQueryVmCallerTrusted
@@ -1,72 +1,57 @@
 

-void MiIsUserQueryVmCallerTrusted(void)

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

+

+bool MiIsUserQueryVmCallerTrusted(longlong param_1)

 

 {

   char cVar1;

-  char *in_RAX;

-  uint uVar2;

-  uint uVar3;

-  uint *unaff_RBX;

-  ulonglong unaff_RBP;

-  byte unaff_SIL;

-  longlong unaff_RDI;

-  ulonglong uVar4;

-  longlong unaff_R15;

+  longlong lVar2;

+  bool bVar3;

+  undefined1 auStack_98 [32];

+  undefined1 *local_78;

+  undefined8 local_70;

+  undefined1 local_68 [4];

+  int local_64;

+  undefined1 local_60 [8];

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined4 local_38;

+  undefined4 local_34;

+  undefined8 local_30;

+  undefined4 local_28;

+  ulonglong local_20;

   

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

-  if (((ulonglong)in_RAX & 4) != 0) {

-    uVar2 = *unaff_RBX;

-    *unaff_RBX = uVar2 | 2;

-    cVar1 = HvIsCurrentLogSwappable();

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

-      uVar2 = uVar2 | 0x42;

-    }

-    else {

-      uVar2 = uVar2 | 0x22;

-    }

-    *unaff_RBX = uVar2;

+  local_20 = __security_cookie ^ (ulonglong)auStack_98;

+  local_70 = 0;

+  local_78 = local_60;

+  local_64 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  lVar2 = PsReferenceEffectiveToken(0,0x74726853,&local_64,local_68);

+  cVar1 = SeTokenIsAdmin(lVar2);

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

+    local_28 = 0;

+    local_30 = SeProfileSingleProcessPrivilege;

+    local_38 = 1;

+    local_34 = 1;

+    SeCaptureSubjectContextEx(param_1,*(undefined8 *)(param_1 + 0xb8),&local_58);

+    cVar1 = SePrivilegeCheck(&local_38,&local_58,1);

+    SeReleaseSubjectContext(&local_58);

+    bVar3 = cVar1 != '\0';

   }

-  uVar2 = *unaff_RBX;

-  if ((uVar2 & 0x40) != 0) {

-    uVar3 = uVar2;

-    cVar1 = CmpIsWriteQueueActive(unaff_RDI + 0x1070);

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

-      return;

-    }

-    uVar4 = (ulonglong)unaff_RBX[2];

-    if ((unaff_SIL & (byte)unaff_RBX[2]) == 0) {

-      *unaff_RBX = uVar3 | 1;

-      cVar1 = HvIsCurrentLogSwappable();

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

-        uVar2 = uVar3 | 5;

-        *unaff_RBX = uVar2;

-        if ((uVar4 & 4) == 0) goto LAB_0;

-        uVar2 = uVar3 | 0x405;

-      }

-      else {

-        uVar2 = uVar3 | 0x21;

-      }

-    }

-    else {

-      uVar2 = uVar3 | 0x504;

-    }

-    *unaff_RBX = uVar2;

+  else {

+    bVar3 = true;

   }

-LAB_0:

-  if (((byte)uVar2 & 0x48) == unaff_SIL) {

-    if (*(int *)(unaff_RDI + 0x80) == (int)unaff_R15) {

-      uVar2 = uVar2 | 0x800;

-      *unaff_RBX = uVar2;

-    }

-    if ((unaff_RBX[2] & 0x14) != 0) {

-      uVar2 = uVar2 | 0x1000;

-      *unaff_RBX = uVar2;

-    }

+  if (local_64 == 1) {

+    ObFastDereferenceObject(*(longlong *)(param_1 + 0x220) + 0x248,lVar2,0x74726853);

   }

-  if ((((*(uint *)(unaff_RDI + 0x1080) & 1) == 0) && (*(longlong *)(unaff_RDI + 0x608) != unaff_R15)

-      ) && ((unaff_RBP & 0x20) != 0 || (unaff_SIL & (byte)uVar2) != 0)) {

-    *unaff_RBX = uVar2 | 0x202;

+  else if (lVar2 != 0) {

+    ObfDereferenceObjectWithTag(lVar2,0x74726853);

   }

-  return;

+  return bVar3;

 }
```

## `AlpcpCancelMessagesByRequestor`  (modified)

```diff
--- AlpcpCancelMessagesByRequestor
+++ AlpcpCancelMessagesByRequestor
@@ -1,93 +1,417 @@
 

-void AlpcpCancelMessagesByRequestor(void)

+undefined4

+AlpcpCancelMessagesByRequestor

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

 

 {

-  ulonglong uVar1;

-  longlong lVar2;

-  longlong unaff_RBP;

-  int unaff_ESI;

-  longlong unaff_RDI;

-  undefined8 *puVar3;

-  longlong *plVar4;

-  longlong unaff_R12;

-  ulonglong *puVar5;

-  undefined8 *unaff_R15;

+  ulonglong *puVar1;

+  uint uVar2;

+  ulonglong uVar3;

+  undefined8 *puVar4;

+  undefined8 *puVar5;

+  int iVar6;

+  longlong lVar7;

+  longlong lVar8;

+  undefined8 uVar9;

+  longlong lVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  longlong *plVar13;

+  ulonglong uVar14;

+  bool bVar15;

+  bool bVar16;

+  undefined4 local_res20;

   

-  if ((int)unaff_RDI != 0) {

-    *(undefined1 *)(unaff_RDI + 10) = 1;

+  local_res20 = 0;

+  if ((param_4 == 1) || (param_4 == 2)) {

+    lVar7 = KeAbPreAcquire(param_2 + 0x88,0,0);

+    LOCK();

+    puVar1 = (ulonglong *)(param_2 + 0x88);

+    uVar12 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

+    if ((uVar12 & 1) == 0) goto LAB_0;

+    lVar8 = param_2 + 0x88;

+    lVar10 = param_2 + 0x88;

   }

+  else if (param_4 == 3) {

+    lVar7 = KeAbPreAcquire(param_2 + 0xb0,0,0);

+    LOCK();

+    puVar1 = (ulonglong *)(param_2 + 0xb0);

+    uVar12 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

+    if ((uVar12 & 1) == 0) goto LAB_0;

+    lVar8 = param_2 + 0xb0;

+    lVar10 = param_2 + 0xb0;

+  }

+  else {

+    lVar7 = KeAbPreAcquire(param_2 + 200,0,0);

+    LOCK();

+    puVar1 = (ulonglong *)(param_2 + 200);

+    uVar12 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

+    if ((uVar12 & 1) == 0) goto LAB_0;

+    lVar8 = param_2 + 200;

+    lVar10 = param_2 + 200;

+  }

+  ExfAcquirePushLockExclusiveEx(lVar10,lVar7,lVar8);

+LAB_0:

+  if (lVar7 != 0) {

+    *(undefined1 *)(lVar7 + 10) = 1;

+  }

+  puVar5 = (undefined8 *)*param_3;

+joined_r0x000140890bb9:

   do {

-    puVar3 = (undefined8 *)*unaff_R15;

     while( true ) {

-      if (puVar3 == unaff_R15) {

-        if ((unaff_ESI == 1) || (unaff_ESI == 2)) {

-          plVar4 = (longlong *)(unaff_RBP + 0x88);

-        }

-        else if (unaff_ESI == 3) {

-          plVar4 = (longlong *)(unaff_RBP + 0xb0);

+      if (puVar5 == param_3) {

+        if ((param_4 == 1) || (param_4 == 2)) {

+          plVar13 = (longlong *)(param_2 + 0x88);

+        }

+        else if (param_4 == 3) {

+          plVar13 = (longlong *)(param_2 + 0xb0);

         }

         else {

-          plVar4 = (longlong *)(unaff_RBP + 200);

+          plVar13 = (longlong *)(param_2 + 200);

         }

         LOCK();

-        lVar2 = *plVar4;

-        *plVar4 = *plVar4 + -1;

+        lVar7 = *plVar13;

+        *plVar13 = *plVar13 + -1;

         UNLOCK();

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

-          ExfTryToWakePushLock(plVar4);

-        }

-        KeAbPostRelease(plVar4);

-        return;

-      }

-      if ((puVar3[3] == unaff_R12) || ((*(uint *)(puVar3 + 5) & 0x10000) != 0)) break;

-      puVar3 = (undefined8 *)*puVar3;

-    }

-    AlpcpReferenceBlob(puVar3);

-    if ((unaff_ESI == 1) || (unaff_ESI == 2)) {

-      plVar4 = (longlong *)(unaff_RBP + 0x88);

-    }

-    else if (unaff_ESI == 3) {

-      plVar4 = (longlong *)(unaff_RBP + 0xb0);

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

+          ExfTryToWakePushLock(plVar13);

+        }

+        KeAbPostRelease(plVar13);

+        return local_res20;

+      }

+      if ((puVar5[3] == param_1) || ((*(uint *)(puVar5 + 5) & 0x10000) != 0)) break;

+      puVar5 = (undefined8 *)*puVar5;

+    }

+    lVar7 = puVar5[-3];

+    do {

+      if (lVar7 < 1) {

+        if (lVar7 != 0) {

+                    /* WARNING: Subroutine does not return */

+          KeBugCheckEx(0x18,0,puVar5,0x20,lVar7);

+        }

+        break;

+      }

+      LOCK();

+      lVar8 = puVar5[-3];

+      if (lVar7 == lVar8) {

+        puVar5[-3] = lVar7 + 1;

+        lVar8 = lVar7;

+      }

+      UNLOCK();

+      bVar15 = lVar8 != lVar7;

+      lVar7 = lVar8;

+    } while (bVar15);

+    lVar7 = KeAbPreAcquire(puVar5 + -2,0,1);

+    LOCK();

+    puVar1 = puVar5 + -2;

+    uVar12 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      if (lVar7 != 0) {

+        *(undefined1 *)(lVar7 + 10) = 1;

+      }

+      *(byte *)(puVar5 + -4) = *(byte *)(puVar5 + -4) | 1;

+      LOCK();

+      plVar13 = puVar5 + -3;

+      lVar7 = *plVar13;

+      *plVar13 = *plVar13 + 0x10000;

+      UNLOCK();

+      if (lVar7 + 0x10000 < 1) {

+                    /* WARNING: Subroutine does not return */

+        KeBugCheckEx(0x18,0,puVar5,0x27,lVar7 + 0x10000);

+      }

+      if (puVar5[3] == param_1) {

+        bVar15 = false;

+LAB_1:

+        uVar12 = 0;

+        if ((puVar5[8] == 0) && (uVar2 = *(uint *)(puVar5 + 5), -1 < (char)uVar2)) {

+          *(undefined1 *)((longlong)puVar5 + 0xf4) = 0;

+          *(ushort *)((longlong)puVar5 + 0xf4) = *(ushort *)((longlong)puVar5 + 0xf4) | 0xc;

+          *(uint *)(puVar5 + 5) = uVar2 | 0x80;

+          *(undefined4 *)(puVar5 + 0x1e) = 0x280000;

+          if (puVar5[4] == 0) {

+            if ((uVar2 & 0x200) == 0) {

+              plVar13 = puVar5 + 10;

+              puVar5[0xb] = *(undefined8 *)(param_5 + 8);

+              *plVar13 = param_5;

+              **(longlong **)(param_5 + 8) = (longlong)plVar13;

+              *(longlong **)(param_5 + 8) = plVar13;

+            }

+            else {

+LAB_2:

+              *(short *)((longlong)puVar5 + -0x1e) = *(short *)((longlong)puVar5 + -0x1e) + -1;

+            }

+          }

+          else {

+            LOCK();

+            plVar13 = (longlong *)(puVar5[4] + 0x5b8);

+            puVar4 = (undefined8 *)*plVar13;

+            *plVar13 = 0;

+            UNLOCK();

+            if (puVar4 != puVar5) goto LAB_2;

+            KeReleaseSemaphoreEx(puVar5[4] + 0x518,1,1);

+            *(short *)((longlong)puVar5 + -0x1e) = *(short *)((longlong)puVar5 + -0x1e) + -3;

+            puVar5[4] = 0;

+          }

+        }

+        AlpcpReleaseMessageAttributesOnCancel(puVar5);

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

+        *(ushort *)((longlong)puVar5 + 0xf4) = *(ushort *)((longlong)puVar5 + 0xf4) & 0xdfff;

+        *(uint *)(puVar5 + 5) = uVar2 | 0x200;

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

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

+            ObfDereferenceObject();

+          }

+          puVar5[3] = 0;

+        }

+        if (((puVar5[6] != 0) && ((*(uint *)(puVar5 + 5) & 0x400) == 0)) && (puVar5[0xc] == 0)) {

+          lVar7 = 0x318;

+          if (puVar5[0x1c] != 0) {

+            lVar7 = puVar5[0x1d] + 0x318;

+          }

+          uVar9 = PsTransferProcessQuotaToSharedQuota(puVar5[6],lVar7);

+          puVar5[6] = uVar9;

+          ObfDereferenceObjectWithTag();

+          *(uint *)(puVar5 + 5) = *(uint *)(puVar5 + 5) | 0x400;

+        }

+        uVar3 = puVar5[0x1a];

+        if (uVar3 != 0) {

+          bVar16 = ((uint)uVar3 & 7) != 7;

+          uVar14 = uVar12;

+          if (bVar16) {

+            uVar14 = uVar3 & 7;

+          }

+          uVar11 = 2;

+          if (bVar16) {

+            uVar11 = uVar12;

+          }

+          PspChargeProcessWakeCounter

+                    (uVar3 & 0xfffffffffffffff8,uVar11,uVar14,*(undefined4 *)(puVar5 + 0x21),

+                     0xffffffff,1,0);

+          puVar5[0x1a] = 0;

+        }

+        uVar3 = puVar5[0x1b];

+        if (uVar3 != 0) {

+          bVar16 = ((uint)uVar3 & 7) != 7;

+          uVar14 = uVar12;

+          if (bVar16) {

+            uVar14 = uVar3 & 7;

+          }

+          uVar11 = 2;

+          if (bVar16) {

+            uVar11 = uVar12;

+          }

+          PspChargeProcessWakeCounter

+                    (uVar3 & 0xfffffffffffffff8,uVar11,uVar14,*(undefined4 *)(puVar5 + 0x21),

+                     0xffffffff,1,0);

+          puVar5[0x1b] = 0;

+        }

+        if (bVar15) {

+          puVar4 = (undefined8 *)*param_3;

+          AlpcpUnlockMessage(puVar5);

+          puVar5 = puVar4;

+        }

+        else {

+          puVar4 = (undefined8 *)*puVar5;

+          AlpcpUnlockMessage(puVar5);

+          puVar5 = puVar4;

+        }

+      }

+      else {

+        *(short *)((longlong)puVar5 + -0x1e) = *(short *)((longlong)puVar5 + -0x1e) + -1;

+        AlpcpUnlockMessage(puVar5);

+        puVar5 = (undefined8 *)*puVar5;

+      }

+      goto joined_r0x000140890bb9;

+    }

+    if (lVar7 != 0) {

+      KeAbPostReleaseEx(puVar5 + -2);

+    }

+    if ((param_4 == 1) || (param_4 == 2)) {

+      plVar13 = (longlong *)(param_2 + 0x88);

+    }

+    else if (param_4 == 3) {

+      plVar13 = (longlong *)(param_2 + 0xb0);

     }

     else {

-      plVar4 = (longlong *)(unaff_RBP + 200);

-    }

-    LOCK();

-    lVar2 = *plVar4;

-    *plVar4 = *plVar4 + -1;

-    UNLOCK();

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

-      ExfTryToWakePushLock(plVar4);

-    }

-    KeAbPostRelease(plVar4);

-    AlpcpLockForCachedReferenceBlob(puVar3);

-    *(short *)((longlong)puVar3 + -0x1e) = *(short *)((longlong)puVar3 + -0x1e) + -1;

-    if (puVar3[3] == unaff_R12) {

-      AlpcpCancelMessage();

+      plVar13 = (longlong *)(param_2 + 200);

+    }

+    LOCK();

+    lVar7 = *plVar13;

+    *plVar13 = *plVar13 + -1;

+    UNLOCK();

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

+      ExfTryToWakePushLock(plVar13);

+    }

+    KeAbPostRelease(plVar13);

+    local_res20 = 1;

+    lVar7 = KeAbPreAcquire(puVar5 + -2,0,0);

+    LOCK();

+    puVar1 = puVar5 + -2;

+    uVar12 = *puVar1;

+    *puVar1 = *puVar1 | 1;

+    UNLOCK();

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

+      ExfAcquirePushLockExclusiveEx(puVar5 + -2,lVar7,puVar5 + -2);

+    }

+    if (lVar7 != 0) {

+      *(undefined1 *)(lVar7 + 10) = 1;

+    }

+    *(byte *)(puVar5 + -4) = *(byte *)(puVar5 + -4) | 1;

+    LOCK();

+    plVar13 = puVar5 + -3;

+    lVar7 = *plVar13;

+    *plVar13 = *plVar13 + 0x10000;

+    UNLOCK();

+    if (lVar7 + 0x10000 < 1) {

+                    /* WARNING: Subroutine does not return */

+      KeBugCheckEx(0x18,0,puVar5,0x26,lVar7 + 0x10000);

+    }

+    if ((param_4 == 1) || (param_4 == 2)) {

+      lVar7 = KeAbPreAcquire(param_2 + 0x88,0,0);

+      LOCK();

+      puVar1 = (ulonglong *)(param_2 + 0x88);

+      uVar12 = *puVar1;

+      *puVar1 = *puVar1 | 1;

+      UNLOCK();

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

+        lVar8 = param_2 + 0x88;

+        lVar10 = param_2 + 0x88;

+        goto LAB_3;

+      }

+    }

+    else if (param_4 == 3) {

+      lVar7 = KeAbPreAcquire(param_2 + 0xb0,0,0);

+      LOCK();

+      puVar1 = (ulonglong *)(param_2 + 0xb0);

+      uVar12 = *puVar1;

+      *puVar1 = *puVar1 | 1;

+      UNLOCK();

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

+        lVar8 = param_2 + 0xb0;

+        lVar10 = param_2 + 0xb0;

+        goto LAB_3;

+      }

     }

     else {

-      AlpcpUnlockMessage(puVar3);

-    }

-    if ((unaff_ESI == 1) || (unaff_ESI == 2)) {

-      puVar5 = (ulonglong *)(unaff_RBP + 0x88);

-    }

-    else if (unaff_ESI == 3) {

-      puVar5 = (ulonglong *)(unaff_RBP + 0xb0);

+      lVar7 = KeAbPreAcquire(param_2 + 200,0,0);

+      LOCK();

+      puVar1 = (ulonglong *)(param_2 + 200);

+      uVar12 = *puVar1;

+      *puVar1 = *puVar1 | 1;

+      UNLOCK();

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

+        lVar8 = param_2 + 200;

+        lVar10 = param_2 + 200;

+LAB_3:

+        ExfAcquirePushLockExclusiveEx(lVar10,lVar7,lVar8);

+      }

+    }

+    if (lVar7 != 0) {

+      *(undefined1 *)(lVar7 + 10) = 1;

+    }

+    if (puVar5[3] == param_1) {

+      for (puVar4 = (undefined8 *)*param_3; puVar4 != param_3; puVar4 = (undefined8 *)*puVar4) {

+        if (puVar4 == puVar5) {

+          bVar15 = true;

+          goto LAB_1;

+        }

+      }

+    }

+    *(short *)((longlong)puVar5 + -0x1e) = *(short *)((longlong)puVar5 + -0x1e) + -1;

+    iVar6 = Feature_Servicing_Alpc_LockOrdering__private_IsEnabledDeviceUsageNoInline();

+    if (iVar6 == 0) {

+      AlpcpUnlockMessage(puVar5);

     }

     else {

-      puVar5 = (ulonglong *)(unaff_RBP + 200);

-    }

-    lVar2 = KeAbPreAcquire(puVar5,0,0);

-    LOCK();

-    uVar1 = *puVar5;

-    *puVar5 = *puVar5 | 1;

-    UNLOCK();

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

-      ExfAcquirePushLockExclusiveEx(puVar5);

-    }

-    if (lVar2 != 0) {

-      *(undefined1 *)(lVar2 + 10) = 1;

-    }

+      if ((param_4 == 1) || (param_4 == 2)) {

+        LOCK();

+        plVar13 = (longlong *)(param_2 + 0x88);

+        lVar7 = *plVar13;

+        *plVar13 = *plVar13 + -1;

+        UNLOCK();

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

+          ExfTryToWakePushLock(param_2 + 0x88);

+        }

+        KeAbPostRelease(param_2 + 0x88);

+        AlpcpUnlockMessage(puVar5);

+        if ((param_4 != 1) && (param_4 != 2)) {

+          if (param_4 == 3) goto LAB_4;

+          goto LAB_5;

+        }

+        lVar7 = KeAbPreAcquire(param_2 + 0x88,0,0);

+        LOCK();

+        puVar1 = (ulonglong *)(param_2 + 0x88);

+        uVar12 = *puVar1;

+        *puVar1 = *puVar1 | 1;

+        UNLOCK();

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

+          lVar8 = param_2 + 0x88;

+          lVar10 = param_2 + 0x88;

+          goto LAB_6;

+        }

+      }

+      else {

+        if (param_4 == 3) {

+          LOCK();

+          plVar13 = (longlong *)(param_2 + 0xb0);

+          lVar7 = *plVar13;

+          *plVar13 = *plVar13 + -1;

+          UNLOCK();

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

+            ExfTryToWakePushLock(param_2 + 0xb0);

+          }

+          KeAbPostRelease(param_2 + 0xb0);

+          AlpcpUnlockMessage(puVar5);

+LAB_4:

+          lVar7 = KeAbPreAcquire(param_2 + 0xb0,0,0);

+          LOCK();

+          puVar1 = (ulonglong *)(param_2 + 0xb0);

+          uVar12 = *puVar1;

+          *puVar1 = *puVar1 | 1;

+          UNLOCK();

+          if ((uVar12 & 1) == 0) goto LAB_7;

+          lVar8 = param_2 + 0xb0;

+          lVar10 = param_2 + 0xb0;

+        }

+        else {

+          LOCK();

+          plVar13 = (longlong *)(param_2 + 200);

+          lVar7 = *plVar13;

+          *plVar13 = *plVar13 + -1;

+          UNLOCK();

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

+            ExfTryToWakePushLock(param_2 + 200);

+          }

+          KeAbPostRelease(param_2 + 200);

+          AlpcpUnlockMessage(puVar5);

+LAB_5:

+          lVar7 = KeAbPreAcquire(param_2 + 200,0,0);

+          LOCK();

+          puVar1 = (ulonglong *)(param_2 + 200);

+          uVar12 = *puVar1;

+          *puVar1 = *puVar1 | 1;

+          UNLOCK();

+          if ((uVar12 & 1) == 0) goto LAB_7;

+          lVar8 = param_2 + 200;

+          lVar10 = param_2 + 200;

+        }

+LAB_6:

+        ExfAcquirePushLockExclusiveEx(lVar10,lVar7,lVar8);

+      }

+LAB_7:

+      if (lVar7 != 0) {

+        *(undefined1 *)(lVar7 + 10) = 1;

+      }

+    }

+    puVar5 = (undefined8 *)*param_3;

   } while( true );

 }
```

## `PopPowerAggregatorActiveToScreenOffStateHandler`  (modified)

```diff
--- PopPowerAggregatorActiveToScreenOffStateHandler
+++ PopPowerAggregatorActiveToScreenOffStateHandler
@@ -1,58 +1,23 @@
 

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

-

-void PopPowerAggregatorActiveToScreenOffStateHandler(void)

+undefined8 PopPowerAggregatorActiveToScreenOffStateHandler(longlong param_1)

 

 {

-  undefined8 uVar1;

-  char cVar2;

-  undefined8 in_RAX;

-  undefined4 unaff_EBX;

-  longlong unaff_RBP;

-  uint uVar3;

-  undefined4 *puVar4;

-  longlong lVar5;

-  undefined4 uVar6;

+  uint uVar1;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  undefined8 local_18;

+  undefined8 uStack_10;

   

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

-  uVar1 = PopDiagHandle;

-  *(undefined8 *)(unaff_RBP + -0x51) = in_RAX;

-  *(longlong *)(unaff_RBP + -0x41) = unaff_RBP + 0x67;

-  *(longlong *)(unaff_RBP + -0x31) = unaff_RBP + -0x79;

-  lVar5 = unaff_RBP + -0x51;

-  *(undefined4 *)(unaff_RBP + -0x79) = unaff_EBX;

-  *(undefined4 *)(unaff_RBP + -0x49) = 8;

-  *(undefined4 *)(unaff_RBP + -0x39) = 4;

-  *(undefined4 *)(unaff_RBP + -0x29) = 4;

-  EtwWrite(uVar1,0x40022680,0,3,lVar5);

-  uVar6 = (undefined4)((ulonglong)lVar5 >> 0x20);

-  if (DAT_0 != 0) {

-    puVar4 = &DAT_0;

-    uVar3 = DAT_0;

-    cVar2 = _tlgKeywordOn(&DAT_0,0x800000000000);

-    if ((cVar2 != '\0') && (5 < uVar3)) {

-      cVar2 = _tlgKeywordOn(puVar4);

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

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

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

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

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

-        *(undefined8 *)(unaff_RBP + -0x61) = *(undefined8 *)(unaff_RBP + -0x69);

-        *(longlong *)(unaff_RBP + 7) = unaff_RBP + -0x61;

-        *(undefined4 *)(unaff_RBP + -0x75) = *(undefined4 *)(unaff_RBP + 0x67);

-        *(longlong *)(unaff_RBP + 0x17) = unaff_RBP + -0x75;

-        *(longlong *)(unaff_RBP + 0x27) = unaff_RBP + -0x71;

-        *(longlong *)(unaff_RBP + 0x37) = unaff_RBP + -0x59;

-        *(undefined4 *)(unaff_RBP + 0xf) = 8;

-        *(undefined4 *)(unaff_RBP + 0x1f) = 4;

-        *(undefined4 *)(unaff_RBP + -0x71) = unaff_EBX;

-        *(undefined4 *)(unaff_RBP + 0x2f) = 4;

-        *(undefined8 *)(unaff_RBP + -0x59) = 0x1000000;

-        *(undefined4 *)(unaff_RBP + 0x3f) = 8;

-        _tlgWriteTransfer_EtwWriteTransfer(puVar4,&DAT_1,0,0,CONCAT44(uVar6,6));

-      }

-    }

-  }

-  return;

+  uStack_20 = 0;

+  local_28 = 3;

+  local_18 = 0;

+  uStack_10 = 0;

+  PopPowerAggregatorSetCurrentState(0,&local_28);

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

+  uVar1 = PopGetMonitorReasonFromPowerEventId(*(undefined4 *)(param_1 + 0x18));

+  PopReleaseRwLock(&PopPowerAggregatorLock);

+  PopSleepstudyStartNextSession(1,uVar1 & 0xffffff);

+  PopAcquireRwLockExclusive(&PopPowerAggregatorLock);

+  return 0;

 }
```

## `FsRtlpOplockAckTimeoutWorker`  (modified)

```diff
--- FsRtlpOplockAckTimeoutWorker
+++ FsRtlpCancelExclusiveIrp
@@ -1,10 +1,13 @@
 

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

 

-void FsRtlpOplockAckTimeoutWorker(void)

+void FsRtlpCancelExclusiveIrp(void)

 

 {

+  longlong in_RAX;

+  

+  *(undefined1 *)(in_RAX + -0x3f) = *(undefined1 *)(in_RAX + -0x3f);

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

   halt_baddata();

 }
```

## `PpmEventHgsContainmentPolicyChange`  (modified)

```diff
--- PpmEventHgsContainmentPolicyChange
+++ PpmEventHgsContainmentPolicyChange
@@ -1,27 +1,80 @@
 

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

 

-void PpmEventHgsContainmentPolicyChange(undefined4 param_1)

+void PpmEventHgsContainmentPolicyChange(void)

 

 {

-  undefined8 uVar1;

-  undefined4 in_EAX;

-  longlong unaff_RBP;

-  undefined8 uStack0000000000000028;

-  undefined4 uStack0000000000000030;

-  longlong lStack0000000000000038;

+  char cVar1;

+  char cVar2;

+  undefined *puVar3;

+  char in_R9B;

+  char in_stack_00000028;

+  char in_stack_00000030;

+  undefined1 auStack_108 [32];

+  undefined8 local_e8;

+  undefined8 local_e0;

+  undefined4 local_d8;

+  undefined4 **local_d0;

+  uint local_c8 [2];

+  undefined4 local_c0 [2];

+  uint local_b8 [2];

+  undefined4 local_b0 [2];

+  uint local_a8;

+  uint local_a4 [3];

+  uint *local_98;

+  undefined8 local_90;

+  undefined4 *local_88;

+  undefined8 local_80;

+  uint *local_78;

+  undefined8 local_70;

+  undefined4 *local_68;

+  undefined8 local_60;

+  uint *local_58;

+  undefined8 local_50;

+  undefined4 *local_48;

+  undefined8 local_40;

+  uint *local_38;

+  undefined8 local_30;

+  ulonglong local_28;

   

-  *(undefined4 *)(unaff_RBP + 0x27) = in_EAX;

-  *(longlong *)(unaff_RBP + 0x37) = unaff_RBP + 0x77;

-  lStack0000000000000038 = unaff_RBP + 7;

-  uStack0000000000000028 = 0;

-  *(undefined4 *)(unaff_RBP + 0x2f) = param_1;

-  *(undefined4 *)(unaff_RBP + 0x3f) = param_1;

-  uVar1 = PpmEtwHandle;

-  *(undefined4 *)(unaff_RBP + 0xf) = 2;

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

-  uStack0000000000000030 = param_1;

-  EtwWriteEx(uVar1);

+  cVar1 = PpmPerfMaxOverrideEnabled;

+  local_28 = __security_cookie ^ (ulonglong)auStack_108;

+  local_b0[0] = PpmCheckLatencyBoostActive;

+  local_c0[0] = PpmHeteroPolicy;

+  if ((PpmHeteroHgsContainmentState & 4) != 0) {

+    puVar3 = &PPM_ETW_WPS_CONTAINMENT_POLICY_CHANGE_RUNDOWN;

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

+      puVar3 = &PPM_ETW_WPS_CONTAINMENT_POLICY_CHANGE;

+    }

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

+      cVar2 = EtwEventEnabled(PpmEtwHandle,puVar3);

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

+        local_90 = 4;

+        local_80 = 4;

+        local_b8[0] = (uint)(cVar1 != '\0');

+        local_70 = 4;

+        local_60 = 4;

+        local_a8 = (uint)(in_R9B != '\0');

+        local_c8[0] = PpmHeteroHgsContainmentState >> 3 & 1;

+        local_50 = 4;

+        local_40 = 4;

+        local_a4[0] = (uint)(in_stack_00000028 != '\0');

+        local_98 = local_c8;

+        local_30 = 4;

+        local_88 = local_c0;

+        local_78 = local_b8;

+        local_68 = local_b0;

+        local_58 = &local_a8;

+        local_48 = &PpmHeteroContainmentPolicy;

+        local_38 = local_a4;

+        local_d0 = &local_98;

+        local_d8 = 7;

+        local_e0 = 0;

+        local_e8 = 0;

+        EtwWriteEx(PpmEtwHandle,puVar3,0,0);

+      }

+    }

+  }

   return;

 }
```

## `PopFxProcessWorkPool`  (modified)

```diff
--- PopFxProcessWorkPool
+++ PopFxProcessWorkPool
@@ -1,10 +1,94 @@
 

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

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

 

-void PopFxProcessWorkPool(void)

+void PopFxProcessWorkPool(undefined8 *param_1,uint param_2)

 

 {

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

-  halt_baddata();

+  short *psVar1;

+  int iVar2;

+  void *pvVar3;

+  int iVar4;

+  uint uVar5;

+  undefined8 *puVar6;

+  undefined8 *puVar7;

+  uint uVar8;

+  bool bVar9;

+  undefined8 local_res8;

+  undefined8 *local_38;

+  undefined8 *puStack_30;

+  

+  uVar8 = (uint)(param_2 != 0);

+  if (param_2 != 0) {

+    param_1[(ulonglong)param_2 + 0x21] = SystemReserved1[0xf];

+  }

+  local_38 = param_1 + 4;

+  puStack_30 = param_1 + 8;

+  do {

+    puVar7 = &local_res8;

+    local_res8 = 0;

+    iVar4 = KeWaitForMutexObject(param_1 + ((longlong)(int)uVar8 + 1) * 4,0,0,0,puVar7);

+    uVar5 = uVar8;

+    if (iVar4 == 0x102) {

+      puVar6 = (undefined8 *)0x0;

+      if (param_2 != 0) {

+        local_res8 = 0xffffffffffff3cb0;

+        puVar6 = &local_res8;

+      }

+      uVar5 = KeWaitForMultipleObjects

+                        (2,&local_38,1,0,(ulonglong)puVar7 & 0xffffffffffffff00,0,puVar6,0);

+      if (uVar5 == 0x102) {

+        param_1[(ulonglong)param_2 + 0x21] = 0;

+        LOCK();

+        *(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) & ~(1 << ((char)param_2 - 1U & 0x1f));

+        UNLOCK();

+        return;

+      }

+    }

+    if (param_1 == (undefined8 *)&PopFxNoFaultSystemWorkPool) {

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

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

+    }

+    if (uVar5 == 0) {

+      puVar7 = (undefined8 *)ExInterlockedRemoveHeadList(param_1 + 2);

+      *puVar7 = 0;

+      puVar7[1] = 0;

+      (*(code *)puVar7[2])(puVar7[3]);

+    }

+    else if (uVar5 == 1) {

+      PopFxDispatchPluginWorkOnce(*param_1);

+    }

+    pvVar3 = SystemReserved1[0xf];

+    if (param_1 == (undefined8 *)&PopFxNoFaultSystemWorkPool) {

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

+      *psVar1 = *psVar1 + 1;

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

+         (*(longlong **)((longlong)pvVar3 + 0x98) != (longlong *)((longlong)pvVar3 + 0x98))) {

+        KiCheckForKernelApcDelivery();

+      }

+    }

+    if (param_2 == 0) {

+      iVar4 = *(int *)(param_1 + 0xc);

+      do {

+        LOCK();

+        iVar2 = *(int *)(param_1 + 0xc);

+        bVar9 = iVar4 == iVar2;

+        if (bVar9) {

+          *(int *)(param_1 + 0xc) = iVar4;

+          iVar2 = iVar4;

+        }

+        iVar4 = iVar2;

+        UNLOCK();

+      } while (!bVar9);

+      if (iVar4 == 0) {

+        uVar8 = uVar8 + 1 & 0x80000001;

+        if ((int)uVar8 < 0) {

+          uVar8 = (uVar8 - 1 | 0xfffffffe) + 1;

+        }

+      }

+      else {

+        uVar8 = 0;

+      }

+    }

+  } while( true );

 }
```

## `FsRtlpOplockCleanup`  (modified)

```diff
--- FsRtlpOplockCleanup
+++ FsRtlpOplockCleanup
@@ -1,16 +1,341 @@
 

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

 

-undefined8 FsRtlpOplockCleanup(void)

+void FsRtlpOplockCleanup(longlong *param_1,longlong param_2,char param_3)

 

 {

-  longlong unaff_RSI;

-  longlong unaff_RDI;

+  longlong *plVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  undefined8 *puVar4;

+  code *pcVar5;

+  undefined1 uVar6;

+  longlong lVar7;

+  undefined8 uVar8;

+  longlong *plVar9;

+  undefined1 *puVar10;

+  undefined1 *puVar11;

+  char cVar12;

+  ulonglong uVar13;

+  longlong *plVar14;

+  undefined4 uVar15;

+  undefined4 uVar17;

+  char cVar18;

+  ulonglong uVar19;

+  bool bVar20;

+  undefined8 uStack_1c0;

+  undefined1 auStack_1b8 [32];

+  undefined4 local_198;

+  undefined1 *local_190;

+  char local_180 [8];

+  char local_178 [8];

+  longlong local_170;

+  int local_168;

+  undefined4 local_164;

+  longlong local_160;

+  longlong *local_158;

+  longlong local_150;

+  longlong *local_148 [3];

+  longlong *local_130;

+  undefined1 local_c8 [32];

+  longlong *local_a8;

+  undefined8 local_a0;

+  longlong **local_98;

+  undefined8 local_90;

+  undefined4 *local_88;

+  undefined8 local_80;

+  undefined1 local_78 [32];

+  longlong **local_58;

+  undefined8 local_50;

+  int *local_48;

+  undefined8 local_40;

+  ulonglong local_38;

+  longlong lVar16;

   

-  _tlgWriteAgg(&DAT_0);

-  *(undefined4 *)(unaff_RDI + 0x30) = 0xc00000e2;

-  IofCompleteRequest();

-  ExReleaseFastMutexUnsafe(*(undefined8 *)(unaff_RSI + 0x98));

-  return 0xc00000e2;

+  puVar11 = auStack_1b8;

+  puVar10 = auStack_1b8;

+  local_38 = __security_cookie ^ (ulonglong)auStack_1b8;

+  cVar12 = '\0';

+  local_178[1] = 0;

+  if ((int)param_1[0x12] == 1) goto LAB_0;

+  local_178[0] = param_3;

+  local_170 = param_2;

+  local_130 = param_1;

+  if (5 < DAT_1) {

+    local_58 = &local_158;

+    local_50 = 8;

+    local_48 = &local_168;

+    local_40 = 4;

+    local_190 = local_78;

+    local_198 = 4;

+    local_168 = (int)param_1[0x12];

+    local_158 = param_1;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_1,&DAT_1400449f6,0,0);

+  }

+  uVar13 = 1;

+  lVar7 = IoGetOplockFullFoExt(*(undefined8 *)(param_2 + 0x30));

+  local_160 = lVar7;

+  puVar11 = auStack_1b8;

+  cVar12 = '\0';

+  if ((*(uint *)(param_1 + 0x12) & 0x1000000) != 0) {

+    plVar14 = param_1 + 0xd;

+    for (plVar9 = (longlong *)*plVar14; plVar9 != plVar14; plVar9 = (longlong *)*plVar9) {

+      if (*(longlong *)(param_2 + 0x30) == plVar9[2]) {

+        puVar10 = auStack_1b8;

+        if (5 < DAT_1) {

+          local_a8 = &local_150;

+          local_a0 = 8;

+          local_98 = local_148;

+          local_90 = 8;

+          local_164 = (undefined4)param_1[0x12];

+          local_88 = &local_164;

+          local_80 = 4;

+          local_190 = local_c8;

+          local_198 = 5;

+          local_150 = plVar9[2];

+          local_148[0] = param_1;

+          _tlgWriteTransfer_EtwWriteTransfer(&DAT_1,&DAT_140044980,0,0);

+          puVar10 = auStack_1b8;

+        }

+        goto LAB_2;

+      }

+    }

+    goto LAB_3;

+  }

+  goto LAB_4;

+LAB_2:

+  if ((longlong *)param_1[0xb] == param_1 + 0xb) {

+    plVar1 = *(longlong **)plVar9[1];

+    lVar16 = *plVar1;

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

+    if ((*(longlong **)(lVar16 + 8) == plVar1) && ((longlong *)*plVar2 == plVar1))

+    goto code_r0x0001403c77bd;

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

+    (*pcVar5)(3);

+    puVar10 = puVar10 + 8;

+  }

+  *(undefined8 *)(puVar10 + -8) = 0x1403c7897;

+  FsRtlpRemoveAndCompleteWaitingIrp();

+  goto LAB_2;

+code_r0x0001403c77bd:

+  *plVar2 = lVar16;

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

+  *(undefined8 *)(puVar10 + -8) = 0x1403c77cd;

+  FsRtlpOplockPerfSendData(plVar9 + 3);

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

+    *(undefined8 *)(puVar10 + -8) = 0x1403c77e2;

+    FsRtlpSyncWithAckTimeout();

+  }

+  else {

+    plVar9[5] = 0;

+  }

+  lVar16 = plVar9[2];

+  *(undefined8 *)(puVar10 + -8) = 0x1403c77f0;

+  ObfDereferenceObjectWithTag(lVar16,0x746c6644);

+  *(undefined8 *)(puVar10 + -8) = 0x1403c77fa;

+  ExFreePoolWithTag(plVar9,0);

+  uVar13 = 1;

+LAB_3:

+  *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0xfeffffff;

+  cVar12 = '\0';

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

+    cVar12 = (char)uVar13;

+  }

+  puVar10[0x41] = cVar12;

+  puVar11 = puVar10;

+LAB_4:

+  plVar14 = param_1 + 5;

+  plVar9 = (longlong *)*plVar14;

+  uVar17 = 0x216;

+  if (plVar9 != plVar14) {

+    uVar19 = 0;

+    puVar11[0x42] = 0;

+    for (; plVar9 != plVar14; plVar9 = (longlong *)*plVar9) {

+      plVar1 = plVar9 + 2;

+      if (*(longlong *)(*(longlong *)(puVar11 + 0x48) + 0x30) == *(longlong *)(*plVar1 + 0x30)) {

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

+        uVar19 = uVar19 & 0xff;

+        bVar20 = *(int *)(*plVar1 + 0x18) == 0x90240;

+        if (bVar20) {

+          uVar19 = uVar13 & 0xffffffff;

+        }

+        puVar11[0x42] = (char)uVar19;

+        uVar8 = 0x216;

+        if (!bVar20) {

+          uVar8 = 0;

+        }

+        lVar16 = *plVar9;

+        *(undefined8 *)(puVar11 + -8) = 0x1403c787a;

+        FsRtlpRemoveAndCompleteReadOnlyIrp(lVar16,uVar8,0,param_1);

+        if ((char)uVar19 != '\0') break;

+        uVar13 = 1;

+      }

+    }

+    *(undefined8 *)(puVar11 + -8) = 0x1403c78ac;

+    FsRtlpComputeShareableOplockState(param_1);

+    param_2 = *(longlong *)(puVar11 + 0x48);

+  }

+  bVar20 = false;

+  if ((lVar7 == 0) || (lVar7 = *(longlong *)(lVar7 + 0x28), lVar7 == 0)) {

+    cVar18 = puVar11[0x40];

+  }

+  else {

+    if ((*(uint *)(lVar7 + 0x30) & 0xf00000) == 0) {

+      lVar16 = 0;

+      uVar15 = 0;

+      if (((*(uint *)(param_1 + 0x12) & 0x10000) != 0) &&

+         (plVar14 = (longlong *)(lVar7 + 0x38), *plVar14 != 0)) {

+        *(undefined8 *)(puVar11 + -8) = 0x1403c78f6;

+        FsRtlpOplockDequeueRH(lVar7);

+        lVar3 = *plVar14;

+        plVar9 = (longlong *)plVar14[1];

+        if ((*(longlong **)(lVar3 + 8) == plVar14) && ((longlong *)*plVar9 == plVar14)) {

+          *plVar9 = lVar3;

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

+          if ((longlong *)param_1[0xf] == param_1 + 0xf) {

+            *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0xfffcffff;

+          }

+          if (*(longlong *)(lVar7 + 0x28) != lVar16) {

+            *(undefined8 *)(puVar11 + -8) = 0x1403c793a;

+            FsRtlpClearOwner(param_1,lVar7);

+          }

+          *(undefined8 *)(puVar11 + -8) = 0x1403c7944;

+          FsRtlpFreeRHOpContext(lVar7,1);

+          cVar18 = puVar11[0x40];

+          goto LAB_5;

+        }

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

+        (*pcVar5)(3);

+        uVar15 = (undefined4)lVar16;

+        puVar11 = puVar11 + 8;

+      }

+      cVar18 = puVar11[0x40];

+      puVar11[0x38] = cVar18;

+      *(short *)(puVar11 + 0x30) = (short)uVar15;

+      *(undefined4 *)(puVar11 + 0x28) = uVar15;

+      *(undefined4 *)(puVar11 + 0x20) = uVar15;

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7980;

+      FsRtlpRemoveAndCompleteRHIrp(lVar7,param_1,0x216,0);

+    }

+    else {

+      *(undefined8 *)(puVar11 + -8) = 0x1403c798a;

+      FsRtlpOplockDequeueRH(lVar7);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7998;

+      FsRtlpModifyThreadPriorities(param_1,lVar7,0);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c79a3;

+      FsRtlpClearOwner(param_1,lVar7);

+      if ((longlong *)param_1[9] == param_1 + 9) {

+        *(undefined1 *)(param_1 + 4) = 0;

+      }

+      uVar8 = *(undefined8 *)(lVar7 + 0x18);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c79be;

+      ObfDereferenceObjectWithTag(uVar8,0x746c6644);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c79c7;

+      FsRtlpOplockPerfSendData(lVar7 + 0x48);

+      cVar18 = puVar11[0x40];

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

+        *(undefined8 *)(puVar11 + -8) = 0x1403c79e1;

+        FsRtlpSyncWithAckTimeout();

+      }

+      else {

+        *(undefined8 *)(lVar7 + 0x58) = 0;

+      }

+      *(undefined8 *)(puVar11 + -8) = 0x1403c79eb;

+      ExFreePoolWithTag(lVar7,0);

+LAB_5:

+      bVar20 = true;

+    }

+    *(undefined8 *)(puVar11 + -8) = 0x1403c79f6;

+    FsRtlpComputeShareableOplockState(param_1);

+    if (bVar20) {

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7a03;

+      FsRtlpReleaseIrpsWaitingForRH(param_1);

+    }

+  }

+  if (*(longlong *)(param_2 + 0x30) == param_1[1]) {

+    if ((*(uint *)(param_1 + 0x12) & 0x1f00f80) == 0) {

+      lVar7 = *param_1;

+      lVar16 = *(longlong *)(lVar7 + 0xb8);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7a40;

+      uVar6 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(lVar7 + 0x45) = uVar6;

+      LOCK();

+      *(undefined8 *)(lVar7 + 0x68) = 0;

+      UNLOCK();

+      uVar6 = *(undefined1 *)(lVar7 + 0x45);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7a54;

+      KeReleaseQueuedSpinLock(7,uVar6);

+      if (*(int *)(lVar16 + 0x18) == 0x90240) {

+        puVar4 = *(undefined8 **)(lVar7 + 0x18);

+        *puVar4 = 0;

+        puVar4[1] = 0;

+        puVar4[2] = 0;

+        *(undefined4 *)puVar4 = 0x180001;

+        *(uint *)((longlong)puVar4 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+        *(undefined8 *)(lVar7 + 0x38) = 0x18;

+      }

+      else {

+        *(undefined8 *)(lVar7 + 0x38) = 8;

+        uVar17 = 0;

+      }

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

+      lVar7 = *param_1;

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7aab;

+      IofCompleteRequest(lVar7,1);

+    }

+    if (-1 < (char)(int)param_1[0x12]) {

+      lVar7 = param_1[1];

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7aca;

+      ObfDereferenceObjectWithTag(lVar7,0x746c6644);

+    }

+    param_1[1] = 0;

+    *param_1 = 0;

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

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7ae6;

+      FsRtlpModifyThreadPriorities(param_1,0,0);

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7af0;

+      FsRtlpClearOwner(param_1,0);

+      *(undefined1 *)(param_1 + 4) = 0;

+    }

+    *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+    while ((longlong *)param_1[0xb] != param_1 + 0xb) {

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7b3f;

+      FsRtlpRemoveAndCompleteWaitingIrp();

+    }

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

+      *(undefined8 *)(puVar11 + -8) = 0x1403c7b27;

+      FsRtlpSyncWithAckTimeout();

+    }

+    else {

+      param_1[0x16] = 0;

+    }

+    *(undefined8 *)(puVar11 + -8) = 0x1403c7b33;

+    FsRtlpOplockPerfSendData(param_1 + 0x14);

+    cVar12 = puVar11[0x41];

+  }

+  if (5 < DAT_1) {

+    *(longlong **)(puVar11 + 0x78) = param_1;

+    *(undefined1 **)(puVar11 + 0xb0) = puVar11 + 0x78;

+    *(undefined8 *)(puVar11 + 0xb8) = 8;

+    *(int *)(puVar11 + 0x48) = (int)param_1[0x12];

+    *(undefined1 **)(puVar11 + 0xc0) = puVar11 + 0x48;

+    *(undefined8 *)(puVar11 + 200) = 4;

+    *(longlong *)(puVar11 + 0x80) = param_1[0xb];

+    *(undefined1 **)(puVar11 + 0xd0) = puVar11 + 0x80;

+    *(undefined8 *)(puVar11 + 0xd8) = 8;

+    *(longlong *)(puVar11 + 0x58) = param_1[0xc];

+    *(undefined1 **)(puVar11 + 0xe0) = puVar11 + 0x58;

+    *(undefined8 *)(puVar11 + 0xe8) = 8;

+    *(undefined1 **)(puVar11 + 0x28) = puVar11 + 0x90;

+    *(undefined4 *)(puVar11 + 0x20) = 6;

+    *(undefined8 *)(puVar11 + -8) = 0x1403c7c07;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_1,&DAT_140044df1,0,0);

+  }

+LAB_0:

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

+    *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) | 0x1000000;

+  }

+  *(undefined8 *)(puVar11 + -8) = 0x1403c7c25;

+  return;

 }
```

## `PopFxActivateComponentWorker`  (modified)

```diff
--- PopFxActivateComponentWorker
+++ PopFxActivateComponentWorker
@@ -1,80 +1,25 @@
 

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

-

-void PopFxActivateComponentWorker(undefined8 param_1,uint param_2,uint param_3,undefined8 param_4)

+void PopFxActivateComponentWorker

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

 

 {

-  byte bVar1;

-  undefined4 uVar2;

-  uint uVar3;

-  ulonglong unaff_RBX;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong in_R11;

-  byte unaff_R13B;

-  bool in_CF;

-  undefined4 uStack0000000000000028;

-  uint uStack0000000000000030;

-  undefined4 uStack0000000000000038;

-  undefined8 uStack0000000000000040;

-  undefined8 uStack0000000000000048;

-  undefined8 uStack0000000000000050;

-  longlong in_stack_00000068;

-  longlong in_stack_00000070;

-  undefined8 in_stack_00000078;

-  byte in_stack_000000d0;

-  undefined4 in_stack_000000e8;

+  char cVar1;

   

-  if (!in_CF) {

-    *(undefined4 *)(unaff_RSI + 0x4a4) = 0;

-    in_stack_000000e8 = 3;

-    if (in_stack_000000d0 == 0) {

-      unaff_RBX = (ulonglong)param_3 / (ulonglong)unaff_R13B;

-    }

-    else {

-      if (in_stack_000000d0 == param_2) {

-        if (PpmPerfSingleStepSize < (uint)unaff_RBX) {

-          unaff_RBX = (ulonglong)((uint)unaff_RBX - PpmPerfSingleStepSize);

-          goto LAB_0;

-        }

-      }

-      else if (in_stack_000000d0 - param_2 != param_2) goto LAB_0;

-      unaff_RBX = (ulonglong)param_2;

-    }

-  }

-LAB_0:

-  if (in_R11 != 0) {

-    bVar1 = *(byte *)(in_R11 + 0xee);

-    if (bVar1 != 0) {

-      *(undefined1 *)(in_R11 + 0xee) = 0;

-      uVar3 = (uint)unaff_RBX;

-      unaff_RBX = unaff_RBX & 0xffffffff;

-      if (uVar3 <= bVar1) {

-        unaff_RBX = (ulonglong)(uint)bVar1;

-      }

-    }

-    bVar1 = *(byte *)(in_R11 + 0xef);

-    if (bVar1 != 0) {

-      *(undefined1 *)(in_R11 + 0xef) = 0;

-      uVar3 = (uint)unaff_RBX;

-      unaff_RBX = unaff_RBX & 0xffffffff;

-      if (uVar3 <= bVar1) {

-        unaff_RBX = (ulonglong)(uint)bVar1;

+  PopFxDeviceCriticalRegionEnter();

+  PopFxReferenceDevice();

+  cVar1 = PopFxActivateComponentDependencies(param_2,param_3);

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

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

+      cVar1 = PopPluginComponentActive(param_1,*(undefined4 *)(param_2 + 0x10),1,param_4);

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

+        PopFxProcessWork(0,param_4);

       }

     }

   }

-  uStack0000000000000050 = 0;

-  uStack0000000000000048 = 0;

-  uStack0000000000000040 = 0;

-  uStack0000000000000038 = in_stack_000000e8;

-  uStack0000000000000030 = (uint)*(byte *)(in_stack_00000070 + 0xaf + unaff_RBP);

-  uStack0000000000000028 = *(undefined4 *)(unaff_RBP + 0x58);

-  uVar2 = (**(code **)(in_stack_00000068 + 0x178))

-                    (in_stack_00000078,unaff_RBX & 0xffffffff,

-                     *(undefined4 *)(in_stack_00000068 + 0x1cc),param_4,

-                     *(undefined4 *)(unaff_RBP + 0x50 + in_stack_00000070 * 4));

-  *(undefined4 *)(unaff_RSI + 0x38) = uVar2;

-  PpmEventPerfSelectProcessorState();

+  else {

+    PopFxCompleteComponentActivation(param_1,param_2,0);

+  }

+  PopFxDeviceCriticalRegionLeave(param_1);

   return;

 }
```

## `SepDuplicateToken`  (modified)

```diff
--- SepDuplicateToken
+++ SepDuplicateToken
@@ -1,313 +1,466 @@
 

-/* WARNING: Instruction at (ram,0x000140850ad1) overlaps instruction at (ram,0x000140850ad0)

-    */

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

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

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

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

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

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

-

-ulonglong SepDuplicateToken(longlong param_1)

+int SepDuplicateToken(undefined4 *param_1,undefined8 param_2,char param_3,int param_4,uint param_5,

+                     undefined1 param_6,undefined1 param_7,undefined8 *param_8)

 

 {

-  ulonglong *puVar1;

-  undefined8 uVar2;

+  undefined4 *puVar1;

+  undefined4 uVar2;

   code *pcVar3;

-  char cVar4;

-  uint uVar5;

-  ulonglong uVar6;

-  ulonglong uVar7;

-  longlong lVar8;

-  longlong in_RAX;

-  ulonglong uVar9;

-  int *piVar10;

-  undefined8 *puVar11;

-  undefined **ppuVar12;

-  ulonglong unaff_RBX;

-  uint uVar13;

-  ulonglong unaff_RSI;

-  uint uVar14;

-  void *unaff_RDI;

-  int *piVar15;

-  ulonglong uVar16;

-  char cVar17;

-  uint uVar18;

-  ulonglong unaff_R12;

-  ulonglong *unaff_R13;

-  longlong unaff_R14;

-  longlong unaff_R15;

-  bool bVar19;

-  undefined4 uVar20;

-  char cStack0000000000000040;

-  uint uStack0000000000000048;

-  uint uStack000000000000004c;

-  void *in_stack_00000068;

-  longlong in_stack_00000078;

-  ulonglong in_stack_00000080;

-  undefined8 in_stack_000000b8;

-  ulonglong in_stack_000000d0;

-  ulonglong in_stack_000000d8;

-  ulonglong in_stack_000000e0;

-  undefined8 in_stack_000000e8;

-  undefined8 in_stack_000000f0;

-  undefined8 *in_stack_000000f8;

-  uint uStack0000000000000118;

-  uint uStack000000000000011c;

-  undefined8 in_stack_00000120;

-  uint in_stack_00000128;

-  uint uStack0000000000000140;

-  uint uStack0000000000000144;

-  undefined4 in_stack_000003b8;

-  char in_stack_000003d8;

+  undefined4 uVar4;

+  undefined4 uVar5;

+  int iVar6;

+  uint uVar7;

+  int iVar8;

+  uint uVar9;

+  undefined4 *puVar10;

+  undefined4 *puVar11;

+  longlong lVar12;

+  longlong lVar13;

+  undefined8 uVar14;

+  longlong *plVar15;

+  void *_Dst;

+  undefined4 *puVar16;

+  ulonglong uVar17;

+  ulonglong uVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  uint uVar21;

+  uint uVar22;

+  byte in_CR8;

+  undefined8 uStack_a0;

+  undefined1 auStack_98 [8];

+  undefined1 auStack_90 [32];

+  uint local_70;

+  undefined4 local_68;

+  uint local_60;

+  undefined4 **local_58;

+  undefined8 local_50;

+  undefined4 *local_48;

+  undefined8 local_40;

+  uint *local_38;

+  int *local_30;

   

-  uVar9 = _uStack0000000000000048;

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

-  do {

-  } while (param_1 == 0);

-  do {

-    ObfReferenceObjectWithTag(unaff_RBX,0x75536553);

-    in_stack_000000d8 =

-         CONCAT44(in_stack_000000d8._4_4_,*(undefined4 *)((longlong)unaff_RDI + 0x538)) &

-         0xffffffff00000003;

-    do {

-      LOCK();

-      uVar6 = *unaff_R13;

-      if (uVar6 == 0x11) {

-        *unaff_R13 = unaff_RSI;

+  puVar19 = auStack_98;

+  puVar20 = auStack_98;

+  local_48 = (undefined4 *)0x0;

+  if ((param_4 == 2) && (3 < param_5)) {

+    return -0x3fffff5b;

+  }

+  puVar10 = (undefined4 *)ExAllocatePool2(0x100,0x30,0x74416553);

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

+    *puVar10 = 0;

+    puVar11 = puVar10 + 2;

+    puVar10[6] = 0;

+    *(undefined4 **)(puVar10 + 4) = puVar11;

+    *(undefined4 **)puVar11 = puVar11;

+    puVar11 = puVar10 + 8;

+    *(undefined4 **)(puVar10 + 10) = puVar11;

+    *(undefined4 **)puVar11 = puVar11;

+    puVar11 = (undefined4 *)0x0;

+    if ((SeTokenLeakTracking == 0) ||

+       (puVar11 = (undefined4 *)ExAllocatePool2(0x100,0x120,0x74416553), puVar16 = puVar10,

+       puVar11 != (undefined4 *)0x0)) {

+      puVar16 = puVar11;

+      lVar12 = ExAllocatePool2(0x40,0x68,0x6c546553);

+      if (lVar12 != 0) {

+        local_70 = param_1[0x21] + 0x498;

+        if (local_70 < 0x498) {

+          ExFreePoolWithTag(puVar10,0);

+          ExFreePoolWithTag(lVar12,0);

+          if (SeTokenLeakTracking != 0) {

+            ExFreePoolWithTag(puVar16,0);

+          }

+          return -0x3fffff6b;

+        }

+        local_68 = param_1[0x22];

+        local_58 = &local_48;

+        local_50 = 0;

+        local_60 = local_70;

+        iVar6 = ObCreateObjectEx(param_6,SeTokenObjectType,param_2,param_6);

+        puVar11 = local_48;

+        if (iVar6 < 0) {

+          ExFreePoolWithTag(puVar10,0);

+          ExFreePoolWithTag(lVar12,0);

+          if (SeTokenLeakTracking != 0) {

+            ExFreePoolWithTag(puVar16,0);

+            return iVar6;

+          }

+          return iVar6;

+        }

+        LOCK();

+        UNLOCK();

+        lVar13 = ExpLuid + 1;

+        ExpLuid = ExpLuid + 1;

+        *(longlong *)(local_48 + 4) = lVar13;

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

+        local_48[0x30] = param_4;

+        local_48[0x31] = param_5;

+        *(longlong *)(local_48 + 0xc) = lVar12;

+        ExInitializeResourceLite();

+        *(undefined8 *)(puVar11 + 6) = *(undefined8 *)(param_1 + 6);

+        uVar2 = param_1[1];

+        uVar4 = param_1[2];

+        uVar5 = param_1[3];

+        uVar17 = 1;

+        *puVar11 = *param_1;

+        puVar11[1] = uVar2;

+        puVar11[2] = uVar4;

+        puVar11[3] = uVar5;

+        puVar11[0x23] = 0;

+        *(undefined8 *)(puVar11 + 8) = *(undefined8 *)(param_1 + 8);

+        *(undefined8 *)(puVar11 + 10) = *(undefined8 *)(param_1 + 10);

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

+        *(undefined8 *)(puVar11 + 0x118) = 0;

+        *(undefined8 *)(puVar11 + 0x11a) = 0;

+        *(undefined8 *)(puVar11 + 0x112) = 0;

+        *(undefined4 **)(puVar11 + 0x11e) = puVar16;

+        puVar11[0x1e] = 0;

+        *(undefined8 *)(puVar11 + 0x122) = 0;

+        if ((SeTokenLeakTracking != 0) &&

+           (uVar7 = RtlWalkFrameChain(puVar16 + 10,0x1e,0), in_CR8 < 2)) {

+          RtlWalkFrameChain(*(longlong *)(puVar11 + 0x11e) + 0x28 + (ulonglong)uVar7 * 8,

+                            0x1e - uVar7,1);

+        }

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

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

+        ExAcquireResourceSharedLite(*(undefined8 *)(param_1 + 0xc));

+        puVar16 = local_48;

+        *(undefined8 *)(local_48 + 0xe) = *(undefined8 *)(param_1 + 0xe);

+        local_30 = local_48 + 0x20;

+        local_48[0x22] = param_1[0x22];

+        local_48[0x24] = param_1[0x24];

+        *local_30 = param_1[0x20];

+        local_48[0x21] = param_1[0x21];

+        iVar6 = Feature_2045735225__private_IsEnabledDeviceUsageNoInline();

+        uVar7 = param_1[0x32];

+        if (iVar6 == 0) {

+          uVar7 = uVar7 & 0xfffffbdf;

+        }

+        else {

+          uVar7 = uVar7 & 0xeffffbdf;

+        }

+        puVar16[0x32] = uVar7;

+        local_38 = puVar16 + 0x32;

+        if ((*local_38 & 0x1000000) != 0) {

+          LOCK();

+          SepLearningModeTokenCount = SepLearningModeTokenCount + 1;

+          UNLOCK();

+          puVar16 = local_48;

+        }

+        iVar6 = param_1[0x1e];

+        if ((puVar11[0x1e] != iVar6) &&

+           (puVar11[0x1e] = iVar6, SeTokenDoesNotTrackSessionObject == 0)) {

+          if (*(longlong *)(puVar11 + 0x122) != 0) {

+            ObfDereferenceObject();

+          }

+          uVar14 = PsGetSessionObjectById(iVar6);

+          *(undefined8 *)(puVar11 + 0x122) = uVar14;

+        }

+        puVar11[0x1e] = param_1[0x1e];

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

+        *(undefined8 *)(puVar16 + 0x16) = *(undefined8 *)(param_1 + 0x16);

+        *(undefined8 *)(puVar16 + 0x18) = uVar14;

+        uVar14 = *(undefined8 *)(param_1 + 0x1c);

+        *(undefined8 *)(puVar16 + 0x1a) = *(undefined8 *)(param_1 + 0x1a);

+        *(undefined8 *)(puVar16 + 0x1c) = uVar14;

+        puVar16[0x34] = param_1[0x34];

+        puVar16[0x35] = param_1[0x35];

+        uVar2 = param_1[0x11];

+        uVar4 = param_1[0x12];

+        uVar5 = param_1[0x13];

+        puVar16[0x10] = param_1[0x10];

+        puVar16[0x11] = uVar2;

+        puVar16[0x12] = uVar4;

+        puVar16[0x13] = uVar5;

+        *(undefined8 *)(puVar16 + 0x14) = *(undefined8 *)(param_1 + 0x14);

+        iVar6 = Feature_ShadowAdminAppCompat__private_IsEnabledDeviceUsageNoInline();

+        if (iVar6 != 0) {

+          *(undefined8 *)(puVar16 + 0x124) = *(undefined8 *)(param_1 + 0x124);

+        }

+        *(undefined4 **)(puVar16 + 0xc2) = puVar10;

+        *(undefined8 *)(puVar16 + 0x10e) = 0;

+        *(undefined8 *)(puVar16 + 0x110) = 0;

+        *(undefined8 *)(puVar16 + 0x120) = 0;

+        *(undefined8 *)(puVar16 + 0xc6) = 0;

+        *(undefined8 *)(puVar16 + 0xc4) = 0;

+        puVar16[200] = 0;

+        memset(puVar16 + 0xca,0,0x110);

+        *(undefined8 *)(puVar16 + 0x2c) = 0;

+        *(undefined8 *)(puVar16 + 0x114) = 0;

+        *(undefined8 *)(puVar16 + 0x116) = 0;

+        *(undefined8 *)(puVar16 + 0x11c) = 0;

+        if (*(char *)((longlong)puVar16 + 0x77) == '\x02') {

+          SepModifyTokenPolicyCounter(puVar16 + 0x16,1);

+        }

+        iVar6 = SepDuplicateLogonSessionReference(puVar16,param_1);

+        if (-1 < iVar6) {

+          iVar8 = Feature_2045735225__private_IsEnabledDeviceUsageNoInline();

+          if ((iVar8 != 0) && ((param_1[0x32] & 0x10000000) != 0)) {

+            local_40 = 0;

+            lVar12 = *(longlong *)(puVar16 + 0x36);

+            uVar14 = PsGetCurrentServerSilo();

+            iVar6 = SepReferenceLogonSessionSilo(lVar12 + 0x10,uVar14,&local_40);

+            if (iVar6 < 0) goto LAB_0;

+            *local_38 = *local_38 | 0x10000000;

+          }

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

+            SepReferenceLuidToIndexEntry();

+          }

+          *(undefined8 *)(puVar16 + 0x11c) = *(undefined8 *)(param_1 + 0x11c);

+          if ((**(int **)(param_1 + 0xc2) == 0) ||

+             (iVar6 = AuthzBasepDuplicateSecurityAttributes

+                                (*(int **)(param_1 + 0xc2),*(undefined8 *)(puVar16 + 0xc2),param_7),

+             -1 < iVar6)) {

+            RtlCopyMemory(puVar16 + 0x126,param_1 + 0x126,(ulonglong)(uint)param_1[0x21]);

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

+              puVar16[0x1f] = param_1[0x1f];

+              plVar15 = (longlong *)

+                        ((longlong)puVar16 + (*(longlong *)(param_1 + 0x26) - (longlong)param_1));

+              *(longlong **)(puVar16 + 0x26) = plVar15;

+              for (iVar8 = puVar16[0x1f]; iVar8 != 0; iVar8 = iVar8 + -1) {

+                *plVar15 = (longlong)puVar16 + (*plVar15 - (longlong)param_1);

+                plVar15 = plVar15 + 2;

+              }

+            }

+            else {

+              *(longlong *)(puVar16 + 0x26) =

+                   (longlong)puVar16 + (*(longlong *)(param_1 + 0x26) - (longlong)param_1);

+              iVar6 = SepDuplicateTokenUserAndGroups(param_1,puVar16);

+              if (iVar6 < 0) {

+                *(undefined8 *)(puVar16 + 0x26) = 0;

+                goto LAB_0;

+              }

+            }

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

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

+            if (lVar12 != 0) {

+              plVar15 = (longlong *)((longlong)puVar16 + (lVar12 - (longlong)param_1));

+              *(longlong **)(puVar16 + 0x28) = plVar15;

+              for (iVar8 = *local_30; iVar8 != 0; iVar8 = iVar8 + -1) {

+                *plVar15 = (longlong)puVar16 + (*plVar15 - (longlong)param_1);

+                plVar15 = plVar15 + 2;

+              }

+            }

+            uVar7 = (uint)*(byte *)(*(longlong *)(param_1 + 0x2a) + 1) * 4 + 8;

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

+              uVar7 = uVar7 + *(ushort *)(*(longlong *)(param_1 + 0x2e) + 2);

+            }

+            _Dst = (void *)ExAllocatePool2(0x100,(ulonglong)uVar7,0x64546553);

+            *(void **)(puVar16 + 0x2c) = _Dst;

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

+              ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+              KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

+              ObfDereferenceObject(local_48);

+              return -0x3fffff66;

+            }

+            RtlCopyMemory(_Dst,*(void **)(param_1 + 0x2c),(ulonglong)uVar7);

+            lVar12 = *(longlong *)(param_1 + 0x2e);

+            lVar13 = *(longlong *)(param_1 + 0x2c);

+            *(longlong *)(puVar16 + 0x2e) = lVar12;

+            if (lVar12 != 0) {

+              *(longlong *)(puVar16 + 0x2e) = (longlong)_Dst + (lVar12 - lVar13);

+            }

+            *(longlong *)(puVar16 + 0x2a) =

+                 (longlong)_Dst + (*(longlong *)(param_1 + 0x2a) - lVar13);

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

+              iVar6 = SepSetTokenCapabilities

+                                (puVar16,*(undefined8 *)(param_1 + 0xc4),

+                                 *(undefined8 *)(param_1 + 0xc6));

+            }

+            if (-1 < iVar6) {

+              if ((*(longlong *)(param_1 + 0xc4) != 0) &&

+                 (iVar6 = SepSetTokenPackage(puVar16), iVar6 < 0)) {

+LAB_1:

+                uVar14 = *(undefined8 *)(param_1 + 0xc);

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

+                ExReleaseResourceLite(uVar14);

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

+                KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

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

+                ObfDereferenceObject(local_48);

+                return iVar6;

+              }

+              puVar20 = auStack_98;

+              puVar10 = puVar16;

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

+                LOCK();

+                plVar15 = (longlong *)(*(longlong *)(param_1 + 0x10e) + 0x18);

+                lVar12 = *plVar15;

+                *plVar15 = *plVar15 + 1;

+                UNLOCK();

+                if (lVar12 + 1 < 2) {

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

+                  (*pcVar3)(0xe);

+                  puVar19 = auStack_90;

+                }

+                *(undefined8 *)(local_48 + 0x10e) = *(undefined8 *)(param_1 + 0x10e);

+                puVar20 = puVar19;

+                puVar10 = local_48;

+              }

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

+                LOCK();

+                plVar15 = (longlong *)(*(longlong *)(param_1 + 0x110) + 0x18);

+                lVar12 = *plVar15;

+                *plVar15 = *plVar15 + 1;

+                UNLOCK();

+                if (lVar12 + 1 < 2) {

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

+                  (*pcVar3)(0xe);

+                  puVar20 = puVar20 + 8;

+                }

+                *(undefined8 *)(local_48 + 0x110) = *(undefined8 *)(param_1 + 0x110);

+                puVar10 = local_48;

+              }

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

+                LOCK();

+                plVar15 = (longlong *)(*(longlong *)(param_1 + 0x120) + 0x18);

+                lVar12 = *plVar15;

+                *plVar15 = *plVar15 + 1;

+                UNLOCK();

+                if (lVar12 + 1 < 2) {

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

+                  (*pcVar3)(0xe);

+                  puVar20 = puVar20 + 8;

+                }

+                *(undefined8 *)(local_48 + 0x120) = *(undefined8 *)(param_1 + 0x120);

+                puVar10 = local_48;

+              }

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

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

+                iVar6 = SepDuplicateTokenClaims(param_1,puVar10);

+                if (iVar6 < 0) goto LAB_1;

+              }

+              uVar14 = *(undefined8 *)(param_1 + 0x114);

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

+              iVar6 = SepSetTokenTrust(puVar10,uVar14);

+              uVar14 = *(undefined8 *)(param_1 + 0xc);

+              if (iVar6 < 0) {

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

+                ExReleaseResourceLite(uVar14);

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

+                KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

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

+                ObfDereferenceObject(local_48);

+                return iVar6;

+              }

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

+              ExReleaseResourceLite(uVar14);

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

+              KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

+              puVar10 = local_48;

+              if (SeTokenLeakTracking != 0) {

+                **(undefined8 **)(local_48 + 0x11e) =

+                     *(undefined8 *)((longlong)SystemReserved1[0xf] + 0x508);

+                *(undefined8 *)(*(longlong *)(local_48 + 0x11e) + 8) =

+                     *(undefined8 *)((longlong)SystemReserved1[0xf] + 0x510);

+                *(undefined4 *)(*(longlong *)(local_48 + 0x11e) + 0x20) = 0xd;

+                *(undefined4 *)(*(longlong *)(local_48 + 0x11e) + 0x118) = 0;

+                *(undefined4 *)(*(longlong *)(local_48 + 0x11e) + 0x11c) = 0;

+                lVar12 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+                lVar13 = *(longlong *)(local_48 + 0x11e);

+                *(undefined8 *)(lVar13 + 0x10) = *(undefined8 *)(lVar12 + 0x338);

+                *(undefined4 *)(lVar13 + 0x18) = *(undefined4 *)(lVar12 + 0x340);

+                *(undefined2 *)(lVar13 + 0x1c) = *(undefined2 *)(lVar12 + 0x344);

+                *(undefined1 *)(lVar13 + 0x1e) = *(undefined1 *)(lVar12 + 0x346);

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

+                SepAddTokenLogonSession(local_48);

+              }

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

+                *(ulonglong *)(puVar10 + 0x10) =

+                     *(ulonglong *)(puVar10 + 0x10) & *(ulonglong *)(puVar10 + 0x12);

+                *(ulonglong *)(puVar10 + 0x14) =

+                     *(ulonglong *)(puVar10 + 0x14) & *(ulonglong *)(puVar10 + 0x12);

+                uVar7 = puVar10[0x1f];

+                uVar18 = (ulonglong)uVar7;

+                if (1 < uVar7) {

+                  do {

+                    lVar12 = *(longlong *)(puVar10 + 0x26);

+                    uVar7 = (uint)uVar17;

+                    if ((*(uint *)(lVar12 + 8 + uVar17 * 0x10) & 0x34) == 0) {

+                      uVar22 = puVar10[0x24];

+                      if (uVar7 == uVar22) {

+                        puVar10[0x24] = 0;

+                        uVar22 = 0;

+                      }

+                      uVar21 = puVar10[0x34];

+                      if (uVar7 == uVar21) {

+                        puVar10[0x34] = 0xffffffff;

+                        uVar21 = 0xffffffff;

+                      }

+                      uVar9 = (int)uVar18 - 1;

+                      uVar18 = (ulonglong)uVar9;

+                      if (uVar9 == uVar21) {

+                        puVar10[0x34] = uVar7;

+                      }

+                      if (uVar9 == uVar22) {

+                        puVar10[0x24] = uVar7;

+                      }

+                      puVar11 = (undefined4 *)(lVar12 + uVar18 * 0x10);

+                      uVar2 = puVar11[1];

+                      uVar4 = puVar11[2];

+                      uVar5 = puVar11[3];

+                      puVar1 = (undefined4 *)(lVar12 + uVar17 * 0x10);

+                      *puVar1 = *puVar11;

+                      puVar1[1] = uVar2;

+                      puVar1[2] = uVar4;

+                      puVar1[3] = uVar5;

+                    }

+                    else {

+                      uVar17 = (ulonglong)(uVar7 + 1);

+                    }

+                    uVar7 = (uint)uVar18;

+                  } while ((uint)uVar17 < uVar7);

+                }

+                puVar10[0x1f] = uVar7;

+              }

+              uVar2 = puVar10[0x1f];

+              uVar14 = *(undefined8 *)(puVar10 + 0x26);

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

+              RtlSidHashInitialize(uVar14,uVar2,puVar10 + 0x3a);

+              uVar2 = puVar10[0x20];

+              uVar14 = *(undefined8 *)(puVar10 + 0x28);

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

+              RtlSidHashInitialize(uVar14,uVar2,puVar10 + 0x7e);

+              lVar12 = *(longlong *)(puVar10 + 0xc6);

+              if (lVar12 != 0) {

+                uVar2 = puVar10[200];

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

+                RtlSidHashInitialize(lVar12,uVar2,puVar16 + 0xca);

+              }

+              if (((SeTokenLeakTracking != 0) && (SepTokenLeakMethodWatch == 0xd)) &&

+                 (puVar10 = local_48,

+                 *(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x1d0) ==

+                 SepTokenLeakProcessCid)) {

+                LOCK();

+                UNLOCK();

+                iVar8 = SepTokenLeakMethodCount + 1;

+                SepTokenLeakMethodCount = SepTokenLeakMethodCount + 1;

+                *(int *)(*(longlong *)(local_48 + 0x11e) + 0x118) = iVar8;

+                iVar8 = *(int *)(*(longlong *)(local_48 + 0x11e) + 0x118);

+                if (SepTokenLeakBreakCount <= iVar8) {

+                    /* WARNING: Subroutine does not return */

+                  *(undefined **)(puVar20 + -8) = &UNK_2;

+                  DbgPrint("\nToken number 0x%x = 0x%p\n",iVar8,local_48);

+                }

+              }

+              *param_8 = puVar10;

+              return iVar6;

+            }

+          }

+        }

+LAB_0:

+        ExReleaseResourceLite(*(undefined8 *)(param_1 + 0xc));

+        KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

+        ObfDereferenceObject(local_48);

+        return iVar6;

       }

-      UNLOCK();

-      if (uVar6 != 0x11) {

-        ExfReleasePushLockShared(unaff_R13);

-        uVar9 = FUN_140b068b6();

-        return uVar9;

+      ExFreePoolWithTag(puVar10,0);

+      if (SeTokenLeakTracking == 0) {

+        return -0x3fffff66;

       }

-      KeAbPostRelease(unaff_R13);

-      KeLeaveCriticalRegionThread(in_stack_00000068);

-      do {

-        in_stack_000000d0 = unaff_RBX;

-        in_stack_000000e0 = PsReferencePrimaryTokenWithTag(unaff_R14,0x75536553);

-        if (SeTokenLeakTracking != 0) {

-          if (in_stack_000000e0 != 0) {

-            LOCK();

-            piVar15 = (int *)(*(longlong *)(in_stack_000000e0 + 0x478) + 0x11c);

-            *piVar15 = *piVar15 + 1;

-            UNLOCK();

-            unaff_RBX = in_stack_000000d0;

-            if (in_stack_000000e0 == SepTokenLeakToken) {

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

-              uVar9 = (*pcVar3)();

-              return uVar9;

-            }

-          }

-          if (unaff_RBX != 0) {

-            LOCK();

-            piVar15 = (int *)(*(longlong *)(unaff_RBX + 0x478) + 0x11c);

-            *piVar15 = *piVar15 + 1;

-            UNLOCK();

-            if (in_stack_000000d0 == SepTokenLeakToken) {

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

-              uVar9 = (*pcVar3)();

-              return uVar9;

-            }

-          }

-        }

-        uVar5 = SepCreateAccessStateFromSubjectContext

-                          (&stack0x000000d0,&stack0x00000130,&stack0x000001d0,in_stack_000003b8,

-                           unaff_R15);

-        uVar2 = SeDebugPrivilege;

-        uVar13 = (uint)unaff_RSI;

-        if ((int)uVar5 < 0) {

-          unaff_R12 = unaff_RSI & 0xffffffff;

-          goto LAB_0;

-        }

-        uVar18 = (uint)unaff_R12;

-        cVar17 = (char)unaff_R12;

-        cVar4 = in_stack_000003d8;

-        if (((uVar9 & 0x400) != 0) && (uStack000000000000004c == 0)) {

-          cVar4 = cVar17;

-        }

-        in_stack_00000080 = 0;

-        SeCaptureSubjectContext(&stack0x00000080);

-        in_stack_00000120 = uVar2;

-        cStack0000000000000040 = cVar17;

-        uStack0000000000000118 = uVar18;

-        uStack000000000000011c = uVar18;

-        in_stack_00000128 = uVar13;

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

-          if (in_stack_00000080 == 0) {

-            cStack0000000000000040 =

-                 SepPrivilegeCheck(0,&stack0x00000120,unaff_R12 & 0xffffffff,unaff_R12 & 0xffffffff,

-                                   cVar4);

-          }

-          else {

-            cStack0000000000000040 = '\0';

-          }

-        }

-        uVar5 = uStack0000000000000118;

-        uVar6 = in_stack_00000080;

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

-          uVar7 = 0;

-          if (in_stack_00000080 != 0) {

-            uVar7 = in_stack_00000080;

-          }

-          uVar2 = **(undefined8 **)(uVar7 + 0x98);

-          cVar4 = RtlEqualSid(SeLocalSystemSid,uVar2);

-          lVar8 = SeExports;

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

-            cVar4 = RtlEqualSid(*(undefined8 *)(SeExports + 0x188),uVar2);

-            if ((cVar4 == '\0') &&

-               (cVar4 = RtlEqualSid(*(undefined8 *)(lVar8 + 0x180),uVar2), cVar4 == '\0')) {

-LAB_1:

-              SepAdtPrivilegedServiceAuditAlarm(&stack0x00000080,&SeSubsystemName,0,uVar6,0);

-              uVar6 = in_stack_00000080;

-            }

-            else {

-              uVar7 = unaff_RSI & 0xffffffff;

-              if (uVar5 != 0) {

-                piVar15 = (int *)&stack0x00000120;

-                uVar16 = (ulonglong)uVar5;

-                do {

-                  piVar10 = *(int **)SepFilterPrivileges;

-                  puVar11 = (undefined8 *)SepFilterPrivileges;

-                  do {

-                    if ((*piVar15 == *piVar10) && (piVar15[1] == piVar10[1])) {

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

-                      break;

-                    }

-                    puVar11 = puVar11 + 1;

-                    piVar10 = (int *)*puVar11;

-                  } while (piVar10 != (int *)0x0);

-                  uVar14 = (uint)uVar7;

-                  piVar15 = piVar15 + 3;

-                  uVar16 = uVar16 - unaff_R12;

-                } while (uVar16 != 0);

-                if (uVar5 != 0) {

-                  piVar15 = (int *)&stack0x00000120;

-                  uVar16 = (ulonglong)uVar5;

-                  do {

-                    ppuVar12 = &SepServicesFilterPrivileges;

-                    piVar10 = &SeSystemtimePrivilege;

-                    do {

-                      if ((*piVar15 == *piVar10) && (piVar15[1] == piVar10[1])) {

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

-                        break;

-                      }

-                      ppuVar12 = ppuVar12 + 1;

-                      piVar10 = (int *)*ppuVar12;

-                    } while (piVar10 != (int *)0x0);

-                    uVar14 = (uint)uVar7;

-                    piVar15 = piVar15 + 3;

-                    uVar16 = uVar16 - unaff_R12;

-                  } while (uVar16 != 0);

-                }

-                if (uVar14 != uVar5) goto LAB_1;

-              }

-            }

-          }

-        }

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

-          LOCK();

-          piVar15 = (int *)(*(longlong *)(uVar6 + 0x478) + 0x11c);

-          *piVar15 = *piVar15 + -1;

-          UNLOCK();

-          if (in_stack_00000080 == SepTokenLeakToken) {

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

-            uVar9 = (*pcVar3)();

-            return uVar9;

-          }

-        }

-        lVar8 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

-        uVar6 = *(ulonglong *)(lVar8 + 0x248);

-        do {

-          if (0xe < uVar6) {

-            ObfDereferenceObjectWithTag(0,0x75536553);

-            goto LAB_2;

-          }

-          puVar1 = (ulonglong *)(lVar8 + 0x248);

-          LOCK();

-          uVar7 = *puVar1;

-          bVar19 = uVar6 == uVar7;

-          if (bVar19) {

-            *puVar1 = uVar6 + 1;

-            uVar7 = uVar6;

-          }

-          UNLOCK();

-          uVar6 = uVar7;

-        } while (!bVar19);

-        if ((int)CONCAT71((int7)(unaff_RSI >> 8),ObpTraceFlags != uVar13) != 0) {

-          ObpPushStackInfo(0xffffffffffffffd0,0,unaff_R12 & 0xffffffff,0x75536553);

-        }

-LAB_2:

-        if (in_stack_00000080 != 0) {

-          ObfDereferenceObjectWithTag(in_stack_00000080,0x75536553);

-        }

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

-          if ((uStack0000000000000140 >> 0x19 & 1) == 0) {

-            uStack0000000000000144 = uStack0000000000000144 | uStack0000000000000140;

-            uStack0000000000000140 = uVar13;

-          }

-          else {

-            uStack0000000000000144 = uStack0000000000000144 | 0x1fffff;

-            uStack0000000000000140 = uVar13;

-          }

-        }

-        lVar8 = PsProcessType;

-        in_stack_00000080 = unaff_RSI;

-        uVar5 = func_0x000140850f10(in_stack_00000078,uStack0000000000000048,&stack0x00000130,0,

-                                    PsProcessType);

-        uVar20 = (undefined4)((ulonglong)lVar8 >> 0x20);

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

-          if (((uStack000000000000004c != 0) && (5 < DAT_3)) &&

-             (cVar4 = _tlgKeywordOn(&DAT_3,0x400000000000), cVar4 != '\0')) {

-            PsGetProcessId(in_stack_00000078);

-            in_stack_000000f0 = 0x1000000;

-            _tlgWriteTransfer_EtwWriteTransfer(&DAT_3,&DAT_1400517dc,0,0,CONCAT44(uVar20,8))

-            ;

-          }

-          *in_stack_000000f8 = in_stack_000000b8;

-LAB_0:

-          EtwWrite(EtwApiCallsProvRegHandle,&KERNEL_AUDIT_API_OPENPROCESS,0,3,&stack0x000002b0);

-          if ((int)unaff_R12 != 0) {

-            SepDeleteAccessState(&stack0x00000130);

-            SeReleaseSubjectContext(&stack0x00000150);

-          }

-          if (in_stack_00000078 != 0) {

-            ObfDereferenceObject();

-          }

-          return (ulonglong)uVar5;

-        }

-        if ((((uStack0000000000000048 >> 10 & 1) == 0) || (uVar5 != 0xc0000022)) ||

-           (uStack000000000000004c != 0)) goto LAB_0;

-        SeDeleteAccessState(&stack0x00000130);

-        unaff_RDI = SystemReserved1[0xf];

-        unaff_R15 = PsProcessType + 0x4c;

-        unaff_R14 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

-        in_stack_000000d8 = 0;

-        in_stack_000000e0 = 0;

-        in_stack_000000e8 = *(undefined8 *)(unaff_R14 + 0x1d0);

-        unaff_RBX = unaff_RSI;

-        uStack000000000000004c = uVar18;

-      } while ((*(uint *)((longlong)SystemReserved1[0xf] + 0x5a0) & 8) == 0);

-      in_stack_00000068 = SystemReserved1[0xf];

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

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

-      unaff_R13 = (ulonglong *)((longlong)unaff_RDI + 0x590);

-      lVar8 = KeAbPreAcquire(unaff_R13,0,0);

-      LOCK();

-      uVar6 = *unaff_R13;

-      if (uVar6 == 0) {

-        *unaff_R13 = 0x11;

-      }

-      UNLOCK();

-      if (uVar6 != 0) {

-        ExfAcquirePushLockSharedEx(unaff_R13,0,lVar8,unaff_R13);

-      }

-      if (lVar8 != 0) {

-        *(char *)(lVar8 + 10) = cVar17;

-      }

-    } while ((*(uint *)((longlong)unaff_RDI + 0x5a0) & 8) == 0);

-    unaff_RBX = *(ulonglong *)((longlong)unaff_RDI + 0x538) & 0xfffffffffffffff8;

-  } while( true );

+    }

+    ExFreePoolWithTag(puVar16,0);

+  }

+  return -0x3fffff66;

 }
```

## `PopFxIdleWorker`  (modified)

```diff
--- PopFxIdleWorker
+++ PopFxIdleWorker
@@ -1,36 +1,58 @@
 

-undefined8 PopFxIdleWorker(ushort *param_1,ushort *param_2)

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

+

+void PopFxIdleWorker(longlong param_1,uint param_2,undefined8 param_3)

 

 {

-  ushort uVar1;

-  ushort *puVar2;

-  ushort uVar3;

-  ushort uVar4;

+  longlong lVar1;

+  int *piVar2;

+  int iVar3;

+  longlong lVar4;

+  undefined1 uVar5;

+  ulonglong uVar6;

+  bool bVar7;

   

-                    /* 0x3adef0  1337  KeIsSubsetAffinityEx */

-  uVar1 = *param_2;

-  uVar3 = *param_1;

-  uVar4 = uVar3;

-  puVar2 = param_2;

-  if (uVar1 <= uVar3) {

-    uVar4 = uVar1;

-    puVar2 = param_1;

-    uVar1 = uVar3;

+  uVar6 = (ulonglong)param_2;

+  lVar4 = *(longlong *)(*(longlong *)(param_1 + 0x368) + uVar6 * 8);

+  PopFxDeviceCriticalRegionEnter();

+  lVar1 = lVar4 + 0x80;

+  uVar5 = KeAcquireSpinLockRaiseToDpc(lVar1);

+  LOCK();

+  bVar7 = *(int *)(lVar4 + 0x58) == -0x80000000;

+  if (bVar7) {

+    *(int *)(lVar4 + 0x58) = 0x40000000;

   }

-  for (uVar3 = 0; uVar3 < uVar4; uVar3 = uVar3 + 1) {

-    if ((*(ulonglong *)(param_2 + (ulonglong)uVar3 * 4 + 4) &

-        *(ulonglong *)(param_1 + (ulonglong)uVar3 * 4 + 4)) !=

-        *(ulonglong *)(param_1 + (ulonglong)uVar3 * 4 + 4)) {

-      return 0;

-    }

+  UNLOCK();

+  if (!bVar7) {

+    KeReleaseSpinLock(lVar1,uVar5);

+    goto LAB_0;

   }

-  if (puVar2 != param_2) {

-    for (; uVar3 < uVar1; uVar3 = uVar3 + 1) {

-      if (*(longlong *)(param_1 + (ulonglong)uVar3 * 4 + 4) != 0) {

-        return 0;

-      }

-    }

+  KeClearEvent(lVar4 + 0x68);

+  *(undefined4 *)(lVar4 + 0x88) = 2;

+  bVar7 = false;

+  if (*(code **)(param_1 + 0x78) == (code *)0x0) {

+    LOCK();

+    *(int *)(lVar4 + 0x88) = *(int *)(lVar4 + 0x88) + -2;

+    UNLOCK();

+LAB_1:

+    bVar7 = true;

   }

-  return 1;

+  else {

+    (**(code **)(param_1 + 0x78))(*(undefined8 *)(param_1 + 0xc0),uVar6);

+    LOCK();

+    piVar2 = (int *)(lVar4 + 0x88);

+    iVar3 = *piVar2;

+    *piVar2 = *piVar2 + -1;

+    UNLOCK();

+    if (iVar3 == 1) goto LAB_1;

+    PopFxAddLogEntry(*(undefined8 *)(param_1 + 0x30),param_2,0xd);

+  }

+  KeReleaseSpinLock(lVar1,uVar5);

+  if (bVar7) {

+    PopFxIdleWorkerTail(param_1,uVar6,param_3);

+  }

+LAB_0:

+  PopFxDeviceCriticalRegionLeave(param_1);

+  return;

 }
```

## `ScAnsiToUnicodeString`  (modified)

```diff
--- ScAnsiToUnicodeString
+++ ScAnsiToUnicodeString
@@ -1,229 +1,53 @@
+

+/* long __cdecl ScAnsiToUnicodeString(char * __ptr64,struct _UNICODE_STRING * __ptr64) */

 

 long __cdecl ScAnsiToUnicodeString(char *param_1,_UNICODE_STRING *param_2)

 

 {

-  wchar_t **ppwVar1;

-  void *pvVar2;

-  byte bVar3;

-  GPT_HEADER *_Dst;

-  undefined8 uVar4;

-  undefined4 uVar5;

-  undefined4 uVar6;

-  undefined4 uVar7;

-  uchar uVar8;

-  undefined4 uVar9;

-  long lVar10;

-  undefined8 *puVar11;

-  wchar_t *pwVar12;

-  longlong lVar13;

-  longlong lVar14;

-  uint uVar15;

-  ulong uVar16;

-  __uint64 _Var17;

-  undefined8 *puVar18;

-  ulonglong uVar19;

-  undefined8 *puVar20;

-  char in_R8B;

-  uint uVar21;

-  ulonglong uVar23;

-  ulonglong uVar24;

-  _UNICODE_STRING *p_StackX_20;

-  char in_stack_00000028;

-  uint uStack0000000000000030;

-  int iStack_58;

-  undefined4 uStack_54;

-  ulonglong uStack_50;

-  ulonglong uVar22;

+  uint uVar1;

+  int iVar2;

+  wchar_t *pwVar3;

+  ulong uVar4;

+  uchar in_R8B;

+  undefined8 local_28;

+  wchar_t *pwStack_20;

+  undefined8 local_18;

+  undefined8 uStack_10;

+  undefined8 *puVar5;

   

-  lVar14 = *(longlong *)param_1;

-  uStack_54 = 0;

-  _Dst = *(GPT_HEADER **)(lVar14 + 0x108);

-  uVar15 = 0x80;

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

-    bVar3 = *(byte *)(lVar14 + 200);

-    uVar16 = 0;

-    while (lVar10 = SC_GPT::ReadHeader((SC_GPT *)param_1,uVar16,_Dst), lVar10 < 0) {

-      uVar16 = uVar16 + 1;

-      if (2 - ((bVar3 & 1) != 0) <= uVar16) {

-        return lVar10;

-      }

-    }

-    lVar14 = *(longlong *)param_1;

-    uStack_50 = *(ulonglong *)(_Dst + 0x28);

-    iStack_58 = *(int *)(_Dst + 0x54);

-    uStack0000000000000030 = *(uint *)(_Dst + 0x50);

-    uVar16 = *(int *)(lVar14 + 0xec) + -1 + uStack0000000000000030 * iStack_58 &

-             -*(int *)(lVar14 + 0xec);

-    uVar15 = uVar16 >> ((byte)*(undefined4 *)(lVar14 + 0xf0) & 0x1f);

+  local_18 = 0;

+  uStack_10 = 0;

+  local_28 = 0;

+  pwStack_20 = (wchar_t *)0x0;

+  ScTrimString(param_1);

+  RtlInitAnsiString(&local_18);

+  uVar4 = (ulong)param_1;

+  uVar1 = RtlAnsiStringToUnicodeSize(&local_18);

+  local_28._0_4_ = CONCAT22((short)uVar1,(undefined2)local_28);

+  pwStack_20 = SC_ENV::Allocate((ulonglong)uVar1,uVar4,in_R8B,0);

+  if (pwStack_20 == (wchar_t *)0x0) {

+    iVar2 = -0x3fffff66;

+    pwVar3 = pwStack_20;

   }

   else {

-    if (*(short *)(_Dst + 0x1fe) == -0x55ab) {

-      uStack_54 = *(undefined4 *)(_Dst + 0x1b8);

-    }

-    uVar21 = *(uint *)&param_2[2].Buffer;

-    if ((0x80 < uVar21) && (uVar15 = uVar21, 0x400 < uVar21)) {

-      return -0x3ffffff3;

-    }

-    iStack_58 = 0x80;

-    uVar16 = *(int *)(lVar14 + 0xec) + -1 + uVar15 * 0x80 & -*(int *)(lVar14 + 0xec);

-    uVar15 = uVar16 >> ((byte)*(undefined4 *)(lVar14 + 0xf0) & 0x1f);

-    uStack0000000000000030 = uVar16 >> 7;

-    uStack_50 = (ulonglong)(uVar15 + 2);

-  }

-  uVar23 = (ulonglong)uVar15;

-  if (uStack0000000000000030 < *(uint *)&param_2->field_0x4) {

-    return -0x3ffffff3;

-  }

-  if ((*(uint *)(lVar14 + 200) & 1) == 0) {

-    uVar24 = (*(longlong *)(lVar14 + 0xf8) - uVar23) - 2;

-  }

-  else {

-    uVar24 = *(longlong *)(lVar14 + 0xf8) - 1;

-  }

-  uVar19 = (ulonglong)((2 << ((byte)*(undefined4 *)(lVar14 + 0xf0) & 0x1f)) + uVar16);

-  puVar11 = SC_ENV::Allocate(uVar19,uVar16,(uchar)uStack0000000000000030,1);

-  if (puVar11 == (undefined8 *)0x0) {

-    return -0x3fffff66;

-  }

-  lVar14 = (longlong)(1 << ((byte)*(undefined4 *)(*(longlong *)param_1 + 0xf0) & 0x1f));

-  puVar20 = (undefined8 *)((uVar19 - lVar14) + (longlong)puVar11);

-  pvVar2 = (void *)(lVar14 + (longlong)puVar11);

-  puVar18 = (undefined8 *)((longlong)pvVar2 + 0x30);

-  uVar19 = 0;

-  while ((uint)uVar19 < *(uint *)&param_2->field_0x4) {

-    uVar22 = uVar19;

-    uVar8 = SC_PART_ENTRY::IsUnused((SC_PART_ENTRY *)(param_2 + uVar19 * 9 + 3));

-    uVar21 = (uint)uVar22;

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

-      pwVar12 = *(wchar_t **)(param_2 + uVar19 * 9 + 6);

-      if (pwVar12 == (wchar_t *)0x0) {

-        pwVar12 = param_2[uVar19 * 9 + 6].Buffer;

+    puVar5 = &local_18;

+    iVar2 = RtlAnsiStringToUnicodeString(&local_28,puVar5,0);

+    uVar4 = (ulong)puVar5;

+    pwVar3 = pwStack_20;

+    if (-1 < iVar2) {

+      if (param_2->Buffer != (wchar_t *)0x0) {

+        SC_ENV::Free(param_2->Buffer,uVar4);

       }

-      if (pwVar12 == (wchar_t *)0x0) {

-        SC_ENV::CreateGuid((_GUID *)(param_2 + uVar19 * 9 + 6));

-        uVar21 = (uint)uVar19;

-      }

-      pwVar12 = param_2[uVar19 * 9 + 5].Buffer;

-      puVar18[-6] = *(undefined8 *)(param_2 + uVar19 * 9 + 5);

-      puVar18[-5] = pwVar12;

-      pwVar12 = param_2[uVar19 * 9 + 6].Buffer;

-      puVar18[-4] = *(undefined8 *)(param_2 + uVar19 * 9 + 6);

-      puVar18[-3] = pwVar12;

-      pwVar12 = param_2[uVar19 * 9 + 3].Buffer;

-      if (*(uint *)(*(longlong *)param_1 + 0xec) != 0) {

-        pwVar12 = (wchar_t *)

-                  ((longlong)pwVar12 / (longlong)(ulonglong)*(uint *)(*(longlong *)param_1 + 0xec));

-      }

-      puVar18[-2] = pwVar12;

-      lVar13 = (longlong)param_2[uVar19 * 9 + 3].Buffer +

-               *(longlong *)(param_2 + uVar19 * 9 + 4) + -1;

-      _Var17 = (__uint64)*(uint *)(*(longlong *)param_1 + 0xec);

-      lVar14 = lVar13;

-      if (*(uint *)(*(longlong *)param_1 + 0xec) != 0) {

-        lVar14 = lVar13 / (longlong)_Var17;

-        _Var17 = lVar13 % (longlong)_Var17;

-      }

-      puVar18[-1] = lVar14;

-      *puVar18 = *(undefined8 *)(param_2 + uVar19 * 9 + 7);

-      RtlStringCbCopyW((ushort *)(puVar18 + 1),_Var17,(ushort *)&param_2[uVar19 * 9 + 7].Buffer);

-      uVar16 = (ulong)_Var17;

-      if (((ulonglong)puVar18[-2] < uStack_50) || (uVar24 < (ulonglong)puVar18[-1])) {

-        lVar10 = -0x3ffffff3;

-        goto LAB_0;

-      }

-      puVar18 = puVar18 + 0x10;

-    }

-    param_2 = p_StackX_20;

-    uVar19 = (ulonglong)(uVar21 + 1);

-  }

-  ppwVar1 = &param_2->Buffer;

-  pwVar12 = *ppwVar1;

-  if (pwVar12 == (wchar_t *)0x0) {

-    pwVar12 = *(wchar_t **)(param_2 + 1);

-  }

-  if (pwVar12 == (wchar_t *)0x0) {

-    SC_ENV::CreateGuid((_GUID *)ppwVar1);

-  }

-  lVar14 = (uVar24 - uStack_50) + 1 << ((byte)*(undefined4 *)(*(longlong *)param_1 + 0xf0) & 0x3f);

-  param_2[2].Length = (short)lVar14;

-  param_2[2].MaximumLength = (short)((ulonglong)lVar14 >> 0x10);

-  *(int *)&param_2[2].field_0x4 = (int)((ulonglong)lVar14 >> 0x20);

-  *(uint *)&param_2[2].Buffer = uStack0000000000000030;

-  *puVar11 = 0x5452415020494645;

-  puVar11[5] = uStack_50;

-  puVar11[4] = uVar23 + 1 + uVar24;

-  puVar11[6] = uVar24;

-  *(undefined4 *)(puVar11 + 1) = 0x10000;

-  *(undefined4 *)((longlong)puVar11 + 0xc) = 0x5c;

-  puVar11[3] = 1;

-  uVar9 = *(undefined4 *)ppwVar1;

-  uVar5 = *(undefined4 *)((longlong)&param_2->Buffer + 4);

-  uVar6 = *(undefined4 *)(param_2 + 1);

-  uVar7 = *(undefined4 *)&param_2[1].field_0x4;

-  *(uint *)(puVar11 + 10) = uStack0000000000000030;

-  *(int *)((longlong)puVar11 + 0x54) = iStack_58;

-  *(undefined4 *)(puVar11 + 7) = uVar9;

-  *(undefined4 *)((longlong)puVar11 + 0x3c) = uVar5;

-  *(undefined4 *)(puVar11 + 8) = uVar6;

-  *(undefined4 *)((longlong)puVar11 + 0x44) = uVar7;

-  puVar11[9] = uStack_50 - uVar23;

-  uVar9 = crc32(0,pvVar2,uVar15 << ((byte)*(undefined4 *)(*(longlong *)param_1 + 0xf0) & 0x1f));

-  *(undefined4 *)(puVar11 + 0xb) = uVar9;

-  uVar9 = crc32(0,puVar11,0x5c);

-  *(undefined4 *)(puVar11 + 2) = uVar9;

-  uVar16 = uVar15 + 1;

-  lVar10 = SC_DISK::WriteSectors(*(SC_DISK **)param_1,uVar16,1,puVar11);

-  if (-1 < lVar10) {

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

-      uVar4 = puVar11[1];

-      *puVar20 = *puVar11;

-      puVar20[1] = uVar4;

-      uVar4 = puVar11[3];

-      puVar20[2] = puVar11[2];

-      puVar20[3] = uVar4;

-      uVar4 = puVar11[5];

-      puVar20[4] = puVar11[4];

-      puVar20[5] = uVar4;

-      uVar4 = puVar11[7];

-      puVar20[6] = puVar11[6];

-      puVar20[7] = uVar4;

-      uVar9 = *(undefined4 *)((longlong)puVar11 + 0x44);

-      uVar5 = *(undefined4 *)(puVar11 + 9);

-      uVar6 = *(undefined4 *)((longlong)puVar11 + 0x4c);

-      *(undefined4 *)(puVar20 + 8) = *(undefined4 *)(puVar11 + 8);

-      *(undefined4 *)((longlong)puVar20 + 0x44) = uVar9;

-      *(undefined4 *)(puVar20 + 9) = uVar5;

-      *(undefined4 *)((longlong)puVar20 + 0x4c) = uVar6;

-      puVar20[10] = puVar11[10];

-      *(undefined4 *)(puVar20 + 0xb) = *(undefined4 *)(puVar11 + 0xb);

-      uVar4 = puVar20[3];

-      *(undefined4 *)(puVar20 + 2) = 0;

-      puVar20[3] = puVar20[4];

-      _Var17 = puVar20[4] - uVar23;

-      puVar20[9] = _Var17;

-      puVar20[4] = uVar4;

-      uVar9 = crc32(0,puVar20,*(undefined4 *)((longlong)puVar20 + 0xc));

-      *(undefined4 *)(puVar20 + 2) = uVar9;

-      uVar16 = uVar15 + 1;

-      lVar10 = SC_DISK::WriteSectors(*(SC_DISK **)param_1,uVar16,_Var17,pvVar2);

-      if (lVar10 < 0) goto LAB_0;

-    }

-    *(uint *)(*(longlong *)param_1 + 200) = *(uint *)(*(longlong *)param_1 + 200) & 0xfffffffd;

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

-      memset(_Dst,0,0x200);

-      *(undefined4 *)(_Dst + 0x1ca) = 0xffffffff;

-      *(undefined4 *)(_Dst + 0x1b8) = uStack_54;

-      _Dst[0x1c2] = (GPT_HEADER)0xee;

-      *(undefined4 *)(_Dst + 0x1c6) = 1;

-      MBR_ENTRY::ComputeChs

-                ((MBR_ENTRY *)(_Dst + 0x1be),(_DISK_GEOMETRY *)(*(longlong *)param_1 + 0xd8));

-      *(undefined2 *)(_Dst + 0x1fe) = 0xaa55;

-      uVar16 = 1;

-      lVar10 = SC_DISK::WriteSectors(*(SC_DISK **)param_1,1,0,(void *)0x0);

+      param_2->Length = (undefined2)local_28;

+      param_2->MaximumLength = local_28._2_2_;

+      *(undefined4 *)&param_2->field_0x4 = local_28._4_4_;

+      param_2->Buffer = pwStack_20;

+      pwVar3 = (wchar_t *)0x0;

     }

   }

-LAB_0:

-  SC_ENV::Free(puVar11,uVar16);

-  return lVar10;

+  if (pwVar3 != (wchar_t *)0x0) {

+    SC_ENV::Free(pwVar3,uVar4);

+  }

+  return iVar2;

 }
```

## `FsRtlpRemoveAndCompleteRHIrp`  (modified)

```diff
--- FsRtlpRemoveAndCompleteRHIrp
+++ FsRtlpRemoveAndCompleteRHIrp
@@ -1,379 +1,148 @@
 

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

 

-ulonglong FsRtlpRemoveAndCompleteRHIrp(undefined8 param_1,undefined8 param_2,ulonglong param_3)

+undefined1

+FsRtlpRemoveAndCompleteRHIrp

+          (longlong param_1,longlong param_2,uint param_3,uint param_4,uint param_5,

+          undefined4 param_6,ushort param_7,char param_8)

 

 {

-  byte *pbVar1;

-  undefined8 uVar2;

-  code *pcVar3;

-  bool bVar4;

-  char cVar5;

-  undefined1 uVar6;

-  int iVar7;

-  uint uVar8;

-  uint uVar9;

-  longlong *plVar10;

-  longlong *plVar11;

-  longlong lVar12;

-  longlong *unaff_RBX;

-  undefined8 *puVar13;

-  ulonglong uVar14;

-  longlong unaff_RDI;

-  undefined8 *unaff_R12;

-  longlong unaff_R13;

-  undefined8 *unaff_R14;

-  uint unaff_R15D;

-  uint unaff_retaddr;

-  undefined1 auStackX_8 [24];

-  undefined4 uStackX_20;

-  longlong *in_stack_00000048;

-  longlong in_stack_00000050;

-  char in_stack_000001d8;

-  char in_stack_000001e0;

-  undefined4 in_stack_000001e8;

+  longlong lVar1;

+  undefined4 *puVar2;

+  bool bVar3;

+  undefined1 uVar4;

+  undefined8 uVar5;

+  undefined1 auStack_138 [32];

+  undefined4 local_118;

+  undefined1 *local_110;

+  undefined1 local_108;

+  undefined4 local_104;

+  uint local_100;

+  uint local_fc;

+  uint local_f8;

+  uint local_f4;

+  undefined4 local_f0;

+  uint local_ec;

+  longlong local_e8 [2];

+  undefined1 local_d8 [32];

+  uint *local_b8;

+  undefined8 local_b0;

+  uint *local_a8;

+  undefined8 local_a0;

+  uint *local_98;

+  undefined8 local_90;

+  undefined4 *local_88;

+  undefined8 local_80;

+  uint *local_78;

+  undefined8 local_70;

+  longlong *local_68;

+  undefined8 local_60;

+  undefined4 *local_58;

+  undefined8 local_50;

+  ulonglong local_48;

   

-  uVar14 = (ulonglong)unaff_retaddr;

-  while (unaff_R14 != unaff_R12) {

-    if ((*(char *)((longlong)unaff_R14 + 0x35) == '\0') ||

-       (puVar13 = unaff_R14, unaff_R15D != 0x3000)) {

-      puVar13 = (undefined8 *)unaff_R14[1];

-      FsRtlpRemoveAndCompleteWaitingIrp(unaff_R14);

+  local_48 = __security_cookie ^ (ulonglong)auStack_138;

+  uVar5 = 0;

+  local_108 = 1;

+  local_100 = param_4;

+  if (5 < DAT_0) {

+    local_b8 = &local_fc;

+    local_a8 = &local_f8;

+    local_98 = &local_f4;

+    local_f0 = param_6;

+    local_88 = &local_f0;

+    local_ec = (uint)param_7;

+    local_78 = &local_ec;

+    local_68 = local_e8;

+    local_104 = *(undefined4 *)(param_2 + 0x90);

+    local_58 = &local_104;

+    local_110 = local_d8;

+    local_118 = 9;

+    local_b0 = 4;

+    local_a0 = 4;

+    local_f4 = param_5;

+    local_90 = 4;

+    local_80 = 4;

+    local_70 = 4;

+    local_60 = 8;

+    local_50 = 4;

+    local_fc = param_3;

+    local_f8 = param_4;

+    local_e8[0] = param_2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043e10,0,0);

+  }

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

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

+  uVar4 = KeAcquireQueuedSpinLock(7);

+  *(undefined1 *)(lVar1 + 0x45) = uVar4;

+  LOCK();

+  *(undefined8 *)(lVar1 + 0x68) = 0;

+  UNLOCK();

+  KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+  FsRtlpOplockDequeueRH(param_1);

+  bVar3 = false;

+  if (*(char *)(lVar1 + 0x44) == '\0') {

+    puVar2 = *(undefined4 **)(lVar1 + 0x18);

+    *(undefined8 *)(puVar2 + 4) = 0;

+    uVar5 = 0x18;

+    *puVar2 = 0x180001;

+    puVar2[1] = 3;

+    puVar2[2] = local_100 >> 0xc & 7;

+    puVar2[3] = param_5;

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

+      puVar2[4] = param_6;

+      *(ushort *)(puVar2 + 5) = param_7;

     }

-    unaff_R14 = (undefined8 *)*puVar13;

-  }

-  FsRtlpOplockDequeueRH(in_stack_00000050);

-  plVar11 = (longlong *)(in_stack_00000050 + 0x38);

-  lVar12 = *plVar11;

-  plVar10 = *(longlong **)(in_stack_00000050 + 0x40);

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

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

-    (*pcVar3)(3);

-    register0x00000020 = (BADSPACEBASE *)auStackX_8;

-LAB_0:

-    lVar12 = *(longlong *)(uVar14 + 0x18);

-    *(undefined4 *)(lVar12 + 8) = 0;

-    *(uint *)(lVar12 + 0xc) = *(uint *)(lVar12 + 0xc) | 4;

-    if (5 < DAT_1) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc6ce;

-      cVar5 = _tlgKeywordOn(&DAT_1,0x400000000000);

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

-        *(undefined8 *)((longlong)register0x00000020 + 0x78) = 1;

-        *(undefined1 **)((longlong)register0x00000020 + 0xc0) =

-             (undefined1 *)((longlong)register0x00000020 + 0x78);

-        *(undefined8 *)((longlong)register0x00000020 + 200) = 8;

-        *(uint *)((longlong)register0x00000020 + 0x58) = unaff_R15D;

-        *(undefined1 **)((longlong)register0x00000020 + 0xd0) =

-             (undefined1 *)((longlong)register0x00000020 + 0x58);

-        *(undefined8 *)((longlong)register0x00000020 + 0xd8) = 4;

-        *(undefined4 *)((longlong)register0x00000020 + 0x5c) = *(undefined4 *)(unaff_RDI + 0x90);

-        *(undefined1 **)((longlong)register0x00000020 + 0xe0) =

-             (undefined1 *)((longlong)register0x00000020 + 0x5c);

-        *(undefined8 *)((longlong)register0x00000020 + 0xe8) = 4;

-        *(undefined8 *)((longlong)register0x00000020 + 0x80) = 0x1000000;

-        *(undefined1 **)((longlong)register0x00000020 + 0xf0) =

-             (undefined1 *)((longlong)register0x00000020 + 0x80);

-        *(undefined8 *)((longlong)register0x00000020 + 0xf8) = 8;

-        *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-             (undefined1 *)((longlong)register0x00000020 + 0xa0);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc785;

-        _tlgWriteAgg(&DAT_1,&DAT_140045012);

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

+      ObfDereferenceObjectWithTag(*(undefined8 *)(param_1 + 0x18),0x746c6644);

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

+        FsRtlpClearOwner(param_2,param_1);

       }

+      bVar3 = true;

+      uVar4 = local_108;

     }

-    goto LAB_2;

-  }

-  *plVar10 = lVar12;

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

-  if (*(longlong **)(unaff_RDI + 0x78) == (longlong *)(unaff_RDI + 0x78)) {

-    *(uint *)(unaff_RDI + 0x90) = *(uint *)(unaff_RDI + 0x90) & 0xfffcffff;

-  }

-  if (*(longlong *)(in_stack_00000050 + 0x28) != 0) {

-    FsRtlpClearOwner();

-  }

-  FsRtlpFreeRHOpContext(in_stack_00000050,1);

-  FsRtlpComputeShareableOplockState();

-  bVar4 = false;

-  cVar5 = FsRtlpOplockUpperLowerCompatible(unaff_R15D,in_stack_000001e8);

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

-  if (((((unaff_R15D >> 0xc & 1) == 0) && (unaff_R15D != 0x10000)) ||

-      (*(longlong *)(*(longlong *)(unaff_R13 + 0x30) + 0x28) == 0)) ||

-     (iVar7 = MmDoesFileHaveUserWritableReferences(), iVar7 == 0)) {

-    if ((in_stack_000001e0 != '\0') || ((*(uint *)(unaff_RDI + 0x90) & 0x40) == 0)) {

-      if (unaff_R15D == 0x10) {

-        if ((((*(uint *)(unaff_RDI + 0x90) & 1) == 0) &&

-            (uVar9 = *(uint *)(unaff_RDI + 0x90) & 0x1f0ffdf, uVar9 != 0x10)) &&

-           ((uVar9 != 0x1000 && (uVar9 != 0x1010)))) goto LAB_2;

-      }

-      else if (unaff_R15D != 0x1000) {

-        if ((unaff_R15D != 0x3000) && (unaff_R15D != 0x10000)) goto LAB_3;

-        if (((((in_stack_000001e0 == '\0') &&

-              (((uVar9 = *(uint *)(unaff_RDI + 0x90), (uVar9 & 1) == 0 &&

-                (uVar8 = uVar9 & 0x1f0ffdf, uVar8 != 0x1000)) && (uVar8 != 0x3000)))) &&

-             (((uVar8 != 0xb000 && (uVar8 != 0x103000)) && (uVar8 != 0x803000)))) &&

-            ((uVar9 >> 0x10 & 1) == 0)) ||

-           (*(char *)(*(longlong *)(unaff_R13 + 0x30) + 0x49) != '\0')) goto LAB_4;

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

-          uVar9 = *(uint *)(unaff_RDI + 0x90) & 0x1f0ffdf;

-          if ((uVar9 == 0x1000) || (uVar9 == 0xb000)) {

-            for (puVar13 = *(undefined8 **)(unaff_RDI + 0x28);

-                puVar13 != (undefined8 *)(unaff_RDI + 0x28); puVar13 = (undefined8 *)*puVar13) {

-              param_3 = 0;

-              cVar5 = FsRtlpOplockKeysEqual

-                                (*(undefined8 *)(unaff_R13 + 0x30),

-                                 *(undefined8 *)(puVar13[2] + 0x30),0);

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

-                if (unaff_R15D == 0x10000) {

-                  unaff_RBX = (undefined8 *)0xc00000e3;

-                  goto LAB_5;

-                }

-                param_3 = 0x3000;

-                FsRtlpRemoveAndCompleteReadOnlyIrp(*(undefined8 *)puVar13[1],0x215,0x3000);

-                break;

-              }

-            }

-          }

-          if (((*(uint *)(unaff_RDI + 0x90) & 0x1f0ffdf) - 0x3000 & 0xffff7fff) == 0) {

-            for (puVar13 = *(undefined8 **)(unaff_RDI + 0x38);

-                puVar13 != (undefined8 *)(unaff_RDI + 0x38); puVar13 = (undefined8 *)*puVar13) {

-              param_3 = 0;

-              cVar5 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),puVar13[3],0);

-              if ((cVar5 != '\0') && (puVar13[7] == 0)) {

-                if (unaff_R15D == 0x10000) {

-                  unaff_RBX = (undefined8 *)0xc00000e3;

-                  goto LAB_5;

-                }

-                uStackX_20 = 0;

-                param_3 = 0x215;

-                FsRtlpRemoveAndCompleteRHIrp(*(undefined8 *)puVar13[1]);

-                break;

-              }

-            }

-          }

-          plVar11 = *(longlong **)(unaff_RDI + 0x48);

-          if (plVar11 != (longlong *)(unaff_RDI + 0x48)) {

-            for (; plVar11 != (undefined8 *)(unaff_RDI + 0x48); plVar11 = (longlong *)*plVar11) {

-              param_3 = 0;

-              cVar5 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),plVar11[3]);

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

-                unaff_RBX = (undefined8 *)0xc00000e2;

-                if (unaff_R15D != 0x10000) goto LAB_2;

-                goto LAB_5;

-              }

-            }

-          }

-        }

-        *(undefined8 *)(*in_stack_00000048 + 0x20) =

-             *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

-        *(undefined8 *)(*in_stack_00000048 + 0x18) = *(undefined8 *)(unaff_R13 + 0x30);

-        uVar9 = FsRtlpOplockEnqueueRH(unaff_RDI + 0x38,*in_stack_00000048);

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

-        if ((int)uVar9 < 0) {

-          if (unaff_R15D != 0x10000) {

-            *(uint *)(uVar14 + 0x30) = uVar9;

-            IofCompleteRequest(uVar14,1);

-          }

-          goto LAB_6;

-        }

-        bVar4 = false;

-        if (unaff_R15D == 0x10000) {

-          plVar10 = (longlong *)(*in_stack_00000048 + 0x38);

-          plVar11 = (longlong *)(unaff_RDI + 0x78);

-          lVar12 = *plVar11;

-          if (*(longlong **)(lVar12 + 8) != plVar11) {

-            plVar11 = (longlong *)0x3;

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

-            plVar10 = (longlong *)(*pcVar3)();

-            register0x00000020 = (BADSPACEBASE *)auStackX_8;

-          }

-          *plVar10 = lVar12;

-          plVar10[1] = (longlong)plVar11;

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

-          *plVar11 = (longlong)plVar10;

-          unaff_RBX = (undefined8 *)0x0;

-          *(undefined4 *)((longlong)register0x00000020 + 0x40) = 0;

-LAB_7:

-          in_stack_000001e0 = *(char *)((longlong)register0x00000020 + 0x1e0);

-          bVar4 = true;

-        }

-        else {

-          *(void **)(*in_stack_00000048 + 0x28) = SystemReserved1[0xf];

-          ObfReferenceObjectWithTag(*(undefined8 *)(*in_stack_00000048 + 0x28),0x746c6644);

-          *(ulonglong *)(*in_stack_00000048 + 0x10) = uVar14;

-          pbVar1 = (byte *)(*(longlong *)(uVar14 + 0xb8) + 3);

-          *pbVar1 = *pbVar1 | 1;

-          unaff_RBX = (undefined8 *)0x103;

-          *(undefined4 *)(uVar14 + 0x30) = 0;

-          *(longlong *)(uVar14 + 0x38) = unaff_RDI;

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

-            ObfReferenceObjectWithTag(*(undefined8 *)(*in_stack_00000048 + 0x18),0x746c6644);

-          }

-          uVar6 = KeAcquireQueuedSpinLock(7);

-          *(undefined1 *)(uVar14 + 0x45) = uVar6;

-          if (*(char *)(uVar14 + 0x44) == '\0') {

-            LOCK();

-            *(code **)(uVar14 + 0x68) = FsRtlpOplockRHIrpCancelRoutine;

-            UNLOCK();

-            KeReleaseQueuedSpinLock(7,*(undefined1 *)(uVar14 + 0x45));

-            unaff_RBX = (undefined8 *)0x103;

-            goto LAB_7;

-          }

-          if ((in_stack_000001d8 == '\0') || (in_stack_000001e0 == '\0')) {

-            FsRtlpCancelOplockRHIrp(uVar14,1);

-          }

-          else {

-            FsRtlpCancelOplockRHIrp(uVar14,1,param_3 & 0xffffffffffffff00);

-          }

-        }

-        if (5 < DAT_1) {

-          *(uint *)((longlong)register0x00000020 + 0x60) = unaff_R15D;

-          *(undefined1 **)((longlong)register0x00000020 + 0x120) =

-               (undefined1 *)((longlong)register0x00000020 + 0x60);

-          *(undefined8 *)((longlong)register0x00000020 + 0x128) = 4;

-          *(char *)((longlong)register0x00000020 + 0x45) = in_stack_000001e0;

-          *(undefined1 **)((longlong)register0x00000020 + 0x130) =

-               (undefined1 *)((longlong)register0x00000020 + 0x45);

-          *(undefined8 *)((longlong)register0x00000020 + 0x138) = 1;

-          *(longlong *)((longlong)register0x00000020 + 0x88) = unaff_RDI;

-          *(undefined1 **)((longlong)register0x00000020 + 0x140) =

-               (undefined1 *)((longlong)register0x00000020 + 0x88);

-          *(undefined8 *)((longlong)register0x00000020 + 0x148) = 8;

-          *(undefined4 *)((longlong)register0x00000020 + 0x48) = *(undefined4 *)(unaff_RDI + 0x90);

-          *(undefined1 **)((longlong)register0x00000020 + 0x150) =

-               (undefined1 *)((longlong)register0x00000020 + 0x48);

-          *(undefined8 *)((longlong)register0x00000020 + 0x158) = 4;

-          *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-               (undefined1 *)((longlong)register0x00000020 + 0x100);

-          *(undefined4 *)((longlong)register0x00000020 + 0x20) = 6;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcbd7;

-          _tlgWriteTransfer_EtwWriteTransfer(&DAT_1,&DAT_140044faa,0,0);

-        }

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcbdf;

-        FsRtlpComputeShareableOplockState();

-        if (bVar4) {

-          *(longlong *)((longlong)register0x00000020 + 0x20) = *in_stack_00000048 + 0x58;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcc04;

-          FsRtlpOplockTryPrepForAckTimeout();

-        }

-        *in_stack_00000048 = 0;

-        if (unaff_R15D == 0x10000) {

-          *(uint *)(unaff_RDI + 0x90) = *(uint *)(unaff_RDI + 0x90) | 0x10000;

-        }

-        goto LAB_6;

-      }

-      if (in_stack_000001e0 != '\0') goto LAB_8;

-      uVar9 = *(uint *)(unaff_RDI + 0x90);

-      if ((((((uVar9 & 1) != 0) || (uVar8 = uVar9 & 0x1f0ffdf, uVar8 == 0x10)) || (uVar8 == 0x1000))

-          || (((uVar8 == 0x1010 || (uVar8 == 0x3000)) ||

-              ((uVar8 == 0xb000 || ((uVar8 == 0x103000 || (uVar8 == 0x803000)))))))) ||

-         ((uVar9 >> 0x10 & 1) != 0)) {

-        unaff_RBX = *(longlong **)(unaff_RDI + 0x38);

-        if ((unaff_RBX != (longlong *)(unaff_RDI + 0x38)) ||

-           (*(longlong **)(unaff_RDI + 0x48) != (longlong *)(unaff_RDI + 0x48))) {

-          for (; unaff_RBX != (undefined8 *)(unaff_RDI + 0x38); unaff_RBX = (longlong *)*unaff_RBX)

-          {

-            cVar5 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),unaff_RBX[3],0);

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

-          }

-          for (unaff_RBX = *(longlong **)(unaff_RDI + 0x48);

-              unaff_RBX != (undefined8 *)(unaff_RDI + 0x48); unaff_RBX = (longlong *)*unaff_RBX) {

-            cVar5 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),unaff_RBX[3],0);

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

-          }

-        }

-        uVar9 = *(uint *)(unaff_RDI + 0x90) & 0x1f0ffdf;

-        if ((((uVar9 != 0x10) && (uVar9 != 0x1000)) && (uVar9 != 0x1010)) && (uVar9 != 0xb000))

-        goto LAB_8;

-        unaff_RBX = *(longlong **)(unaff_RDI + 0x28);

-        do {

-          if (unaff_RBX == (undefined8 *)(unaff_RDI + 0x28)) {

-LAB_8:

-            pbVar1 = (byte *)(*(longlong *)(uVar14 + 0xb8) + 3);

-            *pbVar1 = *pbVar1 | 1;

-            *(undefined4 *)(uVar14 + 0x30) = 0;

-            plVar10 = (longlong *)(uVar14 + 0xa8);

-            plVar11 = (longlong *)(unaff_RDI + 0x28);

-            lVar12 = *plVar11;

-            if (*(longlong **)(lVar12 + 8) == plVar11) goto LAB_9;

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

-            (*pcVar3)(3);

-            register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-          }

-          else {

-            plVar11 = (longlong *)(unaff_RBX[2] + 0x30);

-            if ((*(int *)(unaff_RBX[2] + 0x18) == 0x90240) ||

-               (*plVar11 != *(longlong *)(unaff_R13 + 0x30))) {

-              lVar12 = *plVar11;

-              uVar2 = *(undefined8 *)(unaff_R13 + 0x30);

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcd72;

-              cVar5 = FsRtlpOplockKeysEqual(uVar2,lVar12,0);

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

-                uVar2 = *(undefined8 *)unaff_RBX[1];

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcd94;

-                FsRtlpRemoveAndCompleteReadOnlyIrp(uVar2,0x215);

-                goto LAB_8;

-              }

-            }

-          }

-          unaff_RBX = (longlong *)*unaff_RBX;

-        } while( true );

-      }

-      goto LAB_2;

+    else {

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

+           (-(uint)(local_100 != 0) & 0xff900000) + 0x800000 |

+           *(uint *)(param_1 + 0x30) & 0xff0fffff;

+      FsRtlpOplockEnqueueRH(param_2 + 0x48,param_1);

+      FsRtlpModifyThreadPriorities(param_2,param_1,1);

+      FsRtlpOplockSendModernAppTermination(param_2,param_1);

+      uVar4 = local_108;

     }

-LAB_4:

-    if (unaff_R15D != 0x10000) goto LAB_2;

-    unaff_RBX = (undefined8 *)0xc0000909;

   }

   else {

-    if (unaff_R15D != 0x10000) goto LAB_0;

-    unaff_RBX = (undefined8 *)0xc00000e2;

+    param_3 = 0xc0000120;

+    ObfDereferenceObjectWithTag(*(undefined8 *)(param_1 + 0x18),0x746c6644);

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

+      FsRtlpClearOwner(param_2,param_1);

+    }

+    bVar3 = true;

+    uVar4 = 0;

   }

-LAB_5:

-  *(int *)((longlong)register0x00000020 + 0x40) = (int)unaff_RBX;

-LAB_6:

-  if ((*(char *)((longlong)register0x00000020 + 0x44) != '\0') && (unaff_R15D != 0x10000)) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce72;

-    ExReleaseFastMutexUnsafe(*(undefined8 *)((longlong)register0x00000020 + 0x70));

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

+  if (bVar3) {

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

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

+    }

+    FsRtlpFreeRHOpContext(param_1,param_8 == '\0');

   }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce84;

-  return (ulonglong)unaff_RBX & 0xffffffff;

-LAB_9:

-  *plVar10 = lVar12;

-  *(longlong **)(uVar14 + 0xb0) = plVar11;

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

-  *plVar11 = (longlong)plVar10;

-  *(longlong *)(uVar14 + 0x38) = unaff_RDI;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcde1;

-  FsRtlpComputeShareableOplockState();

-  if (*(char *)((longlong)register0x00000020 + 0x1d8) != '\0') {

-    uVar2 = *(undefined8 *)(unaff_R13 + 0x30);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcdf9;

-    ObfReferenceObjectWithTag(uVar2,0x746c6644);

+  *(uint *)(lVar1 + 0x30) = param_3;

+  IofCompleteRequest(lVar1,1);

+  if (5 < DAT_0) {

+    local_b8 = &local_100;

+    local_a8 = (uint *)local_e8;

+    local_b0 = 4;

+    local_104 = *(undefined4 *)(param_2 + 0x90);

+    local_98 = &local_104;

+    local_110 = local_d8;

+    local_118 = 5;

+    local_a0 = 8;

+    local_90 = 4;

+    local_100 = param_3;

+    local_e8[0] = param_2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043db5,0,0);

   }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce03;

-  uVar6 = KeAcquireQueuedSpinLock(7);

-  *(undefined1 *)(uVar14 + 0x45) = uVar6;

-  if (*(char *)(uVar14 + 0x44) == '\0') {

-    LOCK();

-    *(code **)(uVar14 + 0x68) = FsRtlpReadOnlyOplockIrpCancelRoutine;

-    UNLOCK();

-    uVar6 = *(undefined1 *)(uVar14 + 0x45);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce31;

-    KeReleaseQueuedSpinLock(7,uVar6);

-  }

-  else {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce16;

-    FsRtlpCancelReadOnlyOplockIrp(uVar14,1);

-  }

-  bVar4 = true;

-  unaff_RBX = (undefined8 *)0x103;

-  *(undefined4 *)((longlong)register0x00000020 + 0x40) = 0x103;

-LAB_3:

-  if (bVar4) goto LAB_6;

-LAB_2:

-  unaff_RBX = (undefined8 *)0xc00000e2;

-  *(undefined4 *)(uVar14 + 0x30) = 0xc00000e2;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce54;

-  IofCompleteRequest(uVar14,1);

-  goto LAB_5;

+  return uVar4;

 }
```

## `EtwTraceThread`  (modified)

```diff
--- EtwTraceThread
+++ EtwTraceThread
@@ -1,23 +1,155 @@
 

-undefined8 EtwTraceThread(void)

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

+

+void EtwTraceThread(longlong param_1,longlong param_2,char param_3)

 

 {

-  byte *pbVar1;

-  char unaff_BPL;

-  ulonglong unaff_RSI;

-  longlong unaff_RDI;

-  longlong in_R9;

-  longlong in_R10;

-  byte unaff_R14B;

+  short sVar1;

+  ushort *puVar2;

+  bool bVar3;

+  void *pvVar4;

+  int iVar5;

+  uint uVar6;

+  longlong lVar7;

+  undefined8 uVar8;

+  undefined8 uVar9;

+  undefined1 auStack_f8 [32];

+  undefined2 local_d8;

+  undefined4 local_d0;

+  undefined2 local_c8;

+  undefined4 local_c4;

+  undefined4 local_c0;

+  longlong local_b8;

+  undefined4 local_a8;

+  undefined4 local_a4;

+  undefined8 local_a0;

+  undefined8 local_98;

+  ulonglong local_90;

+  ulonglong local_88;

+  undefined8 local_80;

+  undefined8 local_78;

+  undefined8 local_70;

+  undefined4 local_68;

+  undefined1 local_64;

+  undefined1 local_63;

+  undefined1 local_62;

+  undefined1 local_61;

+  undefined8 local_60;

+  undefined4 *local_58;

+  undefined8 local_50;

+  undefined *local_48;

+  ulonglong local_40;

+  undefined *local_38;

+  undefined8 local_30;

+  ulonglong local_28;

   

-  pbVar1 = (byte *)(in_R10 + 0x49 + in_R9 * 2);

-  *pbVar1 = *pbVar1 ^ unaff_R14B;

-  ExReleaseFastMutex(unaff_RSI & 0xffffffff);

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

-    FsRtlNotifyVolumeEvent(*(undefined8 *)(unaff_RDI + 0x30),5);

+  local_28 = __security_cookie ^ (ulonglong)auStack_f8;

+  uVar9 = 2;

+  local_c4 = 2;

+  uVar8 = 0;

+  local_60 = 0;

+  local_c0 = 0x601903;

+  local_b8 = param_1;

+  if (((uint *)(EtwpHostSiloState + 0x12cc) != (uint *)0x0) &&

+     ((*(uint *)(EtwpHostSiloState + 0x12cc) & 2) != 0)) {

+    EtwpPsProvTraceThread();

   }

-  *(undefined4 *)(unaff_RSI + 0x30) = 0;

-  IofCompleteRequest();

-  return 0;

+  local_a8 = *(undefined4 *)(param_1 + 0x508);

+  local_a4 = *(undefined4 *)(param_1 + 0x510);

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

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

+  if (*(ushort *)(param_1 + 0x248) < **(ushort **)(param_1 + 0x240)) {

+    uVar8 = *(undefined8 *)

+             (*(ushort **)(param_1 + 0x240) + (ulonglong)*(ushort *)(param_1 + 0x248) * 4 + 4);

+  }

+  local_78 = *(undefined8 *)(param_1 + 0x560);

+  local_90 = 0;

+  local_88 = 0;

+  local_70 = *(undefined8 *)(param_1 + 0xf0);

+  local_68 = 0;

+  local_64 = *(undefined1 *)(param_1 + 0x233);

+  local_80 = uVar8;

+  local_63 = PsGetPagePriorityThread(param_1);

+  local_62 = PsGetIoPriorityThread(param_1);

+  local_61 = 0;

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

+    local_c8 = 0x502;

+    local_c0 = 0x4601903;

+    lVar7 = *(longlong *)(param_1 + 0xf0);

+    if (lVar7 != 0) {

+      if (*(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0x220) + 0x310) != 0) {

+        sVar1 = *(short *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0x220) + 0x6ec);

+        if ((sVar1 == 0x14c) || (bVar3 = false, sVar1 == 0x1c4)) {

+          bVar3 = true;

+        }

+        if (bVar3) {

+          local_68 = *(undefined4 *)(lVar7 + 0x2f60);

+          local_90 = (ulonglong)*(uint *)(lVar7 + 0x2004);

+          local_88 = (ulonglong)*(uint *)(lVar7 + 0x2008);

+          goto LAB_0;

+        }

+      }

+      local_68 = *(undefined4 *)(lVar7 + 0x1720);

+      local_90 = *(ulonglong *)(lVar7 + 8);

+      local_88 = *(ulonglong *)(lVar7 + 0x10);

+    }

+  }

+  else {

+    local_c8 = 0x501;

+    if (param_2 != 0) {

+      local_90 = *(ulonglong *)(param_2 + 0x10);

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

+    }

+    lVar7 = PsGetCurrentThreadTeb();

+    if (lVar7 != 0) {

+      if (*(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0x220) + 0x310) != 0) {

+        sVar1 = *(short *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0x220) + 0x6ec);

+        if ((sVar1 == 0x14c) || (bVar3 = false, sVar1 == 0x1c4)) {

+          bVar3 = true;

+        }

+        if (bVar3) {

+          local_68 = *(undefined4 *)(lVar7 + 0x2f60);

+          goto LAB_0;

+        }

+      }

+      local_68 = *(undefined4 *)(lVar7 + 0x1720);

+    }

+  }

+LAB_0:

+  pvVar4 = SystemReserved1[0xf];

+  local_58 = &local_a8;

+  local_50 = 0x48;

+  iVar5 = Feature_1224463674__private_IsEnabledDeviceUsageNoInline();

+  if (iVar5 != 0) {

+    PsLockThreadNameShared(param_1,pvVar4);

+  }

+  puVar2 = *(ushort **)(param_1 + 0x6a0);

+  if ((puVar2 == (ushort *)0x0) ||

+     (local_48 = *(undefined **)(puVar2 + 4), local_48 == (undefined *)0x0)) {

+    local_48 = &EtwpNull;

+    local_40 = 2;

+  }

+  else {

+    uVar6 = 0x800;

+    if (*puVar2 < 0x800) {

+      uVar6 = (uint)*puVar2;

+    }

+    local_40 = (ulonglong)uVar6;

+    if ((uVar6 == 0) ||

+       (*(short *)(*(longlong *)(puVar2 + 4) + -2 + (ulonglong)(uVar6 >> 1) * 2) != 0)) {

+      local_38 = &EtwpNull;

+      local_30 = 2;

+      uVar9 = 3;

+    }

+  }

+  uVar8 = PsGetProcessServerSilo(*(undefined8 *)(param_1 + 0x220));

+  local_d0 = local_c0;

+  local_d8 = local_c8;

+  EtwTraceSiloKernelEvent(uVar8,&local_58,uVar9,2);

+  iVar5 = Feature_1224463674__private_IsEnabledDeviceUsageNoInline();

+  if (iVar5 != 0) {

+    PsUnlockThreadNameShared(param_1,pvVar4);

+  }

+  return;

 }
```

## `PopPowerAggregatorHandleModernStandbyIntent`  (modified)

```diff
--- PopPowerAggregatorHandleModernStandbyIntent
+++ PopPowerAggregatorHandleModernStandbyIntent
@@ -1,37 +1,70 @@
 

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

-

-void PopPowerAggregatorHandleModernStandbyIntent

-               (undefined8 param_1,undefined8 param_2,undefined1 param_3,undefined4 param_4)

+undefined8

+PopPowerAggregatorHandleModernStandbyIntent(longlong param_1,undefined8 *param_2,int param_3)

 

 {

-  char cVar1;

-  longlong *unaff_RBP;

-  longlong lVar2;

-  bool in_CF;

-  bool in_ZF;

+  undefined8 uVar1;

+  char cVar2;

+  int iVar3;

+  undefined8 uVar4;

+  undefined8 local_28;

+  undefined8 uStack_20;

   

-  lVar2 = *unaff_RBP;

-  if (!in_CF && !in_ZF) {

-    *unaff_RBP = 0x140756d0d;

-    cVar1 = _tlgKeywordOn(&DAT_0,0x400000000000);

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

-      *(undefined4 *)(lVar2 + -0x15) = param_4;

-      *(longlong *)(lVar2 + 0x17) = lVar2 + -0x15;

-      *(undefined1 *)(lVar2 + -0x19) = param_3;

-      *(longlong *)(lVar2 + 0x27) = lVar2 + -0x19;

-      *(undefined8 *)(lVar2 + 0x1f) = 4;

-      *(longlong *)(lVar2 + 0x37) = lVar2 + -0x11;

-      *(undefined8 *)(lVar2 + 0x2f) = 1;

-      unaff_RBP[6] = lVar2 + -9;

-      *(undefined4 *)(unaff_RBP + 5) = 5;

-      *(undefined8 *)(lVar2 + -0x11) = 0x1000000;

-      *(undefined8 *)(lVar2 + 0x3f) = 8;

-      *unaff_RBP = 0x140756d7b;

-      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140048b68,0,0);

+  local_28 = 0;

+  uStack_20 = 0;

+  if (*(uint *)(param_1 + 0x10) < 3) {

+    *(undefined4 *)param_2 = 1;

+    if (param_3 == 2) {

+      *(undefined1 *)(param_2 + 3) = 1;

+    }

+    uVar4 = 0;

+    if (*(int *)(param_1 + 0x10) == 1) {

+      *(undefined1 *)((longlong)param_2 + 0x19) = *(undefined1 *)(param_1 + 0x29);

+    }

+    else if (PopPowerAggregatorOneWayEntry != 0) {

+      *(undefined1 *)((longlong)param_2 + 0x19) = 1;

+    }

+    if (*(int *)(param_2 + 1) - 0x35U < 2) {

+      *(undefined1 *)((longlong)param_2 + 0x1b) = 1;

+    }

+    iVar3 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+    if (iVar3 != 0) {

+      PopCurrentPowerState(&local_28);

+      iVar3 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

+      if (iVar3 != 8) {

+        iVar3 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

+        if (iVar3 != 6) {

+          PopAcquireRwLockShared(&PopAdaptiveStandbyLock);

+          cVar2 = DAT_0;

+          PopReleaseRwLock(&PopAdaptiveStandbyLock);

+          if ((((cVar2 == '\0') && ((char)local_28 == '\0')) && ((uint)uStack_20 != 0)) &&

+             ((uStack_20._4_4_ * 100 + ((uint)uStack_20 >> 1)) / (uint)uStack_20 < 0x15)) {

+            *(undefined1 *)((longlong)param_2 + 0x1b) = 1;

+          }

+        }

+      }

+    }

+    if (PopEnforceAusterityMode != 0) {

+      *(undefined1 *)((longlong)param_2 + 0x1b) = 1;

+    }

+    if (((*(int *)(param_1 + 0x10) == 1) && (*(char *)(param_1 + 0x2b) != '\0')) &&

+       ((*(int *)(param_2 + 1) != 0x2b && (*(int *)(param_2 + 1) != 0x37)))) {

+      *(undefined1 *)((longlong)param_2 + 0x1b) = 1;

+    }

+    cVar2 = PopPowerAggregatorAllowModernStandbyPromotion(param_1,param_2);

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

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

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

+      param_2[1] = uVar1;

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

+      param_2[2] = *(undefined8 *)(param_1 + 0x20);

+      param_2[3] = uVar1;

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

     }

   }

-  *unaff_RBP = 0x140756d87;

-  return;

+  else {

+    uVar4 = 0xc000a003;

+  }

+  return uVar4;

 }
```

## `PpmHeteroHgsEvaluateContainmentDecision`  (modified)

```diff
--- PpmHeteroHgsEvaluateContainmentDecision
+++ PpmHeteroHgsEvaluateContainmentDecision
@@ -1,97 +1,31 @@
 

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

-

-ulonglong PpmHeteroHgsEvaluateContainmentDecision

-                    (ulonglong param_1,undefined1 param_2,undefined8 param_3)

+void PpmHeteroHgsEvaluateContainmentDecision(longlong param_1)

 

 {

-  char cVar1;

+  uint uVar1;

   uint uVar2;

-  longlong lVar3;

-  ulonglong uVar4;

-  ulonglong unaff_RBX;

-  longlong unaff_RBP;

-  undefined1 unaff_SIL;

-  short sVar5;

-  ulonglong unaff_R12;

-  undefined4 uVar6;

-  undefined8 in_XMM0_Qa;

-  undefined4 uVar7;

-  undefined4 in_XMM0_Dc;

-  undefined4 in_XMM0_Dd;

+  char cVar3;

+  char cVar4;

+  longlong lVar5;

   

-  uVar7 = (undefined4)((ulonglong)in_XMM0_Qa >> 0x20);

-  uVar6 = (undefined4)in_XMM0_Qa;

-  uVar4 = unaff_R12 & 0xffffffff;

-  *(undefined4 *)(unaff_RBP + 7) = uVar6;

-  *(undefined4 *)(unaff_RBP + 0xb) = uVar7;

-  *(undefined4 *)(unaff_RBP + 0xf) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + 0x13) = in_XMM0_Dd;

-  *(undefined4 *)(unaff_RBP + 0x17) = uVar6;

-  *(undefined4 *)(unaff_RBP + 0x1b) = uVar7;

-  *(undefined4 *)(unaff_RBP + 0x1f) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + 0x23) = in_XMM0_Dd;

-  param_1 = unaff_RBX & param_1;

-  if (param_1 == 0) {

-    uVar4 = 0xc0000008;

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

+  cVar4 = *(char *)(lVar5 + 0x33b);

+  cVar3 = PpmHeteroHgsEvaluateContainmentMinPolicyDecision();

+  uVar1 = PpmHeteroHgsContainmentState;

+  PpmHeteroHgsContainmentState = PpmHeteroHgsContainmentState & 0xfffffff7;

+  if ((((PpmHeteroPolicy == 4) && (PpmHeteroContainmentPolicy == 1)) &&

+      (PpmHeteroHgsParkingEnabled != '\0')) &&

+     (((PpmPerfMaxOverrideEnabled == '\0' && (PpmCheckLatencyBoostActive == 0)) &&

+      ((cVar3 == '\0' && (cVar4 == '\0')))))) {

+    PpmHeteroHgsContainmentState = PpmHeteroHgsContainmentState | 8;

   }

-  else {

-    *(undefined4 *)(unaff_RBP + -9) = uVar6;

-    *(undefined4 *)(unaff_RBP + -5) = uVar7;

-    *(undefined4 *)(unaff_RBP + -1) = in_XMM0_Dc;

-    *(undefined4 *)(unaff_RBP + 3) = in_XMM0_Dd;

-    *(undefined1 *)(unaff_RBP + -5) = param_2;

-    *(undefined8 *)(unaff_RBP + -1) = param_3;

-    *(longlong *)(unaff_RBP + -0x19) = *(longlong *)(unaff_RBP + 0x7f);

-    lVar3 = -1;

-    do {

-      lVar3 = lVar3 + 1;

-      sVar5 = (short)unaff_R12;

-    } while (*(short *)(*(longlong *)(unaff_RBP + 0x7f) + lVar3 * 2) != sVar5);

-    *(int *)(unaff_RBP + -0xd) = (int)unaff_R12;

-    *(int *)(unaff_RBP + -0x11) = (int)lVar3 * 2 + 2;

-    if (*(short *)(param_1 + 100) != sVar5) {

-      cVar1 = EtwpLevelKeywordEnabled(*(longlong *)(param_1 + 0x20) + 0x60);

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

-        uVar2 = EtwpEventWriteFull(*(undefined8 *)(param_1 + 0x20),*(undefined2 *)(param_1 + 100),0)

-        ;

-        uVar4 = (ulonglong)uVar2;

-      }

-    }

-    if (*(short *)(param_1 + 0x66) != sVar5) {

-      cVar1 = EtwpLevelKeywordEnabled(*(longlong *)(param_1 + 0x28) + 0x60,unaff_SIL);

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

-        uVar2 = EtwpEventWriteFull(*(undefined8 *)(param_1 + 0x20),*(undefined2 *)(param_1 + 0x66),0

-                                   ,0,unaff_RBP + -9);

-        uVar4 = (ulonglong)uVar2;

-      }

-    }

-    lVar3 = *(longlong *)(param_1 + 0x20);

-    if (*(ulonglong *)(lVar3 + 0x290) != unaff_R12) {

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

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

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

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

-      if (*(short *)(param_1 + 0x68) != sVar5) {

-        cVar1 = EtwpLevelKeywordEnabled(*(longlong *)(lVar3 + 0x290) + 0x60,unaff_SIL);

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

-          uVar2 = EtwpEventWriteFull(*(undefined8 *)(*(longlong *)(param_1 + 0x20) + 0x290),

-                                     *(undefined2 *)(param_1 + 0x68),0,0,unaff_RBP + -9);

-          uVar4 = (ulonglong)uVar2;

-        }

-      }

-      if (*(short *)(param_1 + 0x6a) != sVar5) {

-        cVar1 = EtwpLevelKeywordEnabled

-                          (*(longlong *)(*(longlong *)(param_1 + 0x28) + 0x290) + 0x60,unaff_SIL);

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

-          uVar2 = EtwpEventWriteFull(*(undefined8 *)(*(longlong *)(param_1 + 0x20) + 0x290),

-                                     *(undefined2 *)(param_1 + 0x66),0,0,unaff_RBP + -9);

-          uVar4 = (ulonglong)uVar2;

-        }

-      }

-    }

-    uVar4 = uVar4 & 0xffffffff;

+  uVar2 = PpmHeteroHgsContainmentState;

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

+    *(undefined4 *)(lVar5 + 4) = 2;

   }

-  return uVar4;

+  if (uVar1 != uVar2) {

+    PpmEventHgsContainmentPolicyChange();

+  }

+  return;

 }
```

## `KiMoveScbThreadsToNewReadylist`  (modified)

```diff
--- KiMoveScbThreadsToNewReadylist
+++ KiMoveScbThreadsToNewReadylist
@@ -1,89 +1,207 @@
 

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

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

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

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

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

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

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

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

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

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

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

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

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

 /* WARNING: Enum "_NT_IORING_OP_FLAGS": Some values do not have unique names */

 /* WARNING: Enum "_POWER_LIMIT_TYPES": Some values do not have unique names */

 /* WARNING: Enum "_POOL_TYPE": Some values do not have unique names */

 /* WARNING: Struct "_MMSUPPORT_FLAGS": ignoring multiple overlapping fields */

+/* void __cdecl KiMoveScbThreadsToNewReadylist(struct _KSCB * __ptr64,struct _KSCB * __ptr64,struct

+   _KPRCB * __ptr64,struct _SINGLE_LIST_ENTRY * __ptr64) */

 

 void __cdecl

 KiMoveScbThreadsToNewReadylist

           (_KSCB *param_1,_KSCB *param_2,_KPRCB *param_3,_SINGLE_LIST_ENTRY *param_4)

 

 {

-  longlong *plVar1;

-  int iVar2;

-  longlong lVar3;

-  int unaff_EBX;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong *unaff_RDI;

-  uint unaff_R13D;

-  longlong lVar4;

-  longlong unaff_R15;

+  uint *puVar1;

+  _LIST_ENTRY *p_Var2;

+  ushort uVar3;

+  _KSCB *p_Var4;

+  _LIST_ENTRY *p_Var5;

+  _LIST_ENTRY *p_Var6;

+  code *pcVar7;

+  longlong lVar8;

+  bool bVar9;

+  _LIST_ENTRY *p_Var10;

+  _KPRCB *p_Var11;

+  char cVar12;

+  char cVar13;

+  char cVar14;

+  _KSCB *p_Var15;

+  _LIST_ENTRY *p_Var16;

+  _KSCB *p_Var17;

+  ulonglong uVar18;

+  _KSCB *p_Var19;

+  uint uVar20;

+  int iVar21;

+  ulonglong uVar22;

+  _SINGLE_LIST_ENTRY *p_Var23;

+  ulong *puVar24;

+  _LIST_ENTRY *p_Var25;

+  ulonglong unaff_R13;

+  ulonglong uVar26;

+  bool bVar27;

+  undefined4 local_res10 [2];

+  _KPRCB *local_res18;

+  _SINGLE_LIST_ENTRY *local_res20;

+  undefined4 *local_60;

+  uint local_58;

+  uint local_54;

+  _LIST_ENTRY *local_50 [2];

   

-  ExAcquireSpinLockExclusive();

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

-    if ((-1 < unaff_EBX) && (unaff_RDI[10] == 1)) {

-      if ((*(uint *)(unaff_RDI + 4) & 1) == 0) {

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

-        if ((*(uint *)(*unaff_RDI + 0x38) & 1) == 0) goto LAB_0;

-      }

-      else {

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

-      }

+  p_Var25 = (_LIST_ENTRY *)0x0;

+  local_res10[0] = 0;

+  bVar27 = false;

+  local_50[0] = (_LIST_ENTRY *)0x0;

+  uVar26 = unaff_R13 & 0xffffffffffffff00;

+  uVar3 = param_1->ReadySummary;

+  uVar18 = (ulonglong)uVar3;

+  if (param_2 == (_KSCB *)0x0) {

+    bVar9 = true;

+    if (param_3 == (_KPRCB *)0x0) {

+      bVar27 = param_4 != (_SINGLE_LIST_ENTRY *)0x0;

+      bVar9 = false;

     }

   }

   else {

-LAB_0:

-    MiReleaseSpinLockExclusive();

-    MiPurgeSubsection();

-    if (*(char *)(unaff_RBP + 1) != '\0') {

-      MiNotifyUserOfLostData();

-    }

-    plVar1 = (longlong *)(*(longlong *)(unaff_RBP + 0x77) + 0x50);

-    *plVar1 = *plVar1 + *(longlong *)(unaff_RBP + -9);

-    ExAcquireSpinLockExclusive();

-    iVar2 = func_0x00014027ef44();

-    if (-1 < iVar2) {

-      return;

-    }

-    if ((iVar2 == -0x3ffffe77) && ((int)unaff_RDI[0xd] == 0)) {

-      MiUpdateSystemProtoPtesTree(unaff_RDI + 0xf,2);

-      lVar4 = unaff_RDI[1];

-      unaff_RDI[1] = 0;

-      goto LAB_1;

-    }

+    param_2->ReadySummary = param_2->ReadySummary | uVar3;

+    local_50[0] = param_2->ReadyListHead;

+    uVar26 = 1;

+    bVar9 = false;

   }

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

+  local_res18 = param_3;

+  local_res20 = param_4;

+  if (uVar3 != 0) {

+    do {

+      p_Var11 = local_res18;

+      local_58 = 0x1f;

+      local_54 = (uint)uVar18;

+      if (local_54 != 0) {

+        for (; local_54 >> local_58 == 0; local_58 = local_58 - 1) {

+        }

+      }

+      local_54 = local_54 ^ 1 << (local_58 & 0x1f);

+      p_Var17 = (_KSCB *)(param_1->ReadyListHead + local_58);

+      p_Var19 = (_KSCB *)p_Var17->GenerationCycles;

+      p_Var23 = local_res20;

+      do {

+        p_Var2 = p_Var19[-1].ReadyListHead + 5;

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

+          puVar1 = (uint *)((longlong)&p_Var19[-1].ReadyListHead[0xc].Flink + 4);

+          *puVar1 = *puVar1 & 0xffffdfff;

+          p_Var10 = p_Var19[-1].ReadyListHead[0xc].Blink;

+          p_Var19[1].ReadyListHead[9].Flink = p_Var25;

+          if (((ulonglong)p_Var10 & 0x400000) != 0) {

+            p_Var10 = p_Var19[1].ReadyListHead[10].Blink;

+            LOCK();

+            *(uint *)&p_Var10->Flink = *(uint *)&p_Var10->Flink & 0xfffbffff;

+            UNLOCK();

+          }

+        }

+        else {

+          p_Var19[1].ReadyListHead[9].Flink = (_LIST_ENTRY *)param_2;

+        }

+        p_Var4 = (_KSCB *)p_Var19->GenerationCycles;

+        if (bVar27) {

+          KiInsertDeferredReadyList(p_Var23,p_Var2);

+        }

+        else if (bVar9) {

+          puVar24 = param_1->ShareRank;

+          uVar18 = (ulonglong)p_Var25 & 0xffffffff;

+          uVar22 = (ulonglong)p_Var25 & 0xffffffff;

+          p_Var15 = param_1;

+          cVar12 = KiIsThreadConstrainedBySchedulingGroup(p_Var2);

+          iVar21 = (int)uVar22;

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

+            cVar12 = KiCheckForMaxOverQuotaScb(param_1);

+            iVar21 = (int)uVar22;

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

+              do {

+                iVar21 = (int)uVar22;

+                uVar20 = (int)uVar18 + p_Var15->Rank;

+                uVar18 = (ulonglong)uVar20;

+                if (puVar24 == (ulong *)0x0) {

+                  if (uVar20 != 0) break;

+                }

+                else {

+                  uVar22 = (ulonglong)(iVar21 + *p_Var15->ShareRank);

+                }

+                iVar21 = (int)uVar22;

+                p_Var15 = p_Var15->Parent;

+              } while (p_Var15 != (_KSCB *)0x0);

+            }

+          }

+          local_60 = local_res10;

+          KiAddThreadToPrcbQueue

+                    (p_Var11,p_Var2,(int)*(char *)((longlong)&p_Var19[-1].Parent + 3),0,iVar21 != 0)

+          ;

+          if ((DAT_0 & 0x800) != 0) {

+            EtwTraceReadyQueueInsertion(p_Var2,p_Var11->Number,local_res10[0],0);

+          }

+          p_Var25 = (_LIST_ENTRY *)0x0;

+          p_Var23 = local_res20;

+        }

+        p_Var19 = p_Var4;

+      } while (p_Var4 != p_Var17);

+      uVar18 = (ulonglong)local_54;

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

+        p_Var10 = (_LIST_ENTRY *)p_Var17->GenerationCycles;

+        p_Var5 = (_LIST_ENTRY *)p_Var17->MinQuotaCycleTarget;

+        if (((_KSCB *)p_Var10->Blink != p_Var17) || ((_KSCB *)p_Var5->Flink != p_Var17)) {

 LAB_1:

-  MiDecrementSubsectionViewCount();

-  if ((unaff_RDI[10] == 0) && ((*(uint *)(unaff_R15 + 0x38) & 1) == 0)) {

-    MiInsertUnusedSubsection();

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

+          (*pcVar7)(3);

+          cVar12 = (char)p_Var2;

+          if ((p_Var17 == param_1) || ((char)local_60 != cVar12)) {

+            KiSearchForNewThreadsForRescheduleContext(p_Var4,local_50);

+          }

+          cVar13 = KiCommitRescheduleContext(p_Var4,uVar18,0,local_50);

+          cVar14 = KiIsThreadConstrainedBySchedulingGroup(uVar26);

+          if (((cVar14 != '\0') && (cVar14 = KiShouldPreemptionBeDeferred(), cVar14 != '\0')) &&

+             ((*(uint *)(uVar26 + 0x78) & 0xc00) == 0)) {

+            cVar12 = '\x01';

+          }

+          p_Var25 = local_50[0];

+          p_Var11 = local_res18;

+          lVar8 = CONCAT44(local_54,local_58);

+          if ((((cVar13 != '\0') || (local_50[0] != (_LIST_ENTRY *)0x0)) || (cVar12 != '\0')) ||

+             (lVar8 != 0)) {

+            KiReleasePrcbLocksForIsolationUnit(local_res18);

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

+              if ((char)p_Var4->GenerationCycles != '\0') {

+                FUN_1406d0b5e();

+                return;

+              }

+              KiFlushSoftwareInterruptBatch(uVar18 + 0x35d8);

+            }

+            if (lVar8 != 0) {

+              KiProcessScbTracingList(uVar18,&local_58);

+            }

+            if (p_Var25 != (_LIST_ENTRY *)0x0) {

+              KiReadyDeferredReadyList(uVar18,local_50);

+            }

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

+              KiInsertDeferredPreemptionApc(uVar18,uVar26,0);

+            }

+            KiAcquirePrcbLocksForIsolationUnit(uVar18,1,p_Var11);

+          }

+          return;

+        }

+        p_Var5->Flink = p_Var10;

+        p_Var10->Blink = p_Var5;

+        p_Var16 = local_50[0] + local_58;

+        p_Var6 = p_Var16->Blink;

+        if ((p_Var16->Flink->Blink != p_Var16) ||

+           (((p_Var6->Flink != p_Var16 || (p_Var10->Flink->Blink != p_Var10)) ||

+            (p_Var5->Flink != p_Var10)))) goto LAB_1;

+        p_Var6->Flink = p_Var10;

+        p_Var16->Blink = p_Var10->Blink;

+        p_Var10->Blink->Flink = p_Var16;

+        p_Var10->Blink = p_Var6;

+      }

+      p_Var17->MinQuotaCycleTarget = (ulong64)p_Var17;

+      p_Var17->GenerationCycles = (ulong64)p_Var17;

+    } while (local_54 != 0);

   }

-  lVar3 = MiDecrementModifiedWriteCount();

-  MiReleaseSpinLockExclusive();

-  if (unaff_RSI != 0) {

-    FsRtlReleaseFileForCcFlush(unaff_RSI);

-    ObfDereferenceObjectWithTag(unaff_RSI,0x63536d4d);

-  }

-  if (lVar3 != 0) {

-    MiReleaseControlAreaWaiters(lVar3);

-  }

-  if (lVar4 != 0) {

-    ExFreePoolWithTag(lVar4,0);

-  }

+  param_1->ReadySummary = (ushort)p_Var25;

   return;

 }
```

## `PspImplicitAssignProcessToJob`  (modified)

```diff
--- PspImplicitAssignProcessToJob
+++ PspImplicitAssignProcessToJob
@@ -1,10 +1,79 @@
 

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

-

-void PspImplicitAssignProcessToJob(void)

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

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  void *pvVar2;

+  int iVar3;

+  int iVar4;

+  uint *puVar5;

+  longlong lVar6;

+  

+  pvVar2 = SystemReserved1[0xf];

+  PspLockJobChain(param_1,SystemReserved1[0xf],0);

+  lVar6 = param_1;

+  if ((param_3 >> 10 & 1) == 0) {

+    for (; lVar6 != 0; lVar6 = *(longlong *)(lVar6 + 0x518)) {

+      if ((*(uint *)(lVar6 + 0x100) >> 0xc & 1) == 0) {

+        if ((param_3 & 1) == 0) goto LAB_0;

+        if ((*(uint *)(lVar6 + 0x100) >> 0xb & 1) == 0) goto LAB_1;

+      }

+    }

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

+LAB_1:

+      if ((lVar6 == param_1) && ((*(uint *)(lVar6 + 0x610) & 0x40000000) == 0)) {

+        iVar3 = -0x3fffffde;

+        goto LAB_2;

+      }

+    }

+  }

+  else {

+    lVar6 = PsGetEffectiveServerSilo(param_1);

+  }

+LAB_0:

+  if (lVar6 == 0) {

+    iVar3 = 0;

+  }

+  else {

+    lVar1 = *(longlong *)(lVar6 + 0x700);

+    if (((lVar1 - 1U < 0xfffffffffffffffe) && (*(longlong *)(param_2 + 0x758) != lVar1)) &&

+       (param_2 != *(longlong *)(lVar1 + 0x78))) {

+      iVar3 = -0x3fffff45;

+    }

+    else {

+      iVar3 = PspValidateJobChainLimits(lVar6,0,param_2,param_3);

+      if ((-1 < iVar3) && (iVar3 = PspEstablishJobHierarchy(lVar6,param_2,0,1), -1 < iVar3)) {

+        PspIncrementJobChainProcessCounts(lVar6,0,param_2,param_3);

+        PspApplyJobChainLimitsToProcess(lVar6,0,param_2);

+        if ((*(uint *)(lVar6 + 0x610) & 0x1000) != 0) {

+          puVar5 = (uint *)(param_2 + 0x728);

+          lVar6 = 7;

+          do {

+            LOCK();

+            *puVar5 = *puVar5 | 0x80000000;

+            UNLOCK();

+            puVar5 = puVar5 + 1;

+            lVar6 = lVar6 + -1;

+          } while (lVar6 != 0);

+          LOCK();

+          *(uint *)(param_2 + 0x74c) = *(uint *)(param_2 + 0x74c) | 0x80000000;

+          UNLOCK();

+        }

+        PspUnlockJobChain(param_1,pvVar2);

+        iVar3 = PspApplyWorkingSetLimitsToProcess(param_2);

+        if (iVar3 < 0) {

+          return iVar3;

+        }

+        iVar4 = MmAssignProcessToJob(param_2,0,0);

+        if (iVar4 != 0) {

+          return iVar3;

+        }

+        return -0x3fffffbc;

+      }

+    }

+  }

+LAB_2:

+  PspUnlockJobChain(param_1,pvVar2);

+  return iVar3;

 }
```

## `FsRtlpOplockBreakToII`  (modified)

```diff
--- FsRtlpOplockBreakToII
+++ FsRtlpOplockBreakToII
@@ -1,399 +1,101 @@
 

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

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

-

-ulonglong FsRtlpOplockBreakToII(undefined4 param_1)

+undefined4

+FsRtlpOplockBreakToII

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

+          undefined8 param_6,undefined8 param_7,undefined8 param_8,undefined8 param_9,

+          undefined8 param_10,undefined8 param_11,undefined1 *param_12,undefined8 param_13)

 

 {

-  longlong lVar1;

-  undefined8 *puVar2;

-  undefined8 uVar3;

-  code *pcVar4;

-  void *pvVar5;

-  char cVar6;

-  undefined1 uVar7;

-  int iVar8;

-  uint uVar9;

-  longlong *plVar10;

-  ulonglong uVar11;

-  ulonglong unaff_RBX;

-  longlong *unaff_RSI;

-  undefined8 uVar12;

-  longlong lVar13;

-  char unaff_R12B;

-  char *unaff_R13;

-  uint uVar14;

-  longlong *plVar15;

-  ulonglong unaff_R15;

-  undefined4 uVar16;

-  undefined4 extraout_XMM0_Da;

-  undefined4 extraout_XMM0_Da_00;

-  undefined4 extraout_XMM0_Da_01;

-  undefined4 extraout_XMM0_Da_02;

-  undefined4 extraout_XMM0_Da_03;

-  undefined1 local_res8 [24];

-  undefined8 local_res20;

-  ulonglong in_stack_00000058;

-  undefined8 uStack_8;

+  uint *puVar1;

+  longlong lVar2;

+  char cVar3;

+  undefined1 uVar4;

+  uint uVar5;

+  undefined4 uVar6;

+  uint *puVar7;

+  undefined8 uVar8;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

   

-  uVar14 = *(uint *)(unaff_RSI + 0x12);

-  if (((uVar14 >> 0x10 & 1) == 0) || (*unaff_R13 != '\r')) {

-LAB_0:

-    lVar13 = 0;

-    uVar14 = *(uint *)((longlong)register0x00000020 + 0x168);

-    uVar11 = (ulonglong)uVar14;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbde6;

-    cVar6 = FsRtlpOplockUpperLowerCompatible

-                      (uVar11,*(undefined4 *)((longlong)register0x00000020 + 0x170));

-    if (cVar6 == '\0') goto LAB_1;

-    uVar16 = extraout_XMM0_Da;

-    if (((uVar14 >> 0xc & 1) != 0) && (*(longlong *)(*(longlong *)(unaff_R13 + 0x30) + 0x28) != 0))

+  local_38 = 0;

+  uStack_30 = 0;

+  local_28 = 0;

+  puVar1 = (uint *)(param_1 + 0x12);

+  if ((*puVar1 & 0x7040) == 0x40) {

+    if (((param_4 & 8) == 0) &&

+       (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(param_2 + 0x30),param_1[1],0), cVar3 != '\0'))

     {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbe0f;

-      iVar8 = MmDoesFileHaveUserWritableReferences();

-      lVar1 = _DAT_2;

-      lVar13 = 0;

-      uVar16 = extraout_XMM0_Da_00;

-      if (iVar8 != 0) {

-        *(undefined4 *)(_DAT_2 + 8) = 0;

-        uVar12 = 4;

-        *(uint *)(lVar1 + 0xc) = *(uint *)(lVar1 + 0xc) | 4;

-        if (5 < DAT_3) {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbe52;

-          cVar6 = _tlgKeywordOn(&DAT_3,0x400000000000);

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

-            *(ulonglong *)((longlong)register0x00000020 + 0x70) = unaff_R15;

-            *(undefined1 **)((longlong)register0x00000020 + 0xb0) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x70);

-            *(undefined8 *)((longlong)register0x00000020 + 0xb8) = 8;

-            *(uint *)((longlong)register0x00000020 + 0x50) = uVar14;

-            *(undefined1 **)((longlong)register0x00000020 + 0xc0) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x50);

-            *(undefined8 *)((longlong)register0x00000020 + 200) = uVar12;

-            *(int *)((longlong)register0x00000020 + 0x48) = (int)unaff_RSI[0x12];

-            *(undefined1 **)((longlong)register0x00000020 + 0xd0) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x48);

-            *(undefined8 *)((longlong)register0x00000020 + 0xd8) = uVar12;

-            *(undefined8 *)((longlong)register0x00000020 + 0x68) = 0x1000000;

-            *(undefined1 **)((longlong)register0x00000020 + 0xe0) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x68);

-            *(undefined8 *)((longlong)register0x00000020 + 0xe8) = 8;

-            *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-                 (undefined1 *)((longlong)register0x00000020 + 0x90);

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbef7;

-            _tlgWriteAgg(&DAT_3,&DAT_140044f34);

+      return 0;

+    }

+    puVar7 = (uint *)(param_1 + 0x12);

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

+      if ((*puVar1 & 0x1f00f80) == 0) {

+        lVar2 = *param_1;

+        uVar8 = 7;

+        uVar4 = KeAcquireQueuedSpinLock(7);

+        *(undefined1 *)(lVar2 + 0x45) = uVar4;

+        LOCK();

+        *(undefined8 *)(lVar2 + 0x68) = 0;

+        UNLOCK();

+        KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar2 + 0x45));

+        if (*(char *)(lVar2 + 0x44) != '\0') {

+          *(undefined8 *)(lVar2 + 0x38) = 8;

+          FsRtlpModifyThreadPriorities(param_1,0,0);

+          FsRtlpClearOwner(param_1,0);

+          *(undefined1 *)(param_1 + 4) = 0;

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

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

           }

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

+          IofCompleteRequest(*param_1,1);

+          *param_1 = 0;

+          ObfDereferenceObjectWithTag(param_1[1],0x746c6644);

+          param_1[1] = 0;

+          *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+          while ((longlong *)param_1[0xb] != param_1 + 0xb) {

+            FsRtlpRemoveAndCompleteWaitingIrp();

+          }

+          return 0;

         }

-        goto LAB_1;

+        uVar5 = *puVar7;

+        if ((uVar5 & 6) == 0) {

+          uVar5 = uVar5 | 0x200;

+          uVar8 = 8;

+        }

+        else {

+          uVar5 = uVar5 | 0x100;

+        }

+        *puVar7 = uVar5;

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

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

+        IofCompleteRequest(*param_1,1);

+        *param_1 = 0;

+      }

+      else if ((char)*puVar1 < '\0') {

+        *puVar1 = *puVar7 & 0x20 | 1;

+        param_1[1] = 0;

+        return 0;

+      }

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

+        FsRtlpOplockTryStartBreakAckTimeout(param_1 + 0x14,param_1[0x16]);

+        FsRtlpModifyThreadPriorities(param_1,0,1);

+        FsRtlpOplockSendModernAppTermination(param_1,0);

+        *param_12 = 0;

+        uVar6 = FsRtlpWaitOnIrp(param_1,param_3,param_6,param_7,param_8,&local_38,0,param_9,param_10

+                                ,param_11,param_13);

+      }

+      else {

+        uVar6 = 0x108;

       }

     }

-LAB_4:

-    uVar14 = (uint)uVar11;

-    if (uVar14 == 200) {

-      *unaff_RSI = 1;

-      unaff_RSI[1] = *(longlong *)(unaff_R13 + 0x30);

-      *(uint *)(unaff_RSI + 0x12) = *(uint *)(unaff_RSI + 0x12) & 0x20 | 200;

-      unaff_RBX = (ulonglong)*(uint *)((longlong)register0x00000020 + 0x50);

-      unaff_R12B = *(char *)((longlong)register0x00000020 + 0x40);

-LAB_5:

-      if (unaff_R12B == '\0') goto LAB_6;

-LAB_7:

-      *unaff_RSI = 1;

-      unaff_RSI[1] = *(longlong *)(unaff_R13 + 0x30);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc329;

-      FsRtlpClearOwner(uVar16,0);

-      unaff_RSI[2] = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

-      pvVar5 = SystemReserved1[0xf];

-      unaff_RSI[3] = (longlong)SystemReserved1[0xf];

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc354;

-      ObfReferenceObjectWithTag(pvVar5,0x746c6644);

-      *(undefined1 *)(unaff_RSI + 4) = 0;

-      *(uint *)(unaff_RSI + 0x12) = *(uint *)(unaff_RSI + 0x12) & 0x20 | uVar14;

-      uVar12 = *(undefined8 *)(unaff_R13 + 0x30);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc378;

-      ObfReferenceObjectWithTag(uVar12,0x746c6644);

-      *(byte *)(_DAT_8 + 3) = *(byte *)(_DAT_8 + 3) | 1;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc395;

-      plRam0000000000000039 = unaff_RSI;

-      uRam0000000000000046 = KeAcquireQueuedSpinLock(7);

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

-        LOCK();

-        _DAT_9 = FsRtlpExclusiveIrpCancelRoutine;

-        UNLOCK();

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc3c4;

-        uVar16 = KeReleaseQueuedSpinLock(7,uRam0000000000000046);

-        *(longlong **)((longlong)register0x00000020 + 0x20) = unaff_RSI + 0x16;

-        lVar13 = unaff_RSI[1];

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc3e6;

-        FsRtlpOplockTryPrepForAckTimeout(uVar16,lVar13,1,unaff_RSI + 0x14);

-      }

-      else {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc3ac;

-        FsRtlpCancelExclusiveIrp(1,1,1);

-      }

-      unaff_RBX = 0x103;

-      goto LAB_6;

+    else {

+      uVar6 = 0xc0000909;

     }

-    uVar9 = *(uint *)(unaff_RSI + 0x12);

-    if ((uVar9 & 0x91) == 0) {

-      if ((((uVar9 & 0x7000) == 0) || ((uVar9 & 0x1f00f00) != 0)) ||

-         ((longlong *)unaff_RSI[9] != unaff_RSI + 9)) {

-        if ((uVar14 >> 0x10 & 1) == 0) {

-          unaff_RBX = 0xc00000e2;

-          uRam0000000000000031 = 0xc00000e2;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc2ff;

-          uVar16 = IofCompleteRequest(1,1);

-          *(undefined4 *)((longlong)register0x00000020 + 0x50) = 0xc00000e2;

-          goto LAB_5;

-        }

-      }

-      else if ((uVar14 >> 0x10 & 1) == 0) {

-        if (((uVar11 & 0x7000) != 0) &&

-           ((lVar1 = *(longlong *)(unaff_R13 + 0x30), *(char *)(lVar1 + 0x49) == (char)lVar13 ||

-            ((uVar14 >> 0xd & 1) == 0)))) {

-          uVar9 = uVar9 & 0x1f0ffdf;

-          if (uVar9 == 0x1000) {

-            if ((uVar14 - 0x5040 & 0xffffdfff) == 0) {

-              for (plVar10 = (longlong *)unaff_RSI[5]; plVar10 != unaff_RSI + 5;

-                  plVar10 = (longlong *)*plVar10) {

-                lVar13 = plVar10[2];

-                *(longlong *)((longlong)register0x00000020 + 0x68) = lVar13;

-                uVar12 = *(undefined8 *)(lVar13 + 0x30);

-                uVar3 = *(undefined8 *)(unaff_R13 + 0x30);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc271;

-                cVar6 = FsRtlpOplockKeysEqual(uVar3,uVar12,0);

-                if (cVar6 == '\0') goto LAB_10;

-                uVar16 = extraout_XMM0_Da_03;

-              }

-              uVar11 = 1;

-              if ((*(uint *)((longlong)register0x00000020 + 0x48) < 2) ||

-                 ((*(byte *)((longlong)register0x00000020 + 0x160) & 1) != 0)) {

-                plVar10 = (longlong *)unaff_RSI[5];

-                while (*(longlong **)((longlong)register0x00000020 + 0x48) = plVar10,

-                      plVar10 != unaff_RSI + 5) {

-                  puVar2 = (undefined8 *)plVar10[1];

-                  uVar12 = *puVar2;

-                  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc2c4;

-                  uVar16 = FsRtlpRemoveAndCompleteReadOnlyIrp(uVar12,0x215,uVar14 & 0x7000);

-                  plVar10 = (longlong *)*puVar2;

-                }

-                unaff_R12B = '\x01';

-                *(undefined1 *)((longlong)register0x00000020 + 0x40) = 1;

-                goto LAB_5;

-              }

-              goto LAB_11;

-            }

-          }

-          else if (uVar9 == 0x3000) {

-            if (uVar14 == 0x7040) {

-              for (plVar10 = (longlong *)unaff_RSI[7]; plVar10 != unaff_RSI + 7;

-                  plVar10 = (longlong *)*plVar10) {

-                lVar13 = plVar10[3];

-                uVar12 = *(undefined8 *)(unaff_R13 + 0x30);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc1b2;

-                cVar6 = FsRtlpOplockKeysEqual(uVar12,lVar13,0);

-                lVar13 = 0;

-                if (cVar6 == '\0') goto LAB_10;

-                if (plVar10[7] != 0) {

-                  unaff_RBX = 0xc00000e3;

-                  goto LAB_12;

-                }

-                uVar16 = extraout_XMM0_Da_02;

-              }

-              uVar11 = 1;

-              if ((*(uint *)((longlong)register0x00000020 + 0x48) < 2) ||

-                 ((*(byte *)((longlong)register0x00000020 + 0x160) & 1) != 0)) {

-                plVar10 = (longlong *)unaff_RSI[7];

-                while (*(longlong **)((longlong)register0x00000020 + 0x48) = plVar10,

-                      plVar10 != unaff_RSI + 7) {

-                  puVar2 = (undefined8 *)plVar10[1];

-                  *(char *)((longlong)register0x00000020 + 0x38) = (char)lVar13;

-                  *(short *)((longlong)register0x00000020 + 0x30) = (short)lVar13;

-                  *(int *)((longlong)register0x00000020 + 0x28) = (int)lVar13;

-                  *(int *)((longlong)register0x00000020 + 0x20) = (int)lVar13;

-                  uVar12 = *puVar2;

-                  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc230;

-                  uVar16 = FsRtlpRemoveAndCompleteRHIrp(uVar12);

-                  lVar13 = 0;

-                  plVar10 = (longlong *)*puVar2;

-                }

-                goto LAB_7;

-              }

-              goto LAB_11;

-            }

-          }

-          else if (((uVar9 == 0x5040) || ((uVar9 == 0x7040 && (uVar14 == 0x7040)))) &&

-                  ((uVar14 - 0x5040 & 0xffffdfff) == 0)) {

-            lVar13 = unaff_RSI[1];

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc0cb;

-            cVar6 = FsRtlpOplockKeysEqual(lVar1,lVar13,0);

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

-              lVar13 = *unaff_RSI;

-              *(longlong *)((longlong)register0x00000020 + 0x78) = lVar13;

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc0eb;

-              uVar7 = KeAcquireQueuedSpinLock(7);

-              *(undefined1 *)(lVar13 + 0x45) = uVar7;

-              LOCK();

-              *(undefined8 *)(lVar13 + 0x68) = 0;

-              UNLOCK();

-              uVar7 = *(undefined1 *)(lVar13 + 0x45);

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc100;

-              KeReleaseQueuedSpinLock(7,uVar7);

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

-              if (*(char *)(lVar1 + 0x44) == '\0') {

-                puVar2 = *(undefined8 **)(lVar1 + 0x18);

-                *(undefined8 **)((longlong)register0x00000020 + 0x80) = puVar2;

-                *puVar2 = 0;

-                puVar2[1] = 0;

-                puVar2[2] = 0;

-                *(undefined4 *)puVar2 = 0x180001;

-                *(uint *)((longlong)puVar2 + 4) = *(uint *)(unaff_RSI + 0x12) >> 0xc & 7;

-                *(uint *)(puVar2 + 1) = (uint)(uVar11 >> 0xc) & 7;

-                *(undefined8 *)(lVar13 + 0x38) = 0x18;

-                *(undefined4 *)(lVar13 + 0x30) = 0x215;

-              }

-              else {

-                *(undefined8 *)(lVar13 + 0x38) = 0;

-                *(undefined4 *)(lVar13 + 0x30) = 0xc0000120;

-              }

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc16d;

-              IofCompleteRequest(lVar1,1);

-              *unaff_RSI = 0;

-              lVar13 = unaff_RSI[1];

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc17e;

-              uVar16 = ObfDereferenceObjectWithTag(lVar13,0x746c6644);

-              unaff_RSI[1] = 0;

-              goto LAB_7;

-            }

-          }

-        }

-        goto LAB_10;

-      }

-LAB_13:

-      unaff_RBX = 0xc0000909;

-      goto LAB_6;

-    }

-    if (((uVar9 & 0x10) == 0) || ((uVar11 & 0x7000) == 0)) {

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

-        lVar13 = unaff_RSI[1];

-        uVar12 = *(undefined8 *)(unaff_R13 + 0x30);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbf8a;

-        cVar6 = FsRtlpOplockKeysEqual(uVar12,lVar13,0);

-        lVar13 = 0;

-        uVar16 = extraout_XMM0_Da_01;

-        if (cVar6 == '\0') goto LAB_14;

-      }

-      cVar6 = (char)lVar13;

-      uVar9 = *(uint *)(unaff_RSI + 0x12) & 0x1f0ffdf;

-      if (((uVar9 == 0x10) || (uVar9 == 0x1000)) || (uVar9 == 0x1010)) {

-        lVar13 = unaff_RSI[5];

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbfc0;

-        uVar16 = FsRtlpRemoveAndCompleteReadOnlyIrp(lVar13,0,0);

-        cVar6 = '\0';

-      }

-      uVar11 = 1;

-      if (((1 < *(uint *)((longlong)register0x00000020 + 0x48)) &&

-          ((*(uint *)(unaff_RSI + 0x12) & 1) != 0)) &&

-         ((*(byte *)((longlong)register0x00000020 + 0x160) & 1) == 0)) {

-        unaff_RBX = 0xc00000e2;

-        goto LAB_15;

-      }

-      if ((*(char *)(*(longlong *)(unaff_R13 + 0x30) + 0x49) == cVar6) || ((uVar14 >> 0xd & 1) == 0)

-         ) goto LAB_7;

-      if ((uVar14 >> 0x10 & 1) != 0) goto LAB_13;

-      goto LAB_11;

-    }

-LAB_14:

-    if ((uVar14 >> 0x10 & 1) != 0) goto LAB_13;

-LAB_10:

-    unaff_RBX = 0xc00000e2;

-LAB_12:

-    uVar11 = 1;

   }

   else {

-    cVar6 = FsRtlpCallerIsAtomicRequestor

-                      (param_1,*(undefined8 *)(unaff_R13 + 0x30),&stack0x00000058);

-    uVar11 = in_stack_00000058;

-    lVar13 = 0;

-    if (cVar6 == '\0') goto LAB_0;

-    if ((uVar14 >> 0x11 & 1) == 0) {

-LAB_16:

-      plVar10 = (longlong *)unaff_RSI[0xb];

-      while (plVar10 != unaff_RSI + 0xb) {

-        plVar15 = plVar10;

-        if (*(char *)((longlong)plVar10 + 0x35) == (char)lVar13) {

-          plVar15 = (longlong *)plVar10[1];

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbd4e;

-          FsRtlpRemoveAndCompleteWaitingIrp(plVar10);

-          lVar13 = 0;

-        }

-        plVar10 = (longlong *)*plVar15;

-      }

-      uVar11 = *(ulonglong *)((longlong)register0x00000020 + 0x58);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbd63;

-      uVar16 = FsRtlpOplockDequeueRH(uVar11);

-      plVar10 = (longlong *)(uVar11 + 0x38);

-      lVar1 = *plVar10;

-      plVar15 = *(longlong **)(uVar11 + 0x40);

-      if ((*(longlong **)(lVar1 + 8) == plVar10) && ((longlong *)*plVar15 == plVar10)) {

-        *plVar15 = lVar1;

-        *(longlong **)(lVar1 + 8) = plVar15;

-        if ((longlong *)unaff_RSI[0xf] == unaff_RSI + 0xf) {

-          *(uint *)(unaff_RSI + 0x12) = *(uint *)(unaff_RSI + 0x12) & 0xfffcffff;

-        }

-        if (*(longlong *)(uVar11 + 0x28) != lVar13) {

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbdac;

-          FsRtlpClearOwner(uVar16,uVar11);

-        }

-        unaff_R15 = 1;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbdbd;

-        FsRtlpFreeRHOpContext(uVar11,1);

-        *(undefined8 *)((longlong)register0x00000020 + 0x58) = 0;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbdcc;

-        FsRtlpComputeShareableOplockState();

-        goto LAB_0;

-      }

-      pcVar4 = (code *)swi(0x29);

-      uVar16 = (*pcVar4)(3);

-      register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-      goto LAB_4;

-    }

-    uVar16 = FsRtlpOplockDequeueRH(in_stack_00000058);

-    plVar10 = (longlong *)(uVar11 + 0x38);

-    lVar1 = *plVar10;

-    plVar15 = *(longlong **)(uVar11 + 0x40);

-    if ((*(longlong **)(lVar1 + 8) != plVar10) || ((longlong *)*plVar15 != plVar10)) {

-      pcVar4 = (code *)swi(0x29);

-      (*pcVar4)(3);

-      register0x00000020 = (BADSPACEBASE *)local_res8;

-      unaff_RBX = uVar11;

-      goto LAB_16;

-    }

-    *plVar15 = lVar1;

-    *(longlong **)(lVar1 + 8) = plVar15;

-    if ((longlong *)unaff_RSI[0xf] == unaff_RSI + 0xf) {

-      *(uint *)(unaff_RSI + 0x12) = *(uint *)(unaff_RSI + 0x12) & 0xfffcffff;

-    }

-    if (*(longlong *)(uVar11 + 0x28) != lVar13) {

-      FsRtlpClearOwner(uVar16,uVar11);

-    }

-    FsRtlpFreeRHOpContext(uVar11,unaff_R15 & 0xff);

-    in_stack_00000058 = 0;

-    FsRtlpComputeShareableOplockState();

-LAB_1:

-    uVar11 = unaff_R15 & 0xff;

-LAB_11:

-    unaff_RBX = 0xc00000e2;

+    uVar6 = 0;

   }

-LAB_15:

-  uRam0000000000000031 = (undefined4)unaff_RBX;

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dbd24;

-  IofCompleteRequest(1,uVar11);

-LAB_6:

-  lVar13 = unaff_RSI[0x13];

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc3f7;

-  ExReleaseFastMutexUnsafe(lVar13);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dc409;

-  return unaff_RBX & 0xffffffff;

+  return uVar6;

 }
```

## `FsRtlInitSystem`  (modified)

```diff
--- FsRtlInitSystem
+++ FsRtlInitSystem
@@ -1,55 +1,51 @@
 

-int FsRtlInitSystem(undefined8 param_1)

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+bool FsRtlInitSystem(void)

 

 {

-  undefined8 *puVar1;

+  int iVar1;

   longlong lVar2;

-  undefined8 *puVar3;

-  int unaff_EBX;

-  longlong unaff_RSI;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined4 unaff_R15D;

+  longlong lVar3;

+  int local_res8 [2];

+  undefined4 local_18;

+  undefined4 local_14;

+  wchar_t *local_10;

   

-  ExFreePoolWithTag(param_1,unaff_R15D);

-  if (unaff_EBX < 0) {

-    if (unaff_R14 == 0) goto LAB_0;

-    if (*(longlong *)(unaff_R14 + 8) != 0) {

-      ExFreePoolWithTag(*(longlong *)(unaff_R14 + 8),unaff_R15D);

-    }

-    if (*(longlong *)(unaff_R14 + 0x20) != 0) {

-      ExFreePoolWithTag(*(longlong *)(unaff_R14 + 0x20),unaff_R15D);

-    }

-    while( true ) {

-      ExFreePoolWithTag();

-LAB_0:

-      puVar1 = *(undefined8 **)(unaff_RSI + 0x48);

-      if (puVar1 == (undefined8 *)0x0) break;

-      *(undefined8 *)(unaff_RSI + 0x48) = *puVar1;

-      puVar3 = *(undefined8 **)(puVar1[-1] + 0x20);

-      if (puVar3[-1] == unaff_RSI) {

-        if (puVar3 != (undefined8 *)0x0) {

-          *(undefined8 *)(puVar1[-1] + 0x20) = *puVar3;

-        }

-        ExFreePoolWithTag(puVar3 + -1,0x74694d45);

-      }

-    }

-    while (puVar1 = *(undefined8 **)(unaff_RSI + 0x40), puVar1 != (undefined8 *)0x0) {

-      *(undefined8 *)(unaff_RSI + 0x40) = *puVar1;

-      lVar2 = puVar1[-1];

-      puVar3 = *(undefined8 **)(lVar2 + 0x30);

-      if (puVar3[-1] == unaff_RSI) {

-        if (puVar3 != (undefined8 *)0x0) {

-          *(undefined8 *)(lVar2 + 0x30) = *puVar3;

-        }

-        ExFreePoolWithTag(puVar3 + -1,0x74694d45);

-      }

-      ExFreePoolWithTag(puVar1 + -1,0x74694d45);

-    }

-    if (unaff_R13 != 0) {

-      ExFreePoolWithTag();

-    }

+  local_res8[0] = 0;

+  local_14 = 0;

+  FsRtlPagingIoResources = ExAllocatePoolWithTag(0x610,0x680,0x74725346);

+  lVar3 = 0x10;

+  lVar2 = 0;

+  do {

+    ExInitializeResourceLite2(FsRtlPagingIoResources + lVar2,0xffffffff);

+    lVar2 = lVar2 + 0x68;

+    lVar3 = lVar3 + -1;

+  } while (lVar3 != 0);

+  FsRtlInitializeTunnels();

+  FsRtlInitializeFileLocks();

+  FsRtlInitializeLargeMcbs();

+  ExInitializePagedLookasideList(&FsRtlEcpListLookaside,0,0,0,0x18,0x6c655346,0);

+  FsRtlpUncSemaphore = 5;

+  _DAT_0 = &DAT_140f8e3c8;

+  _DAT_1 = &DAT_1;

+  DAT_2 = 8;

+  local_10 = L"Win95TruncatedExtensions";

+  _DAT_3 = 1;

+  _DAT_4 = 0x7fffffff;

+  local_18 = 0x320030;

+  iVar1 = FsRtlGetCompatibilityModeValue(&local_18,local_res8);

+  if ((-1 < iVar1) && (local_res8[0] != 0)) {

+    FsRtlSafeExtensions = 0;

   }

-  return unaff_EBX;

+  iVar1 = FsRtlInitializeWorkerThread();

+  if (((-1 < iVar1) && (iVar1 = FsFilterInit(), -1 < iVar1)) &&

+     (iVar1 = FsRtlInitializeSmssEvent(), -1 < iVar1)) {

+    FsRtlInitializeTieringHeat();

+    FsRtlInitializeDedupChange();

+    iVar1 = FsRtlInitializeOplockPerf();

+    return -1 < iVar1;

+  }

+  return false;

 }
```

## `AlpcpReferenceBlob`  (modified)

```diff
--- AlpcpReferenceBlob
+++ AlpcpTryLockForCachedReferenceBlob
@@ -1,30 +1,42 @@
 

-longlong AlpcpReferenceBlob(longlong param_1)

+ulonglong AlpcpTryLockForCachedReferenceBlob(longlong param_1)

 

 {

-  longlong lVar1;

-  longlong lVar2;

-  bool bVar3;

+  ulonglong *puVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  ulonglong uVar4;

   

-  lVar1 = *(longlong *)(param_1 + -0x18);

-  do {

-    if (lVar1 < 1) {

-      if (lVar1 == 0) {

-        return 0;

-      }

+  lVar3 = KeAbPreAcquire(param_1 + -0x10,0,1);

+  LOCK();

+  puVar1 = (ulonglong *)(param_1 + -0x10);

+  uVar4 = *puVar1;

+  *puVar1 = *puVar1 | 1;

+  UNLOCK();

+  if ((uVar4 & 1) == 0) {

+    if (lVar3 != 0) {

+      *(undefined1 *)(lVar3 + 10) = 1;

+    }

+    *(byte *)(param_1 + -0x20) = *(byte *)(param_1 + -0x20) | 1;

+    LOCK();

+    plVar2 = (longlong *)(param_1 + -0x18);

+    lVar3 = *plVar2;

+    *plVar2 = *plVar2 + 0x10000;

+    UNLOCK();

+    lVar3 = lVar3 + 0x10000;

+    if (lVar3 < 1) {

                     /* WARNING: Subroutine does not return */

-      KeBugCheckEx(0x18,0,param_1,0x20,lVar1);

+      KeBugCheckEx(0x18,0,param_1,0x27,lVar3);

     }

-    LOCK();

-    lVar2 = *(longlong *)(param_1 + -0x18);

-    if (lVar1 == lVar2) {

-      *(longlong *)(param_1 + -0x18) = lVar1 + 1;

-      lVar2 = lVar1;

+    uVar4 = CONCAT71((int7)((ulonglong)lVar3 >> 8),1);

+  }

+  else {

+    uVar4 = 0;

+    if (lVar3 != 0) {

+      uVar4 = KeAbPostReleaseEx(param_1 + -0x10,lVar3);

     }

-    UNLOCK();

-    bVar3 = lVar2 != lVar1;

-    lVar1 = lVar2;

-  } while (bVar3);

-  return lVar2 + 1;

+    uVar4 = uVar4 & 0xffffffffffffff00;

+  }

+  return uVar4;

 }
```

## `PopFxIdleWorkerTail`  (modified)

```diff
--- PopFxIdleWorkerTail
+++ PopFxIdleWorkerTail
@@ -1,10 +1,88 @@
 

-/* WARNING: Control flow encountered bad instruction data */

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-void PopFxIdleWorkerTail(void)

+void PopFxIdleWorkerTail(longlong param_1,uint param_2,undefined8 param_3)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong lVar1;

+  int iVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  undefined1 uVar5;

+  char cVar6;

+  int iVar7;

+  ulonglong uVar8;

+  bool bVar9;

+  

+  uVar8 = (ulonglong)param_2;

+  lVar3 = *(longlong *)(*(longlong *)(param_1 + 0x368) + uVar8 * 8);

+  lVar1 = lVar3 + 200;

+  PopFxDeviceCriticalRegionEnter();

+  uVar4 = _DAT_0;

+  uVar5 = KeAcquireSpinLockRaiseToDpc(lVar1);

+  if (*(int *)(lVar3 + 0xd8) == 1) {

+    PopFxUpdateAccountingActiveTime(lVar1,uVar4,0);

+    *(undefined1 *)(lVar3 + 0xd0) = 0;

+  }

+  KeReleaseSpinLock(lVar1,uVar5);

+  PopDiagTraceFxComponentLogicalCondition(*(undefined8 *)(param_1 + 0x30),uVar8,0);

+  PpmInterlockedUpdateTimeNoFence(param_1 + 0x220,uVar4,0);

+  iVar7 = *(int *)(lVar3 + 0x58);

+  do {

+    LOCK();

+    iVar2 = *(int *)(lVar3 + 0x58);

+    bVar9 = iVar7 == iVar2;

+    if (bVar9) {

+      *(int *)(lVar3 + 0x58) = iVar7;

+      iVar2 = iVar7;

+    }

+    iVar7 = iVar2;

+    UNLOCK();

+  } while (!bVar9);

+  if (iVar7 == 0x40000000) {

+    cVar6 = PopPluginComponentActive(param_1,param_2);

+    if (cVar6 == '\x01') {

+      PopFxProcessWork(0,param_3);

+    }

+    PopFxDeactivateComponentDependencies(lVar3);

+    LOCK();

+    bVar9 = *(int *)(lVar3 + 0x58) == 0x40000000;

+    if (bVar9) {

+      *(int *)(lVar3 + 0x58) = 0;

+    }

+    UNLOCK();

+    if (!bVar9) {

+      LOCK();

+      *(int *)(lVar3 + 0x58) = *(int *)(lVar3 + 0x58) + 1;

+      UNLOCK();

+      LOCK();

+      *(uint *)(lVar3 + 0x58) = *(uint *)(lVar3 + 0x58) & 0xbfffffff;

+      UNLOCK();

+      PopFxActivateComponentWorker(param_1,lVar3,0,0);

+    }

+  }

+  else {

+    PopFxReferenceDevice(param_1,8);

+    LOCK();

+    *(int *)(lVar3 + 0x58) = *(int *)(lVar3 + 0x58) + 1;

+    UNLOCK();

+    LOCK();

+    *(uint *)(lVar3 + 0x58) = *(uint *)(lVar3 + 0x58) & 0xbfffffff;

+    UNLOCK();

+    uVar5 = KeAcquireSpinLockRaiseToDpc(lVar1);

+    if (*(int *)(lVar3 + 0xd8) == 1) {

+      *(undefined8 *)(lVar3 + 0xe0) = _DAT_0;

+      *(undefined1 *)(lVar3 + 0xd0) = 1;

+    }

+    KeReleaseSpinLock(lVar1,uVar5);

+    PopDiagTraceFxComponentLogicalCondition(*(undefined8 *)(param_1 + 0x30),uVar8,1);

+    if (*(code **)(param_1 + 0x70) != (code *)0x0) {

+      (**(code **)(param_1 + 0x70))(*(undefined8 *)(param_1 + 0xc0),param_2);

+    }

+    PopFxCompleteComponentActivation(param_1,lVar3,1);

+  }

+  PopFxDeviceCriticalRegionLeave(param_1);

+  return;

 }
```

## `CmFcpSecondaryMultiPartDumpDataCallback`  (modified)

```diff
--- CmFcpSecondaryMultiPartDumpDataCallback
+++ CmFcpSecondaryMultiPartDumpDataCallback
@@ -1,8 +1,92 @@
 

-undefined8 CmFcpSecondaryMultiPartDumpDataCallback(undefined8 param_1)

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+void CmFcpSecondaryMultiPartDumpDataCallback

+               (undefined8 param_1,undefined8 param_2,longlong *param_3)

 

 {

-  KeSetEvent(param_1,0,0);

-  return 0;

+  undefined4 *puVar1;

+  uint *puVar2;

+  uint uVar3;

+  undefined8 *puVar4;

+  longlong lVar5;

+  uint uVar6;

+  int iVar7;

+  char *pcVar8;

+  uint local_res18 [2];

+  

+  local_res18[0] = 0;

+  *(undefined4 *)(param_3 + 5) = 0;

+  pcVar8 = (char *)param_3[6];

+  *(undefined4 *)(param_3 + 2) = 0xf1f53f3;

+  *(undefined4 *)((longlong)param_3 + 0x14) = 0x42e7561f;

+  *(undefined4 *)(param_3 + 3) = 0x8ebab4bd;

+  *(undefined4 *)((longlong)param_3 + 0x1c) = 0xd526b766;

+  if (pcVar8 == (char *)0x0) {

+    pcVar8 = &DAT_0;

+    _DAT_0 = 0;

+    DAT_1 = 0;

+    param_3[6] = (longlong)&DAT_0;

+  }

+  if (*pcVar8 == '\0') {

+    *(undefined4 *)(param_3 + 5) = 0x10;

+    if ((int)param_3[1] != 0) {

+      puVar1 = (undefined4 *)*param_3;

+      iVar7 = 0;

+      *puVar1 = 0x10;

+      puVar1[1] = 1;

+      puVar1[2] = DAT_2;

+      for (puVar4 = DAT_3; (undefined8 **)puVar4 != &DAT_3;

+          puVar4 = (undefined8 *)*puVar4) {

+        if (((puVar4[0xe] != 0) && (puVar4[0xf] != 0)) &&

+           ((ulonglong)puVar4[0xe] < (ulonglong)puVar4[0xf])) {

+          iVar7 = iVar7 + 1;

+        }

+      }

+      puVar1[3] = iVar7;

+      *(int *)(param_3 + 1) = (int)param_3[5];

+      param_3[4] = *param_3;

+    }

+    *pcVar8 = '\x01';

+    lVar5 = CmFcpFindNextProviderWithDescriptors(DAT_3);

+  }

+  else {

+    puVar4 = *(undefined8 **)(pcVar8 + 8);

+    lVar5 = 0;

+    if (puVar4 == (undefined8 *)0x0) goto LAB_4;

+    uVar3 = CmFcpCountFeatureDescriptors(puVar4[0xe],puVar4[0xf],local_res18);

+    uVar6 = uVar3 * 0x10 + 0x18;

+    *(uint *)(param_3 + 5) = uVar6;

+    if (((int)param_3[1] != 0) && (uVar6 <= *(uint *)((longlong)param_3 + 0xc))) {

+      puVar2 = (uint *)*param_3;

+      *puVar2 = uVar6;

+      puVar2[1] = 1;

+      *(undefined8 *)(puVar2 + 2) = puVar4[10];

+      puVar2[4] = local_res18[0];

+      puVar2[5] = uVar3;

+      CmFcpPopulateModuleFeatures(puVar4[0xe],puVar4[0xf],puVar2 + 6);

+      *(int *)(param_3 + 1) = (int)param_3[5];

+      param_3[4] = *param_3;

+    }

+    lVar5 = CmFcpFindNextProviderWithDescriptors(*puVar4);

+  }

+  *(longlong *)(pcVar8 + 8) = lVar5;

+LAB_4:

+  if (lVar5 == 0) {

+    *(uint *)(param_3 + 7) = *(uint *)(param_3 + 7) & 0xfffffffe;

+    pcVar8[8] = '\0';

+    pcVar8[9] = '\0';

+    pcVar8[10] = '\0';

+    pcVar8[0xb] = '\0';

+    pcVar8[0xc] = '\0';

+    pcVar8[0xd] = '\0';

+    pcVar8[0xe] = '\0';

+    pcVar8[0xf] = '\0';

+    *pcVar8 = '\0';

+  }

+  else {

+    *(uint *)(param_3 + 7) = *(uint *)(param_3 + 7) | 1;

+  }

+  return;

 }
```

## `EtwTimLogControlProtectionKernelModeReturnMismatch`  (modified)

```diff
--- EtwTimLogControlProtectionKernelModeReturnMismatch
+++ EtwTimLogControlProtectionKernelModeReturnMismatch
@@ -1,10 +1,255 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void EtwTimLogControlProtectionKernelModeReturnMismatch(void)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Type propagation algorithm not settling */

+

+void EtwTimLogControlProtectionKernelModeReturnMismatch(int param_1,undefined8 *param_2)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  char cVar1;

+  int iVar2;

+  longlong lVar3;

+  ushort uVar4;

+  wchar_t *pwVar5;

+  ushort uVar6;

+  wchar_t *pwVar7;

+  wchar_t *pwVar8;

+  uint uVar9;

+  undefined1 auStack_348 [32];

+  undefined8 uStack_328;

+  undefined1 *puStack_320;

+  undefined4 uStack_318;

+  ushort **ppuStack_310;

+  wchar_t awStack_308 [32];

+  wchar_t local_2c8 [32];

+  ushort local_288 [2];

+  ushort local_284 [2];

+  PVOID local_280;

+  PVOID local_278;

+  PVOID local_270;

+  undefined4 local_268;

+  undefined4 local_264;

+  undefined4 local_260;

+  undefined4 local_25c;

+  undefined4 local_258;

+  undefined4 local_254;

+  undefined4 local_250 [2];

+  longlong local_248;

+  longlong local_240;

+  undefined8 local_238;

+  wchar_t *pwStack_230;

+  undefined8 local_228;

+  wchar_t *pwStack_220;

+  PVOID local_218;

+  longlong local_210;

+  PVOID local_208;

+  longlong local_200 [3];

+  ushort *local_1e8;

+  undefined8 local_1e0;

+  wchar_t *local_1d8;

+  uint local_1d0;

+  undefined4 local_1cc;

+  ushort *local_1c8;

+  undefined8 local_1c0;

+  wchar_t *local_1b8;

+  uint local_1b0;

+  undefined4 local_1ac;

+  undefined4 *local_1a8;

+  undefined8 local_1a0;

+  PVOID *local_198;

+  undefined8 local_190;

+  longlong *local_188;

+  undefined8 local_180;

+  undefined4 *local_178;

+  undefined8 local_170;

+  PVOID *local_168;

+  undefined8 local_160;

+  longlong *local_158;

+  undefined8 local_150;

+  undefined4 *local_148;

+  undefined8 local_140;

+  undefined4 *local_138;

+  undefined8 local_130;

+  undefined4 *local_128;

+  undefined8 local_120;

+  undefined1 local_118 [32];

+  undefined4 *local_f8;

+  undefined8 local_f0;

+  uint *local_e8;

+  undefined8 local_e0;

+  wchar_t *local_d8;

+  uint local_d0 [2];

+  uint *local_c8;

+  undefined8 local_c0;

+  wchar_t *local_b8;

+  uint local_b0 [2];

+  PVOID *local_a8;

+  undefined8 local_a0;

+  longlong *local_98;

+  undefined8 local_90;

+  PVOID *local_88;

+  undefined8 local_80;

+  longlong *local_78;

+  undefined8 local_70;

+  undefined4 *local_68;

+  undefined8 local_60;

+  PVOID *local_58;

+  undefined8 local_50;

+  longlong *local_48;

+  undefined8 local_40;

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)local_288;

+  local_278 = (PVOID)*param_2;

+  local_270 = (PVOID)param_2[1];

+  local_264 = *(undefined4 *)(param_2 + 2);

+  local_25c = *(undefined4 *)((longlong)param_2 + 0x14);

+  local_258 = *(undefined4 *)(param_2 + 3);

+  local_268 = *(undefined4 *)((longlong)param_2 + 0x1c);

+  local_280 = (PVOID)0x0;

+  local_238 = 0;

+  pwStack_230 = (wchar_t *)0x0;

+  local_228 = 0;

+  pwStack_220 = (wchar_t *)0x0;

+  pwVar5 = local_2c8;

+  if (param_1 == 1) {

+    local_260 = 0;

+    ppuStack_310 = (ushort **)0x14064d29e;

+    memset(local_2c8,0,0x40);

+    local_238._0_4_ = CONCAT22(0x40,(ushort)local_238);

+    ppuStack_310 = (ushort **)0x14064d2b3;

+    pwStack_230 = local_2c8;

+    iVar2 = RtlPcToFileName(local_278);

+    pwVar8 = pwStack_230;

+    uVar6 = 0;

+    if (-1 < iVar2) {

+      uVar6 = (ushort)local_238;

+    }

+    local_1e0 = 2;

+    uVar9 = 0xc;

+    if (uVar6 == 0) {

+      local_1d8 = L"(null)";

+      local_288[0] = 6;

+      local_1d0 = uVar9;

+    }

+    else {

+      local_1d8 = pwStack_230;

+      local_288[0] = uVar6 >> 1;

+      local_1d0 = (uint)uVar6;

+    }

+    local_1cc = 0;

+    local_1e8 = local_288;

+    memset(awStack_308,0,0x40);

+    local_228._0_4_ = CONCAT22(0x40,(ushort)local_228);

+    pwStack_220 = awStack_308;

+    iVar2 = RtlPcToFileName(local_270,&local_228);

+    pwVar7 = pwStack_220;

+    uVar4 = 0;

+    if (-1 < iVar2) {

+      uVar4 = (ushort)local_228;

+    }

+    local_1c8 = local_284;

+    local_1c0 = 2;

+    if (uVar4 == 0) {

+      local_1b8 = L"(null)";

+      local_284[0] = 6;

+    }

+    else {

+      local_1b8 = pwStack_220;

+      uVar9 = (uint)uVar4;

+      local_284[0] = uVar4 >> 1;

+    }

+    local_1a8 = &local_260;

+    lVar3 = 0;

+    local_1ac = 0;

+    local_1a0 = 4;

+    local_1b0 = uVar9;

+    RtlPcToFileHeader(local_278,&local_280);

+    local_248 = lVar3;

+    if (local_280 != (PVOID)0x0) {

+      local_248 = (longlong)local_278 - (longlong)local_280;

+    }

+    local_198 = &local_278;

+    local_188 = &local_248;

+    local_178 = &local_25c;

+    local_278 = (PVOID)0x0;

+    local_190 = 8;

+    local_180 = 8;

+    local_170 = 4;

+    RtlPcToFileHeader(local_270,&local_280);

+    if (local_280 != (PVOID)0x0) {

+      lVar3 = (longlong)local_270 - (longlong)local_280;

+    }

+    local_168 = &local_270;

+    local_270 = (PVOID)0x0;

+    local_158 = &local_240;

+    local_160 = 8;

+    local_148 = &local_258;

+    local_138 = &local_268;

+    local_128 = &local_264;

+    ppuStack_310 = &local_1e8;

+    uStack_318 = 0xd;

+    puStack_320 = (undefined1 *)0x0;

+    uStack_328 = 0;

+    local_150 = 8;

+    local_140 = 4;

+    local_130 = 4;

+    local_120 = 4;

+    local_240 = lVar3;

+    EtwWriteEx(EtwSecurityMitigationsRegHandle,

+               &MITIGATION_AUDIT_CONTROL_PROTECTION_KERNEL_MODE_RETURN_MISMATCH,0,0);

+    if (uVar6 == 0) {

+      pwVar8 = L"";

+      uVar6 = 0;

+    }

+    if (uVar4 == 0) {

+      pwVar7 = L"";

+      uVar4 = 0;

+    }

+    pwVar5 = (wchar_t *)auStack_348;

+    if ((5 < DAT_0) &&

+       (cVar1 = _tlgKeywordOn(&DAT_0,0x400000000000), pwVar5 = (wchar_t *)auStack_348,

+       cVar1 != '\0')) {

+      local_f8 = &local_254;

+      local_e8 = local_d0;

+      local_254 = 1;

+      local_d0[0] = (uint)uVar6;

+      local_c8 = local_b0;

+      local_f0 = 4;

+      local_b0[0] = (uint)uVar4;

+      local_218 = local_278;

+      local_a8 = &local_218;

+      local_210 = local_248;

+      local_98 = &local_210;

+      local_208 = local_270;

+      local_88 = &local_208;

+      local_200[0] = local_240;

+      local_78 = local_200;

+      local_250[0] = local_268;

+      local_68 = local_250;

+      local_280 = (PVOID)CONCAT44(local_280._4_4_,local_264);

+      local_58 = &local_280;

+      local_48 = local_200 + 1;

+      puStack_320 = local_118;

+      uStack_328 = CONCAT44(uStack_328._4_4_,0xe);

+      local_e0 = 2;

+      local_d0[1] = 0;

+      local_c0 = 2;

+      local_b0[1] = 0;

+      local_a0 = 8;

+      local_90 = 8;

+      local_80 = 8;

+      local_70 = 8;

+      local_60 = 4;

+      local_50 = 4;

+      local_200[1] = 0x1000000;

+      local_40 = 8;

+      local_d8 = pwVar8;

+      local_b8 = pwVar7;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140053afc,0,0);

+      pwVar5 = (wchar_t *)auStack_348;

+    }

+  }

+  *(undefined8 *)((longlong)pwVar5 + -8) = 0x14064d6e7;

+  return;

 }
```

## `FsRtlpOplockFsctrlInternal$fin$0`  (modified)

```diff
--- FsRtlpOplockFsctrlInternal$fin$0
+++ FsRtlpOplockFsctrlInternal$fin$0
@@ -1,13 +1,11 @@
 

-bool FsRtlpOplockFsctrlInternal_fin_0(void)

+void FsRtlpOplockFsctrlInternal_fin_0(undefined8 param_1,longlong param_2)

 

 {

-  char *in_RAX;

-  longlong unaff_RBP;

-  

-  *in_RAX = *in_RAX + (char)in_RAX;

-  *(char **)(unaff_RBP + 0x48) = in_RAX;

-  *(undefined1 *)(unaff_RBP + 0x40) = *(undefined1 *)(*(longlong *)(unaff_RBP + 0x48) + 0x232);

-  return *(char *)(unaff_RBP + 0x40) != '\0';

+  if (*(longlong *)(param_2 + 0x50) != 0) {

+    FsRtlpClearOwner(**(undefined8 **)(param_2 + 0xa0));

+    FsRtlpFreeRHOpContext(*(undefined8 *)(param_2 + 0x50),0);

+  }

+  return;

 }
```

## `FsRtlpOplockFsctrlInternal$fin$2`  (modified)

```diff
--- FsRtlpOplockFsctrlInternal$fin$2
+++ FsRtlpOplockFsctrlInternal$fin$2
@@ -1,12 +1,11 @@
 

-bool FsRtlpOplockFsctrlInternal_fin_2(void)

+void FsRtlpOplockFsctrlInternal_fin_2(undefined8 param_1,longlong param_2)

 

 {

-  undefined4 in_EAX;

-  longlong unaff_RBP;

-  

-  *(undefined4 *)(unaff_RBP + 0x38) = in_EAX;

-  *(undefined1 *)(unaff_RBP + 0x20) = *(undefined1 *)(*(longlong *)(unaff_RBP + 0x38) + 0x232);

-  return *(char *)(unaff_RBP + 0x20) != '\0';

+  if (*(longlong *)(param_2 + 0x50) != 0) {

+    FsRtlpClearOwner(**(undefined8 **)(param_2 + 0xa0));

+    FsRtlpFreeRHOpContext(*(undefined8 *)(param_2 + 0x50),0);

+  }

+  return;

 }
```

## `FsRtlpOplockFsctrlInternal$fin$1`  (modified)

```diff
--- FsRtlpOplockFsctrlInternal$fin$1
+++ FsRtlpOplockFsctrlInternal$fin$1
@@ -1,11 +1,15 @@
 

-bool FsRtlpOplockFsctrlInternal_fin_1(void)

+void FsRtlpOplockFsctrlInternal_fin_1(undefined8 param_1,longlong param_2)

 

 {

-  longlong unaff_RBP;

-  longlong unaff_retaddr;

+  longlong lVar1;

   

-  *(undefined1 *)(unaff_RBP + 0x30) = *(undefined1 *)(unaff_retaddr + 0x232);

-  return *(char *)(unaff_RBP + 0x30) != '\0';

+  lVar1 = *(longlong *)(param_2 + 0xa8);

+  if (*(longlong *)(param_2 + 0x50) != 0) {

+    FsRtlpClearOwner(lVar1);

+    FsRtlpFreeRHOpContext(*(undefined8 *)(param_2 + 0x50),0);

+  }

+  ExReleaseFastMutexUnsafe(*(undefined8 *)(lVar1 + 0x98));

+  return;

 }
```

## `IoReadPartitionTable`  (modified)

```diff
--- IoReadPartitionTable
+++ IoReadPartitionTable
@@ -1,49 +1,93 @@
 

-/* WARNING: Instruction at (ram,0x00014070adac) overlaps instruction at (ram,0x00014070adab)

-    */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Enum "_POOL_TYPE": Some values do not have unique names */

+/* WARNING: Struct "_MMSUPPORT_FLAGS": ignoring multiple overlapping fields */

+/* WARNING: Enum "_NT_IORING_OP_FLAGS": Some values do not have unique names */

+/* WARNING: Enum "_POWER_LIMIT_TYPES": Some values do not have unique names */

 

-void IoReadPartitionTable(longlong param_1,undefined8 param_2,uint param_3,undefined8 param_4)

+long IoReadPartitionTable

+               (_DEVICE_OBJECT *param_1,undefined8 param_2,uchar param_3,longlong *param_4)

 

 {

-  char *pcVar1;

-  char cVar2;

-  byte bVar3;

-  undefined7 uVar4;

-  char *in_RAX;

-  short sVar5;

-  uint uVar6;

-  ulonglong uVar7;

-  short *unaff_RBX;

-  int unaff_ESI;

-  short *in_R10;

-  char *in_R11;

+  SC_DISK_LAYOUT SVar1;

+  longlong lVar2;

+  SC_DISK_LAYOUT *pSVar3;

+  long lVar4;

+  void *_Dst;

+  uint uVar5;

+  longlong lVar6;

+  SC_DISK_LAYOUT **ppSVar7;

+  uchar uVar8;

+  ulonglong uVar9;

+  longlong *plVar10;

+  undefined1 auStack_1e8 [32];

+  SC_DISK_LAYOUT *local_1c8 [2];

+  undefined **local_1b8 [49];

+  undefined8 local_30;

+  ulonglong local_28;

   

-  *in_RAX = *in_RAX + (byte)in_RAX;

-  pcVar1 = (char *)((longlong)unaff_RBX + param_1 * 4 + 0x59);

-  *pcVar1 = *pcVar1 + (char)param_1;

-  *(byte *)(param_1 + -0x73) = *(byte *)(param_1 + -0x73) | (byte)in_RAX;

-  uVar4 = (undefined7)((ulonglong)param_4 >> 8);

-  cVar2 = *in_R11;

-  uVar7 = CONCAT71(uVar4,cVar2 == '\\') & 0xffffffff;

-  while (uVar6 = (uint)uVar7, uVar6 < param_3) {

-    bVar3 = in_R11[uVar7];

-    if (bVar3 == 0x5c) break;

-    if (((0x7f < bVar3) && (NlsMbOemCodePageTag != (char)param_4)) &&

-       (*(short *)(NlsOemLeadByteInfo + (ulonglong)bVar3 * 2) != (short)param_4)) {

-      uVar6 = uVar6 + unaff_ESI;

+                    /* 0x70bd90  1036  IoReadPartitionTable */

+  local_28 = __security_cookie ^ (ulonglong)auStack_1e8;

+  plVar10 = param_4;

+  uVar8 = param_3;

+  SC_DISK::SC_DISK((SC_DISK *)local_1b8);

+  local_30 = 0;

+  local_1c8[0] = (SC_DISK_LAYOUT *)0x0;

+  *plVar10 = 0;

+  local_1b8[0] = &NT_DISK::_vftable_;

+  lVar4 = NT_DISK::Initialize((NT_DISK *)local_1b8,param_1);

+  if (-1 < lVar4) {

+    ppSVar7 = local_1c8;

+    lVar4 = SC_DISK::ReadPartitionTable((SC_DISK *)local_1b8,ppSVar7);

+    pSVar3 = local_1c8[0];

+    if (-1 < lVar4) {

+      if (*(int *)local_1c8[0] == 1) {

+        lVar4 = -0x3fffff45;

+      }

+      else {

+        uVar5 = *(int *)(local_1c8[0] + 4) * 0x90 + 0x30;

+        _Dst = SC_ENV::Allocate((ulonglong)uVar5,(ulong)ppSVar7,uVar8,0);

+        *param_4 = (longlong)_Dst;

+        if (_Dst == (void *)0x0) {

+          lVar4 = -0x3fffff66;

+        }

+        else {

+          memset(_Dst,0,(ulonglong)uVar5);

+          uVar9 = 0;

+          *(int *)*param_4 = *(int *)(pSVar3 + 4);

+          *(int *)(*param_4 + 4) = *(int *)(pSVar3 + 8);

+          if (*(int *)(pSVar3 + 4) != 0) {

+            do {

+              lVar2 = *param_4;

+              lVar6 = uVar9 * 0x20;

+              if ((param_3 == '\0') ||

+                 (((SVar1 = pSVar3[uVar9 * 0x90 + 0x50], SVar1 != (SC_DISK_LAYOUT)0x0 &&

+                   (SVar1 != (SC_DISK_LAYOUT)0x5)) && (SVar1 != (SC_DISK_LAYOUT)0xf)))) {

+                *(undefined8 *)(lVar6 + 8 + lVar2) = *(undefined8 *)(pSVar3 + uVar9 * 0x90 + 0x38);

+                *(undefined8 *)(lVar6 + 0x10 + lVar2) =

+                     *(undefined8 *)(pSVar3 + uVar9 * 0x90 + 0x40);

+                *(undefined4 *)(lVar6 + 0x18 + lVar2) =

+                     *(undefined4 *)(pSVar3 + uVar9 * 0x90 + 0x54);

+                *(undefined4 *)(lVar6 + 0x1c + lVar2) =

+                     *(undefined4 *)(pSVar3 + uVar9 * 0x90 + 0x48);

+                *(SC_DISK_LAYOUT *)(lVar6 + 0x20 + lVar2) = pSVar3[uVar9 * 0x90 + 0x50];

+                *(SC_DISK_LAYOUT *)(lVar6 + 0x21 + lVar2) = pSVar3[uVar9 * 0x90 + 0x51];

+                *(SC_DISK_LAYOUT *)(lVar6 + 0x22 + lVar2) = pSVar3[uVar9 * 0x90 + 0x52];

+                *(SC_DISK_LAYOUT *)(lVar6 + 0x23 + lVar2) = pSVar3[uVar9 * 0x90 + 0x4c];

+              }

+              uVar5 = (int)uVar9 + 1;

+              uVar9 = (ulonglong)uVar5;

+            } while (uVar5 < *(uint *)(pSVar3 + 4));

+          }

+        }

+      }

     }

-    uVar7 = (ulonglong)(uVar6 + unaff_ESI);

+    if (pSVar3 != (SC_DISK_LAYOUT *)0x0) {

+      ExFreePoolWithTag(pSVar3,0);

+    }

   }

-  sVar5 = (short)uVar7 - (short)CONCAT71(uVar4,cVar2 == '\\');

-  *unaff_RBX = sVar5;

-  unaff_RBX[1] = sVar5;

-  *(char **)(unaff_RBX + 4) = in_R11 + CONCAT71(uVar4,cVar2 == '\\');

-  if (uVar6 < param_3) {

-    sVar5 = ((short)param_3 - (short)uVar7) - (short)unaff_ESI;

-    *in_R10 = sVar5;

-    *(char **)(in_R10 + 4) = in_R11 + (uVar6 + 1);

-    in_R10[1] = sVar5;

-  }

-  return;

+  local_1b8[0] = &NT_DISK::_vftable_;

+  SC_DISK::~SC_DISK((SC_DISK *)local_1b8);

+  return lVar4;

 }
```

## `HashpVerifyEcdsaSignature`  (modified)

```diff
--- HashpVerifyEcdsaSignature
+++ HashpVerifyEcdsaSignature
@@ -1,145 +1,73 @@
 

-ulonglong HashpVerifyEcdsaSignature(undefined8 param_1,size_t param_2,char param_3)

+undefined4

+HashpVerifyEcdsaSignature

+          (int param_1,undefined8 param_2,undefined4 param_3,undefined8 param_4,undefined4 param_5,

+          undefined8 param_6,undefined4 param_7)

 

 {

-  uint *puVar1;

-  undefined8 uVar2;

-  uint uVar3;

-  ulonglong unaff_RBX;

-  undefined8 *unaff_RBP;

-  undefined8 *_Dst;

-  uint unaff_EDI;

-  uint uVar4;

-  uint *unaff_R12;

-  uint uVar5;

-  ulonglong unaff_R13;

-  undefined8 *unaff_R14;

-  ulonglong unaff_R15;

+  _SYMCRYPT_ECURVE *p_Var1;

+  int iVar2;

+  _SYMCRYPT_ECURVE *p_Var3;

+  longlong lVar4;

+  undefined *puVar5;

+  _SYMCRYPT_ECURVE **pp_Var6;

+  undefined8 in_stack_ffffffffffffffc8;

+  undefined4 uVar7;

   

-  uVar5 = (uint)unaff_R13;

-  uVar4 = unaff_EDI & uVar5;

-  if ((*(int *)((longlong)unaff_RBP + 0x94) == 0) || (unaff_RBP[0x10] == unaff_RBX)) {

-LAB_0:

-    if ((*(int *)(unaff_RBP + 0x14) != 0) && (unaff_RBP[0x13] != unaff_RBX)) {

-      uVar3 = *(int *)(unaff_RBP + 0x14) + uVar4;

-      if (uVar3 < uVar4) goto LAB_1;

-      uVar4 = uVar3 + 7 & uVar5;

-    }

-    if ((*(int *)(unaff_RBP + 0x12) != 0) && (unaff_RBP[0x11] != unaff_RBX)) {

-      uVar3 = *(int *)(unaff_RBP + 0x12) + uVar4;

-      if (uVar3 < uVar4) goto LAB_1;

-      uVar4 = uVar3 + 7 & uVar5;

-    }

-    if (param_3 != '\0') {

-      if ((uint)param_2 < uVar4) {

-        unaff_RBX = 0xc0000023;

-      }

-      else {

-        memset(unaff_R14,0,param_2);

-        uVar2 = unaff_RBP[1];

-        _Dst = unaff_R14 + 0x15;

-        *unaff_R14 = *unaff_RBP;

-        unaff_R14[1] = uVar2;

-        uVar2 = unaff_RBP[3];

-        unaff_R14[2] = unaff_RBP[2];

-        unaff_R14[3] = uVar2;

-        uVar2 = unaff_RBP[5];

-        unaff_R14[4] = unaff_RBP[4];

-        unaff_R14[5] = uVar2;

-        uVar2 = unaff_RBP[7];

-        unaff_R14[6] = unaff_RBP[6];

-        unaff_R14[7] = uVar2;

-        uVar2 = unaff_RBP[9];

-        unaff_R14[8] = unaff_RBP[8];

-        unaff_R14[9] = uVar2;

-        uVar2 = unaff_RBP[0xb];

-        unaff_R14[10] = unaff_RBP[10];

-        unaff_R14[0xb] = uVar2;

-        uVar2 = unaff_RBP[0xd];

-        unaff_R14[0xc] = unaff_RBP[0xc];

-        unaff_R14[0xd] = uVar2;

-        uVar2 = unaff_RBP[0xf];

-        unaff_R14[0xe] = unaff_RBP[0xe];

-        unaff_R14[0xf] = uVar2;

-        uVar2 = unaff_RBP[0x11];

-        unaff_R14[0x10] = unaff_RBP[0x10];

-        unaff_R14[0x11] = uVar2;

-        uVar2 = unaff_RBP[0x13];

-        unaff_R14[0x12] = unaff_RBP[0x12];

-        unaff_R14[0x13] = uVar2;

-        unaff_R14[0x14] = unaff_RBP[0x14];

-        puVar1 = (uint *)unaff_RBP[3];

-        if (puVar1 != (uint *)0x0) {

-          RtlCopyMemory(_Dst,puVar1,(ulonglong)*puVar1);

-          unaff_R14[0x17] = unaff_RBX;

-          unaff_R14[3] = unaff_R15;

-          uVar3 = *(int *)unaff_RBP[3] + 0xafU & uVar5;

-          _Dst = (undefined8 *)((ulonglong)uVar3 + (longlong)unaff_R14);

-          unaff_R15 = (ulonglong)uVar3;

-        }

-        uVar3 = (uint)unaff_R15;

-        puVar1 = (uint *)unaff_RBP[4];

-        if (puVar1 != (uint *)0x0) {

-          RtlCopyMemory(_Dst,puVar1,(ulonglong)*puVar1);

-          _Dst[2] = unaff_RBX;

-          _Dst[3] = unaff_RBX;

-          unaff_R14[4] = (longlong)_Dst - (longlong)unaff_R14;

-          uVar3 = *(int *)unaff_RBP[4] + 7 + uVar3 & uVar5;

-          _Dst = (undefined8 *)((ulonglong)uVar3 + (longlong)unaff_R14);

-        }

-        puVar1 = (uint *)unaff_RBP[5];

-        if (puVar1 != (uint *)0x0) {

-          RtlCopyMemory(_Dst,puVar1,(ulonglong)*puVar1);

-          _Dst[1] = unaff_RBX;

-          unaff_R14[5] = (longlong)_Dst - (longlong)unaff_R14;

-          uVar3 = *(int *)unaff_RBP[5] + 7 + uVar3 & uVar5;

-          _Dst = (undefined8 *)((ulonglong)uVar3 + (longlong)unaff_R14);

-        }

-        puVar1 = (uint *)unaff_RBP[7];

-        if (puVar1 != (uint *)0x0) {

-          RtlCopyMemory(_Dst,puVar1,(ulonglong)*puVar1);

-          unaff_R14[7] = (longlong)_Dst - (longlong)unaff_R14;

-          uVar3 = *(int *)unaff_RBP[7] + 7 + uVar3 & uVar5;

-          _Dst = (undefined8 *)((ulonglong)uVar3 + (longlong)unaff_R14);

-        }

-        if ((*(uint *)((longlong)unaff_RBP + 0x94) != 0) && ((void *)unaff_RBP[0x10] != (void *)0x0)

-           ) {

-          RtlCopyMemory(_Dst,(void *)unaff_RBP[0x10],

-                        (ulonglong)*(uint *)((longlong)unaff_RBP + 0x94));

-          unaff_R14[0x10] = (longlong)_Dst - (longlong)unaff_R14;

-          uVar3 = *(int *)((longlong)unaff_RBP + 0x94) + 7 + uVar3 & uVar5;

-          _Dst = (undefined8 *)((ulonglong)uVar3 + (longlong)unaff_R14);

-        }

-        if ((*(uint *)(unaff_RBP + 0x14) != 0) && ((void *)unaff_RBP[0x13] != (void *)0x0)) {

-          RtlCopyMemory(_Dst,(void *)unaff_RBP[0x13],(ulonglong)*(uint *)(unaff_RBP + 0x14));

-          unaff_R14[0x13] = (longlong)_Dst - (longlong)unaff_R14;

-          _Dst = (undefined8 *)

-                 ((*(int *)(unaff_RBP + 0x14) + 7 + uVar3 & unaff_R13) + (longlong)unaff_R14);

-        }

-        if ((*(uint *)(unaff_RBP + 0x12) != 0) && ((void *)unaff_RBP[0x11] != (void *)0x0)) {

-          RtlCopyMemory(_Dst,(void *)unaff_RBP[0x11],(ulonglong)*(uint *)(unaff_RBP + 0x12));

-          unaff_R14[0x11] = (longlong)_Dst - (longlong)unaff_R14;

-        }

-        unaff_R14[6] = unaff_RBX;

-        unaff_R14[8] = unaff_RBX;

-        unaff_R14[10] = unaff_RBX;

-        unaff_R14[0xb] = unaff_RBX;

-        unaff_R14[0xc] = unaff_RBX;

-        unaff_R14[0xd] = unaff_RBX;

-        *(undefined4 *)unaff_R14 = 0x400;

-      }

-    }

-    *unaff_R12 = uVar4;

+  uVar7 = (undefined4)((ulonglong)in_stack_ffffffffffffffc8 >> 0x20);

+  if (param_1 == 0x2e01) {

+    puVar5 = &DAT_0;

+    pp_Var6 = &g_pEcurveP256;

+    p_Var3 = g_pEcurveP256;

+  }

+  else if (param_1 == 0x2e02) {

+    puVar5 = &DAT_1;

+    pp_Var6 = &g_pEcurveP384;

+    p_Var3 = g_pEcurveP384;

   }

   else {

-    uVar3 = *(int *)((longlong)unaff_RBP + 0x94) + uVar4;

-    if (uVar4 <= uVar3) {

-      uVar4 = uVar3 + 7 & uVar5;

-      goto LAB_0;

+    if ((param_1 != 0x2e03) ||

+       (iVar2 = Feature_CodeIntegrity_EccSupport__private_IsEnabledDeviceUsageNoInline(), iVar2 == 0

+       )) {

+      return 0xc0000428;

     }

-LAB_1:

-    unaff_RBX = 0xc000000d;

+    puVar5 = &DAT_2;

+    pp_Var6 = &g_pEcurveP521;

+    p_Var3 = g_pEcurveP521;

   }

-  return unaff_RBX & 0xffffffff;

+  if (p_Var3 == (_SYMCRYPT_ECURVE *)0x0) {

+    p_Var3 = (_SYMCRYPT_ECURVE *)SymCryptEcurveAllocate(puVar5,0);

+    if (p_Var3 == (_SYMCRYPT_ECURVE *)0x0) {

+      return 0xc0000017;

+    }

+    LOCK();

+    p_Var1 = *pp_Var6;

+    if (p_Var1 == (_SYMCRYPT_ECURVE *)0x0) {

+      *pp_Var6 = p_Var3;

+    }

+    UNLOCK();

+    if (p_Var1 != (_SYMCRYPT_ECURVE *)0x0) {

+      SymCryptEcurveFree();

+    }

+  }

+  lVar4 = SymCryptEckeyAllocate(*pp_Var6);

+  if (lVar4 == 0) {

+    return 0xc0000017;

+  }

+  iVar2 = Feature_CodeIntegrity_EccSupport__private_IsEnabledDeviceUsageNoInline();

+  iVar2 = SymCryptEckeySetValue

+                    (0,0,param_2,param_3,CONCAT44(uVar7,2),2,((iVar2 == 0) + 0x10) * 0x100,lVar4);

+  if (iVar2 == 0) {

+    iVar2 = SymCryptEcDsaVerify(lVar4,param_4,param_5,param_6,param_7,2,0);

+    uVar7 = 0;

+    if (iVar2 != 0) {

+      uVar7 = 0xc0000428;

+    }

+  }

+  else {

+    uVar7 = 0xc0000428;

+  }

+  SymCryptEckeyFree(lVar4);

+  return uVar7;

 }
```

## `RtlpDeCommitFreeBlock`  (modified)

```diff
--- RtlpDeCommitFreeBlock
+++ RtlpDeCommitFreeBlock
@@ -1,30 +1,211 @@
 

-undefined8 RtlpDeCommitFreeBlock(undefined8 param_1,undefined8 param_2)

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+void RtlpDeCommitFreeBlock(longlong param_1,ulonglong param_2,ulonglong param_3)

 

 {

-  longlong lVar1;

-  char cVar2;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  undefined8 uVar3;

-  undefined8 uStack0000000000000028;

+  bool bVar1;

+  int iVar2;

+  ulonglong uVar3;

+  undefined8 *puVar4;

+  longlong lVar5;

+  ulonglong uVar6;

+  ushort uVar7;

+  undefined8 *puVar8;

+  longlong lVar9;

+  undefined8 *puVar10;

+  longlong lVar11;

+  ulonglong local_res8;

+  ulonglong local_res18 [2];

+  ulonglong local_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  ulonglong local_40;

   

-  uStack0000000000000028 = param_2;

-  cVar2 = RtlpInitializeHeapSegment();

-  if (cVar2 == '\0') {

-    ZwFreeVirtualMemory();

-    uVar3 = 0;

+  puVar8 = (undefined8 *)0x0;

+  local_40 = 0;

+  local_50 = 0;

+  bVar1 = false;

+  uVar3 = param_2;

+  local_res18[0] = param_3;

+  if ((((*(longlong *)(param_1 + 0x168) != _RtlpHeapKey) ||

+       (param_3 < *(ulonglong *)(param_1 + 0xb0))) ||

+      (uVar6 = *(longlong *)(param_1 + 0xc0) + param_3, uVar6 < *(ulonglong *)(param_1 + 0xb8))) ||

+     (uVar6 < *(ulonglong *)(param_1 + 0x240) >>

+              ((char)*(undefined4 *)(param_1 + 0x2b8) + 4U & 0x3f))) goto LAB_0;

+  uVar3 = RtlpCoalesceFreeBlocks(param_1,param_2,local_res18);

+  uVar6 = local_res18[0];

+  lVar11 = param_1;

+  if (*(byte *)(param_2 + 0xe) != 0) {

+    lVar11 = (param_2 & 0xffffffffffff0000) + (ulonglong)*(byte *)(param_2 + 0xe) * -0x10000 +

+             0x10000;

+  }

+  lVar9 = local_res18[0] * 0x10 + uVar3;

+  if (*(char *)(lVar9 + 0xf) == '\x03') {

+    RtlpRemoveUCRBlock();

+    local_48 = *(undefined8 *)(lVar9 + 0x38);

+    local_50 = *(undefined8 *)(lVar9 + 0x30);

+    *(int *)(lVar11 + 0x54) = *(int *)(lVar11 + 0x54) + -1;

+    *(int *)(lVar11 + 0x50) = *(int *)(lVar11 + 0x50) - (int)(*(ulonglong *)(lVar9 + 0x38) >> 0xc);

+    lVar5 = *(longlong *)(lVar9 + 0x38);

+    *(int *)(param_1 + 0x264) = *(int *)(param_1 + 0x264) + -1;

+    *(longlong *)(param_1 + 0x240) = lVar5 + *(longlong *)(param_1 + 0x240);

+    if (0xfefff < *(ulonglong *)(lVar9 + 0x38)) {

+      *(longlong *)(param_1 + 0x248) = *(longlong *)(param_1 + 0x248) - *(ulonglong *)(lVar9 + 0x38)

+      ;

+    }

+    local_res18[0] = uVar6 + 0x40 + (*(ulonglong *)(lVar9 + 0x38) >> 4);

+    bVar1 = true;

   }

   else {

-    lVar1 = *(longlong *)(*(longlong *)(unaff_RBP + 0x40) + 0x40);

-    if ((*(int *)(unaff_RBX + 0x7c) != 0) &&

-       (*(uint *)(lVar1 + 8) = *(uint *)(lVar1 + 8) ^ *(uint *)(unaff_RBX + 0x88),

-       *(byte *)(lVar1 + 0xb) !=

-       (byte)(*(byte *)(lVar1 + 10) ^ *(byte *)(lVar1 + 9) ^ *(byte *)(lVar1 + 8)))) {

-      RtlpAnalyzeHeapFailure();

-    }

-    uVar3 = *(undefined8 *)(*(longlong *)(unaff_RBP + 0x40) + 0x40);

-  }

-  return uVar3;

+    local_48 = 0;

+  }

+  param_3 = local_res18[0];

+  if (*(short *)(param_1 + 0x8c) == *(short *)(uVar3 + 0xc)) {

+    for (puVar4 = *(undefined8 **)(lVar11 + 0x60);

+        (puVar10 = puVar8, (undefined8 *)(lVar11 + 0x60) != puVar4 &&

+        (puVar10 = puVar4 + -2, puVar4[3] + puVar4[2] != uVar3)); puVar4 = (undefined8 *)*puVar4) {

+    }

+    local_58 = uVar3;

+    if ((0 < RtlpHeapErrorHandlerThreshold) && (puVar10 == (undefined8 *)0x0)) {

+                    /* WARNING: Subroutine does not return */

+      DbgPrint(&s__UCRBlock____NULL_);

+    }

+    lVar9 = local_res18[0] * 0x10;

+    if (!bVar1) {

+      lVar9 = lVar9 + -0x20;

+    }

+    local_res8 = (lVar9 + uVar3 & 0xfffffffffffff000) - uVar3;

+    if (local_res8 == 0) {

+      if ((0 < RtlpHeapErrorHandlerThreshold) && (bVar1)) {

+                    /* WARNING: Subroutine does not return */

+        DbgPrint(&s___TrailingUCR_);

+      }

+      goto LAB_0;

+    }

+    iVar2 = ZwFreeVirtualMemory(0xffffffffffffffff,&local_58,&local_res8,0x4000);

+    if (-1 < iVar2) {

+      *(int *)(param_1 + 0x26c) = *(int *)(param_1 + 0x26c) + 1;

+      uVar6 = puVar10[5];

+      if (0xfefff < uVar6) {

+        *(longlong *)(param_1 + 0x248) = *(longlong *)(param_1 + 0x248) - uVar6;

+      }

+      RtlpRemoveUCRBlock(uVar6,puVar10);

+      puVar10[5] = puVar10[5] + local_res8;

+      RtlpInsertUCRBlock(param_1,puVar10);

+      *(int *)(lVar11 + 0x50) = *(int *)(lVar11 + 0x50) + (int)(local_res8 >> 0xc);

+      *(ulonglong *)(param_1 + 0x240) = *(longlong *)(param_1 + 0x240) - local_res8;

+      if (0xfefff < (ulonglong)puVar10[5]) {

+        *(longlong *)(param_1 + 0x248) = *(longlong *)(param_1 + 0x248) + puVar10[5];

+      }

+      if (bVar1) {

+        return;

+      }

+      uVar6 = local_58 + local_res8;

+      *(undefined2 *)(uVar6 + 0xc) = *(undefined2 *)(param_1 + 0x8c);

+      if (param_3 * 0x10 + uVar3 == local_58 + local_res8) {

+        if (*(int *)(param_1 + 0x7c) == 0) {

+          return;

+        }

+        *(byte *)(uVar6 + 0xb) = *(byte *)(uVar6 + 10) ^ *(byte *)(uVar6 + 9) ^ *(byte *)(uVar6 + 8)

+        ;

+        *(uint *)(uVar6 + 8) = *(uint *)(uVar6 + 8) ^ *(uint *)(param_1 + 0x88);

+        return;

+      }

+      *(undefined1 *)(uVar6 + 0xf) = 0;

+      *(undefined1 *)(uVar6 + 10) = 0;

+      iVar2 = RtlpHeapErrorHandlerThreshold;

+      uVar7 = (ushort)(param_3 * 0x10 - local_res8 >> 4);

+      *(ushort *)(uVar6 + 8) = uVar7;

+      if ((0 < iVar2) && (uVar7 < 2)) {

+                    /* WARNING: Subroutine does not return */

+        DbgPrint("((LONG)FreeEntry->Size > 1)");

+      }

+      *(undefined1 *)(uVar6 + 0xb) = 0;

+      if (*(longlong *)(lVar11 + 0x28) != lVar11) {

+        uVar3 = (uVar6 - lVar11 >> 0x10) + 1;

+        if (0xfd < uVar3) {

+          RtlpLogHeapFailure(3,*(longlong *)(lVar11 + 0x28),uVar6,lVar11,0,0);

+        }

+        puVar8 = (undefined8 *)(uVar3 & 0xff);

+      }

+      param_3 = (ulonglong)*(ushort *)(uVar6 + 8);

+      *(char *)(uVar6 + 0xe) = (char)puVar8;

+      uVar3 = uVar6;

+      goto LAB_0;

+    }

+LAB_1:

+    RtlpUpdateHeapRates(param_1,3);

+    if (bVar1) {

+      RtlpCreateUCREntry();

+      param_3 = local_res18[0];

+    }

+  }

+  else {

+    local_58 = uVar3 + 0x103f & 0xfffffffffffff000;

+    if (local_58 == uVar3 + 0x50) {

+      local_58 = local_58 + 0x1000;

+    }

+    lVar5 = local_res18[0] * 0x10;

+    if (!bVar1) {

+      lVar5 = lVar5 + -0x20;

+    }

+    uVar6 = lVar5 + uVar3 & 0xfffffffffffff000;

+    if (uVar6 < local_58) {

+      if ((0 < RtlpHeapErrorHandlerThreshold) && (bVar1)) {

+                    /* WARNING: Subroutine does not return */

+        DbgPrint(&s___TrailingUCR_);

+      }

+      goto LAB_0;

+    }

+    local_res8 = uVar6 - local_58;

+    if (*(char *)(lVar9 + 0xf) == '\x03') {

+      if (local_res8 != 0) goto LAB_2;

+    }

+    else {

+      if ((local_res8 == 0) || (local_res8 < *(ulonglong *)(param_1 + 0xb0))) goto LAB_0;

+LAB_2:

+      *(int *)(param_1 + 0x26c) = *(int *)(param_1 + 0x26c) + 1;

+      iVar2 = ZwFreeVirtualMemory(0xffffffffffffffff,&local_58,&local_res8,0x4000);

+      if (iVar2 < 0) goto LAB_1;

+    }

+    if (!bVar1) {

+      lVar9 = local_res8 + local_58;

+      *(undefined2 *)(lVar9 + 0xc) = *(undefined2 *)(param_1 + 0x8c);

+      if (param_3 * 0x10 + uVar3 == local_58 + local_res8) {

+        if (*(int *)(param_1 + 0x7c) != 0) {

+          *(byte *)(lVar9 + 0xb) =

+               *(byte *)(lVar9 + 10) ^ *(byte *)(lVar9 + 9) ^ *(byte *)(lVar9 + 8);

+          *(uint *)(lVar9 + 8) = *(uint *)(lVar9 + 8) ^ *(uint *)(param_1 + 0x88);

+        }

+      }

+      else {

+        *(undefined1 *)(lVar9 + 0xf) = 0;

+        *(undefined1 *)(lVar9 + 10) = 0;

+        iVar2 = RtlpHeapErrorHandlerThreshold;

+        uVar7 = (ushort)(((param_3 * 0x10 - local_res8) - local_58) + uVar3 >> 4);

+        *(ushort *)(lVar9 + 8) = uVar7;

+        if ((0 < iVar2) && (uVar7 < 2)) {

+                    /* WARNING: Subroutine does not return */

+          DbgPrint("(LONG)FreeEntry->Size > 1");

+        }

+        *(undefined1 *)(lVar9 + 0xb) = 0;

+        if (*(longlong *)(lVar11 + 0x28) != lVar11) {

+          uVar6 = ((ulonglong)(lVar9 - lVar11) >> 0x10) + 1;

+          if (0xfd < uVar6) {

+            RtlpLogHeapFailure(3,*(longlong *)(lVar11 + 0x28),lVar9,lVar11,0,0);

+          }

+          puVar8 = (undefined8 *)(uVar6 & 0xff);

+        }

+        *(char *)(lVar9 + 0xe) = (char)puVar8;

+        RtlpInsertFreeBlock(param_1,lVar9,*(undefined2 *)(lVar9 + 8));

+      }

+    }

+    RtlpCreateUCREntry(param_1,lVar11,local_58 - 0x30,local_res8,uVar3,&local_40);

+    param_3 = local_40;

+  }

+LAB_0:

+  RtlpInsertFreeBlock(param_1,uVar3,param_3);

+  return;

 }
```

## `PopAdaptiveStandbySessionStart`  (modified)

```diff
--- PopAdaptiveStandbySessionStart
+++ PopAdaptiveStandbySessionStart
@@ -1,48 +1,158 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-undefined1 PopAdaptiveStandbySessionStart(undefined8 param_1)

+void PopAdaptiveStandbySessionStart(char *param_1,undefined4 param_2)

 

 {

-  undefined8 uVar1;

-  undefined1 unaff_BL;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  longlong unaff_R15;

-  byte bStack0000000000000031;

-  undefined4 uStack0000000000000040;

-  undefined4 uStack0000000000000044;

-  undefined4 uStack0000000000000048;

-  undefined4 uStack000000000000004c;

-  undefined4 uStack0000000000000050;

-  undefined4 uStack0000000000000054;

+  char cVar1;

+  int iVar2;

+  undefined4 uVar3;

+  undefined8 uVar4;

+  undefined4 uVar5;

+  undefined *puVar6;

+  ulonglong uVar7;

+  undefined1 auStack_158 [32];

+  undefined4 local_138;

+  undefined1 *local_130;

+  byte local_128 [4];

+  undefined4 local_124;

+  undefined4 local_120;

+  undefined4 local_11c;

+  undefined4 local_118;

+  undefined1 local_114 [4];

+  longlong local_110;

+  longlong local_108;

+  ulonglong local_100;

+  ulonglong local_f8 [2];

+  undefined1 local_e8 [32];

+  ulonglong *local_c8;

+  undefined8 local_c0;

+  undefined4 *local_b8;

+  undefined8 local_b0;

+  longlong *local_a8;

+  undefined8 local_a0;

+  byte *local_98;

+  undefined8 local_90;

+  byte *local_88;

+  undefined8 local_80;

+  undefined4 *local_78;

+  undefined8 local_70;

+  undefined4 *local_68;

+  undefined8 local_60;

+  undefined4 *local_58;

+  undefined8 local_50;

+  longlong *local_48;

+  undefined8 local_40;

+  ulonglong *local_38;

+  undefined8 local_30;

+  ulonglong local_28;

   

-  uStack0000000000000040 = *(undefined4 *)(unaff_RDI + 0x94);

-  *(undefined4 **)(unaff_RBP + 0xc0) = &stack0x00000040;

-  uStack0000000000000044 = *(undefined4 *)(unaff_R15 + 0x98);

-  *(undefined4 **)(unaff_RBP + 0xd0) = &stack0x00000044;

-  bStack0000000000000031 = *(byte *)(unaff_R15 + 0x9c) & (byte)param_1;

-  *(undefined8 *)(unaff_RBP + 200) = 4;

-  *(byte **)(unaff_RBP + 0xe0) = &stack0x00000031;

-  uStack0000000000000048 = *(undefined4 *)(unaff_R15 + 0xa0);

-  *(undefined4 **)(unaff_RBP + 0xf0) = &stack0x00000048;

-  uStack000000000000004c = *(undefined4 *)(unaff_R15 + 0xa4);

-  *(undefined4 **)(unaff_RBP + 0x100) = &stack0x0000004c;

-  uStack0000000000000050 = *(undefined4 *)(unaff_R15 + 0xa8);

-  *(undefined4 **)(unaff_RBP + 0x110) = &stack0x00000050;

-  uStack0000000000000054 = *(undefined4 *)(unaff_R15 + 0xac);

-  *(undefined4 **)(unaff_RBP + 0x120) = &stack0x00000054;

-  *(longlong *)(unaff_RBP + 0x130) = unaff_RBP + -0x70;

-  *(undefined8 *)(unaff_RBP + 0xd8) = 4;

-  *(undefined8 *)(unaff_RBP + 0xe8) = param_1;

-  *(undefined8 *)(unaff_RBP + 0xf8) = 4;

-  *(undefined8 *)(unaff_RBP + 0x108) = 4;

-  *(undefined8 *)(unaff_RBP + 0x118) = 4;

-  *(undefined8 *)(unaff_RBP + 0x128) = 4;

-  *(undefined8 *)(unaff_RBP + -0x70) = 0x1000000;

-  *(undefined8 *)(unaff_RBP + 0x138) = 8;

-  uVar1 = IoGetActivityIdThread();

-  _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e526,uVar1,0,0x1a);

-  return unaff_BL;

+  local_28 = __security_cookie ^ (ulonglong)auStack_158;

+  uVar7 = _DAT_0 / 10000000;

+  *(ulonglong *)(param_1 + 200) = uVar7;

+  *(undefined8 *)(param_1 + 0xd0) = _DAT_1;

+  *(undefined4 *)(param_1 + 0xb0) = *(undefined4 *)(param_1 + 0x88);

+  *(undefined4 *)(param_1 + 0xb4) = *(undefined4 *)(param_1 + 0x8c);

+  *(undefined4 *)(param_1 + 0xb8) = *(undefined4 *)(param_1 + 0x90);

+  *(undefined4 *)(param_1 + 0xbc) = *(undefined4 *)(param_1 + 0x94);

+  *(undefined4 *)(param_1 + 0xc0) = *(undefined4 *)(param_1 + 0x98);

+  iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  if (iVar2 == 0) {

+    PopAdaptiveStandbyQueryReserveConfiguration(param_1);

+    if (DAT_2 < 6) {

+      return;

+    }

+    cVar1 = _tlgKeywordOn(&DAT_2,0x400000000000);

+    if (cVar1 == '\0') {

+      return;

+    }

+    local_c8 = &local_100;

+    local_b8 = (undefined4 *)local_114;

+    local_108 = *(longlong *)(param_1 + 0xf0);

+    local_a8 = &local_108;

+    local_128[0] = param_1[0xb0] & 1;

+    local_c0 = 8;

+    local_98 = local_128;

+    local_118 = *(undefined4 *)(param_1 + 0xb4);

+    local_88 = (byte *)&local_118;

+    local_11c = *(undefined4 *)(param_1 + 0xb8);

+    local_78 = &local_11c;

+    local_120 = *(undefined4 *)(param_1 + 0xbc);

+    local_68 = &local_120;

+    local_124 = *(undefined4 *)(param_1 + 0xc0);

+    local_58 = &local_124;

+    local_48 = &local_110;

+    local_b0 = 4;

+    local_a0 = 8;

+    local_90 = 1;

+    local_80 = 4;

+    local_70 = 4;

+    local_60 = 4;

+    local_50 = 4;

+    local_110 = 0x1000000;

+    local_40 = 8;

+    local_114 = (undefined1  [4])param_2;

+    local_100 = uVar7;

+    uVar4 = IoGetActivityIdThread();

+    puVar6 = &DAT_3;

+    local_138 = 0xb;

+  }

+  else {

+    uVar5 = *(undefined4 *)(param_1 + 0x98);

+    uVar3 = PopAdaptiveStandbyCalculateBatteryRegion();

+    *(undefined4 *)(param_1 + 0xd8) = uVar3;

+    *(undefined8 *)(param_1 + 0xe0) = *(undefined8 *)(param_1 + 200);

+    *(undefined4 *)(param_1 + 0xe8) = uVar5;

+    if (*param_1 != '\0') {

+      PopAdaptiveStandbyHandleBatteryUpdate(param_1,0);

+    }

+    if (DAT_2 < 6) {

+      return;

+    }

+    cVar1 = _tlgKeywordOn(&DAT_2,0x400000000000);

+    if (cVar1 == '\0') {

+      return;

+    }

+    local_110 = *(longlong *)(param_1 + 0xf0);

+    local_c8 = local_f8;

+    local_b8 = &local_124;

+    local_a8 = &local_110;

+    local_98 = (byte *)&local_108;

+    local_108 = local_110 + -1;

+    if (*(int *)(param_1 + 0xf8) != 2) {

+      local_108 = local_110;

+    }

+    local_128[0] = param_1[0xb0] & 1;

+    local_c0 = 8;

+    local_88 = local_128;

+    local_120 = *(undefined4 *)(param_1 + 0xb4);

+    local_78 = &local_120;

+    local_11c = *(undefined4 *)(param_1 + 0xb8);

+    local_68 = &local_11c;

+    local_118 = *(undefined4 *)(param_1 + 0xbc);

+    local_58 = &local_118;

+    local_114 = *(undefined1 (*) [4])(param_1 + 0xc0);

+    local_48 = (longlong *)local_114;

+    local_38 = &local_100;

+    local_b0 = 4;

+    local_a0 = 8;

+    local_90 = 8;

+    local_80 = 1;

+    local_70 = 4;

+    local_60 = 4;

+    local_50 = 4;

+    local_40 = 4;

+    local_100 = 0x1000000;

+    local_30 = 8;

+    local_124 = param_2;

+    local_f8[0] = uVar7;

+    uVar4 = IoGetActivityIdThread();

+    puVar6 = &DAT_4;

+    local_138 = 0xc;

+  }

+  local_130 = local_e8;

+  _tlgWriteTransfer_EtwWriteTransfer(&DAT_2,puVar6,uVar4,0);

+  return;

 }
```

## `PopIdleGlobalUserPresenceCallback`  (modified)

```diff
--- PopIdleGlobalUserPresenceCallback
+++ PopIdleGlobalUserPresenceCallback
@@ -1,158 +1,25 @@
 

-/* WARNING: Instruction at (ram,0x000140ac6b64) overlaps instruction at (ram,0x000140ac6b5f)

-    */

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

-

-void PopIdleGlobalUserPresenceCallback

-               (undefined8 *param_1,char *param_2,ulonglong param_3,undefined4 param_4)

+undefined8 PopIdleGlobalUserPresenceCallback(longlong *param_1,int *param_2,int param_3)

 

 {

-  int *piVar1;

-  int iVar2;

-  uint uVar3;

-  undefined4 uVar4;

-  uint uVar5;

-  byte bVar6;

-  undefined4 uVar7;

-  longlong in_RAX;

-  undefined1 *puVar8;

-  char *pcVar9;

-  char unaff_BL;

-  undefined8 *unaff_RBP;

-  byte unaff_DIL;

-  ulonglong uVar10;

-  undefined4 in_R10D;

-  char *in_R11;

-  undefined8 unaff_R12;

-  int unaff_R13D;

-  char unaff_R14B;

-  undefined4 unaff_R15D;

-  undefined8 in_stack_00000020;

-  undefined8 in_stack_00000050;

-  uint uStack000000000000005c;

-  uint uStack0000000000000064;

-  undefined4 in_stack_00000070;

+  int iVar1;

+  longlong lVar2;

   

-  uVar7 = (undefined4)((ulonglong)in_stack_00000020 >> 0x20);

-  *(char *)(in_RAX + 0xf) = *(char *)(in_RAX + 0xf) + (char)param_1;

-  bVar6 = (byte)in_RAX >> 1;

-  pcVar9 = (char *)CONCAT71((int7)((ulonglong)in_RAX >> 8),bVar6);

-  if ((POPCOUNT(bVar6) & 1U) == 0) {

-    *pcVar9 = *pcVar9 + bVar6;

+  lVar2 = *param_1 + -0x4344b427786e8a1d;

+  if (lVar2 == 0) {

+    lVar2 = param_1[1] + 0x564123f418f6f86e;

   }

-  else {

-    piVar1 = (int *)((longlong)param_1 + -10);

-    *piVar1 = *piVar1 + 1;

-    iVar2 = *piVar1;

-    *param_2 = *param_2;

-    puVar8 = (undefined1 *)0x40af2440;

-    in_R11 = "-";

-    if (iVar2 == 0) {

-      puVar8 = &s__;

+  if (((lVar2 == 0) && (param_2 != (int *)0x0)) && (param_3 == 4)) {

+    iVar1 = *param_2;

+    PopAcquirePolicyLock();

+    if (iVar1 == 0) {

+      PopIdleCancelAoAcDozeS4Timer(2);

+      DAT_0 = 0;

+      DAT_1 = 0;

+      PopSmartSuspendValidatePredictions();

     }

-    _tlgCreate1Sz_char(unaff_RBP + 0x38,puVar8);

-    pcVar9 = "Battery Charging";

-    if ((unaff_DIL & (byte)param_3) == 0) {

-      pcVar9 = in_R11;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x3a,pcVar9);

-    param_1 = unaff_RBP + 0x3c;

-    param_2 = "Battery Critical";

-    if ((byte)((byte)unaff_R15D & (byte)param_3) == 0) {

-      param_2 = in_R11;

-    }

+    PopReleasePolicyLock();

   }

-  _tlgCreate1Sz_char(param_1,param_2);

-  pcVar9 = "Battery charge limiting mode";

-  if ((param_3 & 0x10) == 0) {

-    pcVar9 = in_R11;

-  }

-  _tlgCreate1Sz_char(unaff_RBP + 0x3e,pcVar9);

-  pcVar9 = "Battery charging state power supply present";

-  if ((param_3 & 0x20) == 0) {

-    pcVar9 = in_R11;

-  }

-  _tlgCreate1Sz_char(unaff_RBP + 0x40,pcVar9);

-  pcVar9 = "Battery charging state adequate";

-  if ((param_3 & 0x40) == 0) {

-    pcVar9 = in_R11;

-  }

-  _tlgCreate1Sz_char(unaff_RBP + 0x42,pcVar9);

-  pcVar9 = "Battery trip point supported";

-  if ((param_3 & 0x80) == 0) {

-    pcVar9 = in_R11;

-  }

-  _tlgCreate1Sz_char(unaff_RBP + 0x44,pcVar9);

-  _tlgCreate1Sz_char(unaff_RBP + 0x46);

-  uVar5 = DAT_0;

-  uVar10 = (ulonglong)DAT_0;

-  uStack000000000000005c = (uint)unaff_R12;

-  uStack0000000000000064 = uStack000000000000005c;

-  if (DAT_0 != 0) {

-    uStack0000000000000064 = (DAT_1 * 100 + (DAT_140f0b3b8 >> 1)) / DAT_140f0b3b8;

-  }

-  unaff_RBP[0x48] = &stack0x00000064;

-  unaff_RBP[0x49] = 4;

-  if (uVar5 != 0) {

-    uStack000000000000005c = (uint)(((ulonglong)DAT_1 * 100000) / uVar10);

-  }

-  uVar3 = _DAT_2 & 0x40000000;

-  pcVar9 = "Relative Capacity Unit";

-  unaff_RBP[0x4b] = 4;

-  unaff_RBP[0x4a] = &stack0x0000005c;

-  *(uint *)(unaff_RBP + 1) = DAT_1;

-  unaff_RBP[0x4c] = unaff_RBP + 1;

-  unaff_RBP[0x4e] = (longlong)unaff_RBP + -0x14;

-  *(undefined4 *)((longlong)unaff_RBP + -0x24) = DAT_3;

-  unaff_RBP[0x50] = (longlong)unaff_RBP + -0x24;

-  *(undefined4 *)(unaff_RBP + -4) = DAT_4;

-  unaff_RBP[0x52] = unaff_RBP + -4;

-  *(undefined4 *)((longlong)unaff_RBP + -0x1c) = DAT_5;

-  unaff_RBP[0x54] = (longlong)unaff_RBP + -0x1c;

-  unaff_RBP[0x56] = unaff_RBP + -3;

-  if (uVar3 == 0) {

-    pcVar9 = "mWh Unit";

-  }

-  unaff_RBP[0x4d] = 4;

-  *(uint *)((longlong)unaff_RBP + -0x14) = uVar5;

-  unaff_RBP[0x4f] = 4;

-  unaff_RBP[0x51] = 4;

-  unaff_RBP[0x53] = 4;

-  unaff_RBP[0x55] = 4;

-  *(undefined4 *)(unaff_RBP + -3) = in_R10D;

-  unaff_RBP[0x57] = 4;

-  _tlgCreate1Sz_char(unaff_RBP + 0x58,pcVar9);

-  uVar4 = DAT_6;

-  unaff_RBP[0x5a] = unaff_RBP + -0xe;

-  *(undefined4 *)(unaff_RBP + -0xe) = uVar4;

-  unaff_RBP[0x5c] = &stack0x00000070;

-  unaff_RBP[0x5b] = 4;

-  unaff_RBP[0x5d] = 4;

-  in_stack_00000070 = param_4;

-  _tlgWriteTransfer_EtwWriteTransfer(&DAT_7,&DAT_14004cb2a,0,0,CONCAT44(uVar7,0x17));

-  if (in_stack_00000050._4_4_ == unaff_R13D) {

-    if (unaff_R14B == '\0') {

-      unaff_RBP[2] = _DAT_8;

-    }

-    else {

-      unaff_RBP[2] = unaff_R12;

-    }

-    ZwUpdateWnfStateData(&WNF_PO_DISCHARGE_START_FILETIME,unaff_RBP + 2,unaff_R15D,0);

-  }

-  if (unaff_BL != '\0') {

-    *unaff_RBP = unaff_R12;

-    *(undefined4 *)((longlong)unaff_RBP + 4) = 0xffffffff;

-    uVar7 = ZwUpdateWnfStateData(&WNF_PO_POWER_STATE_CHANGE);

-    if (5 < DAT_7) {

-      unaff_RBP[0x77] = 4;

-      unaff_RBP[0x76] = &stack0x00000070;

-      in_stack_00000070 = uVar7;

-      _tlgWriteTransfer_EtwWriteTransfer(&DAT_7,&DAT_14004caf6,0,0,3);

-    }

-  }

-  PopReleaseRwLock(&PopCB);

-  PopReleaseRwLock(&PopPolicyDeviceLock);

-  return;

+  return 0;

 }
```

## `PspDeleteCreateProcessContext`  (modified)

```diff
--- PspDeleteCreateProcessContext
+++ PspDeleteCreateProcessContext
@@ -1,10 +1,93 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void PspDeleteCreateProcessContext(void)

+void PspDeleteCreateProcessContext(longlong param_1)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong lVar1;

+  int iVar2;

+  longlong lVar3;

+  ulonglong uVar4;

+  

+  if (*(longlong *)(param_1 + 0xb0) != 0) {

+    ObCloseHandle();

+  }

+  if (*(longlong *)(param_1 + 0xb8) != 0) {

+    ObfDereferenceObject();

+  }

+  if (*(longlong *)(param_1 + 0xa0) != 0) {

+    ObfDereferenceObject();

+  }

+  if (*(longlong *)(param_1 + 0x88) != 0) {

+    ObfDereferenceObjectWithTag();

+  }

+  if (*(longlong *)(param_1 + 0xc0) != 0) {

+    ObCloseHandle();

+  }

+  if (*(longlong *)(param_1 + 200) != 0) {

+    ObCloseHandle();

+  }

+  if (*(longlong *)(param_1 + 0xd0) != 0) {

+    ObfDereferenceObject();

+  }

+  if ((*(byte *)(param_1 + 0x10) & 4) != 0) {

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0xd8));

+  }

+  if ((*(longlong *)(param_1 + 0x118) != 0) && (*(longlong *)(param_1 + 0x118) != param_1 + 0x108))

+  {

+    ExFreePoolWithTag();

+  }

+  if (*(longlong *)(param_1 + 0x128) != 0) {

+    ExFreePoolWithTag();

+  }

+  if (*(longlong *)(param_1 + 0x170) != 0) {

+    uVar4 = 0;

+    if (*(int *)(param_1 + 0x17c) != 0) {

+      do {

+        lVar1 = *(longlong *)(*(longlong *)(param_1 + 0x170) + uVar4 * 8);

+        if (lVar1 != 0) {

+          ObfDereferenceObjectWithTag(lVar1,0x6c4a7350);

+        }

+        uVar4 = uVar4 + 1;

+      } while (uVar4 < *(uint *)(param_1 + 0x17c));

+    }

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0x170));

+  }

+  if (*(void **)(param_1 + 0x168) != (void *)0x0) {

+    memset(*(void **)(param_1 + 0x168),0,(ulonglong)*(uint *)(param_1 + 0x178));

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0x168));

+  }

+  if (*(void **)(param_1 + 400) != (void *)0x0) {

+    memset(*(void **)(param_1 + 400),0,(ulonglong)*(uint *)(param_1 + 0x18c));

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 400),0);

+  }

+  lVar1 = *(longlong *)(param_1 + 0x198);

+  if (lVar1 != 0) {

+    lVar3 = *(longlong *)(lVar1 + 8);

+    if ((lVar3 != 0) || (lVar3 = *(longlong *)(lVar1 + 0x18), lVar3 != 0)) {

+      ExFreePoolWithTag(lVar3,0);

+    }

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0x198),0);

+  }

+  if (*(longlong *)(param_1 + 0x1b0) != 0) {

+    ExFreePoolWithTag(*(longlong *)(param_1 + 0x1b0),0);

+    *(undefined8 *)(param_1 + 0x1b0) = 0;

+  }

+  iVar2 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar2 != 0) && (*(longlong *)(param_1 + 0x1f8) != 0)) {

+    lVar1 = *(longlong *)(*(longlong *)(param_1 + 0x1f8) + 0x10);

+    if (lVar1 != 0) {

+      ExFreePoolWithTag(lVar1,0);

+    }

+    lVar1 = *(longlong *)(*(longlong *)(param_1 + 0x1f8) + 0x18);

+    if (lVar1 != 0) {

+      SeReleaseSidAndAttributesArray(lVar1,*(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232));

+    }

+    if (*(longlong *)(param_1 + 0x200) != 0) {

+      ExFreePoolWithTag(*(longlong *)(param_1 + 0x200),0);

+    }

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0x1f8),0);

+  }

+  RtlFreeAnsiString(param_1 + 0xf0);

+  PspDestroyProcessParameterOverrides(*(undefined8 *)(param_1 + 0x1d8));

+  return;

 }
```

## `PpmHeteroHgsRegisterContainmentGroups`  (modified)

```diff
--- PpmHeteroHgsRegisterContainmentGroups
+++ PpmHeteroHgsRegisterContainmentGroups
@@ -1,48 +1,99 @@
 

-undefined4 PpmHeteroHgsRegisterContainmentGroups(void)

+void PpmHeteroHgsRegisterContainmentGroups(longlong param_1,longlong param_2)

 

 {

-  int iVar1;

-  uint uVar2;

-  longlong lVar3;

-  int in_EAX;

-  undefined4 *puVar4;

-  undefined4 unaff_EBP;

-  longlong unaff_RDI;

-  undefined4 unaff_R14D;

+  undefined4 uVar1;

+  int iVar2;

+  int *piVar3;

+  longlong lVar4;

+  int *piVar5;

+  longlong lVar6;

+  longlong lVar7;

+  int iVar8;

+  undefined4 local_res20 [2];

   

-  uVar2 = in_EAX * 2;

-  *(char *)(ulonglong)uVar2 = *(char *)(ulonglong)uVar2 + (char)uVar2;

-  puVar4 = (undefined4 *)ExAllocatePool2(unaff_R14D);

-  *(undefined4 **)(unaff_RDI + 0x8a50) = puVar4;

-  lVar3 = PpmHeteroCapability;

-  if (puVar4 != (undefined4 *)0x0) {

-    *puVar4 = *(undefined4 *)(PpmHeteroCapability + 4);

-    iVar1 = *(int *)(lVar3 + 4) * 8 + 8;

-    puVar4 = (undefined4 *)ExAllocatePool2(unaff_R14D,iVar1,unaff_EBP);

-    *(undefined4 **)(unaff_RDI + 0x8a58) = puVar4;

-    if (puVar4 != (undefined4 *)0x0) {

-      *puVar4 = *(undefined4 *)(PpmHeteroCapability + 4);

-      puVar4 = (undefined4 *)ExAllocatePool2(unaff_R14D,iVar1,unaff_EBP);

-      *(undefined4 **)(unaff_RDI + 0x8a60) = puVar4;

-      if (puVar4 != (undefined4 *)0x0) {

-        *puVar4 = *(undefined4 *)(PpmHeteroCapability + 4);

-        return 0;

+  local_res20[0] = 0;

+  piVar3 = (int *)ExAllocatePool2(0x40,0x340,0x704d5050);

+  if (piVar3 != (int *)0x0) {

+    lVar7 = 0;

+    iVar8 = 0;

+    lVar6 = 8;

+    do {

+      *(undefined8 *)(lVar7 + 0x10 + (longlong)piVar3) = 0x200001;

+      memset((void *)((longlong)piVar3 + lVar7 + 0x18),0,0x100);

+      iVar2 = Feature_PpmParkEx__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 == 0) {

+        iVar2 = KeEnumerateNextProcessor(local_res20);

+        uVar1 = local_res20[0];

+        while (local_res20[0] = uVar1, iVar2 == 0) {

+          lVar4 = KeGetPrcb(uVar1);

+          if (iVar8 == 0) {

+            if (*(char *)(lVar4 + 0x8a68) == '\0') {

+              piVar5 = piVar3 + 4;

+              goto LAB_0;

+            }

+          }

+          else if (iVar8 == 1) {

+            if (*(char *)(lVar4 + 0x8a68) == '\x01') {

+              piVar5 = piVar3 + 0x46;

+              goto LAB_0;

+            }

+          }

+          else if (iVar8 == 2) {

+            piVar5 = piVar3 + 0x88;

+LAB_0:

+            *(short *)(lVar6 + (longlong)piVar3) = *(short *)(lVar6 + (longlong)piVar3) + 1;

+            KeAddProcessorAffinityEx(piVar5,uVar1);

+          }

+          iVar2 = KeEnumerateNextProcessor(local_res20);

+          uVar1 = local_res20[0];

+        }

       }

+      else {

+        iVar2 = KeEnumerateNextProcessor(local_res20);

+        uVar1 = local_res20[0];

+        while (local_res20[0] = uVar1, iVar2 == 0) {

+          lVar4 = KeGetPrcb(uVar1);

+          if (iVar8 == 0) {

+            if (*(char *)(lVar4 + 0x8a68) == '\0') {

+              piVar5 = piVar3 + 4;

+              goto LAB_1;

+            }

+          }

+          else if (iVar8 == 1) {

+            if (*(char *)(lVar4 + 0x8a68) == '\x01') {

+              piVar5 = piVar3 + 0x46;

+              goto LAB_1;

+            }

+          }

+          else if (iVar8 == 2) {

+            piVar5 = piVar3 + 0x88;

+LAB_1:

+            *(short *)(lVar6 + (longlong)piVar3) = *(short *)(lVar6 + (longlong)piVar3) + 1;

+            KeAddProcessorAffinityEx(piVar5,uVar1);

+          }

+          iVar2 = KeEnumerateNextProcessor(local_res20);

+          uVar1 = local_res20[0];

+        }

+      }

+      if (*(short *)(lVar6 + (longlong)piVar3) != 0) {

+        *piVar3 = *piVar3 + 1;

+      }

+      iVar8 = iVar8 + 1;

+      lVar7 = lVar7 + 0x108;

+      lVar6 = lVar6 + 2;

+    } while (iVar8 < 3);

+    piVar3[1] = 2;

+    if ((param_2 != 0) && (*(longlong *)(param_2 + 0x4f8) != 0)) {

+      piVar3[0xcb] = *(int *)(*(longlong *)(param_2 + 0x4f8) + 0x32c);

+      *(undefined1 *)(piVar3 + 0xca) = *(undefined1 *)(*(longlong *)(param_2 + 0x4f8) + 0x328);

+      *(undefined1 *)((longlong)piVar3 + 0x33b) =

+           *(undefined1 *)(*(longlong *)(param_2 + 0x4f8) + 0x33b);

     }

+    PpmHeteroHgsContainmentState = PpmHeteroHgsContainmentState | 4;

+    *(int **)(param_1 + 0x4f8) = piVar3;

+    PpmEventHgsContainmentGroupInfo(param_1,0);

   }

-  if (*(longlong *)(unaff_RDI + 0x8a50) != 0) {

-    ExFreePoolWithTag(*(longlong *)(unaff_RDI + 0x8a50),unaff_EBP);

-    *(undefined8 *)(unaff_RDI + 0x8a50) = 0;

-  }

-  if (*(longlong *)(unaff_RDI + 0x8a58) != 0) {

-    ExFreePoolWithTag(*(longlong *)(unaff_RDI + 0x8a58),unaff_EBP);

-    *(undefined8 *)(unaff_RDI + 0x8a58) = 0;

-  }

-  if (*(longlong *)(unaff_RDI + 0x8a60) != 0) {

-    ExFreePoolWithTag(*(longlong *)(unaff_RDI + 0x8a60),unaff_EBP);

-    *(undefined8 *)(unaff_RDI + 0x8a60) = 0;

-  }

-  return 0xc000009a;

+  return;

 }
```

## `KiApplyProcessorErrata`  (modified)

```diff
--- KiApplyProcessorErrata
+++ KiApplyProcessorErrata
@@ -1,42 +1,30 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

-

-undefined1 KiApplyProcessorErrata(undefined8 param_1,undefined1 *param_2)

+void KiApplyProcessorErrata(longlong param_1)

 

 {

-  int *piVar1;

-  ulonglong in_RAX;

-  longlong lVar2;

-  longlong unaff_RBX;

-  undefined4 unaff_R14D;

+  ulonglong uVar1;

+  char cVar2;

   

-  *param_2 = (char)(in_RAX >> 8);

-  lVar2 = CONCAT71((int7)(in_RAX >> 8),*(undefined1 *)(unaff_RBX + (in_RAX & 0xff)));

-  piVar1 = (int *)(lVar2 + -0x73);

-  *piVar1 = *piVar1 + -1;

-  _DAT_0 = (ulonglong)((int)lVar2 + 0x952601);

-  _DAT_1 = (undefined4)unaff_RBX;

-  _DAT_2 = (undefined2)unaff_R14D;

-  DAT_3 = 6;

-  _KiUserCodePatchMutex = unaff_R14D;

-  _DAT_4 = unaff_RBX;

-  _DAT_5 = _DAT_140f0fd10;

-  _DAT_6 = _DAT_140f0fd20;

-  memset(&KiAltContextWorkQueue,0,0x80);

-  _DAT_7 = &KiAltContextWorkQueue;

-  _DAT_8 = KiAltReturnDpcRoutine;

-  _KiAltContextWorkQueue = &KiAltContextWorkQueue;

-  _DAT_9 = KiAltReturnWorkerRoutine;

-  _DAT_10 = KiAltContextProcessMcheckAltReturn;

-  _DAT_11 = unaff_RBX;

-  _DAT_12 = 0x113;

-  _DAT_13 = &KiAltContextWorkQueue;

-  _DAT_14 = unaff_RBX;

-  _DAT_15 = unaff_RBX;

-  _DAT_16 = &KiAltContextWorkQueue;

-  _DAT_17 = unaff_RBX;

-  KiAltReturnInitialized = (char)unaff_R14D;

-  return (char)unaff_R14D;

+  if (*(char *)(param_1 + 0x8d) == '\x01') {

+    if (('\x0f' < *(char *)(param_1 + 0x40)) && (*(char *)(param_1 + 0x40) != '\x11')) {

+      cVar2 = HviIsAnyHypervisorPresent();

+      if (cVar2 == '\0') {

+        uVar1 = rdmsr(0xc0011029);

+        wrmsr(0xc0011029,uVar1 & 0xffffffff00000000 | uVar1 & 0xffffffff | 2);

+      }

+    }

+    if ((*(char *)(param_1 + 0x8d) == '\x01') && (*(char *)(param_1 + 0x40) == '\x17')) {

+      if (((byte)(*(byte *)(param_1 + 0x43) - 0x30) < 0x20) || (0x5f < *(byte *)(param_1 + 0x43))) {

+        cVar2 = HviIsAnyHypervisorPresent();

+        if (cVar2 == '\0') {

+          uVar1 = rdmsr(0xc00110e3);

+          wrmsr(0xc00110e3,uVar1 & 0xffffffff00000000 | uVar1 & 0xffffffff | 2);

+          uVar1 = rdmsr(0xc001102e);

+          wrmsr(0xc001102e,uVar1 & 0xffffffff00000000 | 0x200000000 | uVar1 & 0xffffffff);

+        }

+      }

+    }

+  }

+  return;

 }
```

## `PspUnlockJobsAndProcessExclusive`  (modified)

```diff
--- PspUnlockJobsAndProcessExclusive
+++ PspUnlockJobsAndProcessExclusive
@@ -1,10 +1,40 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void PspUnlockJobsAndProcessExclusive(void)

+void PspUnlockJobsAndProcessExclusive(uint *param_1,longlong param_2,longlong param_3)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  short *psVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  uint uVar4;

+  

+  uVar4 = *param_1;

+  while (uVar4 != 0) {

+    uVar4 = uVar4 - 1;

+    if ((char)param_1[(ulonglong)uVar4 * 4 + 4] == '\0') {

+      ExReleaseResourceLite(*(longlong *)(param_1 + (ulonglong)uVar4 * 4 + 2) + 0x38);

+    }

+    else {

+      PspUnlockJobChain(*(longlong *)(param_1 + (ulonglong)uVar4 * 4 + 2),0);

+    }

+  }

+  if (param_2 != 0) {

+    plVar2 = (longlong *)(param_2 + 0x1c8);

+    LOCK();

+    lVar3 = *plVar2;

+    *plVar2 = *plVar2 + -1;

+    UNLOCK();

+    if (((byte)lVar3 & 6) == 2) {

+      ExfTryToWakePushLock(plVar2);

+      FUN_140b0ffd4();

+      return;

+    }

+    KeAbPostRelease(plVar2);

+  }

+  psVar1 = (short *)(param_3 + 0x1e6);

+  *psVar1 = *psVar1 + 1;

+  if ((*psVar1 == 0) && (*(longlong **)(param_3 + 0x98) != (longlong *)(param_3 + 0x98))) {

+    KiCheckForKernelApcDelivery();

+  }

+  return;

 }
```

## `EtwpTraceThreadRundownWithStack`  (modified)

```diff
--- EtwpTraceThreadRundownWithStack
+++ EtwpTraceThreadRundownWithStack
@@ -1,88 +1,96 @@
 

-/* WARNING: Removing unreachable block (ram,0x00014064e09d) */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-undefined8

-EtwpTraceThreadRundownWithStack(ulonglong param_1,undefined8 *param_2,undefined8 *param_3)

+void EtwpTraceThreadRundownWithStack(void *param_1,longlong param_2)

 

 {

-  byte bVar1;

-  undefined8 in_RAX;

-  ulonglong uVar2;

-  longlong lVar3;

-  int unaff_EBX;

-  longlong unaff_RBP;

-  ulonglong uVar4;

-  undefined8 *unaff_RSI;

-  uint uVar5;

-  undefined8 *puVar6;

-  ulonglong unaff_R12;

-  undefined1 unaff_R15B;

-  bool bVar7;

-  byte bStack0000000000000069;

-  byte bStack000000000000006a;

-  byte bStack000000000000006b;

-  byte bStack000000000000006c;

-  byte bStack000000000000006d;

-  byte bStack000000000000006e;

-  byte bStack000000000000006f;

+  uint uVar1;

+  char cVar2;

+  int iVar3;

+  int iVar4;

+  undefined4 uVar5;

+  undefined1 auStack_108 [32];

+  longlong *local_e8;

+  undefined8 local_e0;

+  undefined1 local_d8;

+  undefined8 local_d0;

+  undefined8 local_c8;

+  undefined8 **ppuStack_c0;

+  undefined8 **local_b8;

+  longlong local_b0;

+  undefined1 local_a8 [96];

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 *local_38;

+  undefined8 local_30;

+  ulonglong local_28;

   

-  if (param_2 < param_3) {

-    param_1 = unaff_R12;

-  }

-  puVar6 = param_3;

-  if (param_1 != 0) {

-    for (; param_1 != 0; param_1 = param_1 - 1) {

-      *puVar6 = in_RAX;

-      puVar6 = puVar6 + 1;

+  local_28 = __security_cookie ^ (ulonglong)auStack_108;

+  memset(local_a8,0,0x58);

+  local_b8 = (undefined8 ***)0x0;

+  local_c8 = 0;

+  ppuStack_c0 = (undefined8 ***)0x0;

+  local_b0 = 0;

+  iVar4 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  if (((param_1 != SystemReserved1[0xf]) && ((*(byte *)((longlong)param_1 + 0x5a8) & 4) == 0)) &&

+     (*(char *)(param_2 + 0x43) == '\0')) {

+    local_d0 = 0;

+    local_b8 = &ppuStack_c0;

+    ppuStack_c0 = &ppuStack_c0;

+    local_d8 = 0;

+    local_e0 = 0;

+    local_c8 = 0x60001;

+    local_e8 = (longlong *)0x0;

+    KeInitializeApc(local_a8,param_1,0,EtwpThreadRundownApc);

+    iVar3 = Feature_EtwThreadStackRundownPriority__private_IsEnabledDeviceUsageNoInline();

+    if (iVar3 != 0) {

+      *(undefined4 *)(param_2 + 0x48) = 0;

+      *(undefined1 *)(param_2 + 0x4c) = 0;

+      iVar4 = KeQueryPriorityThread(SystemReserved1[0xf]);

+      iVar3 = KeQueryPriorityThread(param_1);

+      *(int *)(param_2 + 0x48) = iVar3;

+      if (iVar3 < iVar4) {

+        *(undefined1 *)(param_2 + 0x4c) = 1;

+        uVar5 = KeSetPriorityThread(param_1,iVar4);

+        *(undefined4 *)(param_2 + 0x48) = uVar5;

+      }

+    }

+    cVar2 = KeInsertQueueApc(local_a8,&local_c8,param_2,0);

+    if (cVar2 != '\0') {

+      local_b0 = (ulonglong)EtwpStackCaptureTimeout * -10000;

+      local_e8 = &local_b0;

+      iVar3 = KeWaitForMutexObject(&local_c8,7,0);

+      if (iVar3 != 0x102) {

+        return;

+      }

+      cVar2 = KeRemoveQueueApc(local_a8);

+      if (cVar2 == '\0') {

+        local_e8 = (longlong *)0x0;

+        KeWaitForMutexObject(&local_c8,7,0);

+        return;

+      }

+      iVar3 = Feature_EtwThreadStackRundownPriority__private_IsEnabledDeviceUsageNoInline();

+      if (iVar3 != 0) {

+        if (*(char *)(param_2 + 0x4c) != '\0') {

+          KeSetPriorityThread(param_1,*(undefined4 *)(param_2 + 0x48));

+        }

+        local_48 = CONCAT44(*(undefined4 *)((longlong)param_1 + 0x508),

+                            *(undefined4 *)((longlong)param_1 + 0x510));

+        uVar1 = *(uint *)(param_2 + 0x48);

+        uStack_40 = (ulonglong)uVar1;

+        if (*(char *)(param_2 + 0x4c) != '\0') {

+          uStack_40 = CONCAT44(iVar4 - uVar1,uVar1);

+        }

+        local_30 = 0x10;

+        local_38 = &local_48;

+        local_e8 = (longlong *)CONCAT44(local_e8._4_4_,0x100);

+        EtwTraceKernelEvent(&local_38,1,2,0x568);

+      }

     }

   }

-  uVar4 = unaff_R12 & 0xffffffff;

-  bVar1 = (byte)DAT_0;

-  if ((DAT_0 & 0xffffffe0) != 0) {

-    do {

-      lVar3 = (longlong)DAT_1;

-      while (puVar6 = *(undefined8 **)(lVar3 + uVar4 * 8), ((ulonglong)puVar6 & 1) == 0) {

-        *(undefined8 *)(lVar3 + uVar4 * 8) = *puVar6;

-        uVar2 = puVar6[1] & unaff_RBP << (bVar1 & 0x1f);

-        bStack0000000000000069 = (byte)(uVar2 >> 8);

-        bStack000000000000006a = (byte)(uVar2 >> 0x10);

-        bStack000000000000006b = (byte)(uVar2 >> 0x18);

-        bStack000000000000006c = (byte)(uVar2 >> 0x20);

-        bStack000000000000006d = (byte)(uVar2 >> 0x28);

-        bStack000000000000006e = (byte)(uVar2 >> 0x30);

-        bStack000000000000006f = (byte)(uVar2 >> 0x38);

-        uVar5 = unaff_EBX - 1U &

-                (uint)bStack000000000000006f +

-                (((((((((uint)uVar2 & 0xff) + 0xb15dcb) * 0x25 + (uint)bStack0000000000000069) *

-                     0x25 + (uint)bStack000000000000006a) * 0x25 + (uint)bStack000000000000006b) *

-                   0x25 + (uint)bStack000000000000006c) * 0x25 + (uint)bStack000000000000006d) *

-                 0x25 + (uint)bStack000000000000006e) * 0x25;

-        *puVar6 = param_3[uVar5];

-        param_3[uVar5] = puVar6;

-      }

-      uVar5 = (int)uVar4 + 1;

-      uVar4 = (ulonglong)uVar5;

-    } while (uVar5 < DAT_0 >> 5);

-  }

-  lVar3 = (longlong)DAT_1;

-  DAT_0 = DAT_0 & 0x1f | unaff_EBX << 5;

-  bVar7 = DAT_1 != (undefined8 *)0x0;

-  DAT_1 = param_3;

-  if (bVar7) {

-    ExFreePoolWithTag(lVar3,0x42777445);

-  }

-  puVar6 = DAT_1;

-  uVar4 = unaff_RBP << ((byte)DAT_0 & 0x1f) & unaff_RSI[1];

-  bStack000000000000006f = (byte)(uVar4 >> 0x38);

-  lVar3 = ((((((((uVar4 & 0xff) + 0xb15dcb) * 0x25 + (uVar4 >> 8 & 0xff)) * 0x25 +

-              (uVar4 >> 0x10 & 0xff)) * 0x25 + (uVar4 >> 0x18 & 0xff)) * 0x25 +

-            (uVar4 >> 0x20 & 0xff)) * 0x25 + (uVar4 >> 0x28 & 0xff)) * 0x25 + (uVar4 >> 0x30 & 0xff)

-          ) * 0x25;

-  uVar5 = (DAT_0 >> 5) - 1 & (uint)bStack000000000000006f + (int)lVar3;

-  *unaff_RSI = DAT_1[uVar5];

-  puVar6[uVar5] = unaff_RSI;

-  EtwpMdlTable = EtwpMdlTable + 1;

-  ExReleaseSpinLockExclusive(&DAT_2,CONCAT71((int7)((ulonglong)lVar3 >> 8),unaff_R15B));

-  return 1;

+  EtwpTraceThreadRundown(param_1,param_2);

+  return;

 }
```

## `NtSetInformationToken`  (modified)

```diff
--- NtSetInformationToken
+++ PspValidateJobAssignmentUILimits
@@ -1,54 +1,76 @@
 

-ulonglong NtSetInformationToken(void)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+int PspValidateJobAssignmentUILimits(uint param_1)

 

 {

-  longlong lVar1;

-  undefined4 *in_RAX;

-  ulonglong uVar2;

-  undefined4 unaff_ESI;

-  uint uVar3;

-  uint unaff_R12D;

-  uint *unaff_R15;

-  undefined4 uVar4;

-  undefined4 *puStack0000000000000028;

-  longlong in_stack_00000088;

-  uint in_stack_00000098;

-  uint in_stack_000000c8;

+  short *psVar1;

+  char in_AL;

+  int iVar2;

+  undefined8 *puVar3;

+  char unaff_BL;

+  char *unaff_RBP;

+  longlong unaff_R13;

+  char unaff_R15B;

+  char in_CF;

+  undefined8 in_stack_00000040;

+  undefined4 in_stack_00000058;

+  longlong in_stack_00000080;

+  undefined8 in_stack_000000b0;

+  undefined1 uStack0000000000000180;

+  undefined8 uStack0000000000000190;

+  undefined8 uStack0000000000000198;

+  undefined8 uStack00000000000001a0;

+  undefined8 uStack00000000000001a8;

+  undefined4 uStack00000000000001b0;

+  undefined4 uStack00000000000001b4;

+  undefined4 uStack00000000000001b8;

+  undefined4 uStack00000000000001bc;

+  undefined8 uStack00000000000001c0;

   

-  uVar4 = (undefined4)((ulonglong)&stack0x00000088 >> 0x20);

-  puStack0000000000000028 = in_RAX;

-  uVar2 = SepReferenceTokenByHandle();

-  lVar1 = in_stack_00000088;

-  if (-1 < (int)uVar2) {

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(in_stack_00000088 + 0x30),1);

-    if (*(longlong *)(lVar1 + 0x308) == 0) {

-      uVar3 = 0x10;

-    }

-    else {

-      puStack0000000000000028 = &stack0x00000098;

-      AuthzBasepQuerySecurityAttributesToken

-                (*(longlong *)(lVar1 + 0x308),0,0,0,CONCAT44(uVar4,unaff_ESI));

-      uVar3 = in_stack_00000098;

-    }

-    *unaff_R15 = uVar3;

-    if (unaff_R12D < uVar3) {

-      ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0x30));

-      KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-      ObfDereferenceObjectWithTag(in_stack_00000088,0x74726853);

-      uVar2 = 0xc0000023;

-    }

-    else {

-      puStack0000000000000028 = &stack0x00000098;

-      in_stack_000000c8 = AuthzBasepQuerySecurityAttributesToken(*(undefined8 *)(lVar1 + 0x308),0,0)

-      ;

-      ExReleaseResourceLite(*(undefined8 *)(lVar1 + 0x30));

-      KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-      ObfDereferenceObjectWithTag(in_stack_00000088,0x74726853);

-      uVar2 = (ulonglong)in_stack_000000c8;

+  *unaff_RBP = *unaff_RBP + in_AL + in_CF;

+  uStack0000000000000190 = *(undefined8 *)(unaff_R13 + 0x10);

+  uStack0000000000000198 = *(undefined8 *)(unaff_R13 + 0x18);

+  uStack00000000000001a0 = *(undefined8 *)(unaff_R13 + 0x20);

+  uStack00000000000001a8 = *(undefined8 *)(unaff_R13 + 0x28);

+  uStack00000000000001b0 = *(undefined4 *)(unaff_R13 + 0x30);

+  uStack00000000000001b4 = *(undefined4 *)(unaff_R13 + 0x34);

+  uStack00000000000001b8 = *(undefined4 *)(unaff_R13 + 0x38);

+  uStack00000000000001bc = *(undefined4 *)(unaff_R13 + 0x3c);

+  uStack00000000000001c0 = *(undefined8 *)(unaff_R13 + 0x40);

+  _uStack0000000000000180 = param_1;

+  if (((param_1 & 0xfffffffc) == 0) && ((param_1 & 3) != 0)) {

+    PspLockRootJobExclusive(in_stack_00000040,in_stack_00000080,&stack0x000000b0);

+    puVar3 = &stack0x000000b0;

+    PspLockJobConditionally(in_stack_00000040,puVar3);

+    iVar2 = PspSetJobIoAttribution

+                      (in_stack_00000040,

+                       CONCAT71((int7)((ulonglong)puVar3 >> 8),uStack0000000000000180) &

+                       0xffffffffffffff01,1,1);

+    unaff_BL = '\b';

+    if (-1 < iVar2) {

+      PspUnlockJobConditionally(in_stack_00000040,&stack0x000000b0);

+      PspUnlockJob(in_stack_000000b0,in_stack_00000080);

+      unaff_BL = unaff_R15B;

     }

   }

-  return uVar2;

+  else {

+    iVar2 = -0x3ffffff3;

+  }

+  if (unaff_BL == '\b') {

+    PspUnlockJobConditionally(in_stack_00000040,&stack0x000000b0);

+    PspUnlockJob(in_stack_000000b0,in_stack_00000080);

+  }

+  psVar1 = (short *)(in_stack_00000080 + 0x1e6);

+  *psVar1 = *psVar1 + 1;

+  if ((*psVar1 == 0) &&

+     (*(longlong **)(in_stack_00000080 + 0x98) != (longlong *)(in_stack_00000080 + 0x98))) {

+    KiCheckForKernelApcDelivery();

+  }

+  if ((iVar2 != 0) && ((PerfGlobalGroupMask & 0x80000) != 0)) {

+    EtwTraceJobSetQuery(in_stack_00000040,in_stack_00000058,0,0,iVar2);

+  }

+  ObfDereferenceObjectWithTag(in_stack_00000040,0x79517350);

+  return iVar2;

 }
```

## `PopAdaptiveStandbyQueryReserveConfiguration`  (modified)

```diff
--- PopAdaptiveStandbyQueryReserveConfiguration
+++ PopAdaptiveStandbyQueryReserveConfiguration
@@ -1,69 +1,91 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-char PopAdaptiveStandbyQueryReserveConfiguration(void)

+void PopAdaptiveStandbyQueryReserveConfiguration(longlong param_1)

 

 {

-  longlong lVar1;

-  char cVar2;

-  longlong lVar3;

-  char unaff_BL;

-  char cVar4;

-  code *unaff_RBP;

-  longlong unaff_RSI;

-  undefined8 *puVar5;

-  longlong unaff_R12;

-  code *unaff_R14;

-  code *unaff_R15;

-  bool bVar6;

-  char in_stack_00000088;

-  undefined8 in_stack_00000090;

+  longlong *plVar1;

+  int iVar2;

+  undefined8 uVar3;

+  undefined1 auStack_f8 [32];

+  wchar_t *local_d8;

+  undefined1 *local_d0;

+  undefined8 *local_c8;

+  undefined4 *local_c0;

+  undefined4 local_b8 [2];

+  longlong local_b0;

+  undefined8 local_a8;

+  undefined4 local_a0;

+  undefined4 local_9c;

+  undefined8 local_98;

+  wchar_t *local_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined1 local_78 [32];

+  longlong *local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  undefined4 *local_48;

+  undefined4 local_40;

+  undefined4 local_3c;

+  undefined8 *local_38;

+  undefined4 local_30;

+  undefined4 local_2c;

+  ulonglong local_28;

   

-  *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-       *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-  lVar3 = KeAbPreAcquire();

-  LOCK();

-  bVar6 = PopPepDeviceListLock != 0;

-  lVar1 = unaff_RSI;

-  if (bVar6) {

-    lVar1 = PopPepDeviceListLock;

+  local_28 = __security_cookie ^ (ulonglong)auStack_f8;

+  local_b8[0] = 0;

+  plVar1 = (longlong *)(param_1 + 0xd0);

+  if (*plVar1 != 0) {

+    if (5 < DAT_0) {

+      local_4c = 0;

+      local_58 = &local_b0;

+      local_50 = 8;

+      local_b0 = *plVar1;

+      uVar3 = IoGetActivityIdThread();

+      local_d0 = local_78;

+      local_d8 = (wchar_t *)CONCAT44(local_d8._4_4_,3);

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004dd50,uVar3,0);

+    }

+    *(undefined4 *)(param_1 + 0x70) = 0;

+    *(longlong *)(param_1 + 0x68) = *plVar1;

+    if (*(char *)(param_1 + 0x78) == '\0') {

+      if (*(longlong *)(param_1 + 0x228) != 0) {

+        local_98 = 0;

+        local_90 = L"Reserve Configuration Update";

+        local_c0 = local_b8;

+        local_a0 = 1;

+        local_d8 = L"AdaptiveStandby";

+        local_9c = 300;

+        local_88 = 0;

+        uStack_80 = 0;

+        local_c8 = (undefined8 *)(param_1 + 0x80);

+        iVar2 = Pdcv2ActivationClientActivate(*(longlong *)(param_1 + 0x228),&local_a0,0);

+        if (5 < DAT_0) {

+          local_4c = 0;

+          local_3c = 0;

+          local_2c = 0;

+          local_b0 = CONCAT44(local_b0._4_4_,iVar2);

+          local_58 = &local_b0;

+          local_48 = local_b8;

+          local_a8 = *(undefined8 *)(param_1 + 0x80);

+          local_38 = &local_a8;

+          local_50 = 4;

+          local_40 = 4;

+          local_30 = 8;

+          uVar3 = IoGetActivityIdThread();

+          local_d0 = local_78;

+          local_d8 = (wchar_t *)CONCAT44(local_d8._4_4_,5);

+          _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004dd92,uVar3,0);

+        }

+        if (iVar2 < 0) {

+          return;

+        }

+      }

+      *(undefined1 *)(param_1 + 0x78) = 1;

+      PopUmpoSendPowerAdaptiveReserveConfigurationQuery(plVar1);

+    }

   }

-  PopPepDeviceListLock = lVar1;

-  UNLOCK();

-  if (bVar6) {

-    ExfAcquirePushLockSharedEx();

-  }

-  if (lVar3 != 0) {

-    *(char *)(lVar3 + 10) = unaff_BL;

-  }

-  puVar5 = PopPepDeviceList;

-  if (unaff_RBP != (code *)0x0) {

-    (*unaff_RBP)(in_stack_00000090);

-    puVar5 = PopPepDeviceList;

-  }

-  while ((cVar4 = unaff_BL, (undefined8 **)puVar5 != &PopPepDeviceList &&

-         (cVar2 = (*unaff_R15)(puVar5,in_stack_00000090), cVar4 = (char)unaff_R12, cVar2 != '\0')))

-  {

-    puVar5 = (undefined8 *)*puVar5;

-  }

-  if (unaff_R14 != (code *)0x0) {

-    (*unaff_R14)(cVar4,in_stack_00000090);

-  }

-  if (in_stack_00000088 != (char)unaff_R12) {

-    LOCK();

-    bVar6 = PopPepDeviceListLock != 0x11;

-    lVar1 = unaff_R12;

-    if (bVar6) {

-      lVar1 = PopPepDeviceListLock;

-    }

-    PopPepDeviceListLock = lVar1;

-    UNLOCK();

-    if (bVar6) {

-      ExfReleasePushLockShared();

-    }

-    KeAbPostRelease();

-    KeLeaveCriticalRegion();

-  }

-  return cVar4;

+  return;

 }
```

## `CmFcpInitializeFeatureUsageProviderSubscription`  (modified)

```diff
--- CmFcpInitializeFeatureUsageProviderSubscription
+++ CmFcpInitializeFeatureUsageProviderSubscription
@@ -1,68 +1,32 @@
 

-undefined4 CmFcpInitializeFeatureUsageProviderSubscription(void)

+void CmFcpInitializeFeatureUsageProviderSubscription

+               (void *param_1,undefined8 param_2,undefined8 param_3,undefined8 *param_4)

 

 {

-  undefined4 uVar1;

-  char cVar2;

-  longlong lVar3;

-  uint unaff_EBX;

-  undefined4 uVar4;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  undefined4 unaff_R13D;

-  void *unaff_R14;

-  undefined4 *unaff_R15;

-  bool in_ZF;

+  undefined8 *_Dst;

+  undefined8 uVar1;

   

-  if (in_ZF) {

-    lVar3 = HvpGetCellPaged();

+  memset(param_1,0,0x88);

+  uVar1 = 0;

+  if (param_4 != (undefined8 *)0x0) {

+    *(undefined8 *)((longlong)param_1 + 0x70) = *param_4;

+    *(undefined8 *)((longlong)param_1 + 0x78) = param_4[1];

+    *(undefined4 *)((longlong)param_1 + 0x80) = *(undefined4 *)(param_4 + 3);

+    uVar1 = param_4[2];

   }

-  else {

-    lVar3 = HvpGetCellFlat();

-  }

-  if (lVar3 == 0) {

-    return 0xc000009a;

-  }

-  *(uint *)(unaff_RBP + -0x20) = unaff_EBX;

-  if (*(uint *)(lVar3 + 4) != unaff_EBX) {

-    cVar2 = CmpGetValueData();

-    if (cVar2 == '\0') {

-LAB_0:

-      uVar4 = 0xc000009a;

-      goto LAB_1;

-    }

-    unaff_EBX = *(uint *)(unaff_RBP + -0x20);

-    if (unaff_EBX != 0) {

-      unaff_R14 = (void *)CmpAllocateTransientPool(0x100,unaff_EBX,unaff_R13D);

-      if (unaff_R14 == (void *)0x0) goto LAB_0;

-      RtlCopyMemory(unaff_R14,*(void **)(unaff_RBP + -8),(ulonglong)unaff_EBX);

-    }

-  }

-  uVar1 = *(undefined4 *)(lVar3 + 0xc);

-  unaff_R15[1] = unaff_EBX;

-  uVar4 = 0;

-  *unaff_R15 = uVar1;

-  *(void **)(unaff_R15 + 2) = unaff_R14;

-LAB_1:

-  if (*(longlong *)(unaff_RBP + -8) != 0) {

-    if (*(char *)(unaff_RBP + 0x30) == '\0') {

-      if ((*(byte *)(unaff_RDI + 0x8c) & 1) == 0) {

-        HvpReleaseCellPaged();

-      }

-      else {

-        HvpReleaseCellFlat();

-      }

-    }

-    else {

-      ExFreePoolWithTag(*(longlong *)(unaff_RBP + -8),0);

-    }

-  }

-  if ((*(byte *)(unaff_RDI + 0x8c) & 1) == 0) {

-    HvpReleaseCellPaged();

-  }

-  else {

-    HvpReleaseCellFlat();

-  }

-  return uVar4;

+  _Dst = (undefined8 *)((longlong)param_1 + 0x10);

+  memset(_Dst,0,0x40);

+  *_Dst = 0;

+  *(undefined4 *)((longlong)param_1 + 0x38) = 0;

+  *(undefined8 *)((longlong)param_1 + 0x30) = 0;

+  *(code **)((longlong)param_1 + 0x20) = CmpWorkItemWrapper;

+  *(code **)((longlong)param_1 + 0x40) = CmFcpFeatureUsageProviderSubscriptionWrapper;

+  *(undefined8 **)((longlong)param_1 + 0x28) = _Dst;

+  *(undefined4 *)((longlong)param_1 + 0x3c) = 4;

+  *(undefined8 *)((longlong)param_1 + 0x48) = uVar1;

+  *(undefined8 *)((longlong)param_1 + 0x68) = 0;

+  *(undefined8 *)((longlong)param_1 + 0x50) = param_3;

+  *(undefined8 **)((longlong)param_1 + 0x58) = &CmFcSystemManager;

+  return;

 }
```

## `PspAssignProcessToJob`  (modified)

```diff
--- PspAssignProcessToJob
+++ PspAssignProcessToJob
@@ -1,112 +1,285 @@
 

-int PspAssignProcessToJob

-              (undefined8 param_1,undefined2 param_2,undefined8 param_3,ulonglong param_4)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+int PspAssignProcessToJob(longlong param_1,longlong param_2,longlong param_3,int param_4)

 

 {

-  int iVar1;

-  int iVar2;

-  ulonglong in_RAX;

-  ulonglong uVar3;

-  ulonglong unaff_RBP;

-  ulonglong unaff_RSI;

-  longlong unaff_RDI;

-  longlong lVar4;

-  undefined8 unaff_R14;

-  ulonglong uVar5;

-  ulonglong in_stack_00000050;

-  ulonglong uStack0000000000000058;

-  ulonglong in_stack_00000060;

-  ulonglong in_stack_00000068;

-  longlong in_stack_00000070;

-  undefined8 in_stack_00000078;

-  undefined8 in_stack_00000080;

-  undefined4 uStack00000000000000d0;

-  undefined8 *in_stack_000000d8;

+  longlong *plVar1;

+  uint *puVar2;

+  bool bVar3;

+  char cVar4;

+  int iVar5;

+  int iVar6;

+  uint uVar7;

+  longlong lVar8;

+  byte bVar9;

+  byte bVar10;

+  uint uVar11;

+  longlong lVar12;

+  void *pvVar13;

+  undefined4 uVar14;

+  int iVar15;

+  bool bVar16;

+  undefined1 auStack_d8 [32];

+  undefined8 *local_b8;

+  undefined8 local_b0;

+  undefined8 local_a8;

+  char local_98 [4];

+  int local_94;

+  longlong local_90;

+  void *local_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  ulonglong local_40;

   

-  *(int *)(in_RAX - 0x7d) = *(int *)(in_RAX - 0x7d) + -1;

-  uVar3 = in_RAX & 0xffffffffffffff50;

-  *(int *)(uVar3 - 0x75) = *(int *)(uVar3 - 0x75) + -1;

-  out(param_2,(char)uVar3);

-  lVar4 = 0;

-  uStack00000000000000d0 = (undefined4)uVar3;

-  for (; uStack0000000000000058 = unaff_RBP, unaff_RBP <= param_4; unaff_RBP = unaff_RBP + 1) {

-    iVar1 = MiIsPfn(unaff_RBP);

-    if (iVar1 == 0) {

-      uVar3 = unaff_RBP;

-      if (lVar4 != 0) {

-        uVar3 = in_stack_00000050;

-      }

-      lVar4 = lVar4 + 1;

-      in_stack_00000050 = uVar3;

-      if (unaff_RBP == in_stack_00000060) goto LAB_0;

-    }

-    else {

+  pvVar13 = SystemReserved1[0xf];

+  local_40 = __security_cookie ^ (ulonglong)auStack_d8;

+  local_98[0] = '\0';

+  local_80 = 0;

+  uStack_78 = 0;

+  local_70 = 0;

+  local_88 = SystemReserved1[0xf];

+  local_48 = 0;

+  local_94 = 0;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  bVar16 = param_4 == 5;

+  if (bVar16) {

+    param_3 = *(longlong *)(param_2 + 0x2a0);

+    param_2 = PspGetNextJobProcess(0,SystemReserved1[0xf],&local_80,0);

+    ObfReferenceObjectWithTag(param_2,0x624a7350);

+    PspQuitNextJobProcess(param_1,pvVar13,&local_80,param_2);

+  }

+  iVar15 = local_94;

+  bVar9 = bVar16;

+  if (param_2 != 0) {

+    cVar4 = ExAcquireRundownProtection(param_2 + 0x1e8);

+    if (cVar4 == '\0') {

+      iVar6 = -0x3ffffef6;

+      bVar10 = bVar16;

+      bVar3 = false;

+      goto LAB_0;

+    }

+    bVar9 = 0x10;

+  }

+  local_b8 = &local_68;

+  PspGetJobLockHierarchyForAssignment(param_1,param_2,param_3,param_4);

+  bVar10 = bVar9 | 6;

+  bVar3 = true;

+  PspLockJobAssignment(pvVar13);

+  PspLockJobsAndProcessExclusive(&local_68,param_2,pvVar13,1);

+  if (param_4 == 5) {

+    cVar4 = PspIsJobMovable();

+    if (cVar4 != '\0') {

+      local_94 = 5;

+      if ((*(longlong *)(param_2 + 0x2a0) != param_1) ||

+         ((*(uint *)(param_2 + 0x5fc) & 0x1000) == 0)) {

+        iVar6 = -0x3fffffde;

+        iVar15 = 5;

+        goto LAB_0;

+      }

+LAB_1:

+      iVar15 = local_94;

+      if ((param_2 != 0) && (local_94 != 5)) {

+        param_3 = *(longlong *)(param_2 + 0x2a0);

+      }

+      cVar4 = PspValidateJobAssignmentUILimits(param_1,param_3,local_94);

+      if ((((cVar4 != '\0') &&

+           (cVar4 = PspValidateJobAssignmentSiloPolicy(param_1,param_3,param_2,iVar15),

+           cVar4 != '\0')) &&

+          (cVar4 = PspValidateJobAssignmentMemoryPartition(param_1,param_3,param_2,iVar15),

+          cVar4 != '\0')) &&

+         (((iVar15 != 5 || ((*(uint *)(param_1 + 0x420) & 1) == 0)) &&

+          (((iVar15 - 4U & 0xfffffffc) != 0 ||

+           ((iVar15 == 6 || (*(byte *)(param_3 + 0x44e) + 1 < 0x65)))))))) {

+        if (((iVar15 - 4U & 0xfffffffc) == 0) && (iVar15 != 6)) {

+          iVar6 = 0;

+          do {

+            if (((1 < iVar6 - 1U) && ((*(uint *)(param_1 + 0x610) >> 0x19 & 1) != 0)) &&

+               ((*(uint *)(param_3 + 0x610) >> 0x19 & 1) != 0)) goto LAB_2;

+            iVar6 = iVar6 + 1;

+          } while (iVar6 < 3);

+        }

+        cVar4 = PspValidateJobAssignmentDiskIoAttribution(param_1);

+        if (cVar4 != '\0') {

+          local_90 = param_3;

+          lVar12 = param_1;

+          if ((iVar15 == 1) || (iVar15 == 3)) {

+LAB_3:

+            if ((lVar12 != 0) &&

+               (iVar6 = PspValidateJobChainLimits(lVar12,local_90,param_2,0), pvVar13 = local_88,

+               iVar6 < 0)) goto LAB_0;

+          }

+          else {

+            if (iVar15 == 4) {

+              local_90 = 0;

+              goto LAB_3;

+            }

+            if (iVar15 == 5) {

+              local_90 = 0;

+              lVar12 = param_3;

+              goto LAB_3;

+            }

+            lVar12 = 0;

+            local_90 = 0;

+          }

+          iVar6 = PspEstablishJobHierarchy(param_1,param_2,param_3,iVar15);

+          pvVar13 = local_88;

+          if (-1 < iVar6) {

+            if (param_2 == 0) {

+              iVar6 = 0;

+            }

+            else {

+              if ((*(uint *)(param_1 + 0x610) & 0x1000) != 0) {

+                uVar11 = 0;

+                do {

+                  uVar7 = *(uint *)(param_2 + 0x728 + (longlong)(int)uVar11 * 4) & 0x7fffffff;

+                  if (uVar7 != 0) {

+                    local_a8 = 0x626f4a;

+                    local_b0 = 0;

+                    local_b8 = (undefined8 *)((ulonglong)local_b8 & 0xffffffff00000000);

+                    PspChargeJobWakeCounter(param_1,param_3,(ulonglong)uVar11,uVar7);

+                  }

+                  LOCK();

+                  puVar2 = (uint *)(param_2 + 0x728 + (ulonglong)uVar11 * 4);

+                  *puVar2 = *puVar2 | 0x80000000;

+                  UNLOCK();

+                  uVar11 = uVar11 + 1;

+                } while (uVar11 < 7);

+                uVar11 = *(uint *)(param_2 + 0x74c) & 0x7fffffff;

+                if (uVar11 != 0) {

+                  local_a8 = 0x626f4a;

+                  local_b0 = 0;

+                  local_b8 = (undefined8 *)CONCAT44(local_b8._4_4_,4);

+                  PspChargeJobWakeCounter(param_1,param_3,0,uVar11);

+                }

+                LOCK();

+                *(uint *)(param_2 + 0x74c) = *(uint *)(param_2 + 0x74c) | 0x80000000;

+                UNLOCK();

+              }

+              plVar1 = (longlong *)(param_2 + 0x1c8);

+              LOCK();

+              lVar8 = *plVar1;

+              *plVar1 = *plVar1 + -1;

+              UNLOCK();

+              if (((byte)lVar8 & 6) == 2) {

+                ExfTryToWakePushLock(plVar1);

+              }

+              KeAbPostRelease(plVar1);

+              iVar15 = local_94;

+              lVar8 = local_90;

+              if (local_94 == 4) {

+                lVar8 = param_3;

+              }

+              PspIncrementJobChainProcessCounts(lVar12,lVar8,param_2,0);

+              PspApplyJobChainLimitsToProcess(param_1,param_3,param_2);

+              pvVar13 = local_88;

+              PspUnlockJobsAndProcessExclusive(&local_68,0,local_88);

+              bVar10 = bVar9 | 10;

+              bVar3 = false;

+              if ((*(uint *)(param_1 + 0x610) & 0x1000000) == 0) {

+                PsQueryProcessAttributes(param_2,local_98,0);

+                iVar15 = local_94;

+                if (local_98[0] == '\0') {

+                  LOCK();

+                  *(uint *)(param_1 + 0x610) = *(uint *)(param_1 + 0x610) | 0x1800000;

+                  UNLOCK();

+                }

+                else {

+                  LOCK();

+                  *(uint *)(param_1 + 0x610) = *(uint *)(param_1 + 0x610) | 0x1000000;

+                  UNLOCK();

+                }

+              }

+              iVar6 = PspApplyWorkingSetLimitsToProcess(param_2);

+              if (-1 < iVar6) {

+                uVar14 = 0;

+                if (iVar15 == 5) {

+                  uVar14 = 4;

+                }

+                iVar5 = MmAssignProcessToJob(param_2,param_3,uVar14);

+                if (iVar5 == 0) {

+                  iVar6 = -0x3fffffbc;

+                }

+                else {

+                  PspUnlockJobAssignment(pvVar13);

+                  *(short *)((longlong)pvVar13 + 0x1e4) = *(short *)((longlong)pvVar13 + 0x1e4) + -1

+                  ;

+                  bVar10 = bVar9 | 8;

+                  bVar3 = false;

+                  PspChangeProcessExecutionState(param_2);

+                  KiLeaveCriticalRegionUnsafe(pvVar13);

+                  if (((*(int *)(param_1 + 0x220) != 0) &&

+                      (cVar4 = IsWin32kJobNotifyCallOutPresent(), cVar4 != '\0')) &&

+                     (*(uint *)(param_1 + 0x240) < 0xfffffffe)) {

+                    Win32kJobAddProcessNotify(param_1,param_2);

+                  }

+                  if (iVar15 == 5) {

+                    iVar6 = -0x3ffffdd3;

+                    bVar10 = bVar9 | 0x28;

+                  }

+                }

+              }

+            }

+          }

+          goto LAB_0;

+        }

+      }

+LAB_2:

+      iVar6 = -0x3fffff45;

+      goto LAB_0;

+    }

+  }

+  else {

+    iVar6 = PspGetJobAssignmentDisposition(param_1,param_2,param_3,&local_94);

+    iVar15 = local_94;

+    if (-1 < iVar6) {

+      if (local_94 != param_4) {

+        iVar6 = -0x3ffffdd3;

+        goto LAB_0;

+      }

+      if (local_94 == 2) {

+        iVar6 = 0;

+        goto LAB_0;

+      }

+      goto LAB_1;

+    }

+  }

+  iVar6 = -0x3fffffde;

+  bVar3 = true;

 LAB_0:

-      uVar3 = in_stack_00000050;

-      if (lVar4 != 0) {

-        iVar1 = MiReferenceIoPages(1,in_stack_00000050,lVar4,uStack00000000000000d0,0);

-        if (iVar1 < 0) goto LAB_1;

-        in_stack_00000050 = 0xffffffffffffffff;

-        in_stack_00000068 = (uVar3 - 1) + lVar4;

-        lVar4 = 0;

-        unaff_RBP = uStack0000000000000058;

-      }

-    }

-    param_4 = in_stack_00000060;

-  }

-  iVar1 = MiInsertVadCharges();

-  if (iVar1 < 0) {

-LAB_1:

-    UNLOCK_ADDRESS_SPACE_UNORDERED();

-    if (in_stack_00000068 != 0xffffffffffffffff) {

-      lVar4 = 0;

-      uVar3 = 0xffffffffffffffff;

-      for (; unaff_RSI <= in_stack_00000068; unaff_RSI = unaff_RSI + 1) {

-        iVar2 = MiIsPfn(unaff_RSI);

-        uVar5 = uVar3;

-        if (iVar2 == 0) {

-          uVar5 = unaff_RSI;

-          if (lVar4 != 0) {

-            uVar5 = uVar3;

-          }

-          lVar4 = lVar4 + 1;

-          if (unaff_RSI == in_stack_00000068) goto LAB_2;

-        }

-        else {

-LAB_2:

-          if (lVar4 != 0) {

-            MiDereferenceIoPages(1,uVar5,lVar4);

-            lVar4 = 0;

-            uVar5 = 0xffffffffffffffff;

-          }

-        }

-        uVar3 = uVar5;

-      }

-    }

-    ExFreePoolWithTag();

-  }

-  else {

-    MiInsertViewOfPhysicalSection();

-    if (in_stack_00000070 != 0) {

-      MiAdvanceVadHint(in_stack_00000080,in_stack_00000078);

-    }

-    if (*(int *)(unaff_RDI + 0x78) == 0) {

-      UNLOCK_ADDRESS_SPACE_UNORDERED();

-    }

-    else {

-      MiLockVad();

-      UNLOCK_ADDRESS_SPACE_UNORDERED();

-      iVar1 = MiCommitVadMetadataBits();

-      if (iVar1 < 0) {

-        MiReferenceVad();

-        MiDeleteVad();

-        return iVar1;

-      }

-      MiUnlockVad();

-    }

-    *in_stack_000000d8 = unaff_R14;

-    iVar1 = 0;

-  }

-  return iVar1;

+  if ((bVar10 & 0x10) != 0) {

+    ExReleaseRundownProtection(param_2 + 0x1e8);

+  }

+  if ((((bVar10 & 0x20) == 0) && (iVar6 < 0)) && ((bVar10 & 8) != 0)) {

+    if (iVar15 == 5) {

+      local_b8 = (undefined8 *)(longlong)iVar6;

+                    /* WARNING: Subroutine does not return */

+      KeBugCheckEx(0xef,param_2,0,param_1);

+    }

+    uVar14 = 0xc000010a;

+    if (iVar6 != -0x3ffffef6) {

+      uVar14 = 0xc0000044;

+    }

+    PspRemoveProcessFromJobChain(param_2,0,10,uVar14);

+  }

+  if (bVar3) {

+    PspUnlockJobsAndProcessExclusive(&local_68,param_2,pvVar13);

+  }

+  if ((bVar10 & 2) != 0) {

+    PspUnlockJobAssignment(pvVar13);

+  }

+  if (bVar16) {

+    ObfDereferenceObjectWithTag(param_2,0x624a7350);

+  }

+  return iVar6;

 }
```

## `PopPdcRegister`  (modified)

```diff
--- PopPdcRegister
+++ PopPdcRegister
@@ -1,48 +1,88 @@
 

-void PopPdcRegister(void)

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+undefined8 PopPdcRegister(longlong param_1,undefined8 *param_2)

 

 {

-  longlong lVar1;

-  undefined4 in_EAX;

-  void *unaff_RBX;

-  uint unaff_EBP;

-  longlong unaff_RSI;

-  ulonglong uVar2;

-  undefined8 in_R10;

-  uint uVar3;

-  ulonglong unaff_R14;

-  undefined4 uStack0000000000000028;

-  undefined8 uStack0000000000000030;

+  char cVar1;

+  undefined1 uVar2;

+  int iVar3;

+  undefined8 uVar4;

   

-  while( true ) {

-    uStack0000000000000028 = in_EAX;

-    uStack0000000000000030 = in_R10;

-    PopDiagTraceFxPerfSetRegistration();

-    uVar3 = (int)unaff_R14 + 1;

-    unaff_R14 = (ulonglong)uVar3;

-    if (*(uint *)(unaff_RSI + 0x90) <= uVar3) break;

-    lVar1 = *(longlong *)(unaff_R14 * 0x20 + *(longlong *)(unaff_RSI + 0x98));

-    if (*(int *)(lVar1 + 0x1c) == 0) {

-      memset(unaff_RBX,0,(ulonglong)unaff_EBP);

-      uVar2 = 0;

-      if (*(int *)(lVar1 + 0x20) != 0) {

-        do {

-          *(undefined8 *)((longlong)unaff_RBX + uVar2 * 8) =

-               *(undefined8 *)(*(longlong *)(lVar1 + 0x28) + uVar2 * 0x10);

-          uVar3 = (int)uVar2 + 1;

-          uVar2 = (ulonglong)uVar3;

-        } while (uVar3 < *(uint *)(lVar1 + 0x20));

-      }

-      in_R10 = 0;

+  uVar4 = 0;

+  if (param_2 == (undefined8 *)0x0) {

+    uVar4 = 0xc000000d;

+  }

+  else {

+    PopAcquirePolicyLock();

+    _PopModernStandbyTransitionInfo = 0;

+    PoPdcCallbacks = *(undefined8 *)(param_1 + 8);

+    DAT_0 = *(undefined8 *)(param_1 + 0x10);

+    DAT_1 = *(undefined8 *)(param_1 + 0x18);

+    DAT_2 = *(undefined8 *)(param_1 + 0x20);

+    DAT_3 = *(undefined8 *)(param_1 + 0x28);

+    DAT_4 = *(undefined8 *)(param_1 + 0x30);

+    DAT_5 = *(undefined8 *)(param_1 + 0x38);

+    DAT_6 = *(undefined8 *)(param_1 + 0x40);

+    DAT_7 = *(undefined8 *)(param_1 + 0x48);

+    DAT_8 = *(undefined8 *)(param_1 + 0x50);

+    DAT_9 = *(undefined8 *)(param_1 + 0x58);

+    DAT_10 = *(undefined8 *)(param_1 + 0x60);

+    DAT_11 = *(undefined8 *)(param_1 + 0x68);

+    DAT_12 = *(undefined8 *)(param_1 + 0x70);

+    DAT_13 = *(undefined8 *)(param_1 + 0x78);

+    DAT_14 = *(undefined8 *)(param_1 + 0x80);

+    DAT_15 = *(undefined8 *)(param_1 + 0x88);

+    DAT_16 = *(undefined8 *)(param_1 + 0x90);

+    DAT_17 = *(undefined8 *)(param_1 + 0x98);

+    DAT_18 = *(undefined8 *)(param_1 + 0xa0);

+    DAT_19 = *(undefined8 *)(param_1 + 0xa8);

+    DAT_20 = *(undefined8 *)(param_1 + 0xb0);

+    DAT_21._0_4_ = *(undefined4 *)(param_1 + 0xb8);

+    DAT_21._4_4_ = *(undefined4 *)(param_1 + 0xbc);

+    DAT_22._0_4_ = *(undefined4 *)(param_1 + 0xc0);

+    DAT_22._4_4_ = *(undefined4 *)(param_1 + 0xc4);

+    DAT_23._0_4_ = *(undefined4 *)(param_1 + 200);

+    DAT_23._4_4_ = *(undefined4 *)(param_1 + 0xcc);

+    DAT_24._0_4_ = *(undefined4 *)(param_1 + 0xd0);

+    DAT_24._4_4_ = *(undefined4 *)(param_1 + 0xd4);

+    DAT_25 = *(code **)(param_1 + 0xd8);

+    *param_2 = PdcPoResiliencyClient;

+    param_2[1] = PdcPoLowPower;

+    param_2[2] = PdcPoSetPowerAction;

+    param_2[3] = PdcPoReportButton;

+    param_2[4] = PdcPoReportLidState;

+    param_2[5] = PdcPoRecordButton;

+    param_2[6] = PdcPoVerifyActionPolicy;

+    param_2[7] = PdcPoVerifyPowerState;

+    param_2[8] = PdcPoBlockSessionSwitchEx;

+    param_2[9] = PopControlMonitor;

+    param_2[10] = PopNotifyCsStateExited;

+    param_2[0xb] = PdcPoCurrentPdcPhase;

+    param_2[0xc] = PdcPoPpmRegisterProfiles;

+    param_2[0xd] = PdcPoPpmApplyProfile;

+    param_2[0xe] = PdcPoPpmResetProfile;

+    param_2[0xf] = PdcPoNetworkResiliency;

+    param_2[0x10] = PpmQueryDripsResidency;

+    param_2[0x11] = PdcPoSleepStudyHelperSetPhaseActive;

+    iVar3 = Feature_14FBugcheckMinidumpDiagnostics__private_IsEnabledDeviceUsageNoInline();

+    if (iVar3 != 0) {

+      param_2[0x13] = KeQueryCurrentWaitInformationThread;

+      param_2[0x14] = PsEnumProcessThreads;

+    }

+    param_2[0x12] = PdcPoLidReliabilityUpdateCallback;

+    cVar1 = PopIsPlatformAoAcCapableInitialized();

+    if (cVar1 == '\0') {

+      PopReleasePolicyLock();

     }

     else {

-      in_R10 = *(undefined8 *)(lVar1 + 0x20);

+      uVar2 = SSHSupportIsPlatformAoAc();

+      PopReleasePolicyLock();

+      (*DAT_25)(uVar2);

     }

-    in_EAX = *(undefined4 *)(lVar1 + 0x18);

+    ExQueueWorkItem(&PopDelayedPdcRegistrationWorkItem,1);

   }

-  if (unaff_RBX != (void *)0x0) {

-    ExFreePoolWithTag();

-  }

-  return;

+  return uVar4;

 }
```

## `NtQueryInformationJobObject`  (modified)

```diff
--- NtQueryInformationJobObject
+++ NtQueryInformationJobObject
@@ -1,174 +1,1279 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Type propagation algorithm not settling */

 

-int NtQueryInformationJobObject(void)

+ulonglong NtQueryInformationJobObject

+                    (longlong param_1,int param_2,undefined8 *param_3,uint param_4,uint *param_5)

 

 {

-  longlong lVar1;

-  undefined8 *puVar2;

-  undefined4 uVar3;

-  undefined4 uVar4;

-  undefined4 uVar5;

-  undefined8 uVar6;

-  char cVar7;

-  int iVar8;

-  int iVar9;

-  ulonglong uVar10;

-  longlong lVar11;

-  char cVar12;

-  byte unaff_BL;

-  undefined4 *unaff_RBP;

-  uint uVar13;

-  char cVar14;

-  uint unaff_EDI;

-  uint uVar15;

-  char *unaff_R13;

-  uint unaff_R14D;

-  undefined1 unaff_R15B;

+  undefined4 uVar1;

+  undefined4 uVar2;

+  undefined8 uVar3;

+  void *pvVar4;

+  _exception *p_Var5;

+  char cVar6;

+  undefined1 uVar7;

+  ushort uVar8;

+  ushort uVar9;

+  uint uVar10;

+  int iVar11;

+  uint uVar12;

+  ulonglong uVar13;

+  longlong lVar14;

+  uint *puVar15;

+  int *piVar16;

+  undefined4 *puVar17;

+  uint uVar18;

+  longlong *plVar19;

+  ushort *puVar20;

+  ushort *puVar21;

+  int iVar22;

+  undefined8 *puVar23;

+  undefined8 *puVar24;

+  uint *puVar25;

+  longlong lVar26;

+  ushort uVar27;

+  undefined8 *puVar28;

+  int *piVar29;

+  uint *puVar30;

+  size_t _Size;

+  byte *pbVar31;

+  uint uVar32;

+  uint uVar33;

+  undefined4 uVar34;

+  uint *puVar35;

+  bool bVar36;

+  undefined1 auStack_ab8 [32];

+  int local_a98;

+  longlong *local_a90;

+  undefined8 local_a88;

+  undefined8 local_a80;

+  char local_a78;

+  undefined8 *local_a70;

+  uint *local_a68;

+  uint local_a60;

+  char local_a5c;

+  char local_a5b;

+  byte local_a5a;

+  byte local_a59;

+  _exception *local_a58;

+  ushort local_a50 [2];

+  uint local_a4c;

+  uint local_a48 [2];

+  longlong local_a40;

+  uint *local_a38;

+  undefined4 local_a30;

+  uint local_a2c;

+  undefined8 local_a28;

+  undefined8 *puStack_a20;

+  longlong local_a18;

+  undefined8 *local_a10;

+  uint local_a08;

+  uint local_a04;

+  uint local_a00;

+  undefined4 local_9fc;

+  uint local_9f8 [6];

+  uint local_9e0 [2];

+  undefined8 local_9d8;

+  undefined8 local_9d0;

+  undefined8 local_9c8;

+  ulonglong local_9c0;

+  void *pvStack_9b8;

+  uint local_9b0 [2];

+  uint5 uStack_9a8;

+  undefined3 uStack_9a3;

+  undefined8 local_9a0;

+  undefined8 uStack_998;

+  ulonglong local_990;

+  undefined8 local_988;

+  undefined8 uStack_980;

+  undefined8 local_978;

+  undefined8 uStack_970;

+  undefined8 local_968;

+  uint local_958 [2];

+  undefined8 local_950;

+  longlong local_948;

+  undefined8 local_940;

+  longlong local_938;

+  undefined8 local_930;

+  longlong local_928;

+  longlong local_920;

+  longlong local_918;

+  undefined4 local_910;

+  undefined4 local_90c;

+  longlong local_908;

+  undefined4 local_900 [2];

+  undefined4 local_8f8 [4];

+  undefined8 local_8e8;

+  undefined8 uStack_8e0;

+  undefined8 local_8d8;

+  undefined8 uStack_8d0;

+  undefined8 local_8c8;

+  undefined8 uStack_8c0;

+  undefined8 local_8b8;

+  undefined8 local_8b0;

+  undefined8 local_8a8;

+  longlong local_8a0;

+  undefined4 local_898;

+  undefined4 local_894;

+  uint local_890;

+  longlong local_888;

+  undefined8 local_868;

+  undefined8 uStack_860;

+  undefined8 local_858;

+  undefined8 uStack_850;

+  undefined8 local_848;

+  longlong lStack_840;

+  undefined8 local_838;

+  ulonglong uStack_830;

+  undefined8 local_828;

+  undefined8 uStack_820;

+  undefined8 local_818;

+  longlong lStack_810;

+  longlong local_808;

+  undefined8 uStack_800;

+  ulonglong local_7f8;

+  longlong local_7f0;

+  longlong lStack_7e8;

+  longlong local_7e0;

+  undefined8 uStack_7d8;

+  undefined8 local_7d0;

+  undefined8 local_7c8;

+  undefined8 uStack_7c0;

+  undefined8 local_7b8;

+  undefined8 uStack_7b0;

+  undefined4 local_7a8;

+  undefined8 local_7a0;

+  undefined8 uStack_798;

+  uint local_788;

+  uint local_784;

+  undefined8 local_780;

+  longlong local_778;

+  undefined8 local_770;

+  longlong local_768;

+  undefined8 local_760;

+  longlong local_758;

+  longlong local_750;

+  longlong local_748;

+  undefined4 local_740;

+  undefined4 local_73c;

+  uint local_738;

+  uint local_734;

+  undefined8 local_730;

+  longlong local_728;

+  undefined8 local_720;

+  longlong local_718;

+  undefined8 local_710;

+  longlong local_708;

+  longlong local_700;

+  longlong local_6f8;

+  longlong local_6f0;

+  undefined4 local_6e8;

+  undefined4 local_6e4;

+  undefined8 local_6d8;

+  undefined8 uStack_6d0;

+  undefined8 local_6c8;

+  undefined8 uStack_6c0;

+  undefined8 local_6b8;

+  undefined8 uStack_6b0;

+  undefined4 local_6a8;

+  undefined8 local_698;

+  undefined8 local_690;

+  uint local_688;

+  undefined8 local_680;

+  undefined8 local_678;

+  undefined4 local_670;

+  undefined8 local_668;

+  uint local_660;

+  undefined4 local_65c;

+  longlong local_628;

+  longlong local_620;

+  longlong local_618;

+  longlong local_610;

+  longlong local_608;

+  uint local_5f8 [20];

+  uint local_5a8 [16];

+  undefined8 local_568 [9];

+  undefined8 local_520;

+  undefined8 local_518;

+  undefined8 local_3a8;

+  undefined8 local_3a0;

+  ushort local_398 [4];

+  undefined8 auStack_390 [33];

+  undefined8 local_288;

+  ushort local_280 [252];

+  ushort local_88 [32];

+  ulonglong local_48;

   

-  cVar14 = (char)unaff_EDI;

-  if (unaff_R13 != (char *)0x0) {

-    *unaff_R13 = cVar14;

-    uVar10 = *(ulonglong *)(unaff_RBP + 0x7a);

-    if (uVar10 < 0x40000) {

-      uVar10 = 0x40000;

-    }

-    *(ulonglong *)(unaff_R13 + 0x18) = uVar10;

-    *(undefined8 *)(unaff_R13 + 0x10) = *(undefined8 *)(unaff_RBP + 0x7c);

-    *(ulonglong *)(unaff_R13 + 8) = (ulonglong)(uint)unaff_RBP[0x78];

+  local_48 = __security_cookie ^ (ulonglong)auStack_ab8;

+  local_a68 = param_5;

+  local_a38 = param_5;

+  local_a70 = param_3;

+  local_a4c = param_4;

+  local_a18 = param_1;

+  local_a10 = param_3;

+  memset(local_568,0,0x1d0);

+  local_868 = 0;

+  uStack_860 = 0;

+  puVar15 = (uint *)0x0;

+  uVar10 = 0;

+  local_a48[0] = 0;

+  memset(local_398,0,0x108);

+  local_a78 = 0;

+  local_a5a = 0;

+  local_9f8[2] = 0;

+  local_9f8[3] = 0;

+  local_9f8[0] = 0;

+  local_9f8[1] = 0;

+  local_a08 = 0;

+  local_9d8 = 0;

+  local_a00 = 0;

+  local_7c8 = 0;

+  uStack_7c0 = 0;

+  local_7b8 = 0;

+  uStack_7b0 = 0;

+  local_7a8 = 0;

+  local_7a0 = 0;

+  uStack_798 = 0;

+  local_9e0[0] = 0;

+  local_9e0[1] = 0;

+  local_a04 = 0;

+  local_9c8 = 0;

+  memset(&local_698,0,0x98);

+  local_8c8 = 0;

+  uStack_8c0 = 0;

+  uVar8 = 0;

+  local_a50[0] = 0;

+  local_a30 = 0;

+  local_5f8[1] = 0;

+  memset(local_5f8,0,0x44);

+  local_a40 = 0;

+  local_9f8[4] = 0;

+  memset(local_958,0,0x68);

+  memset(&local_788,0,0x50);

+  memset(&local_738,0,0x58);

+  local_7f0 = 0;

+  lStack_7e8 = 0;

+  local_7e0 = 0;

+  uStack_7d8 = 0;

+  local_7d0 = 0;

+  local_8e8 = 0;

+  uStack_8e0 = 0;

+  memset(&local_8b8,0,0x48);

+  local_858 = 0;

+  uStack_850 = 0;

+  local_848 = 0;

+  lStack_840 = 0;

+  local_838 = 0;

+  uStack_830 = 0;

+  local_828 = 0;

+  uStack_820 = 0;

+  local_818 = 0;

+  lStack_810 = 0;

+  local_808 = 0;

+  uStack_800 = 0;

+  local_7f8 = 0;

+  local_9fc = 0;

+  local_9c0 = 0;

+  pvStack_9b8 = (void *)0x0;

+  local_988 = 0;

+  uStack_980 = 0;

+  local_978 = 0;

+  uStack_970 = 0;

+  local_968 = (ulonglong)local_968._4_4_ << 0x20;

+  local_9d0 = 0;

+  memset(local_5a8,0,0x40);

+  pvVar4 = SystemReserved1[0xf];

+  local_8d8 = 0;

+  uStack_8d0 = 0;

+  local_9b0[0] = 0;

+  local_9b0[1] = 0;

+  _uStack_9a8 = 0;

+  local_9a0 = 0;

+  uStack_998 = 0;

+  local_990 = 0;

+  local_6d8 = 0;

+  uStack_6d0 = 0;

+  local_6c8 = 0;

+  uStack_6c0 = 0;

+  local_6b8 = 0;

+  uStack_6b0 = 0;

+  local_6a8 = 0;

+  local_a28 = 0;

+  local_a5b = '\0';

+  local_a59 = 0;

+  if (0x32 < param_2 - 1U) {

+    return 0xc0000003;

   }

-  unaff_RBP[8] = unaff_EDI;

-  PspMapThreadCreationFlags(unaff_RBP[0x1e2],unaff_RBP + 3);

-  if (*(char *)(unaff_RBP + 7) != cVar14) {

-    unaff_RBP[8] = 2;

-    unaff_RBP[3] = unaff_RBP[3] | 0x10;

-  }

-  if (*(char *)((longlong)unaff_RBP + 0x1d) != cVar14) {

-    unaff_RBP[0x1e0] = unaff_RBP[0x1e0] | 0x400;

-  }

-  if (*(char *)((longlong)unaff_RBP + 7) != cVar14) {

-    unaff_RBP[3] = unaff_RBP[3] | 0x400;

-  }

-  unaff_RBP[3] = unaff_RBP[3] | 0x60;

-  iVar8 = PspAllocateThread(*(undefined8 *)(unaff_RBP + 4),*(undefined8 *)(unaff_RBP + 0x32),

-                            unaff_R15B,unaff_RBP + 0x68);

-  if (iVar8 < 0) {

-    PspUnlockProcessExclusive(*(undefined8 *)(unaff_RBP + 4),*(undefined8 *)(unaff_RBP + 0x14));

-    PspRundownSingleProcess(*(undefined8 *)(unaff_RBP + 4),0);

-    cVar7 = (char)*unaff_RBP;

+  local_a60 = param_4;

+  if (param_2 == 9) {

+    if ((param_4 != 0x90) && (param_4 != 0x98)) {

+      return 0xc0000004;

+    }

     goto LAB_0;

   }

-  lVar1 = *(longlong *)(unaff_RBP + 0x10);

-  cVar7 = PsTestProtectedProcessIncompatibility(unaff_R15B,lVar1,*(undefined8 *)(unaff_RBP + 4));

-  if (cVar7 == '\0') {

-    uVar13 = unaff_RBP[0xe];

-    uVar15 = unaff_RBP[0xf];

+  if (param_2 == 0xc) {

+    uVar33 = param_4 - 0x30;

+LAB_1:

+    bVar36 = (uVar33 & 0xfffffff7) == 0;

+LAB_2:

+    if (!bVar36) {

+      return 0xc0000004;

+    }

   }

   else {

-    Feature_ID51912085__private_IsEnabledPreCheck();

-    uVar15 = unaff_RBP[0xf];

-    if ((uVar15 >> 0x19 & 1) != 0) {

-      uVar15 = uVar15 & 0xfdffffff |

-               ~*(uint *)(&DAT_1 + (ulonglong)(unaff_BL >> 4) * 0xc) & 0x1fffff;

-      if ((*(longlong *)(unaff_RBP + 0x8a) == 0) || (lVar1 == *(longlong *)(unaff_RBP + 0x8a))) {

-        uVar15 = uVar15 | unaff_R14D;

-      }

-    }

-    uVar13 = unaff_RBP[0xe];

-    if ((uVar13 >> 0x19 & 1) != 0) {

-      uVar13 = uVar13 & 0xfdffffff |

-               ~*(uint *)(&DAT_2 + (ulonglong)(unaff_BL >> 4) * 0xc) & 0x1fffff;

-      if ((*(longlong *)(unaff_RBP + 0x8a) == 0) || (lVar1 == *(longlong *)(unaff_RBP + 0x8a))) {

-        uVar13 = uVar13 | unaff_R14D;

+    if (param_2 == 0xd) {

+      uVar33 = param_4 - 0x50;

+      goto LAB_1;

+    }

+    if (param_2 == 0x13) {

+      if ((param_4 == 0x1b0) || (param_4 == 0x1c0)) goto LAB_0;

+      bVar36 = param_4 == 0x1d0;

+      goto LAB_2;

+    }

+    if (param_2 == 0x14) {

+      if (param_4 != 0x28) {

+        bVar36 = param_4 == 0x40;

+        goto LAB_2;

+      }

+    }

+    else if (param_2 == 0x1c) {

+      if (param_4 != 0x10) {

+        bVar36 = param_4 == 0x28;

+        goto LAB_2;

+      }

+    }

+    else if (param_2 == 0x1e) {

+      if (param_4 != 0x10) {

+        bVar36 = param_4 == 0x24;

+        goto LAB_2;

+      }

+    }

+    else if (param_2 == 0x2b) {

+      if (param_4 != 1) {

+        return 0xc0000004;

+      }

+    }

+    else {

+      local_a60 = *(uint *)(&DAT_3 + (longlong)param_2 * 4);

+      if (param_4 != local_a60) {

+        if (((((param_2 == 3) || (param_2 == 5)) || (param_2 == 0xb)) ||

+            ((param_2 == 0xe || (param_2 == 0x1f)))) || (param_2 == 0x25)) {

+          bVar36 = param_4 < local_a60;

+          local_a60 = param_4;

+          if (bVar36) {

+            return 0xc0000004;

+          }

+        }

+        else {

+          if (param_2 != 0x26) {

+            return 0xc0000004;

+          }

+          local_a60 = param_4;

+          if (param_4 != 0x20) {

+            return 0xc0000004;

+          }

+        }

       }

     }

   }

-  iVar8 = PspInsertProcess(*(undefined8 *)(unaff_RBP + 4),*(undefined8 *)(unaff_RBP + 0xc),uVar15,

-                           unaff_RBP[0x1e0],*(undefined8 *)(unaff_RBP + 0x8c));

-  iVar9 = PspInsertThread(*(undefined8 *)(unaff_RBP + 0x1a),*(undefined8 *)(unaff_RBP + 4),

-                          unaff_RBP + 0x54,unaff_RBP + 3,uVar13);

-  KiLeaveCriticalRegionUnsafe(*(undefined8 *)(unaff_RBP + 0x14));

-  if (iVar8 < 0) {

-    PspRundownSingleProcess(*(undefined8 *)(unaff_RBP + 4),0);

-    cVar7 = (char)*unaff_RBP;

+LAB_0:

+  uVar33 = local_a60;

+  uVar34 = 1;

+  local_a58 = SystemReserved1[0xf];

+  local_a5c = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+  local_a2c = local_a60;

+  if (local_a5c != '\0') {

+    if ((param_4 != 0) &&

+       (((ulonglong)param_3 & (ulonglong)(*(int *)(&DAT_4 + (longlong)param_2 * 4) - 1)) !=

+        0)) {

+                    /* WARNING: Subroutine does not return */

+      ExRaiseDatatypeMisalignment();

+    }

+    if (param_5 != (uint *)0x0) {

+      puVar35 = (uint *)&DAT_5;

+      if (param_5 < &DAT_5) {

+        puVar35 = param_5;

+      }

+      *puVar35 = *puVar35;

+    }

+  }

+  if (local_a18 == 0) {

+    lVar26 = *(longlong *)(*(longlong *)((longlong)pvVar4 + 0xb8) + 0x2a0);

+    local_a40 = lVar26;

+    if (lVar26 == 0) {

+      if ((param_2 - 0x1fU & 0xfffffff7) != 0) {

+        return 0xc0000022;

+      }

+    }

+    else {

+      ObfReferenceObjectWithTag(lVar26);

+    }

   }

   else {

-    iVar8 = iVar9;

-    if (iVar9 < 0) {

-LAB_3:

-      cVar7 = (char)*unaff_RBP;

+    local_a80 = 0;

+    local_a88 = 0;

+    local_a90 = &local_a40;

+    local_a98 = 0x79517350;

+    uVar13 = ObpReferenceObjectByHandleWithTag(local_a18,4,PsJobType,local_a5c);

+    lVar26 = local_a40;

+    if ((int)uVar13 < 0) {

+      return uVar13;

+    }

+  }

+  uVar12 = local_a4c;

+  puVar23 = local_a70;

+  local_a78 = '\0';

+  puVar35 = (uint *)0x0;

+  uVar32 = 0;

+  cVar6 = '\x01';

+  uVar18 = 1;

+  puVar25 = local_a68;

+  local_a48[0] = uVar33;

+  if (param_2 < 0x1b) {

+    if (param_2 == 0x1a) {

+      uVar10 = PspQueryJobHierarchyInterferenceCount(lVar26,local_a70);

+      if (-1 < (int)uVar10) {

+        local_a78 = cVar6;

+      }

+      puVar25 = local_a68;

+      puVar35 = puVar15;

+      local_a48[0] = ((int)uVar10 >> 0x1f & 0xfffffff8U) + 8;

+      goto LAB_6;

+    }

+    if (param_2 < 0xd) {

+      if (param_2 == 0xc) {

+LAB_7:

+        PspLockJobShared(lVar26,local_a58);

+        puVar35 = *(uint **)(lVar26 + 0x4c0);

+        if (puVar35 != (uint *)0x0) {

+          local_890 = *puVar35;

+          local_8b8 = *(undefined8 *)(puVar35 + 2);

+          local_8b0 = *(undefined8 *)(puVar35 + 4);

+          local_8a8 = *(undefined8 *)(puVar35 + 6);

+          local_888 = *(longlong *)(puVar35 + 8) << 0xc;

+          local_8a0 = *(longlong *)(puVar35 + 10) << 0xc;

+          puVar35 = puVar35 + 0xf;

+          do {

+            iVar11 = (int)puVar15;

+            puVar15 = (uint *)PspNotificationLimitRateControlToleranceField(&local_8b8);

+            *puVar15 = puVar35[-3];

+            puVar15 = (uint *)PspNotificationLimitRateControlToleranceIntervalField(&local_8b8);

+            *puVar15 = *puVar35;

+            puVar15 = (uint *)(ulonglong)(iVar11 + 1U);

+            puVar35 = puVar35 + 1;

+          } while ((int)(iVar11 + 1U) < 3);

+        }

+        PspUnlockJob(lVar26,local_a58);

+        puVar23 = local_a70;

+        puVar25 = local_a68;

+        if (local_a4c == 0x30) {

+          local_858 = local_8b8;

+          uStack_850 = local_8b0;

+          local_848 = local_8a8;

+          lStack_840 = local_8a0;

+          local_838 = CONCAT44(local_894,local_898);

+          uStack_830 = (ulonglong)local_890 & 0xffffffff00070204;

+          puVar35 = (uint *)&local_858;

+        }

+        else if (local_a4c == 0x38) {

+          local_828 = local_8b8;

+          uStack_820 = local_8b0;

+          local_818 = local_8a8;

+          lStack_810 = local_888;

+          local_808 = local_8a0;

+          uStack_800 = CONCAT44(local_894,local_898);

+          local_7f8 = (ulonglong)local_890 & 0xffffffff00278204;

+          puVar35 = (uint *)&local_828;

+        }

+        else {

+          puVar35 = (uint *)&local_8b8;

+        }

+        goto LAB_6;

+      }

+      if (param_2 < 7) {

+        if (param_2 == 6) {

+          local_a04 = *(uint *)(lVar26 + 0x224);

+          puVar35 = &local_a04;

+          goto LAB_6;

+        }

+        if (param_2 == 1) goto LAB_8;

+        if (param_2 == 2) goto LAB_9;

+        if (param_2 == 3) {

+          local_a48[0] = 0;

+          uVar10 = PspQueryJobHierarchyProcessIdList(lVar26,local_a70,local_a4c,local_a48);

+          puVar25 = local_a68;

+          puVar35 = puVar15;

+          local_a78 = cVar6;

+          goto LAB_6;

+        }

+        if (param_2 == 4) {

+          PspLockJobShared(lVar26,local_a58);

+          local_a08 = *(uint *)(lVar26 + 0x220);

+          PspUnlockJob(lVar26,local_a58);

+          puVar35 = &local_a08;

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          goto LAB_6;

+        }

+        if (param_2 == 5) {

+          local_968 = 0;

+          *local_a70 = 0;

+          local_a70[1] = 0;

+          local_a70[2] = 0;

+          local_a70[3] = 0;

+          local_a70[4] = 0;

+          puVar35 = puVar15;

+          uVar10 = 0;

+          local_a78 = cVar6;

+          goto LAB_6;

+        }

+      }

+      else {

+        if (param_2 == 8) {

+LAB_8:

+          PspQueryJobHierarchyAccountingInformation(lVar26,local_568);

+          puVar35 = (uint *)local_568;

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          goto LAB_6;

+        }

+        if (param_2 == 9) {

+LAB_9:

+          PspLockJobShared(lVar26,local_a58);

+          local_680 = *(undefined8 *)(lVar26 + 0xf0);

+          local_678 = *(undefined8 *)(lVar26 + 0xf8);

+          local_670 = *(undefined4 *)(lVar26 + 0x104);

+          local_660 = (uint)*(byte *)(lVar26 + 0x44d);

+          local_65c = *(undefined4 *)(lVar26 + 0x244);

+          iVar11 = KeIsSingleGroupAffinityEx(lVar26 + 0x108,local_a50);

+          if (iVar11 == 0) {

+            local_668 = 0;

+          }

+          else {

+            local_668 = *(undefined8 *)(lVar26 + 0x110 + (ulonglong)local_a50[0] * 8);

+          }

+          local_698 = *(undefined8 *)(lVar26 + 0xe0);

+          local_690 = *(undefined8 *)(lVar26 + 0xe8);

+          uVar12 = PspGetJobLimitInformationValidFlags(param_2,local_a4c);

+          local_688 = *(uint *)(lVar26 + 0x100) & (uVar12 | 0x7fff);

+          if (param_2 == 9) {

+            PspLockJobMemoryLimitsShared(lVar26,0);

+            local_628 = *(longlong *)(lVar26 + 0x2b0) << 0xc;

+            local_620 = *(longlong *)(lVar26 + 0x2b8) << 0xc;

+            local_610 = *(longlong *)(lVar26 + 0x2d0) << 0xc;

+            local_608 = *(longlong *)(lVar26 + 0x2c0) << 0xc;

+            PspUnlockJobMemoryLimitsShared(lVar26,0);

+            PspUnlockJob(lVar26,local_a58);

+            local_618 = *(longlong *)(lVar26 + 0x2c8) << 0xc;

+          }

+          else {

+            PspUnlockJob(lVar26,local_a58);

+          }

+          puVar35 = (uint *)&local_698;

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          goto LAB_6;

+        }

+        if (param_2 == 10) {

+          PspLockJobListShared();

+          PspUnlockJobListShared(local_a58);

+          puVar35 = local_9f8 + 4;

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          goto LAB_6;

+        }

+        if (param_2 == 0xb) {

+          if ((local_a68 != (uint *)0x0) && ((local_a4c & 1) == 0)) {

+            PspLockJobShared(lVar26,local_a58);

+            uVar9 = *(ushort *)(lVar26 + 0x108);

+            if (uVar9 != 0) {

+              plVar19 = (longlong *)(lVar26 + 0x110);

+              puVar35 = puVar15;

+              uVar27 = local_a50[0];

+              do {

+                if (*plVar19 != 0) {

+                  local_88[(longlong)puVar35] = uVar27;

+                  puVar35 = (uint *)(ulonglong)((int)puVar35 + 1);

+                }

+                uVar32 = (uint)puVar35;

+                uVar8 = uVar8 + 1;

+                plVar19 = plVar19 + 1;

+                uVar27 = uVar8;

+              } while (uVar8 < uVar9);

+            }

+            PspUnlockJob(lVar26,local_a58);

+            puVar23 = local_a70;

+            local_a48[0] = uVar32 * 2;

+            bVar36 = uVar12 < local_a48[0];

+            uVar33 = local_a48[0];

+            if (uVar12 < local_a48[0]) {

+              uVar33 = local_a2c;

+            }

+            local_a78 = cVar6;

+            local_a2c = uVar33;

+            RtlCopyMemory(local_a70,local_88,(ulonglong)uVar33);

+            puVar25 = local_a68;

+            puVar35 = puVar15;

+            uVar10 = -(uint)bVar36 & 0xc0000023;

+            goto LAB_6;

+          }

+          goto LAB_10;

+        }

+      }

     }

     else {

-      lVar11 = PsGetProcessServerSilo(*(undefined8 *)(unaff_RBP + 4));

-      if (lVar11 != *(longlong *)(unaff_RBP + 0xd2)) {

-        iVar8 = -0x3ffffdd3;

-        goto LAB_3;

-      }

-      iVar8 = PspCreateObjectHandle(*(undefined8 *)(unaff_RBP + 4),unaff_RBP + 0xec,PsProcessType);

-      if (iVar8 < 0) {

-        cVar7 = (char)*unaff_RBP;

-LAB_4:

-        if (iVar8 < 0) {

-          if (((unaff_RBP[0x1b0] & 0x200) != 0) || ((*(uint *)(lVar1 + 0x5fc) & 0x1000) != 0)) {

-            unaff_R14D = unaff_EDI & 0xff;

-          }

-          ObCloseHandle(*(undefined8 *)(unaff_RBP + 0x1b2),(char)unaff_R14D);

-        }

+      if (param_2 == 0xd) {

+LAB_11:

+        local_a60 = local_a60 & 0xff000000;

+        PspQueryJobHierarchyAccountingInformation(lVar26,local_568);

+        local_950 = local_520;

+        local_940 = local_518;

+        local_930 = local_568[0];

+        PspLockJobExclusive(lVar26,local_a58);

+        if ((*(uint *)(lVar26 + 0x610) & 0x4008) != 0x4008) {

+          LOCK();

+          *(uint *)(lVar26 + 0x610) = *(uint *)(lVar26 + 0x610) & 0xfffffffb;

+          UNLOCK();

+          lVar26 = local_a40;

+        }

+        PspLockJobMemoryLimitsShared(lVar26,0);

+        local_920 = *(longlong *)(lVar26 + 0x4b8) << 0xc;

+        PspUnlockJobMemoryLimitsShared(lVar26,0);

+        if (*(undefined4 **)(lVar26 + 0x4c0) == (undefined4 *)0x0) {

+          local_958[0] = 0;

+          local_958[1] = 0;

+          local_948 = 0;

+          local_938 = 0;

+          local_928 = 0;

+          local_908 = 0;

+          local_918 = 0;

+          puVar35 = puVar15;

+          do {

+            iVar11 = (int)puVar35;

+            puVar17 = (undefined4 *)PspLimitViolationRateControlToleranceLimitField(local_958);

+            *puVar17 = 0;

+            puVar35 = (uint *)(ulonglong)(iVar11 + 1U);

+          } while ((int)(iVar11 + 1U) < 3);

+        }

+        else {

+          local_958[1] = *(undefined4 *)(*(longlong *)(lVar26 + 0x4c0) + 4);

+          local_958[0] = **(undefined4 **)(lVar26 + 0x4c0);

+          lVar14 = *(longlong *)(lVar26 + 0x4c0);

+          local_948 = *(longlong *)(lVar14 + 0x48);

+          if (local_948 == 0) {

+            local_948 = *(longlong *)(lVar14 + 8);

+          }

+          local_938 = *(longlong *)(lVar14 + 0x50);

+          if (local_938 == 0) {

+            local_938 = *(longlong *)(lVar14 + 0x10);

+          }

+          local_928 = *(longlong *)(lVar14 + 0x58);

+          if (local_928 == 0) {

+            local_928 = *(longlong *)(lVar14 + 0x18);

+          }

+          local_908 = *(longlong *)(lVar14 + 0x60);

+          if (local_908 == 0) {

+            local_908 = *(longlong *)(lVar14 + 0x20);

+          }

+          local_908 = local_908 << 0xc;

+          local_918 = *(longlong *)(lVar14 + 0x68);

+          if (local_918 == 0) {

+            local_918 = *(longlong *)(lVar14 + 0x28);

+          }

+          local_918 = local_918 << 0xc;

+          puVar35 = &local_a60;

+          piVar29 = (int *)(lVar14 + 0x30);

+          puVar25 = puVar15;

+          do {

+            iVar22 = (int)puVar25;

+            piVar16 = (int *)PspLimitViolationRateControlToleranceLimitField(local_958);

+            iVar11 = piVar29[0x10];

+            if (iVar11 == 0) {

+              iVar11 = *piVar29;

+            }

+            else {

+              *(undefined1 *)puVar35 = 1;

+            }

+            *piVar16 = iVar11;

+            puVar25 = (uint *)(ulonglong)(iVar22 + 1U);

+            piVar29 = piVar29 + 1;

+            puVar35 = (uint *)((longlong)puVar35 + 1);

+          } while ((int)(iVar22 + 1U) < 3);

+        }

+        puVar35 = &local_a60;

+        local_a38 = (uint *)0x3c;

+        do {

+          puVar25 = *(uint **)(lVar26 + 0x4c0);

+          iVar11 = (int)puVar15;

+          uVar34 = 1;

+          if ((puVar25 != (uint *)0x0) &&

+             (puVar30 = local_a38, uVar10 = PspRateControlLimitFlag(puVar15),

+             (*puVar25 & uVar10) != 0)) {

+            uVar34 = *(undefined4 *)((longlong)puVar30 + (longlong)puVar25);

+          }

+          local_a30 = uVar34;

+          local_a98 = iVar11;

+          PspQueryRateControlHistory(lVar26,uVar34,(char)*puVar35,&local_9fc);

+          p_Var5 = local_a58;

+          if (iVar11 == 0) {

+            puVar17 = local_8f8;

+          }

+          else if (iVar11 == 1) {

+            puVar17 = local_900;

+          }

+          else {

+            puVar17 = &local_910;

+          }

+          *puVar17 = local_9fc;

+          puVar15 = (uint *)(ulonglong)(iVar11 + 1U);

+          local_a38 = local_a38 + 1;

+          puVar35 = (uint *)((longlong)puVar35 + 1);

+        } while ((int)(iVar11 + 1U) < 3);

+        if (*(longlong *)(lVar26 + 0x4c0) != 0) {

+          *(undefined4 *)(*(longlong *)(lVar26 + 0x4c0) + 4) = 0;

+          memset((void *)(*(longlong *)(lVar26 + 0x4c0) + 0x48),0,0x40);

+        }

+        PspUnlockJob(lVar26,p_Var5);

+        if (local_a4c == 0x58) {

+          local_730 = local_950;

+          local_728 = local_948;

+          local_720 = local_940;

+          local_718 = local_938;

+          local_710 = local_930;

+          local_708 = local_928;

+          local_700 = local_920;

+          local_6f8 = local_908;

+          local_6f0 = local_918;

+          local_6e8 = local_910;

+          local_6e4 = local_90c;

+          local_738 = local_958[0] & 0x278204;

+          local_734 = local_958[1] & 0x278204;

+          puVar35 = &local_738;

+        }

+        else if (local_a4c == 0x50) {

+          local_780 = local_950;

+          local_778 = local_948;

+          local_770 = local_940;

+          local_768 = local_938;

+          local_760 = local_930;

+          local_758 = local_928;

+          local_750 = local_920;

+          local_748 = local_918;

+          local_740 = local_910;

+          local_73c = local_90c;

+          local_788 = local_958[0] & 0x70204;

+          local_784 = local_958[1] & 0x70204;

+          puVar35 = &local_788;

+        }

+        else {

+          puVar35 = local_958;

+        }

+        puVar25 = local_a68;

+        puVar23 = local_a70;

+        uVar10 = 0;

+        if ((PerfGlobalGroupMask & 0x80000) != 0) {

+          local_a90 = (longlong *)CONCAT62(local_a90._2_6_,0x726);

+          local_a98 = 0;

+          EtwTraceJobSetQuery(lVar26,param_2,local_958,&local_a30);

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+        }

+        goto LAB_6;

+      }

+      if (param_2 == 0xe) {

+        if ((local_a68 != (uint *)0x0) && ((local_a4c & 0xf) == 0)) {

+          PspLockJobShared(lVar26,local_a58);

+          lVar14 = 2;

+          if ((*(uint *)(lVar26 + 0x100) & 0x10) == 0) {

+            puVar23 = (undefined8 *)&KeActiveProcessors;

+            puVar20 = local_398;

+            do {

+              uVar3 = puVar23[1];

+              *(undefined8 *)puVar20 = *puVar23;

+              *(undefined8 *)(puVar20 + 4) = uVar3;

+              uVar3 = puVar23[3];

+              *(undefined8 *)(puVar20 + 8) = puVar23[2];

+              *(undefined8 *)(puVar20 + 0xc) = uVar3;

+              uVar3 = puVar23[5];

+              *(undefined8 *)(puVar20 + 0x10) = puVar23[4];

+              *(undefined8 *)(puVar20 + 0x14) = uVar3;

+              uVar3 = puVar23[7];

+              *(undefined8 *)(puVar20 + 0x18) = puVar23[6];

+              *(undefined8 *)(puVar20 + 0x1c) = uVar3;

+              uVar3 = puVar23[9];

+              *(undefined8 *)(puVar20 + 0x20) = puVar23[8];

+              *(undefined8 *)(puVar20 + 0x24) = uVar3;

+              uVar3 = puVar23[0xb];

+              *(undefined8 *)(puVar20 + 0x28) = puVar23[10];

+              *(undefined8 *)(puVar20 + 0x2c) = uVar3;

+              uVar34 = *(undefined4 *)((longlong)puVar23 + 100);

+              uVar1 = *(undefined4 *)(puVar23 + 0xd);

+              uVar2 = *(undefined4 *)((longlong)puVar23 + 0x6c);

+              *(undefined4 *)(puVar20 + 0x30) = *(undefined4 *)(puVar23 + 0xc);

+              *(undefined4 *)(puVar20 + 0x32) = uVar34;

+              *(undefined4 *)(puVar20 + 0x34) = uVar1;

+              *(undefined4 *)(puVar20 + 0x36) = uVar2;

+              puVar21 = puVar20 + 0x40;

+              uVar34 = *(undefined4 *)((longlong)puVar23 + 0x74);

+              uVar1 = *(undefined4 *)(puVar23 + 0xf);

+              uVar2 = *(undefined4 *)((longlong)puVar23 + 0x7c);

+              *(undefined4 *)(puVar20 + 0x38) = *(undefined4 *)(puVar23 + 0xe);

+              *(undefined4 *)(puVar20 + 0x3a) = uVar34;

+              *(undefined4 *)(puVar20 + 0x3c) = uVar1;

+              *(undefined4 *)(puVar20 + 0x3e) = uVar2;

+              puVar23 = puVar23 + 0x10;

+              lVar14 = lVar14 + -1;

+              puVar20 = puVar21;

+            } while (lVar14 != 0);

+            *(undefined8 *)puVar21 = *puVar23;

+          }

+          else {

+            puVar23 = (undefined8 *)(lVar26 + 0x108);

+            puVar20 = local_398;

+            do {

+              uVar3 = puVar23[1];

+              *(undefined8 *)puVar20 = *puVar23;

+              *(undefined8 *)(puVar20 + 4) = uVar3;

+              uVar3 = puVar23[3];

+              *(undefined8 *)(puVar20 + 8) = puVar23[2];

+              *(undefined8 *)(puVar20 + 0xc) = uVar3;

+              uVar3 = puVar23[5];

+              *(undefined8 *)(puVar20 + 0x10) = puVar23[4];

+              *(undefined8 *)(puVar20 + 0x14) = uVar3;

+              uVar3 = puVar23[7];

+              *(undefined8 *)(puVar20 + 0x18) = puVar23[6];

+              *(undefined8 *)(puVar20 + 0x1c) = uVar3;

+              uVar3 = puVar23[9];

+              *(undefined8 *)(puVar20 + 0x20) = puVar23[8];

+              *(undefined8 *)(puVar20 + 0x24) = uVar3;

+              uVar3 = puVar23[0xb];

+              *(undefined8 *)(puVar20 + 0x28) = puVar23[10];

+              *(undefined8 *)(puVar20 + 0x2c) = uVar3;

+              uVar34 = *(undefined4 *)((longlong)puVar23 + 100);

+              uVar1 = *(undefined4 *)(puVar23 + 0xd);

+              uVar2 = *(undefined4 *)((longlong)puVar23 + 0x6c);

+              *(undefined4 *)(puVar20 + 0x30) = *(undefined4 *)(puVar23 + 0xc);

+              *(undefined4 *)(puVar20 + 0x32) = uVar34;

+              *(undefined4 *)(puVar20 + 0x34) = uVar1;

+              *(undefined4 *)(puVar20 + 0x36) = uVar2;

+              puVar21 = puVar20 + 0x40;

+              uVar34 = *(undefined4 *)((longlong)puVar23 + 0x74);

+              uVar1 = *(undefined4 *)(puVar23 + 0xf);

+              uVar2 = *(undefined4 *)((longlong)puVar23 + 0x7c);

+              *(undefined4 *)(puVar20 + 0x38) = *(undefined4 *)(puVar23 + 0xe);

+              *(undefined4 *)(puVar20 + 0x3a) = uVar34;

+              *(undefined4 *)(puVar20 + 0x3c) = uVar1;

+              *(undefined4 *)(puVar20 + 0x3e) = uVar2;

+              puVar23 = puVar23 + 0x10;

+              lVar14 = lVar14 + -1;

+              puVar20 = puVar21;

+            } while (lVar14 != 0);

+            *(undefined8 *)puVar21 = *puVar23;

+          }

+          PspUnlockJob(lVar26);

+          memset(&local_288,0,(ulonglong)local_398[0] << 4);

+          puVar23 = local_a70;

+          if (local_398[0] != 0) {

+            puVar24 = &local_288;

+            puVar28 = auStack_390;

+            uVar9 = local_a50[0];

+            do {

+              *(ushort *)(puVar24 + 1) = uVar9;

+              *puVar24 = *puVar28;

+              uVar8 = uVar8 + 1;

+              puVar28 = puVar28 + 1;

+              puVar24 = puVar24 + 2;

+              uVar9 = uVar8;

+            } while (uVar8 < local_398[0]);

+          }

+          local_a48[0] = (uint)local_398[0] << 4;

+          bVar36 = uVar12 < local_a48[0];

+          uVar33 = local_a48[0];

+          if (bVar36) {

+            uVar33 = uVar12;

+          }

+          local_a78 = cVar6;

+          local_a60 = uVar33;

+          RtlCopyMemory(local_a70,&local_288,(ulonglong)uVar33);

+          puVar25 = local_a68;

+          uVar10 = -(uint)bVar36 & 0xc0000023;

+          goto LAB_6;

+        }

+LAB_10:

+        puVar35 = puVar15;

+        uVar10 = 0xc000000d;

+        goto LAB_6;

+      }

+      if (param_2 == 0xf) {

+        PspLockJobShared(lVar26,local_a58);

+        lVar14 = *(longlong *)(lVar26 + 0x4d8);

+        if ((lVar14 != 0) && (uVar12 = *(uint *)(lVar14 + 0x28), (uVar12 & 0x40) == 0)) {

+          uVar18 = (uVar12 & 4 | 2) >> 1;

+          uVar32 = uVar18 | 4;

+          if ((uVar12 & 1) == 0) {

+            uVar32 = uVar18;

+          }

+          uVar18 = uVar32 | 8;

+          if ((uVar12 & 2) == 0) {

+            uVar18 = uVar32;

+          }

+          uVar32 = uVar18 | 0x10;

+          if ((uVar12 & 0x20) == 0) {

+            uVar32 = uVar18;

+          }

+          local_9e0[0] = uVar32 | 0x20;

+          if ((uVar12 & 0x80) == 0) {

+            local_9e0[0] = uVar32;

+          }

+          local_9e0[1] = *(undefined4 *)(lVar14 + 0x2c);

+        }

+        PspUnlockJob(lVar26,local_a58);

+        puVar35 = local_9e0;

+        puVar25 = local_a68;

+        puVar23 = local_a70;

+        goto LAB_6;

+      }

+      if (param_2 == 0x10) {

+        local_a00 = *(uint *)(lVar26 + 0x450);

+        puVar35 = &local_a00;

+        goto LAB_6;

+      }

+      if (param_2 == 0x11) {

+        local_9d8 = *(undefined8 *)(lVar26 + 0x238);

+        puVar35 = (uint *)&local_9d8;

+        goto LAB_6;

+      }

+      if (param_2 == 0x12) {

+        local_8c8 = local_8c8 & 0xffffffffffff;

+        PspLockJobShared(lVar26,local_a58);

+        local_8c8 = CONCAT44(CONCAT22(local_8c8._6_2_,

+                                      CONCAT11((char)(*(uint *)(lVar26 + 0x610) >> 0x13),

+                                               (char)(*(uint *)(lVar26 + 0x610) >> 9))),

+                             ~*(uint *)(lVar26 + 0x614)) & 0xffff010100000008 | 7;

+        uStack_8c0 = *(undefined8 *)(lVar26 + 0x4a0);

+        PspUnlockJob(lVar26,local_a58);

+        puVar35 = (uint *)&local_8c8;

+        puVar25 = local_a68;

+        puVar23 = local_a70;

+        goto LAB_6;

+      }

+      if (param_2 == 0x13) goto LAB_8;

+      if (param_2 == 0x14) {

+        uVar12 = PspAllocateAndQueryNotificationChannel(local_a58,lVar26,local_5a8);

+        puVar25 = local_a68;

+        puVar23 = local_a70;

+        puVar35 = local_5a8;

+        uVar10 = 0;

+        if ((int)uVar12 < 0) {

+          puVar35 = puVar15;

+          uVar10 = uVar12;

+        }

+        goto LAB_6;

+      }

+      if (param_2 == 0x15) {

+        local_a5a = (byte)(*(uint *)(lVar26 + 0x610) >> 10) & 1;

+        puVar35 = (uint *)&local_a5a;

+        goto LAB_6;

+      }

+    }

+  }

+  else if (param_2 < 0x28) {

+    if (param_2 == 0x27) {

+      if (lVar26 == 0) {

+        uVar10 = _GetStoragePropertyPost_SC_DEVICE__MEAAJW4_STORAGE_PROPERTY_ID__PEAU_STORAGE_DESCRIPTOR_HEADER___Z

+                           (local_a58);

+        uVar13 = (ulonglong)uVar10;

       }

       else {

-        puVar2 = *(undefined8 **)(unaff_RBP + 0x72);

-        if (puVar2 != (undefined8 *)0x0) {

-          uVar6 = *(undefined8 *)(unaff_RBP + 0x78);

-          *puVar2 = *(undefined8 *)(unaff_RBP + 0x76);

-          puVar2[1] = uVar6;

-          uVar6 = *(undefined8 *)(unaff_RBP + 0x7c);

-          puVar2[2] = *(undefined8 *)(unaff_RBP + 0x7a);

-          puVar2[3] = uVar6;

-          uVar3 = unaff_RBP[0x7f];

-          uVar4 = unaff_RBP[0x80];

-          uVar5 = unaff_RBP[0x81];

-          *(undefined4 *)(puVar2 + 4) = unaff_RBP[0x7e];

-          *(undefined4 *)((longlong)puVar2 + 0x24) = uVar3;

-          *(undefined4 *)(puVar2 + 5) = uVar4;

-          *(undefined4 *)((longlong)puVar2 + 0x2c) = uVar5;

-          uVar6 = *(undefined8 *)(unaff_RBP + 0x84);

-          puVar2[6] = *(undefined8 *)(unaff_RBP + 0x82);

-          puVar2[7] = uVar6;

-        }

-        **(undefined8 **)(unaff_RBP + 0x22) = *(undefined8 *)(unaff_RBP + 0x14e);

-        cVar7 = (char)*unaff_RBP;

-        if ((iVar8 < 0) ||

-           (iVar8 = PspUpdateCreateInfo(6,unaff_RBP + 0x68,*(undefined8 *)(unaff_RBP + 4)),

-           iVar8 < 0)) {

-          if (((unaff_RBP[0x14c] & 0x200) != 0) ||

-             (cVar12 = (char)unaff_R14D, (*(uint *)(lVar1 + 0x5fc) & 0x1000) != 0)) {

-            cVar12 = cVar14;

-          }

-          ObCloseHandle(*(undefined8 *)(unaff_RBP + 0x14e),cVar12);

-          goto LAB_4;

-        }

-      }

-    }

-    SeDeleteAccessState(unaff_RBP + 0xec);

-    if (iVar8 < 0) {

-      PsTerminateProcess(*(undefined8 *)(unaff_RBP + 4),iVar8);

+        PsGetJobServerSilo(lVar26,&local_a28);

+        uVar13 = local_a28;

+      }

+      _Size = (size_t)uVar33;

+      lVar14 = PsGetServerSiloGlobals(uVar13);

+      puVar23 = local_a70;

+      RtlCopyMemory(local_a70,*(void **)(lVar14 + 0x508),_Size);

+      puVar25 = local_a68;

+      uVar10 = uVar32;

+      local_a78 = cVar6;

+      goto LAB_6;

+    }

+    if (0x21 < param_2) {

+      if (param_2 == 0x22) goto LAB_11;

+      if (param_2 == 0x24) {

+        if ((*(uint *)(lVar26 + 0x610) & 0x40000000) != 0) {

+          local_8d8 = CONCAT44(local_8d8._4_4_,*(undefined4 *)(lVar26 + 0x5bc));

+          lVar14 = PsGetParentSilo(lVar26);

+          cVar6 = PsIsHostSilo(lVar14);

+          if (cVar6 == '\0') {

+            local_8d8 = CONCAT44(*(undefined4 *)(lVar14 + 0x5bc),(uint)local_8d8);

+          }

+          else {

+            local_8d8 = local_8d8 & 0xffffffff;

+          }

+          uStack_8d0 = CONCAT44(uStack_8d0._4_4_,*(undefined4 *)(lVar26 + 0x5b0));

+          uVar7 = PspIsSiloInServerSilo(lVar26);

+          uStack_8d0._0_5_ = CONCAT14(uVar7,(undefined4)uStack_8d0);

+          puVar35 = (uint *)&local_8d8;

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          goto LAB_6;

+        }

+      }

+      else if (param_2 == 0x25) {

+        lVar14 = PspGetJobSilo(lVar26);

+        if (lVar14 != 0) {

+          uVar10 = ObGetSiloRootDirectoryPath(lVar14,&local_9c0);

+          puVar23 = local_a70;

+          puVar25 = local_a68;

+          if (-1 < (int)uVar10) {

+            uVar13 = local_9c0 & 0xffff;

+            uVar33 = (ushort)local_9c0 + 0x10;

+            local_a60 = uVar33;

+            if (local_a4c < uVar33) {

+              uVar10 = 0xc0000023;

+              local_a78 = cVar6;

+            }

+            else {

+              local_a28 = (ulonglong)CONCAT22((ushort)local_9c0,(ushort)local_9c0);

+              puStack_a20 = local_a70 + 2;

+              if (local_a5c == '\0') {

+                local_a78 = cVar6;

+                RtlCopyVolatileMemory(local_a70,&local_a28,0x10);

+              }

+              else {

+                local_a78 = cVar6;

+                RtlCopyToUser();

+              }

+              if (local_a5c == '\0') {

+                RtlCopyVolatileMemory(puStack_a20,pvStack_9b8,uVar13);

+              }

+              else {

+                RtlCopyToUser();

+              }

+              if (local_a68 != (uint *)0x0) {

+                *local_a68 = uVar33;

+              }

+            }

+            puVar25 = local_a68;

+            ExFreePoolWithTag(pvStack_9b8,0);

+          }

+          goto LAB_6;

+        }

+      }

+      else {

+        if (param_2 != 0x26) goto LAB_12;

+        PsGetJobServerSilo(lVar26,&local_a28);

+        uVar13 = local_a28;

+        cVar6 = PsIsHostSilo(local_a28);

+        if (cVar6 == '\0') {

+          lVar14 = *(longlong *)(uVar13 + 0x5e0);

+          uStack_9a8 = (uint5)*(uint *)(lVar14 + 0x4fc);

+          local_990 = CONCAT44(NtBuildNumber,*(undefined4 *)(lVar14 + 0x538)) & 0xffffffffffff;

+          local_9b0[1] = *(undefined4 *)(lVar14 + 0x4f8);

+          if (local_a5c == '\0') {

+            local_a38 = (uint *)0x0;

+            MmQueryApiSetSchema(&local_a38,&local_a10);

+            lVar14 = PsGetServerSiloGlobals(uVar13);

+            local_9a0 = *(undefined8 *)(lVar14 + 0x3f0);

+            uStack_998 = *(undefined8 *)local_a38;

+          }

+          else {

+            local_9a0 = 0;

+            uStack_998 = 0;

+          }

+          local_9b0[0] = PsGetServerSiloServiceSessionId(uVar13);

+          puVar25 = local_a68;

+          puVar23 = local_a70;

+          puVar35 = local_9b0;

+          uVar10 = 0;

+          goto LAB_6;

+        }

+      }

+LAB_13:

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      uVar10 = 0xc0000509;

+      goto LAB_6;

+    }

+    if (param_2 == 0x21) goto LAB_7;

+    if (param_2 == 0x1c) {

+      uStack_7d8 = 0;

+      local_7d0 = 0;

+      PspLockJobMemoryLimitsShared(lVar26,local_a58);

+      lVar14 = local_a40;

+      lStack_7e8 = *(longlong *)(lVar26 + 0x2d0) << 0xc;

+      local_7f0 = *(longlong *)(lVar26 + 0x4b8) << 0xc;

+      local_7e0 = *(longlong *)(lVar26 + 0x620) << 0xc;

+      PspUnlockJobMemoryLimitsShared(local_a40,local_a58);

+      puVar35 = (uint *)&local_7f0;

+      lVar26 = lVar14;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

+    }

+    if (param_2 == 0x1d) {

+      local_9d0 = *(undefined8 *)(lVar26 + 0x620);

+      lVar26 = local_a40;

+      puVar35 = (uint *)&local_9d0;

+      uVar10 = 0;

+      goto LAB_6;

+    }

+    if (param_2 == 0x1e) {

+      local_7c8 = *(undefined8 *)(lVar26 + 0x5c0);

+      uStack_7c0 = *(undefined8 *)(lVar26 + 0x5c8);

+      if (local_a4c == 0x24) {

+        local_7b8 = *(undefined8 *)(lVar26 + 0x5d0);

+        uStack_7b0 = *(undefined8 *)(lVar26 + 0x5d8);

+        local_7a8 = *(undefined4 *)(lVar26 + 0x5bc);

+      }

+      puVar35 = (uint *)&local_7c8;

+      goto LAB_6;

+    }

+    if (param_2 == 0x1f) {

+      uVar10 = 0xc0000002;

+      goto LAB_6;

+    }

+    if (param_2 == 0x20) {

+      PspLockJobShared(lVar26,local_a58);

+      uVar13 = uStack_8e0;

+      lVar14 = *(longlong *)(lVar26 + 0x608);

+      if (lVar14 != 0) {

+        uStack_8e0._0_4_ = uVar18;

+        if ((*(uint *)(lVar14 + 0x30) & 1) != 0) {

+          uVar34 = 3;

+          uStack_8e0._0_4_ = 3;

+          local_8e8 = *(undefined8 *)(lVar14 + 0x28);

+        }

+        if ((*(uint *)(lVar14 + 0x30) & 2) != 0) {

+          uStack_8e0._5_3_ = SUB83(uVar13,5);

+          uStack_8e0 = CONCAT35(uStack_8e0._5_3_,CONCAT14(*(undefined1 *)(lVar14 + 0x40),uVar34)) |

+                       4;

+        }

+      }

+      PspUnlockJob(lVar26,local_a58);

+      puVar35 = (uint *)&local_8e8;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

     }

   }

-  ObfDereferenceObject(*(undefined8 *)(unaff_RBP + 0x1a));

-LAB_0:

-  ObfDereferenceObjectWithTag(*(undefined8 *)(unaff_RBP + 4),0x72437350);

-  if ((*(longlong *)(unaff_RBP + 0x96) != 0) && (DAT_5 != (code *)0x0)) {

-    (*DAT_5)();

+  else {

+    if (param_2 == 0x2a) {

+      memset(local_5f8,0,0x48);

+      PspLockJobShared(lVar26,local_a58);

+      uVar10 = PspQueryJobIoAttribution(lVar26,local_5f8);

+      PspUnlockJob(lVar26,local_a58);

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      puVar35 = local_5f8;

+      goto LAB_6;

+    }

+    if (param_2 == 0x2b) {

+      if ((*(longlong *)(lVar26 + 0x700) != 0) && (*(longlong *)(lVar26 + 0x700) != -1)) {

+        local_a5b = cVar6;

+      }

+      puVar35 = (uint *)&local_a5b;

+      uVar10 = 0;

+      goto LAB_6;

+    }

+    if (param_2 == 0x2c) {

+      local_7a0 = *(undefined8 *)(lVar26 + 0x5d0);

+      uStack_798 = *(undefined8 *)(lVar26 + 0x5d8);

+      puVar35 = (uint *)&local_7a0;

+      goto LAB_6;

+    }

+    if (param_2 == 0x2e) {

+      PspLockJobShared(lVar26,local_a58);

+      local_9c8 = *(undefined8 *)(lVar26 + 0x710);

+      PspUnlockJob(lVar26,local_a58);

+      puVar35 = (uint *)&local_9c8;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

+    }

+    if (param_2 == 0x2f) {

+      local_a59 = (byte)(*(uint *)(lVar26 + 0x614) >> 1) & 1;

+      puVar35 = (uint *)&local_a59;

+      goto LAB_6;

+    }

+    if (param_2 == 0x30) {

+      PspLockJobShared(lVar26,local_a58);

+      if (*(uint *)(lVar26 + 0x440) < 5) {

+        local_9f8[2] = uVar18;

+      }

+      local_9f8[3] = *(uint *)(lVar26 + 0x440);

+      PspUnlockJob(lVar26,local_a58);

+      puVar35 = local_9f8 + 2;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

+    }

+    if (param_2 == 0x31) {

+      PspLockJobShared(lVar26,local_a58);

+      if (*(uint *)(lVar26 + 0x448) < 8) {

+        local_9f8[0] = uVar18;

+      }

+      local_9f8[1] = *(uint *)(lVar26 + 0x448);

+      PspUnlockJob(lVar26,local_a58);

+      puVar35 = local_9f8;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

+    }

+    if (param_2 == 0x32) {

+      PsGetJobServerSilo(lVar26,&local_a28);

+      cVar6 = PsIsHostSilo(local_a28);

+      if (cVar6 == '\0') {

+        lVar14 = PsGetServerSiloGlobals(local_a28);

+        puVar23 = local_a70;

+        puVar25 = local_a68;

+        if (*(int *)(lVar14 + 0x53c) == 0) {

+          uVar10 = 0x80000022;

+        }

+        else {

+          local_6d8 = *(undefined8 *)(lVar14 + 0x558);

+          uStack_6d0 = *(undefined8 *)(lVar14 + 0x560);

+          local_6c8 = CONCAT44(local_6c8._4_4_,*(undefined4 *)(lVar14 + 0x540));

+          puVar20 = (ushort *)((longlong)&local_6c8 + 4);

+          pbVar31 = (byte *)(lVar14 + 0x544);

+          do {

+            *puVar20 = (ushort)*pbVar31;

+            uVar10 = (int)puVar15 + 1;

+            puVar15 = (uint *)(ulonglong)uVar10;

+            pbVar31 = pbVar31 + 1;

+            puVar20 = puVar20 + 1;

+          } while (uVar10 < 0xf);

+          puVar35 = (uint *)&local_6d8;

+          uVar10 = 0;

+        }

+        goto LAB_6;

+      }

+      goto LAB_13;

+    }

+    if (param_2 == 0x33) {

+      PspQueryJobHierarchyAccountingInformation(lVar26,local_568);

+      local_868 = local_3a8;

+      uStack_860 = local_3a0;

+      puVar35 = (uint *)&local_868;

+      puVar25 = local_a68;

+      puVar23 = local_a70;

+      goto LAB_6;

+    }

   }

-  PspDeleteMemoryPartitionContext(*(undefined8 *)(unaff_RBP + 0x16));

-  PspDeleteCreateProcessContext(unaff_RBP + 0x68);

-  if (*(longlong *)(unaff_RBP + 0x3c) != 0) {

-    FsRtlFreeExtraCreateParameterList();

+LAB_12:

+  puVar35 = puVar15;

+  uVar10 = 0xc0000003;

+LAB_6:

+  if (lVar26 != 0) {

+    ObfDereferenceObjectWithTag(lVar26,0x79517350);

   }

-  if (cVar7 != '\0') {

-    ObfDereferenceObject(*(undefined8 *)(unaff_RBP + 10));

+  if ((-1 < (int)uVar10) && (local_a78 == '\0')) {

+    RtlCopyMemory(puVar23,puVar35,(ulonglong)uVar33);

   }

-  return iVar8;

+  if (puVar25 != (uint *)0x0) {

+    *puVar25 = local_a48[0];

+  }

+  return (ulonglong)uVar10;

 }
```

## `PpmHeteroHgsCalculateContainmentCount`  (modified)

```diff
--- PpmHeteroHgsCalculateContainmentCount
+++ PopFxIdleWorkerTail
@@ -1,158 +1,10 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Control flow encountered bad instruction data */

 

-void PpmHeteroHgsCalculateContainmentCount(void)

+void PopFxIdleWorkerTail(void)

 

 {

-  longlong *plVar1;

-  longlong lVar2;

-  longlong lVar3;

-  code *pcVar4;

-  int iVar5;

-  undefined4 in_EAX;

-  int iVar6;

-  void *pvVar7;

-  char cVar8;

-  longlong *unaff_RBX;

-  longlong unaff_RBP;

-  undefined8 *unaff_RSI;

-  ulonglong unaff_RDI;

-  char cVar9;

-  int iVar10;

-  void *unaff_R13;

-  longlong *unaff_R14;

-  ulonglong unaff_R15;

-  ulonglong in_CR8;

-  ulonglong uVar11;

-  undefined1 local_res8 [24];

-  

-  PopIrpLockThread = (void *)CONCAT44(PopIrpLockThread._4_4_,in_EAX);

-  while (((undefined8 *)unaff_RBX[1] == unaff_RSI &&

-         (plVar1 = (longlong *)*unaff_RBX, (longlong *)plVar1[1] == unaff_RBX))) {

-    PopIrpWorkerList = plVar1;

-    plVar1[1] = (longlong)unaff_RSI;

-    PopIrpLockThread = unaff_R13;

-    KeReleaseInStackQueuedSpinLock(unaff_RBP + -0x50);

-    ExAcquireFastMutex(&PopIrpWorkerMutex);

-    PopIrpWorkerInFlightCount = PopIrpWorkerInFlightCount + 1;

-    cVar9 = (char)unaff_R13;

-    iVar10 = (int)unaff_R13;

-    if ((PopCreateIrpWorkerAllowed != cVar9) &&

-       ((((PopIrpWorkerInFlightCount == PopIrpWorkerCount && (PopIrpWorkerCount < 0xf)) &&

-         (PopIrpWorkerPendingCount == iVar10)) && (PopIrpWorkerRequested == cVar9)))) {

-      PopIrpWorkerRequested = '\x01';

-      KeSetEvent(&PopIrpWorkerControlEvent,0,0);

-    }

-    ExReleaseFastMutex(&PopIrpWorkerMutex);

-    unaff_R14 = unaff_RBX + -0x15;

-    lVar2 = unaff_RBX[2];

-    unaff_RSI = *(undefined8 **)(lVar2 + 0x28);

-    PoDeviceAcquireIrp(unaff_R14,CONCAT71((int7)((ulonglong)lVar2 >> 8),*(undefined1 *)(lVar2 + 1)))

-    ;

-    lVar2 = unaff_RBX[(longlong)*(char *)((longlong)unaff_RBX + -0x66) * 9 + 4];

-    if (((*(char *)(lVar2 + 0xb8) == (char)unaff_RDI) && (*(int *)(lVar2 + 0xbc) == 1)) &&

-       (*(undefined8 **)(lVar2 + 0x20) == unaff_RSI)) {

-      lVar3 = *(longlong *)(lVar2 + 200);

-      pvVar7 = unaff_R13;

-      if (*(longlong *)(lVar2 + 0x18) != 0) {

-        pvVar7 = *(void **)(*(longlong *)(*(longlong *)(lVar2 + 0x18) + 0x138) + 0x28);

-      }

-      iVar5 = *(int *)((longlong)pvVar7 + 0x9c);

-      *(undefined4 *)((longlong)pvVar7 + 0x9c) = *(undefined4 *)(lVar2 + 0xc0);

-      if (lVar3 != 0) {

-        iVar6 = PopFxGetDeviceDStateReason(lVar3);

-        *(int *)(lVar2 + 0x118) = iVar6;

-        *(char *)(lVar2 + 0xd0) = cVar9;

-        if (iVar6 == 1) {

-          *(undefined1 *)(lVar2 + 0xd0) = 1;

-        }

-        iVar6 = *(int *)(lVar2 + 0xc0);

-        *(bool *)(lVar2 + 0xd1) = iVar6 != iVar5;

-        if (iVar6 != iVar5) {

-          if (iVar6 == 1) {

-            LOCK();

-            *(uint *)(lVar3 + 0x20) = *(uint *)(lVar3 + 0x20) | 2;

-            UNLOCK();

-          }

-          else {

-            iVar5 = Feature_Sx_PEP_Notification_Synchronization__private_IsEnabledNoReportingNoInline

-                              ();

-            if ((iVar5 != 0) && ((*(uint *)(lVar3 + 0x360) & 1) == 0)) {

-              LOCK();

-              *(uint *)(lVar3 + 0x20) = *(uint *)(lVar3 + 0x20) | 0x800;

-              UNLOCK();

-            }

-          }

-          PopPepDeviceDState(*(undefined8 *)(lVar3 + 0x38),*(undefined4 *)(lVar2 + 0xc0),0,

-                             *(undefined4 *)(lVar2 + 0x118));

-        }

-      }

-      unaff_RDI = 2;

-    }

-    *(longlong **)(unaff_RBP + -0x20) = unaff_R14;

-    *(undefined8 **)(unaff_RBP + -0x18) = unaff_RSI;

-    uVar11 = in_CR8;

-    cVar8 = cVar9;

-    if (((*(uint *)(unaff_RSI + 6) & 0x2000) == 0) && (unaff_R14 == PopInrushIrp)) {

-      uVar11 = unaff_RDI;

-      if (KiIrqlFlags != iVar10) {

-        KiRaiseIrqlProcessIrqlFlags(in_CR8 & 0xff,unaff_RDI & 0xff);

-      }

-      cVar8 = '\x01';

-      unaff_R15 = in_CR8;

-    }

-    (**(code **)(unaff_RSI[1] + 0x120))(unaff_RSI,unaff_R14);

-    in_CR8 = uVar11;

-    if (cVar8 != '\0') {

-      if (KiIrqlFlags != iVar10) {

-        KiLowerIrqlProcessIrqlFlags(uVar11,unaff_R15 & 0xff);

-      }

-      in_CR8 = unaff_R15 & 0xff;

-    }

-    if (*(int *)((longlong)SystemReserved1[0xf] + 0x1e4) != iVar10) goto LAB_0;

-    *(undefined8 *)(unaff_RBP + -0x20) = 0;

-    *(undefined8 *)(unaff_RBP + -0x18) = 0;

-    ObfDereferenceObjectWithTag(unaff_RSI,0x72496f50);

-    ExAcquireFastMutex(&PopIrpWorkerMutex);

-    PopIrpWorkerInFlightCount = PopIrpWorkerInFlightCount - 1;

-    ExReleaseFastMutex(&PopIrpWorkerMutex);

-    unaff_RSI = &PopIrpWorkerList;

-    while (iVar5 = KeWaitForMutexObject(&PopIrpWorkerSemaphore,0,0,0), iVar5 == 0x102) {

-      ExAcquireFastMutex(&PopIrpWorkerMutex);

-      if ((PopCreateIrpWorkerAllowed == cVar9) ||

-         ((PopIrpWorkerInFlightCount == PopIrpWorkerCount - 1 &&

-          (PopIrpWorkerPendingCount == iVar10)))) {

-        cVar8 = '\x01';

-      }

-      else {

-        lVar2 = *(longlong *)(unaff_RBP + -0x38);

-        plVar1 = *(longlong **)(unaff_RBP + -0x30);

-        if ((*(longlong *)(lVar2 + 8) != unaff_RBP + -0x38) || (*plVar1 != unaff_RBP + -0x38))

-        goto LAB_1;

-        *plVar1 = lVar2;

-        *(longlong **)(lVar2 + 8) = plVar1;

-        cVar8 = cVar9;

-        PopIrpWorkerCount = PopIrpWorkerCount - 1;

-      }

-      ExReleaseFastMutex(&PopIrpWorkerMutex);

-      if (cVar8 == '\0') {

-        PsTerminateSystemThread(0);

-        return;

-      }

-    }

-    KeAcquireInStackQueuedSpinLock(&PopIrpLock);

-    PopIrpLockThread = SystemReserved1[0xf];

-    unaff_RBX = PopIrpWorkerList;

-  }

-LAB_1:

-  pcVar4 = (code *)swi(0x29);

-  (*pcVar4)(3);

-  register0x00000020 = (BADSPACEBASE *)local_res8;

-LAB_0:

-  *(ulonglong *)((longlong)register0x00000020 + 0x20) =

-       (ulonglong)*(uint *)((longlong)SystemReserved1[0xf] + 0x1e4);

-                    /* WARNING: Subroutine does not return */

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404e48e2;

-  KeBugCheckEx(0xa0,0x901,unaff_RSI,unaff_R14);

+                    /* WARNING: Bad instruction - Truncating control flow here */

+  halt_baddata();

 }
```

## `AlpcpEnumerateResourcesPort`  (modified)

```diff
--- AlpcpEnumerateResourcesPort
+++ AlpcpEnumerateResourcesPort
@@ -1,10 +1,46 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void AlpcpEnumerateResourcesPort(void)

+int AlpcpEnumerateResourcesPort

+              (longlong param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong *plVar1;

+  longlong lVar2;

+  int iVar3;

+  longlong lVar4;

+  undefined8 *puVar5;

+  

+  plVar1 = (longlong *)(param_1 + 0x148);

+  iVar3 = 0;

+  lVar4 = KeAbPreAcquire(plVar1,0,0);

+  LOCK();

+  lVar2 = *plVar1;

+  if (lVar2 == 0) {

+    *plVar1 = 0x11;

+  }

+  UNLOCK();

+  if (lVar2 != 0) {

+    ExfAcquirePushLockSharedEx(plVar1,0,lVar4,plVar1);

+  }

+  if (lVar4 != 0) {

+    *(undefined1 *)(lVar4 + 10) = 1;

+  }

+  puVar5 = *(undefined8 **)(param_1 + 0x150);

+  while ((puVar5 != (undefined8 *)(param_1 + 0x150) &&

+         ((*(char *)((longlong)puVar5 + 0x11) != '\x06' ||

+          (iVar3 = AlpcpViewSearchCallbackFunction(puVar5 + 6,param_4), -1 < iVar3))))) {

+    puVar5 = (undefined8 *)*puVar5;

+  }

+  plVar1 = (longlong *)(param_1 + 0x148);

+  LOCK();

+  lVar2 = *plVar1;

+  if (lVar2 == 0x11) {

+    *plVar1 = 0;

+  }

+  UNLOCK();

+  if (lVar2 != 0x11) {

+    ExfReleasePushLockShared(plVar1);

+  }

+  KeAbPostRelease(plVar1);

+  return iVar3;

 }
```

## `PopPowerAggregatorNotifyPdcPhaseState`  (modified)

```diff
--- PopPowerAggregatorNotifyPdcPhaseState
+++ PopPowerAggregatorNotifyPdcPhaseState
@@ -1,13 +1,63 @@
 

-void PopPowerAggregatorNotifyPdcPhaseState(byte *param_1)

+void PopPowerAggregatorNotifyPdcPhaseState(int param_1,char param_2)

 

 {

-  byte in_AL;

-  undefined7 in_register_00000001;

+  int iVar1;

+  undefined4 local_38;

+  undefined4 local_34;

+  undefined4 local_30;

+  int local_28 [8];

   

-  *param_1 = *param_1 & in_AL;

-  *(byte *)CONCAT71(in_register_00000001,in_AL) =

-       *(char *)CONCAT71(in_register_00000001,in_AL) + in_AL;

+  if (param_1 != 2) {

+    return;

+  }

+  local_28[2] = 0;

+  local_28[3] = 0;

+  local_28[0] = 0x11;

+  local_28[1] = 0;

+  local_28[4] = 0;

+  local_28[5] = 0;

+  local_28[6] = 0;

+  local_28[7] = 0;

+  PopAcquirePolicyLock();

+  PopAcquireRwLockExclusive(&PopPowerAggregatorLock);

+  if (param_2 == '\0') {

+    DAT_0 = 0;

+    goto LAB_1;

+  }

+  if (DAT_2 != 1) goto LAB_140757fd0;

+  PoModernStandbyActionInProgress = 1;

+  DAT_0 = 1;

+  if (DAT_3 == 1) {

+LAB_4:

+    local_28[0] = 0xd;

+  }

+  else if (DAT_3 == 2) {

+    local_28[0] = 0xe;

+  }

+  else if (DAT_3 == 3) {

+LAB_5:

+    PopPowerAggregatorHandleIntentUnsafe(3,0,0,0x35);

+  }

+  else if (DAT_3 == 4) {

+    iVar1 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+    if (iVar1 != 0) goto LAB_4;

+  }

+  else if ((DAT_3 == 5) &&

+          (iVar1 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline(),

+          iVar1 != 0)) goto LAB_5;

+  DAT_3 = 0;

+LAB_1:

+  PopPowerAggregatorEvaluateDozeTimers();

+  PopReleaseRwLock(&PopPowerAggregatorLock);

+  if (local_28[0] != 0x11) {

+    local_30 = 0;

+    local_28[1] = 0x80;

+    local_38 = 3;

+    local_34 = 0x80000024;

+    PopExecutePowerAction(local_28,0,&local_38,5,1);

+  }

+  PopReleasePolicyLock();

   return;

 }
```

## `PopIdleCsStateChanged`  (modified)

```diff
--- PopIdleCsStateChanged
+++ PopIdleCsStateChanged
@@ -1,163 +1,28 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-void PopIdleCsStateChanged(undefined8 param_1,undefined8 param_2)

+void PopIdleCsStateChanged(char param_1)

 

 {

   uint uVar1;

-  uint uVar2;

-  char cVar3;

-  undefined4 in_EAX;

-  undefined4 uVar4;

-  uint uVar5;

-  char *pcVar6;

-  char unaff_BL;

-  undefined8 *unaff_RBP;

-  byte unaff_DIL;

-  ulonglong uVar7;

-  undefined4 uVar8;

-  char *pcVar9;

-  undefined8 unaff_R12;

-  int unaff_R13D;

-  char unaff_R14B;

-  undefined4 unaff_R15D;

-  undefined8 in_XMM0_Qb;

-  undefined8 in_XMM1_Qb;

-  undefined8 uVar10;

-  undefined4 uVar11;

-  undefined8 in_stack_00000050;

-  undefined8 in_stack_00000058;

-  undefined8 in_stack_00000060;

-  undefined4 in_stack_00000070;

   

-  *(undefined8 *)((longlong)unaff_RBP + 0xdc) = param_1;

-  *(undefined8 *)((longlong)unaff_RBP + 0xe4) = in_XMM0_Qb;

-  *(undefined4 *)((longlong)unaff_RBP + 0xec) = in_EAX;

-  unaff_RBP[0x19] = param_2;

-  unaff_RBP[0x1a] = in_XMM1_Qb;

-  uVar10 = unaff_R12;

-  uVar4 = ZwUpdateWnfStateData();

-  uVar11 = (undefined4)((ulonglong)uVar10 >> 0x20);

-  uVar5 = (uint)unaff_R12;

-  if ((5 < DAT_0) &&

-     (cVar3 = _tlgKeywordOn(&DAT_0,0x400000000000), uVar2 = DAT_140f0b380,

-     uVar8 = DAT_1, cVar3 != '\0')) {

-    uVar7 = (ulonglong)DAT_2;

-    pcVar6 = "AC Power";

-    unaff_RBP[0x34] = unaff_RBP + -0xf;

-    *(undefined4 *)(unaff_RBP + -0xf) = uVar8;

-    unaff_RBP[0x35] = 4;

-    if ((byte)((byte)unaff_R13D & (byte)uVar2) == 0) {

-      pcVar6 = "DC Power";

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x36,pcVar6);

-    pcVar6 = "Battery Discharging";

-    pcVar9 = "-";

-    if ((uVar7 & 2) == 0) {

-      pcVar6 = "-";

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x38,pcVar6);

-    pcVar6 = "Battery Charging";

-    if ((unaff_DIL & (byte)uVar7) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x3a,pcVar6);

-    pcVar6 = "Battery Critical";

-    if ((byte)((byte)unaff_R15D & (byte)uVar7) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x3c,pcVar6);

-    pcVar6 = "Battery charge limiting mode";

-    if ((uVar7 & 0x10) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x3e,pcVar6);

-    pcVar6 = "Battery charging state power supply present";

-    if ((uVar7 & 0x20) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x40,pcVar6);

-    pcVar6 = "Battery charging state adequate";

-    if ((uVar7 & 0x40) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x42,pcVar6);

-    pcVar6 = "Battery trip point supported";

-    if ((uVar7 & 0x80) == 0) {

-      pcVar6 = pcVar9;

-    }

-    _tlgCreate1Sz_char(unaff_RBP + 0x44,pcVar6);

-    _tlgCreate1Sz_char(unaff_RBP + 0x46);

-    uVar2 = DAT_3;

-    uVar7 = (ulonglong)DAT_3;

-    in_stack_00000060._4_4_ = uVar5;

-    if (DAT_3 != 0) {

-      in_stack_00000060._4_4_ = (DAT_4 * 100 + (DAT_140f0b3b8 >> 1)) / DAT_140f0b3b8;

-    }

-    unaff_RBP[0x48] = (longlong)&stack0x00000060 + 4;

-    unaff_RBP[0x49] = 4;

-    if (uVar2 != 0) {

-      uVar5 = (uint)(((ulonglong)DAT_4 * 100000) / uVar7);

-    }

-    uVar1 = _DAT_5 & 0x40000000;

-    pcVar6 = "Relative Capacity Unit";

-    unaff_RBP[0x4b] = 4;

-    unaff_RBP[0x4a] = (longlong)&stack0x00000058 + 4;

-    *(uint *)(unaff_RBP + 1) = DAT_4;

-    unaff_RBP[0x4c] = unaff_RBP + 1;

-    unaff_RBP[0x4e] = (longlong)unaff_RBP + -0x14;

-    *(undefined4 *)((longlong)unaff_RBP + -0x24) = DAT_6;

-    unaff_RBP[0x50] = (longlong)unaff_RBP + -0x24;

-    *(undefined4 *)(unaff_RBP + -4) = DAT_7;

-    unaff_RBP[0x52] = unaff_RBP + -4;

-    *(undefined4 *)((longlong)unaff_RBP + -0x1c) = DAT_8;

-    unaff_RBP[0x54] = (longlong)unaff_RBP + -0x1c;

-    unaff_RBP[0x56] = unaff_RBP + -3;

-    if (uVar1 == 0) {

-      pcVar6 = "mWh Unit";

-    }

-    unaff_RBP[0x4d] = 4;

-    *(uint *)((longlong)unaff_RBP + -0x14) = uVar2;

-    unaff_RBP[0x4f] = 4;

-    unaff_RBP[0x51] = 4;

-    unaff_RBP[0x53] = 4;

-    unaff_RBP[0x55] = 4;

-    *(undefined4 *)(unaff_RBP + -3) = uVar8;

-    unaff_RBP[0x57] = 4;

-    in_stack_00000058._4_4_ = uVar5;

-    _tlgCreate1Sz_char(unaff_RBP + 0x58,pcVar6);

-    uVar8 = DAT_9;

-    unaff_RBP[0x5a] = unaff_RBP + -0xe;

-    *(undefined4 *)(unaff_RBP + -0xe) = uVar8;

-    unaff_RBP[0x5c] = &stack0x00000070;

-    unaff_RBP[0x5b] = 4;

-    unaff_RBP[0x5d] = 4;

-    in_stack_00000070 = uVar4;

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004cb2a,0,0,CONCAT44(uVar11,0x17));

-  }

-  if (in_stack_00000050._4_4_ == unaff_R13D) {

-    if (unaff_R14B == '\0') {

-      unaff_RBP[2] = _DAT_10;

-    }

-    else {

-      unaff_RBP[2] = unaff_R12;

-    }

-    ZwUpdateWnfStateData(&WNF_PO_DISCHARGE_START_FILETIME,unaff_RBP + 2,unaff_R15D,0);

-  }

-  if (unaff_BL != '\0') {

-    *unaff_RBP = unaff_R12;

-    *(undefined4 *)((longlong)unaff_RBP + 4) = 0xffffffff;

-    uVar4 = ZwUpdateWnfStateData(&WNF_PO_POWER_STATE_CHANGE);

-    if (5 < DAT_0) {

-      unaff_RBP[0x77] = 4;

-      unaff_RBP[0x76] = &stack0x00000070;

-      in_stack_00000070 = uVar4;

-      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004caf6,0,0,3);

+  PopAcquirePolicyLock();

+  DAT_0 = param_1;

+  uVar1 = PopGetModernStandbyTransitionReason(0);

+  if (param_1 == '\0') {

+    if ((0xffffff < uVar1) || ((uVar1 & 0xffffff) != 6)) {

+      PopIdleCancelAoAcDozeS4Timer(1);

+      _DAT_1 = 0;

     }

   }

-  PopReleaseRwLock(&PopCB);

-  PopReleaseRwLock(&PopPolicyDeviceLock);

+  else {

+    _DAT_1 = DAT_140e27c48;

+    if (DAT_2 == 0) {

+      _DAT_1 = _DAT_fffff78000000008;

+    }

+    PopIdleArmAoAcDozeS4Timer();

+  }

+  PopReleasePolicyLock();

   return;

 }
```

## `PiCMCaptureInterfaceListInputData`  (modified)

```diff
--- PiCMCaptureInterfaceListInputData
+++ PiCMCaptureInterfaceListInputData
@@ -1,54 +1,141 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-int PiCMCaptureInterfaceListInputData(void)

+int PiCMCaptureInterfaceListInputData(int *param_1,uint param_2,int param_3,int *param_4)

 

 {

-  longlong lVar1;

-  longlong *plVar2;

-  code *pcVar3;

-  int iVar4;

-  longlong in_RAX;

-  undefined8 uVar5;

-  longlong unaff_RBP;

-  undefined4 unaff_ESI;

-  longlong *unaff_RDI;

-  undefined8 *unaff_R15;

-  undefined1 local_res8 [32];

+  longlong *plVar1;

+  uint *puVar2;

+  undefined1 uVar3;

+  uint uVar4;

+  longlong lVar5;

+  int iVar6;

+  int iVar7;

+  undefined8 uVar8;

+  bool bVar9;

+  int iVar10;

+  int iVar11;

   

-  *(char *)(in_RAX + 0x46) = *(char *)(in_RAX + 0x46) >> 0xc;

-  *(undefined4 *)(unaff_RDI + 10) = unaff_ESI;

-  lVar1 = *(longlong *)(unaff_RBP + -0x51);

-  unaff_RDI[0xb] = *(longlong *)(lVar1 + 0x20);

-  iVar4 = PnpDeferNotification();

-  if (iVar4 < 0) {

-    ExFreePoolWithTag();

-    uVar5 = *(undefined8 *)(lVar1 + 0x20);

+  bVar9 = false;

+  uVar3 = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+  if ((param_1 == (int *)0x0) || (param_2 == 0)) {

+    iVar11 = -0x3ffffff3;

+LAB_0:

+    if (-1 < iVar11) {

+      return iVar11;

+    }

   }

   else {

-    ExAcquireFastMutex(&PnpTargetDeviceNotifyLock);

-    plVar2 = *(longlong **)(lVar1 + 0x1e0);

-    if (*plVar2 == lVar1 + 0x1d8) {

-      *unaff_RDI = lVar1 + 0x1d8;

-      unaff_RDI[1] = (longlong)plVar2;

-      *plVar2 = (longlong)unaff_RDI;

-      *(longlong **)(lVar1 + 0x1e0) = unaff_RDI;

-      ExReleaseFastMutex(&PnpTargetDeviceNotifyLock);

-      *unaff_R15 = unaff_RDI;

-      goto LAB_0;

+    if (param_3 == 0) {

+      if (((ulonglong)param_1 & 7) != 0) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

+      }

+      iVar11 = 0;

+      if (param_2 < 0x28) {

+        iVar11 = -0x3ffffff3;

+      }

+      else {

+        uVar8 = *(undefined8 *)(param_1 + 2);

+        *(undefined8 *)param_4 = *(undefined8 *)param_1;

+        *(undefined8 *)(param_4 + 2) = uVar8;

+        iVar10 = param_1[5];

+        iVar6 = param_1[6];

+        iVar7 = param_1[7];

+        param_4[4] = param_1[4];

+        param_4[5] = iVar10;

+        param_4[6] = iVar6;

+        param_4[7] = iVar7;

+        *(undefined8 *)(param_4 + 8) = *(undefined8 *)(param_1 + 8);

+        if (*param_4 != 0x28) {

+          iVar11 = -0x3ffffff3;

+        }

+      }

     }

-    pcVar3 = (code *)swi(0x29);

-    (*pcVar3)(3);

-    register0x00000020 = (BADSPACEBASE *)local_res8;

-    ExFreePoolWithTag();

-    uVar5 = *(undefined8 *)(*(longlong *)(unaff_RBP + -0x51) + 0x20);

+    else {

+      if (((ulonglong)param_1 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

+      }

+      iVar11 = 0;

+      if ((param_2 < 0x24) || (*param_1 != 0x24)) {

+        iVar11 = -0x3ffffff3;

+      }

+      else {

+        *param_4 = 0x28;

+        param_4[1] = param_1[1];

+        iVar10 = param_1[3];

+        iVar6 = param_1[4];

+        iVar7 = param_1[5];

+        param_4[2] = param_1[2];

+        param_4[3] = iVar10;

+        param_4[4] = iVar6;

+        param_4[5] = iVar7;

+        *(ulonglong *)(param_4 + 6) = (ulonglong)(uint)param_1[6];

+        param_4[8] = param_1[7];

+        param_4[9] = param_1[8];

+      }

+    }

+    if (iVar11 < 0) goto LAB_1;

+    plVar1 = (longlong *)(param_4 + 6);

+    lVar5 = *plVar1;

+    *plVar1 = 0;

+    iVar10 = Feature_KernelPnP_InterfaceListFilterUpdates__private_IsEnabledDeviceUsageNoInline();

+    if (iVar10 == 0) {

+      if (lVar5 != 0) {

+        puVar2 = (uint *)(param_4 + 8);

+        if (1 < *puVar2) {

+          iVar11 = PiControlMakeUserModeCallersCopy(plVar1,lVar5,*puVar2,2,uVar3,1);

+          if (iVar11 < 0) {

+            *plVar1 = 0;

+            *puVar2 = 0;

+          }

+          else {

+            bVar9 = true;

+            *(undefined2 *)(*plVar1 + -2 + (ulonglong)(*puVar2 >> 1) * 2) = 0;

+          }

+          goto LAB_0;

+        }

+      }

+      if (lVar5 == 0) {

+        uVar4 = param_4[8];

+        goto joined_r0x000140a05d07;

+      }

+      if (1 < (uint)param_4[8]) goto LAB_0;

+    }

+    else {

+      uVar4 = param_4[8];

+      if (lVar5 == 0) {

+joined_r0x000140a05d07:

+        if (uVar4 == 0) goto LAB_0;

+      }

+      else if (uVar4 - 2 < 399) {

+        iVar11 = PiControlMakeUserModeCallersCopy(plVar1,lVar5,uVar4,2,uVar3,1);

+        if (iVar11 < 0) {

+          *plVar1 = 0;

+          param_4[8] = 0;

+        }

+        else {

+          bVar9 = true;

+          *(undefined2 *)(*plVar1 + -2 + (ulonglong)((uint)param_4[8] >> 1) * 2) = 0;

+        }

+        goto LAB_0;

+      }

+    }

+    iVar11 = -0x3ffffff3;

   }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409f1b5e;

-  ObfDereferenceObject(uVar5);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409f1b6b;

-  ObfDereferenceObjectWithTag();

-LAB_0:

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1409f1b94;

-  return iVar4;

+LAB_1:

+  if (bVar9) {

+    PiControlFreeUserModeCallersBuffer(uVar3,*(undefined8 *)(param_4 + 6));

+  }

+  param_4[0] = 0;

+  param_4[1] = 0;

+  param_4[2] = 0;

+  param_4[3] = 0;

+  param_4[4] = 0;

+  param_4[5] = 0;

+  param_4[6] = 0;

+  param_4[7] = 0;

+  param_4[8] = 0;

+  param_4[9] = 0;

+  return iVar11;

 }
```

## `PspInitializeProcessSecurity`  (modified)

```diff
--- PspInitializeProcessSecurity
+++ PspInitializeProcessSecurity
@@ -1,142 +1,88 @@
 

-ulonglong PspInitializeProcessSecurity(char *param_1,undefined8 param_2)

+ulonglong PspInitializeProcessSecurity

+                    (longlong param_1,longlong param_2,undefined8 param_3,int param_4,

+                    undefined4 param_5,undefined4 param_6,undefined4 param_7,undefined4 param_8,

+                    undefined8 param_9,undefined4 param_10,undefined8 param_11,undefined4 param_12,

+                    undefined8 param_13,undefined8 param_14,char *param_15)

 

 {

-  uint *puVar1;

-  char cVar2;

-  int iVar3;

-  uint uVar4;

-  char *in_RAX;

-  ulonglong uVar5;

-  undefined8 uVar6;

-  longlong lVar7;

-  longlong unaff_RBP;

-  int iVar8;

-  longlong unaff_R14;

-  undefined4 uVar9;

-  undefined4 extraout_XMM0_Da;

-  undefined8 in_XMM0_Qa;

-  undefined4 in_XMM0_Dc;

-  undefined4 in_XMM0_Dd;

-  longlong lVar10;

-  undefined4 uVar12;

-  undefined8 uVar11;

+  int iVar1;

+  undefined4 uVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  longlong lVar5;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  undefined2 local_res8;

+  char local_resa;

+  undefined8 local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  undefined4 local_48;

+  undefined4 local_44;

+  longlong local_40;

+  undefined8 local_38;

+  undefined8 local_30;

   

-  uVar12 = (undefined4)((ulonglong)in_XMM0_Qa >> 0x20);

-  *param_1 = (char)in_RAX;

-  *in_RAX = *in_RAX + (char)in_RAX;

-  uVar6 = PsThreadType;

-  *(longlong *)(unaff_RBP + 0x7f) = unaff_R14;

-  cVar2 = in_RAX[0x232];

-  lVar10 = unaff_RBP + 0x77;

-  iVar8 = (int)unaff_R14;

-  *(int *)(unaff_RBP + 0x6f) = iVar8;

-  *(int *)(unaff_RBP + -0x19) = (int)in_XMM0_Qa;

-  *(undefined4 *)(unaff_RBP + -0x15) = uVar12;

-  *(undefined4 *)(unaff_RBP + -0x11) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + -0xd) = in_XMM0_Dd;

-  *(longlong *)(unaff_RBP + -0x21) = unaff_R14;

-  *(int *)(unaff_RBP + -9) = (int)in_XMM0_Qa;

-  *(undefined4 *)(unaff_RBP + -5) = uVar12;

-  *(undefined4 *)(unaff_RBP + -1) = in_XMM0_Dc;

-  *(undefined4 *)(unaff_RBP + 3) = in_XMM0_Dd;

-  *(longlong *)(unaff_RBP + 0x77) = unaff_R14;

-  uVar5 = ObReferenceObjectByHandle(param_1,param_2,uVar6,cVar2,lVar10);

-  uVar12 = (undefined4)((ulonglong)lVar10 >> 0x20);

-  if ((int)uVar5 < 0) {

-    return uVar5;

+  uVar6 = 0;

+  local_58 = 0;

+  local_res8 = 0;

+  local_resa = '\0';

+  param_15[0] = '\0';

+  param_15[1] = '\0';

+  local_30 = 0;

+  if (param_1 == 0) {

+    *(undefined8 *)(param_2 + 0x248) = 0;

+    SeAssignPrimaryToken(param_2,param_3);

   }

-  uVar9 = SeCaptureSubjectContext(unaff_RBP + -0x19);

-  lVar10 = *(longlong *)(unaff_RBP + -9);

-  lVar7 = lVar10;

-  if (*(longlong *)(unaff_RBP + -0x19) != 0) {

-    lVar7 = *(longlong *)(unaff_RBP + -0x19);

-  }

-  iVar3 = SepRegQueryDwordValue

-                    (uVar9,L"AnonymousAppContainerImpersonationLevelCheck",unaff_RBP + 0x6f);

-  if ((((iVar3 < 0) || (*(int *)(unaff_RBP + 0x6f) == iVar8)) && (*(int *)(lVar7 + 0xc0) != 1)) &&

-     (((*(uint *)(lVar10 + 200) >> 0xe & 1) != 0 && (*(int *)(lVar7 + 0xc4) < 2)))) {

-    uVar5 = 0xc00000a5;

-  }

-  else if ((*(uint *)(lVar7 + 200) >> 0xe & 1) == 0) {

-    iVar3 = SepRegQueryDwordValue(extraout_XMM0_Da,L"EveryoneIncludesAnonymous",unaff_RBP + 0x6f);

-    if ((iVar3 < 0) || (uVar6 = SeAnonymousLogonToken, *(int *)(unaff_RBP + 0x6f) != 1)) {

-      uVar6 = SeAnonymousLogonTokenNoEveryone;

+  else {

+    local_50 = param_5;

+    local_4c = param_12;

+    local_48 = param_6;

+    local_44 = param_7;

+    local_38 = param_13;

+    local_40 = param_1;

+    iVar1 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline();

+    if (iVar1 != 0) {

+      local_30 = param_14;

     }

-    cVar2 = PsIsCurrentThreadInServerSilo();

-    if (cVar2 == '\0') {

-      if ((*(uint *)(lVar7 + 200) & 0x380000) != 0) {

-        *(undefined4 *)(unaff_RBP + 7) = 0x30;

-        uVar11 = CONCAT44(uVar12,2);

-        *(longlong *)(unaff_RBP + 0xf) = unaff_R14;

-        *(int *)(unaff_RBP + 0x1f) = iVar8;

-        *(longlong *)(unaff_RBP + 0x17) = unaff_R14;

-        *(undefined8 *)(unaff_RBP + 0x27) = 0;

-        *(undefined8 *)(unaff_RBP + 0x2f) = 0;

-        uVar4 = SepDuplicateToken(uVar6,unaff_RBP + 7,1,2,uVar11);

-        uVar12 = (undefined4)((ulonglong)uVar11 >> 0x20);

-        uVar5 = (ulonglong)uVar4;

-        if ((int)uVar4 < 0) goto LAB_0;

-        puVar1 = (uint *)(*(longlong *)(unaff_RBP + -0x29) + 200);

-        *puVar1 = *puVar1 | *(uint *)(lVar7 + 200) & 0x380000;

-        uVar6 = *(undefined8 *)(unaff_RBP + -0x29);

+    uVar2 = PsGetProcessSessionId(param_2);

+    uVar3 = SeSubProcessToken(param_2,param_3,&local_58,(-(uint)(param_4 != 0) & 0xfffffffe) + 3,

+                              uVar2,&local_50,param_8,param_9,param_10,param_11,&local_res8);

+    uVar7 = (ulonglong)uVar3;

+    uVar4 = uVar6;

+    if (-1 < (int)uVar3) {

+      ObInitializeFastReference(param_2 + 0x248,local_58);

+      if ((param_4 != 0) || ((char)local_res8 != '\0')) {

+        *param_15 = '\x01';

+      }

+      if (local_res8._1_1_ != '\0') {

+        param_15[1] = '\x01';

+      }

+      uVar4 = 0;

+      if ((param_15[1] == '\0') && (local_resa != '\0')) {

+        uVar4 = PsReferencePrimaryTokenWithTag(param_1,0x746c6644);

+        uVar3 = PspIdentityBasedJobBreakaway(uVar4,local_58,param_15 + 1);

+        uVar7 = (ulonglong)uVar3;

       }

     }

+    if (((*param_15 == '\0') && (-1 < *(int *)(param_1 + 0x750))) &&

+       (((*(uint *)(param_2 + 0x5fc) & 0x800000) == 0 || (*(longlong *)(param_1 + 0x760) != 0)))) {

+      lVar5 = *(longlong *)(param_1 + 0x760);

+    }

     else {

-      uVar6 = PsGetCurrentServerSilo();

-      uVar4 = SepCopyAnonymousTokenAndSetSilo(uVar6,unaff_RBP + 0x7f);

-      uVar5 = (ulonglong)uVar4;

-      if ((int)uVar4 < 0) goto LAB_0;

-      uVar6 = *(undefined8 *)(unaff_RBP + 0x7f);

+      LOCK();

+      UNLOCK();

+      lVar5 = PsNextSecurityDomain + 1;

+      PsNextSecurityDomain = PsNextSecurityDomain + 1;

     }

-    uVar4 = ObReferenceObjectByPointer

-                      (uVar6,4,SeTokenObjectType,

-                       *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232));

-    uVar5 = (ulonglong)uVar4;

-    if (-1 < (int)uVar4) {

-      ObfDereferenceObject(uVar6);

-      lVar10 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

-      lVar7 = PsReferencePrimaryTokenWithTag(lVar10,0x746c6644);

-      if (lVar7 == 0) {

-        uVar5 = 0xc0000001;

-      }

-      else {

-        cVar2 = SeTokenIsRestricted(lVar7);

-        if ((cVar2 == '\0') || (cVar2 = SeTokenIsWriteRestricted(lVar7), cVar2 != '\0')) {

-          ObFastDereferenceObject(lVar10 + 0x248,lVar7,0x746c6644);

-          uVar4 = PsImpersonateClient(*(undefined8 *)(unaff_RBP + 0x77),uVar6,

-                                      *(longlong *)(unaff_RBP + 0x7f) == unaff_R14,0,

-                                      CONCAT44(uVar12,2));

-          uVar5 = (ulonglong)uVar4;

-        }

-        else {

-          ObfDereferenceObject(lVar7);

-          uVar5 = 0xc0000022;

-        }

-      }

+    *(longlong *)(param_2 + 0x760) = lVar5;

+    *(longlong *)(param_2 + 0x768) = lVar5;

+    uVar6 = uVar7;

+    if (uVar4 != 0) {

+      ObFastDereferenceObject(param_1 + 0x248,uVar4,0x746c6644);

     }

   }

-  else {

-    uVar4 = SepGetAnonymousToken(lVar7,unaff_RBP + -0x21);

-    uVar5 = (ulonglong)uVar4;

-    if (-1 < (int)uVar4) {

-      uVar4 = PsImpersonateClient(*(undefined8 *)(unaff_RBP + 0x77),

-                                  *(undefined8 *)(unaff_RBP + -0x21),1,0,CONCAT44(uVar12,2));

-      uVar5 = (ulonglong)uVar4;

-      ObfDereferenceObject(*(undefined8 *)(unaff_RBP + -0x21));

-    }

-  }

-LAB_0:

-  SeReleaseSubjectContext(unaff_RBP + -0x19);

-  if (*(longlong *)(unaff_RBP + 0x77) != 0) {

-    ObfDereferenceObject();

-  }

-  if (*(longlong *)(unaff_RBP + 0x7f) != 0) {

-    ObfDereferenceObject();

-  }

-  if (*(longlong *)(unaff_RBP + -0x29) != 0) {

-    ObfDereferenceObject();

-  }

-  return uVar5;

+  return uVar6;

 }
```

## `CmFcInitSystem1`  (modified)

```diff
--- CmFcInitSystem1
+++ CmFcInitSystem1
@@ -1,51 +1,24 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-int CmFcInitSystem1(void)

+void CmFcInitSystem1(void)

 

 {

-  int in_EAX;

   int iVar1;

-  int unaff_EBX;

-  longlong unaff_RBP;

-  longlong in_stack_00000028;

-  uint uStack0000000000000030;

-  int iStack0000000000000034;

   

-  if (-1 < in_EAX) {

-    uStack0000000000000030 = *(uint *)(lRam00000000d88c0091 + 0x84) & 1;

-    unaff_EBX = ZwSetValueKey(in_stack_00000028,&CmpLastBootSucceededString,0,4,&stack0x00000030,4);

-    if (-1 < unaff_EBX) {

-      uStack0000000000000030 = *(uint *)(lRam00000000d88c0091 + 0x84) >> 1 & 1;

-      unaff_EBX = ZwSetValueKey(in_stack_00000028,&CmpLastBootShutdownString,0,4,&stack0x00000030,4)

-      ;

-      if (-1 < unaff_EBX) {

-        if ((*(uint *)(lRam00000000d88c0091 + 0x84) & 2) == 0) {

-          iVar1 = ZwQueryValueKey(in_stack_00000028,&CmpDirtyShutdownCountString,1,unaff_RBP + -0x80

-                                  ,0x100,&stack0x00000038);

-          if ((iVar1 < 0) || (*(int *)(unaff_RBP + -0x7c) != 4)) {

-            iStack0000000000000034 = 1;

-          }

-          else {

-            iStack0000000000000034 =

-                 *(int *)(unaff_RBP + -0x80 + (ulonglong)*(uint *)(unaff_RBP + -0x78)) + 1;

-          }

-          unaff_EBX = ZwSetValueKey(in_stack_00000028,&CmpDirtyShutdownCountString,0,4,

-                                    (longlong)&stack0x00000030 + 4,4);

-          if (unaff_EBX < 0) goto LAB_0;

-        }

-        if ((*(uint *)(lRam00000000d88c0091 + 0xa58) >> 0x10 & 1) != 0) {

-          unaff_EBX = BcdSetBootBcdAsSystemStore();

-          if (unaff_EBX < 0) goto LAB_0;

-        }

-        unaff_EBX = 0;

-      }

-    }

+  iVar1 = wil_details_ShouldRegisterFeatureStagingChangeNotification();

+  if (iVar1 != 0) {

+    wil_details_RegisterFeatureStagingChangeNotification();

   }

-LAB_0:

-  if (in_stack_00000028 != 0) {

-    ZwClose();

+  iVar1 = wil_details_RegisterFeatureUsageProvider();

+  if ((iVar1 == 0) && (g_wil_details_featureUsageCached != 0)) {

+    RtlArmFeatureUsageProviderFlushNotification(g_wil_details_featureUsageProvider,1);

   }

-  return unaff_EBX;

+  iVar1 = Feature_CmFcCallback__private_IsEnabledDeviceUsageNoInline();

+  if (iVar1 != 0) {

+    CmFcDebugUpdateSystemInfo();

+    DAT_0 = 0;

+    KeRegisterBugCheckReasonCallback

+              (&DAT_1,CmFcpSecondaryMultiPartDumpDataCallback,5,&DAT_140e0ec64);

+  }

+  return;

 }
```

## `PspUnlockJobChain`  (modified)

```diff
--- PspUnlockJobChain
+++ PspUnlockJobChain
@@ -1,10 +1,29 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void PspUnlockJobChain(void)

+void PspUnlockJobChain(longlong param_1,longlong param_2)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  short *psVar1;

+  longlong lVar2;

+  

+  if (1 < *(ulonglong *)(param_1 + 0x538)) {

+    ExReleaseResourceLite(*(longlong *)(param_1 + 0x520) + 0x38);

+  }

+  if (2 < *(ulonglong *)(param_1 + 0x538)) {

+    for (lVar2 = *(ulonglong *)(param_1 + 0x538) - 2; lVar2 != 0; lVar2 = lVar2 + -1) {

+      ExReleaseResourceLite(*(longlong *)(*(longlong *)(param_1 + 0x540) + -8 + lVar2 * 8) + 0x38);

+    }

+  }

+  if (*(longlong *)(param_1 + 0x538) != 0) {

+    ExReleaseResourceLite(*(longlong *)(param_1 + 0x518) + 0x38);

+  }

+  ExReleaseResourceLite(param_1 + 0x38);

+  if (param_2 != 0) {

+    psVar1 = (short *)(param_2 + 0x1e6);

+    *psVar1 = *psVar1 + 1;

+    if ((*psVar1 == 0) && (*(longlong **)(param_2 + 0x98) != (longlong *)(param_2 + 0x98))) {

+      KiCheckForKernelApcDelivery();

+    }

+  }

+  return;

 }
```

## `PopFxCompleteComponentActivation`  (modified)

```diff
--- PopFxCompleteComponentActivation
+++ PopFxCompleteComponentActivation
@@ -1,31 +1,21 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-undefined8 PopFxCompleteComponentActivation(void)

+void PopFxCompleteComponentActivation(undefined8 param_1,longlong param_2,char param_3)

 

 {

-  uint uVar1;

-  undefined8 *unaff_RBX;

-  uint *unaff_RDI;

-  char unaff_R12B;

-  undefined1 *puStack0000000000000058;

-  undefined8 uStack0000000000000060;

+  longlong lVar1;

   

+  lVar1 = param_2;

+  PopFxDeviceCriticalRegionEnter();

   LOCK();

-  *unaff_RBX = 0;

+  *(uint *)(lVar1 + 0x58) = *(uint *)(lVar1 + 0x58) | 0x80000000;

   UNLOCK();

-  uVar1 = 0xbfffff7f;

-  if (unaff_R12B == '\0') {

-    uVar1 = 0xbfffffff;

+  KeSetEvent(lVar1 + 0x68,0,0);

+  if (param_3 != '\0') {

+    PopFxActivateComponentDependents(param_2);

   }

-  LOCK();

-  *unaff_RDI = *unaff_RDI & uVar1;

-  UNLOCK();

-  if (((uint)DAT_0 & 0x20000) != 0) {

-    puStack0000000000000058 = &stack0x00000040;

-    uStack0000000000000060 = 8;

-    EtwTraceKernelEvent(&stack0x00000058,1,0x40020000,0xf55,0x602);

-  }

-  return 1;

+  PopFxIdleComponent(param_1,*(undefined4 *)(param_2 + 0x10),1);

+  PopFxDereferenceDevice(param_1,8);

+  PopFxDeviceCriticalRegionLeave(param_1);

+  return;

 }
```

## `SeQueryHSTIResults$filt$0`  (modified)

```diff
--- SeQueryHSTIResults$filt$0
+++ SeQueryHSTIResults$filt$0
@@ -1,9 +1,8 @@
 

-bool SeQueryHSTIResults_filt_0(undefined8 param_1,uint param_2)

+bool SeQueryHSTIResults_filt_0(undefined8 param_1,longlong param_2)

 

 {

-  *(undefined1 *)((ulonglong)param_2 + 0xa8) =

-       *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

-  return *(char *)((ulonglong)param_2 + 0xa8) != '\0';

+  *(undefined1 *)(param_2 + 0x20) = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+  return *(char *)(param_2 + 0x20) != '\0';

 }
```

## `PopAdaptiveStandbyQueryReserveConfiguration`  (modified)

```diff
--- PopAdaptiveStandbyQueryReserveConfiguration
+++ PopAdaptiveStandbyCheckRestrictedStandbyBudgetAction
@@ -1,91 +1,274 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-void PopAdaptiveStandbyQueryReserveConfiguration(longlong param_1)

+/* WARNING: Type propagation algorithm not settling */

+

+undefined1

+PopAdaptiveStandbyCheckRestrictedStandbyBudgetAction

+          (longlong param_1,uint *param_2,undefined4 *param_3,undefined4 *param_4)

 

 {

-  longlong *plVar1;

-  int iVar2;

-  undefined8 uVar3;

-  undefined1 auStack_f8 [32];

-  wchar_t *local_d8;

-  undefined1 *local_d0;

-  undefined8 *local_c8;

-  undefined4 *local_c0;

-  undefined4 local_b8 [2];

-  longlong local_b0;

-  undefined8 local_a8;

-  undefined4 local_a0;

-  undefined4 local_9c;

-  undefined8 local_98;

-  wchar_t *local_90;

-  undefined8 local_88;

-  undefined8 uStack_80;

-  undefined1 local_78 [32];

-  longlong *local_58;

-  undefined4 local_50;

-  undefined4 local_4c;

-  undefined4 *local_48;

-  undefined4 local_40;

-  undefined4 local_3c;

-  undefined8 *local_38;

-  undefined4 local_30;

-  undefined4 local_2c;

-  ulonglong local_28;

+  undefined1 *puVar1;

+  byte bVar2;

+  char cVar3;

+  int iVar4;

+  undefined8 uVar5;

+  undefined *puVar6;

+  undefined1 uVar7;

+  uint uVar8;

+  undefined1 auStack_298 [32];

+  undefined4 local_278;

+  undefined1 *local_270;

+  byte local_268;

+  byte local_267 [3];

+  undefined4 local_264;

+  undefined4 local_260;

+  undefined8 local_25c;

+  uint local_254;

+  undefined4 local_250;

+  uint local_24c;

+  uint local_248;

+  undefined4 local_244;

+  undefined4 local_240;

+  uint local_23c;

+  uint local_238;

+  undefined4 local_234;

+  uint local_230;

+  undefined4 local_22c;

+  undefined4 local_228;

+  undefined4 local_224;

+  undefined4 local_220 [2];

+  longlong local_218;

+  longlong local_210;

+  ulonglong local_208;

+  ulonglong local_200;

+  undefined1 local_1f8 [32];

+  ulonglong *local_1d8;

+  undefined8 local_1d0;

+  undefined4 *local_1c8;

+  undefined8 local_1c0;

+  uint *local_1b8;

+  undefined8 local_1b0;

+  uint *local_1a8;

+  undefined8 local_1a0;

+  undefined4 *local_198;

+  undefined8 local_190;

+  uint *local_188;

+  undefined8 local_180;

+  undefined4 *local_178;

+  undefined8 local_170;

+  longlong *local_168;

+  undefined8 local_160;

+  longlong *local_158;

+  undefined8 local_150;

+  undefined4 *local_148;

+  undefined8 local_140;

+  undefined4 *local_138;

+  undefined8 local_130;

+  longlong *local_128;

+  undefined8 local_120;

+  undefined4 *local_118;

+  undefined8 local_110;

+  byte *local_108;

+  undefined8 local_100;

+  undefined4 *local_f8;

+  undefined8 local_f0;

+  undefined4 *local_e8;

+  undefined8 local_e0;

+  undefined4 *local_d8;

+  undefined8 local_d0;

+  uint *local_c8;

+  undefined8 local_c0;

+  byte *local_b8;

+  undefined8 local_b0;

+  undefined4 *local_a8;

+  undefined8 local_a0;

+  uint *local_98;

+  undefined8 local_90;

+  uint *local_88;

+  undefined8 local_80;

+  undefined4 *local_78;

+  undefined8 local_70;

+  ulonglong *local_68;

+  undefined8 local_60;

+  ulonglong local_58;

   

-  local_28 = __security_cookie ^ (ulonglong)auStack_f8;

-  local_b8[0] = 0;

-  plVar1 = (longlong *)(param_1 + 0xd0);

-  if (*plVar1 != 0) {

-    if (5 < DAT_0) {

-      local_4c = 0;

-      local_58 = &local_b0;

-      local_50 = 8;

-      local_b0 = *plVar1;

-      uVar3 = IoGetActivityIdThread();

-      local_d0 = local_78;

-      local_d8 = (wchar_t *)CONCAT44(local_d8._4_4_,3);

-      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004dd50,uVar3,0);

-    }

-    *(undefined4 *)(param_1 + 0x70) = 0;

-    *(longlong *)(param_1 + 0x68) = *plVar1;

-    if (*(char *)(param_1 + 0x78) == '\0') {

-      if (*(longlong *)(param_1 + 0x228) != 0) {

-        local_98 = 0;

-        local_90 = L"Reserve Configuration Update";

-        local_c0 = local_b8;

-        local_a0 = 1;

-        local_d8 = L"AdaptiveStandby";

-        local_9c = 300;

-        local_88 = 0;

-        uStack_80 = 0;

-        local_c8 = (undefined8 *)(param_1 + 0x80);

-        iVar2 = Pdcv2ActivationClientActivate(*(longlong *)(param_1 + 0x228),&local_a0,0);

-        if (5 < DAT_0) {

-          local_4c = 0;

-          local_3c = 0;

-          local_2c = 0;

-          local_b0 = CONCAT44(local_b0._4_4_,iVar2);

-          local_58 = &local_b0;

-          local_48 = local_b8;

-          local_a8 = *(undefined8 *)(param_1 + 0x80);

-          local_38 = &local_a8;

-          local_50 = 4;

-          local_40 = 4;

-          local_30 = 8;

-          uVar3 = IoGetActivityIdThread();

-          local_d0 = local_78;

-          local_d8 = (wchar_t *)CONCAT44(local_d8._4_4_,5);

-          _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004dd92,uVar3,0);

+  local_58 = __security_cookie ^ (ulonglong)auStack_298;

+  puVar1 = (undefined1 *)(param_1 + 0x38);

+  if (*(char *)(param_1 + 0x5c) == '\0') {

+    iVar4 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+    if (iVar4 == 0) {

+      bVar2 = PopAdaptiveStandbyCheckRefreshableBudgetAction(param_1,puVar1,param_2,param_3);

+      uVar8 = (uint)bVar2;

+    }

+    else {

+      cVar3 = PopAdaptiveStandbyCheckRefreshableBudgetActionPreconditions();

+      if (cVar3 == '\0') {

+        uVar8 = 0;

+      }

+      else {

+        iVar4 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

+        if (((iVar4 == 8) ||

+            (iVar4 = Feature_AdaptiveHibernateEnhancements__private_GetVariant(), iVar4 == 6)) ||

+           (0x14 < (int)param_2[3])) {

+          bVar2 = PopAdaptiveStandbyCheckRefreshableBudgetActionV2

+                            (puVar1,param_2[4],*param_2,param_3);

+          uVar8 = (uint)bVar2;

+          if (bVar2 != 0) {

+            *param_4 = 3;

+          }

         }

-        if (iVar2 < 0) {

-          return;

+        else {

+          uVar8 = 1;

+          *puVar1 = 1;

+          *param_3 = 0;

+          *param_4 = 5;

         }

       }

-      *(undefined1 *)(param_1 + 0x78) = 1;

-      PopUmpoSendPowerAdaptiveReserveConfigurationQuery(plVar1);

-    }

-  }

-  return;

+    }

+  }

+  else {

+    uVar8 = 0;

+    *param_3 = 0xf;

+  }

+  iVar4 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  uVar7 = (undefined1)uVar8;

+  if (iVar4 == 0) {

+    if (DAT_0 < 6) {

+      return uVar7;

+    }

+    cVar3 = _tlgKeywordOn(&DAT_0,0x400000000000);

+    if (cVar3 == '\0') {

+      return uVar7;

+    }

+    local_208 = (ulonglong)*param_2;

+    local_1d8 = &local_208;

+    local_244 = *(undefined4 *)(param_1 + 0x3c);

+    local_1c8 = &local_244;

+    local_248 = param_2[3];

+    local_1b8 = &local_248;

+    local_24c = param_2[4];

+    local_1a8 = &local_24c;

+    local_250 = *(undefined4 *)(param_1 + 0x40);

+    local_198 = &local_250;

+    local_188 = &local_254;

+    local_25c._4_4_ = *param_3;

+    local_178 = (undefined4 *)((longlong)&local_25c + 4);

+    local_210 = *(longlong *)(param_1 + 0xf0);

+    local_168 = &local_210;

+    local_25c._0_4_ = *(undefined4 *)(param_1 + 0x44);

+    local_158 = &local_25c;

+    local_260 = *(undefined4 *)(param_1 + 0x48);

+    local_148 = &local_260;

+    local_264 = *(undefined4 *)(param_1 + 0x60);

+    local_138 = &local_264;

+    local_128 = &local_218;

+    local_1d0 = 8;

+    local_1c0 = 4;

+    local_1b0 = 4;

+    local_1a0 = 4;

+    local_190 = 4;

+    local_180 = 4;

+    local_170 = 4;

+    local_160 = 8;

+    local_150 = 4;

+    local_140 = 4;

+    local_130 = 4;

+    local_218 = 0x1000000;

+    local_120 = 8;

+    local_254 = uVar8;

+    uVar5 = IoGetActivityIdThread();

+    puVar6 = &DAT_1;

+    local_278 = 0xe;

+  }

+  else {

+    if (DAT_0 < 6) {

+      return uVar7;

+    }

+    cVar3 = _tlgKeywordOn(&DAT_0,0x400000000000);

+    if (cVar3 == '\0') {

+      return uVar7;

+    }

+    local_200 = (ulonglong)*param_2;

+    local_218 = *(longlong *)(param_1 + 0xf0);

+    local_1d8 = &local_200;

+    local_240 = *(undefined4 *)(param_1 + 0x4c);

+    local_210 = local_218 + -1;

+    if (*(int *)(param_1 + 0xf8) != 2) {

+      local_210 = local_218;

+    }

+    local_1c8 = &local_240;

+    local_23c = param_2[3];

+    local_1b8 = &local_23c;

+    local_238 = param_2[4];

+    local_1a8 = &local_238;

+    local_234 = *(undefined4 *)(param_1 + 0x50);

+    local_198 = &local_234;

+    local_188 = &local_230;

+    local_22c = *param_3;

+    local_178 = &local_22c;

+    local_168 = &local_218;

+    local_158 = &local_210;

+    local_228 = *(undefined4 *)(param_1 + 0x54);

+    local_148 = &local_228;

+    local_224 = *(undefined4 *)(param_1 + 0x58);

+    local_138 = &local_224;

+    local_220[0] = *(undefined4 *)(param_1 + 0x60);

+    local_128 = (longlong *)local_220;

+    local_264 = *(undefined4 *)(param_1 + 0xec);

+    local_118 = &local_264;

+    local_268 = *(byte *)(param_1 + 0x88) & 1;

+    local_1d0 = 8;

+    local_108 = &local_268;

+    local_260 = *(undefined4 *)(param_1 + 0x8c);

+    local_f8 = &local_260;

+    local_25c._0_4_ = *(undefined4 *)(param_1 + 0x90);

+    local_1c0 = 4;

+    local_1b0 = 4;

+    local_1a0 = 4;

+    local_190 = 4;

+    local_180 = 4;

+    local_170 = 4;

+    local_160 = 8;

+    local_150 = 8;

+    local_140 = 4;

+    local_130 = 4;

+    local_120 = 4;

+    local_110 = 4;

+    local_100 = 1;

+    local_f0 = 4;

+    local_e8 = (undefined4 *)&local_25c;

+    local_e0 = 4;

+    local_25c._4_4_ = *(undefined4 *)(param_1 + 0x94);

+    local_d8 = (undefined4 *)((longlong)&local_25c + 4);

+    local_254 = *(uint *)(param_1 + 0x98);

+    local_c8 = &local_254;

+    local_267[0] = *(byte *)(param_1 + 0x9c) & 1;

+    local_d0 = 4;

+    local_b8 = local_267;

+    local_250 = *(undefined4 *)(param_1 + 0xa0);

+    local_a8 = &local_250;

+    local_24c = *(uint *)(param_1 + 0xa4);

+    local_98 = &local_24c;

+    local_248 = *(uint *)(param_1 + 0xa8);

+    local_88 = &local_248;

+    local_244 = *(undefined4 *)(param_1 + 0xac);

+    local_78 = &local_244;

+    local_68 = &local_208;

+    local_c0 = 4;

+    local_b0 = 1;

+    local_a0 = 4;

+    local_90 = 4;

+    local_80 = 4;

+    local_70 = 4;

+    local_208 = 0x1000000;

+    local_60 = 8;

+    local_230 = uVar8;

+    uVar5 = IoGetActivityIdThread();

+    puVar6 = &DAT_2;

+    local_278 = 0x1a;

+  }

+  local_270 = local_1f8;

+  _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,puVar6,uVar5,0);

+  return uVar7;

 }
```

## `RtlpFreeHeap`  (modified)

```diff
--- RtlpFreeHeap
+++ RtlpFreeHeap
@@ -1,97 +1,237 @@
 

-/* WARNING: Instruction at (ram,0x0001405e9c5e) overlaps instruction at (ram,0x0001405e9c5d)

-    */

-

-undefined8 RtlpFreeHeap(longlong param_1)

+undefined8 RtlpFreeHeap(longlong param_1,uint param_2,longlong param_3)

 

 {

-  longlong lVar1;

-  undefined2 uVar2;

-  undefined4 uVar3;

-  longlong *plVar4;

-  longlong lVar5;

-  int in_EAX;

-  uint uVar6;

-  longlong unaff_RBX;

-  ulonglong uVar7;

-  longlong unaff_RBP;

-  uint *unaff_RSI;

-  longlong unaff_RDI;

-  longlong *plVar8;

-  int in_R10D;

-  ulonglong in_R11;

-  longlong unaff_R13;

-  ulonglong unaff_R14;

-  ulonglong uVar9;

+  undefined8 *puVar1;

+  ulonglong *puVar2;

+  ulonglong *puVar3;

+  bool bVar4;

+  bool bVar5;

+  ushort uVar6;

+  longlong lVar7;

+  undefined8 *puVar8;

+  uint uVar9;

+  longlong *plVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  longlong *plVar13;

+  uint uVar14;

+  ulonglong uVar15;

+  ulonglong local_res20;

+  undefined8 in_stack_ffffffffffffff78;

+  undefined8 *puVar16;

+  undefined4 uVar17;

+  ulonglong local_58;

+  undefined8 *local_50;

+  uint local_40;

+  uint local_30;

   

-  if (param_1 != 1) {

-    in_EAX = (int)unaff_RDI + 0x60;

-  }

-  uVar7 = (ulonglong)(uint)((int)&stack0x00000000 + in_EAX);

-  uVar3 = *(undefined4 *)(uVar7 + 0x90);

-  *(char *)(unaff_RDI + 0xb) = (char)in_R11;

-  uVar2 = *(undefined2 *)(unaff_RBX + 0x8c);

-  *(undefined4 *)(unaff_RDI + 0x14) = uVar3;

-  *(longlong *)(unaff_RDI + 0x28) = unaff_RBX;

-  *(undefined2 *)(unaff_RDI + 0xc) = uVar2;

-  *(undefined4 *)(unaff_RDI + 0x10) = 0xffeeffee;

-  *(longlong *)(unaff_RDI + 0x30) = unaff_R13;

-  *(longlong *)(unaff_RDI + 0x40) = unaff_RBP;

-  *(int *)(unaff_RDI + 0x38) = in_R10D;

-  *(int *)(unaff_RDI + 0x50) = (int)in_R11;

-  uVar6 = in_R10D << 0xc;

-  *(ulonglong *)(unaff_RDI + 0x48) = (ulonglong)uVar6 + unaff_R13;

-  lVar1 = unaff_RDI + 0x60;

-  *(ulonglong *)(unaff_RBX + 0x240) = *(longlong *)(unaff_RBX + 0x240) + (ulonglong)uVar6;

-  *(ulonglong *)(unaff_RBX + 0x238) = *(longlong *)(unaff_RBX + 0x238) + (ulonglong)uVar6;

-  *(longlong *)(unaff_RDI + 0x68) = lVar1;

-  *(longlong *)lVar1 = lVar1;

-  *(bool *)(unaff_RDI + 0xe) = *(longlong *)(unaff_RDI + 0x28) != unaff_RDI;

-  *(ushort *)(unaff_RBP + 0xc) = (ushort)*unaff_RSI ^ *(ushort *)(unaff_RBX + 0x8c);

-  if (*(longlong *)(unaff_RDI + 0x28) == unaff_RDI) {

-    uVar9 = in_R11 & 0xff;

+  local_res20 = 0;

+  bVar4 = false;

+  bVar5 = false;

+  local_58 = 0;

+  if (param_1 == param_3) {

+    RtlpLogHeapFailure(9,param_1,param_3,0,0,0);

+    return 0;

+  }

+  param_2 = param_2 | *(uint *)(param_1 + 0x74);

+  if ((param_2 & 1) == 0) {

+    ExAcquireResourceExclusiveLite

+              (*(undefined8 *)(param_1 + 0x160),CONCAT71((uint7)(uint3)(param_2 >> 8),1));

+    bVar4 = true;

+    bVar5 = true;

+    if ((*(int *)(param_1 + 0x7c) != 0) &&

+       (*(uint *)(param_3 + 8) = *(uint *)(param_1 + 0x88) ^ *(uint *)(param_3 + 8),

+       *(byte *)(param_3 + 0xb) !=

+       (byte)(*(byte *)(param_3 + 10) ^ *(byte *)(param_3 + 9) ^ *(byte *)(param_3 + 8)))) {

+      RtlpAnalyzeHeapFailure(param_1,param_3);

+    }

+    plVar10 = *(longlong **)(param_1 + 0x138);

+    do {

+      if ((uint)*(ushort *)(param_3 + 8) < *(uint *)(plVar10 + 1)) break;

+      plVar10 = (longlong *)*plVar10;

+    } while (plVar10 != (longlong *)0x0);

+  }

+  else if ((*(int *)(param_1 + 0x7c) != 0) &&

+          (*(uint *)(param_3 + 8) = *(uint *)(param_1 + 0x88) ^ *(uint *)(param_3 + 8),

+          *(byte *)(param_3 + 0xb) !=

+          (byte)(*(byte *)(param_3 + 10) ^ *(byte *)(param_3 + 9) ^ *(byte *)(param_3 + 8)))) {

+    RtlpAnalyzeHeapFailure(param_1,param_3);

+  }

+  if ((*(byte *)(param_3 + 10) & 8) != 0) {

+    *(byte *)(param_3 + 10) = *(byte *)(param_3 + 10) & 0xf7;

+  }

+  if (*(char *)(param_3 + 0xf) == '\x04') {

+    puVar2 = (ulonglong *)(param_3 + -0x30);

+    local_58 = (ulonglong)puVar2 & 0xffffffffffff0000;

+    *(longlong *)(param_1 + 600) = *(longlong *)(param_1 + 600) - *(longlong *)(param_3 + -0x10);

+    *(longlong *)(param_1 + 0x250) = *(longlong *)(param_1 + 0x250) - *(longlong *)(param_3 + -8);

+    uVar15 = *puVar2;

+    puVar3 = *(ulonglong **)(param_3 + -0x28);

+    if ((*puVar3 == *(ulonglong *)(uVar15 + 8)) && ((ulonglong *)*puVar3 == puVar2)) {

+      *puVar3 = uVar15;

+      *(ulonglong **)(uVar15 + 8) = puVar3;

+    }

+    else {

+      RtlpLogHeapFailure(0xd);

+    }

+    if (bVar4) {

+      ExReleaseResourceLite(*(undefined8 *)(param_1 + 0x160));

+      bVar4 = false;

+    }

+    local_res20 = 0;

+    ZwFreeVirtualMemory(0xffffffffffffffff,&local_58,&local_res20,0x8000);

+    goto LAB_0;

+  }

+  local_res20 = (ulonglong)*(ushort *)(param_3 + 8);

+  lVar7 = RtlpCoalesceFreeBlocks(param_1,param_3,&local_res20);

+  if ((*(ulonglong *)(param_1 + 0xb0) <= local_res20) &&

+     (*(ulonglong *)(param_1 + 0xb8) <= local_res20 + *(longlong *)(param_1 + 0xc0))) {

+    RtlpDeCommitFreeBlock(param_1,lVar7);

+    goto LAB_0;

+  }

+  if (0xff00 < local_res20) {

+    RtlpInsertFreeBlock(param_1,lVar7);

+    goto LAB_0;

+  }

+  uVar15 = local_res20 & 0xffff;

+  if ((param_2 & 0x3c010f60) == 0) {

+    *(undefined1 *)(lVar7 + 10) = 0;

+    *(undefined1 *)(lVar7 + 0xf) = 0;

+    if (*(longlong *)(param_1 + 0x138) == 0) {

+      puVar8 = *(undefined8 **)(param_1 + 0x150);

+    }

+    else {

+      puVar8 = (undefined8 *)RtlpFindEntry(param_1,uVar15);

+    }

+    for (; uVar17 = (undefined4)((ulonglong)in_stack_ffffffffffffff78 >> 0x20),

+        (undefined8 *)(param_1 + 0x150) != puVar8; puVar8 = (undefined8 *)*puVar8) {

+      if (*(int *)(param_1 + 0x7c) == 0) {

+        uVar6 = *(ushort *)(puVar8 + -1);

+      }

+      else {

+        local_40 = *(uint *)(puVar8 + -1);

+        if ((*(uint *)(param_1 + 0x7c) & local_40) != 0) {

+          local_40 = local_40 ^ *(uint *)(param_1 + 0x88);

+        }

+        uVar6 = (ushort)local_40;

+        bVar4 = bVar5;

+      }

+      if (uVar15 <= uVar6) break;

+    }

+    puVar1 = (undefined8 *)(lVar7 + 0x10);

+    plVar10 = (longlong *)puVar8[1];

+    puVar16 = (undefined8 *)*plVar10;

+    if (puVar16 == puVar8) {

+      *puVar1 = puVar8;

+      *(longlong **)(lVar7 + 0x18) = plVar10;

+      *plVar10 = (longlong)puVar1;

+      puVar8[1] = puVar1;

+    }

+    else {

+      RtlpLogHeapFailure(0xd,0,puVar8,0,puVar16,0);

+      uVar17 = (undefined4)((ulonglong)puVar16 >> 0x20);

+    }

+    *(ulonglong *)(param_1 + 0xc0) =

+         (ulonglong)*(ushort *)(lVar7 + 8) + *(longlong *)(param_1 + 0xc0);

+    if (*(longlong **)(param_1 + 0x138) != (longlong *)0x0) {

+      uVar9 = (uint)*(ushort *)(lVar7 + 8);

+      plVar10 = *(longlong **)(param_1 + 0x138);

+      do {

+        plVar13 = plVar10;

+        uVar14 = *(uint *)(plVar13 + 1);

+        if (uVar9 < uVar14) goto LAB_1;

+        plVar10 = (longlong *)*plVar13;

+      } while ((longlong *)*plVar13 != (longlong *)0x0);

+      uVar9 = uVar14 - 1;

+LAB_1:

+      RtlpHeapAddListEntry

+                (param_1,plVar13,uVar14,lVar7 + 0x10,CONCAT44(uVar17,uVar9),

+                 *(undefined2 *)(lVar7 + 8));

+    }

   }

   else {

-    uVar9 = (unaff_R14 >> 0x10) + 1;

-    if (0xfd < uVar9) {

-      *(ulonglong *)(uVar7 + 0x28) = in_R11;

-      *(ulonglong *)(uVar7 + 0x20) = in_R11;

-      *(undefined8 *)(uVar7 - 8) = 0x1405e9d01;

-      RtlpLogHeapFailure(3);

-      unaff_RSI = (uint *)(unaff_RDI + 8);

-    }

-  }

-  *(char *)(unaff_RBP + 0xe) = (char)uVar9;

-  *(ulonglong *)(uVar7 + 0x28) = uVar7 + 0x30;

-  *(longlong *)(uVar7 + 0x20) = unaff_RBP;

-  *(undefined8 *)(uVar7 - 8) = 0x1405e9d3d;

-  RtlpCreateUCREntry();

-  if (*(int *)(unaff_RBX + 0x7c) != 0) {

-    *(byte *)(unaff_RDI + 0xb) =

-         *(byte *)((longlong)unaff_RSI + 2) ^ *(byte *)((longlong)unaff_RSI + 1) ^ (byte)*unaff_RSI;

-    *unaff_RSI = *unaff_RSI ^ *(uint *)(unaff_RBX + 0x88);

-  }

-  if (*(longlong *)(uVar7 + 0x30) != 0) {

-    *(undefined8 *)(uVar7 - 8) = 0x1405e9d6b;

-    func_0x0001405e9dc0();

-  }

-  lVar1 = unaff_RBX + 0x120;

-  plVar8 = (longlong *)(unaff_RDI + 0x18);

-  plVar4 = *(longlong **)(unaff_RBX + 0x128);

-  lVar5 = *plVar4;

-  if (lVar5 == lVar1) {

-    *plVar8 = lVar1;

-    *(longlong **)(unaff_RDI + 0x20) = plVar4;

-    *plVar4 = (longlong)plVar8;

-    *(longlong **)(unaff_RBX + 0x128) = plVar8;

-  }

-  else {

-    *(undefined8 *)(uVar7 + 0x28) = 0;

-    *(longlong *)(uVar7 + 0x20) = lVar5;

-    *(undefined8 *)(uVar7 - 8) = 0x1405e9daa;

-    RtlpLogHeapFailure(0xd,0,lVar1,0);

-  }

-  *(int *)(unaff_RBX + 0x260) = *(int *)(unaff_RBX + 0x260) + 1;

+    *(byte *)(lVar7 + 10) = *(byte *)(lVar7 + 10) & 0xf0;

+    *(undefined1 *)(lVar7 + 0xf) = 0;

+    if ((*(uint *)(param_1 + 0x70) & 0x40) != 0) {

+      local_50 = (undefined8 *)(lVar7 + 0x20);

+      uVar12 = uVar15 * 0x10 - 0x20 >> 2;

+      if (uVar12 != 0) {

+        if (((ulonglong)local_50 & 4) != 0) {

+          *(undefined4 *)local_50 = 0xfeeefeee;

+          uVar12 = uVar12 - 1;

+          if (uVar12 == 0) goto LAB_2;

+          local_50 = (undefined8 *)(lVar7 + 0x24);

+        }

+        puVar8 = local_50;

+        for (uVar11 = uVar12 >> 1; uVar11 != 0; uVar11 = uVar11 - 1) {

+          *puVar8 = 0xfeeefeeefeeefeee;

+          puVar8 = puVar8 + 1;

+        }

+        if ((uVar12 & 1) != 0) {

+          *(undefined4 *)((longlong)local_50 + uVar12 * 4 + -4) = 0xfeeefeee;

+        }

+      }

+LAB_2:

+      *(byte *)(lVar7 + 10) = *(byte *)(lVar7 + 10) | 4;

+    }

+    if (*(longlong *)(param_1 + 0x138) == 0) {

+      puVar8 = *(undefined8 **)(param_1 + 0x150);

+    }

+    else {

+      puVar8 = (undefined8 *)RtlpFindEntry(param_1,uVar15);

+    }

+    for (; uVar17 = (undefined4)((ulonglong)in_stack_ffffffffffffff78 >> 0x20),

+        (undefined8 *)(param_1 + 0x150) != puVar8; puVar8 = (undefined8 *)*puVar8) {

+      if (*(int *)(param_1 + 0x7c) == 0) {

+        uVar6 = *(ushort *)(puVar8 + -1);

+      }

+      else {

+        local_30 = *(uint *)(puVar8 + -1);

+        if ((*(uint *)(param_1 + 0x7c) & local_30) != 0) {

+          local_30 = local_30 ^ *(uint *)(param_1 + 0x88);

+        }

+        uVar6 = (ushort)local_30;

+        bVar4 = bVar5;

+      }

+      if (uVar15 <= uVar6) break;

+    }

+    puVar1 = (undefined8 *)(lVar7 + 0x10);

+    plVar10 = (longlong *)puVar8[1];

+    puVar16 = (undefined8 *)*plVar10;

+    if (puVar16 == puVar8) {

+      *puVar1 = puVar8;

+      *(longlong **)(lVar7 + 0x18) = plVar10;

+      *plVar10 = (longlong)puVar1;

+      puVar8[1] = puVar1;

+    }

+    else {

+      RtlpLogHeapFailure(0xd,0,puVar8,0,puVar16,0);

+      uVar17 = (undefined4)((ulonglong)puVar16 >> 0x20);

+    }

+    *(ulonglong *)(param_1 + 0xc0) =

+         (ulonglong)*(ushort *)(lVar7 + 8) + *(longlong *)(param_1 + 0xc0);

+    if (*(longlong **)(param_1 + 0x138) != (longlong *)0x0) {

+      uVar9 = (uint)*(ushort *)(lVar7 + 8);

+      plVar10 = *(longlong **)(param_1 + 0x138);

+      do {

+        plVar13 = plVar10;

+        uVar14 = *(uint *)(plVar13 + 1);

+        if (uVar9 < uVar14) goto LAB_1;

+        plVar10 = (longlong *)*plVar13;

+      } while ((longlong *)*plVar13 != (longlong *)0x0);

+      uVar9 = uVar14 - 1;

+      goto LAB_1;

+    }

+  }

+  if (*(int *)(param_1 + 0x7c) != 0) {

+    *(byte *)(lVar7 + 0xb) = *(byte *)(lVar7 + 10) ^ *(byte *)(lVar7 + 9) ^ *(byte *)(lVar7 + 8);

+    *(uint *)(lVar7 + 8) = *(uint *)(param_1 + 0x88) ^ *(uint *)(lVar7 + 8);

+  }

+LAB_0:

+  if (bVar4) {

+    ExReleaseResourceLite(*(undefined8 *)(param_1 + 0x160));

+  }

   return 1;

 }
```

## `PspUpdateCalloutParameters`  (modified)

```diff
--- PspUpdateCalloutParameters
+++ PspUpdateCalloutParameters
@@ -1,67 +1,59 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

-

-longlong PspUpdateCalloutParameters(undefined8 param_1,uint param_2,ulonglong param_3)

+undefined8

+PspUpdateCalloutParameters(int param_1,undefined4 *param_2,undefined4 param_3,undefined8 param_4)

 

 {

-  uint uVar1;

-  uint uVar2;

-  int iVar3;

-  longlong lVar4;

-  longlong unaff_RBX;

-  undefined8 *unaff_RSI;

-  uint uVar5;

-  int unaff_R12D;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined4 unaff_R15D;

-  byte in_stack_00000080;

-  int in_stack_00000088;

+  bool bVar1;

   

-  uVar1 = RtlpCalculateSubsegmentSizeIndex(param_2 + (int)param_3);

-  uVar5 = (int)unaff_RBX + 0xc;

-  iVar3 = (int)unaff_R13;

-  if (uVar1 <= uVar5) {

-    uVar1 = uVar5;

+  if (param_1 < 0x19) {

+    if (param_1 == 0x18) goto LAB_0;

+    if (param_1 < 0xc) {

+      if (param_1 == 0xb) goto LAB_0;

+      if (param_1 < 6) {

+        if (param_1 == 5) goto LAB_0;

+        goto LAB_1;

+      }

+      param_1 = param_1 + -7;

+      bVar1 = param_1 == 0;

+    }

+    else {

+      if (((param_1 == 0xc) || (param_1 == 0xd)) ||

+         ((param_1 == 0xe || ((param_1 == 0xf || (param_1 == 0x10)))))) goto LAB_0;

+      param_1 = param_1 + -0x12;

+      bVar1 = param_1 == 0;

+    }

+LAB_2:

+    if (bVar1) goto LAB_0;

   }

-  uVar1 = iVar3 << ((byte)uVar1 & 0x1f);

-  if (param_2 <= ((uint)(param_3 >> 6) & 0x3ffffff)) {

-    uVar2 = RtlpCalculateSubsegmentSizeIndex(param_3 & 0xffffffff);

-    if (uVar2 <= uVar5) {

-      uVar2 = uVar5;

+  else {

+    if (0x23 < param_1) {

+      if ((((param_1 == 0x24) || (param_1 == 0x25)) || (param_1 == 0x26)) || (param_1 == 0x27))

+      goto LAB_0;

+      param_1 = param_1 + -0x28;

+LAB_1:

+      if (param_1 == 0) goto LAB_0;

+      param_1 = param_1 + -1;

+      bVar1 = param_1 == 0;

+      goto LAB_2;

     }

-    uVar5 = iVar3 << ((byte)uVar2 & 0x1f);

-    if (uVar5 < uVar1) {

-      uVar1 = uVar5;

+    if (param_1 == 0x23) goto LAB_0;

+    if (0x1e < param_1) {

+      param_1 = param_1 + -0x1f;

+      bVar1 = param_1 == 0;

+      goto LAB_2;

+    }

+    if ((param_1 == 0x1e) || (param_1 == 0x19)) goto LAB_0;

+    param_1 = param_1 + -0x1a;

+    if (param_1 == 0) {

+      return 1;

     }

   }

-  lVar4 = (*(code *)(unaff_RSI[1] ^ RtlpHpHeapGlobals ^ (ulonglong)unaff_RSI))

-                    (*unaff_RSI,uVar1,&stack0x00000080,&stack0x00000098);

-  if (lVar4 != 0) {

-    uVar5 = uVar1;

-    if ((unaff_R12D < iVar3) && ((in_stack_00000080 & (byte)unaff_R13) == 0)) {

-      uVar5 = RtlpHpLfhSubsegmentComputeCommitUnit(uVar1,unaff_R15D);

-    }

-    in_stack_00000088 = (int)unaff_RBX;

-    iVar3 = (*(code *)(unaff_RSI[3] ^ RtlpHpHeapGlobals ^ (ulonglong)unaff_RSI))

-                      (*unaff_RSI,lVar4,uVar5,&stack0x00000088);

-    if (iVar3 < 0) {

-      (*(code *)(unaff_RSI[2] ^ RtlpHpHeapGlobals ^ (ulonglong)unaff_RSI))(*unaff_RSI,lVar4,uVar1);

-    }

-    else {

-      RtlpHpLfhSubsegmentInitialize(lVar4,uVar1,uVar5,unaff_R12D);

-      LOCK();

-      UNLOCK();

-      LOCK();

-      *(longlong *)(unaff_R14 + 0x40) = *(longlong *)(unaff_R14 + 0x40) + unaff_R13;

-      UNLOCK();

-      LOCK();

-      *(longlong *)(unaff_R14 + 0x38) =

-           *(longlong *)(unaff_R14 + 0x38) + (ulonglong)*(ushort *)(lVar4 + 0x22);

-      UNLOCK();

-      unaff_RBX = lVar4;

-    }

+  if (((param_1 != 1) && (param_1 != 2)) && (param_1 != 3)) {

+    return 0;

   }

-  return unaff_RBX;

+LAB_0:

+  *param_2 = param_3;

+  *(undefined8 *)(param_2 + 2) = param_4;

+  return 1;

 }
```

## `RtlpInitializeHeapSegment`  (modified)

```diff
--- RtlpInitializeHeapSegment
+++ RtlpInitializeHeapSegment
@@ -1,19 +1,116 @@
 

-void RtlpInitializeHeapSegment(longlong *param_1)

+undefined8

+RtlpInitializeHeapSegment

+          (longlong param_1,longlong param_2,longlong param_3,undefined8 param_4,undefined4 param_5,

+          longlong param_6,ulonglong param_7,ulonglong param_8)

 

 {

-  longlong in_RAX;

-  bool in_ZF;

-  undefined8 uStack0000000000000028;

+  ulonglong uVar1;

+  longlong lVar2;

+  undefined2 uVar3;

+  longlong *plVar4;

+  int iVar5;

+  uint uVar6;

+  ulonglong uVar7;

+  longlong lVar8;

+  longlong lVar9;

+  uint *puVar10;

+  longlong *plVar11;

+  ulonglong uVar12;

+  undefined8 in_stack_ffffffffffffffb8;

+  undefined4 uVar13;

+  undefined8 in_stack_ffffffffffffffc0;

+  undefined4 uVar14;

+  ulonglong local_38 [2];

   

-  if (in_ZF) {

-    *param_1 = in_RAX;

-    *(longlong **)(in_RAX + 8) = param_1;

+  uVar12 = param_8;

+  uVar13 = (undefined4)((ulonglong)in_stack_ffffffffffffffb8 >> 0x20);

+  uVar14 = (undefined4)((ulonglong)in_stack_ffffffffffffffc0 >> 0x20);

+  local_38[0] = 0;

+  uVar7 = param_8 - param_6;

+  if (uVar7 < 0xfffff001) {

+    uVar1 = param_3 + 0xf;

+    lVar8 = (longlong)(uVar7 + ((longlong)uVar7 >> 0x3f & 0xfffU)) >> 0xc;

+    lVar2 = (uVar1 & 0xfffffffffffffff0) + param_2;

+    if (lVar2 + 0x50U < param_7) {

+LAB_0:

+      param_8 = lVar8;

+      *(undefined1 *)(param_2 + 10) = 1;

+      lVar9 = uVar12 - param_7;

+      *(undefined1 *)(param_2 + 0xf) = 1;

+      *(ushort *)(param_2 + 8) = (ushort)((longlong)uVar1 >> 4);

+      *(undefined1 *)(param_2 + 0xb) = 0;

+      uVar3 = *(undefined2 *)(param_1 + 0x8c);

+      *(undefined4 *)(param_2 + 0x14) = param_5;

+      *(longlong *)(param_2 + 0x28) = param_1;

+      *(undefined2 *)(param_2 + 0xc) = uVar3;

+      *(undefined4 *)(param_2 + 0x10) = 0xffeeffee;

+      *(longlong *)(param_2 + 0x30) = param_6;

+      *(longlong *)(param_2 + 0x40) = lVar2;

+      *(int *)(param_2 + 0x38) = (int)param_8;

+      *(undefined4 *)(param_2 + 0x50) = 0;

+      uVar6 = (int)param_8 << 0xc;

+      *(ulonglong *)(param_2 + 0x48) = (ulonglong)uVar6 + param_6;

+      lVar8 = param_2 + 0x60;

+      *(ulonglong *)(param_1 + 0x240) = *(longlong *)(param_1 + 0x240) + (ulonglong)uVar6;

+      *(ulonglong *)(param_1 + 0x238) = *(longlong *)(param_1 + 0x238) + (ulonglong)uVar6;

+      *(longlong *)(param_2 + 0x68) = lVar8;

+      *(longlong *)lVar8 = lVar8;

+      *(bool *)(param_2 + 0xe) = *(longlong *)(param_2 + 0x28) != param_2;

+      *(ushort *)(lVar2 + 0xc) = *(ushort *)(param_2 + 8) ^ *(ushort *)(param_1 + 0x8c);

+      if (*(longlong *)(param_2 + 0x28) == param_2) {

+        uVar12 = 0;

+      }

+      else {

+        uVar12 = (uVar1 >> 0x10) + 1;

+        if (0xfd < uVar12) {

+          RtlpLogHeapFailure(3,*(longlong *)(param_2 + 0x28),lVar2,param_2,0,0);

+        }

+      }

+      puVar10 = (uint *)(param_2 + 8);

+      *(char *)(lVar2 + 0xe) = (char)uVar12;

+      RtlpCreateUCREntry(param_1,param_2,param_7 - 0x30,

+                         ((uint)(lVar9 >> 0x3f) & 0xfff) + (int)lVar9 & 0xfffff000,lVar2,local_38);

+      if (*(int *)(param_1 + 0x7c) != 0) {

+        *(byte *)(param_2 + 0xb) =

+             *(byte *)(param_2 + 10) ^ *(byte *)(param_2 + 9) ^ *(byte *)puVar10;

+        *puVar10 = *puVar10 ^ *(uint *)(param_1 + 0x88);

+      }

+      if (local_38[0] != 0) {

+        RtlpInsertFreeBlock(param_1,lVar2);

+      }

+      lVar2 = param_1 + 0x120;

+      plVar11 = (longlong *)(param_2 + 0x18);

+      plVar4 = *(longlong **)(param_1 + 0x128);

+      if (*plVar4 == lVar2) {

+        *plVar11 = lVar2;

+        *(longlong **)(param_2 + 0x20) = plVar4;

+        *plVar4 = (longlong)plVar11;

+        *(longlong **)(param_1 + 0x128) = plVar11;

+      }

+      else {

+        RtlpLogHeapFailure(0xd,0,lVar2,0,*plVar4,0);

+      }

+      *(int *)(param_1 + 0x260) = *(int *)(param_1 + 0x260) + 1;

+      return 1;

+    }

+    if (lVar2 + 0x50U < param_8) {

+      local_38[0] = (lVar2 - param_7) + 0x100f & 0xfffffffffffff000;

+      param_8 = lVar8;

+      iVar5 = RtlpHpHeapCheckCommitLimit

+                        (local_38[0],*(longlong *)(param_1 + 0x240) - *(longlong *)(param_1 + 0x2a0)

+                         ,param_1,param_1 + 0x178);

+      if ((iVar5 != 0) &&

+         (iVar5 = ZwAllocateVirtualMemory

+                            (0xffffffffffffffff,&param_7,0,local_38,CONCAT44(uVar13,0x1000),

+                             CONCAT44(uVar14,4)), -1 < iVar5)) {

+        param_7 = param_7 + local_38[0];

+        lVar8 = param_8;

+        goto LAB_0;

+      }

+      *(int *)(param_1 + 0x280) = *(int *)(param_1 + 0x280) + 1;

+    }

   }

-  else {

-    uStack0000000000000028 = 0;

-    RtlpLogHeapFailure(0xd);

-  }

-  return;

+  return 0;

 }
```

## `NtQueryInformationToken`  (modified)

```diff
--- NtQueryInformationToken
+++ PspDoesJobHierarchyPermitUILimits
@@ -1,1583 +1,35 @@
 

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

-/* WARNING: Type propagation algorithm not settling */

-

-ulonglong NtQueryInformationToken

-                    (undefined8 param_1,int param_2,ulonglong *param_3,uint param_4,uint *param_5)

+bool PspDoesJobHierarchyPermitUILimits(longlong param_1,ulonglong param_2)

 

 {

-  ushort *puVar1;

-  char cVar2;

+  int iVar1;

+  longlong lVar2;

   bool bVar3;

-  char cVar4;

-  byte bVar5;

-  uint uVar6;

-  uint uVar7;

-  int iVar8;

-  uint uVar9;

-  longlong *plVar10;

-  longlong *plVar11;

-  undefined8 uVar12;

-  char *pcVar13;

-  int *piVar14;

-  ulonglong uVar15;

-  int iVar16;

-  int iVar17;

-  longlong lVar18;

-  uint *puVar19;

-  longlong *plVar20;

-  ulonglong *puVar21;

-  longlong *plVar22;

-  uint *puVar23;

-  longlong lVar24;

-  undefined8 *puVar25;

-  uint uVar26;

-  uint uVar27;

-  ushort uVar28;

-  uint uVar29;

-  uint uVar30;

-  ulonglong uVar31;

-  ushort uVar32;

-  uint uVar33;

-  uint uVar34;

-  longlong *plVar35;

-  uint uVar36;

-  ushort *puVar38;

-  ushort *puVar39;

-  undefined4 extraout_XMM0_Da;

-  undefined4 uVar42;

-  ulonglong uVar40;

-  uint **ppuVar41;

-  undefined4 uVar44;

-  char *pcVar43;

-  undefined4 uVar46;

-  longlong **pplVar45;

-  undefined8 in_stack_fffffffffffffe60;

-  undefined4 uVar47;

-  char local_158 [8];

-  uint *local_150;

-  longlong *local_148;

-  uint local_140 [2];

-  longlong *local_138;

-  char local_130;

-  uint local_12c;

-  longlong *local_128;

-  longlong *local_120;

-  ulonglong local_118;

-  uint local_110;

-  uint local_10c;

-  undefined8 local_108;

-  ulonglong local_100;

-  uint *local_f8;

-  ulonglong local_f0;

-  uint local_e8;

-  uint *local_e0;

-  undefined8 uStack_d8;

-  ulonglong local_d0 [3];

-  ulonglong uStack_b8;

-  undefined8 local_b0;

-  ulonglong uStack_a8;

-  undefined8 local_a0;

-  undefined8 *******pppppppuStack_98;

-  undefined8 *******local_90;

-  ulonglong uStack_88;

-  undefined8 *******local_80;

-  undefined8 *******pppppppuStack_78;

-  longlong local_70 [9];

-  longlong *plVar37;

   

-  plVar20 = (longlong *)0x0;

-  uVar30 = 0;

-  uVar34 = 0;

-                    /* 0xad0840  1738  NtQueryInformationToken */

-  local_150 = (uint *)0x0;

-  uVar26 = 0;

-  local_140[0] = 0;

-  local_f0 = 0;

-  local_70[0] = 0;

-  local_70[1] = 0;

-  local_138 = (longlong *)0x0;

-  local_12c = 0;

-  local_70[6] = 0;

-  local_70[7] = 0;

-  local_a0 = 0;

-  pppppppuStack_98 = (undefined8 *******)0x0;

-  local_90 = (undefined8 *******)0x0;

-  uStack_88 = 0;

-  local_80 = (undefined8 *******)0x0;

-  pppppppuStack_78 = (undefined8 *******)0x0;

-  local_158[0] = '\0';

-  local_148 = (longlong *)0x0;

-  cVar2 = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

-  if (cVar2 != '\0') {

-    ProbeForWrite(param_3,param_4,4);

-    puVar19 = (uint *)&DAT_0;

-    if (param_5 < &DAT_0) {

-      puVar19 = param_5;

-    }

-    *puVar19 = *puVar19;

-  }

-  uVar7 = 0;

-  switch(param_2) {

-  case 1:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = (uint)*(byte *)(**(longlong **)(puVar19 + 0x26) + 1) * 4 + 0x18;

-    *param_5 = uVar26;

-    if (param_4 < uVar26) goto LAB_1;

-    RtlCopySidAndAttributesArray

-              (1,*(undefined8 *)(puVar19 + 0x26),uVar26,param_3,param_3 + 2,&local_138,&local_138);

-LAB_2:

-    uVar12 = *(undefined8 *)(puVar19 + 0xc);

-    goto LAB_3;

-  case 2:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = puVar19[0x1f];

-    uVar30 = uVar26 * 0x10 - 8;

-    if (1 < uVar26) {

-      plVar20 = *(longlong **)(puVar19 + 0x26);

-      uVar15 = (ulonglong)(uVar26 - 1);

-      do {

-        plVar20 = plVar20 + 2;

-        uVar30 = uVar30 + (uint)*(byte *)(*plVar20 + 1) * 4 + 8;

-        uVar15 = uVar15 - 1;

-      } while (uVar15 != 0);

-    }

-    *param_5 = uVar30;

-    if (uVar30 <= param_4) {

-      *(uint *)param_3 = puVar19[0x1f] - 1;

-      RtlCopySidAndAttributesArray

-                (puVar19[0x1f] - 1,*(longlong *)(puVar19 + 0x26) + 0x10,uVar30,param_3 + 1,

-                 (ulonglong)(puVar19[0x1f] * 0x10 - 0x20) + 0x18 + (longlong)param_3,&local_138,

-                 &local_138);

-      goto LAB_4;

-    }

-    break;

-  case 3:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = SepTokenPrivilegeCount(puVar19);

-    if (uVar26 < 2) {

-      uVar26 = 0x10;

-    }

-    else {

-      uVar26 = uVar26 * 0xc + 4;

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      SepConvertTokenPrivileges(puVar19,param_3);

-      goto LAB_4;

-    }

-    break;

-  case 4:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    iVar16 = (uint)*(byte *)(*(longlong *)

-                              (*(longlong *)(puVar19 + 0x26) + (ulonglong)puVar19[0x24] * 0x10) + 1)

-             * 4;

-    uVar26 = iVar16 + 0x10;

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      *param_3 = (ulonglong)(param_3 + 1);

-      RtlCopySid(iVar16 + 8,param_3 + 1,

-                 *(undefined8 *)(*(longlong *)(puVar19 + 0x26) + (ulonglong)puVar19[0x24] * 0x10));

-      goto LAB_4;

-    }

-    break;

-  case 5:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    iVar16 = (uint)*(byte *)(*(longlong *)(puVar19 + 0x2a) + 1) * 4;

-    uVar26 = iVar16 + 0x10;

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      *param_3 = (ulonglong)(param_3 + 1);

-      RtlCopySid(iVar16 + 8,param_3 + 1,*(undefined8 *)(puVar19 + 0x2a));

-      goto LAB_4;

-    }

-    break;

-  case 6:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    local_140[0] = 8;

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = local_140[0];

-    if (*(longlong *)(puVar19 + 0x2e) != 0) {

-      uVar26 = *(ushort *)(*(longlong *)(puVar19 + 0x2e) + 2) + 8;

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      if (*(longlong *)(puVar19 + 0x2e) == 0) {

-        *param_3 = 0;

+  lVar2 = *(longlong *)(param_1 + 0x518);

+  do {

+    if (lVar2 == 0) {

+LAB_0:

+      if ((param_2 & 1) == 0) {

+        iVar1 = PspEnumJobsAndProcessesInJobHierarchy

+                          (param_1,PspDoesJobHierarchyPermitUILimitsCallback,0,0,param_1,1);

+        bVar3 = -1 < iVar1;

       }

       else {

-        *param_3 = (ulonglong)(param_3 + 1);

-        RtlCopyMemory(param_3 + 1,*(void **)(puVar19 + 0x2e),

-                      (ulonglong)*(ushort *)((longlong)*(void **)(puVar19 + 0x2e) + 2));

+        bVar3 = true;

       }

-      goto LAB_4;

+      return bVar3;

     }

-    break;

-  case 7:

-    uVar15 = SepReferenceTokenByHandle(param_1,0x10,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

+    if ((*(uint *)(lVar2 + 0x610) & 0x10) != 0) {

+      if ((param_2 & 2) == 0) {

+        return false;

+      }

+      if ((*(uint *)(lVar2 + 0x614) & 0x10) == 0) {

+        return false;

+      }

+      goto LAB_0;

     }

-    *param_5 = 0x10;

-    if (0xf < param_4) {

-      uVar26 = local_150[1];

-      uVar30 = local_150[2];

-      uVar34 = local_150[3];

-      *(uint *)param_3 = *local_150;

-      *(uint *)((longlong)param_3 + 4) = uVar26;

-      *(uint *)(param_3 + 1) = uVar30;

-      *(uint *)((longlong)param_3 + 0xc) = uVar34;

-      goto LAB_5;

-    }

-    goto LAB_6;

-  case 8:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (3 < param_4) {

-      *(uint *)param_3 = local_150[0x30];

-      goto LAB_5;

-    }

-    goto LAB_6;

-  case 9:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    puVar19 = local_150;

-    if (local_150[0x30] == 2) {

-      *param_5 = 4;

-      if (3 < param_4) {

-        *(uint *)param_3 = local_150[0x31];

-        goto LAB_5;

-      }

-      goto LAB_6;

-    }

-LAB_7:

-    ObfDereferenceObjectWithTag(puVar19,0x74726853);

-switchD_140ad092b_caseD_ffffffff:

-    return 0xc0000003;

-  case 10:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 0x38;

-    if (param_4 < 0x38) goto LAB_6;

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    *param_3 = *(ulonglong *)(puVar19 + 4);

-    param_3[1] = *(ulonglong *)(puVar19 + 6);

-    param_3[2] = *(ulonglong *)(puVar19 + 10);

-    *(uint *)(param_3 + 3) = puVar19[0x30];

-    *(uint *)((longlong)param_3 + 0x1c) = puVar19[0x31];

-    *(uint *)(param_3 + 4) = puVar19[0x22];

-    local_e8 = (puVar19[0x22] + (uint)*(byte *)(*(longlong *)(puVar19 + 0x2a) + 1) * -4) - 8;

-    if (*(longlong *)(puVar19 + 0x2e) != 0) {

-      local_e8 = local_e8 - *(ushort *)(*(longlong *)(puVar19 + 0x2e) + 2);

-    }

-    *(uint *)((longlong)param_3 + 0x24) = local_e8;

-    *(uint *)(param_3 + 5) = puVar19[0x1f] - 1;

-    uVar26 = SepTokenPrivilegeCount(puVar19);

-    *(uint *)((longlong)param_3 + 0x2c) = uVar26;

-    param_3[6] = *(ulonglong *)(puVar19 + 0xe);

-    goto LAB_4;

-  case 0xb:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = puVar19[0x20];

-    uVar30 = uVar26 * 0x10 + 8;

-    if (uVar26 != 0) {

-      plVar20 = *(longlong **)(puVar19 + 0x28);

-      uVar15 = (ulonglong)uVar26;

-      do {

-        uVar30 = uVar30 + (uint)*(byte *)(*plVar20 + 1) * 4 + 8;

-        plVar20 = plVar20 + 2;

-        uVar15 = uVar15 - 1;

-      } while (uVar15 != 0);

-    }

-    *param_5 = uVar30;

-    if (uVar30 <= param_4) {

-      *(uint *)param_3 = puVar19[0x20];

-      RtlCopySidAndAttributesArray

-                (puVar19[0x20],*(undefined8 *)(puVar19 + 0x28),uVar30,param_3 + 1,

-                 (ulonglong)(puVar19[0x20] << 4) + 8 + (longlong)param_3,&local_138,&local_138);

-      goto LAB_4;

-    }

-    break;

-  case 0xc:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (param_4 < 4) goto LAB_6;

-    SeQuerySessionIdToken(local_150,&local_12c);

-    *(uint *)param_3 = local_12c;

-    *param_5 = 4;

-    goto LAB_8;

-  case 0xd:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar33 = SepTokenPrivilegeCount(puVar19);

-    local_128 = (longlong *)CONCAT44(local_128._4_4_,uVar33);

-    uVar36 = uVar33 * 0xc;

-    local_120 = (longlong *)CONCAT44(local_120._4_4_,uVar36);

-    uVar26 = puVar19[0x1f];

-    uVar6 = uVar26 * 0x10;

-    local_f8 = (uint *)CONCAT44(local_f8._4_4_,uVar6);

-    uVar27 = uVar34;

-    uVar9 = uVar30;

-    if (uVar26 < 2) {

-LAB_9:

-      uVar29 = uVar6;

-      if (uVar7 < uVar26) {

-        plVar10 = *(longlong **)(puVar19 + 0x26);

-        uVar15 = (ulonglong)uVar7;

-        goto LAB_10;

-      }

-    }

-    else {

-      plVar10 = *(longlong **)(puVar19 + 0x26);

-      uVar7 = (uVar26 - 2 >> 1) + 1;

-      uVar31 = (ulonglong)uVar7;

-      uVar7 = uVar7 * 2;

-      local_118 = CONCAT44(local_118._4_4_,uVar7);

-      uVar15 = uVar31 * 2;

-      plVar11 = plVar10;

-      plVar35 = plVar20;

-      plVar22 = plVar20;

-      do {

-        uVar27 = (int)plVar35 + ((uint)*(byte *)(*plVar11 + 1) * 4 + 0xf & 0xfffffff8);

-        plVar35 = (longlong *)(ulonglong)uVar27;

-        uVar9 = (int)plVar22 + ((uint)*(byte *)(plVar11[2] + 1) * 4 + 0xf & 0xfffffff8);

-        plVar22 = (longlong *)(ulonglong)uVar9;

-        plVar11 = plVar11 + 4;

-        uVar31 = uVar31 - 1;

-      } while (uVar31 != 0);

-      local_148 = plVar10;

-      if (uVar26 <= uVar7) goto LAB_9;

-LAB_10:

-      uVar29 = ((uint)*(byte *)(plVar10[uVar15 * 2] + 1) * 4 + 0xf & 0xfffffff8) + uVar6;

-    }

-    uVar29 = uVar29 + uVar27 + uVar9;

-    uVar7 = puVar19[0x20];

-    iVar16 = uVar7 * 0x10;

-    local_100 = CONCAT44(local_100._4_4_,iVar16);

-    if (uVar7 < 2) {

-LAB_11:

-      plVar35 = plVar20;

-      if ((uint)plVar35 < uVar7) {

-        plVar10 = *(longlong **)(puVar19 + 0x28);

-        goto LAB_12;

-      }

-    }

-    else {

-      plVar10 = *(longlong **)(puVar19 + 0x28);

-      uVar27 = (uVar7 - 2 >> 1) + 1;

-      uVar15 = (ulonglong)uVar27;

-      uVar27 = uVar27 * 2;

-      local_118 = CONCAT44(local_118._4_4_,uVar27);

-      plVar35 = (longlong *)(uVar15 * 2);

-      plVar11 = plVar10;

-      plVar22 = plVar20;

-      do {

-        uVar34 = (int)plVar20 + ((uint)*(byte *)(*plVar11 + 1) * 4 + 0xf & 0xfffffff8);

-        plVar20 = (longlong *)(ulonglong)uVar34;

-        uVar30 = (int)plVar22 + ((uint)*(byte *)(plVar11[2] + 1) * 4 + 0xf & 0xfffffff8);

-        plVar22 = (longlong *)(ulonglong)uVar30;

-        plVar11 = plVar11 + 4;

-        uVar15 = uVar15 - 1;

-      } while (uVar15 != 0);

-      plVar20 = (longlong *)(ulonglong)uVar27;

-      local_148 = plVar35;

-      local_138 = plVar10;

-      if (uVar7 <= uVar27) goto LAB_11;

-LAB_12:

-      iVar16 = ((uint)*(byte *)(plVar10[(longlong)plVar35 * 2] + 1) * 4 + 0xf & 0xfffffff8) + iVar16

-      ;

-    }

-    uVar34 = iVar16 + uVar34 + uVar30;

-    uVar30 = uVar36 + 0x38 + uVar34 + uVar29;

-    *param_5 = uVar30;

-    if (uVar30 <= param_4) {

-      param_3[6] = *(ulonglong *)(puVar19 + 6);

-      *(uint *)((longlong)param_3 + 4) = uVar29;

-      *(uint *)param_3 = puVar19[0x1f];

-      puVar21 = param_3 + 7;

-      param_3[1] = (ulonglong)puVar21;

-      *(uint *)((longlong)param_3 + 0x14) = uVar34;

-      *(uint *)(param_3 + 2) = puVar19[0x20];

-      if (puVar19[0x20] == 0) {

-        param_3[3] = 0;

-        uVar15 = local_f0;

-      }

-      else {

-        uVar15 = (ulonglong)uVar29 + (longlong)puVar21;

-        param_3[3] = uVar15;

-      }

-      *(uint *)((longlong)param_3 + 0x24) = uVar36;

-      *(uint *)(param_3 + 4) = uVar33;

-      uVar31 = (ulonglong)uVar34 + (ulonglong)uVar29 + (longlong)puVar21;

-      param_3[5] = uVar31;

-      RtlCopySidAndAttributesArray

-                (puVar19[0x1f],*(undefined8 *)(puVar19 + 0x26),uVar29 + uVar26 * -0x10,puVar21,

-                 (longlong)puVar21 + (ulonglong)uVar6,&local_138,&local_138);

-      if (uVar15 != 0) {

-        RtlCopySidAndAttributesArray

-                  (puVar19[0x20],*(undefined8 *)(puVar19 + 0x28),uVar34 - (int)local_100,uVar15,

-                   uVar15 + (local_100 & 0xffffffff),&local_138,&local_138);

-      }

-      SepConvertTokenPrivilegesToLuidAndAttributes(puVar19,uVar31);

-      goto LAB_4;

-    }

-    break;

-  case 0xf:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (param_4 < 4) {

-      return 0xc0000023;

-    }

-    *(uint *)param_3 = local_150[0x32] >> 6 & 1;

-    goto LAB_5;

-  case 0x10:

-    cVar4 = SeSinglePrivilegeCheck(SeSecurityPrivilege,cVar2);

-    if (cVar4 == '\0') {

-      return 0xc0000061;

-    }

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 0x1f;

-    if (param_4 < 0x1f) goto LAB_6;

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar15 = *(ulonglong *)(puVar19 + 0x18);

-    *param_3 = *(ulonglong *)(puVar19 + 0x16);

-    param_3[1] = uVar15;

-    param_3[2] = *(ulonglong *)(puVar19 + 0x1a);

-    *(uint *)(param_3 + 3) = puVar19[0x1c];

-    *(short *)((longlong)param_3 + 0x1c) = (short)puVar19[0x1d];

-    *(undefined1 *)((longlong)param_3 + 0x1e) = *(undefined1 *)((longlong)puVar19 + 0x76);

-LAB_4:

-    uVar12 = *(undefined8 *)(puVar19 + 0xc);

-LAB_3:

-    ExReleaseResourceLite(uVar12);

-    KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-    goto LAB_5;

-  case 0x11:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 8;

-    if (7 < param_4) {

-      *param_3 = *(ulonglong *)(local_150 + 0x38);

-      goto LAB_5;

-    }

-    goto LAB_6;

-  case 0x12:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (3 < param_4) {

-      puVar19 = local_150;

-      uVar26 = SepGetTokenElevationType(local_150);

-      *(uint *)param_3 = uVar26;

-      ObfDereferenceObjectWithTag(puVar19,0x74726853);

-      return 0;

-    }

-    goto LAB_6;

-  case 0x13:

-    local_128 = (longlong *)0x0;

-    local_108 = 0;

-    local_100 = 0;

-    local_d0[0] = 0;

-    local_d0[1] = 0;

-    local_d0[2] = 0;

-    uStack_b8 = 0;

-    local_b0 = 0;

-    uStack_a8 = uStack_a8 & 0xffffffff00000000;

-    local_130 = '\0';

-    pplVar45 = &local_148;

-    pcVar43 = local_158;

-    ppuVar41 = &local_150;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 8;

-    if (param_4 != 8) goto LAB_13;

-    iVar16 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

-    if (iVar16 == 0) {

-      bVar3 = false;

-    }

-    else {

-      local_118 = local_118 & 0xffffffff00000000;

-      RtlQueryElevationFlags(&local_118);

-      local_130 = ((byte)local_118 & 0x18) == 0x10;

-      bVar3 = (bool)local_130;

-    }

-    local_158[0] = SeSinglePrivilegeCheck(SeTcbPrivilege,cVar2);

-    local_120 = (longlong *)CONCAT44(local_120._4_4_,2 - (uint)(local_158[0] != '\0'));

-    iVar16 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline(-local_158[0]);

-    puVar19 = local_150;

-    if (iVar16 == 0) {

-      uVar26 = SepReferenceLogonSessionSilo

-                         (*(longlong *)(local_150 + 0x36) + 0x10,

-                          *(undefined8 *)(*(longlong *)(local_150 + 0x36) + 0xa8),&local_128);

-      uVar15 = (ulonglong)uVar26;

-      plVar11 = local_128;

-      if ((int)uVar26 < 0) goto LAB_14;

-    }

-    else {

-      if (((bVar3) && (iVar16 = SepGetTokenElevationType(local_150), iVar16 == 3)) &&

-         (lVar18 = *(longlong *)(puVar19 + 0x36),

-         *(int *)(lVar18 + 0x14) == 0 && *(int *)(lVar18 + 0x10) == 0)) {

-        local_118 = 0;

-        uVar12 = *(undefined8 *)(lVar18 + 8);

-        uVar26 = 0xc0000002;

-        iVar16 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

-        if ((iVar16 != 0) && (lVar18 = ExGetExtensionTable(SepAuthExtensionHost), lVar18 != 0)) {

-          uVar26 = (**(code **)(lVar18 + 0x30))(uVar12,&local_118);

-          ExReleaseExtensionTable(SepAuthExtensionHost);

-        }

-        if ((int)uVar26 < 0) {

-          ObfDereferenceObjectWithTag(puVar19,0x74726853);

-          return (ulonglong)uVar26;

-        }

-        local_f8 = (uint *)0x0;

-        pcVar43 = (char *)0x0;

-        ppuVar41 = &local_f8;

-        uVar26 = ObReferenceObjectByHandle(local_118,8,SeTokenObjectType,0,ppuVar41,0);

-        uVar15 = (ulonglong)uVar26;

-        ObCloseHandle(local_118,0);

-        puVar23 = local_f8;

-        if ((int)uVar26 < 0) goto LAB_14;

-        uVar26 = SepReferenceLogonSessionSilo

-                           (local_f8 + 6,*(undefined8 *)(*(longlong *)(puVar19 + 0x36) + 0xa8),

-                            &local_128);

-        ObfDereferenceObject(puVar23);

-        if ((int)uVar26 < 0) {

-          ObfDereferenceObjectWithTag(puVar19,0x74726853);

-          return (ulonglong)uVar26;

-        }

-        SeQuerySessionIdToken(puVar19,&local_12c);

-        plVar11 = local_128;

-        uVar26 = SeSetSessionIdToken(local_128[7],local_12c);

-        if (-1 < (int)uVar26) {

-          plVar11[2] = *(longlong *)(*(longlong *)(puVar19 + 0x36) + 8);

-          lVar18 = *(longlong *)(puVar19 + 0x36);

-          uVar12 = PsGetCurrentServerSilo();

-          uVar26 = SepReferenceLogonSessionSilo(lVar18 + 8,uVar12,&local_e0);

-          if (-1 < (int)uVar26) goto LAB_15;

-        }

-        uVar15 = (ulonglong)uVar26;

-        SepDeReferenceLogonSessionDirect(plVar11);

-        goto LAB_14;

-      }

-      uVar26 = SepReferenceLogonSessionSilo

-                         (*(longlong *)(puVar19 + 0x36) + 0x10,

-                          *(undefined8 *)(*(longlong *)(puVar19 + 0x36) + 0xa8),&local_128);

-      plVar11 = local_128;

-      if ((int)uVar26 < 0) {

-        ObfDereferenceObjectWithTag(puVar19,0x74726853);

-        return (ulonglong)uVar26;

-      }

-    }

-LAB_15:

-    iVar16 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

-    uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-    uVar26 = uVar7;

-    if (((iVar16 != 0) && (local_130 != '\0')) && (local_158[0] == '\0')) {

-      lVar18 = *(longlong *)(*(longlong *)(puVar19 + 0x36) + 0x38);

-      uVar30 = uVar7;

-      if (lVar18 != 0) {

-        *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-             *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-        ExAcquireResourceSharedLite(*(undefined8 *)(lVar18 + 0x30),1);

-        local_138 = (longlong *)CONCAT44(local_138._4_4_,*(undefined4 *)(lVar18 + 200));

-        ExReleaseResourceLite(*(undefined8 *)(lVar18 + 0x30));

-        KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-        plVar11 = local_128;

-        puVar19 = local_150;

-        uVar30 = (uint)local_138;

-      }

-      uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-      if ((uVar30 >> 0x1b & 1) != 0) {

-        local_118 = local_118 & 0xffffffff00000000;

-        local_70[2] = 0;

-        local_70[3] = 0;

-        local_70[4] = 0;

-        local_70[5] = 0;

-        SeCaptureSubjectContext(local_70 + 2);

-        lVar18 = *(longlong *)(*(longlong *)(local_70[4] + 0xd8) + 0x38);

-        if (lVar18 != 0) {

-          *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-               *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-          ExAcquireResourceSharedLite(*(undefined8 *)(lVar18 + 0x30),1);

-          local_118 = CONCAT44(local_118._4_4_,*(undefined4 *)(lVar18 + 200));

-          ExReleaseResourceLite(*(undefined8 *)(lVar18 + 0x30));

-          KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-          plVar11 = local_128;

-          puVar19 = local_150;

-        }

-        lVar18 = local_70[4];

-        uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-        if ((local_118 & 0x8000000) != 0) {

-          cVar4 = RtlEqualSid(**(undefined8 **)(puVar19 + 0x26),

-                              **(undefined8 **)(local_70[4] + 0x98));

-          uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-          if (cVar4 != '\0') {

-            local_e0 = (uint *)0x0;

-            uStack_d8 = 0;

-            SeQueryTokenIntegrity(lVar18,&local_e0);

-            puVar23 = local_e0;

-            uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-            if ((int)uStack_d8 == 0x60) {

-              pcVar13 = (char *)RtlSubAuthorityCountSid(local_e0);

-              uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-              if (*pcVar13 == '\x01') {

-                piVar14 = (int *)RtlSubAuthoritySid(puVar23,0);

-                uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-                if (*piVar14 == 0x3000) {

-                  puVar23 = *(uint **)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x350)

-                  ;

-                  puVar39 = &g_ImpersonationTokenAllowedList;

-                  uVar12 = 0xc0;

-                  local_e0 = puVar23;

-                  do {

-                    lVar18 = PsGetCurrentServerSiloGlobals();

-                    plVar11 = local_128;

-                    puVar19 = local_150;

-                    uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-                    lVar18 = *(longlong *)(lVar18 + 0x4b0);

-                    uVar28 = *puVar39;

-                    if (uVar28 <= (ushort)*puVar23) {

-                      puVar38 = *(ushort **)(puVar39 + 4);

-                      puVar1 = puVar38 + (uVar28 >> 1);

-                      if (puVar1 <= puVar38) {

-LAB_16:

-                        SeReleaseSubjectContext(local_70 + 2);

-                        uVar26 = 1;

-                        goto LAB_17;

-                      }

-                      lVar24 = (*(longlong *)(puVar23 + 2) +

-                               ((ulonglong)(ushort)*puVar23 - (ulonglong)uVar28 & 0xfffffffffffffffe

-                               )) - (longlong)puVar38;

-                      while( true ) {

-                        uVar28 = *puVar38;

-                        if (0x60 < uVar28) {

-                          if (uVar28 < 0x7b) {

-                            uVar28 = uVar28 - 0x20;

-                          }

-                          else if ((lVar18 != 0) && ((ushort)uVar12 <= uVar28)) {

-                            uVar28 = uVar28 + *(short *)(lVar18 + (ulonglong)

-                                                                  ((uint)*(ushort *)

-                                                                          (lVar18 + (ulonglong)

-                                                                                    ((uint)*(ushort 

-                                                  *)(lVar18 + (ulonglong)(uVar28 >> 8) * 2) +

-                                                  (uVar28 >> 4 & 0xf)) * 2) + (uVar28 & 0xf)) * 2);

-                          }

-                        }

-                        uVar32 = *(ushort *)(lVar24 + (longlong)puVar38);

-                        if (0x60 < uVar32) {

-                          if (uVar32 < 0x7b) {

-                            uVar32 = uVar32 - 0x20;

-                          }

-                          else if ((lVar18 != 0) && (0xbf < uVar32)) {

-                            uVar32 = uVar32 + *(short *)(lVar18 + (ulonglong)

-                                                                  ((uint)*(ushort *)

-                                                                          (lVar18 + (ulonglong)

-                                                                                    ((uint)*(ushort 

-                                                  *)(lVar18 + (ulonglong)(uVar32 >> 8) * 2) +

-                                                  (uVar32 >> 4 & 0xf)) * 2) + (uVar32 & 0xf)) * 2);

-                          }

-                        }

-                        if (uVar28 != uVar32) break;

-                        puVar38 = puVar38 + 1;

-                        if (puVar1 <= puVar38) goto LAB_16;

-                        uVar12 = 0xc0;

-                      }

-                      uVar12 = 0xc0;

-                      puVar23 = local_e0;

-                    }

-                    uVar30 = (int)plVar20 + 1;

-                    plVar20 = (longlong *)(ulonglong)uVar30;

-                    puVar39 = puVar39 + 8;

-                  } while (uVar30 == 0);

-                }

-              }

-            }

-          }

-        }

-        SeReleaseSubjectContext(local_70 + 2);

-      }

-    }

-LAB_17:

-    iVar16 = 1;

-    local_d0[0] = CONCAT44(local_d0[0]._4_4_,0x30);

-    local_d0[1] = 0;

-    if (cVar2 == '\0') {

-      uVar7 = 0x200;

-    }

-    uStack_b8 = CONCAT44(uStack_b8._4_4_,uVar7);

-    local_d0[2] = 0;

-    local_b0 = 0;

-    uStack_a8 = 0;

-    iVar8 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

-    if (iVar8 != 0) {

-      iVar16 = uVar26 + 1;

-    }

-    uVar31 = CONCAT44(uVar42,iVar16);

-    uVar26 = SepDuplicateToken(plVar11[7],local_d0,0,(ulonglong)local_120 & 0xffffffff,uVar31,

-                               (ulonglong)pcVar43 & 0xffffffffffffff00,

-                               (ulonglong)pplVar45 & 0xffffffffffffff00,&local_100);

-    uVar15 = (ulonglong)uVar26;

-    SepDeReferenceLogonSessionDirect(plVar11);

-    if (-1 < (int)uVar26) {

-      uVar26 = ObInsertObjectEx(local_100,0,0xf01ff,0,uVar31 & 0xffffffff00000000,0,&local_108);

-      uVar15 = (ulonglong)uVar26;

-      if (-1 < (int)uVar26) {

-        *param_3 = local_108;

-        ObfDereferenceObjectWithTag(puVar19,0x74726853);

-        return 0;

-      }

-    }

-LAB_14:

-    ObfDereferenceObjectWithTag(puVar19,0x74726853);

-    return uVar15;

-  case 0x14:

-    *param_5 = 4;

-    if (param_4 != 4) {

-      return 0xc0000004;

-    }

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = SepGetTokenElevation(puVar19);

-    ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-    KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-    *(uint *)param_3 = uVar26;

-    goto LAB_5;

-  case 0x15:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 1;

-    if (param_4 != 0) {

-      *(bool *)param_3 = (local_150[0x32] & 0x810) != 0;

-      goto LAB_5;

-    }

-    goto LAB_6;

-  case 0x16:

-    pplVar45 = &local_148;

-    pcVar43 = local_158;

-    ppuVar41 = &local_150;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-    uVar44 = (undefined4)((ulonglong)pcVar43 >> 0x20);

-    uVar46 = (undefined4)((ulonglong)pplVar45 >> 0x20);

-    uVar47 = (undefined4)((ulonglong)in_stack_fffffffffffffe60 >> 0x20);

-    uVar15 = 1;

-    lVar18 = 0x25;

-    plVar11 = plVar20;

-    do {

-      plVar10 = (longlong *)(ulonglong)((int)plVar11 + 1);

-      if ((*(ulonglong *)(puVar19 + 0x10) & uVar15) == 0) {

-        plVar10 = plVar11;

-      }

-      uVar15 = uVar15 << 1 | (ulonglong)((longlong)uVar15 < 0);

-      lVar18 = lVar18 + -1;

-      plVar11 = plVar10;

-    } while (lVar18 != 0);

-    iVar16 = (int)plVar10 * 0xc + 4;

-    if ((int)plVar10 == 0) {

-      iVar16 = 0x10;

-    }

-    local_138 = (longlong *)CONCAT44(local_138._4_4_,iVar16);

-    uVar26 = puVar19[0x1f];

-    iVar17 = uVar26 * 0x10;

-    local_118 = CONCAT44(local_118._4_4_,iVar17);

-    local_10c = puVar19[0x20];

-    iVar16 = local_10c * 0x10;

-    local_f8 = (uint *)CONCAT44(local_f8._4_4_,iVar16);

-    uVar27 = puVar19[200];

-    iVar8 = uVar27 * 0x10;

-    local_100 = CONCAT44(local_100._4_4_,iVar8);

-    uVar9 = uVar7;

-    uVar33 = uVar34;

-    uVar36 = uVar30;

-    if (uVar26 < 2) {

-LAB_18:

-      if (uVar9 < uVar26) {

-        plVar35 = *(longlong **)(puVar19 + 0x26);

-        uVar15 = (ulonglong)uVar9;

-        goto LAB_19;

-      }

-    }

-    else {

-      plVar35 = *(longlong **)(puVar19 + 0x26);

-      uVar9 = (uVar26 - 2 >> 1) + 1;

-      uVar31 = (ulonglong)uVar9;

-      uVar9 = uVar9 * 2;

-      local_120 = (longlong *)CONCAT44(local_120._4_4_,uVar9);

-      uVar15 = uVar31 * 2;

-      plVar11 = plVar35;

-      plVar22 = plVar20;

-      plVar37 = plVar20;

-      do {

-        uVar33 = (int)plVar22 + ((uint)*(byte *)(*plVar11 + 1) * 4 + 0xf & 0xfffffff8);

-        plVar22 = (longlong *)(ulonglong)uVar33;

-        uVar36 = (int)plVar37 + ((uint)*(byte *)(plVar11[2] + 1) * 4 + 0xf & 0xfffffff8);

-        plVar37 = (longlong *)(ulonglong)uVar36;

-        plVar11 = plVar11 + 4;

-        uVar31 = uVar31 - 1;

-      } while (uVar31 != 0);

-      local_128 = plVar35;

-      if (uVar26 <= uVar9) goto LAB_18;

-LAB_19:

-      iVar17 = ((uint)*(byte *)(plVar35[uVar15 * 2] + 1) * 4 + 0xf & 0xfffffff8) + iVar17;

-    }

-    local_f0 = CONCAT44(local_f0._4_4_,iVar17 + uVar33 + uVar36);

-    uVar26 = uVar7;

-    uVar9 = uVar34;

-    uVar33 = uVar30;

-    if (local_10c < 2) {

-LAB_20:

-      if (uVar26 < local_10c) {

-        plVar35 = *(longlong **)(puVar19 + 0x28);

-        uVar15 = (ulonglong)uVar26;

-        goto LAB_21;

-      }

-    }

-    else {

-      plVar35 = *(longlong **)(puVar19 + 0x28);

-      uVar9 = (local_10c - 2 >> 1) + 1;

-      uVar31 = (ulonglong)uVar9;

-      uVar26 = uVar9 * 2;

-      uVar15 = (ulonglong)uVar9 * 2;

-      plVar11 = plVar35;

-      plVar22 = plVar20;

-      plVar37 = plVar20;

-      do {

-        uVar9 = (int)plVar37 + ((uint)*(byte *)(*plVar11 + 1) * 4 + 0xf & 0xfffffff8);

-        plVar37 = (longlong *)(ulonglong)uVar9;

-        uVar33 = (int)plVar22 + ((uint)*(byte *)(plVar11[2] + 1) * 4 + 0xf & 0xfffffff8);

-        plVar22 = (longlong *)(ulonglong)uVar33;

-        plVar11 = plVar11 + 4;

-        uVar31 = uVar31 - 1;

-      } while (uVar31 != 0);

-      local_120 = plVar35;

-      if (local_10c <= uVar26) goto LAB_20;

-LAB_21:

-      iVar16 = ((uint)*(byte *)(plVar35[uVar15 * 2] + 1) * 4 + 0xf & 0xfffffff8) + iVar16;

-    }

-    local_140[0] = iVar16 + uVar9 + uVar33;

-    if (uVar27 < 2) {

-LAB_22:

-      if (uVar7 < uVar27) {

-        plVar35 = *(longlong **)(puVar19 + 0xc6);

-        uVar15 = (ulonglong)uVar7;

-        goto LAB_23;

-      }

-    }

-    else {

-      plVar35 = *(longlong **)(puVar19 + 0xc6);

-      uVar26 = (uVar27 - 2 >> 1) + 1;

-      uVar31 = (ulonglong)uVar26;

-      uVar7 = uVar26 * 2;

-      uVar15 = (ulonglong)uVar26 * 2;

-      plVar11 = plVar35;

-      plVar22 = plVar20;

-      plVar37 = plVar20;

-      do {

-        uVar34 = (int)plVar22 + ((uint)*(byte *)(*plVar11 + 1) * 4 + 0xf & 0xfffffff8);

-        plVar22 = (longlong *)(ulonglong)uVar34;

-        uVar30 = (int)plVar37 + ((uint)*(byte *)(plVar11[2] + 1) * 4 + 0xf & 0xfffffff8);

-        plVar37 = (longlong *)(ulonglong)uVar30;

-        plVar11 = plVar11 + 4;

-        uVar31 = uVar31 - 1;

-      } while (uVar31 != 0);

-      local_120 = plVar35;

-      if (uVar27 <= uVar7) goto LAB_22;

-LAB_23:

-      iVar8 = ((uint)*(byte *)(plVar35[uVar15 * 2] + 1) * 4 + 0xf & 0xfffffff8) + iVar8;

-    }

-    local_12c = iVar8 + uVar34 + uVar30;

-    local_120._0_4_ = 0;

-    if (*(longlong *)(puVar19 + 0xc4) != 0) {

-      local_120._0_4_ = (uint)*(byte *)(*(longlong *)(puVar19 + 0xc4) + 1) * 4 + 0xf & 0xfffffff8;

-    }

-    plVar11 = local_148;

-    if (local_158[0] == '\0') {

-      plVar11 = *(longlong **)(puVar19 + 0x114);

-    }

-    local_128._0_4_ = 0;

-    if (plVar11 != (longlong *)0x0) {

-      local_128._0_4_ = (uint)*(byte *)((longlong)plVar11 + 1) * 4 + 0xf & 0xfffffff8;

-    }

-    puVar23 = *(uint **)(puVar19 + 0xc2);

-    plVar35 = (longlong *)0x0;

-    local_108 = (ulonglong)local_108._4_4_ << 0x20;

-    plVar11 = plVar20;

-    if (puVar23 != (uint *)0x0) {

-      if ((ulonglong)*puVar23 * 0x70 < 0x100000000) {

-        uVar30 = (int)((ulonglong)*puVar23 * 0x70) + 0x30;

-        uVar26 = 0xffffffff;

-        if (uVar30 >= 0x30) {

-          uVar26 = uVar30;

-        }

-        uVar34 = -(uint)(uVar30 < 0x30) & 0xc0000095;

-        if (0x2f < uVar30) {

-          local_e0 = puVar23 + 2;

-          puVar23 = *(uint **)local_e0;

-          if (puVar23 != local_e0) {

-            do {

-              uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-              uVar44 = (undefined4)((ulonglong)pcVar43 >> 0x20);

-              uVar46 = (undefined4)((ulonglong)pplVar45 >> 0x20);

-              uVar47 = (undefined4)((ulonglong)in_stack_fffffffffffffe60 >> 0x20);

-              uVar30 = uVar26 + 1 & 0xfffffffe;

-              plVar11 = (longlong *)0x0;

-              if (uVar30 < uVar26) goto LAB_24;

-              uVar26 = (ushort)puVar23[8] + uVar30;

-              local_10c = 0xffffffff;

-              if (uVar26 >= uVar30) {

-                local_10c = uVar26;

-              }

-              uVar34 = -(uint)(uVar26 < uVar30) & 0xc0000095;

-              if (uVar26 < uVar30) {

-LAB_25:

-                plVar35 = (longlong *)(local_108 & 0xffffffff);

-                goto LAB_26;

-              }

-              uVar34 = AuthzBasepGetInternalSecurityAttributeValueCopyoutBufferSize

-                                 (puVar23,&local_10c);

-              uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-              uVar44 = (undefined4)((ulonglong)pcVar43 >> 0x20);

-              uVar46 = (undefined4)((ulonglong)pplVar45 >> 0x20);

-              uVar47 = (undefined4)((ulonglong)in_stack_fffffffffffffe60 >> 0x20);

-              if ((int)uVar34 < 0) goto LAB_25;

-              puVar23 = *(uint **)puVar23;

-              uVar26 = local_10c;

-            } while (puVar23 != local_e0);

-          }

-          plVar35 = (longlong *)(ulonglong)uVar26;

-        }

-      }

-      else {

-        uVar34 = 0xc0000095;

-        plVar35 = plVar20;

-      }

-LAB_26:

-      plVar11 = plVar20;

-      if (-1 < (int)uVar34) {

-        plVar11 = plVar35;

-      }

-    }

-LAB_24:

-    uVar26 = (int)local_f0 + 0x388 +

-             (uint)local_138 + (int)plVar11 + (uint)local_128 + local_12c + (uint)local_120 +

-             local_140[0];

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      SepCopyTokenAccessInformation

-                (puVar19,param_3,param_4,plVar10,CONCAT44(uVar42,(int)local_f0),

-                 CONCAT44(uVar44,(undefined4)local_118),CONCAT44(uVar46,local_140[0]),

-                 CONCAT44(uVar47,local_f8._0_4_),(uint)local_120,local_12c,(int)local_100,

-                 (uint)local_128,(int)plVar11,local_158[0],local_148);

-      goto LAB_2;

-    }

-    goto LAB_1;

-  case 0x17:

-  case 0x18:

-  case 0x1a:

-  case 0x1d:

-  case 0x28:

-  case 0x2a:

-  case 0x2f:

-  case 0x30:

-    pplVar45 = &local_148;

-    pcVar43 = local_158;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (param_4 < 4) goto LAB_6;

-    if (param_2 == 0x17) {

-      uVar26 = local_150[0x32] >> 9;

-LAB_27:

-      uVar26 = uVar26 & 1;

-    }

-    else {

-      if (param_2 == 0x18) {

-        uVar26 = local_150[0x32] >> 10;

-        goto LAB_27;

-      }

-      if (param_2 == 0x1a) {

-        uVar26 = local_150[0x32] >> 0xc;

-        goto LAB_27;

-      }

-      if (param_2 == 0x28) {

-        uVar26 = (uint)((local_150[0x32] & 0x18) != 0);

-      }

-      else {

-        if (param_2 == 0x2a) {

-          uVar26 = (uint)*(ushort *)((longlong)local_150 + 0xca);

-          goto LAB_27;

-        }

-        if (param_2 == 0x2f) {

-          bVar5 = SepIsSandboxedToken(local_150,cVar2);

-          uVar26 = (uint)bVar5;

-        }

-        else {

-          if (param_2 != 0x30) {

-            uVar26 = local_150[0x32] >> 0xe;

-            goto LAB_27;

-          }

-          bVar5 = SepSidInTokenSidHash

-                            (local_150 + 0xca,0,SeAppSiloSid,0,1,

-                             (ulonglong)pcVar43 & 0xffffffffffffff00,pplVar45);

-          uVar26 = (uint)bVar5;

-        }

-      }

-    }

-    *(uint *)param_3 = uVar26;

-LAB_8:

-    ObfDereferenceObjectWithTag(puVar19,0x74726853);

-    return 0;

-  case 0x19:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    SepCopyTokenIntegrity(puVar19,local_70);

-    uVar26 = (uint)*(byte *)(local_70[0] + 1) * 4 + 0x18;

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      RtlCopySidAndAttributesArray

-                (1,local_70,(uint)*(byte *)(local_70[0] + 1) * 4 + 8,param_3,param_3 + 2,&local_138,

-                 &local_138);

-      goto LAB_2;

-    }

-    goto LAB_1;

-  case 0x1b:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (3 < param_4) {

-      local_110 = SeQueryMandatoryPolicyToken(local_150,param_3);

-      uVar15 = (ulonglong)local_110;

-      ObfDereferenceObjectWithTag(extraout_XMM0_Da,0x74726853);

-      return uVar15;

-    }

-    goto LAB_6;

-  case 0x1c:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    plVar11 = plVar20;

-    if (puVar19[0x1f] != 0) {

-      do {

-        if ((*(uint *)(*(longlong *)(puVar19 + 0x26) + 8 + (longlong)plVar11 * 0x10) & 0xc0000000)

-            == 0xc0000000) {

-          plVar20 = *(longlong **)(*(longlong *)(puVar19 + 0x26) + (longlong)plVar11 * 0x10);

-          break;

-        }

-        uVar26 = (int)plVar11 + 1;

-        plVar11 = (longlong *)(ulonglong)uVar26;

-      } while (uVar26 < puVar19[0x1f]);

-    }

-    if (plVar20 == (longlong *)0x0) {

-      ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-      KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-      ObfDereferenceObjectWithTag(local_150,0x74726853);

-      return 0xc0000225;

-    }

-    uVar26 = (uint)*(byte *)(*(longlong *)(*(longlong *)(puVar19 + 0x26) + (longlong)plVar11 * 0x10)

-                            + 1) * 4 + 0x20;

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      *(uint *)param_3 = 1;

-      plVar20 = (longlong *)((longlong)plVar11 * 0x10 + *(longlong *)(puVar19 + 0x26));

-      RtlCopySidAndAttributesArray

-                (1,plVar20,(uint)*(byte *)(*plVar20 + 1) * 4 + 8,param_3 + 1,param_3 + 3,&local_138,

-                 &local_138);

-      goto LAB_2;

-    }

-LAB_1:

-    uVar12 = *(undefined8 *)(puVar19 + 0xc);

-    goto LAB_28;

-  case 0x1e:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = puVar19[200];

-    uVar30 = uVar26 * 0x10 + 8;

-    if (uVar26 != 0) {

-      plVar20 = *(longlong **)(puVar19 + 0xc6);

-      uVar15 = (ulonglong)uVar26;

-      do {

-        uVar30 = uVar30 + (uint)*(byte *)(*plVar20 + 1) * 4 + 8;

-        plVar20 = plVar20 + 2;

-        uVar15 = uVar15 - 1;

-      } while (uVar15 != 0);

-    }

-    *param_5 = uVar30;

-    if (uVar30 <= param_4) {

-      *(uint *)param_3 = puVar19[200];

-      RtlCopySidAndAttributesArray

-                (puVar19[200],*(undefined8 *)(puVar19 + 0xc6),uVar30,param_3 + 1,

-                 (ulonglong)(puVar19[200] << 4) + 8 + (longlong)param_3,&local_138,&local_138);

-      goto LAB_4;

-    }

-    break;

-  case 0x1f:

-    uVar26 = 8;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    lVar18 = *(longlong *)(puVar19 + 0xc4);

-    if (lVar18 != 0) {

-      uVar26 = (uint)*(byte *)(lVar18 + 1) * 4 + 0x10;

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      puVar21 = (ulonglong *)0x0;

-      if (lVar18 != 0) {

-        puVar21 = param_3 + 1;

-      }

-      *param_3 = (ulonglong)puVar21;

-      if (puVar21 != (ulonglong *)0x0) {

-        RtlCopySid(uVar26 - 8,puVar21,*(undefined8 *)(puVar19 + 0xc4));

-      }

-      goto LAB_4;

-    }

-    break;

-  case 0x20:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 4;

-    if (3 < param_4) {

-      *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-           *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-      ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-      lVar18 = *(longlong *)(puVar19 + 0x10e);

-      if (lVar18 != 0) {

-        uVar26 = *(uint *)(lVar18 + 0x28);

-      }

-      ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-      KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-      *(uint *)param_3 = uVar26;

-      goto LAB_5;

-    }

-    goto LAB_6;

-  case 0x21:

-  case 0x22:

-    pplVar45 = &local_148;

-    pcVar43 = local_158;

-    ppuVar41 = &local_150;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    lVar18 = *(longlong *)(puVar19 + 0x112);

-    if (((lVar18 == 0) ||

-        ((*(undefined8 **)(lVar18 + 0x240) == (undefined8 *)0x0 && (param_2 == 0x21)))) ||

-       ((*(undefined8 **)(lVar18 + 0x248) == (undefined8 *)0x0 && (param_2 == 0x22)))) {

-      uVar26 = 0x10;

-      local_90 = &pppppppuStack_98;

-      pppppppuStack_98 = &pppppppuStack_98;

-      uStack_88 = uStack_88 & 0xffffffff00000000;

-      pppppppuStack_78 = &local_80;

-      local_80 = &local_80;

-      puVar25 = &local_a0;

-    }

-    else {

-      puVar25 = *(undefined8 **)(lVar18 + 0x248);

-      if (param_2 == 0x21) {

-        puVar25 = *(undefined8 **)(lVar18 + 0x240);

-      }

-      AuthzBasepQueryClaimAttributesToken(puVar25,0,0,local_140,ppuVar41,pcVar43,pplVar45);

-      uVar26 = local_140[0];

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      local_110 = AuthzBasepQueryClaimAttributesToken

-                            (puVar25,param_3,param_4,local_140,ppuVar41,pcVar43,pplVar45);

-      uVar12 = *(undefined8 *)(puVar19 + 0xc);

-LAB_29:

-      ExReleaseResourceLite(uVar12);

-      KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-LAB_30:

-      ObfDereferenceObjectWithTag(local_150,0x74726853);

-      return (ulonglong)local_110;

-    }

-    uVar12 = *(undefined8 *)(puVar19 + 0xc);

-    goto LAB_28;

-  case 0x25:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    puVar23 = *(uint **)(puVar19 + 0x112);

-    if ((puVar23 == (uint *)0x0) || (uVar26 = *puVar23, uVar26 == 0)) {

-      uVar30 = 0x18;

-    }

-    else {

-      uVar30 = uVar26 * 0x10 + 8;

-      uVar7 = uVar26;

-    }

-    if (uVar7 != 0) {

-      plVar20 = *(longlong **)(puVar23 + 2);

-      uVar15 = (ulonglong)uVar7;

-      do {

-        uVar30 = uVar30 + (uint)*(byte *)(*plVar20 + 1) * 4 + 8;

-        plVar20 = plVar20 + 2;

-        uVar15 = uVar15 - 1;

-      } while (uVar15 != 0);

-    }

-    *param_5 = uVar30;

-    if (uVar30 <= param_4) {

-      *param_3 = 0;

-      param_3[1] = 0;

-      param_3[2] = 0;

-      *(uint *)param_3 = uVar7;

-      if (uVar7 != 0) {

-        RtlCopySidAndAttributesArray

-                  (uVar7,*(undefined8 *)(*(longlong *)(puVar19 + 0x112) + 8),uVar30,param_3 + 1,

-                   (ulonglong)(uVar7 * 0x10 - 0x10) + 0x18 + (longlong)param_3,&local_138,&local_138

-                  );

-      }

-      goto LAB_4;

-    }

-    break;

-  case 0x27:

-    pplVar45 = &local_148;

-    ppuVar41 = &local_150;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar42 = (undefined4)((ulonglong)ppuVar41 >> 0x20);

-    if (*(longlong *)(puVar19 + 0xc2) == 0) {

-      uVar26 = 0x10;

-    }

-    else {

-      uVar15 = (ulonglong)ppuVar41 & 0xffffffff00000000;

-      AuthzBasepQuerySecurityAttributesToken

-                (*(longlong *)(puVar19 + 0xc2),0,0,0,uVar15,local_140,pplVar45);

-      uVar42 = (undefined4)(uVar15 >> 0x20);

-      uVar26 = local_140[0];

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      local_110 = AuthzBasepQuerySecurityAttributesToken

-                            (*(undefined8 *)(puVar19 + 0xc2),0,0,param_3,CONCAT44(uVar42,param_4),

-                             local_140,pplVar45);

-      uVar12 = *(undefined8 *)(puVar19 + 0xc);

-      goto LAB_29;

-    }

-    break;

-  case 0x29:

-    uVar26 = 8;

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    plVar20 = local_148;

-    if (local_158[0] == '\0') {

-      plVar20 = *(longlong **)(puVar19 + 0x114);

-    }

-    if (plVar20 != (longlong *)0x0) {

-      uVar26 = (uint)*(byte *)((longlong)plVar20 + 1) * 4 + 0x10;

-    }

-    *param_5 = uVar26;

-    if (uVar26 <= param_4) {

-      puVar21 = (ulonglong *)0x0;

-      if (plVar20 != (longlong *)0x0) {

-        puVar21 = param_3 + 1;

-      }

-      *param_3 = (ulonglong)puVar21;

-      if (puVar21 != (ulonglong *)0x0) {

-        plVar20 = local_148;

-        if (local_158[0] == '\0') {

-          plVar20 = *(longlong **)(puVar19 + 0x114);

-        }

-        RtlCopySid(uVar26 - 8,puVar21,plVar20);

-      }

-      goto LAB_31;

-    }

-    break;

-  case 0x2b:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    local_110 = SepInternalQuerySecurityAttributesTokenEx(puVar19);

-    ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-    KeLeaveCriticalRegionThread(SystemReserved1[0xf]);

-    goto LAB_30;

-  case 0x2c:

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    puVar19 = local_150;

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

-         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

-    ExAcquireResourceSharedLite(*(undefined8 *)(local_150 + 0xc),1);

-    uVar26 = 0x10;

-    if (*(longlong *)(puVar19 + 0x120) != 0) {

-      uVar26 = *(ushort *)(*(longlong *)(puVar19 + 0x120) + 0x2a) + 0x10;

-    }

-    *param_5 = uVar26;

-    if (param_4 < uVar26) {

-      ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-      KeLeaveCriticalRegionThread(SystemReserved1[0xf]);

-      goto LAB_6;

-    }

-    if (*(longlong *)(puVar19 + 0x120) == 0) {

-      *(undefined1 *)(param_3 + 1) = 0;

-      *param_3 = 0;

-    }

-    else {

-      *(undefined1 *)(param_3 + 1) = 1;

-      *param_3 = (ulonglong)(param_3 + 2);

-      RtlCopyMemory(param_3 + 2,*(void **)(*(longlong *)(puVar19 + 0x120) + 0x30),

-                    (ulonglong)*(ushort *)(*(longlong *)(puVar19 + 0x120) + 0x2a));

-    }

-LAB_31:

-    ExReleaseResourceLite(*(undefined8 *)(puVar19 + 0xc));

-    KeLeaveCriticalRegionThread(SystemReserved1[0xf]);

-LAB_5:

-    ObfDereferenceObjectWithTag(local_150,0x74726853);

-    return 0;

-  case -2:

-    iVar16 = Feature_2045735225__private_IsEnabledDeviceUsageNoInline();

-    if (iVar16 == 0) {

-      return 0xc0000003;

-    }

-    local_108 = 0;

-    local_128 = (longlong *)0x0;

-    local_120 = (longlong *)0x0;

-    local_d0[0] = local_d0[0] & 0xffffffff;

-    uStack_b8 = uStack_b8 & 0xffffffff;

-    cVar4 = SeSinglePrivilegeCheck(SeTcbPrivilege,cVar2);

-    if (cVar4 == '\0') {

-      return 0xc0000003;

-    }

-    pplVar45 = &local_148;

-    pcVar43 = local_158;

-    uVar42 = (undefined4)((ulonglong)&local_150 >> 0x20);

-    uVar15 = SepReferenceTokenByHandle(param_1,8,cVar2);

-    if ((int)uVar15 < 0) {

-      return uVar15;

-    }

-    *param_5 = 8;

-    if (param_4 != 8) {

-LAB_13:

-      ObfDereferenceObjectWithTag(local_150,0x74726853);

-      return 0xc0000004;

-    }

-    iVar16 = Feature_ShadowAdmin__private_IsEnabledDeviceUsageNoInline();

-    puVar19 = local_150;

-    if (iVar16 != 0) {

-      local_118 = local_118 & 0xffffffff00000000;

-      RtlQueryElevationFlags(&local_118);

-      puVar19 = local_150;

-      if ((((byte)local_118 & 0x18) == 0x10) &&

-         (iVar16 = SepGetTokenElevationType(local_150), iVar16 == 2)) {

-        lVar18 = *(longlong *)(puVar19 + 0x36);

-        if (*(int *)(lVar18 + 0x1c) != 0 || *(int *)(lVar18 + 0x18) != 0) {

-          uVar26 = SepReferenceLogonSessionSilo

-                             ((int *)(lVar18 + 0x18),*(undefined8 *)(lVar18 + 0xa8),&local_108);

-          uVar15 = (ulonglong)uVar26;

-          if (-1 < (int)uVar26) {

-            local_d0[0] = CONCAT44(local_d0[0]._4_4_,0x30);

-            local_d0[1] = 0;

-            if (cVar2 == '\0') {

-              uVar7 = 0x200;

-            }

-            uStack_b8 = CONCAT44(uStack_b8._4_4_,uVar7);

-            local_d0[2] = 0;

-            local_b0 = 0;

-            uStack_a8 = 0;

-            SeQuerySessionIdToken(puVar19,&local_12c);

-            uVar31 = local_108;

-            uVar26 = SeSetSessionIdToken(*(undefined8 *)(local_108 + 0x38),local_12c);

-            uVar15 = (ulonglong)uVar26;

-            if ((int)uVar26 < 0) {

-              SepDeReferenceLogonSessionDirect(uVar31);

-            }

-            else {

-              uVar40 = CONCAT44(uVar42,1);

-              uVar26 = SepDuplicateToken(*(undefined8 *)(uVar31 + 0x38),local_d0,0,1,uVar40,

-                                         (ulonglong)pcVar43 & 0xffffffffffffff00,

-                                         (ulonglong)pplVar45 & 0xffffffffffffff00,&local_120);

-              uVar15 = (ulonglong)uVar26;

-              SepDeReferenceLogonSessionDirect(uVar31);

-              if (-1 < (int)uVar26) {

-                lVar18 = local_120[0x1b];

-                uVar12 = PsGetCurrentServerSilo();

-                uVar26 = SepReferenceLogonSessionSilo(lVar18 + 0x10,uVar12,&local_e0);

-                if (-1 < (int)uVar26) {

-                  *(uint *)(local_120 + 0x19) = *(uint *)(local_120 + 0x19) | 0x10000000;

-                  uVar26 = ObInsertObjectEx(local_120,0,0xf01ff,0,uVar40 & 0xffffffff00000000,0,

-                                            &local_128);

-                  if (-1 < (int)uVar26) {

-                    *param_3 = (ulonglong)local_128;

-                    ObfDereferenceObjectWithTag(puVar19,0x74726853);

-                    return 0;

-                  }

-                }

-                ObfDereferenceObject(local_120);

-                ObfDereferenceObjectWithTag(puVar19,0x74726853);

-                return (ulonglong)uVar26;

-              }

-            }

-          }

-          ObfDereferenceObjectWithTag(puVar19,0x74726853);

-          return uVar15;

-        }

-      }

-    }

-    goto LAB_7;

-  default:

-    goto switchD_140ad092b_caseD_ffffffff;

-  }

-  uVar12 = *(undefined8 *)(puVar19 + 0xc);

-LAB_28:

-  ExReleaseResourceLite(uVar12);

-  KiLeaveCriticalRegionUnsafe(SystemReserved1[0xf]);

-LAB_6:

-  ObfDereferenceObjectWithTag(local_150,0x74726853);

-  return 0xc0000023;

+    lVar2 = *(longlong *)(lVar2 + 0x518);

+  } while( true );

 }
```

## `PopIdleAoAcDozeToS4`  (modified)

```diff
--- PopIdleAoAcDozeToS4
+++ PopIdleAoAcDozeToS4
@@ -1,69 +1,50 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

 void PopIdleAoAcDozeToS4(void)

 

 {

-  char cVar1;

-  char *pcVar2;

-  ulonglong unaff_RBX;

-  longlong *unaff_RBP;

-  longlong unaff_RSI;

-  byte unaff_DIL;

-  undefined4 in_stack_00000048;

-  undefined4 uStack000000000000004c;

-  undefined4 in_stack_00000050;

-  undefined4 uStack0000000000000054;

-  undefined4 in_stack_00000058;

-  undefined4 uStack000000000000005c;

-  undefined4 in_stack_00000060;

-  undefined4 uStack0000000000000064;

-  undefined4 in_stack_00000068;

-  undefined8 in_stack_00000070;

+  undefined4 local_38;

+  undefined4 local_34;

+  undefined4 local_30;

+  undefined4 local_28;

+  undefined4 local_24;

+  undefined8 local_20;

+  undefined8 uStack_18;

+  undefined8 local_10;

   

-  PopPowerAdapterQueryStatus(unaff_RBX & 0xffffffff);

-  PopReleaseRwLock(&PopCB);

-  if (5 < DAT_0) {

-    cVar1 = _tlgKeywordOn(&DAT_0,0x400000000000);

-    if (cVar1 != '\0') {

-      uStack000000000000004c = *(undefined4 *)(unaff_RBX + 0x88);

-      pcVar2 = "REC Supported";

-      unaff_RBP[-0xb] = unaff_RSI;

-      unaff_RBP[-0xc] = (longlong)&stack0x0000004c;

-      if ((unaff_DIL & (byte)*(undefined4 *)(unaff_RBX + 0x8c)) == 0) {

-        pcVar2 = "-";

+  PopAcquirePolicyLock();

+  PopTraceSystemIdleS0LowPowerDoze();

+  local_10 = 0;

+  local_20 = 0;

+  uStack_18 = 0;

+  if (DAT_0 != 1) {

+    if (DAT_0 == 2) {

+      local_28 = 0xb;

+      if ((DAT_1 != 0) &&

+         ((ulonglong)PopSmartUserPresenceCheckTimeout * 10000000 <

+          (ulonglong)(_DAT_2 - DAT_140f0b0a8))) {

+        local_28 = 0xc;

       }

-      _tlgCreate1Sz_char(unaff_RBP + -10,pcVar2);

-      in_stack_00000068 = *(undefined4 *)(unaff_RBX + 0x90);

-      unaff_RBP[-8] = (longlong)&stack0x00000068;

-      uStack0000000000000064 = *(undefined4 *)(unaff_RBX + 0x94);

-      unaff_RBP[-6] = (longlong)&stack0x00000064;

-      in_stack_00000060 = *(undefined4 *)(unaff_RBX + 0x98);

-      unaff_RBP[-4] = (longlong)&stack0x00000060;

-      uStack000000000000005c = *(undefined4 *)(unaff_RBX + 0x9c);

-      unaff_RBP[-2] = (longlong)&stack0x0000005c;

-      in_stack_00000058 = *(undefined4 *)(unaff_RBX + 0xa0);

-      *unaff_RBP = (longlong)&stack0x00000058;

-      uStack0000000000000054 = *(undefined4 *)(unaff_RBX + 0xa4);

-      unaff_RBP[2] = (longlong)&stack0x00000054;

-      in_stack_00000050 = *(undefined4 *)(unaff_RBX + 0xa8);

-      unaff_RBP[4] = (longlong)&stack0x00000050;

-      in_stack_00000048 = *(undefined4 *)(unaff_RBX + 0xac);

-      unaff_RBP[6] = (longlong)&stack0x00000048;

-      unaff_RBP[-7] = unaff_RSI;

-      unaff_RBP[8] = (longlong)&stack0x00000070;

-      unaff_RBP[-1] = unaff_RSI;

-      unaff_RBP[-3] = unaff_RSI;

-      unaff_RBP[-5] = unaff_RSI;

-      unaff_RBP[1] = unaff_RSI;

-      unaff_RBP[3] = unaff_RSI;

-      unaff_RBP[5] = unaff_RSI;

-      unaff_RBP[7] = unaff_RSI;

-      in_stack_00000070 = 0x1000000;

-      unaff_RBP[9] = 8;

-      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004cfda,0,0,0xd);

+      goto LAB_3;

+    }

+    if (DAT_0 == 6) {

+      local_28 = 0xb;

+      goto LAB_3;

     }

   }

+  local_28 = 6;

+LAB_3:

+  local_30 = 0;

+  local_24 = 0x80;

+  local_38 = 3;

+  local_34 = 0x80000024;

+  PopExecutePowerAction(&local_28,0,&local_38,5,1);

+  PopReleasePolicyLock();

+  LOCK();

+  DAT_4 = 0;

+  UNLOCK();

+  PopDeepSleepClearDisengageReason(4);

   return;

 }
```

## `PopAdaptiveStandbyWnfCallback`  (modified)

```diff
--- PopAdaptiveStandbyWnfCallback
+++ PopAdaptiveStandbySessionStart
@@ -1,23 +1,48 @@
 

-void PopAdaptiveStandbyWnfCallback(longlong param_1)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+undefined1 PopAdaptiveStandbySessionStart(undefined8 param_1)

 

 {

-  byte *pbVar1;

-  byte bVar2;

-  code *pcVar3;

-  byte in_AL;

-  undefined7 in_register_00000001;

+  undefined8 uVar1;

+  undefined1 unaff_BL;

+  longlong unaff_RBP;

+  longlong unaff_RDI;

+  longlong unaff_R15;

+  byte bStack0000000000000031;

+  undefined4 uStack0000000000000040;

+  undefined4 uStack0000000000000044;

+  undefined4 uStack0000000000000048;

+  undefined4 uStack000000000000004c;

+  undefined4 uStack0000000000000050;

+  undefined4 uStack0000000000000054;

   

-  *(byte *)(CONCAT71(in_register_00000001,in_AL) & 0xffffffffffffffb0) =

-       *(char *)(CONCAT71(in_register_00000001,in_AL) & 0xffffffffffffffb0) + (in_AL & 0xb0);

-  pbVar1 = (byte *)(param_1 + -0x75);

-  bVar2 = *pbVar1;

-  *pbVar1 = *pbVar1 + (byte)param_1;

-  if (CARRY1(bVar2,(byte)param_1)) {

-    return;

-  }

-  pcVar3 = (code *)swi(3);

-  (*pcVar3)();

-  return;

+  uStack0000000000000040 = *(undefined4 *)(unaff_RDI + 0x94);

+  *(undefined4 **)(unaff_RBP + 0xc0) = &stack0x00000040;

+  uStack0000000000000044 = *(undefined4 *)(unaff_R15 + 0x98);

+  *(undefined4 **)(unaff_RBP + 0xd0) = &stack0x00000044;

+  bStack0000000000000031 = *(byte *)(unaff_R15 + 0x9c) & (byte)param_1;

+  *(undefined8 *)(unaff_RBP + 200) = 4;

+  *(byte **)(unaff_RBP + 0xe0) = &stack0x00000031;

+  uStack0000000000000048 = *(undefined4 *)(unaff_R15 + 0xa0);

+  *(undefined4 **)(unaff_RBP + 0xf0) = &stack0x00000048;

+  uStack000000000000004c = *(undefined4 *)(unaff_R15 + 0xa4);

+  *(undefined4 **)(unaff_RBP + 0x100) = &stack0x0000004c;

+  uStack0000000000000050 = *(undefined4 *)(unaff_R15 + 0xa8);

+  *(undefined4 **)(unaff_RBP + 0x110) = &stack0x00000050;

+  uStack0000000000000054 = *(undefined4 *)(unaff_R15 + 0xac);

+  *(undefined4 **)(unaff_RBP + 0x120) = &stack0x00000054;

+  *(longlong *)(unaff_RBP + 0x130) = unaff_RBP + -0x70;

+  *(undefined8 *)(unaff_RBP + 0xd8) = 4;

+  *(undefined8 *)(unaff_RBP + 0xe8) = param_1;

+  *(undefined8 *)(unaff_RBP + 0xf8) = 4;

+  *(undefined8 *)(unaff_RBP + 0x108) = 4;

+  *(undefined8 *)(unaff_RBP + 0x118) = 4;

+  *(undefined8 *)(unaff_RBP + 0x128) = 4;

+  *(undefined8 *)(unaff_RBP + -0x70) = 0x1000000;

+  *(undefined8 *)(unaff_RBP + 0x138) = 8;

+  uVar1 = IoGetActivityIdThread();

+  _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e526,uVar1,0,0x1a);

+  return unaff_BL;

 }
```

## `SepVerifyDesktopAppPolicyOverrideCaller`  (modified)

```diff
--- SepVerifyDesktopAppPolicyOverrideCaller
+++ SepVerifyDesktopAppPolicyOverrideCaller
@@ -1,20 +1,82 @@
 

-undefined8 SepVerifyDesktopAppPolicyOverrideCaller(void)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+undefined1 SepVerifyDesktopAppPolicyOverrideCaller(undefined8 param_1)

 

 {

-  ulonglong in_RAX;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  uint uStack0000000000000050;

+  char cVar1;

+  undefined1 uVar2;

+  int iVar3;

+  longlong lVar4;

+  undefined1 auStack_2a8 [32];

+  undefined1 *local_288;

+  undefined8 local_280;

+  ulonglong *local_278;

+  undefined8 local_270;

+  undefined1 local_268 [4];

+  int local_264;

+  ulonglong local_260;

+  undefined8 local_258;

+  undefined8 local_250;

+  undefined8 local_248;

+  undefined1 *puStack_240;

+  undefined8 local_238;

+  undefined1 *puStack_230;

+  undefined1 local_228 [16];

+  undefined1 local_218 [256];

+  undefined1 local_118 [256];

+  ulonglong local_18;

   

-  LOCK();

-  *(ulonglong *)(unaff_RSI + 0x18) = *(ulonglong *)(unaff_RSI + 0x18) & in_RAX;

-  UNLOCK();

-  uStack0000000000000050 = *(uint *)(unaff_RBP + 0x20) & 0xfffdffff | 0x50000;

-  *(uint *)(unaff_RBP + 0x20) = uStack0000000000000050;

-  MiSetPfnIdentity();

-  MiClearPfnReuseFields();

-  *(ulonglong *)(unaff_RBP + 0x18) = *(ulonglong *)(unaff_RBP + 0x18) & 0xc000000000000000;

-  return 1;

+  local_18 = __security_cookie ^ (ulonglong)auStack_2a8;

+  local_260 = 0;

+  local_264 = 0;

+  local_250 = 0x100;

+  local_258 = 0x100;

+  uVar2 = 0;

+  local_248 = 0;

+  puStack_240 = (undefined1 *)0x0;

+  local_238 = 0;

+  puStack_230 = (undefined1 *)0x0;

+  cVar1 = SeSinglePrivilegeCheck

+                    (SeTcbPrivilege,*(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232));

+  if (cVar1 == '\0') {

+    local_270 = 0;

+    local_278 = (ulonglong *)0x0;

+    local_280 = 0;

+    local_288 = (undefined1 *)0x0;

+    iVar3 = RtlQueryPackageClaims(param_1,local_218,&local_258,0);

+    if (-1 < iVar3) {

+      local_288 = local_228;

+      local_280 = 0;

+      lVar4 = PsReferenceEffectiveToken(SystemReserved1[0xf],0x74726853,&local_264,local_268);

+      local_270 = 0;

+      local_278 = &local_260;

+      local_280 = 0;

+      local_288 = (undefined1 *)0x0;

+      iVar3 = RtlQueryPackageClaims(lVar4,local_118,&local_250,0);

+      if ((-1 < iVar3) && ((local_260 & 4) != 0)) {

+        local_238._0_4_ = CONCAT22((short)local_258 + -2,(short)local_258 + -2);

+        puStack_230 = local_218;

+        local_248._0_4_ = CONCAT22((short)local_250 + -2,(short)local_250 + -2);

+        puStack_240 = local_118;

+        RtlCompareUnicodeString(&local_238,&local_248,0);

+        uVar2 = FUN_1404230a9();

+        return uVar2;

+      }

+      if (lVar4 != 0) {

+        if (local_264 == 1) {

+          ObFastDereferenceObject

+                    (*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x248,lVar4,0x74726853);

+        }

+        else {

+          ObfDereferenceObjectWithTag(lVar4,0x74726853);

+        }

+      }

+    }

+  }

+  else {

+    uVar2 = 1;

+  }

+  return uVar2;

 }
```

## `PiCMCaptureDeviceListInputData`  (modified)

```diff
--- PiCMCaptureDeviceListInputData
+++ PiCMCaptureDeviceListInputData
@@ -1,59 +1,126 @@
 

-int PiCMCaptureDeviceListInputData(wchar_t *param_1,int param_2,wchar_t *param_3,int param_4)

+int PiCMCaptureDeviceListInputData(int *param_1,uint param_2,int param_3,int *param_4)

 

 {

-  wchar_t wVar1;

-  wchar_t *pwVar2;

-  longlong lVar3;

-  int iVar5;

-  wchar_t *_Str1;

+  longlong *plVar1;

+  uint *puVar2;

+  undefined1 uVar3;

+  uint uVar4;

+  longlong lVar5;

   int iVar6;

-  uint uVar7;

-  longlong lVar4;

+  int iVar7;

+  bool bVar8;

+  int iVar9;

+  int iVar10;

   

-  iVar6 = 0;

-  wVar1 = *param_3;

-  do {

-    _Str1 = param_1;

-    if (wVar1 == L'\0') {

-      return iVar6;

+  bVar8 = false;

+  uVar3 = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+  if ((param_1 == (int *)0x0) || (param_2 == 0)) {

+    iVar10 = -0x3ffffff3;

+LAB_0:

+    if (-1 < iVar10) {

+      return iVar10;

     }

-    for (; *_Str1 != L'\0'; _Str1 = _Str1 + lVar4 + 2) {

-      if (param_4 == 0) {

-        pwVar2 = _Str1;

-        do {

-          uVar7 = (uint)*(ushort *)((longlong)pwVar2 + ((longlong)param_3 - (longlong)_Str1));

-          iVar5 = (ushort)*pwVar2 - uVar7;

-          if (iVar5 != 0) break;

-          pwVar2 = pwVar2 + 1;

-        } while (uVar7 != 0);

+  }

+  else {

+    if (param_3 == 0) {

+      if (((ulonglong)param_1 & 7) != 0) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

+      }

+      iVar10 = 0;

+      if (param_2 < 0x18) {

+        iVar10 = -0x3ffffff3;

       }

       else {

-        iVar5 = _wcsicmp(_Str1,param_3);

+        iVar9 = param_1[1];

+        iVar6 = param_1[2];

+        iVar7 = param_1[3];

+        *param_4 = *param_1;

+        param_4[1] = iVar9;

+        param_4[2] = iVar6;

+        param_4[3] = iVar7;

+        *(undefined8 *)(param_4 + 4) = *(undefined8 *)(param_1 + 4);

+        if (*param_4 != 0x18) {

+          iVar10 = -0x3ffffff3;

+        }

       }

-      if (iVar5 == 0) {

-        iVar6 = 1;

-        break;

+    }

+    else {

+      if (((ulonglong)param_1 & 3) != 0) {

+                    /* WARNING: Subroutine does not return */

+        ExRaiseDatatypeMisalignment();

       }

-      lVar3 = -1;

-      do {

-        lVar4 = lVar3;

-        lVar3 = lVar4 + 1;

-      } while (_Str1[lVar3] != L'\0');

+      iVar10 = 0;

+      if ((param_2 < 0x14) || (*param_1 != 0x14)) {

+        iVar10 = -0x3ffffff3;

+      }

+      else {

+        *param_4 = 0x18;

+        param_4[1] = param_1[1];

+        *(ulonglong *)(param_4 + 2) = (ulonglong)(uint)param_1[2];

+        param_4[4] = param_1[3];

+        param_4[5] = param_1[4];

+      }

     }

-    if (param_2 == 0x12) {

-      return iVar6;

+    if (iVar10 < 0) goto LAB_1;

+    plVar1 = (longlong *)(param_4 + 2);

+    lVar5 = *plVar1;

+    *plVar1 = 0;

+    iVar9 = Feature_KernelPnP_DeviceListFilterUpdates__private_IsEnabledDeviceUsageNoInline();

+    if (iVar9 == 0) {

+      if (lVar5 != 0) {

+        puVar2 = (uint *)(param_4 + 4);

+        if (1 < *puVar2) {

+          iVar10 = PiControlMakeUserModeCallersCopy(plVar1,lVar5,*puVar2,2,uVar3,1);

+          if (iVar10 < 0) {

+            *plVar1 = 0;

+            *puVar2 = 0;

+          }

+          else {

+            bVar8 = true;

+            *(undefined2 *)(*plVar1 + -2 + (ulonglong)(*puVar2 >> 1) * 2) = 0;

+          }

+          goto LAB_0;

+        }

+      }

+      if (lVar5 == 0) {

+        uVar4 = param_4[4];

+        goto joined_r0x000140a18e4d;

+      }

+      if (1 < (uint)param_4[4]) goto LAB_0;

     }

-    if ((param_2 == 0x2012) && (iVar6 != 0)) {

-      return iVar6;

+    else {

+      uVar4 = param_4[4];

+      if (lVar5 == 0) {

+joined_r0x000140a18e4d:

+        if (uVar4 == 0) goto LAB_0;

+      }

+      else if (uVar4 - 2 < 0x1ff) {

+        iVar10 = PiControlMakeUserModeCallersCopy(plVar1,lVar5,uVar4,2,uVar3,1);

+        if (iVar10 < 0) {

+          *plVar1 = 0;

+          param_4[4] = 0;

+        }

+        else {

+          bVar8 = true;

+          *(undefined2 *)(*plVar1 + -2 + (ulonglong)((uint)param_4[4] >> 1) * 2) = 0;

+        }

+        goto LAB_0;

+      }

     }

-    lVar3 = -1;

-    do {

-      lVar4 = lVar3;

-      lVar3 = lVar4 + 1;

-    } while (param_3[lVar3] != L'\0');

-    param_3 = param_3 + lVar4 + 2;

-    wVar1 = *param_3;

-  } while( true );

+    iVar10 = -0x3ffffff3;

+  }

+LAB_1:

+  if (bVar8) {

+    PiControlFreeUserModeCallersBuffer(uVar3,*(undefined8 *)(param_4 + 2));

+  }

+  param_4[0] = 0;

+  param_4[1] = 0;

+  param_4[2] = 0;

+  param_4[3] = 0;

+  param_4[4] = 0;

+  param_4[5] = 0;

+  return iVar10;

 }
```

## `KeIntSteerSnapPerf`  (modified)

```diff
--- KeIntSteerSnapPerf
+++ KeIntSteerSnapPerf
@@ -1,302 +1,249 @@
 

+/* WARNING: Function: __chkstk replaced with injection: alloca_probe */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-undefined8 KeIntSteerSnapPerf(void)

+undefined8

+KeIntSteerSnapPerf(undefined8 param_1,longlong *param_2,undefined4 *param_3,longlong *param_4)

 

 {

-  char cVar1;

+  int *piVar1;

   longlong lVar2;

-  undefined1 auVar3 [16];

-  undefined1 auVar4 [16];

-  undefined1 auVar5 [16];

-  undefined1 auVar6 [16];

-  undefined1 auVar7 [16];

-  undefined1 auVar8 [16];

-  undefined1 auVar9 [16];

-  undefined1 auVar10 [16];

-  undefined1 auVar11 [16];

-  undefined1 auVar12 [16];

-  undefined1 auVar13 [16];

-  undefined1 auVar14 [16];

-  uint uVar15;

-  ulonglong uVar16;

-  longlong *plVar17;

-  longlong lVar18;

-  uint uVar19;

-  ushort *puVar20;

-  int iVar21;

-  ulonglong uVar22;

-  ulonglong uVar23;

-  ulonglong uVar24;

-  longlong unaff_RBX;

-  byte unaff_BPL;

-  longlong unaff_RSI;

-  char cVar25;

-  ulonglong unaff_RDI;

-  undefined7 uVar26;

-  ulonglong uVar27;

-  uint *puVar28;

-  ulonglong *puVar29;

-  undefined8 unaff_R12;

-  ulonglong unaff_R13;

-  longlong unaff_R14;

-  ulonglong uVar30;

-  uint unaff_R15D;

-  bool in_SF;

-  undefined8 in_stack_00000030;

-  uint uStack00000000000000ac;

-  undefined8 *in_stack_000000b0;

+  code *pcVar3;

+  undefined4 uVar4;

+  undefined4 *puVar5;

+  longlong *plVar6;

+  int iVar7;

+  ulonglong uVar8;

+  longlong lVar9;

+  longlong lVar10;

+  longlong *plVar11;

+  undefined1 *puVar13;

+  uint uVar14;

+  longlong *plVar16;

+  ulonglong _Size;

+  longlong lVar17;

+  longlong *plVar18;

+  undefined8 *puVar19;

+  longlong *plVar20;

+  ulonglong in_CR8;

+  undefined8 uVar21;

+  undefined8 uStack_b0;

+  undefined1 auStack_a8 [32];

+  longlong *local_88 [2];

+  longlong local_78;

+  longlong *local_70;

+  longlong *local_68;

+  longlong *local_60;

+  ulonglong local_58;

+  undefined4 *local_50;

+  longlong local_48;

+  longlong *local_40;

+  undefined1 local_38 [8];

+  ulonglong local_30;

+  longlong *plVar12;

+  longlong *plVar15;

   

-  uStack00000000000000ac = (uint)unaff_R13;

-  if (in_SF) {

-    uVar19 = *(uint *)(*(longlong *)(unaff_RSI + 0x220) + 400);

-    uVar15 = uVar19 >> 0xd & 0x3ffff;

-    iVar21 = 0x1f;

-    if (uVar15 != 0) {

-      for (; uVar15 >> iVar21 == 0; iVar21 = iVar21 + -1) {

+  uVar4 = PpmIntSteerLoadMax;

+  local_30 = __security_cookie ^ (ulonglong)local_88;

+  plVar18 = (longlong *)0x0;

+  local_88[1] = (longlong *)0x0;

+  local_88[0] = (longlong *)0x0;

+  puVar13 = auStack_a8;

+  plVar15 = plVar18;

+  local_60 = param_2;

+  local_50 = param_3;

+  local_40 = param_4;

+  if (KiIntSteerEnabled != '\0') {

+    local_88[1] = plVar18;

+    if (KiActiveGroups != 0) {

+      local_88[1] = (longlong *)POPCOUNT(DAT_0);

+    }

+    _Size = (longlong)local_88[1] * 8;

+    uVar8 = _Size + 0xf;

+    if (uVar8 <= _Size) {

+      uVar8 = 0xffffffffffffff0;

+    }

+    uStack_b0 = 0x1403655c4;

+    lVar9 = -(uVar8 & 0xfffffffffffffff0);

+    plVar15 = (longlong *)((longlong)local_88 + lVar9);

+    puVar13 = auStack_a8 + lVar9;

+    local_88[0] = plVar15;

+    if ((int)local_88[1] != 0) {

+      *(undefined8 *)(auStack_a8 + lVar9 + -8) = 0x1403655e2;

+      memset(plVar15,0,_Size);

+      puVar13 = auStack_a8 + lVar9;

+    }

+  }

+  *(undefined8 *)(puVar13 + -8) = 0x1403655eb;

+  lVar9 = RtlGetInterruptTimePrecise(local_38);

+  puVar5 = KiIntSteerDistributionContext;

+  plVar20 = (longlong *)(lVar9 - _KiIntSteerPreviousPerfSnap);

+  local_48 = lVar9;

+  if (plVar20 < (longlong *)0x16e360) {

+    *param_2 = 0;

+  }

+  else {

+    local_68 = plVar20;

+    *(undefined8 *)(puVar13 + -8) = 0x140365634;

+    _KiIntSteerPreviousPerfSnap = lVar9;

+    KiIntSteerPreviousPerfSnapDelta = plVar20;

+    memset(KiIntSteerDistributionContext,0,0x204);

+    *puVar5 = uVar4;

+    *param_2 = (longlong)puVar5;

+    local_70 = (longlong *)0x0;

+    local_58 = in_CR8;

+    uVar21 = 2;

+    if (KiIrqlFlags != 0) {

+      *(undefined8 *)(puVar13 + -8) = 0x140365666;

+      KiRaiseIrqlProcessIrqlFlags(in_CR8 & 0xff);

+    }

+    if (((DAT_1._2_1_ & 0x21) == 0) || (PopHibernateInProgress != 0)) {

+      LOCK();

+      uVar8 = _KiIntTrackSpinlock & 1;

+      _KiIntTrackSpinlock = _KiIntTrackSpinlock | 1;

+      UNLOCK();

+      if (uVar8 != 0) {

+        *(undefined8 *)(puVar13 + -8) = 0x14036569f;

+        KxWaitForSpinLockAndAcquire(&KiIntTrackSpinlock);

       }

     }

-    uVar16 = (ulonglong)(uVar19 >> 4 & 0x1ff);

-    lVar18 = *(longlong *)

-              (*(longlong *)(*(longlong *)(unaff_RBX + 0x8bb0) + (ulonglong)(iVar21 - 2) * 8) + 8 +

-              (ulonglong)(uStack00000000000000ac << ((byte)iVar21 & 0x1f) ^ uVar15) * 8);

-    *(longlong *)(lVar18 + uVar16 * 8) = *(longlong *)(lVar18 + uVar16 * 8) + unaff_R14;

-    unaff_BPL = unaff_BPL & 0x7f;

+    else {

+      *(undefined8 *)(puVar13 + -8) = 0x140365685;

+      KiAcquireSpinLockInstrumented(&KiIntTrackSpinlock);

+    }

+    plVar11 = plVar18;

+    plVar16 = plVar15;

+    plVar12 = param_2;

+    puVar19 = KiIntTrackRootList;

+    plVar6 = plVar20;

+    if ((undefined8 **)KiIntTrackRootList != &KiIntTrackRootList) {

+      do {

+        plVar16 = (longlong *)puVar19[2];

+        local_78 = 0;

+        plVar12 = plVar11;

+        if (plVar16 != puVar19 + 2) {

+          do {

+            if ((*(longlong **)(*plVar16 + 8) != plVar16) || (*(longlong **)plVar16[1] != plVar16))

+            {

+              pcVar3 = (code *)swi(0x29);

+              (*pcVar3)(3);

+              puVar13 = puVar13 + 8;

+              goto LAB_2;

+            }

+            plVar15 = plVar18;

+            param_2 = plVar18;

+            plVar20 = plVar18;

+            if ((int)plVar16[3] != 0) {

+              do {

+                plVar11 = *(longlong **)(plVar16[4] + (longlong)plVar15 * 8);

+                plVar20 = (longlong *)((longlong)plVar20 + plVar11[0x16]);

+                param_2 = (longlong *)((longlong)param_2 + plVar11[0x19]);

+                *(undefined8 *)(puVar13 + -8) = 0x14036572d;

+                iVar7 = Feature_Servicing_KeIntSteerProcessorIndex__private_IsEnabledDeviceUsageNoInline

+                                  ();

+                if (iVar7 == 0) {

+                  if (((((KiActiveGroups < 2) || (uVar14 = *(uint *)(plVar11 + 0xc), uVar14 == 0))

+                       || ((uVar14 < KeMaximumProcessors &&

+                           ((uVar14 = *(uint *)(KiGlobalState + (ulonglong)uVar14 * 4), uVar14 != 0

+                            && ((short)(uVar14 >> 6) == 0)))))) && (KiIntSteerEnabled != '\0')) &&

+                     (*(char *)((longlong)puVar19 + 0x84) == '\0')) {

+                    local_88[0][*(uint *)(plVar11 + 0xc)] =

+                         local_88[0][*(uint *)(plVar11 + 0xc)] + plVar11[0x16] + plVar11[0x19];

+                  }

+                }

+                else {

+                  uVar14 = *(uint *)(plVar11 + 0xc);

+                  if (uVar14 == 0) {

+                    uVar14 = 0;

+                  }

+                  else {

+                    if (((KeMaximumProcessors <= uVar14) ||

+                        (uVar14 = *(uint *)(KiGlobalState + (ulonglong)uVar14 * 4), uVar14 == 0)) ||

+                       ((short)(uVar14 >> 6) != 0)) goto LAB_3;

+                    uVar14 = uVar14 & 0x3f;

+                  }

+                  if ((KiIntSteerEnabled != '\0') && (*(char *)((longlong)puVar19 + 0x84) == '\0'))

+                  {

+                    local_88[0][uVar14] = local_88[0][uVar14] + plVar11[0x16] + plVar11[0x19];

+                  }

+                }

+LAB_3:

+                uVar14 = (int)plVar15 + 1;

+                plVar15 = (longlong *)(ulonglong)uVar14;

+              } while (uVar14 < *(uint *)(plVar16 + 3));

+            }

+            lVar9 = plVar16[5];

+            plVar16[5] = (longlong)plVar20;

+            if (0 < (longlong)plVar20 - lVar9) {

+              local_78 = local_78 + ((longlong)plVar20 - lVar9);

+            }

+            lVar9 = plVar16[6];

+            plVar16[6] = (longlong)param_2;

+            plVar16 = (longlong *)*plVar16;

+            lVar17 = local_78 + ((longlong)param_2 - lVar9);

+            if ((longlong)param_2 - lVar9 < 1) {

+              lVar17 = local_78;

+            }

+            local_78 = lVar17;

+            plVar12 = local_70;

+          } while (plVar16 != puVar19 + 2);

+        }

+        plVar11 = (longlong *)((longlong)plVar12 + local_78);

+        puVar19[0x18] = local_78;

+        puVar19 = (undefined8 *)*puVar19;

+        local_70 = plVar11;

+        plVar16 = local_88[0];

+        plVar12 = local_60;

+        plVar6 = local_68;

+      } while ((undefined8 **)puVar19 != &KiIntTrackRootList);

+    }

+    plVar20 = plVar6;

+    param_2 = plVar12;

+    plVar15 = plVar16;

+    if (((DAT_1._2_1_ & 1) == 0) || (PopHibernateInProgress != 0)) {

+LAB_2:

+      LOCK();

+      _KiIntTrackSpinlock = 0;

+      UNLOCK();

+    }

+    else {

+      *(undefined8 *)(puVar13 + -8) = 0x1403658a4;

+      KiReleaseSpinLockInstrumented(&KiIntTrackSpinlock);

+    }

+    if (KiIrqlFlags != 0) {

+      *(undefined8 *)(puVar13 + -8) = 0x1403658cb;

+      KiLowerIrqlProcessIrqlFlags(uVar21);

+    }

+    if ((KiIntSteerEnabled != '\0') && ((int)local_88[1] != 0)) {

+      lVar9 = (longlong)plVar15 - (longlong)KiIntSteerPerProcIsrDpcTimeAffinitized;

+      uVar8 = (ulonglong)local_88[1] & 0xffffffff;

+      lVar17 = (longlong)&KiProcessorBlock - (longlong)KiIntSteerPerProcIsrDpcTimeAffinitized;

+      plVar15 = KiIntSteerPerProcIsrDpcTimeAffinitized;

+      do {

+        lVar2 = *(longlong *)(lVar9 + (longlong)plVar15);

+        lVar10 = lVar2 - *plVar15;

+        *plVar15 = lVar2;

+        if (0 < lVar10) {

+          piVar1 = (int *)((longlong)plVar18 + *param_2 + 4);

+          *piVar1 = *piVar1 + (int)((ulonglong)(lVar10 * 10000) /

+                                   ((ulonglong)

+                                    *(uint *)(*(longlong *)(lVar17 + (longlong)plVar15) + 0x44) *

+                                   (longlong)KiIntSteerPreviousPerfSnapDelta));

+        }

+        plVar15 = plVar15 + 1;

+        plVar18 = (longlong *)((longlong)plVar18 + 4);

+        uVar8 = uVar8 - 1;

+      } while (uVar8 != 0);

+    }

+    KiIntSteerLoadPercent =

+         (undefined4)

+         ((ulonglong)((longlong)plVar11 * 10000) /

+         (ulonglong)((longlong)plVar20 * KiIntSteerSlowestCyclesPerSec));

   }

-  if ((unaff_BPL & 0x10) != 0) {

-    lVar18 = unaff_RBX + (ulonglong)*(byte *)(unaff_RSI + 0x7c) * 8;

-    *(longlong *)(lVar18 + 0x8688) = *(longlong *)(lVar18 + 0x8688) + unaff_R14;

-    unaff_BPL = unaff_BPL & 0xef;

-  }

-  cVar25 = (char)unaff_RDI;

-  if ((unaff_BPL & 0x20) != 0) {

-    lVar18 = *(longlong *)(unaff_RSI + 0x688);

-    if (lVar18 != 0) {

-      lVar2 = *(longlong *)(unaff_RBX + 0x89b8);

-      uVar19 = unaff_R15D;

-      if ((*(longlong *)(unaff_RBX + 0x89b0) != 0) && (lVar2 != 0)) {

-        if (*(char *)(lVar2 + 0x70) == cVar25) {

-          uVar15 = *(uint *)(*(longlong *)(unaff_RBX + 0x89b0) + 0x210);

-          uVar19 = *(uint *)(lVar2 + 0x50);

-          if (uVar15 <= *(uint *)(lVar2 + 0x50)) {

-            uVar19 = uVar15;

-          }

-        }

-        else {

-          uVar19 = *(uint *)(lVar2 + 0x84);

-        }

-      }

-      uVar16 = unaff_RDI & 0xffffffff;

-      puVar20 = (ushort *)(unaff_RBX + 0x8a6a);

-      do {

-        if (uVar19 <= *puVar20) break;

-        uVar15 = (int)uVar16 + 1;

-        uVar16 = (ulonglong)uVar15;

-        puVar20 = puVar20 + 1;

-      } while (uVar15 < 3);

-      cVar1 = *(char *)(unaff_RBX + 0x8a08);

-      lVar2 = lVar18 + (ulonglong)(-(uint)(cVar1 != '\0') & 8);

-      *(longlong *)(lVar2 + uVar16 * 0x10) = *(longlong *)(lVar2 + uVar16 * 0x10) + unaff_R14;

-      uVar19 = *(uint *)(lVar18 + 0xc0);

-      if (uVar19 < KiTimelineBitmapTime) {

-        if (KiTimelineBitmapTime - uVar19 < 0x20) {

-          uStack00000000000000ac =

-               *(int *)(lVar18 + 0xc4) << ((byte)(KiTimelineBitmapTime - uVar19) & 0x1f) |

-               uStack00000000000000ac;

-        }

-        *(ulonglong *)(lVar18 + 0xc0) = CONCAT44(uStack00000000000000ac,KiTimelineBitmapTime);

-      }

-      else if (uVar19 - KiTimelineBitmapTime < 0x20) {

-        *(uint *)(lVar18 + 0xc4) =

-             *(uint *)(lVar18 + 0xc4) |

-             uStack00000000000000ac << ((byte)(uVar19 - KiTimelineBitmapTime) & 0x1f);

-      }

-      if ((KiEfficiencyClassSystem == (int)unaff_RDI) &&

-         (((*(byte *)(unaff_RSI + 0x204) - 2 & 0xfffffffb) == 0 ||

-          (*(byte *)(unaff_RSI + 0x204) == 5)))) {

-        *(longlong *)(lVar18 + 8 + uVar16 * 0x10) =

-             *(longlong *)(lVar18 + 8 + uVar16 * 0x10) + unaff_R14;

-      }

-      if (*(ulonglong *)(unaff_RSI + 0x650) != unaff_RDI) {

-        uVar22 = (ulonglong)(-(uint)(cVar1 != '\0') & 8);

-        lVar18 = lVar18 + (uVar16 + 8) * 0x10;

-        *(longlong *)(uVar22 + lVar18) = *(longlong *)(uVar22 + lVar18) + unaff_R14;

-        lVar18 = 0x40;

-        if (cVar1 != '\0') {

-          lVar18 = 0x48;

-        }

-        LOCK();

-        plVar17 = (longlong *)

-                  (lVar18 + *(longlong *)(*(longlong *)(unaff_RSI + 0x650) + 0x688) + uVar16 * 0x10)

-        ;

-        *plVar17 = *plVar17 + unaff_R14;

-        UNLOCK();

-      }

-    }

-    unaff_BPL = unaff_BPL & 0xdf;

-  }

-  if (((unaff_BPL & 0x40) != 0) && (*(longlong *)(unaff_RSI + 0x3c8) != 0)) {

-    *(char *)(*(longlong *)(unaff_RSI + 0x3c8) + 0x40) = cVar25;

-  }

-  if (KiHgsPlusEnabled != cVar25) {

-    KiUpdateThreadHgsFeedback();

-  }

-  uVar26 = (undefined7)(unaff_RDI >> 8);

-  if (((*(ulonglong *)(unaff_RBX + 0x86b0) != unaff_RDI) &&

-      (*(undefined **)(unaff_RSI + 0x220) != &KiInitialProcess)) &&

-     (*(byte *)(unaff_RSI + 0x204) < 7)) {

-    uVar19 = *(uint *)(unaff_RSI + 0x50);

-    if (*(uint *)(unaff_RSI + 0x50) <= *(uint *)(unaff_RSI + 0x54)) {

-      uVar19 = *(uint *)(unaff_RSI + 0x54);

-    }

-    plVar17 = (longlong *)

-              (*(longlong *)(unaff_RBX + 0x86b0) +

-              (ulonglong)

-              (((int)CONCAT71(uVar26,KiDynamicHeteroCpuPolicyExpectedCycles <= uVar19) +

-               (uint)*(byte *)(unaff_RSI + 0x204) * 2) * KiHgsPlusConfiguration +

-              (uint)*(byte *)(unaff_RSI + 0x205)) * 8);

-    *plVar17 = *plVar17 + unaff_R14;

-  }

-  if ((unaff_BPL & 0xbe) != 0) {

-    if (*(longlong *)(unaff_RSI + 0x68) != 0) {

-      plVar17 = (longlong *)

-                ((ulonglong)*(uint *)(unaff_RBX + 0xd8) + *(longlong *)(unaff_RSI + 0x68));

-      do {

-        *plVar17 = *plVar17 + unaff_R14;

-        plVar17 = (longlong *)plVar17[0x34];

-      } while (plVar17 != (longlong *)0x0);

-    }

-    if ((((*(byte *)(unaff_RSI + 2) & 8) != 0) &&

-        (*(undefined **)(unaff_RSI + 0x220) != &KiInitialProcess)) &&

-       (uVar16 = *(ulonglong *)(*(longlong *)(unaff_RBX + 0xc0) + 0x80),

-       (uVar16 & *(ulonglong *)

-                  (*(longlong *)(unaff_RSI + 0x240) + 8 +

-                  (ulonglong)*(ushort *)(*(longlong *)(unaff_RBX + 0xc0) + 0x88) * 8)) != uVar16)) {

-      *(longlong *)(unaff_RBX + 0x86a8) = *(longlong *)(unaff_RBX + 0x86a8) + unaff_R14;

-    }

-    if (*(ulonglong *)(unaff_RSI + 0x168) != unaff_RDI) {

-      KiEndCounterAccumulation();

-    }

-  }

-  if (in_stack_000000b0 != (undefined8 *)0x0) {

-    *in_stack_000000b0 = unaff_R12;

-  }

-  uVar16 = unaff_RDI;

-  uVar22 = unaff_RDI;

-  uVar23 = unaff_RDI;

-  uVar30 = unaff_RDI;

-  if (*(char *)(unaff_RBX + 0x86dc) != cVar25) {

-    uVar16 = KeQueryPerformanceCounter(0);

-    uVar22 = uVar16;

-    if (*(byte *)(unaff_RBX + 0xac) != 0) {

-      uVar22 = uVar16 << (*(byte *)(unaff_RBX + 0xac) & 0x3f);

-    }

-    auVar3._8_8_ = 0;

-    auVar3._0_8_ = *(ulonglong *)(unaff_RBX + 0xb0);

-    auVar9._8_8_ = 0;

-    auVar9._0_8_ = uVar22;

-    uVar23 = SUB168(auVar3 * auVar9,8);

-    uVar27 = *(ulonglong *)(unaff_RBX + 0x86f8);

-    uVar22 = uVar23 - *(longlong *)(unaff_RBX + 0x8680);

-    uVar30 = uVar16 - uVar27;

-    if ((KiTickAccumulationFromAccountingPeriods != cVar25) && (_DAT_0 != unaff_RDI))

-    {

-      if (DAT_1 == 0) {

-        auVar8._8_8_ = 0;

-        auVar8._0_8_ = _DAT_2;

-        auVar14._8_8_ = 0;

-        auVar14._0_8_ = uVar27;

-        uVar24 = SUB168(auVar8 * auVar14,8);

-        uVar27 = uVar16;

-      }

-      else {

-        auVar4._8_8_ = 0;

-        auVar4._0_8_ = _DAT_2;

-        auVar10._8_8_ = 0;

-        auVar10._0_8_ = uVar27 << (DAT_1 & 0x3f);

-        uVar24 = SUB168(auVar4 * auVar10,8);

-        uVar27 = uVar16 << (DAT_1 & 0x3f);

-      }

-      auVar5._8_8_ = 0;

-      auVar5._0_8_ = _DAT_2;

-      auVar11._8_8_ = 0;

-      auVar11._0_8_ = uVar27;

-      auVar6._8_8_ = 0;

-      auVar6._0_8_ = KiMaximumIncrementReciprocal;

-      auVar12._8_8_ = 0;

-      auVar12._0_8_ = uVar24;

-      auVar7._8_8_ = 0;

-      auVar7._0_8_ = KiMaximumIncrementReciprocal;

-      auVar13._8_8_ = 0;

-      auVar13._0_8_ = SUB168(auVar5 * auVar11,8);

-      iVar21 = (int)(SUB168(auVar7 * auVar13,8) >> (KiMaximumIncrementShiftCount & 0x3f)) -

-               (int)(SUB168(auVar6 * auVar12,8) >> (KiMaximumIncrementShiftCount & 0x3f));

-      if (iVar21 != 0) {

-        *(int *)(unaff_RBX + 0x8644) = *(int *)(unaff_RBX + 0x8644) + iVar21;

-        *(int *)(unaff_RBX + 0x8650) = *(int *)(unaff_RBX + 0x8650) + iVar21;

-      }

-    }

-  }

-  *(ulonglong *)(unaff_RBX + 0x8700) = *(longlong *)(unaff_RBX + 0x8700) + uVar30;

-  uVar30 = *(longlong *)(unaff_RBX + 0x8778) + uVar22;

-  *(ulonglong *)(unaff_RBX + 0x8778) = uVar30;

-  if ((*(byte *)(unaff_RSI + 2) & 0x20) != 0) {

-    lVar18 = *(longlong *)(unaff_RBX + 0x89b8);

-    if ((*(longlong *)(unaff_RBX + 0x89b0) != 0) && (lVar18 != 0)) {

-      if (*(char *)(lVar18 + 0x70) == cVar25) {

-        uVar19 = *(uint *)(*(longlong *)(unaff_RBX + 0x89b0) + 0x210);

-        unaff_R15D = *(uint *)(lVar18 + 0x50);

-        if (uVar19 <= *(uint *)(lVar18 + 0x50)) {

-          unaff_R15D = uVar19;

-        }

-      }

-      else {

-        unaff_R15D = *(uint *)(lVar18 + 0x84);

-      }

-    }

-    uVar30 = unaff_RDI & 0xffffffff;

-    puVar20 = (ushort *)(unaff_RBX + 0x8a6a);

-    do {

-      if (unaff_R15D <= *puVar20) break;

-      uVar19 = (int)uVar30 + 1;

-      uVar30 = (ulonglong)uVar19;

-      puVar20 = puVar20 + 1;

-    } while (uVar19 < 3);

-    lVar18 = CONCAT71(uVar26,*(char *)(unaff_RBX + 0x8a08) != cVar25) + 0x10f0 + uVar30 * 2;

-    uVar30 = *(longlong *)(unaff_RBX + lVar18 * 8) + uVar22;

-    *(ulonglong *)(unaff_RBX + lVar18 * 8) = uVar30;

-  }

-  if (((*(byte *)(unaff_RSI + 2) & 0x40) != 0) && (*(longlong *)(unaff_RSI + 0x3c8) != 0)) {

-    *(char *)(*(longlong *)(unaff_RSI + 0x3c8) + 0x40) = (char)unaff_R13;

-  }

-  *(ulonglong *)(unaff_RBX + 0x86f8) = uVar16;

-  *(ulonglong *)(unaff_RBX + 0x8680) = uVar23;

-  if ((*(byte *)(unaff_RSI + 2) & 2) != 0) {

-    uVar16 = *(ulonglong *)(unaff_RSI + 0x168);

-    uVar22 = *(ulonglong *)(uVar16 + 0x20);

-    if ((uVar22 != 0) && (uVar30 = (ulonglong)KiHwCountersCount, KiHwCountersCount != 0)) {

-      puVar28 = &KiHwCounters;

-      uVar23 = (ulonglong)KiHwCountersCount;

-      puVar29 = (ulonglong *)(uVar16 + 0x30);

-      do {

-        if ((unaff_R13 & uVar22) != 0) {

-          uVar30 = (ulonglong)*puVar28;

-          uVar27 = rdpmc(*puVar28);

-          uVar16 = CONCAT44((int)(uVar16 >> 0x20),(int)uVar27) | uVar27 & 0xffffffff00000000;

-          *puVar29 = uVar16;

-        }

-        unaff_R13 = unaff_R13 * 2;

-        puVar29 = puVar29 + 3;

-        puVar28 = puVar28 + 1;

-        uVar23 = uVar23 - 1;

-      } while (uVar23 != 0);

-    }

-  }

-  *(undefined1 *)(unaff_RBX + 0x20) = 0;

-  if (*(char *)(unaff_RBX + 6) != '\0') {

-    *(undefined1 *)(unaff_RBX + 6) = 0;

-    HalRequestSoftwareInterrupt(CONCAT71((int7)(uVar30 >> 8),2));

-  }

-  return in_stack_00000030;

+  *local_50 = KiIntSteerLoadPercent;

+  *local_40 = local_48;

+  *(undefined8 *)(puVar13 + -8) = 0x140365984;

+  return 0;

 }
```

## `RtlpFindAndCommitPages`  (modified)

```diff
--- RtlpFindAndCommitPages
+++ RtlpFindAndCommitPages
@@ -1,14 +1,101 @@
 

-undefined8 RtlpFindAndCommitPages(void)

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+longlong RtlpFindAndCommitPages(longlong param_1,ulonglong *param_2)

 

 {

-  longlong unaff_RBX;

-  char unaff_R14B;

+  longlong lVar1;

+  longlong lVar2;

+  ulonglong uVar3;

+  int iVar4;

+  longlong lVar5;

+  code *pcVar6;

+  ulonglong uVar7;

+  undefined1 uVar8;

+  longlong lVar9;

+  undefined8 local_res8;

+  undefined8 in_stack_ffffffffffffffd8;

+  undefined4 uVar10;

+  undefined8 in_stack_ffffffffffffffe0;

+  undefined4 uVar11;

   

-  ZwFreeVirtualMemory(0xffffffffffffffff,&stack0x00000050,&stack0x000000c8);

-  if (unaff_R14B != '\0') {

-    ExReleaseResourceLite(*(undefined8 *)(unaff_RBX + 0x160));

+  uVar10 = (undefined4)((ulonglong)in_stack_ffffffffffffffd8 >> 0x20);

+  uVar11 = (undefined4)((ulonglong)in_stack_ffffffffffffffe0 >> 0x20);

+  lVar5 = RtlpFindUCREntry(param_1,*param_2);

+  if (lVar5 != param_1 + 0xf0) {

+    if ((0 < RtlpHeapErrorHandlerThreshold) && (*(ulonglong *)(lVar5 + 0x28) < *param_2)) {

+                    /* WARNING: Subroutine does not return */

+      DbgPrint(&s__UCRBlock_>Size_>___Size_);

+    }

+    uVar8 = 0;

+    lVar9 = param_1;

+    if (*(byte *)(lVar5 + -2) != 0) {

+      lVar9 = (lVar5 - 0x10U & 0xffffffffffff0000) + (ulonglong)*(byte *)(lVar5 + -2) * -0x10000 +

+              0x10000;

+    }

+    local_res8 = *(undefined8 *)(lVar5 + 0x20);

+    pcVar6 = (code *)(*(ulonglong *)(param_1 + 0x168) ^ _RtlpHeapKey);

+    if (pcVar6 == (code *)0x0) {

+      uVar7 = *param_2 + 0xfff & 0xfffffffffffff000;

+      *param_2 = uVar7;

+      iVar4 = RtlpHpHeapCheckCommitLimit

+                        (uVar7,*(longlong *)(param_1 + 0x240) - *(longlong *)(param_1 + 0x2a0),

+                         param_1,param_1 + 0x178);

+      if (iVar4 != 0) {

+        ZwAllocateVirtualMemory

+                  (0xffffffffffffffff,&local_res8,0,param_2,CONCAT44(uVar10,0x1000),

+                   CONCAT44(uVar11,4));

+      }

+      iVar4 = RtlpUpdateHeapRates(param_1,2);

+    }

+    else {

+      iVar4 = (*pcVar6)(param_1,&local_res8,param_2);

+    }

+    if (-1 < iVar4) {

+      lVar1 = lVar5 + -0x10;

+      if ((*(int *)(param_1 + 0x7c) != 0) &&

+         (*(uint *)(lVar5 + -8) = *(uint *)(lVar5 + -8) ^ *(uint *)(param_1 + 0x88),

+         *(byte *)(lVar5 + -5) !=

+         (byte)(*(byte *)(lVar5 + -6) ^ *(byte *)(lVar5 + -7) ^ *(byte *)(lVar5 + -8)))) {

+        RtlpAnalyzeHeapFailure(param_1,lVar1);

+      }

+      *(undefined1 *)(lVar5 + -6) = 0;

+      *(undefined1 *)(lVar5 + -1) = 0;

+      RtlpRemoveUCRBlock();

+      *(int *)(lVar9 + 0x54) = *(int *)(lVar9 + 0x54) + -1;

+      *(int *)(lVar9 + 0x50) = *(int *)(lVar9 + 0x50) - (int)(*(ulonglong *)(lVar5 + 0x28) >> 0xc);

+      lVar2 = *(longlong *)(lVar5 + 0x28);

+      *(int *)(param_1 + 0x268) = *(int *)(param_1 + 0x268) + 1;

+      *(int *)(param_1 + 0x264) = *(int *)(param_1 + 0x264) + -1;

+      *(longlong *)(param_1 + 0x240) = *(longlong *)(param_1 + 0x240) + lVar2;

+      if (0xfefff < *(ulonglong *)(lVar5 + 0x28)) {

+        *(longlong *)(param_1 + 0x248) =

+             *(longlong *)(param_1 + 0x248) - *(ulonglong *)(lVar5 + 0x28);

+      }

+      uVar7 = *(ulonglong *)(lVar5 + 0x28);

+      uVar3 = *param_2;

+      if ((uVar3 < uVar7) || (*(longlong *)(lVar5 + 0x20) + uVar7 == *(longlong *)(lVar9 + 0x48))) {

+        RtlpCreateUCREntry(param_1,lVar9,*(longlong *)(lVar5 + 0x20) + (uVar3 - 0x30),uVar7 - uVar3,

+                           lVar1,param_2);

+        *param_2 = *param_2 << 4;

+      }

+      else {

+        *param_2 = (ulonglong)*(ushort *)(lVar5 + -8) * 0x10 + uVar3;

+      }

+      *(undefined1 *)(lVar5 + -5) = 0;

+      if (*(longlong *)(lVar9 + 0x28) != lVar9) {

+        uVar7 = ((ulonglong)(lVar1 - lVar9) >> 0x10) + 1;

+        if (0xfd < uVar7) {

+          RtlpLogHeapFailure(3,*(longlong *)(lVar9 + 0x28),lVar1,lVar9,0,0);

+        }

+        uVar8 = (undefined1)uVar7;

+      }

+      *(undefined1 *)(lVar5 + -2) = uVar8;

+      return lVar1;

+    }

+    *(int *)(param_1 + 0x280) = *(int *)(param_1 + 0x280) + 1;

   }

-  return 1;

+  return 0;

 }
```

## `FsRtlpAcknowledgeOplockBreak`  (modified)

```diff
--- FsRtlpAcknowledgeOplockBreak
+++ FsRtlpAcknowledgeOplockBreak
@@ -1,49 +1,127 @@
 

-void FsRtlpAcknowledgeOplockBreak(longlong param_1,undefined8 param_2)

+undefined4

+FsRtlpAcknowledgeOplockBreak

+          (longlong param_1,longlong param_2,longlong param_3,char param_4,undefined4 param_5)

 

 {

-  longlong *plVar1;

-  undefined1 in_AL;

-  char cVar2;

-  char unaff_SIL;

-  longlong *plStack0000000000000030;

+  byte *pbVar1;

+  undefined8 uVar2;

+  code *pcVar3;

+  bool bVar4;

+  char cVar5;

+  undefined1 uVar6;

+  uint uVar7;

+  longlong *plVar8;

+  longlong *plVar9;

+  longlong lVar10;

+  undefined1 *puVar11;

+  undefined1 *puVar12;

+  undefined4 uVar13;

+  undefined1 auStack_48 [8];

+  undefined1 auStack_40 [24];

+  undefined1 local_28;

+  undefined4 local_24;

+  undefined4 local_20;

   

-  cVar2 = (char)param_2;

-  plVar1 = *(longlong **)(param_1 + 0x38);

-  LOCK();

-  *(undefined8 *)(param_1 + 0x68) = 0;

-  UNLOCK();

-  plStack0000000000000030 = plVar1;

-  KeReleaseQueuedSpinLock

-            (7,CONCAT71((int7)(CONCAT62((int6)((ulonglong)param_2 >> 0x10),CONCAT11(in_AL,cVar2)) >>

-                              8),*(undefined1 *)(param_1 + 0x45)));

-  if (cVar2 == '\0') {

-    ExAcquireFastMutex(plVar1[0x13]);

+  puVar12 = auStack_48;

+  puVar11 = auStack_48;

+  if (param_1 == 0) {

+    *(undefined4 *)(param_3 + 0x30) = 0xc00000e3;

+    IofCompleteRequest(param_3,1);

+    return 0xc00000e3;

   }

-  if ((*plVar1 != 0) && (*(char *)(*plVar1 + 0x44) != '\0')) {

-    FsRtlpModifyThreadPriorities(plVar1,0,0);

-    FsRtlpClearOwner(plVar1,0);

-    *(undefined1 *)(plVar1 + 4) = 0;

-    if (*(longlong **)(*plVar1 + 0x38) == plVar1) {

-      *(undefined8 *)(*plVar1 + 0x38) = 0;

+  ExAcquireFastMutexUnsafe(*(undefined8 *)(param_1 + 0x98));

+  bVar4 = true;

+  local_28 = 1;

+  if (*(longlong *)(param_1 + 8) == *(longlong *)(param_2 + 0x30)) {

+    uVar13 = 0x10;

+    cVar5 = FsRtlpOplockUpperLowerCompatible(0x10,param_5);

+    if ((cVar5 == '\0') && ((*(uint *)(param_1 + 0x90) >> 8 & 1) != 0)) {

+      uVar7 = *(uint *)(param_1 + 0x90) & 0xfffffeff;

+      *(uint *)(param_1 + 0x90) = uVar7;

+      *(uint *)(param_1 + 0x90) = uVar7 | 0x400;

     }

-    *(undefined4 *)(*plVar1 + 0x30) = 0xc0000120;

-    IofCompleteRequest(*plVar1,1);

-    *plVar1 = 0;

-    ObfDereferenceObjectWithTag(plVar1[1],0x746c6644);

-    plVar1[1] = 0;

-    *(uint *)(plVar1 + 0x12) = *(uint *)(plVar1 + 0x12) & 0x20 | 1;

-    if (unaff_SIL != '\0') {

-      FsRtlpSyncWithAckTimeout(plVar1 + 0x16);

-      FsRtlpOplockPerfSendData(plVar1 + 0x14);

-      while ((longlong *)plVar1[0xb] != plVar1 + 0xb) {

-        FsRtlpRemoveAndCompleteWaitingIrp();

+    if ((param_4 == '\0') || ((*(uint *)(param_1 + 0x90) & 0x100) == 0)) {

+      if ((*(uint *)(param_1 + 0x90) & 0x300) == 0) {

+        if ((*(uint *)(param_1 + 0x90) >> 10 & 1) == 0) goto LAB_0;

+        *(undefined8 *)(param_3 + 0x38) = 8;

       }

+      local_20 = 0;

+      *(undefined4 *)(param_3 + 0x30) = 0;

+      IofCompleteRequest(param_3,1);

+      local_24 = 1;

     }

+    else {

+      pbVar1 = (byte *)(*(longlong *)(param_3 + 0xb8) + 3);

+      *pbVar1 = *pbVar1 | 1;

+      *(undefined4 *)(param_3 + 0x30) = 0;

+      plVar9 = (longlong *)(param_3 + 0xa8);

+      plVar8 = (longlong *)(param_1 + 0x28);

+      lVar10 = *plVar8;

+      puVar11 = auStack_48;

+      if (*(longlong **)(lVar10 + 8) != plVar8) {

+        plVar9 = (longlong *)0x3;

+        pcVar3 = (code *)swi(0x29);

+        plVar8 = (longlong *)(*pcVar3)();

+        puVar11 = auStack_40;

+      }

+      *plVar9 = lVar10;

+      plVar9[1] = (longlong)plVar8;

+      *(longlong **)(lVar10 + 8) = plVar9;

+      *plVar8 = (longlong)plVar9;

+      *(longlong *)(param_3 + 0x38) = param_1;

+      bVar4 = false;

+      puVar11[0x20] = 0;

+      *(undefined4 *)(puVar11 + 0x24) = uVar13;

+      *(undefined8 *)(puVar11 + -8) = 0x14057d740;

+      uVar6 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(param_3 + 0x45) = uVar6;

+      if (*(char *)(param_3 + 0x44) == '\0') {

+        LOCK();

+        *(code **)(param_3 + 0x68) = FsRtlpReadOnlyOplockIrpCancelRoutine;

+        UNLOCK();

+        uVar6 = *(undefined1 *)(param_3 + 0x45);

+        *(undefined8 *)(puVar11 + -8) = 0x14057d76b;

+        KeReleaseQueuedSpinLock(7,uVar6);

+      }

+      else {

+        *(undefined8 *)(puVar11 + -8) = 0x14057d753;

+        FsRtlpCancelReadOnlyOplockIrp(param_3,1);

+      }

+      *(undefined4 *)(puVar11 + 0x28) = 0x103;

+    }

+    while (*(longlong **)(param_1 + 0x58) != (longlong *)(param_1 + 0x58)) {

+      *(undefined8 *)(puVar11 + -8) = 0x14057d82d;

+      FsRtlpRemoveAndCompleteWaitingIrp();

+    }

+    if (bVar4) {

+      uVar2 = *(undefined8 *)(param_1 + 8);

+      *(undefined8 *)(puVar11 + -8) = 0x14057d7d6;

+      ObfDereferenceObjectWithTag(uVar2,0x746c6644);

+    }

+    *(undefined8 *)(param_1 + 8) = 0;

+    *(undefined8 *)(puVar11 + -8) = 0x14057d7e8;

+    FsRtlpModifyThreadPriorities(param_1,0,0);

+    *(undefined8 *)(puVar11 + -8) = 0x14057d7f2;

+    FsRtlpClearOwner(param_1,0);

+    *(undefined1 *)(param_1 + 0x20) = 0;

+    *(uint *)(param_1 + 0x90) = *(uint *)(param_1 + 0x90) & 0x20 | *(uint *)(puVar11 + 0x24);

+    *(undefined8 *)(puVar11 + -8) = 0x14057d815;

+    FsRtlpSyncWithAckTimeout(param_1 + 0xb0);

+    *(undefined8 *)(puVar11 + -8) = 0x14057d821;

+    FsRtlpOplockPerfSendData(param_1 + 0xa0);

+    uVar13 = *(undefined4 *)(puVar11 + 0x28);

+    puVar12 = puVar11;

   }

-  if (cVar2 == '\0') {

-    ExReleaseFastMutex(plVar1[0x13]);

+  else {

+LAB_0:

+    uVar13 = 0xc00000e3;

+    *(undefined4 *)(param_3 + 0x30) = 0xc00000e3;

+    IofCompleteRequest(param_3,1);

   }

-  return;

+  uVar2 = *(undefined8 *)(param_1 + 0x98);

+  *(undefined8 *)(puVar12 + -8) = 0x14057d851;

+  ExReleaseFastMutexUnsafe(uVar2);

+  return uVar13;

 }
```

## `PopAdaptiveStandbySessionStart`  (modified)

```diff
--- PopAdaptiveStandbySessionStart
+++ PopAdaptiveStandbyHandleBatteryUpdate
@@ -1,158 +1,199 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-void PopAdaptiveStandbySessionStart(char *param_1,undefined4 param_2)

+void PopAdaptiveStandbyHandleBatteryUpdate(longlong param_1,uint *param_2)

 

 {

-  char cVar1;

-  int iVar2;

-  undefined4 uVar3;

-  undefined8 uVar4;

-  undefined4 uVar5;

-  undefined *puVar6;

-  ulonglong uVar7;

-  undefined1 auStack_158 [32];

-  undefined4 local_138;

-  undefined1 *local_130;

-  byte local_128 [4];

-  undefined4 local_124;

-  undefined4 local_120;

-  undefined4 local_11c;

+  uint *puVar1;

+  uint uVar2;

+  uint uVar3;

+  char cVar4;

+  int iVar5;

+  int iVar6;

+  undefined8 uVar7;

+  undefined4 uVar8;

+  ulonglong uVar9;

+  uint uVar10;

+  longlong lVar11;

+  uint *puVar12;

+  undefined1 auStack_138 [32];

   undefined4 local_118;

-  undefined1 local_114 [4];

-  longlong local_110;

-  longlong local_108;

-  ulonglong local_100;

-  ulonglong local_f8 [2];

-  undefined1 local_e8 [32];

-  ulonglong *local_c8;

+  int *local_110;

+  byte local_108 [4];

+  uint local_104;

+  uint local_100;

+  undefined4 local_fc;

+  undefined4 local_f8;

+  uint local_f4;

+  undefined4 local_f0;

+  uint local_ec;

+  int local_e8;

+  int local_e4;

+  int local_e0;

+  int local_dc;

+  int local_d8;

+  int local_d4;

+  uint *local_c8;

   undefined8 local_c0;

-  undefined4 *local_b8;

-  undefined8 local_b0;

-  longlong *local_a8;

-  undefined8 local_a0;

+  int local_b8 [8];

   byte *local_98;

   undefined8 local_90;

-  byte *local_88;

+  uint *local_88;

   undefined8 local_80;

-  undefined4 *local_78;

+  uint *local_78;

   undefined8 local_70;

-  undefined4 *local_68;

+  uint *local_68;

   undefined8 local_60;

-  undefined4 *local_58;

+  uint *local_58;

   undefined8 local_50;

-  longlong *local_48;

-  undefined8 local_40;

-  ulonglong *local_38;

-  undefined8 local_30;

-  ulonglong local_28;

+  ulonglong local_48;

   

-  local_28 = __security_cookie ^ (ulonglong)auStack_158;

-  uVar7 = _DAT_0 / 10000000;

-  *(ulonglong *)(param_1 + 200) = uVar7;

-  *(undefined8 *)(param_1 + 0xd0) = _DAT_1;

-  *(undefined4 *)(param_1 + 0xb0) = *(undefined4 *)(param_1 + 0x88);

-  *(undefined4 *)(param_1 + 0xb4) = *(undefined4 *)(param_1 + 0x8c);

-  *(undefined4 *)(param_1 + 0xb8) = *(undefined4 *)(param_1 + 0x90);

-  *(undefined4 *)(param_1 + 0xbc) = *(undefined4 *)(param_1 + 0x94);

-  *(undefined4 *)(param_1 + 0xc0) = *(undefined4 *)(param_1 + 0x98);

-  iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

-  if (iVar2 == 0) {

-    PopAdaptiveStandbyQueryReserveConfiguration(param_1);

-    if (DAT_2 < 6) {

-      return;

+  local_48 = __security_cookie ^ (ulonglong)auStack_138;

+  local_f8 = 0;

+  local_fc = 0;

+  local_f0 = 0;

+  puVar1 = (uint *)(param_1 + 0x88);

+  iVar5 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  puVar12 = puVar1;

+  if (iVar5 == 0) {

+    uVar10 = param_2[1];

+    uVar2 = param_2[2];

+    uVar3 = param_2[3];

+    *puVar1 = *param_2;

+    *(uint *)(param_1 + 0x8c) = uVar10;

+    *(uint *)(param_1 + 0x90) = uVar2;

+    *(uint *)(param_1 + 0x94) = uVar3;

+    *(uint *)(param_1 + 0x98) = param_2[4];

+    puVar12 = param_2;

+    if (5 < DAT_0) {

+      local_108[0] = (byte)*param_2 & 1;

+      local_90 = 1;

+      local_98 = local_108;

+      local_100 = param_2[1];

+      local_88 = &local_100;

+      local_104 = param_2[2];

+      local_78 = &local_104;

+      local_ec = param_2[3];

+      local_68 = &local_ec;

+      local_f4 = param_2[4];

+      local_58 = &local_f4;

+      local_80 = 4;

+      local_70 = 4;

+      local_60 = 4;

+      local_50 = 4;

+      uVar7 = IoGetActivityIdThread();

+      local_110 = local_b8;

+      local_118 = 7;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e278,uVar7,0);

     }

-    cVar1 = _tlgKeywordOn(&DAT_2,0x400000000000);

-    if (cVar1 == '\0') {

-      return;

-    }

-    local_c8 = &local_100;

-    local_b8 = (undefined4 *)local_114;

-    local_108 = *(longlong *)(param_1 + 0xf0);

-    local_a8 = &local_108;

-    local_128[0] = param_1[0xb0] & 1;

-    local_c0 = 8;

-    local_98 = local_128;

-    local_118 = *(undefined4 *)(param_1 + 0xb4);

-    local_88 = (byte *)&local_118;

-    local_11c = *(undefined4 *)(param_1 + 0xb8);

-    local_78 = &local_11c;

-    local_120 = *(undefined4 *)(param_1 + 0xbc);

-    local_68 = &local_120;

-    local_124 = *(undefined4 *)(param_1 + 0xc0);

-    local_58 = &local_124;

-    local_48 = &local_110;

-    local_b0 = 4;

-    local_a0 = 8;

-    local_90 = 1;

-    local_80 = 4;

-    local_70 = 4;

-    local_60 = 4;

-    local_50 = 4;

-    local_110 = 0x1000000;

-    local_40 = 8;

-    local_114 = (undefined1  [4])param_2;

-    local_100 = uVar7;

-    uVar4 = IoGetActivityIdThread();

-    puVar6 = &DAT_3;

-    local_138 = 0xb;

+  }

+  uVar10 = 0;

+  local_104 = 0;

+  local_100 = 0;

+  if (*(longlong *)(param_1 + 200) == 0) goto LAB_1;

+  if ((((byte)*(undefined4 *)(param_1 + 0xb0) ^ (byte)*puVar1) & 1) != 0) {

+    PopAdaptiveStandbySessionStop(param_1,2);

+    PopAdaptiveStandbySessionStart(param_1,2);

+  }

+  if (*(int *)(param_1 + 0x8c) != *(int *)(param_1 + 0xb4)) {

+    PopAdaptiveStandbySessionStop(param_1,3);

+    PopAdaptiveStandbySessionStart(param_1,3);

+  }

+  if ((*puVar1 & 1) != 0) goto LAB_1;

+  local_e4 = 0;

+  local_d4 = 0;

+  uVar9 = _DAT_2 / 10000000;

+  if (uVar9 - *(longlong *)(param_1 + 200) < 0x100000000) {

+    local_e8 = (int)uVar9 - *(int *)(param_1 + 200);

   }

   else {

-    uVar5 = *(undefined4 *)(param_1 + 0x98);

-    uVar3 = PopAdaptiveStandbyCalculateBatteryRegion();

-    *(undefined4 *)(param_1 + 0xd8) = uVar3;

-    *(undefined8 *)(param_1 + 0xe0) = *(undefined8 *)(param_1 + 200);

-    *(undefined4 *)(param_1 + 0xe8) = uVar5;

-    if (*param_1 != '\0') {

-      PopAdaptiveStandbyHandleBatteryUpdate(param_1,0);

+    local_e8 = -1;

+  }

+  local_e0 = *(int *)(param_1 + 0xc0);

+  local_dc = *(int *)(param_1 + 0x98);

+  local_d8 = local_e0 - local_dc;

+  iVar5 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  if (iVar5 == 0) {

+    cVar4 = PopAdaptiveStandbyCheckRestrictedStandbyBudgetAction(param_1,&local_e8,&local_f8,0);

+    uVar10 = local_104;

+    if (cVar4 != '\0') {

+      uVar10 = 3;

     }

-    if (DAT_2 < 6) {

-      return;

+    cVar4 = PopAdaptiveStandbyCheckHibernateReserveAction(param_1,&local_e8,&local_f0);

+    if (cVar4 != '\0') {

+      uVar10 = 2;

     }

-    cVar1 = _tlgKeywordOn(&DAT_2,0x400000000000);

-    if (cVar1 == '\0') {

-      return;

+    cVar4 = PopAdaptiveStandbyCheckHibernateBudgetAction(param_1,&local_e8,&local_fc,0);

+    uVar8 = local_f0;

+    if (cVar4 != '\0') {

+      uVar10 = 1;

     }

-    local_110 = *(longlong *)(param_1 + 0xf0);

-    local_c8 = local_f8;

-    local_b8 = &local_124;

-    local_a8 = &local_110;

-    local_98 = (byte *)&local_108;

-    local_108 = local_110 + -1;

-    if (*(int *)(param_1 + 0xf8) != 2) {

-      local_108 = local_110;

+  }

+  else {

+    PopAdaptiveStandbyCheckRestrictedStandbyBudgetAction(param_1,&local_e8,&local_f8,&local_104);

+    local_d4 = *(int *)(param_1 + 0xe8) - local_dc;

+    if (uVar9 - *(longlong *)(param_1 + 0xe0) < 0x100000000) {

+      local_e4 = (int)uVar9 - *(int *)(param_1 + 0xe0);

     }

-    local_128[0] = param_1[0xb0] & 1;

-    local_c0 = 8;

-    local_88 = local_128;

-    local_120 = *(undefined4 *)(param_1 + 0xb4);

-    local_78 = &local_120;

-    local_11c = *(undefined4 *)(param_1 + 0xb8);

-    local_68 = &local_11c;

-    local_118 = *(undefined4 *)(param_1 + 0xbc);

-    local_58 = &local_118;

-    local_114 = *(undefined1 (*) [4])(param_1 + 0xc0);

-    local_48 = (longlong *)local_114;

-    local_38 = &local_100;

-    local_b0 = 4;

-    local_a0 = 8;

-    local_90 = 8;

-    local_80 = 1;

-    local_70 = 4;

-    local_60 = 4;

-    local_50 = 4;

-    local_40 = 4;

-    local_100 = 0x1000000;

-    local_30 = 8;

-    local_124 = param_2;

-    local_f8[0] = uVar7;

-    uVar4 = IoGetActivityIdThread();

-    puVar6 = &DAT_4;

-    local_138 = 0xc;

+    else {

+      local_e4 = -1;

+    }

+    cVar4 = PopAdaptiveStandbyCheckHibernateBudgetAction(param_1,&local_e8,&local_fc,&local_100);

+    uVar10 = local_104;

+    if (cVar4 != '\0') {

+      uVar10 = local_100;

+    }

+    lVar11 = (longlong)*(int *)(param_1 + 0xd8);

+    iVar5 = local_dc;

+    iVar6 = PopAdaptiveStandbyCalculateBatteryRegion(local_dc);

+    if ((iVar6 != (int)lVar11) && ((int)(&DAT_3)[lVar11 * 5] <= local_d4)) {

+      *(int *)(param_1 + 0xe8) = iVar5;

+      *(int *)(param_1 + 0xd8) = iVar6;

+      *(ulonglong *)(param_1 + 0xe0) = uVar9;

+    }

+    uVar8 = 5;

   }

-  local_130 = local_e8;

-  _tlgWriteTransfer_EtwWriteTransfer(&DAT_2,puVar6,uVar4,0);

+  if (uVar10 != 0) {

+    if ((uVar10 == 1) || (uVar10 == 2)) {

+LAB_4:

+      *(uint *)(param_1 + 0x224) = uVar10;

+    }

+    else if (uVar10 == 3) {

+LAB_5:

+      if (*(int *)(param_1 + 0x224) == 0) goto LAB_4;

+    }

+    else if (uVar10 == 4) {

+      iVar5 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+      if (iVar5 != 0) goto LAB_4;

+    }

+    else if ((uVar10 == 5) &&

+            (iVar5 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline(),

+            iVar5 != 0)) goto LAB_5;

+    if (*(char *)(param_1 + 0x220) == '\0') {

+      if (5 < DAT_0) {

+        uVar7 = IoGetActivityIdThread();

+        local_110 = &local_e8;

+        local_118 = 2;

+        _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e320,uVar7,0);

+      }

+      *(undefined1 *)(param_1 + 0x220) = 1;

+      ExQueueWorkItem(param_1 + 0x200,1);

+    }

+  }

+  *(int *)(param_1 + 0xec) = *(int *)(param_1 + 0xec) + 1;

+  local_118 = uVar8;

+  PopAdaptiveStandbyTraceBatteryUpdate(param_1,puVar12,local_f8,local_fc);

+LAB_1:

+  if (5 < DAT_0) {

+    local_c8 = &local_f4;

+    local_c0 = 4;

+    local_f4 = uVar10;

+    uVar7 = IoGetActivityIdThread();

+    local_110 = &local_e8;

+    local_118 = 3;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e352,uVar7,0);

+  }

   return;

 }
```

## `SeQueryHSTIResults`  (modified)

```diff
--- SeQueryHSTIResults
+++ SeQueryHSTIResults
@@ -1,10 +1,25 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void SeQueryHSTIResults(void)

+undefined8 SeQueryHSTIResults(void *param_1,uint param_2,uint *param_3)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  uint uVar1;

+  undefined8 uVar2;

+  

+  uVar1 = DAT_0;

+  *param_3 = DAT_0;

+  uVar2 = 0;

+  if (uVar1 == 0) {

+    uVar2 = 0xc0000225;

+  }

+  else if (param_2 < uVar1) {

+    uVar2 = 0xc0000004;

+  }

+  else if (*(char *)((longlong)SystemReserved1[0xf] + 0x232) == '\0') {

+    RtlCopyVolatileMemory(param_1,DAT_1,(ulonglong)DAT_140ff2450);

+  }

+  else {

+    RtlCopyToUser();

+  }

+  return uVar2;

 }
```

## `EtwpEventWriteFull`  (modified)

```diff
--- EtwpEventWriteFull
+++ EtwpEventWriteFull
@@ -1,10 +1,1119 @@
 

-/* WARNING: Control flow encountered bad instruction data */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Removing unreachable block (ram,0x00014033d38a) */

+/* WARNING: Type propagation algorithm not settling */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-void EtwpEventWriteFull(void)

+int EtwpEventWriteFull(longlong param_1,uint param_2,ushort param_3,uint param_4,short *param_5,

+                      ushort param_6,undefined2 param_7,uint *param_8,uint *param_9,uint param_10,

+                      ulonglong param_11,void *param_12,longlong param_13,longlong param_14,

+                      ushort param_15,ushort *param_16,ulonglong *param_17)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  longlong *plVar1;

+  PSLIST_HEADER p_Var2;

+  undefined8 *_Src;

+  undefined8 uVar3;

+  void *pvVar4;

+  longlong lVar5;

+  char cVar6;

+  int iVar7;

+  int iVar8;

+  int iVar9;

+  longlong lVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  ulonglong uVar13;

+  ushort *puVar14;

+  ushort uVar15;

+  uint uVar16;

+  ulonglong uVar17;

+  ushort *puVar18;

+  short *psVar19;

+  uint *puVar20;

+  uint *puVar21;

+  byte bVar22;

+  byte bVar23;

+  ulonglong *puVar24;

+  undefined8 in_R11;

+  uint uVar25;

+  ulonglong uVar26;

+  int *piVar27;

+  ushort uVar28;

+  uint uVar29;

+  uint *puVar30;

+  uint uVar31;

+  bool bVar32;

+  ulonglong in_CR8;

+  uint uVar33;

+  uint uVar34;

+  undefined1 auStack_558 [32];

+  code *local_538;

+  ulonglong local_530;

+  ulonglong local_528;

+  short *local_520;

+  undefined1 local_518;

+  uint local_510;

+  ulonglong local_508;

+  undefined1 local_500;

+  byte local_4f8;

+  uint local_4f4;

+  uint local_4f0;

+  byte local_4ec;

+  uint local_4e8;

+  undefined1 local_4e4;

+  uint local_4e0;

+  int local_4dc;

+  uint local_4d8;

+  byte local_4d4;

+  ushort local_4d0;

+  uint local_4cc;

+  char local_4c8;

+  int local_4c4;

+  uint local_4c0;

+  ulonglong local_4b8;

+  ushort local_4b0;

+  ulonglong local_4a8;

+  uint local_4a0;

+  uint local_49c;

+  longlong local_498;

+  ushort local_490;

+  short *local_488;

+  uint *local_480;

+  PSLIST_ENTRY_conflict local_478;

+  uint local_470;

+  int local_46c;

+  longlong local_468;

+  uint local_460;

+  uint *local_458;

+  void *local_450;

+  ulonglong local_448;

+  uint *local_440;

+  ushort *local_438;

+  ulonglong local_430;

+  longlong local_428;

+  ulonglong local_420;

+  uint *local_418;

+  PSLIST_ENTRY_conflict local_410;

+  ushort *local_408;

+  undefined4 local_400;

+  ushort *local_3f8;

+  longlong local_3f0;

+  longlong local_3e8;

+  uint *local_3e0;

+  void *local_3d8;

+  uint local_3d0;

+  uint local_3cc;

+  undefined8 local_3c8;

+  ulonglong local_3c0;

+  longlong local_3b8;

+  longlong local_3b0;

+  void *local_3a8;

+  longlong local_3a0;

+  ulonglong *local_398;

+  void *local_390;

+  undefined8 local_388;

+  undefined8 uStack_380;

+  ulonglong local_378;

+  uint *local_370;

+  ulonglong local_368;

+  ulonglong local_358 [2];

+  undefined8 local_348;

+  undefined8 local_340;

+  ulonglong uStack_338;

+  uint auStack_330 [182];

+  uint local_58;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_558;

+  local_4e0 = param_2 & 0xffff;

+  local_368 = param_11;

+  local_3cc = param_10;

+  local_370 = param_9;

+  local_498 = param_14;

+  local_488 = param_5;

+  local_420 = param_11;

+  local_450 = param_12;

+  local_3b8 = param_13;

+  local_3f8 = param_16;

+  local_398 = param_17;

+  local_4dc = 0;

+  local_46c = 0;

+  local_4c0 = param_4;

+  local_460 = param_4;

+  local_428 = param_1;

+  local_3d0 = param_4;

+  memset(local_358,0,0x308);

+  local_4d8 = 0;

+  local_478 = (PSLIST_ENTRY_conflict)0x0;

+  local_410 = (PSLIST_ENTRY_conflict)0x0;

+  local_438 = (ushort *)0x0;

+  local_3b0 = 0;

+  local_3c0 = 0;

+  local_490 = param_15 & 0x100;

+  uVar15 = param_15 & 0x200;

+  lVar10 = PsGetCurrentServerSiloGlobals();

+  local_3a0 = *(longlong *)(lVar10 + 0x340);

+  uVar26 = 1;

+  local_430 = 0;

+  local_49c = 0;

+  if (param_10 < 0x81) {

+    if (local_498 == 0) {

+      local_498 = param_1;

+    }

+    if (local_3f8 == (ushort *)0x0) {

+      local_4a0 = 0;

+      local_4d0 = 0;

+      local_418 = (uint *)0x0;

+    }

+    else if (uVar15 == 0) {

+      local_4d0 = *local_3f8;

+      local_4a0 = (uint)local_4d0;

+      local_418 = (uint *)0x0;

+    }

+    else {

+      local_4a0 = 0;

+      local_4d0 = 0;

+      local_418 = (uint *)(local_3f8 + 3);

+    }

+    bVar23 = 0;

+    local_4f8 = 0;

+    local_468 = *(longlong *)(param_1 + 0x288);

+    if ((local_398 != (ulonglong *)0x0) && (*local_398 != 0)) {

+      bVar23 = 4;

+      local_4f8 = 4;

+      local_3c0 = *local_398;

+    }

+    local_3a8 = SystemReserved1[0xf];

+    if (local_450 == (void *)0x0) {

+      local_450 = SystemReserved1[0xf];

+    }

+    local_3f0 = local_468;

+    local_3e8 = local_498;

+    local_3d8 = local_450;

+    cVar6 = KeAreInterruptsEnabled();

+    local_4a8 = in_CR8;

+    if (cVar6 == '\0') {

+      local_4a8 = CONCAT71((int7)((ulonglong)in_R11 >> 8),0xf);

+    }

+    local_4ec = (byte)local_4a8;

+    local_4c8 = local_4ec == 0;

+    if ((bool)local_4c8) {

+      *(short *)((longlong)local_3a8 + 0x1e4) = *(short *)((longlong)local_3a8 + 0x1e4) + -1;

+    }

+    uVar17 = (ulonglong)CONCAT22((short)(local_4e0 >> 0x10),(ushort)local_4e0 & ~param_3);

+    psVar19 = local_488;

+    lVar10 = local_498;

+    uVar12 = local_4a8;

+    uVar25 = 0;

+    local_4d4 = local_4ec;

+    iVar8 = 0;

+LAB_0:

+    do {

+      while( true ) {

+        do {

+          cVar6 = (char)uVar25;

+          uVar16 = 0;

+          bVar32 = (uVar17 & 0xffff) == 0;

+          if (!bVar32) {

+            for (; (((uint)uVar17 & 0xffff) >> uVar16 & 1) == 0; uVar16 = uVar16 + 1) {

+            }

+          }

+          local_4d8 = uVar16;

+          if (bVar32) goto LAB_1;

+          local_388 = 0;

+          uStack_380 = 0;

+          local_378 = 0;

+          local_3c8 = 0;

+          local_4f4 = 0x50;

+          local_480 = (uint *)0x0;

+          local_458 = (uint *)0x0;

+          local_4cc = 0;

+          local_4c4 = 0;

+          local_408 = (ushort *)0x0;

+          local_390 = (void *)0x0;

+          local_4f0 = local_4f0 & 0xffffff00;

+          uVar26 = 1;

+          local_4b8 = 1;

+          local_448 = 1;

+          local_430 = 0;

+          local_4b0 = (ushort)uVar17 & (ushort)uVar17 - 1;

+          uVar17 = CONCAT62((int6)(uVar17 >> 0x10),local_4b0);

+          local_4e0 = (uint)uVar17;

+          piVar27 = (int *)(((ulonglong)uVar16 + 4) * 0x20 + lVar10);

+          uVar25 = local_4f0;

+        } while ((((((local_3b8 != 0) &&

+                    ((*(uint *)(local_3b8 + (ulonglong)(*(ushort *)((longlong)piVar27 + 6) >> 5) * 4

+                               ) >> (*(ushort *)((longlong)piVar27 + 6) & 0x8000001f) & 1) != 0)) ||

+                   (uVar11 = *(ulonglong *)(psVar19 + 4), *piVar27 == 0)) ||

+                  ((*(byte *)(piVar27 + 1) < *(byte *)(psVar19 + 2) && (*(byte *)(piVar27 + 1) != 0)

+                   ))) || ((((piVar27[2] & 0x40U) == 0 || (uVar11 != 0)) &&

+                           (((*(ulonglong *)(piVar27 + 4) & uVar11) == 0 ||

+                            ((*(ulonglong *)(piVar27 + 6) & uVar11) != *(ulonglong *)(piVar27 + 6)))

+                           )))) ||

+                ((((local_4c0 & 2) != 0 ||

+                  (*(int *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x1f0) < 0)) &&

+                 ((piVar27[2] & 0x200U) != 0))));

+        bVar32 = true;

+        if ((*(longlong *)(lVar10 + 0x280) == 0) ||

+           ((uVar25 = *(uint *)((ulonglong)uVar16 * 0x68 + *(longlong *)(lVar10 + 0x280)),

+            (uVar25 & 0x80000200) != 0x80000200 && ((uVar25 & 0x80000100) != 0x80000100)))) {

+          bVar32 = false;

+        }

+        if (!bVar32) break;

+        local_518 = (undefined1)uVar12;

+        local_520 = (short *)((ulonglong)local_520 & 0xffffffffffffff00);

+        local_528 = local_420;

+        local_530 = CONCAT44(local_530._4_4_,param_10);

+        local_538 = (code *)CONCAT62(local_538._2_6_,*psVar19);

+        cVar6 = EtwpApplyEventIdPayloadFilter(lVar10,uVar16,0,psVar19);

+        lVar10 = local_498;

+        uVar12 = local_4a8;

+        if (cVar6 != '\0') break;

+LAB_2:

+        uVar17 = (ulonglong)local_4e0;

+        lVar10 = local_498;

+        uVar25 = local_4f0;

+      }

+      if (local_490 != 0) {

+        local_530 = local_530 & 0xffffffffffffff00;

+        local_538 = *(code **)(psVar19 + 4);

+        cVar6 = EtwpIsEventNameFilterEnabled(lVar10,uVar16,uVar12 & 0xff,(char)psVar19[2]);

+        uVar12 = local_4a8;

+        if (cVar6 != '\0') {

+          local_518 = 0;

+          local_520 = *(short **)(psVar19 + 4);

+          local_528 = CONCAT71(local_528._1_7_,(char)psVar19[2]);

+          local_530 = CONCAT71(local_530._1_7_,(char)local_4a8);

+          local_538 = (code *)((ulonglong)local_538 & 0xffffffffffffff00);

+          cVar6 = EtwpApplyEventNameFilter(local_498,uVar16,param_10,local_420);

+          uVar12 = local_4a8;

+          if (cVar6 == '\0') goto LAB_2;

+        }

+      }

+      lVar10 = local_468;

+      uVar15 = *(ushort *)((longlong)piVar27 + 6);

+      local_440 = (uint *)(ulonglong)uVar15;

+      local_49c = (uint)uVar15;

+      if ((byte)uVar12 < 2) {

+        plVar1 = *(longlong **)(*(longlong *)(local_468 + 0x2c0) + (longlong)local_440 * 8);

+        puVar24 = (ulonglong *)

+                  ((ulonglong)

+                   ((SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)plVar1 + 0x14)) *

+                   (int)plVar1[2]) + *plVar1);

+        uVar17 = *puVar24;

+        do {

+          if ((uVar17 & 1) != 0) goto LAB_3;

+          LOCK();

+          uVar11 = *puVar24;

+          bVar32 = uVar17 == uVar11;

+          if (bVar32) {

+            *puVar24 = uVar17 + 2;

+            uVar11 = uVar17;

+          }

+          UNLOCK();

+          uVar17 = uVar11;

+        } while (!bVar32);

+        if ((uint)uVar15 < *(uint *)(local_468 + 0x10)) {

+          uVar26 = *(ulonglong *)(*(longlong *)(local_468 + 0x2c8) + (longlong)local_440 * 8);

+        }

+        local_4f0 = CONCAT31(local_4f0._1_3_,1);

+        local_4b8 = uVar26;

+        local_448 = uVar26;

+      }

+      else {

+        local_4b8 = uVar26;

+        local_448 = uVar26;

+        if ((uint)uVar15 < *(uint *)(local_468 + 0x10)) {

+          uVar26 = *(ulonglong *)(*(longlong *)(local_468 + 0x2c8) + (longlong)local_440 * 8);

+          local_4b8 = uVar26;

+          local_448 = uVar26;

+        }

+      }

+LAB_3:

+      uVar25 = local_4f0;

+      local_470 = local_49c;

+      if ((uVar26 & 1) != 0) {

+        if ((char)local_4f0 != '\0') {

+          ExReleaseRundownProtectionCacheAwareEx

+                    (*(undefined8 *)(*(longlong *)(local_468 + 0x2c0) + (longlong)local_440 * 8),1);

+          iVar7 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          uVar12 = local_4a8;

+          local_4f0 = uVar25 & 0xff;

+          if (iVar7 != 0) {

+            local_4f0 = 0;

+          }

+        }

+        if (local_49c != 3) goto LAB_2;

+        local_4dc = -0x3ffffff8;

+        uVar25 = local_4e0;

+        if (*(int *)(lVar10 + 0x10f4) != 0) {

+          local_4dc = -0x3ffffd02;

+        }

+LAB_4:

+        uVar17 = (ulonglong)uVar25;

+        goto LAB_5;

+      }

+      uVar16 = -(uint)(local_370 != (uint *)0x0) & 0x10;

+      uVar25 = 0x68;

+      if (local_370 == (uint *)0x0) {

+        uVar25 = 0x50;

+      }

+      uVar31 = local_4d8;

+      local_4e8 = uVar25;

+      if ((piVar27[2] & 0xffffff9fU) != 0) {

+        if ((((EtwpPagingDisabled != '\0') || ((local_4c0 & 1) != 0)) ||

+            (iVar8 = MmCanThreadFault(), iVar8 == 0)) ||

+           (uVar31 = 0x100, *(char *)((longlong)local_3a8 + 0x5ae) != '\0')) {

+          uVar31 = 0;

+        }

+        pvVar4 = FiberData;

+        uVar16 = uVar16 | uVar31;

+        local_4e8 = uVar25;

+        if (((((uint)piVar27[2] >> 0xb & 1) != 0) && (local_3a0 != 0)) &&

+           (local_3a0 != EtwpHostSiloState)) {

+          uVar16 = uVar16 | 0x200;

+          local_4e8 = (*(ushort *)(local_3a0 + 0x1190) + 0xf & 0xfffffff8) + uVar25;

+        }

+        uVar25 = local_4e8;

+        if (((piVar27[2] & 1U) != 0) && ((uVar16 >> 8 & 1) != 0)) {

+          if (local_478 == (PSLIST_ENTRY_conflict)0x0) {

+            p_Var2 = *(PSLIST_HEADER *)((longlong)FiberData + 0x880);

+            *(int *)((longlong)p_Var2 + 0x14) = *(int *)((longlong)p_Var2 + 0x14) + 1;

+            local_478 = ExpInterlockedPopEntrySList(p_Var2);

+            if (local_478 == (PSLIST_ENTRY_conflict)0x0) {

+              *(int *)((longlong)p_Var2 + 0x18) = *(int *)((longlong)p_Var2 + 0x18) + 1;

+              p_Var2 = *(PSLIST_HEADER *)((longlong)pvVar4 + 0x888);

+              *(int *)((longlong)p_Var2 + 0x14) = *(int *)((longlong)p_Var2 + 0x14) + 1;

+              local_478 = ExpInterlockedPopEntrySList(p_Var2);

+              if (local_478 == (PSLIST_ENTRY_conflict)0x0) {

+                *(int *)((longlong)p_Var2 + 0x18) = *(int *)((longlong)p_Var2 + 0x18) + 1;

+                local_478 = (PSLIST_ENTRY_conflict)

+                            (*(code *)p_Var2[3].s.Alignment)

+                                      (*(undefined4 *)((longlong)p_Var2 + 0x24),

+                                       *(undefined4 *)((longlong)p_Var2 + 0x2c),

+                                       *(undefined4 *)((longlong)p_Var2 + 0x28));

+              }

+            }

+            local_410 = local_478;

+            if (local_478 != (PSLIST_ENTRY_conflict)0x0) {

+              *(undefined4 *)&local_478->Next = *(undefined4 *)((longlong)pvVar4 + 0x24);

+              EtwpGetSidExtendedHeaderItem();

+              if (local_478 != (PSLIST_ENTRY_conflict)0x0) goto LAB_6;

+            }

+          }

+          else {

+LAB_6:

+            uVar16 = uVar16 | 2;

+            local_4e8 = uVar25 + *(ushort *)&local_478->Next;

+            uVar25 = local_4e8;

+          }

+        }

+        uVar29 = piVar27[2];

+        if ((uVar29 & 2) != 0) {

+          uVar16 = uVar16 | 1;

+          local_4e8 = uVar25 + 0x10;

+          uVar25 = local_4e8;

+        }

+        if (((char)uVar29 < '\0') &&

+           (((cVar6 = KeAreInterruptsEnabled(), cVar6 != '\0' && ((byte)in_CR8 < 2)) ||

+            (*(char *)((longlong)FiberData + 0x20) == '\0')))) {

+          uVar16 = uVar16 | 0x40;

+          local_4e8 = uVar25 + 0x10;

+          uVar25 = local_4e8;

+        }

+        psVar19 = local_488;

+        lVar10 = local_498;

+        bVar22 = local_4d4;

+        uVar31 = local_4d8;

+        if ((uVar29 >> 8 & 1) != 0) {

+          uVar16 = uVar16 | 0x80;

+          local_4e8 = uVar25 + 0x10;

+          uVar25 = local_4e8;

+        }

+        if (((uVar29 & 4) != 0) && (EtwpPagingDisabled == '\0')) {

+          if ((*(longlong *)(local_498 + 0x280) == 0) ||

+             (((uVar29 = *(uint *)((ulonglong)local_4d8 * 0x68 + *(longlong *)(local_498 + 0x280)),

+               (uVar29 & 0x80001000) != 0x80001000 && ((uVar29 & 0x80002000) != 0x80002000)) &&

+              ((uVar29 & 0x80004000) != 0x80004000)))) {

+            bVar32 = false;

+          }

+          else {

+            bVar32 = true;

+          }

+          if (bVar32) {

+            local_538 = (code *)CONCAT71(local_538._1_7_,local_4d4 < 2);

+            cVar6 = EtwpApplyLevelKwFilter

+                              (local_498,local_4d8,(char)local_488[2],*(undefined8 *)(local_488 + 4)

+                              );

+            if ((cVar6 != '\0') &&

+               (cVar6 = EtwpApplyStackWalkIdFilter(*psVar19,lVar10,uVar31,bVar22 < 2), cVar6 != '\0'

+               )) {

+              local_518 = 1;

+              local_520 = *(short **)(psVar19 + 4);

+              local_528 = CONCAT71(local_528._1_7_,(char)psVar19[2]);

+              local_530 = CONCAT71(local_530._1_7_,(char)local_4a8);

+              local_538 = (code *)((ulonglong)local_538 & 0xffffffffffffff00);

+              cVar6 = EtwpApplyEventNameFilter(lVar10,uVar31,param_10,local_420);

+              if (cVar6 != '\0') goto LAB_7;

+            }

+          }

+          else {

+LAB_7:

+            if ((bVar23 & 1) == 0) {

+              lVar10 = EtwpGetStackLookasideListEntry();

+              bVar22 = bVar23;

+              local_3b0 = lVar10;

+              if (lVar10 != 0) {

+                local_438 = (ushort *)(lVar10 + 0x20);

+                bVar22 = bVar23 | 2;

+                bVar32 = (*(uint *)(local_4b8 + 0x330) & 0x40000000) == 0;

+                local_530 = 0;

+                if (((*(longlong *)(local_428 + 0x28) == 0x4648bdb6b675ec37) &&

+                    (local_530 = 0, *(longlong *)(local_428 + 0x30) == -0x5dc3b238020c6d44)) &&

+                   (*psVar19 == 0x12)) {

+                  uVar16 = uVar16 | 0x20;

+                  local_530 = local_428 + 0x50;

+                  bVar32 = false;

+                }

+                local_538 = (code *)CONCAT71(local_538._1_7_,bVar32);

+                cVar6 = EtwpGetStackExtendedHeaderItem(local_4b8,local_450,local_4c0,lVar10);

+                if (cVar6 == '\0') {

+                  EtwpReleaseStackLookasideListEntry(lVar10);

+                  bVar22 = bVar23 & 0xfd;

+                  local_438 = (ushort *)0x0;

+                }

+              }

+              bVar23 = bVar22 | 1;

+              local_4f8 = bVar23;

+            }

+            puVar14 = local_438;

+            if (local_438 != (ushort *)0x0) {

+              if (((*(uint *)(local_4b8 + 0x334) & 1) == 0) ||

+                 (cVar6 = EtwpGetCrimsonStackKey(local_4b8,local_438,&local_430), cVar6 == '\0')) {

+                uVar16 = uVar16 | 4;

+                uVar25 = uVar25 + *puVar14;

+                local_4e8 = uVar25;

+              }

+              else {

+                uVar16 = uVar16 | 8;

+                uVar25 = uVar25 + 0x18;

+                local_4e8 = uVar25;

+              }

+            }

+          }

+        }

+      }

+      uVar12 = (ulonglong)local_58;

+      uVar29 = 0;

+      if (param_10 != 0) {

+        puVar20 = (uint *)(local_420 + 8);

+        do {

+          iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          if ((iVar8 != 0) && (0xffff < *puVar20)) {

+            if (-1 < local_4dc) {

+              local_4dc = -0x7ffffffb;

+            }

+            goto LAB_8;

+          }

+          if (local_490 == 0) {

+            cVar6 = '\0';

+          }

+          else {

+            cVar6 = (char)puVar20[1];

+          }

+          if (cVar6 == '\0') {

+            local_4e8 = uVar25 + *puVar20;

+            uVar25 = local_4e8;

+          }

+          else if (cVar6 == '\x01') {

+            iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+            if (iVar8 == 0) {

+              local_4cc = local_4cc + (ushort)*puVar20;

+              local_4c4 = local_4c4 + 1;

+            }

+            else {

+              local_4cc = local_4cc + *puVar20;

+              local_4c4 = local_4c4 + 1;

+            }

+          }

+          else if (((cVar6 == '\x04') &&

+                   (iVar8 = Feature_ModernWpp__private_IsEnabledDeviceUsageNoInline(), iVar8 != 0))

+                  && (*puVar20 == 0x10)) {

+            local_418 = *(uint **)(puVar20 + -2);

+          }

+          uVar29 = uVar29 + 1;

+          puVar20 = puVar20 + 4;

+        } while (uVar29 < param_10);

+      }

+      iVar8 = local_4c4;

+      if (local_4c4 != 0) {

+        iVar7 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) {

+          uVar29 = local_4cc + 0xf & 0xfffffff8;

+LAB_9:

+          uVar25 = uVar25 + uVar29;

+          local_4e8 = uVar25;

+          goto LAB_10;

+        }

+        uVar29 = local_4cc + 0xf & 0xfffffff8;

+        if (uVar29 < 0x10000) goto LAB_9;

+LAB_11:

+        if (-1 < local_4dc) {

+          local_4dc = -0x3fffff6b;

+        }

+LAB_8:

+        uVar26 = local_4b8;

+        uVar25 = local_4e0 & 0xffff | 1 << (uVar31 & 0x1f);

+        goto LAB_4;

+      }

+LAB_10:

+      uVar29 = local_4a0;

+      if ((short)local_4a0 != 0) {

+        iVar7 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        if (iVar7 == 0) {

+          uVar29 = (uVar29 & 0xffff) + 0xf & 0xfffffff8;

+        }

+        else {

+          uVar29 = (uVar29 & 0xffff) + 0xf & 0xfffffff8;

+          if (0xffff < uVar29) goto LAB_11;

+        }

+        uVar25 = uVar25 + uVar29;

+        local_4e8 = uVar25;

+      }

+      auStack_330[uVar12 * 0xc] = uVar25;

+      iVar7 = Feature_Servicing_EtwLostEventsFlags__private_IsEnabledDeviceUsageNoInline();

+      uVar31 = local_3d0;

+      if (iVar7 != 0) {

+        uVar31 = 0;

+        if ((local_4c0 & 4) != 0) {

+          uVar31 = 0x200;

+        }

+        if ((local_4c0 & 8) != 0) {

+          uVar31 = 0x600;

+        }

+      }

+      local_538 = (code *)CONCAT44(local_538._4_4_,uVar31);

+      puVar20 = (uint *)EtwpReserveTraceBuffer(local_4b8,uVar25,&local_388,&local_3c8);

+      uVar26 = local_430;

+      local_430 = uVar26;

+      local_3e0 = puVar20;

+      if (local_430 != 0) {

+        EtwpDereferenceStackEntry(local_430);

+        iVar7 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        local_430 = uVar26;

+        if (iVar7 != 0) {

+          local_430 = 0;

+        }

+      }

+      uVar26 = local_4b8;

+      if (puVar20 != (uint *)0x0) {

+        local_358[uVar12 * 6] = local_4b8;

+        local_358[uVar12 * 6 + 1] = (ulonglong)puVar20;

+        *(undefined4 *)((longlong)&local_348 + uVar12 * 0x30) = (undefined4)local_388;

+        *(undefined4 *)((longlong)&local_348 + uVar12 * 0x30 + 4) = local_388._4_4_;

+        *(undefined4 *)(&local_340 + uVar12 * 6) = (undefined4)uStack_380;

+        *(undefined4 *)((longlong)&local_340 + uVar12 * 0x30 + 4) = uStack_380._4_4_;

+        (&uStack_338)[uVar12 * 6] = local_378;

+        local_58 = local_58 + 1;

+        iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        uVar25 = local_4e8;

+        local_4f0 = local_4f0 & 0xff;

+        if (iVar8 != 0) {

+          local_4f0 = 0;

+        }

+        local_4e4 = (undefined1)local_4f0;

+        *puVar20 = local_4e8 | 0xc0130000;

+        *(ushort *)(puVar20 + 1) = param_6;

+        *(undefined2 *)((longlong)puVar20 + 6) = param_7;

+        uVar3 = *(undefined8 *)(local_488 + 4);

+        *(undefined8 *)(puVar20 + 10) = *(undefined8 *)local_488;

+        *(undefined8 *)(puVar20 + 0xc) = uVar3;

+        if (local_418 == (uint *)0x0) {

+          uVar31 = *(uint *)(local_428 + 0x28);

+          uVar29 = *(uint *)(local_428 + 0x2c);

+          uVar33 = *(uint *)(local_428 + 0x30);

+          uVar34 = *(uint *)(local_428 + 0x34);

+        }

+        else {

+          uVar31 = *local_418;

+          uVar29 = local_418[1];

+          uVar33 = local_418[2];

+          uVar34 = local_418[3];

+          *(ushort *)(puVar20 + 1) = param_6 | 0x80;

+        }

+        puVar20[6] = uVar31;

+        puVar20[7] = uVar29;

+        puVar20[8] = uVar33;

+        puVar20[9] = uVar34;

+        if (param_8 == (uint *)0x0) {

+          uVar31 = 0;

+          uVar29 = 0;

+          uVar33 = 0;

+          uVar34 = 0;

+        }

+        else {

+          uVar31 = *param_8;

+          uVar29 = param_8[1];

+          uVar33 = param_8[2];

+          uVar34 = param_8[3];

+        }

+        puVar20[0x10] = uVar31;

+        puVar20[0x11] = uVar29;

+        puVar20[0x12] = uVar33;

+        puVar20[0x13] = uVar34;

+        *(undefined8 *)(puVar20 + 4) = local_3c8;

+        puVar20[2] = *(uint *)((longlong)local_450 + 0x510);

+        puVar20[3] = *(uint *)((longlong)local_450 + 0x508);

+        puVar20[0xe] = *(uint *)((longlong)local_450 + 0x28c);

+        puVar20[0xf] = *(uint *)((longlong)local_450 + 0x2dc);

+        iVar8 = Feature_ModernWpp__private_IsEnabledDeviceUsageNoInline();

+        lVar10 = local_3a0;

+        if ((iVar8 != 0) && ((param_15 & 0x400) != 0)) {

+          *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 0x400;

+        }

+        if (uVar16 == 0) {

+          uVar12 = (ulonglong)local_4f4;

+          puVar30 = local_480;

+        }

+        else {

+          if (uVar16 >> 9 != 0) {

+            local_480 = puVar20 + 0x14;

+            uVar28 = *(short *)(local_3a0 + 0x1190) + 0xfU & 0xfff8;

+            *(ushort *)local_480 = uVar28;

+            *(undefined2 *)((longlong)puVar20 + 0x52) = 0x10;

+            *(undefined2 *)((longlong)puVar20 + 0x56) = *(undefined2 *)(local_3a0 + 0x1190);

+            *(undefined2 *)(puVar20 + 0x15) = 0;

+            uVar15 = *(ushort *)(local_3a0 + 0x1190);

+            RtlCopyMemory(puVar20 + 0x16,*(void **)(local_3a0 + 0x1188),(ulonglong)uVar15);

+            memset((void *)((ulonglong)*(ushort *)(lVar10 + 0x1190) + (longlong)(puVar20 + 0x16)),0,

+                   (ulonglong)(ushort)((uVar28 - uVar15) - 8));

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = (ushort)*local_480 + 0x50;

+            local_458 = local_480;

+          }

+          uVar12 = (ulonglong)local_4f4;

+          puVar30 = local_480;

+          if ((uVar16 & 0x10) != 0) {

+            local_458 = (uint *)(uVar12 + (longlong)puVar20);

+            *local_458 = 0x10018;

+            local_458[1] = 0x100000;

+            uVar31 = param_9[1];

+            uVar29 = param_9[2];

+            uVar33 = param_9[3];

+            local_458[2] = *param_9;

+            local_458[3] = uVar31;

+            local_458[4] = uVar29;

+            local_458[5] = uVar33;

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = local_4f4 + 0x18;

+            uVar12 = (ulonglong)local_4f4;

+            puVar30 = local_458;

+            if (local_480 != (uint *)0x0) {

+              *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+            }

+          }

+          local_480 = puVar30;

+          puVar30 = local_480;

+          if ((uVar16 & 2) != 0) {

+            puVar21 = (uint *)(uVar12 + (longlong)puVar20);

+            RtlCopyMemory(puVar21,local_478,(ulonglong)*(ushort *)&local_478->Next);

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = local_4f4 + *(ushort *)&local_478->Next;

+            uVar12 = (ulonglong)local_4f4;

+            local_480 = puVar21;

+            local_458 = puVar21;

+            if (puVar30 != (uint *)0x0) {

+              puVar30 = puVar30 + 1;

+              *(ushort *)puVar30 = (ushort)*puVar30 | 1;

+            }

+          }

+          puVar30 = local_480;

+          if ((uVar16 & 1) != 0) {

+            local_458 = (uint *)(uVar12 + (longlong)puVar20);

+            *local_458 = 0x30010;

+            local_458[1] = 0x40000;

+            lVar10 = *(longlong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x2e8);

+            if (((lVar10 == 0) ||

+                ((*(uint *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x5fc) & 0x1000)

+                 != 0)) || (uVar31 = *(uint *)(lVar10 + 8), uVar31 == 0xffffffff)) {

+              uVar31 = 0;

+            }

+            local_458[2] = uVar31;

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = (int)uVar12 + 0x10;

+            uVar12 = (ulonglong)local_4f4;

+            puVar30 = local_458;

+            if (local_480 != (uint *)0x0) {

+              *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+            }

+          }

+          local_480 = puVar30;

+          puVar30 = local_480;

+          if ((uVar16 & 0x40) != 0) {

+            local_458 = (uint *)(uVar12 + (longlong)puVar20);

+            *local_458 = 0xd0010;

+            local_458[1] = 0x80000;

+            *(ulonglong *)(local_458 + 2) =

+                 (ulonglong)_DAT_12 << 0x30 |

+                 *(ulonglong *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x678);

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = (int)uVar12 + 0x10;

+            uVar12 = (ulonglong)local_4f4;

+            puVar30 = local_458;

+            if (local_480 != (uint *)0x0) {

+              *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+            }

+          }

+          local_480 = puVar30;

+          if ((char)uVar16 < '\0') {

+            local_458 = (uint *)(uVar12 + (longlong)puVar20);

+            *local_458 = 0xa0010;

+            local_458[1] = 0x80000;

+            pvVar4 = FiberData;

+            if ((bVar23 & 4) == 0) {

+              LOCK();

+              plVar1 = (longlong *)(*(longlong *)((longlong)FiberData + 0x8ba8) + 8);

+              lVar10 = *plVar1;

+              *plVar1 = *plVar1 + 1;

+              UNLOCK();

+              local_3c0 = (ulonglong)*(uint *)((longlong)pvVar4 + 0x24) << 0x30 |

+                          lVar10 + 1U & 0xffffffffffff;

+              bVar23 = bVar23 | 4;

+              local_4f8 = bVar23;

+              if (local_398 != (ulonglong *)0x0) {

+                *local_398 = local_3c0;

+              }

+            }

+            *(ulonglong *)(local_458 + 2) = local_3c0;

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = local_4f4 + 0x10;

+            if (local_480 != (uint *)0x0) {

+              *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+            }

+            uVar12 = (ulonglong)local_4f4;

+            local_480 = local_458;

+          }

+          puVar30 = local_480;

+          if ((uVar16 & 4) != 0) {

+            puVar21 = (uint *)(uVar12 + (longlong)puVar20);

+            RtlCopyMemory(puVar21,local_438,(ulonglong)*local_438);

+            uVar26 = *(ulonglong *)(puVar21 + 2);

+            if ((uVar26 != 0) && ((uVar16 & 0x20) == 0)) {

+              if ((*(uint *)((longlong)local_450 + 0x78) >> 0x17 & 1) == 0) {

+                local_520 = (short *)(uVar26 & 0xffffffff);

+                local_530 = 1;

+                local_538 = EtwpCancelStackWalkApc;

+                local_528 = uVar26 >> 0x20;

+                iVar8 = EtwpQueueApc(local_4b8 + 0x340,local_450,local_4a8 & 0xff,EtwpStackWalkApc);

+                if (-1 < iVar8) goto LAB_13;

+              }

+              puVar21[2] = 0;

+              puVar21[3] = 0;

+            }

+LAB_13:

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = local_4f4 + *local_438;

+            uVar12 = (ulonglong)local_4f4;

+            local_480 = puVar21;

+            local_458 = puVar21;

+            if (puVar30 != (uint *)0x0) {

+              puVar30 = puVar30 + 1;

+              *(ushort *)puVar30 = (ushort)*puVar30 | 1;

+            }

+          }

+          puVar30 = local_480;

+          if ((uVar16 & 8) != 0) {

+            local_458 = (uint *)(uVar12 + (longlong)puVar20);

+            *local_458 = 0x120018;

+            local_458[1] = 0x100000;

+            *(ulonglong *)(local_458 + 4) = local_430;

+            *(undefined8 *)(local_458 + 2) = *(undefined8 *)(local_438 + 4);

+            *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+            local_4f4 = (int)uVar12 + 0x18;

+            uVar12 = (ulonglong)local_4f4;

+            puVar30 = local_458;

+            if (local_480 != (uint *)0x0) {

+              *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+            }

+          }

+        }

+        local_480 = puVar30;

+        uVar15 = (ushort)local_4a0;

+        puVar30 = local_480;

+        if (uVar15 != 0) {

+          puVar30 = (uint *)(uVar12 + (longlong)puVar20);

+          uVar28 = uVar15 + 0xf & 0xfff8;

+          *(ushort *)puVar30 = uVar28;

+          ((ushort *)((longlong)puVar30 + 2))[0] = 0xc;

+          ((ushort *)((longlong)puVar30 + 2))[1] = 0;

+          *(ushort *)((longlong)puVar30 + 6) = uVar15;

+          uVar15 = (uVar28 - uVar15) - 8;

+          local_4d8 = CONCAT22(local_4d8._2_2_,uVar15);

+          uVar16 = local_4a0 & 0xffff;

+          local_440 = puVar30;

+          RtlCopyMemory(puVar30 + 2,local_3f8,(ulonglong)uVar16);

+          memset((void *)((longlong)(puVar30 + 2) + (ulonglong)uVar16),0,(ulonglong)uVar15);

+          *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+          local_4f4 = local_4f4 + (ushort)*puVar30;

+          uVar12 = (ulonglong)local_4f4;

+          if (local_480 != (uint *)0x0) {

+            *(ushort *)(local_480 + 1) = (ushort)local_480[1] | 1;

+          }

+        }

+        uVar17 = 0;

+        puVar14 = local_408;

+        iVar8 = local_4c4;

+        if (local_4c4 != 0) {

+          puVar18 = (ushort *)(uVar12 + (longlong)puVar20);

+          uVar15 = (ushort)(local_4cc + 0xf) & 0xfff8;

+          *puVar18 = uVar15;

+          puVar18[1] = 0xb;

+          puVar18[2] = 0;

+          puVar18[3] = (ushort)local_4cc;

+          puVar14 = puVar18 + 4;

+          local_390 = (void *)((longlong)puVar14 + (ulonglong)local_4cc);

+          local_408 = puVar14;

+          memset(local_390,0,(ulonglong)(ushort)((uVar15 - (ushort)local_4cc) - 8));

+          *(ushort *)(puVar20 + 1) = (ushort)puVar20[1] | 1;

+          local_4f4 = local_4f4 + *puVar18;

+          uVar12 = (ulonglong)local_4f4;

+          iVar8 = local_4c4;

+          if (puVar30 != (uint *)0x0) {

+            *(ushort *)(puVar30 + 1) = (ushort)puVar30[1] | 1;

+          }

+        }

+        while (uVar26 = local_4b8, uVar16 = (uint)uVar17, local_4cc = uVar16, uVar16 < param_10) {

+          uVar31 = *(uint *)(local_420 + 8 + uVar17 * 0x10);

+          uVar26 = (ulonglong)uVar31;

+          _Src = *(undefined8 **)(local_420 + uVar17 * 0x10);

+          if (local_490 == 0) {

+            cVar6 = '\0';

+          }

+          else {

+            cVar6 = *(char *)(local_420 + 0xc + uVar17 * 0x10);

+          }

+          local_4d8 = uVar31;

+          if (cVar6 == '\0') {

+            local_440 = (uint *)(uVar12 + (longlong)puVar20);

+            local_4f4 = (int)uVar12 + uVar31;

+            if (uVar25 < local_4f4) {

+              local_538 = (code *)0x0;

+                    /* WARNING: Subroutine does not return */

+              KeBugCheckEx(0x11d,5,local_4f4,uVar25);

+            }

+            RtlCopyMemory(local_440,_Src,uVar26);

+            uVar12 = (ulonglong)local_4f4;

+            iVar8 = local_4c4;

+LAB_14:

+            uVar17 = (ulonglong)(uVar16 + 1);

+            puVar14 = local_408;

+          }

+          else {

+            if (cVar6 != '\x01') {

+              if ((cVar6 == '\x03') && (uVar31 == 8)) {

+                *(undefined8 *)(puVar20 + 4) = *_Src;

+              }

+              goto LAB_14;

+            }

+            if (((puVar14 == (ushort *)0x0) || (local_390 < (void *)(uVar26 + (longlong)puVar14)))

+               || (iVar8 == 0)) {

+              local_538 = (code *)0x0;

+                    /* WARNING: Subroutine does not return */

+              KeBugCheckEx(0x11d,5,local_4f4,uVar25);

+            }

+            RtlCopyMemory(puVar14,_Src,uVar26);

+            uVar12 = (ulonglong)local_4f4;

+            local_408 = (ushort *)((longlong)puVar14 + (ulonglong)uVar31);

+            local_4c4 = local_4c4 + -1;

+            uVar17 = (ulonglong)(uVar16 + 1);

+            puVar14 = local_408;

+            iVar8 = local_4c4;

+          }

+        }

+        if (((*(uint *)(local_4b8 + 0xc) & 0x80000) != 0) &&

+           (((KdDebuggerNotPresent == '\0' && (KdPitchDebugger == '\0')) ||

+            (KdEventLoggingPresent != '\0')))) {

+          EtwpSendTraceEvent(local_4b8,&local_388);

+        }

+        lVar5 = local_388;

+        lVar10 = *(longlong *)(uVar26 + 0x610);

+        if (lVar10 != 0) {

+          local_400 = 0;

+          uVar12 = local_378;

+          iVar8 = EtwpGetNextEventOffsetType(local_388,local_378 & 0xffffffff);

+          if ((iVar8 != 0) && ((KiDynamicTraceEnabled & 2) != 0)) {

+            local_538 = *(code **)(lVar10 + 8);

+            (*DAT_15)((uVar12 & 0xffffffff) + lVar5,local_400,local_428 + 0x28,0);

+          }

+        }

+        uVar17 = (ulonglong)local_4e0;

+        psVar19 = local_488;

+        lVar10 = local_498;

+        uVar12 = local_4a8;

+        uVar25 = local_4f0;

+        iVar8 = local_4dc;

+        if (local_3b8 != 0) {

+          puVar20 = (uint *)(local_3b8 + (ulonglong)(local_49c >> 5) * 4);

+          *puVar20 = *puVar20 | 1 << (local_49c & 0x1f);

+        }

+        goto LAB_0;

+      }

+      if (local_4e8 < 0xfff9) {

+        iVar7 = -0x3fffffe9;

+        if (*(uint *)(local_4b8 + 8) < local_4e8) {

+          iVar7 = -0x7ffffffb;

+        }

+      }

+      else {

+        iVar7 = -0x3fffff6b;

+      }

+      uVar25 = local_3cc;

+      uVar12 = local_368;

+      if (iVar8 == 0) {

+        uVar25 = 0;

+        uVar12 = 0;

+      }

+      psVar19 = local_488;

+      if ((EtwpEventTracingProvRegHandle != 0) &&

+         (((lVar10 = *(longlong *)(EtwpEventTracingProvRegHandle + 0x20),

+           *(int *)(lVar10 + 0x60) != 0 &&

+           ((((1 < *(byte *)(lVar10 + 100) || (*(byte *)(lVar10 + 100) == 0)) &&

+             ((*(byte *)(lVar10 + 0x70) & 0x40) != 0)) &&

+            ((ulonglong)((uint)*(ulonglong *)(lVar10 + 0x78) & 0x40) ==

+             *(ulonglong *)(lVar10 + 0x78))))) ||

+          ((*(short *)(EtwpEventTracingProvRegHandle + 0x66) != 0 &&

+           (cVar6 = EtwpLevelKeywordEnabled

+                              (*(longlong *)(EtwpEventTracingProvRegHandle + 0x28) + 0x60,2),

+           psVar19 = local_488, cVar6 != '\0')))))) {

+        psVar19 = local_488;

+        local_518 = 0;

+        local_520 = (short *)CONCAT71(local_520._1_7_,local_4d4 < 2);

+        local_530 = CONCAT44(local_530._4_4_,uVar25);

+        local_538 = (code *)CONCAT44(local_538._4_4_,iVar7);

+        local_528 = uVar12;

+        EtwpTraceLostEvent(local_428 + 0x28,local_488,uVar26 + 0x88,local_4c0);

+      }

+      if ((-1 < local_4dc) && (local_46c = local_4dc, (*(uint *)(uVar26 + 0xc) & 0x8000000) == 0)) {

+        local_4dc = iVar7;

+        local_46c = iVar7;

+      }

+      iVar8 = local_4dc;

+      cVar6 = (char)local_4f0;

+      if (cVar6 != '\0') {

+        ExReleaseRundownProtectionCacheAwareEx

+                  (*(undefined8 *)(*(longlong *)(local_468 + 0x2c0) + (longlong)local_440 * 8),1);

+        iVar9 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        if (iVar9 != 0) {

+          cVar6 = '\0';

+        }

+        local_4f0 = CONCAT31(local_4f0._1_3_,cVar6);

+      }

+      uVar17 = (ulonglong)local_4e0;

+      lVar10 = local_498;

+      uVar12 = local_4a8;

+      uVar25 = local_4f0;

+    } while (iVar7 != -0x3fffff6b);

+    local_4dc = -0x3fffff6b;

+LAB_5:

+    cVar6 = (char)local_4f0;

+    iVar8 = local_4dc;

+LAB_1:

+    uVar12 = 0;

+    iVar7 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+    lVar10 = local_468;

+    if (iVar7 != 0) {

+      if (local_430 != 0) {

+        EtwpDereferenceStackEntry(local_430,*(undefined8 *)(uVar26 + 0x420));

+      }

+      lVar10 = local_468;

+      if (cVar6 != '\0') {

+        ExReleaseRundownProtectionCacheAwareEx

+                  (*(undefined8 *)(*(longlong *)(local_468 + 0x2c0) + (ulonglong)local_49c * 8),1);

+      }

+    }

+    if ((bVar23 & 2) != 0) {

+      EtwpReleaseStackLookasideListEntry(local_3b0);

+    }

+    uVar26 = local_4a8;

+    if (iVar8 < 0) {

+      local_518 = local_4d4 < 2;

+      local_500 = 0;

+      local_508 = local_420;

+      local_510 = param_10;

+      local_520 = local_488;

+      local_528 = CONCAT44(local_528._4_4_,iVar8);

+      local_530 = CONCAT44(local_530._4_4_,local_4c0);

+      local_538 = (code *)CONCAT62(local_538._2_6_,(short)uVar17);

+      EtwpFailLogging((char)local_488[2],*(undefined8 *)(local_488 + 4),local_428,local_358);

+    }

+    else {

+      local_4d8 = 0;

+      if (local_58 != 0) {

+        do {

+          uVar17 = *(ulonglong *)((longlong)&local_348 + uVar12 * 0x30);

+          puVar24 = (ulonglong *)(&local_340)[uVar12 * 6];

+          uVar11 = *puVar24;

+          do {

+            if (0xe < (uVar11 ^ uVar17)) {

+              LOCK();

+              *(int *)(*(longlong *)((longlong)&local_348 + uVar12 * 0x30) + 0xc) =

+                   *(int *)(*(longlong *)((longlong)&local_348 + uVar12 * 0x30) + 0xc) + -1;

+              UNLOCK();

+              break;

+            }

+            LOCK();

+            uVar13 = *puVar24;

+            bVar32 = uVar11 == uVar13;

+            if (bVar32) {

+              *puVar24 = uVar11 + 1;

+              uVar13 = uVar11;

+            }

+            UNLOCK();

+            uVar11 = uVar13;

+          } while (!bVar32);

+          if ((byte)uVar26 < 2) {

+            ExReleaseRundownProtectionCacheAwareEx

+                      (*(undefined8 *)

+                        (*(longlong *)(lVar10 + 0x2c0) +

+                        (ulonglong)*(uint *)local_358[uVar12 * 6] * 8),1);

+          }

+          local_4d8 = local_4d8 + 1;

+          uVar12 = (ulonglong)local_4d8;

+          iVar8 = local_4dc;

+        } while (local_4d8 < local_58);

+      }

+    }

+    if (local_4c8 != '\0') {

+      psVar19 = (short *)((longlong)local_3a8 + 0x1e4);

+      *psVar19 = *psVar19 + 1;

+      if (((*psVar19 == 0) &&

+          (*(longlong **)((longlong)local_3a8 + 0x98) != (longlong *)((longlong)local_3a8 + 0x98)))

+         && (*(short *)((longlong)local_3a8 + 0x1e6) == 0)) {

+        KiCheckForKernelApcDelivery();

+      }

+    }

+    pvVar4 = FiberData;

+    if (local_478 != (PSLIST_ENTRY_conflict)0x0) {

+      puVar14 = *(ushort **)((longlong)FiberData + 0x880);

+      *(int *)(puVar14 + 0xe) = *(int *)(puVar14 + 0xe) + 1;

+      if (puVar14[8] <= *puVar14) {

+        *(int *)(puVar14 + 0x10) = *(int *)(puVar14 + 0x10) + 1;

+        puVar14 = *(ushort **)((longlong)pvVar4 + 0x888);

+        *(int *)(puVar14 + 0xe) = *(int *)(puVar14 + 0xe) + 1;

+        if (puVar14[8] <= *puVar14) {

+          *(int *)(puVar14 + 0x10) = *(int *)(puVar14 + 0x10) + 1;

+          (**(code **)(puVar14 + 0x1c))(local_478);

+          return iVar8;

+        }

+      }

+      ExpInterlockedPushEntrySList(puVar14,local_478);

+    }

+  }

+  else {

+    iVar8 = -0x3ffffff3;

+  }

+  return iVar8;

 }
```

## `PpmExitCoordinatedIdle`  (modified)

```diff
--- PpmExitCoordinatedIdle
+++ PpmExitCoordinatedIdle
@@ -1,13 +1,128 @@
 

-/* WARNING: Control flow encountered bad instruction data */

-

-void PpmExitCoordinatedIdle(char param_1)

+uint PpmExitCoordinatedIdle

+               (longlong param_1,longlong param_2,char param_3,int param_4,char param_5,

+               ulonglong param_6,int param_7,char param_8,undefined8 param_9,int param_10)

 

 {

-  longlong in_RAX;

+  uint uVar1;

+  int *piVar2;

+  uint *puVar3;

+  char cVar4;

+  int iVar5;

+  uint uVar6;

+  ulonglong uVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  int iVar11;

+  ulonglong uVar12;

+  uint uVar13;

+  char local_48;

+  char local_47;

+  undefined4 local_44;

+  uint local_40;

+  ulonglong uVar7;

   

-  *(char *)(in_RAX + 0x33) = *(char *)(in_RAX + 0x33) + param_1;

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  uVar12 = 0;

+  uVar13 = 0xffffffff;

+  local_48 = '\0';

+  local_44 = 0xffffffff;

+  iVar11 = 0;

+  if (PpmPlatformStates != (uint *)0x0) {

+    if ((param_3 == '\0') && (uVar7 = uVar12, *(int *)(param_2 + 4) != 0)) {

+      do {

+        uVar9 = (ulonglong)*(uint *)(*(longlong *)(param_2 + 0x10) + uVar7 * 4);

+        uVar6 = PpmPlatformStates[uVar9 * 0x70 + 0x68];

+        if ((uVar6 & 0x3000000) == 0x1000000) {

+          PpmPlatformStates[uVar9 * 0x70 + 0x68] =

+               (uVar6 & 0xfff | 0x2000) << 0xc | uVar6 & 0xfe000fff;

+        }

+        if (param_5 != '\0') {

+          piVar2 = (int *)(uVar9 * 0x400 + 0x28 + *(longlong *)(PpmPlatformStates + 0xc));

+          *piVar2 = *piVar2 + 1;

+        }

+        uVar6 = (int)uVar7 + 1;

+        uVar7 = (ulonglong)uVar6;

+      } while (uVar6 < *(uint *)(param_2 + 4));

+    }

+    uVar6 = *PpmPlatformStates;

+    uVar7 = uVar12;

+    while (puVar3 = PpmPlatformStates, iVar11 = (int)uVar12, PpmPlatformStates = puVar3, uVar6 != 0)

+    {

+      uVar1 = uVar6 - 1;

+      uVar9 = (ulonglong)uVar1;

+      local_47 = (char)uVar7;

+      local_40 = uVar1;

+      iVar5 = KeCheckProcessorAffinityEx

+                        (puVar3 + uVar9 * 0x70 + 0x20,*(undefined4 *)(param_1 + 0x24));

+      uVar6 = local_40;

+      uVar7 = 0;

+      if (iVar5 != 0) {

+        cVar4 = PpmExitCoordinatedIdleState(puVar3 + uVar9 * 0x70 + 0x68,&local_48);

+        uVar6 = local_40;

+        uVar7 = 0;

+        if (cVar4 != '\0') {

+          uVar7 = (ulonglong)(iVar11 + 1U);

+          *(uint *)(*(longlong *)(param_2 + 0x10) + uVar12 * 4) = uVar1;

+          if ((iVar11 + 1U == 1) && (*(char *)(uVar9 * 0x1c0 + 0x79 + (longlong)puVar3) != '\0')) {

+            if (param_3 != '\0') {

+              cVar4 = local_47;

+              if ((((-1 < param_4) && (param_5 == '\0')) && (uVar1 == PpmDripsStateIndex)) &&

+                 (param_10 != 0x82)) {

+                local_47 = '\x01';

+                cVar4 = '\x01';

+                if (param_8 != '\0') {

+                  *(longlong *)(*(longlong *)(PpmPlatformStates + 0xc) + 0x10) =

+                       *(longlong *)(*(longlong *)(PpmPlatformStates + 0xc) + 0x10) + 1;

+                  cVar4 = local_47;

+                }

+              }

+              local_47 = cVar4;

+              if ((char)puVar3[uVar9 * 0x70 + 0x1e] != '\0') {

+                KdCallPowerHandlers(1);

+                KdPowerTransitionEx(0x80000001,1);

+              }

+              if ((((PopSimulate & 0x100) != 0) && (-1 < param_4)) &&

+                 ((param_5 == '\0' && ((param_7 != 0 && (uVar1 == PpmDripsStateIndex)))))) {

+                    /* WARNING: Subroutine does not return */

+                KeBugCheckEx(0xa0,0x599,uVar9,0,0);

+              }

+            }

+            PpmPlatformStates[0xe] = 0;

+            uVar13 = uVar1;

+          }

+          uVar8 = 0;

+          uVar12 = uVar7;

+          if (param_3 == '\0') {

+            uVar6 = local_40;

+            uVar7 = uVar8;

+            if (((param_4 < 0) && (param_5 == '\0')) && (local_48 != '\0')) {

+              piVar2 = (int *)(uVar9 * 0x400 + 0x2c + *(longlong *)(PpmPlatformStates + 0xc));

+              *piVar2 = *piVar2 + 1;

+            }

+          }

+          else {

+            uVar7 = *(ulonglong *)(puVar3 + uVar9 * 0x70 + 0x6a);

+            lVar10 = *(longlong *)(PpmPlatformStates + 0xc) + uVar9 * 0x400;

+            if (uVar7 <= param_6) {

+              uVar8 = param_6 - uVar7;

+              *(longlong *)(lVar10 + 0x48) = *(longlong *)(lVar10 + 0x48) + uVar8;

+            }

+            if (local_47 != '\0') {

+              PopIdleWakeNotifyWakeSource(uVar13,param_10,param_9,uVar7,param_6,&local_44);

+            }

+            uVar7 = 0;

+            *(int *)(lVar10 + 0x30) = *(int *)(lVar10 + 0x30) + 1;

+            PpmUpdatePlatformIdleAccounting(lVar10 + 0x28,uVar8);

+            uVar6 = local_40;

+          }

+        }

+      }

+    }

+    if (param_3 != '\0') {

+      PpmEventCoordinatedIdleTransition(0,uVar12,*(undefined8 *)(param_2 + 0x10),&local_44);

+    }

+  }

+  *(int *)(param_2 + 4) = iVar11;

+  return uVar13;

 }
```

## `EtwpWriteUserEvent`  (modified)

```diff
--- EtwpWriteUserEvent
+++ EtwpWriteUserEvent
@@ -1,105 +1,1167 @@
 

-int EtwpWriteUserEvent(void)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Removing unreachable block (ram,0x000140ad77ff) */

+

+int EtwpWriteUserEvent(ulonglong param_1,ushort param_2,ushort param_3,ushort param_4,uint param_5,

+                      ulonglong *param_6,uint *param_7,byte param_8,ulonglong param_9,uint param_10,

+                      ulonglong param_11,longlong param_12,ulonglong param_13,ushort param_14,

+                      void *param_15,ulonglong *param_16)

 

 {

-  char cVar1;

-  longlong lVar2;

-  int unaff_EBX;

-  uint unaff_EDI;

-  undefined1 unaff_R12B;

-  char unaff_R13B;

-  bool in_SF;

-  char cStack0000000000000050;

-  char cStack0000000000000051;

-  longlong in_stack_00000058;

-  longlong in_stack_00000068;

-  longlong in_stack_00000070;

-  longlong in_stack_00000078;

-  undefined8 in_stack_00000090;

-  longlong in_stack_000000b0;

-  longlong in_stack_000000b8;

-  longlong *in_stack_00000180;

+  short *psVar1;

+  uint *puVar2;

+  undefined1 uVar3;

+  ushort uVar4;

+  undefined8 uVar5;

+  byte bVar6;

+  char cVar7;

+  int iVar8;

+  uint uVar9;

+  int iVar10;

+  uint uVar11;

+  longlong lVar12;

+  ulonglong *puVar13;

+  ulonglong uVar14;

+  char cVar15;

+  ulonglong *puVar16;

+  longlong lVar17;

+  ushort *puVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  int *piVar21;

+  undefined8 *puVar22;

+  ulonglong *puVar23;

+  uint uVar24;

+  ushort *puVar25;

+  void *pvVar26;

+  undefined7 uVar28;

+  ulonglong uVar27;

+  ulonglong uVar29;

+  ulonglong uVar30;

+  ushort uVar31;

+  ushort uVar32;

+  short sVar33;

+  ulonglong uVar34;

+  ulonglong uVar35;

+  uint uVar36;

+  bool bVar37;

+  uint uVar38;

+  uint uVar39;

+  undefined1 local_598 [96];

+  byte local_538 [8];

+  ushort local_530;

+  uint local_528;

+  uint local_524;

+  undefined1 local_520;

+  uint local_51c;

+  int local_518;

+  uint local_514;

+  ulonglong local_510;

+  int local_508;

+  ushort local_504 [2];

+  ushort local_500;

+  uint local_4fc;

+  ulonglong local_4f8;

+  uint local_4f0;

+  ushort local_4ec;

+  longlong local_4e8;

+  ulonglong *local_4e0;

+  ulonglong local_4d8;

+  char local_4d0;

+  char local_4cf;

+  char local_4ce;

+  char local_4cd;

+  undefined1 local_4cc;

+  uint local_4c8;

+  ulonglong local_4c0;

+  ulonglong *local_4b8;

+  ushort *local_4b0;

+  ulonglong local_4a8;

+  ulonglong local_4a0;

+  ushort *local_498;

+  ulonglong local_490;

+  void *local_488;

+  longlong local_480;

+  uint local_478;

+  uint local_474;

+  ulonglong local_470;

+  uint local_468;

+  longlong local_460;

+  uint *local_458;

+  longlong local_450;

+  ushort *local_448;

+  longlong local_440;

+  longlong local_438;

+  void *local_430;

+  ulonglong *local_428;

+  undefined8 local_420;

+  ulonglong *local_418;

+  void *local_410;

+  ushort *local_408;

+  ulonglong local_400;

+  ulonglong local_3f8;

+  undefined8 local_3f0;

+  undefined8 uStack_3e8;

+  ulonglong local_3e0;

+  int local_3d8;

+  int local_3d4;

+  int local_3d0;

+  int local_3cc;

+  void *local_3c8;

+  ulonglong local_3b8 [96];

+  uint local_b8;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  ulonglong local_58;

   

-  cVar1 = cStack0000000000000050;

-  if (((!in_SF) && (unaff_EBX = SepSetTokenPackage(in_stack_00000058), -1 < unaff_EBX)) &&

-     (unaff_EBX = SepAppendAceToTokenDefaultDacl(in_stack_00000058), -1 < unaff_EBX)) {

-    cVar1 = SepSidInTokenSidHash

-                      (in_stack_00000058 + 0x328,0,SePermissiveLearningModeCapabilitySid,0,

-                       unaff_EDI & 0xff);

-    if (cVar1 == '\0') {

-      *(uint *)(in_stack_00000058 + 200) = *(uint *)(in_stack_00000058 + 200) & 0xfcffffff;

-      cVar1 = SepSidInTokenSidHash

-                        (in_stack_00000058 + 0x328,0,SeLearningModeLoggingCapabilitySid,0,

-                         unaff_EDI & 0xff);

-      if (cVar1 != '\0') {

-        LOCK();

-        SepLearningModeTokenCount = SepLearningModeTokenCount + unaff_EDI;

-        UNLOCK();

-        *(uint *)(in_stack_00000058 + 200) = *(uint *)(in_stack_00000058 + 200) | 0x1000000;

+  puVar19 = local_598;

+  local_58 = __security_cookie ^ (ulonglong)local_538;

+  local_490 = param_13;

+  local_4b8 = param_6;

+  local_510 = param_11;

+  local_3f8 = param_11;

+  local_480 = param_12;

+  local_410 = param_15;

+  local_418 = param_16;

+  local_518 = 0;

+  local_530 = param_2;

+  local_4ec = param_3;

+  local_4c0 = param_1;

+  local_400 = param_1;

+  memset(local_3b8,0,0x308);

+  local_514 = 0;

+  local_a8 = 0;

+  uStack_a0 = 0;

+  local_98 = 0;

+  uStack_90 = 0;

+  local_88 = 0;

+  uStack_80 = 0;

+  local_78 = 0;

+  uStack_70 = 0;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_498 = (ushort *)0x0;

+  local_438 = 0;

+  local_448 = (ushort *)0x0;

+  local_504[0] = 0;

+  local_458 = (uint *)0x0;

+  local_488 = (void *)0x0;

+  local_470 = 0;

+  lVar12 = PsGetCurrentServerSiloGlobals();

+  local_450 = *(longlong *)(lVar12 + 0x340);

+  local_500 = param_14 & 0x100;

+  local_4d8 = 0;

+  local_4f0 = 0;

+  uVar14 = (ulonglong)param_10;

+  if (param_11 == 0) {

+    if (param_10 == 0) {

+LAB_0:

+      if (param_10 < 0x81) {

+        uVar27 = local_490;

+        if (local_490 == 0) {

+          uVar27 = param_1;

+        }

+        local_538[0] = 0;

+        lVar12 = *(longlong *)(param_1 + 0x288);

+        if ((local_418 != (ulonglong *)0x0) && (*local_418 != 0)) {

+          local_538[0] = 0x10;

+          local_470 = *local_418;

+        }

+        local_4e8 = lVar12;

+        local_490 = uVar27;

+        local_440 = lVar12;

+        DecodeProviderTraits(local_410,(byte)(param_14 >> 9) & 1,local_504,&local_458);

+        local_430 = SystemReserved1[0xf];

+        *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+             *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+        local_530 = local_530 & ~param_4;

+        lVar17 = local_480;

+        uVar30 = 1;

+        uVar24 = 0;

+LAB_1:

+        while( true ) {

+          do {

+            uVar35 = local_510;

+            cVar7 = (char)uVar24;

+            local_514 = 0;

+            if (local_530 != 0) {

+              for (; (local_530 >> local_514 & 1) == 0; local_514 = local_514 + 1) {

+              }

+            }

+            if (local_530 == 0) goto LAB_2;

+            local_3f0 = 0;

+            uStack_3e8 = 0;

+            local_3e0 = 0;

+            local_4a8 = 0;

+            local_528 = 0x50;

+            local_4fc = 0;

+            local_508 = 0;

+            local_4b0 = (ushort *)0x0;

+            local_408 = (ushort *)0x0;

+            local_524 = (uint)uVar27 & 0xffffff00;

+            local_520 = 0;

+            uVar29 = 1;

+            local_4f8 = 1;

+            local_4a0 = 1;

+            local_4d8 = 0;

+            local_530 = local_530 & local_530 - 1;

+            piVar21 = (int *)(((ulonglong)local_514 + 4) * 0x20 + local_490);

+            uVar27 = local_490;

+            uVar24 = local_524;

+          } while ((((((lVar17 != 0) &&

+                      (uVar30 = 1,

+                      (*(uint *)(lVar17 + (ulonglong)(*(ushort *)((longlong)piVar21 + 6) >> 5) * 4)

+                       >> (*(ushort *)((longlong)piVar21 + 6) & 0x1f) & 1) != 0)) ||

+                     (uVar30 = uVar29, *piVar21 == 0)) ||

+                    ((*(byte *)(piVar21 + 1) < param_8 && (*(byte *)(piVar21 + 1) != 0)))) ||

+                   ((((piVar21[2] & 0x40U) == 0 || (param_9 != 0)) &&

+                    (((*(ulonglong *)(piVar21 + 4) & param_9) == 0 ||

+                     ((*(ulonglong *)(piVar21 + 6) & param_9) != *(ulonglong *)(piVar21 + 6)))))))

+                  || ((((param_5 & 2) != 0 ||

+                       (*(int *)(*(longlong *)((longlong)SystemReserved1[0xf] + 0xb8) + 0x1f0) < 0))

+                      && ((piVar21[2] & 0x200U) != 0))));

+          if ((*(longlong *)(local_490 + 0x280) == 0) ||

+             ((uVar24 = *(uint *)((ulonglong)local_514 * 0x68 + *(longlong *)(local_490 + 0x280)),

+              (uVar24 & 0x80000200) != 0x80000200 && ((uVar24 & 0x80000100) != 0x80000100)))) {

+            bVar37 = false;

+          }

+          else {

+            bVar37 = true;

+          }

+          uVar34 = (ulonglong)local_514;

+          if (!bVar37) break;

+          *(ulonglong *)(puVar19 + 0x28) = local_510;

+          *(int *)(puVar19 + 0x20) = (int)uVar14;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad78ed;

+          cVar7 = EtwpApplyEventIdPayloadFilterOnUserEvent(local_490,uVar34,local_4ec,local_4b8);

+          if (cVar7 != '\0') break;

+LAB_3:

+          uVar14 = (ulonglong)param_10;

+          lVar17 = local_480;

+          param_11 = local_510;

+          uVar24 = local_524;

+        }

+        uVar27 = local_490;

+        if (local_500 != 0) {

+          puVar19[0x28] = 0;

+          *(ulonglong *)(puVar19 + 0x20) = param_9;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad792a;

+          cVar7 = EtwpIsEventNameFilterEnabled(local_490,uVar34,0);

+          if (cVar7 != '\0') {

+            puVar19[0x40] = 0;

+            *(ulonglong *)(puVar19 + 0x38) = param_9;

+            puVar19[0x30] = param_8;

+            puVar19[0x28] = 0;

+            puVar19[0x20] = 1;

+            *(undefined8 *)(puVar19 + -8) = 0x140ad796d;

+            cVar7 = EtwpApplyEventNameFilter(local_490,uVar34,param_10,uVar35);

+            if (cVar7 == '\0') goto LAB_3;

+          }

+        }

+        uVar32 = *(ushort *)((longlong)piVar21 + 6);

+        local_4f0 = (uint)uVar32;

+        lVar17 = (ulonglong)uVar32 * 8;

+        uVar5 = *(undefined8 *)(*(longlong *)(lVar12 + 0x2c0) + lVar17);

+        *(undefined8 *)(puVar19 + -8) = 0x140ad799a;

+        local_4c8 = local_4f0;

+        cVar7 = ExAcquireRundownProtectionCacheAwareEx(uVar5,1);

+        if (cVar7 == '\0') {

+          uVar27 = (ulonglong)local_524;

+        }

+        else {

+          uVar28 = (undefined7)(uVar27 >> 8);

+          if ((uint)uVar32 < *(uint *)(lVar12 + 0x10)) {

+            uVar29 = *(ulonglong *)(*(longlong *)(lVar12 + 0x2c8) + lVar17);

+            uVar34 = (ulonglong)local_514;

+            uVar27 = CONCAT71(uVar28,1);

+            local_524 = (uint)uVar27;

+            local_520 = 1;

+            local_4f8 = uVar29;

+            local_4a0 = uVar29;

+          }

+          else {

+            local_4f8 = 1;

+            local_4a0 = 1;

+            uVar27 = CONCAT71(uVar28,1);

+            local_524 = (uint)uVar27;

+            local_520 = 1;

+          }

+        }

+        if ((uVar29 & 1) != 0) {

+          if ((char)uVar27 != '\0') {

+            uVar5 = *(undefined8 *)(*(longlong *)(lVar12 + 0x2c0) + lVar17);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad7a0b;

+            ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad7a10;

+            iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+            uVar27 = (ulonglong)(local_524 & 0xff);

+            if (iVar8 != 0) {

+              uVar27 = 0;

+            }

+            local_524 = (uint)uVar27;

+          }

+          uVar30 = uVar29;

+          if (uVar32 != 3) goto LAB_3;

+          local_518 = -0x3ffffff8;

+          if (*(int *)(lVar12 + 0x10f4) != 0) {

+            local_518 = -0x3ffffd02;

+          }

+LAB_4:

+          cVar7 = (char)local_524;

+          uVar30 = uVar29;

+          param_11 = local_510;

+          goto LAB_2;

+        }

+        uVar24 = 0;

+        if (param_7 != (uint *)0x0) {

+          local_528 = 0x68;

+          uVar24 = 0x10;

+        }

+        uVar11 = piVar21[2];

+        uVar36 = local_528;

+        if ((uVar11 & 0xffffff9f) != 0) {

+          if ((((uVar11 >> 0xb & 1) != 0) && (local_450 != 0)) && (local_450 != EtwpHostSiloState))

+          {

+            uVar24 = uVar24 | 0x100;

+            local_528 = local_528 + (*(ushort *)(local_450 + 0x1190) + 0xf & 0xfffffff8);

+          }

+          uVar36 = local_528;

+          if ((uVar11 & 1) != 0) {

+            if ((local_538[0] & 2) == 0) {

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7aee;

+              EtwpGetSidExtendedHeaderItem(&local_a8);

+              local_538[0] = local_538[0] | 2;

+              uVar11 = piVar21[2];

+            }

+            uVar24 = uVar24 | 2;

+            local_528 = uVar36 + (ushort)local_a8;

+          }

+          uVar14 = local_490;

+          if ((uVar11 & 2) != 0) {

+            uVar24 = uVar24 | 1;

+            local_528 = local_528 + 0x10;

+          }

+          if ((char)uVar11 < '\0') {

+            uVar24 = uVar24 | 0x40;

+            local_528 = local_528 + 0x10;

+          }

+          if ((uVar11 >> 8 & 1) != 0) {

+            uVar24 = uVar24 | 0x80;

+            local_528 = local_528 + 0x10;

+          }

+          uVar36 = local_528;

+          if ((uVar11 & 4) != 0) {

+            if ((*(longlong *)(local_490 + 0x280) == 0) ||

+               (((uVar11 = *(uint *)(uVar34 * 0x68 + *(longlong *)(local_490 + 0x280)),

+                 (uVar11 & 0x80001000) != 0x80001000 && ((uVar11 & 0x80002000) != 0x80002000)) &&

+                ((uVar11 & 0x80004000) != 0x80004000)))) {

+              bVar37 = false;

+            }

+            else {

+              bVar37 = true;

+            }

+            if (bVar37) {

+              puVar19[0x20] = 1;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7bb4;

+              cVar7 = EtwpApplyLevelKwFilter(local_490,uVar34,param_8,param_9);

+              if (cVar7 != '\0') {

+                *(undefined8 *)(puVar19 + -8) = 0x140ad7bce;

+                cVar7 = EtwpApplyStackWalkFilterOnUserEvent(local_4b8,uVar14,uVar34);

+                if (cVar7 != '\0') {

+                  puVar19[0x40] = 1;

+                  *(ulonglong *)(puVar19 + 0x38) = param_9;

+                  puVar19[0x30] = param_8;

+                  puVar19[0x28] = 0;

+                  puVar19[0x20] = 1;

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7c12;

+                  cVar7 = EtwpApplyEventNameFilter(uVar14,uVar34,param_10,local_510);

+                  if (cVar7 != '\0') goto LAB_5;

+                }

+              }

+            }

+            else {

+LAB_5:

+              bVar6 = local_538[0];

+              if ((local_538[0] & 1) == 0) {

+                *(undefined8 *)(puVar19 + -8) = 0x140ad7c28;

+                local_438 = EtwpGetStackLookasideListEntry();

+                if (local_438 != 0) {

+                  local_538[0] = bVar6 | 8;

+                  local_498 = (ushort *)(local_438 + 0x20);

+                  *(undefined8 *)(puVar19 + 0x28) = 0;

+                  puVar19[0x20] = 0;

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7c6b;

+                  cVar7 = EtwpGetStackExtendedHeaderItem(uVar29,local_430,0,local_438);

+                  if (cVar7 == '\0') {

+                    *(undefined8 *)(puVar19 + -8) = 0x140ad7c7b;

+                    EtwpReleaseStackLookasideListEntry(local_438);

+                    local_538[0] = bVar6 & 0xf7;

+                    local_498 = (ushort *)0x0;

+                  }

+                }

+                local_538[0] = local_538[0] | 1;

+              }

+              puVar25 = local_498;

+              if (local_498 != (ushort *)0x0) {

+                if ((*(uint *)(uVar29 + 0x334) & 1) != 0) {

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7cb7;

+                  cVar7 = EtwpGetCrimsonStackKey(uVar29,local_498,&local_4d8);

+                  if (cVar7 != '\0') {

+                    uVar24 = uVar24 | 8;

+                    uVar36 = uVar36 + 0x18;

+                    local_528 = uVar36;

+                    goto LAB_6;

+                  }

+                }

+                uVar24 = uVar24 | 4;

+                uVar36 = uVar36 + *puVar25;

+                local_528 = uVar36;

+              }

+            }

+          }

+LAB_6:

+          if ((piVar21[2] & 8U) != 0) {

+            puVar20 = puVar19;

+            if ((local_538[0] & 4) == 0) {

+              local_420 = 0;

+              local_460 = 0;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7d05;

+              cVar7 = RtlpGetStackLimits(&local_460,&local_420);

+              if (cVar7 == '\0') {

+                local_460 = 0;

+              }

+              if (0x1e0 < (ulonglong)((longlong)&local_420 - local_460)) {

+                puVar20 = puVar19 + -0x1e0;

+                local_448 = (ushort *)(puVar19 + -0x180);

+                *(undefined8 *)(puVar19 + -0x1e8) = 0x140ad7d49;

+                EtwpGetPsmKeyExtendedHeaderItem();

+              }

+              local_538[0] = local_538[0] | 4;

+            }

+            puVar19 = puVar20;

+            if (local_448 != (ushort *)0x0) {

+              uVar24 = uVar24 | 0x20;

+              uVar36 = uVar36 + *local_448;

+              local_528 = uVar36;

+            }

+          }

+        }

+        uVar14 = 0;

+        local_428 = local_3b8 + (ulonglong)local_b8 * 6;

+        uVar11 = (uint)uVar34;

+        if (param_10 != 0) {

+          local_478 = 0;

+          local_4d0 = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+          if (((local_4d0 != '\0') && (param_10 != 0)) && ((local_510 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+            *(undefined **)(puVar19 + -8) = &UNK_7;

+            ExRaiseDatatypeMisalignment();

+          }

+          local_478 = 0;

+          while (uVar36 = local_528, uVar29 = local_4f8, uVar11 = local_514, (uint)uVar14 < param_10

+                ) {

+            puVar22 = (undefined8 *)(uVar14 * 0x10 + local_510);

+            uVar11 = *(uint *)(puVar22 + 1);

+            local_468 = uVar11;

+            if (0xffff < uVar11) {

+              local_518 = -0x7ffffffb;

+              local_530 = local_530 | (ushort)(1 << (local_514 & 0x1f));

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7e32;

+              iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+              lVar12 = local_4e8;

+              if (iVar8 == 0) {

+                if (local_4d8 != 0) {

+                  uVar5 = *(undefined8 *)(local_4f8 + 0x420);

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7e52;

+                  EtwpDereferenceStackEntry(local_4d8,uVar5);

+                }

+                lVar12 = local_4e8;

+                uVar5 = *(undefined8 *)(*(longlong *)(local_4e8 + 0x2c0) + lVar17);

+                *(undefined8 *)(puVar19 + -8) = 0x140ad7e6f;

+                ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+              }

+              cVar7 = (char)local_524;

+              uVar30 = local_4f8;

+              param_11 = local_510;

+              goto LAB_2;

+            }

+            if (local_500 == 0) {

+              cVar7 = '\0';

+            }

+            else {

+              cVar7 = *(char *)((longlong)puVar22 + 0xc);

+            }

+            if (cVar7 == '\0') {

+              local_528 = local_528 + uVar11;

+            }

+            else if (cVar7 == '\x01') {

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7f1f;

+              local_3d0 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+              if (local_3d0 == 0) {

+                local_4fc = local_4fc + (uVar11 & 0xffff);

+                local_508 = local_508 + 1;

+              }

+              else {

+                local_4fc = local_4fc + uVar11;

+                local_508 = local_508 + 1;

+              }

+            }

+            else if (cVar7 == '\x04') {

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7ec1;

+              local_3d4 = Feature_ModernWpp__private_IsEnabledDeviceUsageNoInline();

+              if ((local_3d4 != 0) && (uVar11 == 0x10)) {

+                local_4cf = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+                if (local_4cf == '\0') {

+                  local_488 = (void *)*puVar22;

+                  local_3c8 = local_488;

+                }

+                else {

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7eef;

+                  local_488 = (void *)RtlReadULong64FromUser(puVar22);

+                  local_3c8 = local_488;

+                }

+              }

+            }

+            if (local_528 < uVar36) {

+              local_518 = -0x7ffffffb;

+              local_530 = local_530 | (ushort)(1 << (local_514 & 0x1f));

+              *(undefined8 *)(puVar19 + -8) = 0x140ad7f6e;

+              iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+              lVar12 = local_4e8;

+              if (iVar8 == 0) {

+                if (local_4d8 != 0) {

+                  uVar5 = *(undefined8 *)(local_4f8 + 0x420);

+                  *(undefined8 *)(puVar19 + -8) = 0x140ad7f8e;

+                  EtwpDereferenceStackEntry(local_4d8,uVar5);

+                }

+                lVar12 = local_4e8;

+                uVar5 = *(undefined8 *)(*(longlong *)(local_4e8 + 0x2c0) + lVar17);

+                *(undefined8 *)(puVar19 + -8) = 0x140ad7fab;

+                ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+              }

+              cVar7 = (char)local_524;

+              uVar30 = local_4f8;

+              param_11 = local_510;

+              goto LAB_2;

+            }

+            local_478 = (uint)uVar14 + 1;

+            uVar14 = (ulonglong)local_478;

+          }

+        }

+        puVar23 = local_428;

+        if (local_508 != 0) {

+          *(undefined8 *)(puVar19 + -8) = 0x140ad808f;

+          iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          if (iVar8 == 0) {

+            uVar9 = local_4fc + 0xf & 0xfffffff8;

+LAB_8:

+            uVar36 = uVar36 + uVar9;

+            local_528 = uVar36;

+            goto LAB_9;

+          }

+          uVar9 = local_4fc + 0xf & 0xfffffff8;

+          if (uVar9 < 0x10000) goto LAB_8;

+LAB_10:

+          if (-1 < local_518) {

+            local_518 = -0x3fffff6b;

+          }

+          local_530 = local_530 | (ushort)(1 << (uVar11 & 0x1f));

+          lVar12 = local_4e8;

+          goto LAB_4;

+        }

+LAB_9:

+        uVar32 = local_504[0];

+        if (local_504[0] != 0) {

+          *(undefined8 *)(puVar19 + -8) = 0x140ad80c3;

+          iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          if ((iVar8 != 0) && (0xffff < (uVar32 + 0xf & 0xfffffff8))) goto LAB_10;

+          uVar36 = uVar36 + (uVar32 + 0xf & 0xfffffff8);

+          local_528 = uVar36;

+        }

+        *(uint *)(puVar23 + 5) = uVar36;

+        *(undefined4 *)(puVar19 + 0x20) = 0;

+        *(undefined8 *)(puVar19 + -8) = 0x140ad8108;

+        puVar13 = (ulonglong *)EtwpReserveTraceBuffer(uVar29,uVar36,&local_3f0,&local_4a8);

+        uVar30 = local_4d8;

+        uVar14 = local_4f8;

+        local_4d8 = uVar30;

+        local_428 = puVar13;

+        if (local_4d8 != 0) {

+          uVar5 = *(undefined8 *)(local_4f8 + 0x420);

+          *(undefined8 *)(puVar19 + -8) = 0x140ad812e;

+          EtwpDereferenceStackEntry(local_4d8,uVar5);

+          *(undefined8 *)(puVar19 + -8) = 0x140ad8133;

+          iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          local_4d8 = uVar30;

+          if (iVar8 != 0) {

+            local_4d8 = 0;

+          }

+        }

+        uVar30 = local_4f8;

+        param_11 = local_510;

+        if (puVar13 != (ulonglong *)0x0) {

+          *puVar23 = uVar14;

+          puVar23[1] = (ulonglong)puVar13;

+          *(uint *)(puVar23 + 2) = (uint)local_3f0;

+          *(uint *)((longlong)puVar23 + 0x14) = local_3f0._4_4_;

+          *(uint *)(puVar23 + 3) = (uint)uStack_3e8;

+          *(uint *)((longlong)puVar23 + 0x1c) = uStack_3e8._4_4_;

+          puVar23[4] = local_3e0;

+          local_b8 = local_b8 + 1;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad8275;

+          iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+          local_524 = local_524 & 0xff;

+          if (iVar8 != 0) {

+            local_524 = 0;

+          }

+          local_520 = (undefined1)local_524;

+          local_474 = 0;

+          uVar35 = 0x50;

+          local_51c = 0x50;

+          puVar23 = (ulonglong *)0x0;

+          local_4e0 = (ulonglong *)0x0;

+          uVar14 = local_4b8[1];

+          *puVar13 = *local_4b8;

+          puVar13[1] = uVar14;

+          uVar14 = local_4b8[3];

+          puVar13[2] = local_4b8[2];

+          puVar13[3] = uVar14;

+          uVar14 = local_4b8[5];

+          puVar13[4] = local_4b8[4];

+          puVar13[5] = uVar14;

+          uVar11 = *(uint *)((longlong)local_4b8 + 0x34);

+          uVar14 = local_4b8[7];

+          uVar9 = *(uint *)((longlong)local_4b8 + 0x3c);

+          *(uint *)(puVar13 + 6) = (uint)local_4b8[6];

+          *(uint *)((longlong)puVar13 + 0x34) = uVar11;

+          *(uint *)(puVar13 + 7) = (uint)uVar14;

+          *(uint *)((longlong)puVar13 + 0x3c) = uVar9;

+          uVar11 = *(uint *)((longlong)local_4b8 + 0x44);

+          uVar14 = local_4b8[9];

+          uVar9 = *(uint *)((longlong)local_4b8 + 0x4c);

+          *(uint *)(puVar13 + 8) = (uint)local_4b8[8];

+          *(uint *)((longlong)puVar13 + 0x44) = uVar11;

+          *(uint *)(puVar13 + 9) = (uint)uVar14;

+          *(uint *)((longlong)puVar13 + 0x4c) = uVar9;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad82e1;

+          local_3d8 = Feature_ModernWpp__private_IsEnabledDeviceUsageNoInline();

+          if (local_3d8 == 0) {

+            if (local_458 == (uint *)0x0) {

+              uVar11 = *(uint *)(local_4c0 + 0x28);

+              uVar9 = *(uint *)(local_4c0 + 0x2c);

+              uVar38 = *(uint *)(local_4c0 + 0x30);

+              uVar39 = *(uint *)(local_4c0 + 0x34);

+            }

+            else {

+LAB_11:

+              uVar11 = *local_458;

+              uVar9 = local_458[1];

+              uVar38 = local_458[2];

+              uVar39 = local_458[3];

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 0x80;

+            }

+LAB_12:

+            *(uint *)(puVar13 + 3) = uVar11;

+            *(uint *)((longlong)puVar13 + 0x1c) = uVar9;

+            *(uint *)(puVar13 + 4) = uVar38;

+            *(uint *)((longlong)puVar13 + 0x24) = uVar39;

+          }

+          else {

+            if (local_458 == (uint *)0x0) {

+              if (local_488 == (void *)0x0) {

+                uVar11 = *(uint *)(local_4c0 + 0x28);

+                uVar9 = *(uint *)(local_4c0 + 0x2c);

+                uVar38 = *(uint *)(local_4c0 + 0x30);

+                uVar39 = *(uint *)(local_4c0 + 0x34);

+                goto LAB_12;

+              }

+            }

+            else if (local_488 == (void *)0x0) goto LAB_11;

+            local_4ce = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+            if ((local_4ce != '\0') && (((ulonglong)local_488 & 3) != 0)) {

+                    /* WARNING: Subroutine does not return */

+              *(undefined **)(puVar19 + -8) = &UNK_13;

+              ExRaiseDatatypeMisalignment();

+            }

+            local_4cd = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+            if (local_4cd == '\0') {

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8394;

+              RtlCopyVolatileMemory(puVar13 + 3,local_488,0x10);

+            }

+            else {

+              *(undefined8 *)(puVar19 + -8) = 0x140ad838d;

+              RtlCopyFromUser();

+            }

+            *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 0x80;

+            uVar36 = local_528;

+          }

+          *(uint *)puVar13 = uVar36 | *(uint *)(&DAT_14 + (ulonglong)local_4ec * 4);

+          *(undefined8 *)(puVar19 + -8) = 0x140ad83ee;

+          local_3cc = Feature_ModernWpp__private_IsEnabledDeviceUsageNoInline();

+          if ((local_3cc != 0) && ((param_14 & 0x400) != 0)) {

+            *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 0x400;

+          }

+          if (uVar24 != 0) {

+            if (uVar24 >> 8 != 0) {

+              puVar23 = puVar13 + 10;

+              uVar31 = *(short *)(local_450 + 0x1190) + 0xfU & 0xfff8;

+              *(ushort *)puVar23 = uVar31;

+              *(undefined2 *)((longlong)puVar13 + 0x52) = 0x10;

+              *(undefined2 *)((longlong)puVar13 + 0x56) = *(undefined2 *)(local_450 + 0x1190);

+              *(ushort *)((longlong)puVar13 + 0x54) = *(ushort *)((longlong)puVar13 + 0x54) & 0xfffe

+              ;

+              *(undefined2 *)((longlong)puVar13 + 0x54) = 0;

+              uVar32 = *(ushort *)(local_450 + 0x1190);

+              pvVar26 = *(void **)(local_450 + 0x1188);

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8497;

+              RtlCopyMemory(puVar13 + 0xb,pvVar26,(ulonglong)uVar32);

+              uVar4 = *(ushort *)(local_450 + 0x1190);

+              *(undefined8 *)(puVar19 + -8) = 0x140ad84b3;

+              memset((void *)((ulonglong)uVar4 + (longlong)(puVar13 + 0xb)),0,

+                     (ulonglong)(ushort)((uVar31 - uVar32) - 8));

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (ushort)*puVar23 + 0x50;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar23;

+            }

+            puVar16 = puVar23;

+            if ((uVar24 & 0x10) != 0) {

+              puVar16 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              *(uint *)puVar16 = 0x10018;

+              *(ushort *)((longlong)puVar16 + 6) = 0x10;

+              *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) & 0xfffe;

+              *(ushort *)((longlong)puVar16 + 4) = 0;

+              uVar11 = param_7[1];

+              uVar9 = param_7[2];

+              uVar38 = param_7[3];

+              *(uint *)(puVar16 + 1) = *param_7;

+              *(uint *)((longlong)puVar16 + 0xc) = uVar11;

+              *(uint *)(puVar16 + 2) = uVar9;

+              *(uint *)((longlong)puVar16 + 0x14) = uVar38;

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (int)uVar35 + 0x18;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar16;

+              if (puVar23 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) | 1;

+              }

+            }

+            puVar23 = puVar16;

+            if ((uVar24 & 2) != 0) {

+              puVar23 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              uVar11 = (uint)(ushort)local_a8;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8563;

+              RtlCopyMemory(puVar23,&local_a8,(ulonglong)uVar11);

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = local_51c + uVar11;

+              if (puVar16 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) | 1;

+              }

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar23;

+            }

+            puVar16 = puVar23;

+            if ((uVar24 & 1) != 0) {

+              puVar16 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              *(uint *)puVar16 = 0x30010;

+              *(ushort *)((longlong)puVar16 + 6) = 4;

+              *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) & 0xfffe;

+              *(ushort *)((longlong)puVar16 + 4) = 0;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad85d2;

+              uVar11 = PsGetCurrentProcessSessionId();

+              *(uint *)(puVar16 + 1) = uVar11;

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (int)uVar35 + 0x10;

+              local_4e0 = puVar16;

+              if (puVar23 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) | 1;

+              }

+            }

+            uVar27 = 0;

+            puVar23 = puVar16;

+            if ((uVar24 & 0x40) != 0) {

+              puVar23 = (ulonglong *)((ulonglong)local_51c + (longlong)puVar13);

+              *(uint *)puVar23 = 0xd0010;

+              *(ushort *)((longlong)puVar23 + 6) = 8;

+              *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) & 0xfffe;

+              *(ushort *)((longlong)puVar23 + 4) = 0;

+              uVar5 = *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

+              *(undefined8 *)(puVar19 + -8) = 0x140ad865c;

+              uVar14 = PsGetProcessStartKey(uVar5);

+              puVar23[1] = uVar14;

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = local_51c + 0x10;

+              uVar36 = local_528;

+              local_4e0 = puVar23;

+              if (puVar16 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) | 1;

+              }

+            }

+            uVar35 = (ulonglong)local_51c;

+            puVar16 = puVar23;

+            if ((char)uVar24 < '\0') {

+              puVar16 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              *(uint *)puVar16 = 0xa0010;

+              *(ushort *)((longlong)puVar16 + 6) = 8;

+              *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) & 0xfffe;

+              *(ushort *)((longlong)puVar16 + 4) = 0;

+              if ((local_538[0] & 0x10) == 0) {

+                *(undefined8 *)(puVar19 + -8) = 0x140ad86e4;

+                EtwpCreateEventKey(&local_470);

+                local_538[0] = local_538[0] | 0x10;

+                if (local_418 != (ulonglong *)0x0) {

+                  *local_418 = local_470;

+                }

+              }

+              puVar16[1] = local_470;

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = local_51c + 0x10;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar16;

+              if (puVar23 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) | 1;

+              }

+            }

+            puVar23 = puVar16;

+            if ((uVar24 & 4) != 0) {

+              puVar23 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              uVar32 = *local_498;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad875d;

+              RtlCopyMemory(puVar23,local_498,(ulonglong)uVar32);

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (int)uVar35 + (uint)*local_498;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar23;

+              if (puVar16 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) | 1;

+              }

+            }

+            puVar25 = local_448;

+            puVar16 = puVar23;

+            if ((uVar24 & 8) != 0) {

+              puVar16 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              *(uint *)puVar16 = 0x120018;

+              *(ushort *)((longlong)puVar16 + 6) = 0x10;

+              *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) & 0xfffe;

+              *(ushort *)((longlong)puVar16 + 4) = 0;

+              puVar16[2] = local_4d8;

+              puVar16[1] = *(ulonglong *)(local_498 + 4);

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (int)uVar35 + 0x18;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar16;

+              if (puVar23 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) | 1;

+              }

+            }

+            puVar23 = puVar16;

+            if ((uVar24 & 0x20) != 0) {

+              puVar23 = (ulonglong *)(uVar35 + (longlong)puVar13);

+              uVar32 = *local_448;

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8833;

+              RtlCopyMemory(puVar23,local_448,(ulonglong)uVar32);

+              *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+              local_51c = (int)uVar35 + (uint)*puVar25;

+              uVar35 = (ulonglong)local_51c;

+              local_4e0 = puVar23;

+              if (puVar16 != (ulonglong *)0x0) {

+                *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) | 1;

+              }

+            }

+          }

+          puVar16 = puVar23;

+          if (local_504[0] != 0) {

+            puVar16 = (ulonglong *)(uVar35 + (longlong)puVar13);

+            uVar32 = local_504[0] + 0xf & 0xfff8;

+            *(ushort *)puVar16 = uVar32;

+            *(ushort *)((longlong)puVar16 + 2) = 0xc;

+            *(ushort *)((longlong)puVar16 + 6) = local_504[0];

+            *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) & 0xfffe;

+            *(ushort *)((longlong)puVar16 + 4) = 0;

+            sVar33 = uVar32 - local_504[0];

+            uVar24 = (uint)local_504[0];

+            *(undefined8 *)(puVar19 + -8) = 0x140ad88d3;

+            RtlCopyMemory(puVar16 + 1,local_410,(ulonglong)uVar24);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad88e2;

+            memset((void *)((ulonglong)uVar24 + (longlong)(puVar16 + 1)),0,

+                   (ulonglong)(ushort)(sVar33 - 8));

+            *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+            local_51c = local_51c + (ushort)*puVar16;

+            uVar35 = (ulonglong)local_51c;

+            local_4e0 = puVar16;

+            if (puVar23 != (ulonglong *)0x0) {

+              *(ushort *)((longlong)puVar23 + 4) = *(ushort *)((longlong)puVar23 + 4) | 1;

+            }

+          }

+          uVar14 = 0;

+          puVar25 = local_4b0;

+          if (local_508 != 0) {

+            puVar18 = (ushort *)(uVar35 + (longlong)puVar13);

+            uVar32 = (ushort)(local_4fc + 0xf) & 0xfff8;

+            *puVar18 = uVar32;

+            puVar18[1] = 0xb;

+            puVar18[3] = (ushort)local_4fc;

+            puVar18[2] = puVar18[2] & 0xfffe;

+            puVar18[2] = 0;

+            puVar25 = puVar18 + 4;

+            local_408 = (ushort *)((longlong)puVar25 + (ulonglong)local_4fc);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad898d;

+            local_4b0 = puVar25;

+            memset((void *)((ulonglong)local_4fc + (longlong)puVar25),0,

+                   (ulonglong)(ushort)((uVar32 - (ushort)local_4fc) - 8));

+            *(ushort *)((longlong)puVar13 + 4) = *(ushort *)((longlong)puVar13 + 4) | 1;

+            local_51c = (int)uVar35 + (uint)*puVar18;

+            uVar35 = (ulonglong)local_51c;

+            if (puVar16 != (ulonglong *)0x0) {

+              *(ushort *)((longlong)puVar16 + 4) = *(ushort *)((longlong)puVar16 + 4) | 1;

+            }

+          }

+          local_474 = 0;

+          while (lVar17 = local_480, uVar30 = local_4f8, uVar24 = (uint)uVar14, uVar24 < param_10) {

+            uVar11 = *(uint *)(local_510 + 8 + uVar14 * 0x10);

+            uVar29 = (ulonglong)uVar11;

+            puVar23 = *(ulonglong **)(local_510 + uVar14 * 0x10);

+            if (local_500 == 0) {

+              cVar15 = '\0';

+            }

+            else {

+              cVar15 = *(char *)(local_510 + 0xc + uVar14 * 0x10);

+              puVar25 = local_4b0;

+              uVar36 = local_528;

+            }

+            cVar7 = (char)local_524;

+            param_11 = local_510;

+            lVar12 = local_4e8;

+            if (cVar15 == '\0') {

+              pvVar26 = (void *)(uVar35 + (longlong)puVar13);

+              local_51c = uVar11 + (uint)uVar35;

+              if (local_51c < (uint)uVar35) {

+                local_51c = 0xffffffff;

+LAB_15:

+                local_518 = -0x3ffffffc;

+                *(uint *)puVar13 = uVar36 | 0xc00d0000;

+                puVar13[2] = local_4a8;

+                goto LAB_2;

+              }

+              uVar35 = (ulonglong)local_51c;

+              if (uVar36 < local_51c) goto LAB_15;

+              local_4cc = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8b6e;

+              RtlCopyMemory(pvVar26,puVar23,uVar29);

+              local_474 = uVar24 + 1;

+              uVar14 = (ulonglong)local_474;

+              puVar25 = local_4b0;

+              uVar36 = local_528;

+            }

+            else if (cVar15 == '\x01') {

+              if ((((puVar25 == (ushort *)0x0) || ((ushort *)(uVar29 + (longlong)puVar25) < puVar25)

+                   ) || (local_408 < (ushort *)(uVar29 + (longlong)puVar25))) || (local_508 == 0)) {

+                local_518 = -0x3ffffffc;

+                *(uint *)puVar13 = uVar36 | 0xc00d0000;

+                puVar13[2] = local_4a8;

+                goto LAB_2;

+              }

+              if ((uVar11 != 0) &&

+                 ((&DAT_16 < (ulonglong *)(uVar29 + (longlong)puVar23) ||

+                  ((ulonglong *)(uVar29 + (longlong)puVar23) < puVar23)))) {

+                puVar25 = local_4b0;

+                uVar36 = local_528;

+              }

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8aba;

+              RtlCopyMemory(puVar25,puVar23,uVar29);

+              local_4b0 = (ushort *)((longlong)puVar25 + uVar29);

+              local_508 = local_508 + -1;

+              local_474 = uVar24 + 1;

+              uVar14 = (ulonglong)local_474;

+              puVar25 = local_4b0;

+            }

+            else if (cVar15 == '\x03') {

+              if (uVar11 == 8) {

+                if ((&DAT_16 < puVar23 + 1) || (puVar23 + 1 < puVar23)) {

+                  puVar25 = local_4b0;

+                  uVar36 = local_528;

+                }

+                local_4a8 = *puVar23;

+              }

+              local_474 = uVar24 + 1;

+              uVar14 = (ulonglong)local_474;

+            }

+            else {

+              local_474 = uVar24 + 1;

+              uVar14 = (ulonglong)local_474;

+            }

+          }

+          if (local_480 != 0) {

+            puVar2 = (uint *)(local_480 + (ulonglong)(local_4f0 >> 5) * 4);

+            *puVar2 = *puVar2 | 1 << (local_4f0 & 0x1f);

+          }

+          puVar13[2] = local_4a8;

+          *(uint *)(puVar13 + 7) = *(uint *)((longlong)local_430 + 0x28c);

+          *(uint *)((longlong)puVar13 + 0x3c) = *(uint *)((longlong)local_430 + 0x2dc);

+          *(uint *)(puVar13 + 1) = *(uint *)((longlong)local_430 + 0x510);

+          *(uint *)((longlong)puVar13 + 0xc) = *(uint *)((longlong)local_430 + 0x508);

+          if (((*(uint *)(local_4f8 + 0xc) & 0x80000) != 0) &&

+             (((KdDebuggerNotPresent == '\0' && (KdPitchDebugger == '\0')) ||

+              (KdEventLoggingPresent != '\0')))) {

+            *(undefined8 *)(puVar19 + -8) = 0x140ad8c6a;

+            EtwpSendTraceEvent(local_4f8,&local_3f0);

+          }

+          lVar12 = local_4e8;

+          param_11 = local_510;

+          uVar14 = (ulonglong)param_10;

+          uVar24 = local_524;

+          if (*(longlong *)(uVar30 + 0x610) != 0) {

+            uVar3 = *(undefined1 *)((longlong)SystemReserved1[0xf] + 0x232);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad8cc8;

+            EtwpInvokeEventCallback(uVar30,&local_3f0,local_4c0 + 0x28,uVar3);

+            uVar14 = (ulonglong)param_10;

+            uVar24 = local_524;

+          }

+          goto LAB_1;

+        }

+        if (uVar36 < 0xfff9) {

+          iVar8 = -0x3fffffe9;

+          if (*(uint *)(local_4f8 + 8) < uVar36) {

+            iVar8 = -0x7ffffffb;

+          }

+        }

+        else {

+          iVar8 = -0x3fffff6b;

+        }

+        uVar14 = 0;

+        uVar24 = 0;

+        if (local_508 != 0) {

+          uVar14 = local_510;

+          uVar24 = param_10;

+        }

+        *(undefined8 *)(puVar19 + -8) = 0x140ad81a0;

+        cVar7 = EtwEventEnabled(EtwpEventTracingProvRegHandle,&ETW_EVENT_LOST_EVENT);

+        if (cVar7 != '\0') {

+          puVar19[0x40] = 1;

+          puVar19[0x38] = 1;

+          *(ulonglong *)(puVar19 + 0x30) = uVar14;

+          *(uint *)(puVar19 + 0x28) = uVar24;

+          *(int *)(puVar19 + 0x20) = iVar8;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad81e2;

+          EtwpTraceLostEvent(local_4c0 + 0x28,local_4b8 + 5,uVar30 + 0x88,param_5);

+        }

+        lVar12 = local_4e8;

+        if ((-1 < local_518) && ((*(uint *)(uVar30 + 0xc) & 0x8000000) == 0)) {

+          local_518 = iVar8;

+        }

+        uVar5 = *(undefined8 *)(*(longlong *)(local_4e8 + 0x2c0) + lVar17);

+        *(undefined8 *)(puVar19 + -8) = 0x140ad8215;

+        ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+        *(undefined8 *)(puVar19 + -8) = 0x140ad821a;

+        iVar10 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        uVar24 = local_524 & 0xff;

+        if (iVar10 != 0) {

+          uVar24 = 0;

+        }

+        cVar7 = (char)uVar24;

+        if (iVar8 != -0x3fffff6b) {

+          uVar14 = (ulonglong)param_10;

+          lVar17 = local_480;

+          uVar27 = 0xc0000095;

+          goto LAB_1;

+        }

+        local_518 = -0x3fffff6b;

+LAB_2:

+        uVar27 = 0;

+        *(undefined8 *)(puVar19 + -8) = 0x140ad8d69;

+        iVar8 = Feature_1345841464__private_IsEnabledDeviceUsageNoInline();

+        uVar14 = local_4d8;

+        if (iVar8 != 0) {

+          if (local_4d8 != 0) {

+            uVar5 = *(undefined8 *)(uVar30 + 0x420);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad8d86;

+            EtwpDereferenceStackEntry(uVar14,uVar5);

+          }

+          if (cVar7 != '\0') {

+            uVar5 = *(undefined8 *)(*(longlong *)(lVar12 + 0x2c0) + (ulonglong)local_4f0 * 8);

+            *(undefined8 *)(puVar19 + -8) = 0x140ad8da1;

+            ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+          }

+        }

+        lVar17 = local_438;

+        if ((local_538[0] & 8) != 0) {

+          *(undefined8 *)(puVar19 + -8) = 0x140ad8db3;

+          EtwpReleaseStackLookasideListEntry(lVar17);

+        }

+        if (local_518 < 0) {

+          puVar23 = local_4b8 + 5;

+          puVar19[0x58] = 1;

+          *(ulonglong *)(puVar19 + 0x50) = param_11;

+          *(uint *)(puVar19 + 0x48) = param_10;

+          puVar19[0x40] = 1;

+          *(ulonglong **)(puVar19 + 0x38) = puVar23;

+          *(int *)(puVar19 + 0x30) = local_518;

+          *(undefined4 *)(puVar19 + 0x28) = 0;

+          *(ushort *)(puVar19 + 0x20) = local_530;

+          uVar14 = local_4c0;

+          *(undefined8 *)(puVar19 + -8) = 0x140ad8eab;

+          EtwpFailLogging(param_8,param_9,uVar14,local_3b8);

+        }

+        else {

+          local_514 = 0;

+          if (local_b8 != 0) {

+            do {

+              uVar14 = local_3b8[uVar27 * 6 + 2];

+              puVar23 = (ulonglong *)local_3b8[uVar27 * 6 + 3];

+              uVar30 = *puVar23;

+              do {

+                if (0xe < (uVar30 ^ uVar14)) {

+                  LOCK();

+                  *(int *)(local_3b8[uVar27 * 6 + 2] + 0xc) =

+                       *(int *)(local_3b8[uVar27 * 6 + 2] + 0xc) + -1;

+                  UNLOCK();

+                  break;

+                }

+                LOCK();

+                uVar35 = *puVar23;

+                bVar37 = uVar30 == uVar35;

+                if (bVar37) {

+                  *puVar23 = uVar30 + 1;

+                  uVar35 = uVar30;

+                }

+                UNLOCK();

+                uVar30 = uVar35;

+              } while (!bVar37);

+              uVar5 = *(undefined8 *)

+                       (*(longlong *)(lVar12 + 0x2c0) +

+                       (ulonglong)*(uint *)local_3b8[uVar27 * 6] * 8);

+              *(undefined8 *)(puVar19 + -8) = 0x140ad8e38;

+              ExReleaseRundownProtectionCacheAwareEx(uVar5,1);

+              local_514 = local_514 + 1;

+              uVar27 = (ulonglong)local_514;

+            } while (local_514 < local_b8);

+          }

+        }

+        psVar1 = (short *)((longlong)local_430 + 0x1e4);

+        *psVar1 = *psVar1 + 1;

+        if (((*psVar1 == 0) &&

+            (*(longlong **)((longlong)local_430 + 0x98) != (longlong *)((longlong)local_430 + 0x98))

+            ) && (*(short *)((longlong)local_430 + 0x1e6) == 0)) {

+          *(undefined8 *)(puVar19 + -8) = 0x140ad8ed9;

+          KiCheckForKernelApcDelivery();

+        }

+        goto LAB_17;

       }

     }

-    else {

-      LOCK();

-      SepLearningModeTokenCount = SepLearningModeTokenCount + unaff_EDI;

-      UNLOCK();

-      *(uint *)(in_stack_00000058 + 200) = *(uint *)(in_stack_00000058 + 200) | 0x3000000;

-    }

-    LOCK();

-    UNLOCK();

-    lVar2 = ExpLuid + 1;

-    ExpLuid = ExpLuid + 1;

-    *(longlong *)(in_stack_00000058 + 0x38) = lVar2;

-    LOCK();

-    UNLOCK();

-    ExReleaseResourceLite(*(undefined8 *)(in_stack_00000058 + 0x30));

-    KeLeaveCriticalRegion();

-    unaff_EBX = ObInsertObjectEx(in_stack_00000058,0,in_stack_00000090._4_4_,unaff_EDI);

-    cVar1 = unaff_R13B;

-    cStack0000000000000051 = unaff_R13B;

-    if ((-1 < unaff_EBX) &&

-       (unaff_EBX = SepAppendAceToTokenObjectAcl(in_stack_00000058,0xf01ff,in_stack_00000068),

-       cVar1 = cStack0000000000000050, -1 < unaff_EBX)) {

-      SepFinalizeTokenAcls(in_stack_00000058);

-      ObfDereferenceObject(in_stack_00000058);

-      cVar1 = unaff_R13B;

-    }

   }

-  if (cStack0000000000000051 != unaff_R13B) {

-    if (-1 < unaff_EBX) {

-      LOCK();

-      UNLOCK();

-      lVar2 = ExpLuid + 1;

-      ExpLuid = ExpLuid + 1;

-      *(longlong *)(in_stack_00000058 + 0x38) = lVar2;

-    }

-    LOCK();

-    UNLOCK();

-    ExReleaseResourceLite(*(undefined8 *)(in_stack_00000058 + 0x30));

-    KeLeaveCriticalRegion();

-  }

-  if (unaff_EBX < 0) {

-    if (cVar1 != '\0') {

-      ObfDereferenceObject(in_stack_00000058);

-    }

-    if (in_stack_000000b8 != 0) {

-      ObCloseHandle(in_stack_000000b8,unaff_R12B);

-    }

-  }

-  if (in_stack_00000070 != 0) {

-    SeReleaseSidAndAttributesArray(in_stack_00000070,unaff_R12B);

-  }

-  if (in_stack_00000068 != 0) {

-    SeReleaseSid(in_stack_00000068,unaff_R12B,(char)unaff_EDI);

-  }

-  if (in_stack_00000078 != 0) {

-    ObfDereferenceObject(in_stack_00000078);

-  }

-  if (in_stack_000000b0 != 0) {

-    ExFreePoolWithTag(in_stack_000000b0,0);

-  }

-  if (-1 < unaff_EBX) {

-    *in_stack_00000180 = in_stack_000000b8;

-  }

-  return unaff_EBX;

+  else if (param_10 != 0) goto LAB_0;

+  puVar19 = local_598;

+  local_518 = -0x3ffffff3;

+LAB_17:

+  *(undefined8 *)(puVar19 + -8) = 0x140ad8eeb;

+  return local_518;

 }
```

## `ExpWnfQueryCurrentUserSID`  (modified)

```diff
--- ExpWnfQueryCurrentUserSID
+++ ExpWnfQueryCurrentUserSID
@@ -1,34 +1,42 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-undefined8 ExpWnfQueryCurrentUserSID(uint param_1)

+int ExpWnfQueryCurrentUserSID

+              (longlong param_1,longlong param_2,undefined8 param_3,undefined4 *param_4,

+              uint *param_5)

 

 {

-  longlong in_RAX;

-  undefined4 unaff_EBX;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  int unaff_R12D;

-  int unaff_R14D;

+  int iVar1;

+  longlong lVar2;

+  int iVar3;

+  undefined1 local_res10 [8];

+  int local_28;

+  int local_24 [3];

   

-  if (*(uint *)(in_RAX + 0x40) < param_1) {

-    *(uint *)(in_RAX + 0x40) = param_1;

+  local_28 = 0;

+  local_24[0] = 0;

+  if (param_2 == 0) {

+    lVar2 = PsReferencePrimaryTokenWithTag();

+    iVar3 = 1;

   }

-  if (*(uint *)(*(longlong *)(unaff_RDI + 0x10) + 0x3c) < *(uint *)(unaff_RBP + -0x71)) {

-    *(uint *)(*(longlong *)(unaff_RDI + 0x10) + 0x3c) = *(uint *)(unaff_RBP + -0x71);

+  else {

+    lVar2 = PsReferenceEffectiveToken(param_2,0x74726853,&local_28,local_res10,local_24,0);

+    iVar3 = local_28;

+    if ((local_24[0] < 2) && (local_28 == 2)) {

+      if (lVar2 != 0) {

+        ObfDereferenceObjectWithTag(lVar2,0x74726853);

+      }

+      return -0x3fffff5b;

+    }

   }

-  HvFreeCell();

-  *(undefined4 *)(unaff_RBP + -0x7d) = unaff_EBX;

-  CmpValueEnumStackCleanup(unaff_RBP + -0x49);

-  if (*(int *)(unaff_RBP + -0x7d) != -1) {

-    CmpFreeKeyValueList();

+  iVar1 = SeQueryUserSidToken(lVar2,param_3,*param_4,param_4);

+  if (iVar3 == 1) {

+    ObFastDereferenceObject(param_1 + 0x248,lVar2,0x74726853);

   }

-  if (unaff_R14D != -1) {

-    HvFreeCell();

+  else if (lVar2 != 0) {

+    ObfDereferenceObjectWithTag(lVar2,0x74726853);

   }

-  if (unaff_R12D != -1) {

-    HvFreeCell();

+  if (-1 < iVar1) {

+    *param_5 = (uint)(iVar3 == 1);

   }

-  return 0;

+  return iVar1;

 }
```

## `EtwpTraceThreadRundown`  (modified)

```diff
--- EtwpTraceThreadRundown
+++ EtwpTraceThreadRundown
@@ -1,15 +1,169 @@
 

-void EtwpTraceThreadRundown(longlong param_1,undefined8 param_2,undefined8 param_3,int param_4)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+void EtwpTraceThreadRundown(void *param_1,longlong param_2)

 

 {

-  char in_AL;

-  undefined7 in_register_00000001;

-  char in_CF;

+  short *psVar1;

+  short sVar2;

+  uint uVar3;

+  ushort *puVar4;

+  void *pvVar5;

+  int iVar6;

+  longlong lVar7;

+  uint uVar8;

+  uint uVar9;

+  bool bVar10;

+  undefined1 auStack_128 [32];

+  undefined4 local_108;

+  short local_100;

+  uint local_f8;

+  undefined1 local_f0;

+  short local_e8;

+  short local_e6;

+  undefined4 local_e4;

+  uint local_e0;

+  undefined4 local_dc;

+  undefined4 *local_d8;

+  void *local_d0;

+  undefined4 local_c8;

+  undefined4 *local_c0;

+  undefined4 local_b8;

+  undefined4 local_b4;

+  undefined8 local_b0;

+  undefined8 local_a8;

+  ulonglong local_a0;

+  ulonglong local_98;

+  undefined8 local_90;

+  undefined8 local_88;

+  longlong local_80;

+  undefined4 local_78;

+  undefined1 local_74;

+  undefined1 local_73;

+  undefined1 local_72;

+  bool local_71;

+  undefined8 local_70;

+  undefined4 *local_68;

+  undefined8 local_60;

+  undefined *local_58;

+  ulonglong local_50;

+  undefined *local_48;

+  undefined8 local_40;

+  ulonglong local_38;

   

-  *(char *)(param_1 + -0x39) = *(char *)(param_1 + -0x39) + (char)param_1;

-  *(char *)CONCAT71(in_register_00000001,in_AL + in_CF) =

-       *(char *)CONCAT71(in_register_00000001,in_AL + in_CF) << 4;

-                    /* WARNING: Subroutine does not return */

-  KeBugCheckEx(param_4 + 0x34);

+  pvVar5 = SystemReserved1[0xf];

+  local_38 = __security_cookie ^ (ulonglong)auStack_128;

+  local_e4 = 2;

+  local_dc = 2;

+  local_90 = 0;

+  local_70 = 0;

+  local_d8 = *(undefined4 **)(param_2 + 0x20);

+  uVar9 = *(uint *)(param_2 + 0x28);

+  local_e8 = 0x504 - (ushort)(*(char *)(param_2 + 0x40) != '\0');

+  if (param_1 != SystemReserved1[0xf]) {

+    uVar9 = uVar9 & 0xffffe7ff;

+  }

+  local_b8 = *(undefined4 *)((longlong)param_1 + 0x508);

+  local_b4 = *(undefined4 *)((longlong)param_1 + 0x510);

+  local_b0 = *(undefined8 *)((longlong)param_1 + 0x38);

+  local_a8 = *(undefined8 *)((longlong)param_1 + 0x30);

+  if (*(ushort *)((longlong)param_1 + 0x248) < **(ushort **)((longlong)param_1 + 0x240)) {

+    local_90 = *(undefined8 *)

+                (*(ushort **)((longlong)param_1 + 0x240) +

+                (ulonglong)*(ushort *)((longlong)param_1 + 0x248) * 4 + 4);

+  }

+  local_88 = *(undefined8 *)((longlong)param_1 + 0x560);

+  local_80 = *(longlong *)((longlong)param_1 + 0xf0);

+  local_a0 = 0;

+  local_98 = 0;

+  local_78 = 0;

+  local_74 = *(undefined1 *)((longlong)param_1 + 0x233);

+  uVar8 = *(uint *)((longlong)param_1 + 0x5a0) >> 0xc & 7;

+  lVar7 = *(longlong *)(*(longlong *)((longlong)param_1 + 0x220) + 0x2a0);

+  if ((lVar7 != 0) && (uVar3 = *(uint *)(lVar7 + 0x444), uVar3 <= uVar8)) {

+    uVar8 = uVar3;

+  }

+  local_73 = (undefined1)uVar8;

+  uVar8 = *(uint *)((longlong)param_1 + 0x5a0) >> 9 & 7;

+  lVar7 = *(longlong *)(*(longlong *)((longlong)param_1 + 0x220) + 0x2a0);

+  if ((lVar7 != 0) && (uVar3 = *(uint *)(lVar7 + 0x43c), (int)uVar3 <= (int)uVar8)) {

+    uVar8 = uVar3;

+  }

+  if ((((int)uVar8 < 2) && (param_1 == SystemReserved1[0xf])) &&

+     (*(int *)((longlong)param_1 + 0x5e0) != 0)) {

+    uVar8 = 2;

+  }

+  local_72 = (undefined1)uVar8;

+  local_71 = false;

+  if ((*(byte *)((longlong)param_1 + 0x5a8) & 8) != 0) {

+    local_71 = *(longlong **)((longlong)param_1 + 0x4d8) != (longlong *)((longlong)param_1 + 0x4d8);

+  }

+  if ((local_80 != 0) && (*(char *)(param_2 + 0x41) != '\0')) {

+    if ((*(longlong *)(*(longlong *)((longlong)param_1 + 0x220) + 0x310) == 0) ||

+       ((sVar2 = *(short *)(*(longlong *)((longlong)param_1 + 0x220) + 0x6ec), sVar2 != 0x14c &&

+        (sVar2 != 0x1c4)))) {

+      local_c8 = *(undefined4 *)(local_80 + 0x1720);

+      local_a0 = *(ulonglong *)(local_80 + 8);

+      local_98 = *(ulonglong *)(local_80 + 0x10);

+      local_78 = local_c8;

+    }

+    else {

+      local_78 = *(undefined4 *)(local_80 + 0x2f60);

+      local_a0 = (ulonglong)*(uint *)(local_80 + 0x2004);

+      local_98 = (ulonglong)*(uint *)(local_80 + 0x2008);

+    }

+  }

+  local_68 = &local_b8;

+  local_60 = 0x48;

+  local_e6 = local_e8;

+  local_e0 = uVar9;

+  local_d0 = param_1;

+  local_c0 = local_d8;

+  iVar6 = Feature_1224463674__private_IsEnabledDeviceUsageNoInline();

+  if (iVar6 != 0) {

+    psVar1 = (short *)((longlong)pvVar5 + 0x1e4);

+    *psVar1 = *psVar1 + -1;

+    lVar7 = KeAbPreAcquire((longlong)param_1 + 0x590,0,0);

+    LOCK();

+    bVar10 = *(longlong *)((longlong)param_1 + 0x590) == 0;

+    if (bVar10) {

+      *(longlong *)((longlong)param_1 + 0x590) = 0x11;

+    }

+    UNLOCK();

+    if (!bVar10) {

+      ExfAcquirePushLockSharedEx((longlong)param_1 + 0x590,0,lVar7,(longlong)param_1 + 0x590);

+    }

+    if (lVar7 != 0) {

+      *(undefined1 *)(lVar7 + 10) = 1;

+    }

+  }

+  puVar4 = *(ushort **)((longlong)param_1 + 0x6a0);

+  if ((puVar4 == (ushort *)0x0) ||

+     (local_58 = *(undefined **)(puVar4 + 4), local_58 == (undefined *)0x0)) {

+    local_58 = &EtwpNull;

+    local_50 = 2;

+  }

+  else {

+    local_50 = 0x800;

+    if (*puVar4 < 0x800) {

+      local_50 = (ulonglong)*puVar4;

+    }

+    if (((int)local_50 == 0) || (*(short *)(local_58 + ((local_50 & 0xfffffffffffffffe) - 2)) != 0))

+    {

+      local_48 = &EtwpNull;

+      local_40 = 2;

+      local_e4 = 3;

+    }

+  }

+  local_f0 = 0;

+  local_100 = local_e8;

+  local_108 = local_e4;

+  local_f8 = uVar9;

+  EtwpLogSystemEventUnsafe(*(undefined8 *)(local_d8 + 0x154),&local_68,param_1,*local_d8);

+  iVar6 = Feature_1224463674__private_IsEnabledDeviceUsageNoInline();

+  if (iVar6 != 0) {

+    PspUnlockThreadSecurityShared(param_1,pvVar5);

+  }

+  return;

 }
```

## `PspAllocateProcess`  (modified)

```diff
--- PspAllocateProcess
+++ PspAllocateProcess
@@ -1,144 +1,1597 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-longlong PspAllocateProcess(void)

+ulonglong PspAllocateProcess(ulonglong param_1,undefined1 param_2,undefined8 param_3,

+                            undefined1 param_4,undefined1 param_5,undefined1 param_6,

+                            longlong param_7,undefined8 param_8,uint param_9,uint param_10,

+                            longlong param_11,int param_12,longlong param_13,undefined8 param_14,

+                            undefined8 param_15)

 

 {

-  ulonglong uVar1;

-  code *pcVar2;

-  char cVar3;

-  int iVar4;

-  undefined8 in_RAX;

+  uint *puVar1;

+  undefined1 uVar2;

+  void *_Src;

+  undefined4 *puVar3;

+  undefined8 uVar4;

   undefined8 uVar5;

-  longlong lVar6;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  char cVar7;

-  uint unaff_R12D;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  longlong unaff_R15;

+  code *pcVar6;

+  undefined4 uVar7;

+  undefined4 uVar8;

+  bool bVar9;

+  undefined8 *puVar10;

+  char cVar11;

+  char cVar12;

+  byte bVar13;

+  undefined1 uVar14;

+  ushort uVar15;

+  ushort uVar16;

+  int iVar17;

+  uint uVar18;

+  int iVar19;

+  uint uVar20;

+  undefined4 uVar21;

+  ulonglong uVar22;

+  longlong lVar23;

+  longlong *plVar24;

+  void *_Dst;

+  longlong lVar25;

+  undefined8 uVar26;

+  undefined8 *puVar27;

+  ulonglong uVar28;

+  ulonglong uVar29;

+  undefined1 *puVar30;

+  undefined1 *puVar31;

+  ulonglong uVar32;

+  undefined2 uVar33;

+  undefined8 *puVar34;

+  undefined8 *puVar35;

+  uint uVar36;

+  ulonglong uVar37;

+  undefined1 *puVar38;

+  uint uVar39;

+  undefined1 *_Dst_00;

   undefined4 extraout_XMM0_Da;

-  undefined4 extraout_XMM0_Da_00;

-  undefined4 uVar8;

-  undefined4 extraout_XMM0_Da_01;

-  undefined4 extraout_XMM0_Da_02;

-  undefined1 auStackX_8 [24];

-  longlong *in_stack_00000078;

+  undefined1 auStack_838 [8];

+  undefined1 auStack_830 [32];

+  uint local_810;

+  undefined4 local_808;

+  uint local_800;

+  undefined1 **local_7f8;

+  undefined8 local_7f0;

+  undefined1 local_7b8;

+  uint local_7b4;

+  uint local_7a8;

+  undefined1 local_7a4;

+  undefined1 local_7a3;

+  ulonglong local_7a0;

+  undefined1 *local_798;

+  undefined2 local_790;

+  undefined4 uStack_78c;

+  undefined4 local_788;

+  undefined4 local_784;

+  undefined8 local_780;

+  undefined2 local_778;

+  undefined4 local_770;

+  undefined4 local_76c;

+  undefined4 local_768;

+  undefined4 local_764;

+  undefined4 local_760;

+  ushort local_75c;

+  undefined4 local_754;

+  undefined4 local_750;

+  undefined4 local_74c;

+  longlong local_748;

+  longlong local_740;

+  undefined8 local_738;

+  undefined8 local_730;

+  uint local_728;

+  undefined4 local_71c;

+  undefined4 local_718;

+  undefined4 local_714;

+  undefined4 local_710;

+  undefined4 local_70c;

+  undefined8 local_708;

+  ulonglong local_700;

+  void *local_6f8;

+  longlong local_6f0;

+  uint local_6e0;

+  undefined4 local_6dc;

+  uint local_6d8;

+  undefined8 local_6d0;

+  undefined8 local_6c8;

+  undefined8 local_6b8;

+  undefined8 local_6b0;

+  longlong local_698;

+  undefined8 local_690;

+  undefined8 local_688;

+  undefined8 local_680;

+  longlong local_668;

+  undefined8 local_658;

+  ulonglong local_650;

+  undefined8 local_648;

+  undefined8 local_640;

+  undefined8 local_628;

+  undefined8 uStack_620;

+  undefined8 local_618;

+  undefined8 uStack_610;

+  undefined8 local_608;

+  undefined8 uStack_600;

+  undefined8 local_5f8;

+  undefined4 uStack_5f0;

+  undefined8 local_5e8;

+  undefined8 uStack_5e0;

+  undefined8 local_5d8;

+  undefined8 uStack_5d0;

+  undefined8 local_5c8;

+  undefined4 uStack_5c0;

+  undefined1 local_4b8 [80];

+  undefined8 local_468;

+  undefined8 uStack_460;

+  undefined8 local_458;

+  undefined8 local_450;

+  undefined8 uStack_448;

+  undefined8 local_440;

+  undefined8 local_438;

+  undefined8 uStack_430;

+  undefined8 local_428;

+  undefined8 uStack_420;

+  undefined8 local_418;

+  undefined8 local_410;

+  undefined8 uStack_408;

+  undefined8 local_400;

+  undefined8 uStack_3f8;

+  undefined8 local_3f0;

+  undefined8 uStack_3e8;

+  ulonglong local_3d0 [33];

+  undefined1 local_2c8 [524];

+  undefined4 local_bc;

+  undefined4 local_a8 [8];

+  ushort local_88 [32];

+  ulonglong local_48;

   

-  *(undefined8 *)(unaff_RSI + 0x30) = in_RAX;

-  *(longlong *)(unaff_RSI + 0x38) = unaff_RBP + 0x230;

-  *(longlong *)(unaff_RSI + 0x40) = unaff_RBP + 0x240;

-  *(longlong *)(unaff_RSI + 0x48) = unaff_RBP + 0x250;

-  *(longlong *)(unaff_RSI + 0x50) = unaff_RBP + 0x260;

-  *(longlong *)(unaff_RSI + 0x58) = unaff_RBP + 0x270;

-  *(longlong *)(unaff_RSI + 0x60) = unaff_RBP + 0x280;

-  *(longlong *)(unaff_RSI + 0x68) = unaff_RBP + 0x290;

-  *(longlong *)(unaff_RSI + 0x70) = unaff_RBP + 0x2a0;

-  *(longlong *)(unaff_RSI + 0x78) = unaff_RBP + 0x2b0;

-  *(longlong *)(unaff_RSI + 0xa0) = unaff_RBP + 0xb8;

-  do {

-    uVar1 = *(ulonglong *)(unaff_RBP + 0x118);

-    cVar7 = (char)unaff_R13;

-    if ((uVar1 < 0xffff800000000000) ||

-       (cVar3 = RtlpIsFrameInBoundsEx

-                          (unaff_RBP + -0x68,*(undefined8 *)(unaff_RBP + 0xb8),unaff_RBP + -0x70,

-                           unaff_RBP + -0x20), cVar3 == '\0')) {

-      if (((KdDebuggerEnabled != cVar7) && (KdDebuggerNotPresent == cVar7)) ||

-         (PspBreakOnContextUnwindFailure != (int)unaff_R13)) {

-        pcVar2 = (code *)swi(0x2c);

-        (*pcVar2)();

-        register0x00000020 = (BADSPACEBASE *)auStackX_8;

-      }

+  puVar30 = auStack_838;

+  puVar31 = auStack_838;

+  local_48 = __security_cookie ^ (ulonglong)auStack_838;

+  local_740 = param_7;

+  local_708 = param_8;

+  local_668 = param_11;

+  local_6f0 = param_13;

+  local_648 = param_14;

+  local_640 = param_15;

+  uVar32 = 0;

+  local_6dc = 0;

+  local_410 = 0;

+  uStack_408 = 0;

+  local_400 = 0;

+  uStack_3f8 = 0;

+  local_3f0 = 0;

+  uStack_3e8 = 0;

+  local_bc = 0;

+  local_618 = 0;

+  uStack_610 = 0;

+  local_608 = 0;

+  uStack_600 = 0;

+  local_5f8 = 0;

+  uStack_5f0 = 0;

+  local_71c = 0;

+  local_628 = 0;

+  uStack_620 = 0;

+  local_6d0 = 0;

+  local_7b8 = param_2;

+  local_7a0 = param_1;

+  local_730 = param_3;

+  local_650 = param_1;

+  memset(local_3d0,0,0x100);

+  uVar18 = 0;

+  local_7b4 = 0;

+  local_768 = 0;

+  local_468 = 0;

+  uStack_460 = 0;

+  local_458 = 0;

+  local_450 = 0;

+  uStack_448 = 0;

+  local_440 = 0;

+  cVar12 = '\0';

+  local_7a3 = 0;

+  local_5e8 = 0;

+  uStack_5e0 = 0;

+  local_5d8 = 0;

+  uStack_5d0 = 0;

+  local_5c8 = 0;

+  uStack_5c0 = 0;

+  local_6c8 = 0;

+  local_798 = (undefined1 *)0x0;

+  local_7a4 = 0;

+  local_778 = 0;

+  uStack_78c = 0;

+  memset(local_4b8,0,0x48);

+  local_760 = 0;

+  local_658 = 0;

+  local_6f8 = SystemReserved1[0xf];

+  local_748 = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+  local_780 = 0;

+  local_6b0 = 0;

+  local_76c = 0;

+  local_788 = 0;

+  local_784 = 0;

+  local_74c = 0;

+  local_750 = 0;

+  local_770 = 0x8664;

+  local_718 = 0;

+  local_70c = 0;

+  local_710 = 0;

+  local_764 = 0;

+  local_680 = 0;

+  local_714 = 0;

+  local_688 = 0;

+  local_790 = 0;

+  local_738 = 0;

+  local_690 = 0;

+  memset(local_2c8,0,0x218);

+  local_7a8 = param_9;

+  if ((param_9 >> 0xb & 1) == 0) {

+    uVar28 = uVar32;

+    if (param_7 == 0) {

+      local_7b4 = (-(uint)(param_1 != 0) & 3) + 1;

 LAB_0:

-      in_stack_00000078 = *(longlong **)((longlong)register0x00000020 + 0x78);

-      iVar4 = -0x3fffffff;

-      goto LAB_1;

-    }

-    uVar5 = RtlpLookupFunctionEntryForStackWalks(uVar1,unaff_RBP + -0x50);

-    if (*(longlong *)(unaff_RBP + -0x48) == 0) goto LAB_0;

-    iVar4 = RtlVirtualUnwind2(0,*(longlong *)(unaff_RBP + -0x48),uVar1,uVar5,unaff_RBP + 0x20);

-    if (iVar4 < 0) {

-      if (((KdDebuggerEnabled != cVar7) && (KdDebuggerNotPresent == cVar7)) ||

-         (PspBreakOnContextUnwindFailure != (int)unaff_R13)) {

-        pcVar2 = (code *)swi(0x2c);

-        (*pcVar2)();

-        register0x00000020 = (BADSPACEBASE *)auStackX_8;

-      }

-      goto LAB_0;

-    }

-  } while (*(longlong *)(unaff_RBP + -0x60) != unaff_RDI);

-  if (*(longlong *)(unaff_RBP + -0x78) == unaff_R13) {

-    if (((unaff_R12D & 0x100008) == 0x100008) && (*(char *)(unaff_R14 + 0x58) == '\x01')) {

-      _fxsave(*(longlong *)(unaff_R14 + 0x78) + 0x100);

-    }

-    if ((*(longlong *)(unaff_R15 + 0x6a8) == unaff_R13) || (*(char *)(unaff_R14 + 0x58) != '\x01'))

-    {

-      func_0x000140998230();

-    }

-    else {

-      lVar6 = *(longlong *)(unaff_R14 + 0x78);

-      func_0x000140998230();

-      if ((*(byte *)(unaff_R15 + 3) & 8) != 0) {

-        RtlCopyContext(lVar6,*(undefined4 *)(lVar6 + 0x30),*(undefined8 *)(unaff_R15 + 0x6a8));

-      }

+      uVar28 = (ulonglong)local_7b4;

     }

   }

   else {

-    uVar8 = extraout_XMM0_Da;

-    if ((unaff_R12D & 0x100008) == 0x100008) {

-      if (*(char *)(unaff_R14 + 0x58) == '\x01') {

-        unaff_R13 = *(longlong *)(unaff_R14 + 0x78) + 0x100;

-        goto LAB_2;

-      }

-    }

-    else if (*(char *)(unaff_R14 + 0x58) == '\x01') {

-LAB_2:

-      uVar5 = *(undefined8 *)(unaff_R14 + 0x78);

-      *(undefined8 *)(unaff_RBP + -0x78) = 0;

-      iVar4 = KeVerifyContextXStateCetU(extraout_XMM0_Da,uVar5,unaff_RBP + -0x78);

-      if (iVar4 < 0) goto LAB_1;

-      uVar8 = extraout_XMM0_Da_00;

-      if ((*(byte *)(unaff_R14 + 0x59) & 4) != 0) {

-        uVar5 = *(undefined8 *)(unaff_R14 + 0x78);

-        *(undefined8 *)(unaff_RBP + -0x38) = 0;

-        *(undefined8 *)(unaff_RBP + -0x30) = 0;

-        *(undefined4 *)(unaff_RBP + -0x38) = 3;

-        *(undefined8 *)(unaff_RBP + -0x28) = 0;

-        iVar4 = KeVerifyContextIpForUserCet(0,uVar5,unaff_RBP + -0x38,unaff_RBP + -0x78);

-        uVar8 = extraout_XMM0_Da_02;

-        if (iVar4 < 0) goto LAB_1;

-      }

-    }

-    cVar7 = *(char *)(unaff_R14 + 0x58);

-    if ((cVar7 == '\x01') &&

-       (iVar4 = RtlpValidateContextXStateDisabledFeatures

-                          (*(undefined8 *)(unaff_R14 + 0x78),*(undefined8 *)(unaff_R15 + 0x428)),

-       uVar8 = extraout_XMM0_Da_01, iVar4 < 0)) goto LAB_1;

-    if ((*(longlong *)(unaff_R15 + 0x6a8) != 0) && (cVar7 == '\x01')) {

-      if ((*(byte *)(unaff_R14 + 0x59) & 2) != 0) {

-        PspSetContextState(uVar8,*(undefined8 *)(unaff_R14 + 0x78));

-        goto LAB_3;

-      }

-      if ((*(byte *)(unaff_R15 + 3) & 8) != 0) {

-        lVar6 = FUN_140b21f92();

-        return lVar6;

-      }

-    }

-    func_0x000140998640();

+    local_7b4 = 2;

+    uVar28 = 2;

+    if ((param_9 >> 0xd & 1) != 0) {

+      local_7b4 = 6;

+      uVar28 = 6;

+      if ((param_9 >> 0xe & 1) != 0) {

+        local_7b4 = 0xe;

+        goto LAB_0;

+      }

+    }

+  }

+  if ((uVar28 & 4) == 0) {

+    if ((param_9 >> 0xc & 1) == 0) goto LAB_1;

+  }

+  else if ((param_12 == 0) || ((uVar28 & 2) != 0)) {

+    if ((*(uint *)(param_1 + 0x5fc) & 0x1000) != 0) {

+      uVar22 = 0xc000000d;

+      puVar38 = auStack_838;

+      goto LAB_2;

+    }

+LAB_1:

+    local_700 = -(ulonglong)((param_9 & 0x100) != 0) & param_1;

+    if ((param_11 == 0) || ((*(uint *)(param_11 + 8) >> 0xd & 1) == 0)) {

+      if ((param_1 != 0) && ((*(uint *)(param_1 + 0x1f0) & 0x200000) != 0)) {

+        local_784 = 0x200000;

+        local_700 = param_1;

+      }

+    }

+    else {

+      if (local_700 != 0) goto LAB_3;

+      local_780 = (&KeNodeBlock)[*(ushort *)(param_11 + 0xaa)];

+    }

+    if ((param_11 != 0) && ((*(uint *)(param_11 + 8) >> 0x12 & 1) != 0)) {

+      local_7b4 = (uint)uVar28 | 0x10000;

+      uVar28 = (ulonglong)local_7b4;

+      *(byte *)(param_11 + 0x10) = *(byte *)(param_11 + 0x10) & 0xef;

+    }

+    local_438 = 0;

+    uStack_430 = 0;

+    local_428 = 0;

+    uStack_420 = 0;

+    local_418 = 0;

+    local_6b8 = 0;

+    uVar36 = 0x840;

+    local_728 = 0;

+    local_698 = 0;

+    if (PsDisableDiskCounters == 0) {

+      uVar36 = 0x868;

+      local_7b4 = (uint)uVar28 | 0x8000;

+      uVar28 = (ulonglong)local_7b4;

+      local_698 = 0x840;

+    }

+    uVar20 = uVar36 + 0x10;

+    local_6d8 = uVar36;

+    cVar11 = PoEnergyEstimationEnabled();

+    if (cVar11 != '\0') {

+      local_728 = uVar36 + 0x10;

+      uVar20 = uVar36 + 0x1f8;

+      local_7b4 = (uint)uVar28 | 0x20000;

+      uVar28 = (ulonglong)local_7b4;

+    }

+    local_75c = KeQueryMaximumGroupCount();

+    local_6e0 = uVar20;

+    uVar36 = uVar18;

+    if (1 < local_75c) {

+      local_6e0 = uVar20 + (uint)local_75c * 0x10;

+      uVar36 = uVar20;

+    }

+    local_754 = 0;

+    uVar20 = (uint)uVar28;

+    uVar22 = uVar32;

+    if ((uVar28 & 0x10002) == 0) {

+      if (local_7a0 != 0) {

+        uVar22 = 4;

+      }

+      local_754 = (undefined4)uVar22;

+    }

+    iVar17 = KeSizeOfKProcessExtension(uVar22);

+    uVar39 = local_6e0 + iVar17;

+    local_7f0 = 0;

+    local_7f8 = &local_798;

+    local_808 = 0;

+    local_810 = uVar39;

+    local_800 = uVar39;

+    uVar22 = ObCreateObjectEx(local_7b8,PsProcessType,local_730);

+    _Dst_00 = local_798;

+    puVar38 = auStack_838;

+    if ((int)uVar22 < 0) goto LAB_2;

+    ObRetagReferences(local_798);

+    memset(_Dst_00,0,(ulonglong)uVar39);

+    *(undefined8 *)(_Dst_00 + 0x580) = 0;

+    *(undefined8 *)(_Dst_00 + 0x588) = 0;

+    *(undefined8 *)(_Dst_00 + 0x590) = 0;

+    *(undefined8 *)(_Dst_00 + 0x598) = 0;

+    *(undefined8 *)(_Dst_00 + 0x580) = 0;

+    puVar38 = _Dst_00 + 0x588;

+    *(undefined1 **)(_Dst_00 + 0x590) = puVar38;

+    *(undefined1 **)puVar38 = puVar38;

+    *(undefined8 *)(_Dst_00 + 0x1e8) = 0;

+    *(undefined8 *)(_Dst_00 + 0x1c8) = 0;

+    puVar38 = _Dst_00 + 0x370;

+    *(undefined1 **)(_Dst_00 + 0x378) = puVar38;

+    *(undefined1 **)puVar38 = puVar38;

+    puVar38 = _Dst_00 + 0x620;

+    *(undefined1 **)(_Dst_00 + 0x628) = puVar38;

+    *(undefined1 **)puVar38 = puVar38;

+    puVar38 = _Dst_00 + 0x710;

+    *(undefined1 **)(_Dst_00 + 0x718) = puVar38;

+    *(undefined1 **)puVar38 = puVar38;

+    _Dst_00[0x5fa] = param_4;

+    _Dst_00[0x5f8] = param_5;

+    _Dst_00[0x5f9] = param_6;

+    *(undefined8 *)(_Dst_00 + 0x658) = 0;

+    *(undefined8 *)(_Dst_00 + 0x788) = 0;

+    *(undefined8 *)(_Dst_00 + 0x780) = 0;

+    *(undefined8 *)(_Dst_00 + 0x798) = 0;

+    *(undefined8 *)(_Dst_00 + 0x790) = 0;

+    *(undefined8 *)(_Dst_00 + 0x7a8) = 0;

+    *(undefined8 *)(_Dst_00 + 0x818) = 0;

+    if ((uVar28 & 2) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 1;

+    }

+    if ((local_7a8 >> 0xf & 1) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x20;

+    }

+    local_730 = CONCAT44(local_730._4_4_,0x20);

+    if ((local_7a8 >> 0x13 & 1) != 0) {

+      LOCK();

+      *(uint *)(_Dst_00 + 0x7dc) = *(uint *)(_Dst_00 + 0x7dc) | 4;

+      UNLOCK();

+      local_7a8 = param_9;

+      _Dst_00 = local_798;

+    }

+    if (uVar36 != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x80;

+      *(undefined1 **)(_Dst_00 + 0x6c8) = _Dst_00 + uVar36;

+      *(undefined1 **)(_Dst_00 + 0x6d0) = _Dst_00 + uVar36 + (ulonglong)local_75c * 8;

+    }

+    if ((param_10 & 1) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x1000;

+    }

+    if ((param_10 & 4) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x800000;

+    }

+    if ((param_10 & 8) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x8000000;

+    }

+    if ((param_10 & 0x10) != 0) {

+      *(uint *)(_Dst_00 + 0x5fc) = *(uint *)(_Dst_00 + 0x5fc) | 0x40000000;

+    }

+    uVar22 = *(ulonglong *)(local_748 + 0x1d0) | 2;

+    if ((local_7a8 >> 9 & 1) != 0) {

+      uVar22 = *(ulonglong *)(local_748 + 0x1d0);

+    }

+    *(ulonglong *)(_Dst_00 + 0x2d8) = uVar22;

+    if ((uVar20 >> 0xf & 1) != 0) {

+      *(undefined1 **)(_Dst_00 + 0x638) = _Dst_00 + local_698;

+    }

+    *(undefined1 **)(_Dst_00 + 0x7f0) = _Dst_00 + local_6d8;

+    if (uVar20 >> 0x11 != 0) {

+      *(undefined1 **)(_Dst_00 + 0x668) = _Dst_00 + local_728;

+      PoEnergyContextInitialize();

+    }

+    uVar22 = local_7a0;

+    if ((param_11 == 0) || ((*(uint *)(param_11 + 8) >> 9 & 1) == 0)) {

+      if (local_7a0 == 0) {

+        uVar21 = 5;

+      }

+      else {

+        uVar21 = *(undefined4 *)(local_7a0 + 0x388);

+      }

+    }

+    else {

+      uVar21 = *(undefined4 *)(param_11 + 0x13c);

+    }

+    *(undefined4 *)(_Dst_00 + 0x388) = uVar21;

+    *(undefined4 *)(_Dst_00 + 0x554) = 0x103;

+    if (local_7a0 == 0) {

+      uVar39 = 2;

+      uVar36 = KeQueryHeteroCpuPolicyThread();

+    }

+    else {

+      uVar39 = *(uint *)(local_7a0 + 500) >> 0x1b & 7;

+      uVar36 = *(uint *)(local_7a0 + 0x1f0) >> 0xc & 7;

+      *(undefined8 *)(_Dst_00 + 0x2d0) = *(undefined8 *)(local_7a0 + 0x1d0);

+    }

+    *(uint *)(_Dst_00 + 500) = uVar39 << 0x1b | *(uint *)(_Dst_00 + 500) & 0xc7ffffff;

+    *(uint *)(_Dst_00 + 0x1f0) = *(uint *)(_Dst_00 + 0x1f0) & 0xffff8fff | uVar36 << 0xc;

+    lVar23 = PspSystemPartition;

+    if (local_6f0 != 0) {

+      cVar11 = PsReferencePartitionSafe(local_6f0);

+      lVar23 = local_6f0;

+      puVar38 = auStack_838;

+      if (cVar11 != '\0') goto LAB_4;

+      uVar22 = 0xc00004a0;

+      goto LAB_5;

+    }

+    local_6f0 = PspSystemPartition;

+    LOCK();

+    plVar24 = (longlong *)(PspSystemPartition + 0x28);

+    lVar25 = *plVar24;

+    *plVar24 = *plVar24 + 1;

+    UNLOCK();

+    if (lVar25 + 1 < 2) {

+      pcVar6 = (code *)swi(0x29);

+      (*pcVar6)(0xe);

+      puVar30 = auStack_830;

+    }

+    *(undefined4 *)(puVar30 + 0x90) = *(undefined4 *)(puVar30 + 0x880);

+    _Dst_00 = *(undefined1 **)(puVar30 + 0xa0);

+    puVar38 = puVar30;

+LAB_4:

+    puVar31 = puVar38;

+    *(longlong *)(_Dst_00 + 0x758) = lVar23;

+    lVar23 = 0;

+    if (*(longlong *)(puVar31 + 0xf8) != 0) {

+      *(undefined8 *)(puVar31 + -8) = 0x140995d16;

+      ObfReferenceObject();

+      lVar23 = *(longlong *)(puVar31 + 0xf8);

+    }

+    if (((uVar28 & 4) != 0) &&

+       (*(uint *)(puVar31 + 200) = (uint)*(ushort *)(uVar22 + 0x6ec), (uVar28 & 2) == 0)) {

+      *(undefined8 *)(puVar31 + -8) = 0x140995d50;

+      cVar11 = ExAcquireRundownProtection(uVar22 + 0x1e8);

+      if (cVar11 != '\0') {

+        lVar23 = *(longlong *)(uVar22 + 0x2a8);

+        *(longlong *)(puVar31 + 0xf8) = lVar23;

+        if (lVar23 != 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x140995d71;

+          ObfReferenceObject(lVar23);

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x140995d79;

+        ExReleaseRundownProtection(uVar22 + 0x1e8);

+      }

+      lVar23 = *(longlong *)(puVar31 + 0xf8);

+      if (lVar23 == 0) {

+        uVar22 = 0xc000010a;

+        goto LAB_5;

+      }

+      lVar25 = *(longlong *)(uVar22 + 0x310);

+      if (lVar25 != 0) {

+        uVar28 = (ulonglong)(uVar20 | 0x40);

+        *(uint *)(puVar31 + 0x84) = uVar20 | 0x40;

+        *(undefined4 *)(puVar31 + 0x120) = *(undefined4 *)(lVar25 + 8);

+      }

+      if ((*(uint *)(uVar22 + 500) & 0x20000) != 0) {

+        uVar18 = 0x20000;

+      }

+      *(uint *)(puVar31 + 0xb0) = uVar18;

+    }

+    *(longlong *)(_Dst_00 + 0x2a8) = lVar23;

+    if ((param_11 == 0) || ((uVar28 & 2) != 0)) {

+      uVar29 = uVar28;

+      if (lVar23 != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x140996384;

+        uVar18 = MmGetSectionInformation(lVar23,4,puVar31 + 0x380);

+        uVar22 = (ulonglong)uVar18;

+        if ((int)uVar18 < 0) goto LAB_5;

+        uVar18 = ((((*(uint *)(puVar31 + 0x3c0) & 0xfa) * 2 | *(uint *)(puVar31 + 0x3c0) & 1) << 5 |

+                  (byte)puVar31[0x3b3] & 2) << 2 | (byte)puVar31[0x3b3] & 4) << 0xb | (uint)uVar28;

+        uVar29 = (ulonglong)uVar18;

+        *(uint *)(puVar31 + 0x84) = uVar18;

+        *(undefined2 *)(puVar31 + 0xa8) = *(undefined2 *)(puVar31 + 0x3ae);

+        *(uint *)(puVar31 + 0xec) = (uint)*(ushort *)(puVar31 + 0x3a6);

+        *(uint *)(puVar31 + 0xe8) = (uint)*(ushort *)(puVar31 + 0x3a4);

+        if ((uVar28 & 4) != 0) {

+          *(uint *)(puVar31 + 0xb0) = *(uint *)(puVar31 + 0xb0) | 8;

+          uVar29 = (ulonglong)(uVar18 | 0x18);

+          *(uint *)(puVar31 + 0x84) = uVar18 | 0x18;

+        }

+      }

+      goto LAB_6;

+    }

+    *(undefined8 *)(_Dst_00 + 0x5f0) = *(undefined8 *)(param_11 + 0x1a8);

+    *(undefined8 *)(puVar31 + -8) = 0x140995e04;

+    uVar18 = MmGetSectionInformation(lVar23,4,param_11 + 0x38);

+    uVar22 = (ulonglong)uVar18;

+    if ((int)uVar18 < 0) {

+LAB_5:

+      if (*(longlong *)(puVar31 + 0x100) != 0) {

+        *(longlong *)(_Dst_00 + 0x1d0) = *(longlong *)(puVar31 + 0x100);

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x140996634;

+      PspRundownSingleProcess(_Dst_00,0);

+      *(undefined8 *)(puVar31 + -8) = 0x140996641;

+      ObfDereferenceObjectWithTag(_Dst_00,0x72437350);

+    }

+    else {

+      uVar18 = ((((*(uint *)(param_11 + 0x78) & 0xfa) * 2 | *(uint *)(param_11 + 0x78) & 1) << 5 |

+                *(byte *)(param_11 + 0x6b) & 2) << 2 | *(byte *)(param_11 + 0x6b) & 4) << 0xb |

+               (uint)uVar28;

+      uVar29 = (ulonglong)uVar18;

+      *(uint *)(puVar31 + 0x84) = uVar18;

+      *(uint *)(puVar31 + 0xec) = (uint)*(ushort *)(param_11 + 0x5e);

+      *(uint *)(puVar31 + 0xe8) = (uint)*(ushort *)(param_11 + 0x5c);

+      if ((*(ushort *)(param_11 + 0x12) & *(ushort *)(param_11 + 100)) != 0) {

+        uVar22 = 0xc000007b;

+        uVar26 = 3;

+LAB_7:

+        *(undefined8 *)(puVar31 + -8) = 0x140995e7e;

+        PspUpdateCreateInfo(uVar26,param_11,0);

+        goto LAB_5;

+      }

+      if ((uVar28 & 4) == 0) {

+        uVar26 = *(undefined8 *)(param_11 + 0xb8);

+        *(undefined8 *)(puVar31 + -8) = 0x140995ea3;

+        ObfReferenceObjectWithTag(uVar26,0x72437350);

+        *(undefined8 *)(_Dst_00 + 0x330) = *(undefined8 *)(param_11 + 0xb8);

+        *(undefined2 *)(puVar31 + 0xa8) = *(undefined2 *)(param_11 + 0x66);

+        *(undefined8 *)(puVar31 + -8) = 0x140995ed4;

+        iVar17 = RtlpOpenImageFileOptionsKeyEx(param_11 + 0xf0);

+        if (iVar17 < 0) {

+          if (iVar17 == -0x3fffffcc) {

+            *(byte *)(param_11 + 0x10) = *(byte *)(param_11 + 0x10) | 0x40;

+          }

+          *(undefined8 *)(param_11 + 200) = 0;

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x140995eff;

+        uVar36 = PspSelectMachineForProcess(*(undefined8 *)(puVar31 + 0x98),param_11,puVar31 + 0xd0)

+        ;

+        uVar22 = (ulonglong)uVar36;

+        if ((int)uVar36 < 0) {

+          uVar26 = 4;

+          goto LAB_7;

+        }

+        *(uint *)(puVar31 + 200) = (uint)*(ushort *)(puVar31 + 0xd0);

+        if (puVar31[0xd2] != '\0') {

+          uVar29 = (ulonglong)(uVar18 | 0x40);

+          *(uint *)(puVar31 + 0x84) = uVar18 | 0x40;

+        }

+        if (puVar31[0xd3] != '\0') {

+          *(uint *)(puVar31 + 0xb0) = *(uint *)(puVar31 + 0xb0) | 0x20000;

+        }

+        lVar23 = *(longlong *)(param_11 + 200);

+        if (lVar23 == 0) goto LAB_6;

+        if (-1 < *(char *)(param_11 + 0x10)) {

+          *(undefined1 **)(puVar31 + 0x28) = puVar31 + 0xac;

+          *(undefined4 *)(puVar31 + 0x20) = 2;

+          *(undefined8 *)(puVar31 + -8) = 0x140995f89;

+          iVar17 = RtlQueryImageFileKeyOption(lVar23,L"Debugger",1,puVar31 + 0xc0);

+          if ((iVar17 != -0x7ffffffb) &&

+             (((iVar17 < 0 || (*(int *)(puVar31 + 0xac) != 2)) || (*(short *)(puVar31 + 0xc0) == 0))

+             )) {

+            *(undefined4 *)(puVar31 + 0x114) = 0;

+            *(undefined8 *)(puVar31 + 0x28) = 0;

+            *(undefined4 *)(puVar31 + 0x20) = 4;

+            uVar26 = *(undefined8 *)(param_11 + 200);

+            *(undefined8 *)(puVar31 + -8) = 0x140995fd7;

+            iVar17 = RtlQueryImageFileKeyOption

+                               (uVar26,L"AppExecutionAliasRedirect",4,puVar31 + 0x114);

+            if ((iVar17 < 0) || (*(int *)(puVar31 + 0x114) != 1)) goto LAB_8;

+          }

+          uVar22 = 0xc0000039;

+          uVar26 = 5;

+          goto LAB_7;

+        }

+LAB_8:

+        *(undefined4 *)(puVar31 + 0xc4) = 0;

+        *(undefined8 *)(puVar31 + 0x28) = 0;

+        *(undefined4 *)(puVar31 + 0x20) = 4;

+        uVar26 = *(undefined8 *)(param_11 + 200);

+        *(undefined8 *)(puVar31 + -8) = 0x140996023;

+        iVar17 = RtlQueryImageFileKeyOption(uVar26,L"UseLargePages",4,puVar31 + 0xc4);

+        uVar18 = *(uint *)(puVar31 + 0x90);

+        uVar36 = uVar18;

+        if ((-1 < iVar17) && (*(int *)(puVar31 + 0xc4) != 0)) {

+          uVar36 = uVar18 | 0x10;

+          *(uint *)(puVar31 + 0x90) = uVar36;

+          *(uint *)(puVar31 + 0x880) = uVar36;

+          if ((uVar29 & 0x40) == 0) {

+            *(undefined4 *)(puVar31 + 0x220) = 0x30;

+            *(undefined8 *)(puVar31 + 0x228) = *(undefined8 *)(param_11 + 200);

+            *(undefined4 *)(puVar31 + 0x238) = 0x240;

+            *(undefined **)(puVar31 + 0x230) = &PspLargePageDLLKeyName;

+            *(undefined8 *)(puVar31 + 0x240) = 0;

+            *(undefined8 *)(puVar31 + 0x248) = 0;

+            *(undefined8 *)(puVar31 + -8) = 0x1409960b5;

+            iVar17 = ZwOpenKey(puVar31 + 0x168,1,puVar31 + 0x220);

+            if (-1 < iVar17) {

+              *(undefined4 *)(puVar31 + 0xc4) = 0;

+              *(undefined8 *)(puVar31 + 0x28) = 0;

+              *(undefined4 *)(puVar31 + 0x20) = 4;

+              *(undefined8 *)(puVar31 + -8) = 0x1409960ed;

+              iVar17 = RtlQueryImageFileKeyOption

+                                 (*(undefined8 *)(puVar31 + 0x168),&u_ntdll_dll,4,puVar31 + 0xc4);

+              if ((-1 < iVar17) && (*(int *)(puVar31 + 0xc4) != 0)) {

+                uVar36 = uVar18 | 0x30;

+                *(uint *)(puVar31 + 0x90) = uVar36;

+                *(uint *)(puVar31 + 0x880) = uVar36;

+              }

+              *(undefined8 *)(puVar31 + -8) = 0x14099611d;

+              ObCloseHandle(*(undefined8 *)(puVar31 + 0x168),0);

+            }

+          }

+        }

+        if (*(longlong *)(puVar31 + 0x138) == 0) {

+          uVar26 = *(undefined8 *)(param_11 + 200);

+          *(undefined8 *)(puVar31 + -8) = 0x140996145;

+          PspReadIFEONodeOptions(_Dst_00,uVar26,puVar31 + 0xb8);

+        }

+        *(undefined4 *)(puVar31 + 0x118) = 0;

+        *(undefined8 *)(puVar31 + 0x28) = 0;

+        *(undefined4 *)(puVar31 + 0x20) = 4;

+        uVar26 = *(undefined8 *)(param_11 + 200);

+        *(undefined8 *)(puVar31 + -8) = 0x140996173;

+        iVar17 = RtlQueryImageFileKeyOption(uVar26,L"ForceWakeCharge",4,puVar31 + 0x118);

+        if ((-1 < iVar17) && (*(int *)(puVar31 + 0x118) != 0)) {

+          *(uint *)(puVar31 + 0xb4) = *(uint *)(puVar31 + 0xb4) | 0x40;

+        }

+        *(undefined1 **)(puVar31 + 0x28) = puVar31 + 0xac;

+        *(undefined4 *)(puVar31 + 0x20) = 0;

+        uVar26 = *(undefined8 *)(param_11 + 200);

+        *(undefined8 *)(puVar31 + -8) = 0x1409961b3;

+        iVar17 = RtlQueryImageFileKeyOption(uVar26,L"AllowedCpuSets",3);

+        if (((iVar17 != -0x7ffffffb) || (uVar18 = *(uint *)(puVar31 + 0xac), 0x100 < uVar18)) ||

+           ((uVar18 & 7) != 0)) {

+LAB_9:

+          *(undefined4 *)(puVar31 + 0x250) = 0x30;

+          *(undefined8 *)(puVar31 + 600) = *(undefined8 *)(param_11 + 200);

+          *(undefined4 *)(puVar31 + 0x268) = 0x240;

+          *(undefined **)(puVar31 + 0x260) = &PspPerfOptionsKeyName;

+          *(undefined8 *)(puVar31 + 0x270) = 0;

+          *(undefined8 *)(puVar31 + 0x278) = 0;

+          *(undefined8 *)(puVar31 + -8) = 0x1409962b3;

+          iVar17 = ZwOpenKey(puVar31 + 0x170,1,puVar31 + 0x250);

+          if (-1 < iVar17) {

+            *(undefined8 *)(puVar31 + -8) = 0x1409962cc;

+            PspReadIFEOPerfOptions(*(undefined8 *)(puVar31 + 0x170),puVar31 + 0x400);

+            *(undefined8 *)(puVar31 + -8) = 0x1409962db;

+            ObCloseHandle(*(undefined8 *)(puVar31 + 0x170),0);

+          }

+          *(undefined8 *)(puVar31 + 0x28) = 0;

+          *(undefined4 *)(puVar31 + 0x20) = 4;

+          uVar26 = *(undefined8 *)(param_11 + 200);

+          *(undefined8 *)(puVar31 + -8) = 0x140996307;

+          iVar17 = RtlQueryImageFileKeyOption(uVar26,L"ImageExpansionMitigation",4,puVar31 + 0x11c);

+          if ((-1 < iVar17) && (*(int *)(puVar31 + 0x11c) == 2)) {

+            LOCK();

+            *(uint *)(_Dst_00 + 0x7dc) = *(uint *)(_Dst_00 + 0x7dc) | 4;

+            UNLOCK();

+            uVar36 = *(uint *)(puVar31 + 0x880);

+            *(uint *)(puVar31 + 0x90) = uVar36;

+            _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+          }

+          if ((uVar36 >> 0x13 & 1) != 0) {

+            LOCK();

+            *(uint *)(_Dst_00 + 0x7dc) = *(uint *)(_Dst_00 + 0x7dc) | 4;

+            UNLOCK();

+            uVar36 = *(uint *)(puVar31 + 0x880);

+            *(uint *)(puVar31 + 0x90) = uVar36;

+            _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+          }

+          goto LAB_10;

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x1409961ed;

+        lVar23 = ExAllocatePool2(0x40,uVar18,0x73437350);

+        *(longlong *)(puVar31 + 0x188) = lVar23;

+        if (lVar23 != 0) {

+          *(undefined1 **)(puVar31 + 0x28) = puVar31 + 0xac;

+          *(uint *)(puVar31 + 0x20) = uVar18;

+          uVar26 = *(undefined8 *)(param_11 + 200);

+          *(undefined8 *)(puVar31 + -8) = 0x140996231;

+          iVar17 = RtlQueryImageFileKeyOption(uVar26,L"AllowedCpuSets",3,lVar23);

+          if ((-1 < iVar17) && ((puVar31[0xac] & 7) == 0)) {

+            uVar18 = (uint)uVar29 | 0x200000;

+            uVar29 = (ulonglong)uVar18;

+            *(uint *)(puVar31 + 0x84) = uVar18;

+            *(uint *)(puVar31 + 0xcc) = *(uint *)(puVar31 + 0xac) >> 3;

+          }

+          goto LAB_9;

+        }

+LAB_11:

+        uVar22 = 0xc0000017;

+        goto LAB_5;

+      }

+LAB_6:

+      uVar36 = *(uint *)(puVar31 + 0x90);

+LAB_10:

+      if ((uVar29 & 0x40) == 0) {

+        uVar33 = (undefined2)*(undefined4 *)(puVar31 + 200);

+      }

+      else {

+        *(undefined8 *)(puVar31 + -8) = 0x14099643c;

+        lVar23 = ExAllocatePool2(0x40,0x10,0x50776f57);

+        *(longlong *)(_Dst_00 + 0x310) = lVar23;

+        if (lVar23 == 0) goto LAB_11;

+        iVar17 = *(int *)(puVar31 + 0x120);

+        uVar33 = (undefined2)*(uint *)(puVar31 + 200);

+        if (iVar17 == 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x14099646c;

+          iVar17 = PspWow64PickBestNtdll(param_11,*(uint *)(puVar31 + 200) & 0xffff);

+        }

+        *(int *)(lVar23 + 8) = iVar17;

+        if (*(undefined8 **)(_Dst_00 + 0x310) != (undefined8 *)0x0) {

+          **(undefined8 **)(_Dst_00 + 0x310) = 1;

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x140996484;

+        iVar17 = Feature_Servicing_LargeAddressAwareShim__private_IsEnabledDeviceUsageNoInline();

+        if ((iVar17 != 0) && ((uVar36 >> 0x17 & 1) != 0)) {

+          LOCK();

+          *(uint *)(_Dst_00 + 500) = *(uint *)(_Dst_00 + 500) | 0x200;

+          UNLOCK();

+          uVar36 = *(uint *)(puVar31 + 0x880);

+          *(uint *)(puVar31 + 0x90) = uVar36;

+          _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+        }

+      }

+      *(undefined2 *)(_Dst_00 + 0x6ec) = uVar33;

+      *(undefined8 *)(puVar31 + -8) = 0x1409964de;

+      uVar18 = SeQueryInformationToken(*(undefined8 *)(puVar31 + 0x130),0x1d,puVar31 + 0xd8);

+      uVar22 = (ulonglong)uVar18;

+      if ((int)uVar18 < 0) goto LAB_5;

+      if (puVar31[0x80] != '\0') {

+        uVar28 = uVar32;

+        if (((param_11 != 0) && (uVar28 = 0, (*(uint *)(param_11 + 8) >> 8 & 1) != 0)) &&

+           (*(char *)(param_11 + 2) == '\x04')) {

+          *(undefined4 *)(puVar31 + 0x790) = 0xe;

+          uVar28 = 1;

+        }

+        iVar17 = *(int *)(puVar31 + 0x898);

+        if (iVar17 != 0) {

+          *(undefined4 *)(puVar31 + uVar28 * 4 + 0x790) = 3;

+          uVar28 = (ulonglong)((int)uVar28 + 1);

+        }

+        if ((uVar36 & 0x30) != 0) {

+          *(undefined4 *)(puVar31 + uVar28 * 4 + 0x790) = 4;

+          uVar28 = (ulonglong)((int)uVar28 + 1);

+        }

+        if ((char)uVar36 < '\0') {

+          *(undefined8 *)(puVar31 + -8) = 0x140996564;

+          iVar19 = PspIsSessionLeaderProcess(*(undefined8 *)(puVar31 + 0xf0));

+          iVar17 = *(int *)(puVar31 + 0x898);

+          if (iVar19 == 0) {

+            *(undefined4 *)(puVar31 + (uVar28 & 0xffffffff) * 4 + 0x790) = 10;

+            uVar28 = (ulonglong)((int)uVar28 + 1);

+          }

+        }

+        iVar19 = (int)uVar28;

+        if ((uVar36 & 0x8400) != 0) {

+          *(undefined4 *)(puVar31 + (uVar28 & 0xffffffff) * 4 + 0x790) = 7;

+          iVar19 = iVar19 + 1;

+        }

+        if (iVar19 != 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x1409965c0;

+          iVar17 = RtlAcquirePrivilege(puVar31 + 0x790,iVar19,iVar17 != 0,puVar31 + 0x180);

+          if (-1 < iVar17) {

+            uVar18 = (uint)uVar29 | 0x400;

+            uVar29 = (ulonglong)uVar18;

+            *(uint *)(puVar31 + 0x84) = uVar18;

+          }

+        }

+      }

+      uVar18 = (uint)uVar29;

+      if ((uVar36 & 0x8400) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x1409965fa;

+        cVar11 = SeSinglePrivilegeCheck(SeTcbPrivilege);

+        if (cVar11 != '\0') goto LAB_12;

+        goto LAB_13;

+      }

+LAB_12:

+      *(undefined2 *)(puVar31 + 0x8c) = 0xffff;

+      *(undefined8 *)(puVar31 + 0x460) = 0x200001;

+      *(undefined8 *)(puVar31 + -8) = 0x1409966a9;

+      memset(puVar31 + 0x468,0,0x100);

+      if (*(longlong *)(puVar31 + 0x138) == 0) {

+        if (*(longlong *)(puVar31 + 0xb8) == 0) {

+          lVar23 = *(longlong *)(puVar31 + 0x98);

+          if (lVar23 == 0) {

+            uVar16 = 0;

+            *(undefined2 *)(puVar31 + 0x8c) = 0;

+            *(undefined8 *)(puVar31 + -8) = 0x140996776;

+            KeAddProcessorAffinityEx(puVar31 + 0x460,0);

+          }

+          else {

+            if ((*(uint *)(lVar23 + 0x1f0) & 0x100000) != 0) {

+              *(uint *)(puVar31 + 0xb4) = *(uint *)(puVar31 + 0xb4) | 0x100000;

+              uVar26 = (&KeNodeBlock)[*(ushort *)(lVar23 + 0x104)];

+              *(undefined8 *)(puVar31 + 0xb8) = uVar26;

+              goto LAB_14;

+            }

+            *(undefined8 *)(puVar31 + -8) = 0x140996712;

+            uVar26 = PspSelectNodeForProcess();

+            *(undefined8 *)(puVar31 + 0xb8) = uVar26;

+            *(undefined8 *)(puVar31 + -8) = 0x140996722;

+            uVar16 = KeSelectGroupFromNode(uVar26);

+            *(ushort *)(puVar31 + 0x8c) = uVar16;

+            if (KeForceGroupAwareness != '\0') {

+              *(undefined8 *)(puVar31 + -8) = 0x14099673b;

+              uVar15 = KeQueryActiveGroupCount();

+              if ((1 < uVar15) && (uVar16 == 0)) {

+                *(undefined8 *)(puVar31 + 0xb8) = 0;

+                uVar16 = 1;

+                *(undefined2 *)(puVar31 + 0x8c) = 1;

+              }

+            }

+          }

+        }

+        else {

+          uVar26 = *(undefined8 *)(puVar31 + 0xb8);

+LAB_14:

+          *(undefined8 *)(puVar31 + -8) = 0x140996785;

+          uVar16 = KeSelectGroupFromNode(uVar26);

+          *(ushort *)(puVar31 + 0x8c) = uVar16;

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x1409967ac;

+        KiCopyAffinityEx((_KAFFINITY_EX *)(puVar31 + 0x460),*(ushort *)(puVar31 + 0x462),

+                         (_KAFFINITY_EX *)&KeActiveProcessors);

+        if (*(longlong *)(puVar31 + 0xb8) == 0) {

+          *(undefined8 *)(puVar31 + 0x200) = 0;

+          *(undefined8 *)(puVar31 + 0x208) = 0;

+          *(ushort *)(puVar31 + 0x208) = uVar16;

+          uVar28 = uVar32;

+          if (uVar16 < *(ushort *)(puVar31 + 0x460)) {

+            uVar28 = *(ulonglong *)(puVar31 + (ulonglong)uVar16 * 8 + 0x468);

+          }

+          *(ulonglong *)(puVar31 + 0x200) = uVar28;

+          *(undefined8 *)(puVar31 + -8) = 0x1409967fc;

+          uVar26 = KeSelectNodeForAffinity(puVar31 + 0x200);

+          goto LAB_15;

+        }

+      }

+      else {

+        *(undefined1 **)(puVar31 + 0x20) = puVar31 + 0x8c;

+        *(undefined8 *)(puVar31 + -8) = 0x140996826;

+        KeQueryAffinityProcess(*(longlong *)(puVar31 + 0x138),puVar31 + 0x460,0,puVar31 + 0x7b0);

+        uVar26 = (&KeNodeBlock)

+                 [*(ushort *)(puVar31 + (ulonglong)*(ushort *)(puVar31 + 0x8c) * 2 + 0x7b0)];

+LAB_15:

+        *(undefined8 *)(puVar31 + 0xb8) = uVar26;

+      }

+      *(uint *)(_Dst_00 + 500) = *(uint *)(_Dst_00 + 500) | *(uint *)(puVar31 + 0xb0);

+      *(uint *)(_Dst_00 + 0x1f0) = *(uint *)(_Dst_00 + 0x1f0) | *(uint *)(puVar31 + 0xb4);

+      if (*(longlong *)(puVar31 + 0x98) != 0) {

+        *(undefined8 *)(puVar31 + 0x178) = 0;

+        *(undefined4 *)(puVar31 + 0xe0) = 0;

+        puVar31[0x88] = 0;

+        if (*(int *)(puVar31 + 0x898) == 0) {

+          uVar28 = uVar32;

+          if ((uVar29 & 4) != 0) {

+            *(undefined8 *)(puVar31 + -8) = 0x140996999;

+            uVar36 = PsGetProcessSessionIdEx(*(longlong *)(puVar31 + 0x98));

+            uVar28 = (ulonglong)uVar36;

+            *(uint *)(puVar31 + 0xe0) = uVar36;

+            *(undefined8 *)(puVar31 + -8) = 0x1409969af;

+            uVar20 = PsGetProcessSessionIdEx(*(undefined8 *)(puVar31 + 0xf0));

+            uVar18 = -(uint)(uVar36 != uVar20) & 0x20 | uVar18;

+          }

+LAB_16:

+          if ((uVar18 & 0x20) != 0) {

+            *(undefined8 *)(puVar31 + -8) = 0x14099697e;

+            uVar36 = PspAttachSession(uVar28,puVar31 + 0x428,puVar31 + 0x178);

+            uVar22 = (ulonglong)uVar36;

+            if ((int)uVar36 < 0) {

+              uVar18 = uVar18 & 0xffffffdf;

+              goto LAB_17;

+            }

+            *(uint *)(_Dst_00 + 0x1f0) = *(uint *)(_Dst_00 + 0x1f0) | 0x80;

+          }

+          if ((*(int *)(puVar31 + 0x898) == 0) || (cVar12 != '\0')) {

+            uVar28 = *(ulonglong *)(puVar31 + 0x98);

+            uVar22 = uVar28;

+            if (cVar12 != '\0') {

+              uVar22 = *(ulonglong *)(puVar31 + 0xf0);

+            }

+            *(undefined8 *)(puVar31 + -8) = 0x140996a36;

+            PspInheritQuota(_Dst_00,uVar22);

+          }

+          else {

+            *(undefined8 *)(puVar31 + -8) = 0x1409969ee;

+            uVar36 = PspAssignProcessQuotaBlock(0,_Dst_00,*(undefined8 *)(puVar31 + 0x130));

+            uVar22 = (ulonglong)uVar36;

+            if ((int)uVar36 < 0) {

+              if ((uVar18 & 0x20) != 0) {

+                *(undefined8 *)(puVar31 + -8) = 0x140996a12;

+                PspDetachSession(*(undefined8 *)(puVar31 + 0x178),puVar31 + 0x428);

+              }

+              goto LAB_17;

+            }

+            uVar28 = *(ulonglong *)(puVar31 + 0x98);

+          }

+          uVar16 = **(ushort **)(puVar31 + 0xb8);

+          *(undefined1 **)(puVar31 + 0x28) = _Dst_00;

+          *(uint *)(puVar31 + 0x20) = uVar16 + 1;

+          *(undefined8 *)(puVar31 + -8) = 0x140996a96;

+          bVar13 = MmCreateProcessAddressSpace(*(undefined8 *)(puVar31 + 0x148));

+          uVar18 = uVar18 ^ (bVar13 & 1) << 0xb;

+          uVar29 = (ulonglong)uVar18;

+          *(uint *)(puVar31 + 0x84) = uVar18;

+          if ((uVar18 & 0x20) != 0) {

+            *(undefined8 *)(puVar31 + -8) = 0x140996ac8;

+            PspDetachSession(*(undefined8 *)(puVar31 + 0x178),puVar31 + 0x428);

+          }

+          if ((uVar18 & 0x800) != 0) goto LAB_18;

+LAB_19:

+          uVar22 = 0xc000009a;

+        }

+        else {

+          *(undefined8 *)(puVar31 + -8) = 0x1409968b5;

+          cVar12 = SeSinglePrivilegeCheck(SeAssignPrimaryTokenPrivilege,puVar31[0x80]);

+          uVar36 = uVar18 | 0x200;

+          if (cVar12 == '\0') {

+            uVar36 = uVar18;

+          }

+          uVar18 = uVar36;

+          *(undefined8 *)(puVar31 + -8) = 0x1409968d9;

+          uVar36 = SeIsTokenAssignableToProcess(*(undefined8 *)(puVar31 + 0x130),puVar31 + 0x88);

+          uVar22 = (ulonglong)uVar36;

+          if (-1 < (int)uVar36) {

+            if ((puVar31[0x88] == '\0') && ((uVar18 >> 9 & 1) == 0)) {

+LAB_13:

+              uVar22 = 0xc0000061;

+            }

+            else {

+              *(undefined8 *)(puVar31 + -8) = 0x140996913;

+              uVar36 = SeQuerySessionIdToken(*(undefined8 *)(puVar31 + 0x130),puVar31 + 0xe0);

+              uVar22 = (ulonglong)uVar36;

+              if (-1 < (int)uVar36) {

+                *(undefined8 *)(puVar31 + -8) = 0x14099692a;

+                uVar36 = PsGetProcessSessionIdEx(*(undefined8 *)(puVar31 + 0xf0));

+                if (*(uint *)(puVar31 + 0xe0) != uVar36) {

+                  if ((uVar18 >> 9 & 1) == 0) goto LAB_13;

+                  if ((puVar31[0x90] & 0x80) != 0) {

+                    uVar22 = 0xc000000d;

+                    goto LAB_17;

+                  }

+                  uVar18 = uVar18 | 0x20;

+                }

+                cVar12 = puVar31[0x88];

+                uVar28 = (ulonglong)*(uint *)(puVar31 + 0xe0);

+                goto LAB_16;

+              }

+            }

+          }

+        }

+LAB_17:

+        if ((uVar18 >> 10 & 1) != 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x140996616;

+          RtlReleasePrivilege(*(undefined8 *)(puVar31 + 0x180));

+        }

+        goto LAB_5;

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x140996ae0;

+      PspInheritQuota(_Dst_00,0);

+      _Dst_00[0x160] = 1;

+      *(undefined8 *)(puVar31 + -8) = 0x140996aec;

+      uVar36 = MmInitializeHandBuiltProcess();

+      uVar22 = (ulonglong)uVar36;

+      uVar28 = 0;

+      if ((int)uVar36 < 0) goto LAB_17;

+LAB_18:

+      uVar18 = (uint)uVar29;

+      LOCK();

+      *(uint *)(_Dst_00 + 500) = *(uint *)(_Dst_00 + 500) | 0x40000;

+      UNLOCK();

+      _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+      uVar36 = *(uint *)(puVar31 + 0xe4);

+      if ((*(uint *)(_Dst_00 + 0x388) & 4) != 0) {

+        uVar36 = uVar36 | 1;

+      }

+      puVar38 = _Dst_00 + *(uint *)(puVar31 + 0x158);

+      uVar20 = uVar36 | 2;

+      if ((uVar18 >> 0x10 & 1) == 0) {

+        uVar20 = uVar36;

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x140996b41;

+      uVar26 = PsGetSessionSchedulingGroupByProcess(_Dst_00);

+      *(undefined1 **)(puVar31 + 0x40) = puVar38;

+      *(uint *)(puVar31 + 0x38) = uVar20;

+      *(undefined8 *)(puVar31 + 0x28) = uVar26;

+      *(undefined8 *)(puVar31 + 0x20) = *(undefined8 *)(puVar31 + 0xb8);

+      *(undefined8 *)(puVar31 + -8) = 0x140996b78;

+      uVar36 = KeInitializeProcess(extraout_XMM0_Da,8,*(undefined2 *)(puVar31 + 0x8c),

+                                   puVar31 + 0x460);

+      uVar22 = (ulonglong)uVar36;

+      if ((int)uVar36 < 0) goto LAB_17;

+      if ((param_11 == 0) || ((uVar29 & 2) != 0)) {

+        puVar35 = (undefined8 *)0x0;

+      }

+      else {

+        *(undefined4 *)(puVar31 + 300) = *(undefined4 *)(param_11 + 0x180);

+        *(undefined4 *)(puVar31 + 0x128) = *(undefined4 *)(param_11 + 0x184);

+        *(undefined8 *)(puVar31 + 0x1b8) = *(undefined8 *)(param_11 + 0x198);

+        *(undefined4 *)(puVar31 + 0x124) = *(undefined4 *)(param_11 + 0x188);

+        *(undefined8 *)(puVar31 + 0x1b0) = *(undefined8 *)(param_11 + 0xd8);

+        puVar35 = *(undefined8 **)(param_11 + 400);

+        *(undefined4 *)(puVar31 + 0xd4) = *(undefined4 *)(param_11 + 0x18c);

+        lVar23 = *(longlong *)(param_11 + 0xb8);

+        if ((lVar23 != 0) && (DAT_20 != (code *)0x0)) {

+          *(undefined8 *)(puVar31 + -8) = 0x140996c1e;

+          iVar17 = (*DAT_20)(lVar23,puVar31 + 0x570);

+          if (-1 < iVar17) {

+            if (((*(int *)(puVar31 + 0x570) == 0) && (puVar35 != (undefined8 *)0x0)) &&

+               (*(int *)(puVar31 + 0xd4) == 0x20c)) {

+              lVar23 = 4;

+              puVar10 = (undefined8 *)(puVar31 + 0x570);

+              do {

+                puVar34 = puVar35;

+                puVar27 = puVar10;

+                uVar26 = puVar34[1];

+                *puVar27 = *puVar34;

+                puVar27[1] = uVar26;

+                uVar26 = puVar34[3];

+                puVar27[2] = puVar34[2];

+                puVar27[3] = uVar26;

+                uVar26 = puVar34[5];

+                puVar27[4] = puVar34[4];

+                puVar27[5] = uVar26;

+                uVar26 = puVar34[7];

+                puVar27[6] = puVar34[6];

+                puVar27[7] = uVar26;

+                uVar26 = puVar34[9];

+                puVar27[8] = puVar34[8];

+                puVar27[9] = uVar26;

+                uVar26 = puVar34[0xb];

+                puVar27[10] = puVar34[10];

+                puVar27[0xb] = uVar26;

+                uVar21 = *(undefined4 *)((longlong)puVar34 + 100);

+                uVar7 = *(undefined4 *)(puVar34 + 0xd);

+                uVar8 = *(undefined4 *)((longlong)puVar34 + 0x6c);

+                *(undefined4 *)(puVar27 + 0xc) = *(undefined4 *)(puVar34 + 0xc);

+                *(undefined4 *)((longlong)puVar27 + 100) = uVar21;

+                *(undefined4 *)(puVar27 + 0xd) = uVar7;

+                *(undefined4 *)((longlong)puVar27 + 0x6c) = uVar8;

+                uVar26 = puVar34[0xf];

+                puVar27[0xe] = puVar34[0xe];

+                puVar27[0xf] = uVar26;

+                lVar23 = lVar23 + -1;

+                puVar10 = puVar27 + 0x10;

+                puVar35 = puVar34 + 0x10;

+              } while (lVar23 != 0);

+              puVar27[0x10] = puVar34[0x10];

+              *(undefined4 *)(puVar27 + 0x11) = *(undefined4 *)(puVar34 + 0x11);

+            }

+            puVar35 = (undefined8 *)(puVar31 + 0x570);

+            *(undefined4 *)(puVar31 + 0xd4) = 0x218;

+          }

+        }

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x140996cc9;

+      iVar17 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline()

+      ;

+      if (((iVar17 != 0) && (param_11 != 0)) && ((*(ulonglong *)(param_11 + 8) >> 0x21 & 1) != 0)) {

+        *(longlong *)(puVar31 + 0x1a8) = param_11 + 0x1f0;

+      }

+      *(undefined8 *)(puVar31 + 0x70) = *(undefined8 *)(puVar31 + 0x1f0);

+      *(undefined8 *)(puVar31 + 0x68) = *(undefined8 *)(puVar31 + 0x1a8);

+      *(undefined8 *)(puVar31 + 0x60) = *(undefined8 *)(puVar31 + 0x1b0);

+      *(undefined4 *)(puVar31 + 0x58) = *(undefined4 *)(puVar31 + 0x124);

+      *(undefined8 *)(puVar31 + 0x50) = *(undefined8 *)(puVar31 + 0x1b8);

+      *(undefined4 *)(puVar31 + 0x48) = *(undefined4 *)(puVar31 + 0xd4);

+      *(undefined8 **)(puVar31 + 0x40) = puVar35;

+      *(undefined4 *)(puVar31 + 0x38) = *(undefined4 *)(puVar31 + 0x128);

+      *(uint *)(puVar31 + 0x30) = (uint)(uVar29 >> 0x10) & 1;

+      *(uint *)(puVar31 + 0x28) = (uint)(uVar29 >> 4) & 1;

+      *(undefined4 *)(puVar31 + 0x20) = *(undefined4 *)(puVar31 + 300);

+      *(undefined8 *)(puVar31 + -8) = 0x140996d81;

+      uVar36 = PspInitializeProcessSecurity

+                         (uVar28,_Dst_00,*(undefined8 *)(puVar31 + 0x130),

+                          *(undefined4 *)(puVar31 + 0x898));

+      uVar22 = (ulonglong)uVar36;

+      if ((int)uVar36 < 0) goto LAB_17;

+      _Dst_00[0x347] = 2;

+      if (uVar28 == 0) {

+        *(undefined8 *)(_Dst_00 + 0x300) = *(undefined8 *)(*(longlong *)(puVar31 + 0xf0) + 0x300);

+        *(undefined8 *)(puVar31 + -8) = 0x140996e0b;

+        uVar36 = MmInitializeHandBuiltProcess2(_Dst_00);

+      }

+      else {

+        if ((*(char *)(uVar28 + 0x347) - 1U & 0xfb) == 0) {

+          _Dst_00[0x347] = *(char *)(uVar28 + 0x347);

+        }

+        uVar37 = uVar32;

+        uVar22 = uVar32;

+        if (param_11 != 0) {

+          uVar37 = (ulonglong)*(uint *)(param_11 + 0x124);

+          uVar22 = *(ulonglong *)(param_11 + 0x128);

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x140996deb;

+        uVar36 = ObInitProcess(-(ulonglong)((*(uint *)(puVar31 + 0x880) & 4) != 0) & uVar28,_Dst_00,

+                               uVar37,uVar22);

+      }

+      uVar22 = (ulonglong)uVar36;

+      if ((int)uVar36 < 0) goto LAB_17;

+      uVar14 = puVar31[0x80];

+      if ((puVar31[0x400] & 7) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x140996e3a;

+        PspApplyIFEOPerfOptions(_Dst_00,puVar31 + 0x400,uVar14);

+      }

+      if ((uVar18 >> 0x15 & 1) != 0) {

+        puVar31[0x20] = 0;

+        *(undefined8 *)(puVar31 + -8) = 0x140996e5f;

+        KeSetCpuSetsProcess(_Dst_00,*(undefined4 *)(puVar31 + 0xcc),*(undefined8 *)(puVar31 + 0x188)

+                            ,1);

+      }

+      if ((puVar31[0x404] & 2) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x140996e78;

+        KeSetExpectedConcurrencyCountProcess(_Dst_00,*(undefined4 *)(puVar31 + 0x420));

+      }

+      if ((param_11 != 0) && ((*(uint *)(param_11 + 8) >> 8 & 1) != 0)) {

+        uVar2 = *(undefined1 *)(param_11 + 2);

+        *(undefined8 *)(puVar31 + -8) = 0x140996e9a;

+        uVar36 = PspSetProcessPriorityClass(_Dst_00,uVar2,0,uVar14);

+        uVar22 = (ulonglong)uVar36;

+        if ((int)uVar36 < 0) goto LAB_17;

+      }

+      *(undefined8 *)(puVar31 + 0x20) = 0;

+      *(undefined8 *)(puVar31 + -8) = 0x140996ebe;

+      uVar14 = PspComputeQuantumAndPriority(_Dst_00,0,puVar31 + 0x94,0);

+      _Dst_00[0x90] = uVar14;

+      _Dst_00[0x91] = puVar31[0x94];

+      *(undefined4 *)(puVar31 + 0xcc) = 0;

+      *(undefined8 *)(puVar31 + -8) = 0x140996eec;

+      PspReadIFEOMitigationOptions(param_11,puVar31 + 0x3d0);

+      *(undefined8 *)(puVar31 + 0x280) = *(undefined8 *)(puVar31 + 0x3d0);

+      *(undefined8 *)(puVar31 + 0x288) = *(undefined8 *)(puVar31 + 0x3d8);

+      *(undefined8 *)(puVar31 + 0x290) = *(undefined8 *)(puVar31 + 0x3e0);

+      *(undefined4 *)(puVar31 + 0x2a0) = (undefined4)PspSystemMitigationOptions;

+      *(undefined4 *)(puVar31 + 0x2a4) = PspSystemMitigationOptions._4_4_;

+      *(undefined4 *)(puVar31 + 0x2a8) = uRam0000000140fc6148;

+      *(undefined4 *)(puVar31 + 0x2ac) = uRam0000000140fc614c;

+      *(undefined8 *)(puVar31 + 0x2b0) = DAT_21;

+      *(undefined8 *)(puVar31 + -8) = 0x140996f4b;

+      PspInheritMitigationOptions(puVar31 + 0x2a0,puVar31 + 0x280,puVar31 + 0x3d0);

+      *(undefined8 *)(puVar31 + -8) = 0x140996f5b;

+      PspReadIFEOMitigationAuditOptions(param_11,puVar31 + 1000);

+      *(undefined8 *)(puVar31 + 0x2c0) = *(undefined8 *)(puVar31 + 1000);

+      *(undefined8 *)(puVar31 + 0x2c8) = *(undefined8 *)(puVar31 + 0x3f0);

+      *(undefined8 *)(puVar31 + 0x2d0) = *(undefined8 *)(puVar31 + 0x3f8);

+      *(undefined4 *)(puVar31 + 0x2e0) = _PspSystemMitigationAuditOptions;

+      *(undefined4 *)(puVar31 + 0x2e4) = uRam0000000140fc63b4;

+      *(undefined4 *)(puVar31 + 0x2e8) = uRam0000000140fc63b8;

+      *(undefined4 *)(puVar31 + 0x2ec) = uRam0000000140fc63bc;

+      *(undefined8 *)(puVar31 + 0x2f0) = DAT_22;

+      *(undefined8 *)(puVar31 + -8) = 0x140996fba;

+      PspInheritMitigationAuditOptions(puVar31 + 0x2e0,puVar31 + 0x2c0,puVar31 + 1000);

+      uVar36 = ((ushort)((ulonglong)*(undefined8 *)(puVar31 + 0x3d0) >> 0x30) & 3) << 0xe;

+      if (param_11 != 0) {

+        if ((*(uint *)(param_11 + 8) >> 0x10 & 1) != 0) {

+          uVar26 = *(undefined8 *)(param_11 + 0x158);

+          *(undefined8 *)(puVar31 + 0x300) = *(undefined8 *)(param_11 + 0x150);

+          *(undefined8 *)(puVar31 + 0x308) = uVar26;

+          *(undefined8 *)(puVar31 + 0x310) = *(undefined8 *)(param_11 + 0x160);

+          *(undefined8 *)(puVar31 + 0x360) = *(undefined8 *)(puVar31 + 0x3d0);

+          *(undefined8 *)(puVar31 + 0x368) = *(undefined8 *)(puVar31 + 0x3d8);

+          *(undefined8 *)(puVar31 + 0x370) = *(undefined8 *)(puVar31 + 0x3e0);

+          *(undefined8 *)(puVar31 + -8) = 0x140997043;

+          PspInheritMitigationOptions(puVar31 + 0x360,puVar31 + 0x300,puVar31 + 0x3d0);

+        }

+        if ((param_11 != 0) && ((*(uint *)(param_11 + 8) >> 0x1b & 1) != 0)) {

+          uVar26 = *(undefined8 *)(param_11 + 0x1c8);

+          *(undefined8 *)(puVar31 + 800) = *(undefined8 *)(param_11 + 0x1c0);

+          *(undefined8 *)(puVar31 + 0x328) = uVar26;

+          *(undefined8 *)(puVar31 + 0x330) = *(undefined8 *)(param_11 + 0x1d0);

+          *(undefined8 *)(puVar31 + 0x340) = *(undefined8 *)(puVar31 + 1000);

+          *(undefined8 *)(puVar31 + 0x348) = *(undefined8 *)(puVar31 + 0x3f0);

+          *(undefined8 *)(puVar31 + 0x350) = *(undefined8 *)(puVar31 + 0x3f8);

+          *(undefined8 *)(puVar31 + -8) = 0x1409970b4;

+          PspInheritMitigationAuditOptions(puVar31 + 0x340,puVar31 + 800,puVar31 + 1000);

+        }

+      }

+      if (*(int *)(puVar31 + 0xd8) != 0) {

+        uVar36 = uVar36 | 4;

+      }

+      uVar20 = uVar36 | 0x40;

+      if ((uVar36 & 4) == 0) {

+        uVar20 = uVar36;

+      }

+      if ((uVar20 & 0x3fc0) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x1409970e6;

+        PspHardenMitigationOptions(puVar31 + 0x3d0);

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x1409970eb;

+      cVar12 = KeIsUserCetAllowed();

+      if (cVar12 == '\0') {

+        *(ulonglong *)(puVar31 + 0x3d8) =

+             *(ulonglong *)(puVar31 + 0x3d8) & 0xefffffffffffffff | 0x2000000000000000;

+      }

+      uVar16 = *(ushort *)(puVar31 + 0xa8) & 0x4000;

+      if ((uVar16 == 0) || ((uVar18 >> 0x12 & 1) == 0)) {

+        *(undefined4 *)(puVar31 + 0x108) = 0;

+      }

+      uVar36 = ((uint)(uVar29 >> 1) & 0x3e00000 | uVar18 & 0x100000) >> 4 |

+               (uint)((uVar29 & 0x6000) != 0) | *(ushort *)(puVar31 + 0xa8) >> 4 & 2 |

+               -(uint)(uVar16 != 0) & 8 | uVar20 | *(uint *)(puVar31 + 0x108);

+      if ((uVar29 >> 1 & 1) != 0) {

+        uVar28 = *(ulonglong *)(puVar31 + 0x3d0);

+        *(ulonglong *)(puVar31 + 0x3d0) = uVar28 & 0xfffffeffffffffff | 0x20000000000;

+        *(ulonglong *)(puVar31 + 0x3d8) =

+             *(ulonglong *)(puVar31 + 0x3d8) & 0xeffffffffffffffe | 0x2000000000000002;

+        if ((puVar31[0x888] & 2) == 0) {

+          uVar28 = uVar28 & 0xfffffeffffccffff | 0x20000110000;

+        }

+        else {

+          uVar28 = uVar28 & 0xfffffeffffecffff | 0x20000220000;

+        }

+        *(ulonglong *)(puVar31 + 0x3d0) = uVar28;

+      }

+      lVar23 = *(longlong *)(puVar31 + 0x98);

+      if (((uVar29 & 4) != 0) && ((*(uint *)(lVar23 + 0x754) & 0x4000) == 0)) {

+        *(ulonglong *)(puVar31 + 0x3d8) =

+             *(ulonglong *)(puVar31 + 0x3d8) & 0xefffffffffffffff | 0x2000000000000000;

+      }

+      if ((uVar29 & 0x40) != 0) {

+        *(ulonglong *)(puVar31 + 0x3d8) =

+             *(ulonglong *)(puVar31 + 0x3d8) & 0xefffffffffffffff | 0x2000000000000000;

+      }

+      uVar28 = *(ulonglong *)(puVar31 + 0x3e0) & 0xffffffffffffefff | 0x2000;

+      *(ulonglong *)(puVar31 + 0x3e0) = uVar28;

+      *(undefined8 *)(puVar31 + -8) = 0x140997289;

+      cVar12 = KeIsCoreIsolationMitigationPolicyEnforceable();

+      if (cVar12 == '\0') {

+        *(ulonglong *)(puVar31 + 0x3e0) = uVar28 & 0xfffffffffeffffff | 0x2000000;

+      }

+      *(undefined4 *)(puVar31 + 0x30) = *(undefined4 *)(puVar31 + 0xe8);

+      *(undefined4 *)(puVar31 + 0x28) = *(undefined4 *)(puVar31 + 0xec);

+      *(uint *)(puVar31 + 0x20) = uVar36;

+      *(undefined8 *)(puVar31 + -8) = 0x1409972d4;

+      PspApplyMitigationOptions(_Dst_00,lVar23,puVar31 + 0x3d0,puVar31 + 1000);

+      if (param_11 != 0) {

+        if (*(uint **)(param_11 + 0x1b0) != (uint *)0x0) {

+          puVar1 = (uint *)(_Dst_00 + 0x750);

+          if ((**(uint **)(param_11 + 0x1b0) & 1) != 0) {

+            LOCK();

+            *puVar1 = *puVar1 | 0x4000;

+            UNLOCK();

+            _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+          }

+          if ((**(uint **)(param_11 + 0x1b0) & 2) != 0) {

+            LOCK();

+            *puVar1 = *puVar1 | 0x8000;

+            UNLOCK();

+            _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+          }

+          *(undefined4 *)(_Dst_00 + 0x6e8) = *(undefined4 *)(*(longlong *)(param_11 + 0x1b0) + 4);

+        }

+        if (param_11 != 0) {

+          if (*(undefined4 **)(param_11 + 0x1b8) != (undefined4 *)0x0) {

+            *(undefined4 *)(_Dst_00 + 0x7a0) = **(undefined4 **)(param_11 + 0x1b8);

+          }

+          if (param_11 != 0) {

+            uVar26 = *(undefined8 *)(puVar31 + 0x3d8);

+            *(undefined8 *)(param_11 + 0x150) = *(undefined8 *)(puVar31 + 0x3d0);

+            *(undefined8 *)(param_11 + 0x158) = uVar26;

+            *(undefined8 *)(param_11 + 0x160) = *(undefined8 *)(puVar31 + 0x3e0);

+            uVar26 = *(undefined8 *)(puVar31 + 0x3f0);

+            *(undefined8 *)(param_11 + 0x1c0) = *(undefined8 *)(puVar31 + 1000);

+            *(undefined8 *)(param_11 + 0x1c8) = uVar26;

+            *(undefined8 *)(param_11 + 0x1d0) = *(undefined8 *)(puVar31 + 0x3f8);

+          }

+        }

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x1409973a9;

+      PsQueryProcessAttributes(_Dst_00,0,puVar31 + 0x95);

+      bVar13 = *(int *)(puVar31 + 0xd8) != 0 | 2;

+      if ((*(uint *)(puVar31 + 0x880) & 0x20000) == 0) {

+        bVar13 = *(int *)(puVar31 + 0xd8) != 0;

+      }

+      *(undefined8 *)(puVar31 + -8) = 0x1409973d1;

+      SmProcessCreateNotification(_Dst_00,bVar13);

+      uVar22 = uVar32;

+      if ((*(uint *)(_Dst_00 + 0x754) & 0x4000) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x1409973e6;

+        uVar36 = KeInitializeProcessUserCetLogging();

+        uVar22 = (ulonglong)uVar36;

+        if ((int)uVar36 < 0) goto LAB_17;

+      }

+      if ((puVar31[0x880] & 0x80) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x140997407;

+        iVar17 = PspIsSessionLeaderProcess();

+        if (iVar17 == 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x14099741e;

+          cVar12 = SeSinglePrivilegeCheck(SeLoadDriverPrivilege,puVar31[0x80]);

+          if (cVar12 == '\0') goto LAB_13;

+        }

+      }

+      if ((uVar29 & 1) == 0) {

+        if ((uVar29 & 4) == 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x140997443;

+          uVar36 = PspInitializeFullProcessImageName(param_11,_Dst_00);

+          uVar22 = (ulonglong)uVar36;

+          if (-1 < (int)uVar36) {

+            *(undefined4 *)(puVar31 + 0x20) = 0;

+            uVar26 = *(undefined8 *)(puVar31 + 0xf8);

+            *(undefined8 *)(puVar31 + -8) = 0x14099746e;

+            uVar36 = MmInitializeProcessAddressSpace(_Dst_00,0,uVar26,puVar31 + 0x880);

+            uVar22 = (ulonglong)uVar36;

+            if (-1 < (int)uVar36) {

+              *(uint *)(puVar31 + 0xcc) = uVar36;

+              if ((param_11 != 0) && ((uVar29 & 2) == 0)) {

+                *(undefined8 *)(puVar31 + -8) = 0x140997491;

+                plVar24 = (longlong *)MiSectionControlArea(uVar26);

+                if (*(longlong *)(*plVar24 + 0x20) != *(longlong *)(_Dst_00 + 0x2b0)) {

+                  *(longlong *)(param_11 + 0x38) =

+                       *(longlong *)(param_11 + 0x38) +

+                       (*(longlong *)(_Dst_00 + 0x2b0) - *(longlong *)(*plVar24 + 0x20));

+                }

+              }

+              uVar29 = (ulonglong)(uVar18 | 0x80);

+              *(uint *)(puVar31 + 0x84) = uVar18 | 0x80;

+              goto LAB_23;

+            }

+          }

+        }

+        else {

+          *(undefined8 *)(_Dst_00 + 0x2b0) = *(undefined8 *)(lVar23 + 0x2b0);

+          *(uint *)(puVar31 + 0x20) = (uint)(uVar29 >> 3) & 1;

+          *(undefined8 *)(puVar31 + -8) = 0x1409974ec;

+          uVar36 = MmInitializeProcessAddressSpace(_Dst_00,lVar23,0,puVar31 + 0x880);

+          uVar22 = (ulonglong)uVar36;

+          if (-1 < (int)uVar36) {

+            uVar28 = (ulonglong)*(ushort *)(*(longlong *)(lVar23 + 0x350) + 2);

+            *(undefined8 *)(puVar31 + -8) = 0x140997518;

+            _Dst = (void *)ExAllocatePool2(0x40,uVar28 + 0x10,0x61506553);

+            *(void **)(_Dst_00 + 0x350) = _Dst;

+            if (_Dst == (void *)0x0) goto LAB_19;

+            lVar23 = *(longlong *)(puVar31 + 0x98);

+            _Src = *(void **)(lVar23 + 0x350);

+            *(undefined8 *)(puVar31 + -8) = 0x140997545;

+            RtlCopyMemory(_Dst,_Src,uVar28 + 0x10);

+            *(longlong *)(*(longlong *)(_Dst_00 + 0x350) + 8) =

+                 *(longlong *)(_Dst_00 + 0x350) + 0x10;

+            *(undefined4 *)(_Dst_00 + 0x2b8) = *(undefined4 *)(lVar23 + 0x2b8);

+            if ((*(uint *)(lVar23 + 0x1f0) & 0x1000000) != 0) {

+              *(uint *)(_Dst_00 + 0x1f0) = *(uint *)(_Dst_00 + 0x1f0) | 0x1000000;

+            }

+            if ((*(uint *)(puVar31 + 0x880) & 0x1000) != 0) {

+              *(undefined8 *)(_Dst_00 + 0x2a8) = 0;

+              *(undefined8 *)(puVar31 + -8) = 0x14099759a;

+              ObfDereferenceObject();

+            }

+LAB_23:

+            uVar18 = (uint)uVar29;

+            if ((uVar29 & 1) == 0) {

+              uVar18 = (*(uint *)(puVar31 + 0x880) & 0x10) << 8 | uVar18;

+              *(uint *)(puVar31 + 0x84) = uVar18;

+              if ((uVar29 & 2) == 0) {

+                uVar18 = uVar18 | 0x100;

+                *(uint *)(puVar31 + 0x84) = uVar18;

+              }

+            }

+            goto LAB_24;

+          }

+        }

+        goto LAB_17;

+      }

+LAB_24:

+      if ((uVar18 >> 10 & 1) != 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x1409975e0;

+        RtlReleasePrivilege();

+      }

+      if (*(short *)(_Dst_00 + 0x6ec) == 0x14c) {

+        *(uint *)(_Dst_00 + 0x88) = *(uint *)(_Dst_00 + 0x88) | 1;

+      }

+      cVar12 = (char)uVar18;

+      if (((cVar12 < '\0') && (param_11 != 0)) && ((uVar18 & 2) == 0)) {

+        *(undefined8 *)(puVar31 + -8) = 0x140997617;

+        uVar36 = PspSetupReservedUserMappings(_Dst_00,puVar31 + 0x428,param_11);

+        uVar22 = (ulonglong)uVar36;

+        if ((int)uVar36 < 0) goto LAB_5;

+      }

+      if ((uVar18 >> 8 & 1) != 0) {

+        *(undefined8 *)(puVar31 + 400) = 0;

+        *(undefined8 *)(puVar31 + 0x198) = 0xffffffffffffffff;

+        bVar13 = (puVar31[0x95] & 1 | -(*(int *)(puVar31 + 0xd8) != 0) & 2U) << 4 |

+                 (byte)(uVar18 >> 0xc) & 1 | -((_Dst_00[0x5fa] & 7) != 0) & 2U |

+                 puVar31[0x193] & 0x88 |

+                 ((byte)(uVar18 >> 0xd) & 1 | ((_Dst_00[0x5fa] & 7) != 1) - 1U & 0x10) << 2;

+        puVar31[0x193] = bVar13;

+        if ((uVar18 & 4) == 0) {

+          *(undefined8 *)(puVar31 + -8) = 0x1409976db;

+          uVar36 = MmCreatePeb(_Dst_00,puVar31 + 400,_Dst_00 + 0x2e0,puVar31 + 0x210);

+          uVar22 = (ulonglong)uVar36;

+          if (-1 < (int)uVar36) {

+            if (*(longlong *)(puVar31 + 0x210) != 0) {

+              LOCK();

+              *(uint *)(_Dst_00 + 0x1f0) = *(uint *)(_Dst_00 + 0x1f0) & 0xffcfffff;

+              UNLOCK();

+              *(undefined1 **)(puVar31 + 0x20) = puVar31 + 0x15c;

+              _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+              *(undefined8 *)(puVar31 + -8) = 0x14099772b;

+              PspSetProcessAffinitySafe(_Dst_00,1,0,puVar31 + 0x210);

+            }

+            goto LAB_25;

+          }

+          *(undefined8 *)(_Dst_00 + 0x2e0) = 0;

+        }

+        else {

+          lVar23 = *(longlong *)(puVar31 + 0x98);

+          puVar3 = *(undefined4 **)(lVar23 + 0x2e0);

+          *(undefined4 **)(_Dst_00 + 0x2e0) = puVar3;

+          if ((uVar18 & 0x10) != 0) goto LAB_26;

+          puVar31[400] = 1;

+          *(undefined8 *)(puVar31 + -8) = 0x1409977fc;

+          KiStackAttachProcess(_Dst_00,0,puVar31 + 0x428);

+          *(undefined8 *)(puVar31 + -8) = 0x14099780f;

+          lVar23 = MmSecureVirtualMemory(puVar3,2000,4);

+          if (lVar23 == 0) {

+            uVar22 = 0xc0000141;

+          }

+          else {

+            uVar21 = *(undefined4 *)(puVar31 + 0x194);

+            uVar7 = *(undefined4 *)(puVar31 + 0x198);

+            uVar8 = *(undefined4 *)(puVar31 + 0x19c);

+            *puVar3 = *(undefined4 *)(puVar31 + 400);

+            puVar3[1] = uVar21;

+            puVar3[2] = uVar7;

+            puVar3[3] = uVar8;

+          }

+          if ((-1 < (int)uVar22) && (*(undefined8 **)(_Dst_00 + 0x310) != (undefined8 *)0x0)) {

+            if ((*(short *)(_Dst_00 + 0x6ec) == 0x14c) ||

+               (bVar9 = false, *(short *)(_Dst_00 + 0x6ec) == 0x1c4)) {

+              bVar9 = true;

+            }

+            if (bVar9) {

+              puVar35 = (undefined8 *)**(undefined8 **)(_Dst_00 + 0x310);

+              *(undefined8 *)(puVar31 + -8) = 0x1409978db;

+              lVar23 = MmSecureVirtualMemory(puVar35,0x488,4);

+              if (lVar23 == 0) {

+                uVar22 = 0xc0000141;

+              }

+              else {

+                *(undefined4 *)(puVar31 + 0x150) = 0;

+                *(undefined4 *)(puVar31 + 0x154) = 0xffffffff;

+                puVar31[0x150] = 1;

+                puVar31[0x153] = bVar13;

+                *puVar35 = *(undefined8 *)(puVar31 + 0x150);

+              }

+            }

+          }

+          *(undefined8 *)(puVar31 + -8) = 0x140997968;

+          KiUnstackDetachProcess(puVar31 + 0x428,0);

+          if (-1 < (int)uVar22) goto LAB_25;

+        }

+        goto LAB_5;

+      }

+LAB_25:

+      lVar23 = *(longlong *)(puVar31 + 0x98);

+LAB_26:

+      if (((cVar12 < '\0') && (param_11 != 0)) && ((uVar18 & 2) == 0)) {

+        *(undefined8 *)(puVar31 + -8) = 0x140997763;

+        uVar36 = PspSetupUserProcessAddressSpace(lVar23,_Dst_00,puVar31 + 0x428,param_11);

+        uVar22 = (ulonglong)uVar36;

+LAB_27:

+        uVar26 = *(undefined8 *)(puVar31 + 0x140);

+      }

+      else {

+        if (((uVar18 >> 8 & 1) == 0) || ((uVar18 & 0x10) != 0)) goto LAB_27;

+        *(undefined8 *)(puVar31 + -8) = 0x1409979a7;

+        KiStackAttachProcess(_Dst_00,0,puVar31 + 0x428);

+        *(undefined8 *)(puVar31 + -8) = 0x1409979af;

+        KeCopyXfdMaskToPeb(_Dst_00);

+        uVar26 = *(undefined8 *)(puVar31 + 0x140);

+        *(undefined8 *)(puVar31 + -8) = 0x1409979c2;

+        PspUpdatePebForAffinityChange(uVar26,_Dst_00);

+        if (cVar12 < '\0') {

+          *(undefined8 *)(puVar31 + -8) = 0x1409979ce;

+          uVar36 = MmMapApiSetView(_Dst_00);

+          uVar32 = (ulonglong)uVar36;

+          if (-1 < (int)uVar36) {

+            *(undefined8 *)(puVar31 + -8) = 0x1409979dc;

+            uVar36 = PspMapSiloSharedDataView(_Dst_00);

+            uVar32 = (ulonglong)uVar36;

+            if (-1 < (int)uVar36) {

+              *(undefined8 *)(puVar31 + -8) = 0x1409979eb;

+              uVar36 = PspPrepareSystemDllInitBlock(0,0);

+              uVar32 = (ulonglong)uVar36;

+              if ((-1 < (int)uVar36) && (*(longlong *)(_Dst_00 + 0x310) != 0)) {

+                *(undefined8 *)(puVar31 + -8) = 0x140997a02;

+                uVar21 = PsWow64GetProcessNtdllType(_Dst_00);

+                *(undefined8 *)(puVar31 + -8) = 0x140997a0b;

+                uVar36 = PspPrepareSystemDllInitBlock(uVar21,0);

+                uVar32 = (ulonglong)uVar36;

+              }

+            }

+          }

+        }

+        *(undefined8 *)(puVar31 + -8) = 0x140997a1c;

+        KiUnstackDetachProcess(puVar31 + 0x428,0);

+        uVar22 = uVar32;

+      }

+      if ((int)uVar22 < 0) goto LAB_5;

+      *(undefined8 *)(puVar31 + -8) = 0x140997780;

+      PspLockProcessExclusive(_Dst_00,uVar26);

+      *(undefined8 *)(puVar31 + 0x20) = 0;

+      *(undefined8 *)(puVar31 + -8) = 0x14099779a;

+      lVar23 = ExCreateHandleEx(PspCidTable,_Dst_00,0,0);

+      *(longlong *)(puVar31 + 0x100) = lVar23;

+      if (lVar23 == 0) {

+        *(undefined8 *)(puVar31 + -8) = 0x1409977b9;

+        PspUnlockProcessExclusive(_Dst_00,uVar26);

+        uVar22 = 0xc000009a;

+        goto LAB_5;

+      }

+      if ((uVar18 >> 0x10 & 1) != 0) {

+        uVar4 = *(undefined8 *)(_Dst_00 + 0x2a8);

+        *(undefined8 *)(puVar31 + -8) = 0x140997a43;

+        uVar18 = MmGetSectionStrongImageReference(0,0,uVar4,puVar31 + 0x1e0);

+        if (-1 < (int)uVar18) {

+          *(ulonglong *)(puVar31 + 0x30) = (ulonglong)*(uint *)(param_11 + 0x178);

+          *(undefined8 *)(puVar31 + 0x28) = *(undefined8 *)(param_11 + 0x168);

+          *(undefined8 *)(puVar31 + 0x20) = *(undefined8 *)(puVar31 + 0x1e0);

+          uVar4 = *(undefined8 *)(param_11 + 0xc0);

+          uVar5 = *(undefined8 *)(_Dst_00 + 0x2e0);

+          *(undefined8 *)(puVar31 + -8) = 0x140997a99;

+          uVar18 = KeSecureProcess(_Dst_00,uVar5,*(undefined8 *)(puVar31 + 0x100),uVar4);

+          if (-1 < (int)uVar18) {

+            lVar23 = *(longlong *)(puVar31 + 0x100);

+            goto LAB_28;

+          }

+        }

+        uVar22 = (ulonglong)uVar18;

+        *(undefined8 *)(puVar31 + -8) = 0x140997a54;

+        PspUnlockProcessExclusive(_Dst_00,uVar26);

+        goto LAB_5;

+      }

+LAB_28:

+      *(undefined8 *)(puVar31 + -8) = 0x140997ab1;

+      lVar25 = KeQuerySystemTimeUnsafe();

+      if (lVar25 == 0) {

+        _Dst_00 = *(undefined1 **)(puVar31 + 0xa0);

+        *(undefined8 *)(_Dst_00 + 0x1f8) = _DAT_29;

+      }

+      else {

+        *(undefined8 *)(puVar31 + -8) = 0x140997ac2;

+        KeQuerySystemTimePrecise(_Dst_00 + 0x1f8);

+      }

+      *(longlong *)(_Dst_00 + 0x1d0) = lVar23;

+      *(undefined8 *)(_Dst_00 + 0x680) = _DAT_30;

+      *(undefined8 *)(puVar31 + -8) = 0x140997afd;

+      uVar26 = KiQueryUnbiasedInterruptTime(1);

+      lVar23 = *(longlong *)(puVar31 + 0xa0);

+      *(undefined8 *)(lVar23 + 0x688) = uVar26;

+      *(undefined8 *)(lVar23 + 0x698) = *(undefined8 *)(_Dst_00 + 0x680);

+      **(longlong **)(puVar31 + 0x1f8) = lVar23;

+      uVar22 = (ulonglong)*(uint *)(puVar31 + 0xcc);

+    }

+    if (*(longlong *)(puVar31 + 0x188) != 0) {

+      *(undefined8 *)(puVar31 + -8) = 0x14099665b;

+      ExFreePoolWithTag(*(longlong *)(puVar31 + 0x188),0x73437350);

+    }

+    puVar38 = puVar31;

+    if (DAT_31 != (code *)0x0) {

+      *(undefined8 *)(puVar31 + -8) = 0x140996674;

+      (*DAT_31)(puVar31 + 0x570);

+    }

+    goto LAB_2;

   }

 LAB_3:

-  iVar4 = 0;

-LAB_1:

-  *(int *)(unaff_R14 + 0x5c) = iVar4;

-  if ((*(byte *)(unaff_R14 + 0x59) & 1) == 0) {

-    *in_stack_00000078 = 0;

-  }

-  else {

-    *in_stack_00000078 = unaff_R14 + 0x60;

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140997ec0;

-  return unaff_R13;

+  uVar22 = 0xc0000030;

+  puVar38 = auStack_838;

+LAB_2:

+  *(undefined8 *)(puVar38 + -8) = 0x140997b46;

+  return uVar22;

 }
```

## `KiSetFeatureBits`  (modified)

```diff
--- KiSetFeatureBits
+++ KiSetFeatureBits
@@ -1,23 +1,438 @@
 

-ulonglong KiSetFeatureBits(undefined4 param_1,uint param_2,ulonglong param_3,longlong param_4)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Removing unreachable block (ram,0x000140b5b497) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b46e) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b421) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b411) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b379) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b33b) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b32c) */

+/* WARNING: Removing unreachable block (ram,0x000140b5b238) */

+/* WARNING: Removing unreachable block (ram,0x000140b5aed0) */

+/* WARNING: Removing unreachable block (ram,0x000140b5aec0) */

+/* WARNING: Removing unreachable block (ram,0x000140b5aea6) */

+/* WARNING: Removing unreachable block (ram,0x000140b5ae77) */

+/* WARNING: Removing unreachable block (ram,0x000140b5ae50) */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+void KiSetFeatureBits(longlong param_1)

 

 {

-  ulonglong in_RAX;

-  ulonglong uVar1;

-  undefined4 in_R10D;

-  char in_R11B;

+  byte bVar1;

+  char cVar2;

+  uint *puVar3;

+  undefined8 *puVar4;

+  undefined4 *puVar5;

+  longlong lVar6;

+  uint uVar7;

+  uint uVar8;

+  uint uVar9;

+  ulonglong uVar10;

+  char cVar11;

+  undefined4 uVar12;

+  int iVar13;

+  undefined8 uVar14;

+  uint uVar15;

+  ulonglong uVar16;

+  ulonglong uVar17;

+  uint uVar18;

+  ulonglong uVar19;

+  ulonglong uVar20;

+  uint uVar21;

+  bool bVar22;

+  undefined1 auStack_e8 [32];

+  undefined4 *local_c8;

+  undefined8 *local_c0;

+  uint local_b8;

+  uint local_b4;

+  uint local_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined4 local_88;

+  uint uStack_84;

+  uint uStack_80;

+  uint uStack_7c;

+  undefined4 local_78;

+  undefined4 uStack_74;

+  undefined4 uStack_70;

+  undefined4 uStack_6c;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong local_38;

   

-  wrmsr(param_1,(ulonglong)param_2 << 0x20 | in_RAX & 0xffffffff);

-  wrmsr(0x26b,*(undefined8 *)(param_4 + 0x30));

-  wrmsr(0x26c,*(undefined8 *)(param_4 + 0x38));

-  wrmsr(0x26d,*(undefined8 *)(param_4 + 0x40));

-  wrmsr(0x26e,*(undefined8 *)(param_4 + 0x48));

-  uVar1 = *(ulonglong *)(param_4 + 0x50);

-  wrmsr(0x26f,uVar1);

-  if (DAT_0 == in_R11B) {

-    uVar1 = param_3 & 0xfffffffffff7ffff | 0x40000;

-    wrmsr(in_R10D,param_3 & 0xffffffff00000000 | param_3 & 0xfff7ffff | 0x40000);

-  }

-  return uVar1;

+  local_38 = __security_cookie ^ (ulonglong)auStack_e8;

+  bVar1 = *(byte *)(param_1 + 0x43);

+  cVar2 = *(char *)(param_1 + 0x8d);

+  local_68 = 0;

+  uStack_60 = 0;

+  local_b0 = (uint)((byte)(cVar2 - 1U) < 2);

+  local_58 = 0;

+  uStack_50 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_a8 = 0;

+  uStack_a0 = 0;

+  local_98 = 0;

+  uStack_90 = 0;

+  if (*(int *)(param_1 + 0x24) == 0) {

+    if (cVar2 == '\x02') {

+      if (*(char *)(param_1 + 0x40) == '\x06') {

+        KiLastExceptionFromBaseMSR = 0x1dd;

+        KiLastExceptionToBaseMSR = 0x1de;

+        if (bVar1 < 0x2e) {

+          if (bVar1 == 0x2d) {

+LAB_0:

+            KiLastBranchFromBaseMSR = 0x680;

+            KiLastBranchToBaseMSR = 0x6c0;

+            goto LAB_1;

+          }

+          if (0x1f < bVar1) {

+            if (bVar1 != 0x25) {

+              if ((bVar1 == 0x26) || (bVar1 == 0x27)) goto LAB_2;

+              if (bVar1 != 0x2a) {

+                bVar22 = bVar1 == 0x2c;

+LAB_3:

+                if (!bVar22) goto LAB_1;

+              }

+            }

+            goto LAB_0;

+          }

+          if (bVar1 == 0x1f) goto LAB_0;

+          if ((bVar1 != 0xf) && (bVar1 != 0x17)) {

+            if (bVar1 == 0x1a) goto LAB_0;

+            if ((bVar1 != 0x1c) && (bVar1 != 0x1d)) {

+              bVar22 = bVar1 == 0x1e;

+              goto LAB_3;

+            }

+          }

+LAB_2:

+          KiLastBranchFromBaseMSR = 0x40;

+          KiLastBranchToBaseMSR = 0x60;

+        }

+        else {

+          if (0x3a < bVar1) {

+            if ((((bVar1 != 0x3c) && (bVar1 != 0x3f)) && (bVar1 != 0x45)) && (bVar1 != 0x46)) {

+              if (bVar1 != 0x4d) goto LAB_1;

+              goto LAB_2;

+            }

+            goto LAB_0;

+          }

+          if (((bVar1 == 0x3a) || (bVar1 == 0x2e)) || (bVar1 == 0x2f)) goto LAB_0;

+          if (((bVar1 == 0x35) || (bVar1 == 0x36)) || (bVar1 == 0x37)) goto LAB_2;

+LAB_1:

+          if (KiLastBranchFromBaseMSR == 0) goto LAB_4;

+        }

+        KiLastBranchTOSMSR = 0x1c9;

+      }

+    }

+    else if (cVar2 == '\x01') {

+      KiLastBranchFromBaseMSR = 0x1db;

+      KiLastBranchToBaseMSR = 0x1dc;

+      KiLastExceptionFromBaseMSR = 0x1dd;

+      KiLastExceptionToBaseMSR = 0x1de;

+    }

+  }

+  else {

+    uVar12 = KiGetProcessorSignature(0,0,0,0);

+    KiSetProcessorSignature(param_1,uVar12);

+  }

+LAB_4:

+  cVar2 = *(char *)(param_1 + 0x8d);

+  puVar3 = (uint *)cpuid_basic_info(0);

+  local_b4 = *puVar3;

+  local_68 = *(undefined8 *)puVar3;

+  uStack_60 = CONCAT44(puVar3[2],puVar3[3]);

+  if (cVar2 == '\x02') {

+    wrmsr(0x8b,0);

+    puVar4 = (undefined8 *)cpuid_Version_info(1);

+    local_68 = *puVar4;

+    uStack_60 = CONCAT44(*(undefined4 *)(puVar4 + 1),*(undefined4 *)((longlong)puVar4 + 0xc));

+  }

+  else if (cVar2 != '\x01') goto LAB_5;

+  uVar14 = rdmsr(0x8b);

+  *(undefined8 *)(param_1 + 0x8fa8) = uVar14;

+LAB_5:

+  puVar5 = (undefined4 *)cpuid_Version_info(1);

+  local_48._0_4_ = *puVar5;

+  uVar15 = puVar5[1];

+  uVar7 = puVar5[2];

+  uVar18 = puVar5[3];

+  puVar3 = (uint *)cpuid(0x80000000);

+  local_b8 = *puVar3;

+  puVar5 = (undefined4 *)cpuid(0x80000001);

+  local_58._0_4_ = *puVar5;

+  local_58._4_4_ = puVar5[1];

+  uVar8 = puVar5[2];

+  uVar9 = puVar5[3];

+  uStack_50 = CONCAT44(uVar8,uVar9);

+  if (*(int *)(param_1 + 0x24) == 0) {

+    if (cVar2 == '\x01') {

+      cVar2 = *(char *)(param_1 + 0x43);

+      bVar1 = *(byte *)(param_1 + 0x42);

+      if (*(char *)(param_1 + 0x40) == '\x0f') {

+        if (((cVar2 == 'k') || (cVar2 == 'h')) && (bVar1 == 1)) {

+          KiCacheErrataMonitor = KiCacheErrataMonitor | 1;

+        }

+      }

+      else if ((*(char *)(param_1 + 0x40) == '\x10') &&

+              ((((cVar2 == '\0' && (bVar1 < 3)) ||

+                ((cVar2 == '\x02' && ((bVar1 < 3 || (bVar1 == 10)))))) ||

+               ((cVar2 == '\x04' && (bVar1 == 0)))))) {

+        KiCacheErrataMonitor = KiCacheErrataMonitor | 2;

+      }

+    }

+    if (*(int *)(param_1 + 0x24) == 0) {

+      if (*(char *)(param_1 + 0x8d) == '\x01') {

+        if (*(char *)(param_1 + 0x40) == '\x17') {

+          KiAccessBitErrata = 1;

+        }

+      }

+      else if ((*(char *)(param_1 + 0x8d) == '\x02') && (*(char *)(param_1 + 0x40) == '\x06')) {

+        bVar1 = *(byte *)(param_1 + 0x43);

+        if (((bVar1 < 0x37) && ((0x6000c010000000U >> ((ulonglong)bVar1 & 0x3f) & 1) != 0)) ||

+           ((((byte)(bVar1 - 0x37) < 0x17 && ((0x480001U >> ((byte)(bVar1 - 0x37) & 0x1f) & 1) != 0)

+             ) && (*(byte *)(param_1 + 0x42) < 8)))) {

+          KiAccessBitErrata = 2;

+        }

+      }

+    }

+  }

+  local_48._4_4_ = uVar15;

+  uStack_40._0_4_ = uVar18;

+  uStack_40._4_4_ = uVar7;

+  KiDetectKvaLeakage(param_1);

+  uVar21 = uVar8;

+  if (*(char *)(param_1 + 0x8d) == '\x01') {

+    uVar21 = uVar8 | 0x100000;

+    uStack_50 = CONCAT44(uVar8,(undefined4)uStack_50) | 0x10000000000000;

+  }

+  *(uint *)(param_1 + 0xd4) = uVar15 >> 0x18;

+  *(uint *)(param_1 + 0xe8) = uVar15 >> 5 & 0x7f8;

+  if ((((((uVar7 & 0x789f3fd) == 0x789f3fd) && ((uVar21 >> 0xb & 1) != 0)) &&

+       ((uVar21 >> 0x14 & 1) != 0)) && (((uVar18 >> 0xd & 1) != 0 && ((uVar9 & 1) != 0)))) &&

+     (KiOpPrefetchPatchSkip == 0)) {

+    uVar17 = *(ulonglong *)(param_1 + 0x8fa0);

+    uVar19 = uVar17 | 0x20113dfe;

+    if ((uVar17 & 0x400000000) != 0) {

+      wrmsr(0xc0000103,

+            (ulonglong)CONCAT11(*(undefined1 *)(param_1 + 0xd0),*(undefined1 *)(param_1 + 0xd1)));

+    }

+    uVar16 = 0;

+    wrmsr(0x174,0);

+    wrmsr(0x176,0);

+    uVar14 = 0x175;

+    wrmsr(0x175,0);

+    if ((uVar21 >> 0x19 & 1) != 0) {

+      uVar14 = 0xc0000080;

+      uVar20 = rdmsr(0xc0000080);

+      uVar16 = uVar20 >> 0x20;

+      wrmsr(0xc0000080,uVar16 << 0x20 | uVar20 & 0xffffffff | 0x4000);

+    }

+    *(undefined4 *)(param_1 + 0xa0) = 1;

+    *(undefined4 *)(param_1 + 0xa4) = 1;

+    *(undefined4 *)(param_1 + 0x9ec8) = 1;

+    *(undefined4 *)(param_1 + 0x9ecc) = 1;

+    iVar13 = Feature_PpmParkEx__private_IsEnabledNoReportingNoInline(uVar14,uVar16);

+    uVar7 = local_b4;

+    uVar15 = local_b8;

+    if (iVar13 != 0) {

+      *(undefined4 *)(param_1 + 0xbb48) = 1;

+    }

+    local_c0 = &local_a8;

+    local_c8 = &local_88;

+    local_88 = (undefined4)local_48;

+    uStack_84 = local_48._4_4_;

+    uStack_80 = (uint)uStack_40;

+    uStack_7c = uStack_40._4_4_;

+    local_78 = (undefined4)local_58;

+    uStack_74 = local_58._4_4_;

+    uStack_70 = (undefined4)uStack_50;

+    uStack_6c = uStack_50._4_4_;

+    KiComputeTopologyConstants(*(undefined1 *)(param_1 + 0x8d),local_b4,local_b8,&local_78);

+    uVar16 = local_a8;

+    if ((local_a8 & 0x10) != 0) {

+      *(undefined4 *)(param_1 + 0xd4) = (undefined4)uStack_90;

+    }

+    if ((local_a8 & 1) != 0) {

+      *(undefined4 *)(param_1 + 0xa4) = (undefined4)uStack_a0;

+    }

+    if ((local_a8 & 8) != 0) {

+      *(undefined4 *)(param_1 + 0x9ecc) = local_98._4_4_;

+    }

+    if ((local_a8 & 2) != 0) {

+      *(undefined4 *)(param_1 + 0xa0) = uStack_a0._4_4_;

+    }

+    if ((local_a8 & 4) != 0) {

+      *(undefined4 *)(param_1 + 0x9ec8) = (undefined4)local_98;

+    }

+    iVar13 = Feature_PpmParkEx__private_IsEnabledNoReportingNoInline();

+    uVar20 = local_a8;

+    if ((iVar13 != 0) && ((uVar16 & 0x20) != 0)) {

+      *(undefined4 *)(param_1 + 0xbb48) = uStack_90._4_4_;

+    }

+    *(undefined1 *)(param_1 + 0x8f) = *(undefined1 *)(param_1 + 0xa4);

+    *(undefined1 *)(param_1 + 0x8e) = *(undefined1 *)(param_1 + 0xa0);

+    uVar8 = (local_a8._4_4_ & 1) * 2 + 1;

+    uVar18 = uVar8 | 4;

+    if ((local_a8 & 0x800000000) == 0) {

+      uVar18 = uVar8;

+    }

+    uVar8 = uVar18 | 8;

+    if ((local_a8 & 0x400000000) == 0) {

+      uVar8 = uVar18;

+    }

+    uVar18 = uVar8 | 0x10;

+    if ((local_a8 & 0x200000000) == 0) {

+      uVar18 = uVar8;

+    }

+    iVar13 = Feature_PpmParkEx__private_IsEnabledNoReportingNoInline();

+    if ((iVar13 != 0) && ((uVar20 & 0x2000000000) != 0)) {

+      uVar18 = uVar18 | 0x20;

+    }

+    LOCK();

+    _KiExplicitTopologyLevels = _KiExplicitTopologyLevels | uVar18;

+    UNLOCK();

+    cVar2 = *(char *)(param_1 + 0x8d);

+    if (cVar2 == '\x01') {

+      uVar19 = uVar17 | 0x20313dfe;

+    }

+    else if (cVar2 == '\x02') {

+      uVar19 = uVar17 | 0x21113dfe;

+    }

+    iVar13 = *(int *)(param_1 + 0xa4);

+    if ((*(int *)(param_1 + 0x24) != 0) && (cVar11 = HalIsHyperThreadingEnabled(), cVar11 == '\0'))

+    {

+      iVar13 = iVar13 * *(int *)(param_1 + 0xa0);

+    }

+    *(int *)(param_1 + 0xdc) = -iVar13;

+    if ((byte)(cVar2 - 1U) < 3) {

+      if (uVar15 < 0x80000008) {

+        if (cVar2 == '\x01') {

+          KiMtrrMaxRangeShift = 0x28;

+        }

+      }

+      else {

+        puVar5 = (undefined4 *)cpuid(0x80000008);

+        KiMtrrMaxRangeShift = (byte)*puVar5;

+      }

+    }

+    KiMtrrMaskBase = (1L << (KiMtrrMaxRangeShift & 0x3f)) - 1U & 0xfffffffffffff000;

+    uVar17 = (ulonglong)((uint)KeFeatureBits2 & 0x4000);

+    cVar2 = *(char *)(param_1 + 0x8d);

+    if ((cVar2 == '\x02') && (6 < uVar7)) {

+      lVar6 = cpuid_Extended_Feature_Enumeration_info(7);

+      uVar17 = (ulonglong)*(uint *)(lVar6 + 8);

+      if ((*(uint *)(lVar6 + 4) >> 0xf & 1) != 0) {

+        lVar6 = cpuid(0x10);

+        uVar17 = (ulonglong)*(uint *)(lVar6 + 8);

+        if ((*(uint *)(lVar6 + 4) & 2) != 0) {

+          uVar19 = uVar19 | 0x100000000000;

+        }

+      }

+    }

+    uVar20 = 0x10000000000;

+    uVar16 = uVar19 | 0x20000;

+    if ((char)local_b0 == '\0') {

+      uVar16 = uVar19;

+    }

+    KiMtrrMaskMask = KiMtrrMaskBase;

+    if (cVar2 == '\x02') {

+      lVar6 = cpuid_Version_info(1);

+      uVar17 = (ulonglong)*(uint *)(lVar6 + 8);

+      if ((*(uint *)(lVar6 + 0xc) & 0x20) != 0) {

+        lVar6 = rdmsr(0x482);

+        if (lVar6 < 0) {

+          uVar17 = rdmsr(0x48b);

+          if ((uVar17 & 0x200000000) != 0) {

+            uVar16 = uVar16 | 0x4000000;

+          }

+          if (((uVar16 & 1) != 0) && ((uVar17 & 0x40000000000000) != 0)) {

+            uVar17 = HvlSetHardwareMbecAvailable();

+          }

+          if ((uVar20 & uVar17) != 0) {

+            HvlSetApicVirtualizationAvailable();

+          }

+        }

+        uVar19 = rdmsr(0x3a);

+        uVar17 = uVar19 & 0xffffffff00000000;

+        uVar10 = uVar16 | 0x8000000;

+        if (((byte)uVar19 & 5) != 5) {

+          uVar10 = uVar16;

+        }

+        uVar16 = uVar10;

+        if ((uVar19 & 4) != 0) {

+          KiVirtFlags = KiVirtFlags | 1;

+        }

+        if ((uVar19 & 1) != 0) {

+          KiVirtFlags = KiVirtFlags | 2;

+        }

+      }

+    }

+    else if (cVar2 == '\x01') {

+      puVar3 = (uint *)cpuid(0x80000000);

+      if (0x80000009 < *puVar3) {

+        lVar6 = cpuid(0x8000000a);

+        uVar15 = *(uint *)(lVar6 + 8);

+        if ((uVar15 & 1) != 0) {

+          uVar16 = uVar16 | 0x4000000;

+        }

+        if ((uVar15 & 0x20000) != 0) {

+          HvlSetHardwareMbecAvailable(*(undefined4 *)(lVar6 + 0xc));

+        }

+        if ((uVar15 >> 0xd & 1) != 0) {

+          HvlSetApicVirtualizationAvailable();

+        }

+      }

+      uVar19 = rdmsr(0xc0010114);

+      uVar17 = uVar19 & 0xffffffff00000000;

+      if ((uVar19 & 0x10) == 0) {

+        uVar16 = uVar16 | 0x8000000;

+        KiVirtFlags = KiVirtFlags | 1;

+      }

+    }

+    if (*(char *)(param_1 + 0x8d) == '\x02') {

+      lVar6 = cpuid_Extended_Feature_Enumeration_info(7);

+      uVar17 = (ulonglong)*(uint *)(lVar6 + 8);

+      if ((*(uint *)(lVar6 + 4) & 4) != 0) {

+        uVar19 = rdmsr(0x3a);

+        uVar17 = uVar19 & 0xffffffff00000000;

+        if ((uVar19 & 0x40001) == 0x40001) {

+          puVar3 = (uint *)cpuid(0x12);

+          uVar15 = *puVar3;

+          uVar17 = (ulonglong)puVar3[2];

+          if ((uVar15 & 1) != 0) {

+            uVar16 = uVar16 | uVar20;

+            *(uint *)(MmWriteableSharedUserData + 0x36c) =

+                 *(uint *)(MmWriteableSharedUserData + 0x36c) | 2;

+            if ((uVar15 & 2) != 0) {

+              uVar16 = uVar16 | 0x80000000000;

+              *(uint *)(MmWriteableSharedUserData + 0x36c) =

+                   *(uint *)(MmWriteableSharedUserData + 0x36c) | 4;

+            }

+          }

+        }

+      }

+    }

+    KiApplyProcessorErrata(param_1,uVar17);

+    KiInitializeHresetSupport(param_1);

+    *(ulonglong *)(param_1 + 0x8fa0) = uVar16;

+    DAT_6 = &KeProcessorFeaturesBuffer;

+    _KeProcessorFeaturesBuffer = 0;

+    uRam0000000140fc64a0 = 0;

+    _KeProcessorFeaturesBitMap = 0x80;

+    return;

+  }

+  if (*(int *)(param_1 + 0x24) == 0) {

+    KdInitSystem(0,KeLoaderBlock);

+  }

+  local_c8 = (undefined4 *)(ulonglong)KiOpPrefetchPatchSkip;

+                    /* WARNING: Subroutine does not return */

+  KeBugCheckEx(0x5d,uVar7,uVar21,uVar9);

 }
```

## `PpmParkCalculateCoreParkingMask`  (modified)

```diff
--- PpmParkCalculateCoreParkingMask
+++ PpmParkCalculateCoreParkingMask
@@ -1,338 +1,342 @@
 

 /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-undefined8

-PpmParkCalculateCoreParkingMask(undefined8 param_1,undefined8 param_2,uint param_3,uint param_4)

+undefined8 PpmParkCalculateCoreParkingMask(void)

 

 {

-  undefined1 uVar1;

+  ushort uVar1;

   ushort uVar2;

-  ulonglong uVar3;

-  byte bVar4;

-  ushort uVar5;

-  int iVar6;

-  undefined8 uVar7;

-  ulonglong uVar8;

-  longlong lVar9;

-  ulonglong uVar10;

-  ulonglong *puVar11;

-  uint uVar12;

-  ushort *unaff_RBX;

-  ulonglong uVar13;

-  longlong unaff_RBP;

+  byte bVar3;

+  undefined1 uVar4;

+  int iVar5;

+  uint uVar6;

+  ulonglong uVar7;

+  longlong lVar8;

+  undefined8 uVar9;

+  uint uVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  undefined1 uVar13;

   uint uVar14;

-  ulonglong unaff_RSI;

-  longlong unaff_RDI;

-  byte in_R10B;

-  ulonglong unaff_R12;

-  uint uVar15;

+  ulonglong *puVar15;

   ushort *puVar16;

-  uint unaff_R14D;

-  ulonglong unaff_R15;

-  bool bVar17;

-  undefined8 uStack0000000000000030;

-  ulonglong uStack0000000000000038;

-  ulonglong uStack0000000000000040;

-  longlong lStack0000000000000048;

-  longlong lStack0000000000000050;

-  longlong lStack0000000000000058;

-  uint uStack0000000000000060;

-  undefined1 uStack0000000000000068;

-  undefined1 uStack0000000000000070;

-  undefined4 uStack0000000000000078;

+  ulonglong uVar17;

+  longlong lVar18;

+  uint uVar19;

+  ulonglong uVar20;

+  undefined2 uVar21;

+  ushort *puVar22;

+  uint uVar23;

+  ulonglong uVar24;

+  bool bVar25;

+  uint local_res8;

+  uint local_res10 [2];

+  undefined4 local_res18 [2];

+  uint local_res20;

+  ulonglong in_stack_fffffffffffffee0;

+  undefined4 uVar26;

+  uint local_c8;

+  undefined8 local_b8;

+  ulonglong uStack_b0;

+  undefined8 local_a8;

+  uint local_a0;

+  int local_9c;

+  ulonglong local_98;

+  ulonglong local_90;

+  longlong local_88;

+  ulonglong local_80;

+  ushort *local_78;

+  undefined *local_70;

+  ulonglong local_68;

+  ulonglong local_60;

+  ushort *local_58;

   

-  do {

-    *(uint *)(unaff_RBP + 0x58) = param_3;

-    do {

-      unaff_RBX[4] = (ushort)param_4 & 0xff;

-      param_4 = (int)*(undefined8 *)(unaff_RBP + 0x50) + param_4;

-      uVar15 = (uint)unaff_RSI;

-      if (uVar15 <= param_4) {

-        param_4 = uVar15;

+  uVar7 = 0;

+  local_a8 = 0;

+  local_res18[0] = 0;

+  local_80 = 0;

+  local_res10[0] = 0;

+  local_90 = 0;

+  local_b8 = 0;

+  uStack_b0 = 0;

+  iVar5 = Feature_PpmParkEx__private_IsEnabledDeviceUsageNoInline();

+  if (iVar5 == 0) {

+    if (PpmIsParkingEnabled != 0) {

+      PpmParkSoftParkCurrentRank = 0;

+      local_70 = PpmCurrentProfile + (longlong)DAT_0 * 0x1e8;

+      PpmParkSoftParkRankListChanged = 0;

+      local_9c = (uint)(byte)local_70[0xb4] * 100;

+      if (PpmParkNewSoftParkRankList != (void *)0x0) {

+        memset(PpmParkNewSoftParkRankList,0xff,(ulonglong)KeMaximumProcessors << 2);

       }

-      uVar12 = (uint)unaff_R15;

-      if ((uint)unaff_R15 < param_4) {

-        uVar12 = param_4;

-      }

-      *(int *)(unaff_RBP + -0x80) = *(int *)(unaff_RBP + -0x80) - uVar15;

-      bVar17 = PpmParkSoftParkingEnabled == '\0';

-      uVar5 = (ushort)uVar12 & 0xff;

-      *(ushort *)(unaff_RBP + 0x50) = uVar5;

-      unaff_RBX[5] = uVar5;

-      if (bVar17) {

-        *(uint *)(unaff_RBP + 0x58) = *(uint *)(unaff_RBP + 0x58) | 0x200000;

-        uVar14 = uVar12;

-      }

-      else {

-        uVar14 = uVar15;

-        if (unaff_R14D != 0) {

-          *(uint *)(unaff_RBP + 0x58) = *(uint *)(unaff_RBP + 0x58) | 0x800000;

-          uVar14 = (uint)in_R10B;

-          if (uVar15 < in_R10B) {

-            uVar14 = uVar15;

-          }

-        }

-      }

-      uVar15 = 0;

-      uStack0000000000000070 = 0;

-      uStack0000000000000068 = 0;

-      if (PpmHeteroHgsParkingEnabled != '\0') {

-        uVar15 = (uint)*(ushort *)(unaff_RDI + 0x4e8);

-        uStack0000000000000070 = *(undefined1 *)(unaff_RDI + 0x4ef);

-        uStack0000000000000068 = *(undefined1 *)(unaff_RDI + 0x4ee);

-      }

-      uVar10 = *(ulonglong *)(unaff_RBP + -0x78);

-      uStack0000000000000078 = *(undefined4 *)(unaff_RBP + 0x68);

-      uStack0000000000000030 = *(undefined8 *)(unaff_RBP + -0x18);

-      uVar13 = uVar10 & *(ulonglong *)(unaff_RBP + -0x20);

-      lStack0000000000000058 = unaff_RDI + 0x4b0;

-      lStack0000000000000050 = unaff_RBP + 0x58;

-      lStack0000000000000048 = unaff_RBP + -0x48;

-      uStack0000000000000040 = unaff_RBP + -0x38;

-      uStack0000000000000038 = *(undefined8 *)(unaff_RBP + -0x50);

-      uStack0000000000000060 = uVar15;

-      PpmParkComputeUnparkMask

-                (unaff_RDI,uVar10,*(ulonglong *)(unaff_RDI + 0x20) & uVar10,uVar13,uVar12);

-      uVar10 = *(ulonglong *)(unaff_RBP + -0x78);

-      uVar1 = *(undefined1 *)(unaff_RBP + 0x50);

-      lStack0000000000000050 = CONCAT44(lStack0000000000000050._4_4_,uVar15);

-      *(ulonglong *)(unaff_RDI + 0x18) =

-           *(ulonglong *)(unaff_RDI + 0x18) & ~uVar10 | *(ulonglong *)(unaff_RBP + -0x48) |

-           *(ulonglong *)(unaff_RBP + -0x38);

-      *(ulonglong *)(unaff_RDI + 0x28) =

-           ~uVar10 & *(ulonglong *)(unaff_RDI + 0x28) | *(ulonglong *)(unaff_RBP + -0x48);

-      lStack0000000000000048 =

-           CONCAT44(lStack0000000000000048._4_4_,*(undefined4 *)(unaff_RBP + 0x58));

-      uStack0000000000000030 = *(undefined8 *)(unaff_RBP + -0x50);

-      iVar6 = *(int *)(unaff_RBP + 0x68);

-      uStack0000000000000038 = uVar13;

-      uStack0000000000000040 = unaff_R12;

-      PpmEventTraceSoftCoreParkingSelection(unaff_RDI,iVar6,uVar1,(char)uVar14,(char)unaff_R15);

-      bVar4 = *(byte *)(unaff_RDI + 0xc);

-      puVar16 = *(ushort **)(unaff_RBP + -0x10);

-      uVar12 = iVar6 + 1;

-      uVar15 = *(uint *)(unaff_RBP + -0x80);

-      *(uint *)(unaff_RBP + 0x68) = uVar12;

-      uVar13 = 0;

-      uVar10 = (ulonglong)uVar12;

-      if (uVar12 < bVar4) goto LAB_0;

-      do {

-        uVar10 = (ulonglong)*(uint *)(unaff_RBP + -0x58);

+      local_a0 = 0;

+      if (PpmParkNumNodes != 0) {

         do {

-          do {

-            uVar15 = (int)uVar10 + 1;

-            uVar10 = (ulonglong)uVar15;

-            bVar17 = PpmParkNumNodes <= uVar15;

-            *(uint *)(unaff_RBP + -0x58) = uVar15;

-            if (bVar17) {

-              func_0x0001404e6848();

-              uVar15 = (uint)(PpmParkLpiCap != 0);

-              if ((PpmParkLpiEngaged != uVar15) || (bVar17 = false, PpmParkLpiCapChanged != 0)) {

-                bVar17 = true;

+          uVar17 = 0;

+          lVar18 = uVar7 * 0x508 + PpmParkNodes;

+          uVar14 = (uint)uVar7;

+          local_88 = lVar18;

+          if ((*(byte *)(lVar18 + 0x4a0) & 1) == 0) {

+            *(undefined8 *)(lVar18 + 0x20) = *(undefined8 *)(lVar18 + 0x18);

+            *(undefined2 *)(lVar18 + 0x4dc) = 0;

+            *(undefined1 *)(lVar18 + 0x4de) = 0;

+            uVar1 = *(ushort *)(lVar18 + 0x492);

+            if (*(ushort *)(lVar18 + 0x496) <= *(ushort *)(lVar18 + 0x492)) {

+              uVar1 = *(ushort *)(lVar18 + 0x496);

+            }

+            local_c8 = (uint)uVar1;

+            local_68 = PpmParkFindOverUtilizedProcessors(lVar18);

+            *(undefined1 *)(lVar18 + 0x4c0) = 0;

+            if (PpmHeteroFavoredCoreRotationTimeoutMs != 0) {

+              uVar7 = _DAT_1 /

+                      ((ulonglong)PpmHeteroFavoredCoreRotationTimeoutMs * 10000);

+              *(ulonglong *)(lVar18 + 0x4b0) = uVar7;

+              if (uVar7 != *(ulonglong *)(lVar18 + 0x4b8)) {

+                *(undefined1 *)(lVar18 + 0x4c0) = 1;

+                *(ulonglong *)(lVar18 + 0x4b8) = uVar7;

               }

-              PpmParkLpiCapChanged = 0;

-              PpmParkLpiEngaged = uVar15;

-              if (bVar17) {

-                PpmEventLPICoreParking();

-              }

-              return 1;

             }

-            unaff_RDI = uVar10 * 0x508 + PpmParkNodes;

-            *(longlong *)(unaff_RBP + -0x40) = unaff_RDI;

-          } while ((*(byte *)(unaff_RDI + 0x4a0) & 1) != 0);

-          *(undefined8 *)(unaff_RDI + 0x20) = *(undefined8 *)(unaff_RDI + 0x18);

-          *(undefined2 *)(unaff_RDI + 0x4dc) = 0;

-          *(undefined1 *)(unaff_RDI + 0x4de) = 0;

-          uVar5 = *(ushort *)(unaff_RDI + 0x492);

-          if (*(ushort *)(unaff_RDI + 0x496) <= *(ushort *)(unaff_RDI + 0x492)) {

-            uVar5 = *(ushort *)(unaff_RDI + 0x496);

-          }

-          uVar15 = (uint)uVar5;

-          *(uint *)(unaff_RBP + -0x80) = uVar15;

-          uVar7 = PpmParkFindOverUtilizedProcessors(unaff_RDI);

-          *(undefined8 *)(unaff_RBP + -0x20) = uVar7;

-          *(undefined1 *)(unaff_RDI + 0x4c0) = 0;

-          if (PpmHeteroFavoredCoreRotationTimeoutMs != 0) {

-            uVar8 = _DAT_1 /

-                    ((ulonglong)PpmHeteroFavoredCoreRotationTimeoutMs * 10000);

-            *(ulonglong *)(unaff_RDI + 0x4b0) = uVar8;

-            if (uVar8 != *(ulonglong *)(unaff_RDI + 0x4b8)) {

-              *(undefined1 *)(unaff_RDI + 0x4c0) = 1;

-              *(ulonglong *)(unaff_RDI + 0x4b8) = uVar8;

+            local_res20 = 0;

+            if (*(char *)(lVar18 + 0xc) != '\0') {

+              puVar22 = (ushort *)(lVar18 + 4);

+              do {

+                uVar24 = 0;

+                puVar16 = (ushort *)(uVar17 * 0x280 + *(longlong *)(lVar18 + 0x500));

+                local_res10[0] = 0;

+                uVar7 = *(ulonglong *)(puVar16 + 0xc);

+                uVar14 = local_a0;

+                local_78 = puVar16;

+                local_58 = puVar22;

+                if (uVar7 == 0) break;

+                local_res10[0] = 0x100000;

+                if (PpmParkGranularity < 2) {

+                  uVar17 = *(ulonglong *)(puVar16 + 0x10);

+                }

+                else {

+                  local_a8 = CONCAT62(local_a8._2_6_,*puVar22);

+                  uStack_b0 = *(ulonglong *)(puVar16 + 0x10);

+                  local_b8 = 0;

+                  uVar17 = uVar24;

+                  while (iVar5 = KeEnumerateNextProcessor(local_res18,&local_b8), iVar5 == 0) {

+                    lVar8 = KeGetPrcb(local_res18[0]);

+                    uVar17 = uVar17 | *(ulonglong *)(lVar8 + 0x8e60);

+                  }

+                }

+                uVar17 = uVar17 & uVar7;

+                if (uVar17 != 0) {

+                  local_res10[0] = local_res10[0] | 0x10000;

+                }

+                uVar10 = (uint)*puVar16 - (int)POPCOUNT(uVar17);

+                local_98 = 0;

+                uVar14 = local_c8;

+                if (uVar10 <= local_c8) {

+                  uVar14 = uVar10;

+                }

+                uVar20 = local_98;

+                local_60 = uVar17;

+                if (KiClockTimerPerCpu == '\0') {

+                  local_res18[0] = KiClockTimerOwner;

+                  lVar8 = KeGetPrcb();

+                  uVar20 = local_98;

+                  if (((ushort)*(byte *)(lVar8 + 0xd0) == *puVar22) &&

+                     ((uVar7 & *(ulonglong *)(lVar8 + 200)) != 0)) {

+                    local_b8 = 0;

+                    local_a8 = CONCAT62(local_a8._2_6_,*puVar22);

+                    uStack_b0 = *(ulonglong *)(lVar8 + 200);

+                    iVar5 = KeEnumerateNextProcessor(local_res18,&local_b8);

+                    uVar11 = uVar24;

+                    uVar20 = local_98;

+                    while ((iVar5 == 0 &&

+                           (lVar18 = local_88, uVar20 = uVar11, (uint)uVar24 < uVar14))) {

+                      lVar18 = KeGetPrcb(local_res18[0]);

+                      uVar20 = *(ulonglong *)(lVar18 + 200);

+                      if ((uVar17 & uVar20) == 0) {

+                        if (1 < PpmParkGranularity) {

+                          uVar20 = *(ulonglong *)(lVar18 + 0x8e60);

+                        }

+                        local_res10[0] = local_res10[0] | 0x100;

+                        uVar11 = uVar20 | uVar11;

+                        uVar24 = POPCOUNT(uVar11);

+                      }

+                      iVar5 = KeEnumerateNextProcessor(local_res18,&local_b8);

+                      lVar18 = local_88;

+                      uVar20 = uVar11;

+                    }

+                  }

+                }

+                local_98 = uVar20;

+                uVar10 = (uint)uVar24;

+                puVar15 = &KiSystemAllowedCpuSets + (ulonglong)*puVar22 * 2;

+                uVar20 = uVar7;

+                do {

+                  lVar8 = RtlBeginReadTickLock(&KiCpuSetSequence);

+                  uVar26 = (undefined4)(in_stack_fffffffffffffee0 >> 0x20);

+                } while (KiCpuSetSequence != lVar8);

+                uVar20 = ~*puVar15 & uVar20;

+                if (uVar20 == 0) {

+                  bVar3 = 0;

+                }

+                else {

+                  bVar3 = (byte)POPCOUNT(uVar20);

+                }

+                local_res8 = (uint)bVar3;

+                uVar11 = local_98;

+                if (bVar3 != 0) {

+                  local_res8 = (uint)bVar3;

+                  if (1 < PpmParkGranularity) {

+                    local_b8 = 0;

+                    local_a8 = CONCAT62(local_a8._2_6_,*puVar22);

+                    uStack_b0 = uVar20;

+                    while (iVar5 = KeEnumerateNextProcessor(local_res18,&local_b8), iVar5 == 0) {

+                      lVar8 = KeGetPrcb(local_res18[0]);

+                      uVar20 = uVar20 | *(ulonglong *)(lVar8 + 0x8e60);

+                    }

+                    local_res8 = (uint)POPCOUNT(uVar20);

+                  }

+                  local_b8 = 0;

+                  local_a8 = CONCAT62(local_a8._2_6_,*puVar22);

+                  uStack_b0 = uVar20;

+                  iVar5 = KeEnumerateNextProcessor(local_res18);

+                  uVar26 = (undefined4)(in_stack_fffffffffffffee0 >> 0x20);

+                  uVar11 = local_98;

+                  while (iVar5 == 0) {

+                    uVar26 = (undefined4)(in_stack_fffffffffffffee0 >> 0x20);

+                    uVar10 = (uint)uVar24;

+                    puVar16 = local_78;

+                    lVar18 = local_88;

+                    if (uVar14 <= uVar10) break;

+                    lVar18 = KeGetPrcb(local_res18[0]);

+                    uVar12 = *(ulonglong *)(lVar18 + 200);

+                    if ((uVar17 & uVar12) == 0) {

+                      if (1 < PpmParkGranularity) {

+                        uVar12 = *(ulonglong *)(lVar18 + 0x8e60);

+                      }

+                      local_res10[0] = local_res10[0] | 0x10;

+                      uVar11 = uVar12 | uVar11;

+                      uVar24 = POPCOUNT(uVar11);

+                    }

+                    uVar10 = (uint)uVar24;

+                    iVar5 = KeEnumerateNextProcessor(local_res18);

+                    uVar26 = (undefined4)(in_stack_fffffffffffffee0 >> 0x20);

+                    puVar16 = local_78;

+                    lVar18 = local_88;

+                  }

+                }

+                local_98 = uVar11;

+                in_stack_fffffffffffffee0 = local_60;

+                uVar1 = puVar16[1];

+                if ((uVar10 < uVar1) && (uVar10 < uVar14)) {

+                  uVar10 = uVar14;

+                  if (uVar1 < uVar14) {

+                    uVar10 = (uint)uVar1;

+                  }

+                  local_res10[0] = local_res10[0] | 4;

+                }

+                uVar1 = puVar16[2];

+                if (((uVar1 < uVar14) && (uVar10 < uVar14)) &&

+                   (local_res10[0] = local_res10[0] | 8, uVar14 = (uint)uVar1, uVar1 <= uVar10)) {

+                  uVar14 = uVar10;

+                }

+                bVar3 = 0;

+                uVar23 = PpmHeteroHgsContainmentState & 8;

+                if (uVar23 != 0) {

+                  bVar3 = *(byte *)(*(longlong *)(lVar18 + 0x4f8) + 8 +

+                                   (longlong)*(int *)(*(longlong *)(lVar18 + 0x4f8) + 4) * 2);

+                }

+                uVar1 = *puVar16;

+                uVar2 = puVar16[3];

+                if (uVar1 <= puVar16[3]) {

+                  uVar2 = uVar1;

+                }

+                uVar19 = (uint)uVar2;

+                if ((PpmCheckLatencyBoostActive != 0) &&

+                   (uVar6 = ((uint)(byte)local_70[(ulonglong)(local_res20 != 0) + 0x89] *

+                             (uint)uVar1 + 0x32) / 100, uVar19 < uVar6)) {

+                  local_res10[0] = local_res10[0] | 0x40;

+                  uVar19 = uVar6;

+                }

+                if (1 < PpmParkGranularity) {

+                  uVar19 = uVar19 + (PpmParkGranularity - 1);

+                  uVar19 = uVar19 - uVar19 % (uint)PpmParkGranularity;

+                }

+                if (((uVar23 != 0) && (bVar3 != 0)) && (bVar3 < (byte)uVar19)) {

+                  local_res10[0] = local_res10[0] | 0x400000;

+                  uVar19 = (uint)bVar3;

+                }

+                puVar16[4] = (ushort)uVar19 & 0xff;

+                uVar6 = local_res8 + uVar19;

+                if (uVar14 <= local_res8 + uVar19) {

+                  uVar6 = uVar14;

+                }

+                uVar19 = uVar10;

+                if (uVar10 < uVar6) {

+                  uVar19 = uVar6;

+                }

+                local_c8 = local_c8 - uVar14;

+                bVar25 = PpmParkSoftParkingEnabled == '\0';

+                puVar16[5] = (ushort)uVar19 & 0xff;

+                if (bVar25) {

+                  local_res10[0] = local_res10[0] | 0x200000;

+                  uVar6 = uVar19;

+                }

+                else {

+                  uVar6 = uVar14;

+                  if (uVar23 != 0) {

+                    local_res10[0] = local_res10[0] | 0x800000;

+                    uVar6 = (uint)bVar3;

+                    if (uVar14 < bVar3) {

+                      uVar6 = uVar14;

+                    }

+                  }

+                }

+                uVar21 = 0;

+                uVar4 = 0;

+                uVar13 = 0;

+                if (PpmHeteroHgsParkingEnabled != '\0') {

+                  uVar21 = *(undefined2 *)(lVar18 + 0x4e8);

+                  uVar4 = *(undefined1 *)(lVar18 + 0x4ef);

+                  uVar13 = *(undefined1 *)(lVar18 + 0x4ee);

+                }

+                uVar17 = uVar7 & local_68;

+                PpmParkComputeUnparkMask

+                          (lVar18,uVar7,*(ulonglong *)(lVar18 + 0x20) & uVar7,uVar17,uVar19,

+                           CONCAT44(uVar26,uVar6),local_60,local_98,&local_80,&local_90,local_res10,

+                           lVar18 + 0x4b0,uVar21,uVar13,uVar4,local_res20);

+                uVar14 = local_res20;

+                *(ulonglong *)(lVar18 + 0x18) =

+                     *(ulonglong *)(lVar18 + 0x18) & ~uVar7 | local_90 | local_80;

+                *(ulonglong *)(lVar18 + 0x28) = ~uVar7 & *(ulonglong *)(lVar18 + 0x28) | local_90;

+                PpmEventTraceSoftCoreParkingSelection

+                          (lVar18,local_res20,(char)uVar19,(char)uVar6,uVar10 & 0xff,

+                           in_stack_fffffffffffffee0,local_98,uVar17,uVar20,local_res10[0],uVar21);

+                local_res20 = uVar14 + 1;

+                uVar17 = (ulonglong)local_res20;

+                puVar22 = local_58;

+                uVar14 = local_a0;

+              } while (local_res20 < *(byte *)(lVar18 + 0xc));

             }

           }

-          *(undefined4 *)(unaff_RBP + 0x68) = 0;

-        } while (*(char *)(unaff_RDI + 0xc) == '\0');

-        puVar16 = (ushort *)(unaff_RDI + 4);

-        uVar10 = uVar13;

-LAB_0:

-        *(ushort **)(unaff_RBP + -0x10) = puVar16;

-        unaff_RBX = (ushort *)(uVar10 * 0x280 + *(longlong *)(unaff_RDI + 0x500));

-        *(undefined4 *)(unaff_RBP + 0x58) = 0;

-        *(ushort **)(unaff_RBP + -0x30) = unaff_RBX;

-        uVar10 = *(ulonglong *)(unaff_RBX + 0xc);

-        *(ulonglong *)(unaff_RBP + -0x78) = uVar10;

-      } while (uVar10 == 0);

-      *(undefined4 *)(unaff_RBP + 0x58) = 0x100000;

-      if (PpmParkGranularity < 2) {

-        uVar8 = *(ulonglong *)(unaff_RBX + 0x10);

+          local_a0 = uVar14 + 1;

+          uVar7 = (ulonglong)local_a0;

+        } while (local_a0 < PpmParkNumNodes);

       }

-      else {

-        *(ushort *)(unaff_RBP + -0x60) = *puVar16;

-        *(undefined8 *)(unaff_RBP + -0x68) = *(undefined8 *)(unaff_RBX + 0x10);

-        *(undefined8 *)(unaff_RBP + -0x70) = 0;

-        uVar8 = uVar13;

-        while (iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60,unaff_RBP + -0x70), iVar6 == 0) {

-          lVar9 = KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x60));

-          uVar8 = uVar8 | *(ulonglong *)(lVar9 + 0x8e60);

-        }

+      bVar25 = false;

+      PpmParkComputeDiff();

+      uVar14 = (uint)(PpmParkLpiCap != 0);

+      if ((PpmParkLpiEngaged != uVar14) || (PpmParkLpiCapChanged != 0)) {

+        bVar25 = true;

       }

-      uVar8 = uVar8 & uVar10;

-      *(ulonglong *)(unaff_RBP + -0x18) = uVar8;

-      if (uVar8 != 0) {

-        *(uint *)(unaff_RBP + 0x58) = *(uint *)(unaff_RBP + 0x58) | 0x10000;

+      PpmParkLpiCapChanged = 0;

+      PpmParkLpiEngaged = uVar14;

+      if (bVar25) {

+        PpmEventLPICoreParking();

       }

-      uVar12 = (uint)*unaff_RBX - (int)POPCOUNT(uVar8);

-      *(undefined8 *)(unaff_RBP + -0x50) = 0;

-      if (uVar12 <= uVar15) {

-        uVar15 = uVar12;

-      }

-      unaff_RSI = (ulonglong)uVar15;

-      unaff_R15 = uVar13;

-      if (KiClockTimerPerCpu == '\0') {

-        *(undefined4 *)(unaff_RBP + 0x60) = KiClockTimerOwner;

-        lVar9 = KeGetPrcb();

-        uVar5 = *puVar16;

-        uVar10 = *(ulonglong *)(unaff_RBP + -0x78);

-        if ((*(byte *)(lVar9 + 0xd0) == uVar5) &&

-           (uVar3 = *(ulonglong *)(lVar9 + 200), (uVar10 & uVar3) != 0)) {

-          *(undefined8 *)(unaff_RBP + -0x70) = 0;

-          *(ushort *)(unaff_RBP + -0x60) = uVar5;

-          *(ulonglong *)(unaff_RBP + -0x68) = uVar3;

-          iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60,unaff_RBP + -0x70);

-          if (iVar6 == 0) {

-            do {

-              if (uVar15 <= (uint)unaff_R15) break;

-              lVar9 = KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x60));

-              uVar10 = *(ulonglong *)(lVar9 + 200);

-              if ((uVar8 & uVar10) == 0) {

-                if (1 < PpmParkGranularity) {

-                  uVar10 = *(ulonglong *)(lVar9 + 0x8e60);

-                }

-                *(uint *)(unaff_RBP + 0x58) = *(uint *)(unaff_RBP + 0x58) | 0x100;

-                uVar13 = uVar10 | uVar13;

-                unaff_R15 = POPCOUNT(uVar13);

-              }

-              iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60,unaff_RBP + -0x70);

-            } while (iVar6 == 0);

-            unaff_RDI = *(longlong *)(unaff_RBP + -0x40);

-            *(ulonglong *)(unaff_RBP + -0x50) = uVar13;

-          }

-          goto LAB_2;

-        }

-      }

-      else {

-LAB_2:

-        uVar10 = *(ulonglong *)(unaff_RBP + -0x78);

-      }

-      puVar11 = &KiSystemAllowedCpuSets + (ulonglong)*puVar16 * 2;

-      do {

-        lVar9 = RtlBeginReadTickLock(&KiCpuSetSequence);

-      } while (KiCpuSetSequence != lVar9);

-      unaff_R12 = ~*puVar11 & uVar10;

-      if (unaff_R12 == 0) {

-        bVar4 = 0;

-      }

-      else {

-        bVar4 = (byte)POPCOUNT(unaff_R12);

-      }

-      *(ulonglong *)(unaff_RBP + 0x50) = (ulonglong)bVar4;

-      if (bVar4 != 0) {

-        if (1 < PpmParkGranularity) {

-          uVar5 = *puVar16;

-          *(undefined8 *)(unaff_RBP + -0x70) = 0;

-          *(ushort *)(unaff_RBP + -0x60) = uVar5;

-          *(ulonglong *)(unaff_RBP + -0x68) = unaff_R12;

-          while (iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60,unaff_RBP + -0x70), iVar6 == 0) {

-            lVar9 = KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x60));

-            unaff_R12 = unaff_R12 | *(ulonglong *)(lVar9 + 0x8e60);

-          }

-          *(longlong *)(unaff_RBP + 0x50) = POPCOUNT(unaff_R12);

-        }

-        uVar5 = *puVar16;

-        *(undefined8 *)(unaff_RBP + -0x70) = 0;

-        *(ushort *)(unaff_RBP + -0x60) = uVar5;

-        *(ulonglong *)(unaff_RBP + -0x68) = unaff_R12;

-        iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60);

-        if (iVar6 == 0) {

-          uVar10 = *(ulonglong *)(unaff_RBP + -0x50);

-          do {

-            if (uVar15 <= (uint)unaff_R15) break;

-            lVar9 = KeGetPrcb(*(undefined4 *)(unaff_RBP + 0x60));

-            uVar13 = *(ulonglong *)(lVar9 + 200);

-            if ((uVar8 & uVar13) == 0) {

-              if (1 < PpmParkGranularity) {

-                uVar13 = *(ulonglong *)(lVar9 + 0x8e60);

-              }

-              *(uint *)(unaff_RBP + 0x58) = *(uint *)(unaff_RBP + 0x58) | 0x10;

-              uVar10 = uVar13 | uVar10;

-              unaff_R15 = POPCOUNT(uVar10);

-            }

-            iVar6 = KeEnumerateNextProcessor(unaff_RBP + 0x60);

-          } while (iVar6 == 0);

-          unaff_RBX = *(ushort **)(unaff_RBP + -0x30);

-          *(ulonglong *)(unaff_RBP + -0x50) = uVar10;

-          unaff_RDI = *(longlong *)(unaff_RBP + -0x40);

-        }

-      }

-      uVar5 = unaff_RBX[1];

-      if (((uint)unaff_R15 < (uint)uVar5) && ((uint)unaff_R15 < uVar15)) {

-        unaff_R15 = unaff_RSI;

-        if (uVar5 < uVar15) {

-          unaff_R15 = (ulonglong)uVar5;

-        }

-        param_3 = *(uint *)(unaff_RBP + 0x58) | 4;

-        *(uint *)(unaff_RBP + 0x58) = param_3;

-      }

-      else {

-        param_3 = *(uint *)(unaff_RBP + 0x58);

-      }

-      uVar5 = unaff_RBX[2];

-      if ((uVar5 < uVar15) && ((uint)unaff_R15 < uVar15)) {

-        param_3 = param_3 | 8;

-        *(uint *)(unaff_RBP + 0x58) = param_3;

-        unaff_RSI = (ulonglong)(uint)uVar5;

-        if ((uint)uVar5 <= (uint)unaff_R15) {

-          unaff_RSI = unaff_R15;

-        }

-      }

-      in_R10B = 0;

-      unaff_R14D = PpmHeteroHgsContainmentState & 8;

-      if (unaff_R14D != 0) {

-        in_R10B = *(byte *)(*(longlong *)(unaff_RDI + 0x4f8) + 8 +

-                           (longlong)*(int *)(*(longlong *)(unaff_RDI + 0x4f8) + 4) * 2);

-      }

-      uVar5 = *unaff_RBX;

-      uVar2 = unaff_RBX[3];

-      if (uVar5 <= unaff_RBX[3]) {

-        uVar2 = uVar5;

-      }

-      param_4 = (uint)uVar2;

-      if ((PpmCheckLatencyBoostActive != 0) &&

-         (uVar15 = ((uint)*(byte *)((ulonglong)(*(int *)(unaff_RBP + 0x68) != 0) + 0x89 +

-                                   *(longlong *)(unaff_RBP + -0x28)) * (uint)uVar5 + 0x32) / 100,

-         param_4 < uVar15)) {

-        param_3 = param_3 | 0x40;

-        *(uint *)(unaff_RBP + 0x58) = param_3;

-        param_4 = uVar15;

-      }

-      if (1 < PpmParkGranularity) {

-        param_4 = param_4 + (PpmParkGranularity - 1);

-        param_4 = param_4 - param_4 % (uint)PpmParkGranularity;

-      }

-    } while (((unaff_R14D == 0) || (in_R10B == 0)) || ((byte)param_4 <= in_R10B));

-    param_3 = param_3 | 0x400000;

-    param_4 = (uint)in_R10B;

-  } while( true );

+    }

+    uVar9 = 1;

+  }

+  else {

+    uVar9 = PpmParkCalculateCoreParkingMaskEx();

+  }

+  return uVar9;

 }
```

## `FsRtlpSyncWithAckTimeout`  (modified)

```diff
--- FsRtlpSyncWithAckTimeout
+++ FsRtlpFreeRHOpContext
@@ -1,26 +1,11 @@
 

-void FsRtlpSyncWithAckTimeout(longlong *param_1)

+void FsRtlpFreeRHOpContext(longlong param_1,char param_2)

 

 {

-  char cVar1;

-  longlong lVar2;

-  

-  lVar2 = *param_1;

-  if (lVar2 == 0) {

-    return;

+  if (param_2 != '\0') {

+    FsRtlpSyncWithAckTimeout(param_1 + 0x58);

   }

-  if (*(char *)(lVar2 + 0xb4) != '\0') {

-    cVar1 = KeCancelTimer();

-    lVar2 = *param_1;

-    if (cVar1 == '\0') {

-      *(undefined1 *)(lVar2 + 0xb5) = 1;

-      goto LAB_0;

-    }

-  }

-  ObfDereferenceObjectWithTag(*(undefined8 *)(lVar2 + 0xa8),0x746c6644);

-  ExFreeToNPagedLookasideList(&g_OplockAckTimeoutLookaside,*param_1);

-LAB_0:

-  *param_1 = 0;

+  ExFreePoolWithTag(param_1,0);

   return;

 }
```

## `EtwpThreadRundownApc`  (modified)

```diff
--- EtwpThreadRundownApc
+++ EtwpThreadRundownApc
@@ -1,10 +1,30 @@
-

-/* WARNING: Control flow encountered bad instruction data */

 

 void EtwpThreadRundownApc(void)

 

 {

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  undefined8 uVar1;

+  longlong lVar2;

+  bool bVar3;

+  int iVar4;

+  undefined4 uVar5;

+  undefined8 *in_R9;

+  longlong *in_stack_00000028;

+  

+  bVar3 = false;

+  uVar1 = *in_R9;

+  lVar2 = *in_stack_00000028;

+  EtwpTraceThreadRundown(SystemReserved1[0xf],lVar2);

+  iVar4 = Feature_EtwThreadStackRundownPriority__private_IsEnabledDeviceUsageNoInline();

+  uVar5 = 0;

+  if ((iVar4 != 0) && (uVar5 = 0, *(char *)(lVar2 + 0x4c) != '\0')) {

+    uVar5 = *(undefined4 *)(lVar2 + 0x48);

+    bVar3 = true;

+  }

+  KeSetEvent(uVar1,0,0);

+  iVar4 = Feature_EtwThreadStackRundownPriority__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar4 != 0) && (bVar3)) {

+    KeSetPriorityThread(SystemReserved1[0xf],uVar5);

+  }

+  return;

 }
```

## `FsRtlpRequestShareableOplock`  (modified)

```diff
--- FsRtlpRequestShareableOplock
+++ FsRtlpOplockBreakByCacheFlags
@@ -1,494 +1,1373 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Type propagation algorithm not settling */

 

-ulonglong FsRtlpRequestShareableOplock

-                    (longlong *param_1,char *param_2,undefined8 **param_3,uint param_4,

-                    undefined8 param_5,undefined8 param_6,char param_7)

+undefined4

+FsRtlpOplockBreakByCacheFlags

+          (longlong *param_1,char *param_2,longlong *param_3,uint param_4,undefined8 param_5,

+          uint param_6,undefined4 *param_7,undefined2 *param_8,longlong *param_9,undefined8 param_10

+          ,undefined8 param_11,undefined8 param_12,longlong *param_13,undefined8 param_14,

+          longlong *param_15,longlong *param_16)

 

 {

   longlong lVar1;

-  undefined8 uVar2;

-  undefined8 uVar3;

-  code *pcVar4;

-  bool bVar5;

-  undefined1 *puVar6;

-  char cVar7;

-  undefined1 uVar8;

-  int iVar9;

-  uint uVar10;

-  uint uVar11;

-  undefined8 *puVar12;

-  longlong *plVar13;

-  longlong lVar14;

-  longlong *plVar15;

-  undefined8 *puVar16;

-  undefined1 *puVar17;

-  undefined1 *puVar18;

-  undefined8 **ppuVar19;

-  longlong *plVar20;

-  char cVar21;

-  undefined8 *puVar22;

-  undefined8 uStack_1b0;

-  undefined1 auStack_1a8 [8];

-  undefined1 auStack_1a0 [24];

-  longlong alStack_188 [4];

-  undefined4 local_168;

-  char local_164 [4];

-  undefined8 local_160;

-  undefined8 *local_158;

-  uint local_150 [6];

-  undefined8 local_138;

-  undefined8 auStack_130 [9];

-  longlong alStack_e8 [12];

-  longlong alStack_88 [10];

+  bool bVar2;

+  char cVar3;

+  undefined1 uVar4;

+  uint uVar5;

+  int iVar6;

+  uint uVar7;

+  undefined4 uVar8;

+  undefined4 uVar9;

+  undefined *puVar10;

+  longlong *plVar11;

+  longlong *plVar12;

+  undefined1 auStack_ca8 [32];

+  undefined8 local_c88;

+  undefined8 *local_c80;

+  undefined2 local_c78;

+  ulonglong local_c70;

+  longlong *local_c68;

+  undefined8 local_c60;

+  longlong *local_c58;

+  char local_c48;

+  longlong *local_c40;

+  char local_c38;

+  char local_c37;

+  undefined1 local_c36;

+  undefined4 local_c34;

+  uint local_c30 [2];

+  longlong *local_c28;

+  undefined1 local_c20;

+  char *local_c18;

+  uint local_c10;

+  uint local_c0c;

+  uint local_c08 [2];

+  undefined8 *local_c00;

+  uint local_bf8;

+  uint local_bf4;

+  uint local_bf0 [3];

+  uint local_be4;

+  undefined4 local_be0;

+  uint local_bdc;

+  uint local_bd8;

+  uint local_bd4;

+  uint local_bd0;

+  uint local_bcc;

+  uint local_bc8;

+  uint local_bc4;

+  uint local_bc0;

+  uint local_bbc [3];

+  uint local_bb0;

+  undefined4 local_bac;

+  uint local_ba8;

+  uint local_ba4;

+  uint local_ba0;

+  uint local_b9c;

+  uint local_b98;

+  undefined4 local_b94;

+  undefined4 local_b90;

+  undefined4 local_b8c;

+  uint local_b88;

+  uint local_b84;

+  undefined4 local_b80;

+  undefined4 local_b7c;

+  uint local_b78;

+  uint local_b74;

+  undefined4 local_b70;

+  undefined4 local_b6c;

+  uint local_b68;

+  uint local_b64;

+  undefined4 local_b60;

+  uint local_b5c;

+  uint local_b58;

+  uint local_b54;

+  uint local_b50;

+  uint local_b4c;

+  uint local_b48;

+  uint local_b44;

+  uint local_b40;

+  uint local_b3c;

+  uint local_b38;

+  uint local_b34;

+  uint local_b30;

+  uint local_b2c;

+  uint local_b28;

+  uint local_b24;

+  uint local_b20;

+  uint local_b1c [3];

+  uint local_b10;

+  undefined4 local_b0c;

+  uint local_b08;

+  uint local_b04;

+  uint local_b00;

+  uint local_afc;

+  uint local_af8;

+  uint local_af4;

+  uint local_af0;

+  uint local_aec;

+  uint local_ae8 [2];

+  longlong *local_ae0;

+  uint local_ad8;

+  uint local_ad4;

+  uint local_ad0;

+  uint local_acc;

+  longlong *local_ac8;

+  longlong *local_ac0;

+  longlong *local_ab8;

+  longlong *local_ab0;

+  longlong *local_aa8;

+  longlong *local_aa0;

+  longlong *local_a98;

+  longlong *local_a90;

+  longlong *local_a88;

+  longlong *local_a80;

+  longlong *local_a78;

+  longlong *local_a70;

+  longlong *local_a68;

+  longlong *local_a60;

+  longlong *local_a58;

+  longlong *local_a50;

+  longlong *local_a48;

+  longlong *local_a40;

+  longlong *local_a38;

+  longlong *local_a30;

+  longlong *local_a28;

+  longlong *local_a20;

+  longlong *local_a18;

+  longlong *local_a10;

+  undefined8 local_a08;

+  undefined8 uStack_a00;

+  undefined8 local_9f8;

+  undefined1 local_9e8 [32];

+  uint *local_9c8;

+  undefined8 local_9c0;

+  uint *local_9b8;

+  undefined8 local_9b0;

+  longlong **local_9a8;

+  undefined8 local_9a0;

+  uint *local_998;

+  undefined8 local_990;

+  undefined1 local_988 [32];

+  uint *local_968;

+  undefined8 local_960;

+  uint *local_958;

+  undefined8 local_950;

+  longlong **local_948;

+  undefined8 local_940;

+  longlong **local_938;

+  undefined8 local_930;

+  uint *local_928;

+  undefined8 local_920;

+  undefined1 local_918 [32];

+  uint *local_8f8;

+  undefined8 local_8f0;

+  longlong **local_8e8;

+  undefined8 local_8e0;

+  char **local_8d8;

+  undefined8 local_8d0;

+  longlong **local_8c8;

+  undefined8 local_8c0;

+  longlong **local_8b8;

+  undefined8 local_8b0;

+  undefined1 local_8a8 [32];

+  uint *local_888;

+  undefined8 local_880;

+  uint *local_878;

+  undefined8 local_870;

+  uint *local_868;

+  undefined8 local_860;

+  longlong **local_858;

+  undefined8 local_850;

+  undefined4 *local_848;

+  undefined8 local_840;

+  undefined1 local_838 [32];

+  uint *local_818;

+  undefined8 local_810;

+  uint *local_808;

+  undefined8 local_800;

+  uint *local_7f8;

+  undefined8 local_7f0;

+  longlong **local_7e8;

+  undefined8 local_7e0;

+  uint *local_7d8;

+  undefined8 local_7d0;

+  undefined1 local_7c8 [32];

+  undefined4 *local_7a8;

+  undefined8 local_7a0;

+  uint *local_798;

+  undefined8 local_790;

+  uint *local_788;

+  undefined8 local_780;

+  longlong **local_778;

+  undefined8 local_770;

+  uint *local_768;

+  undefined8 local_760;

+  undefined1 local_758 [32];

+  uint *local_738;

+  undefined8 local_730;

+  uint *local_728;

+  undefined8 local_720;

+  uint *local_718;

+  undefined8 local_710;

+  longlong **local_708;

+  undefined8 local_700;

+  undefined4 *local_6f8;

+  undefined8 local_6f0;

+  undefined1 local_6e8 [32];

+  undefined4 *local_6c8;

+  undefined8 local_6c0;

+  uint *local_6b8;

+  undefined8 local_6b0;

+  uint *local_6a8;

+  undefined8 local_6a0;

+  longlong **local_698;

+  undefined8 local_690;

+  undefined4 *local_688;

+  undefined8 local_680;

+  undefined1 local_678 [32];

+  undefined4 *local_658;

+  undefined8 local_650;

+  uint *local_648;

+  undefined8 local_640;

+  uint *local_638;

+  undefined8 local_630;

+  longlong **local_628;

+  undefined8 local_620;

+  undefined4 *local_618;

+  undefined8 local_610;

+  undefined1 local_608 [32];

+  undefined4 *local_5e8;

+  undefined8 local_5e0;

+  uint *local_5d8;

+  undefined8 local_5d0;

+  uint *local_5c8;

+  undefined8 local_5c0;

+  longlong **local_5b8;

+  undefined8 local_5b0;

+  undefined4 *local_5a8;

+  undefined8 local_5a0;

+  undefined1 local_598 [32];

+  uint *local_578;

+  undefined8 local_570;

+  uint *local_568;

+  undefined8 local_560;

+  uint *local_558;

+  undefined8 local_550;

+  longlong **local_548;

+  undefined8 local_540;

+  undefined4 *local_538;

+  undefined8 local_530;

+  undefined1 local_528 [32];

+  uint *local_508;

+  undefined8 local_500;

+  uint *local_4f8;

+  undefined8 local_4f0;

+  longlong **local_4e8;

+  undefined8 local_4e0;

+  uint *local_4d8;

+  undefined8 local_4d0;

+  undefined1 local_4c8 [32];

+  uint *local_4a8;

+  undefined8 local_4a0;

+  uint *local_498;

+  undefined8 local_490;

+  longlong **local_488;

+  undefined8 local_480;

+  uint *local_478;

+  undefined8 local_470;

+  undefined1 local_468 [32];

+  uint *local_448;

+  undefined8 local_440;

+  uint *local_438;

+  undefined8 local_430;

+  longlong **local_428;

+  undefined8 local_420;

+  uint *local_418;

+  undefined8 local_410;

+  undefined1 local_408 [32];

+  uint *local_3e8;

+  undefined8 local_3e0;

+  uint *local_3d8;

+  undefined8 local_3d0;

+  longlong **local_3c8;

+  undefined8 local_3c0;

+  uint *local_3b8;

+  undefined8 local_3b0;

+  undefined1 local_3a8 [32];

+  uint *local_388;

+  undefined8 local_380;

+  uint *local_378;

+  undefined8 local_370;

+  longlong **local_368;

+  undefined8 local_360;

+  uint *local_358;

+  undefined8 local_350;

+  undefined1 local_348 [32];

+  uint *local_328;

+  undefined8 local_320;

+  uint *local_318;

+  undefined8 local_310;

+  longlong **local_308;

+  undefined8 local_300;

+  undefined4 *local_2f8;

+  undefined8 local_2f0;

+  undefined1 local_2e8 [32];

+  uint *local_2c8;

+  undefined8 local_2c0;

+  uint *local_2b8;

+  undefined8 local_2b0;

+  longlong **local_2a8;

+  undefined8 local_2a0;

+  uint *local_298;

+  undefined8 local_290;

+  undefined1 local_288 [32];

+  uint *local_268;

+  undefined8 local_260;

+  uint *local_258;

+  undefined8 local_250;

+  longlong **local_248;

+  undefined8 local_240;

+  uint *local_238;

+  undefined8 local_230;

+  undefined1 local_228 [32];

+  uint *local_208;

+  undefined8 local_200;

+  uint *local_1f8;

+  undefined8 local_1f0;

+  longlong **local_1e8;

+  undefined8 local_1e0;

+  uint *local_1d8;

+  undefined8 local_1d0;

+  undefined1 local_1c8 [32];

+  uint *local_1a8;

+  undefined8 local_1a0;

+  uint *local_198;

+  undefined8 local_190;

+  longlong **local_188;

+  undefined8 local_180;

+  uint *local_178;

+  undefined8 local_170;

+  undefined1 local_168 [32];

+  uint *local_148;

+  undefined8 local_140;

+  uint *local_138;

+  undefined8 local_130;

+  longlong **local_128;

+  undefined8 local_120;

+  uint *local_118;

+  undefined8 local_110;

+  undefined1 local_108 [32];

+  uint *local_e8;

+  undefined8 local_e0;

+  uint *local_d8;

+  undefined8 local_d0;

+  longlong **local_c8;

+  undefined8 local_c0;

+  uint *local_b8;

+  undefined8 local_b0;

+  undefined1 local_a8 [32];

+  uint *local_88;

+  undefined8 local_80;

+  uint *local_78;

+  undefined8 local_70;

+  longlong **local_68;

+  undefined8 local_60;

+  uint *local_58;

+  undefined8 local_50;

+  ulonglong local_48;

   

-  puVar17 = auStack_1a8;

-  puVar18 = auStack_1a8;

-  alStack_88[8] = __security_cookie ^ (ulonglong)auStack_1a8;

-  local_150[4] = param_4;

-  local_160 = param_5;

-  local_168 = 0;

-  local_158 = (undefined8 *)0x0;

-  local_138 = 0;

-  local_164[0] = 0;

-  local_164[1] = 0;

-  puVar12 = (undefined8 *)*param_1;

-  ppuVar19 = param_3;

-  if (puVar12 == (undefined8 *)0x0) {

-    puVar12 = (undefined8 *)FsRtlpAllocateOplock();

-    *param_1 = (longlong)puVar12;

+  local_48 = __security_cookie ^ (ulonglong)auStack_ca8;

+  local_ac0 = param_9;

+  local_ab8 = param_13;

+  local_aa8 = param_15;

+  local_ab0 = param_16;

+  local_c34 = 0;

+  local_a08 = 0;

+  uStack_a00 = 0;

+  local_9f8 = 0;

+  local_c48 = '\0';

+  local_c38 = '\0';

+  local_c36 = 0;

+  local_c37 = '\x01';

+  local_c30[0] = param_4 & 8;

+  local_c40 = param_3;

+  local_c18 = param_2;

+  if (5 < DAT_0) {

+    local_9c8 = &local_c10;

+    local_9c0 = 4;

+    local_c0c = param_6;

+    local_9b8 = &local_c0c;

+    local_9b0 = 4;

+    local_9a8 = &local_ae0;

+    local_9a0 = 8;

+    local_c08[0] = *(uint *)(param_1 + 0x12);

+    local_998 = local_c08;

+    local_990 = 4;

+    local_c80 = (undefined8 *)local_9e8;

+    local_c88 = CONCAT44(local_c88._4_4_,6);

+    local_c10 = param_4;

+    local_ae0 = param_1;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044ed4,0,0);

   }

-  if ((param_7 == '\0') && (param_4 != 0x10000)) {

-    local_138 = puVar12[0x13];

-    ExAcquireFastMutexUnsafe(local_138);

-    local_164[0] = 1;

+  if ((((param_6 != 0x7000) && (param_6 != 0x5000)) && (param_6 != 0x4000)) && (param_6 != 0x2000))

+  {

+    if (local_c40 != (longlong *)0x0) {

+      *(undefined4 *)(local_c40 + 6) = 0xc00000e3;

+      IofCompleteRequest(local_c40,1);

+    }

+    if (3 < DAT_0) {

+      local_c08[0] = 0xc00000e3;

+      local_968 = local_c08;

+      local_960 = 4;

+      local_958 = &local_c0c;

+      local_950 = 4;

+      local_c10 = param_6;

+      local_948 = (longlong **)&local_c10;

+      local_940 = 4;

+      local_938 = &local_c40;

+      local_930 = 8;

+      local_c30[0] = *(uint *)(param_1 + 0x12);

+      local_928 = local_c30;

+      local_920 = 4;

+      local_c80 = (undefined8 *)local_988;

+      local_c88 = CONCAT44(local_c88._4_4_,7);

+      local_c40 = param_1;

+      local_c0c = param_4;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044e69,0,0);

+    }

+    return 0xc00000e3;

   }

-  uVar11 = *(uint *)(puVar12 + 0x12);

-  plVar15 = (undefined8 *)0x0;

-  puVar6 = auStack_1a8;

-  if (((uVar11 >> 0x10 & 1) != 0) &&

-     (plVar15 = (undefined8 *)0x0, puVar6 = auStack_1a8, *param_2 == '\r')) {

-    ppuVar19 = &local_158;

-    cVar7 = FsRtlpCallerIsAtomicRequestor(puVar12,*(undefined8 *)(param_2 + 0x30));

-    puVar16 = local_158;

-    puVar6 = auStack_1a8;

-    if (cVar7 == '\0') goto LAB_0;

-    plVar15 = (undefined8 *)0x0;

-    if ((uVar11 >> 0x11 & 1) == 0) {

-LAB_1:

-      puVar16 = (undefined8 *)puVar12[0xb];

-      while (puVar16 != puVar12 + 0xb) {

-        if ((*(char *)((longlong)puVar16 + 0x35) == '\0') || (puVar22 = puVar16, param_4 != 0x3000))

-        {

-          puVar22 = (undefined8 *)puVar16[1];

-          *(undefined8 *)(puVar17 + -8) = 0x1404dc5b1;

-          FsRtlpRemoveAndCompleteWaitingIrp(puVar16);

-        }

-        puVar16 = (undefined8 *)*puVar22;

-      }

-      lVar14 = *(longlong *)(puVar17 + 0x50);

-      *(undefined8 *)(puVar17 + -8) = 0x1404dc5c3;

-      FsRtlpOplockDequeueRH(lVar14);

-      plVar20 = (longlong *)(lVar14 + 0x38);

-      lVar1 = *plVar20;

-      plVar13 = *(longlong **)(lVar14 + 0x40);

-      if ((*(longlong **)(lVar1 + 8) == plVar20) && ((longlong *)*plVar13 == plVar20)) {

-        *plVar13 = lVar1;

-        *(longlong **)(lVar1 + 8) = plVar13;

-        if ((longlong *)puVar12[0xf] == puVar12 + 0xf) {

-          *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) & 0xfffcffff;

-        }

-        if (*(longlong *)(lVar14 + 0x28) != 0) {

-          *(undefined8 *)(puVar17 + -8) = 0x1404dc60d;

-          FsRtlpClearOwner(puVar12,lVar14);

-        }

-        *(undefined8 *)(puVar17 + -8) = 0x1404dc617;

-        FsRtlpFreeRHOpContext(lVar14,1);

-        *(undefined8 *)(puVar17 + 0x50) = 0;

-        *(undefined8 *)(puVar17 + -8) = 0x1404dc628;

-        FsRtlpComputeShareableOplockState(puVar12);

-        param_7 = puVar17[0x1e0];

-        puVar6 = puVar17;

-        goto LAB_0;

-      }

-      pcVar4 = (code *)swi(0x29);

-      (*pcVar4)(3);

-      puVar18 = puVar17 + 8;

+  if (param_1 == (longlong *)0x0) {

+    return local_c34;

+  }

+  uVar7 = *(uint *)(param_1 + 0x12);

+  if ((uVar7 == 1) || ((param_6 & uVar7) == 0)) {

+    if (DAT_0 < 6) {

+      return 0;

+    }

+    local_ae8[1] = 0;

+    local_8f8 = local_ae8 + 1;

+    local_8f0 = 4;

+    local_ae0 = (longlong *)CONCAT44(local_ae0._4_4_,param_4);

+    local_8e8 = &local_ae0;

+    local_8e0 = 4;

+    local_c18 = (char *)CONCAT44(local_c18._4_4_,param_6);

+    local_8d8 = &local_c18;

+    local_8d0 = 4;

+    local_8c8 = &local_a10;

+    local_8c0 = 8;

+    local_c40 = (longlong *)CONCAT44(local_c40._4_4_,uVar7);

+    local_8b8 = &local_c40;

+    local_8b0 = 4;

+    local_c80 = (undefined8 *)local_918;

+    puVar10 = &DAT_1;

+    local_a10 = param_1;

 LAB_2:

-      puVar16 = param_3[3];

-      *(undefined4 *)(puVar16 + 1) = 0;

-      *(uint *)((longlong)puVar16 + 0xc) = *(uint *)((longlong)puVar16 + 0xc) | 4;

-      if (5 < DAT_3) {

-        *(undefined8 *)(puVar18 + -8) = 0x1404dc6ce;

-        cVar7 = _tlgKeywordOn(&DAT_3,0x400000000000);

-        if (cVar7 != '\0') {

-          *(undefined8 *)(puVar18 + 0x78) = 1;

-          *(undefined1 **)(puVar18 + 0xc0) = puVar18 + 0x78;

-          *(undefined8 *)(puVar18 + 200) = 8;

-          *(uint *)(puVar18 + 0x58) = param_4;

-          *(undefined1 **)(puVar18 + 0xd0) = puVar18 + 0x58;

-          *(undefined8 *)(puVar18 + 0xd8) = 4;

-          *(undefined4 *)(puVar18 + 0x5c) = *(undefined4 *)(puVar12 + 0x12);

-          *(undefined1 **)(puVar18 + 0xe0) = puVar18 + 0x5c;

-          *(undefined8 *)(puVar18 + 0xe8) = 4;

-          *(undefined8 *)(puVar18 + 0x80) = 0x1000000;

-          *(undefined1 **)(puVar18 + 0xf0) = puVar18 + 0x80;

-          *(undefined8 *)(puVar18 + 0xf8) = 8;

-          *(undefined1 **)(puVar18 + 0x20) = puVar18 + 0xa0;

-          *(undefined8 *)(puVar18 + -8) = 0x1404dc785;

-          _tlgWriteAgg(&DAT_3,&DAT_140045012);

-        }

+    local_c88 = CONCAT44(local_c88._4_4_,7);

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,puVar10,0,0);

+    return 0;

+  }

+  if ((local_c30[0] == 0) &&

+     (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),param_1[1],param_4),

+     cVar3 != '\0')) {

+    if (DAT_0 < 6) {

+      return 0;

+    }

+    local_c08[0] = 0;

+    local_818 = local_c08;

+    local_810 = 4;

+    local_808 = &local_c0c;

+    local_800 = 4;

+    local_c10 = param_6;

+    local_7f8 = &local_c10;

+    local_7f0 = 4;

+    local_7e8 = &local_a88;

+    local_7e0 = 8;

+    local_c30[0] = *(uint *)(param_1 + 0x12);

+    local_7d8 = local_c30;

+    local_7d0 = 4;

+    local_c80 = (undefined8 *)local_838;

+    puVar10 = &DAT_3;

+    local_c0c = param_4;

+    local_a88 = param_1;

+    goto LAB_2;

+  }

+  uVar7 = *(uint *)(param_1 + 0x12);

+  if (((uVar7 & 0x40) != 0) && ((param_4 & 0x10010000) != 0)) {

+    if (DAT_0 < 4) {

+      return 0xc0000909;

+    }

+    local_c34 = 0xc0000909;

+    local_7a8 = &local_c34;

+    local_7a0 = 4;

+    local_798 = &local_ad8;

+    local_790 = 4;

+    local_ad0 = param_6;

+    local_788 = &local_ad0;

+    local_780 = 4;

+    local_778 = &local_a78;

+    local_770 = 8;

+    local_768 = &local_acc;

+    local_760 = 4;

+    local_c80 = (undefined8 *)local_7c8;

+    puVar10 = &DAT_4;

+    local_ad8 = param_4;

+    local_acc = uVar7;

+    local_a78 = param_1;

+LAB_5:

+    local_c88 = CONCAT44(local_c88._4_4_,7);

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,puVar10,0,0);

+    return 0xc0000909;

+  }

+  uVar5 = uVar7 & 0x1f0ffdf;

+  if (0x105040 < uVar5) {

+    if (uVar5 == 0x107040) {

+      if (5 < DAT_0) {

+        local_968 = &local_af0;

+        local_960 = 4;

+        local_aec = param_6;

+        local_958 = &local_aec;

+        local_950 = 4;

+        local_948 = &local_a18;

+        local_940 = 8;

+        local_938 = (longlong **)local_ae8;

+        local_930 = 4;

+        local_c80 = (undefined8 *)local_988;

+        local_c88 = CONCAT44(local_c88._4_4_,6);

+        local_af0 = param_4;

+        local_ae8[0] = uVar7;

+        local_a18 = param_1;

+        _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043f10,0,0);

+      }

+      if ((param_6 >> 0xc & 1) != 0) {

+LAB_6:

+        uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x807040;

+LAB_7:

+        *(uint *)(param_1 + 0x12) = uVar7;

       }

     }

     else {

-      FsRtlpOplockDequeueRH(local_158);

-      plVar15 = puVar16 + 7;

-      lVar14 = *plVar15;

-      plVar20 = (longlong *)puVar16[8];

-      if ((*(longlong **)(lVar14 + 8) != plVar15) || ((longlong *)*plVar20 != plVar15)) {

-        pcVar4 = (code *)swi(0x29);

-        (*pcVar4)(3);

-        puVar17 = auStack_1a0;

-        plVar15 = puVar16;

-        goto LAB_1;

-      }

-      *plVar20 = lVar14;

-      *(longlong **)(lVar14 + 8) = plVar20;

-      if ((longlong *)puVar12[0xf] == puVar12 + 0xf) {

-        *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) & 0xfffcffff;

-      }

-      if (puVar16[5] != 0) {

-        FsRtlpClearOwner(puVar12,puVar16);

-      }

-      FsRtlpFreeRHOpContext(puVar16,1);

-      local_158 = (undefined8 *)0x0;

-      FsRtlpComputeShareableOplockState(puVar12);

-    }

-    goto LAB_4;

+      if (uVar5 != 0x307040) {

+        if (uVar5 == 0x507040) {

+          if (5 < DAT_0) {

+            local_4a8 = &local_b08;

+            local_4a0 = 4;

+            local_b04 = param_6;

+            local_498 = &local_b04;

+            local_490 = 4;

+            local_488 = &local_a28;

+            local_480 = 8;

+            local_478 = &local_b00;

+            local_470 = 4;

+            local_c80 = (undefined8 *)local_4c8;

+            local_c88 = CONCAT44(local_c88._4_4_,6);

+            local_b08 = param_4;

+            local_b00 = uVar7;

+            local_a28 = param_1;

+            _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044640,0,0);

+          }

+          plVar12 = local_c40;

+          if (param_6 == 0x2000) {

+            if (((param_4 & 0x40000080) == 0x40000080) &&

+               (iVar6 = FsRtlpCheckSharingAgainstOplockOwner(local_c40,param_1[1],*param_7,*param_8)

+               , -1 < iVar6)) goto LAB_8;

+            uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x107040;

+          }

+          else {

+            if ((param_6 >> 0xc & 1) == 0) goto LAB_9;

+            uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x807040;

+          }

+          *(uint *)(param_1 + 0x12) = uVar7;

+        }

+        else {

+          if (uVar5 == 0x803000) {

+            if (5 < DAT_0) {

+              local_508 = &local_b24;

+              local_500 = 4;

+              local_b20 = param_6;

+              local_4f8 = &local_b20;

+              local_4f0 = 4;

+              local_4e8 = &local_a38;

+              local_4e0 = 8;

+              local_4d8 = &local_ad4;

+              local_4d0 = 4;

+              local_c80 = (undefined8 *)local_528;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_b24 = param_4;

+              local_ad4 = uVar7;

+              local_a38 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044787,0,0);

+            }

+            plVar12 = local_c40;

+            if ((param_6 & 0x3000) != 0) {

+              if ((-1 < (char)param_4) && ((param_4 & 0x10010000) != 0)) {

+                if (DAT_0 < 4) {

+                  return 0xc0000909;

+                }

+                local_b1c[1] = 0xc0000909;

+                local_578 = local_b1c + 1;

+                local_570 = 4;

+                local_568 = local_b1c + 2;

+                local_560 = 4;

+                local_558 = &local_b10;

+                local_550 = 4;

+                local_548 = &local_aa8;

+                local_540 = 8;

+                local_b0c = (undefined4)param_1[0x12];

+                local_538 = &local_b0c;

+                local_530 = 4;

+                local_c80 = (undefined8 *)local_598;

+                puVar10 = &DAT_10;

+                local_b1c[2] = param_4;

+                local_b10 = param_6;

+                local_aa8 = param_1;

+                goto LAB_5;

+              }

+              if ((param_6 >> 0xd & 1) != 0) {

+                for (plVar11 = (longlong *)param_1[9]; plVar12 = local_c40, local_c28 = plVar11,

+                    plVar11 != param_1 + 9; plVar11 = (longlong *)*plVar11) {

+                  if (((local_c30[0] != 0) ||

+                      (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),plVar11[3],0)

+                      , cVar3 == '\0')) &&

+                     (((param_4 & 0x40000080) != 0x40000080 ||

+                      (iVar6 = FsRtlpCheckSharingAgainstOplockOwner

+                                         (local_c40,plVar11[3],*param_7,*param_8), iVar6 < 0)))) {

+                    if ((param_4 & 0x10010000) != 0) {

+                      return 0xc0000909;

+                    }

+                    goto LAB_9;

+                  }

+                }

+              }

+            }

+            goto LAB_8;

+          }

+          if (uVar5 == 0x805040) {

+            if (5 < DAT_0) {

+              local_e8 = &local_b30;

+              local_e0 = 4;

+              local_b2c = param_6;

+              local_d8 = &local_b2c;

+              local_d0 = 4;

+              local_c8 = &local_a40;

+              local_c0 = 8;

+              local_b8 = &local_b28;

+              local_b0 = 4;

+              local_c80 = (undefined8 *)local_108;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_b30 = param_4;

+              local_b28 = uVar7;

+              local_a40 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044565,0,0);

+            }

+            goto LAB_11;

+          }

+          if (uVar5 == 0x807040) {

+            if (5 < DAT_0) {

+              local_148 = &local_b3c;

+              local_140 = 4;

+              local_b38 = param_6;

+              local_138 = &local_b38;

+              local_130 = 4;

+              local_128 = &local_a48;

+              local_120 = 8;

+              local_118 = &local_b34;

+              local_110 = 4;

+              local_c80 = (undefined8 *)local_168;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_b3c = param_4;

+              local_b34 = uVar7;

+              local_a48 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043ea0,0,0);

+            }

+            if (((param_4 & 0x40000080) == 0x40000080) &&

+               (iVar6 = FsRtlpCheckSharingAgainstOplockOwner(local_c40,param_1[1],*param_7,*param_8)

+               , plVar12 = local_c40, -1 < iVar6)) goto LAB_8;

+            goto LAB_12;

+          }

+LAB_13:

+          if ((uVar7 >> 0x18 & 1) == 0) {

+            plVar12 = local_c40;

+            if (2 < DAT_0) {

+              local_1a8 = &local_b48;

+              local_1a0 = 4;

+              local_b44 = param_6;

+              local_198 = &local_b44;

+              local_190 = 4;

+              local_188 = &local_a50;

+              local_180 = 8;

+              local_178 = &local_b40;

+              local_170 = 4;

+              local_c80 = (undefined8 *)local_1c8;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_b48 = param_4;

+              local_b40 = uVar7;

+              local_a50 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043f7d,0,0);

+              plVar12 = local_c40;

+            }

+            goto LAB_8;

+          }

+          if (5 < DAT_0) {

+            local_208 = &local_b54;

+            local_200 = 4;

+            local_b50 = param_6;

+            local_1f8 = &local_b50;

+            local_1f0 = 4;

+            local_1e8 = &local_a58;

+            local_1e0 = 8;

+            local_1d8 = &local_b4c;

+            local_1d0 = 4;

+            local_c80 = (undefined8 *)local_228;

+            local_c88 = CONCAT44(local_c88._4_4_,6);

+            local_b54 = param_4;

+            local_b4c = uVar7;

+            local_a58 = param_1;

+            _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043fea,0,0);

+          }

+        }

+LAB_9:

+        local_c48 = '\x01';

+        plVar12 = local_c40;

+        goto LAB_8;

+      }

+      if (5 < DAT_0) {

+        local_268 = &local_afc;

+        local_260 = 4;

+        local_af8 = param_6;

+        local_258 = &local_af8;

+        local_250 = 4;

+        local_248 = &local_a20;

+        local_240 = 8;

+        local_238 = &local_af4;

+        local_230 = 4;

+        local_c80 = (undefined8 *)local_288;

+        local_c88 = CONCAT44(local_c88._4_4_,6);

+        local_afc = param_4;

+        local_af4 = uVar7;

+        local_a20 = param_1;

+        _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_1400446ae,0,0);

+      }

+      if (param_6 == 0x4000) {

+        uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x107040;

+        goto LAB_7;

+      }

+      if ((param_6 & 0x5000) == 0x5000) goto LAB_6;

+    }

+    plVar12 = local_c40;

+    if (((param_4 & 0x40000080) != 0x40000080) ||

+       (iVar6 = FsRtlpCheckSharingAgainstOplockOwner(local_c40,param_1[1],*param_7,*param_8),

+       iVar6 < 0)) {

+      local_c48 = '\x01';

+    }

+    goto LAB_8;

   }

-LAB_0:

-  puVar18 = puVar6;

-  bVar5 = false;

-  *(undefined8 *)(puVar18 + -8) = 0x1404dc643;

-  cVar7 = FsRtlpOplockUpperLowerCompatible(param_4,*(undefined4 *)(puVar18 + 0x1e8));

-  if (cVar7 == '\0') goto LAB_4;

-  if ((((param_4 >> 0xc & 1) == 0) && (param_4 != 0x10000)) ||

-     (*(longlong *)(*(longlong *)(param_2 + 0x30) + 0x28) == 0)) {

-LAB_5:

-    if ((param_7 != '\0') || ((*(uint *)(puVar12 + 0x12) & 0x40) == 0)) {

-      if (param_4 == 0x10) {

-        if ((((*(uint *)(puVar12 + 0x12) & 1) == 0) &&

-            (uVar11 = *(uint *)(puVar12 + 0x12) & 0x1f0ffdf, uVar11 != 0x10)) &&

-           ((uVar11 != 0x1000 && (uVar11 != 0x1010)))) goto LAB_4;

-      }

-      else if (param_4 != 0x1000) {

-        if ((param_4 != 0x3000) && (param_4 != 0x10000)) goto LAB_6;

-        if ((((param_7 == '\0') &&

-             (((((uVar11 = *(uint *)(puVar12 + 0x12), (uVar11 & 1) == 0 &&

-                 (uVar10 = uVar11 & 0x1f0ffdf, uVar10 != 0x1000)) && (uVar10 != 0x3000)) &&

-               ((uVar10 != 0xb000 && (uVar10 != 0x103000)))) && (uVar10 != 0x803000)))) &&

-            ((uVar11 >> 0x10 & 1) == 0)) ||

-           (*(char *)(*(longlong *)(param_2 + 0x30) + 0x49) != '\0')) goto LAB_7;

-        if (param_7 == '\0') {

-          if (((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) == 0x1000) ||

-             ((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) == 0xb000)) {

-            for (puVar16 = (undefined8 *)puVar12[5]; puVar16 != puVar12 + 5;

-                puVar16 = (undefined8 *)*puVar16) {

-              uVar2 = *(undefined8 *)(puVar16[2] + 0x30);

-              uVar3 = *(undefined8 *)(param_2 + 0x30);

-              ppuVar19 = (undefined8 **)0x0;

-              *(undefined8 *)(puVar18 + -8) = 0x1404dc872;

-              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

-              if (cVar7 != '\0') {

-                if (param_4 == 0x10000) {

-                  plVar15 = (undefined8 *)0xc00000e3;

-                  goto LAB_8;

-                }

-                ppuVar19 = (undefined8 **)0x3000;

-                uVar2 = *(undefined8 *)puVar16[1];

-                *(undefined8 *)(puVar18 + -8) = 0x1404dc8a7;

-                FsRtlpRemoveAndCompleteReadOnlyIrp(uVar2,0x215,0x3000,puVar12);

-                break;

-              }

-            }

-          }

-          if (((*(uint *)(puVar12 + 0x12) & 0x1f0ffdf) - 0x3000 & 0xffff7fff) == 0) {

-            for (puVar16 = (undefined8 *)puVar12[7]; puVar16 != puVar12 + 7;

-                puVar16 = (undefined8 *)*puVar16) {

-              uVar2 = puVar16[3];

-              uVar3 = *(undefined8 *)(param_2 + 0x30);

-              ppuVar19 = (undefined8 **)0x0;

-              *(undefined8 *)(puVar18 + -8) = 0x1404dc8db;

-              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

-              if ((cVar7 != '\0') && (puVar16[7] == 0)) {

-                if (param_4 == 0x10000) {

-                  plVar15 = (undefined8 *)0xc00000e3;

-                  goto LAB_8;

-                }

-                puVar16 = (undefined8 *)puVar16[1];

-                puVar18[0x38] = 0;

-                *(undefined2 *)(puVar18 + 0x30) = 0;

-                *(undefined4 *)(puVar18 + 0x28) = 0;

-                *(undefined4 *)(puVar18 + 0x20) = 0;

-                ppuVar19 = (undefined8 **)0x215;

-                uVar2 = *puVar16;

-                *(undefined8 *)(puVar18 + -8) = 0x1404dc938;

-                FsRtlpRemoveAndCompleteRHIrp(uVar2,puVar12,0x215,0x3000);

-                break;

-              }

-            }

-          }

-          plVar15 = (longlong *)puVar12[9];

-          if (plVar15 != puVar12 + 9) {

-            for (; plVar15 != puVar12 + 9; plVar15 = (longlong *)*plVar15) {

-              uVar2 = plVar15[3];

-              uVar3 = *(undefined8 *)(param_2 + 0x30);

-              ppuVar19 = (undefined8 **)0x0;

-              *(undefined8 *)(puVar18 + -8) = 0x1404dc95d;

-              cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2);

-              if (cVar7 != '\0') {

-                plVar15 = (undefined8 *)0xc00000e2;

-                if (param_4 != 0x10000) goto LAB_4;

-                goto LAB_8;

-              }

-            }

-          }

-        }

-        plVar20 = *(longlong **)(puVar18 + 0x48);

-        *(undefined8 *)(*plVar20 + 0x20) = *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

-        *(undefined8 *)(*plVar20 + 0x18) = *(undefined8 *)(param_2 + 0x30);

-        lVar14 = *plVar20;

-        *(undefined8 *)(puVar18 + -8) = 0x1404dc9bb;

-        uVar11 = FsRtlpOplockEnqueueRH(puVar12 + 7,lVar14);

-        plVar15 = (longlong *)(ulonglong)uVar11;

-        *(uint *)(puVar18 + 0x40) = uVar11;

-        if ((int)uVar11 < 0) {

-          if (param_4 != 0x10000) {

-            *(uint *)(param_3 + 6) = uVar11;

-            *(undefined8 *)(puVar18 + -8) = 0x1404dc9df;

-            IofCompleteRequest(param_3,1);

-          }

-          goto LAB_9;

-        }

-        bVar5 = false;

-        if (param_4 == 0x10000) {

-          plVar13 = (longlong *)(*plVar20 + 0x38);

-          plVar15 = puVar12 + 0xf;

-          lVar14 = *plVar15;

-          if (*(longlong **)(lVar14 + 8) != plVar15) {

-            plVar15 = (longlong *)0x3;

-            pcVar4 = (code *)swi(0x29);

-            plVar13 = (longlong *)(*pcVar4)();

-            puVar18 = puVar18 + 8;

-          }

-          *plVar13 = lVar14;

-          plVar13[1] = (longlong)plVar15;

-          *(longlong **)(lVar14 + 8) = plVar13;

-          *plVar15 = (longlong)plVar13;

-          plVar15 = (undefined8 *)0x0;

-          *(undefined4 *)(puVar18 + 0x40) = 0;

-LAB_10:

-          cVar21 = puVar18[0x1e0];

-          bVar5 = true;

-        }

-        else {

-          *(void **)(puVar18 + 0x90) = SystemReserved1[0xf];

-          *(void **)(*plVar20 + 0x28) = SystemReserved1[0xf];

-          uVar2 = *(undefined8 *)(*plVar20 + 0x28);

-          *(undefined8 *)(puVar18 + -8) = 0x1404dca52;

-          ObfReferenceObjectWithTag(uVar2,0x746c6644);

-          *(undefined8 ***)(*plVar20 + 0x10) = param_3;

-          *(byte *)((longlong)param_3[0x17] + 3) = *(byte *)((longlong)param_3[0x17] + 3) | 1;

-          plVar15 = (undefined8 *)0x103;

-          *(undefined4 *)(puVar18 + 0x40) = 0x103;

-          *(undefined4 *)(param_3 + 6) = 0;

-          param_3[7] = puVar12;

-          cVar7 = puVar18[0x1d8];

-          if (cVar7 != '\0') {

-            uVar2 = *(undefined8 *)(**(longlong **)(puVar18 + 0x48) + 0x18);

-            *(undefined8 *)(puVar18 + -8) = 0x1404dca9b;

-            ObfReferenceObjectWithTag(uVar2,0x746c6644);

-          }

-          *(undefined8 *)(puVar18 + -8) = 0x1404dcaa5;

-          uVar8 = KeAcquireQueuedSpinLock(7);

-          *(undefined1 *)((longlong)param_3 + 0x45) = uVar8;

-          if (*(char *)((longlong)param_3 + 0x44) == '\0') {

-            LOCK();

-            param_3[0xd] = (undefined8 *)FsRtlpOplockRHIrpCancelRoutine;

-            UNLOCK();

-            uVar8 = *(undefined1 *)((longlong)param_3 + 0x45);

-            *(undefined8 *)(puVar18 + -8) = 0x1404dcb04;

-            KeReleaseQueuedSpinLock(7,uVar8);

-            plVar15 = (longlong *)(ulonglong)*(uint *)(puVar18 + 0x40);

-            plVar20 = *(longlong **)(puVar18 + 0x48);

-            goto LAB_10;

-          }

-          cVar21 = puVar18[0x1e0];

-          if ((cVar7 == '\0') || (cVar21 == '\0')) {

-            *(undefined8 *)(puVar18 + -8) = 0x1404dcae4;

-            FsRtlpCancelOplockRHIrp(param_3,1);

-            plVar20 = *(longlong **)(puVar18 + 0x48);

-          }

-          else {

-            *(undefined8 *)(puVar18 + -8) = 0x1404dcace;

-            FsRtlpCancelOplockRHIrp(param_3,1,(ulonglong)ppuVar19 & 0xffffffffffffff00);

-            plVar20 = *(longlong **)(puVar18 + 0x48);

-          }

-        }

-        if (5 < DAT_3) {

-          *(uint *)(puVar18 + 0x60) = param_4;

-          *(undefined1 **)(puVar18 + 0x120) = puVar18 + 0x60;

-          *(undefined8 *)(puVar18 + 0x128) = 4;

-          puVar18[0x45] = cVar21;

-          *(undefined1 **)(puVar18 + 0x130) = puVar18 + 0x45;

-          *(undefined8 *)(puVar18 + 0x138) = 1;

-          *(undefined8 **)(puVar18 + 0x88) = puVar12;

-          *(undefined1 **)(puVar18 + 0x140) = puVar18 + 0x88;

-          *(undefined8 *)(puVar18 + 0x148) = 8;

-          *(undefined4 *)(puVar18 + 0x48) = *(undefined4 *)(puVar12 + 0x12);

-          *(undefined1 **)(puVar18 + 0x150) = puVar18 + 0x48;

-          *(undefined8 *)(puVar18 + 0x158) = 4;

-          *(undefined1 **)(puVar18 + 0x28) = puVar18 + 0x100;

-          *(undefined4 *)(puVar18 + 0x20) = 6;

-          *(undefined8 *)(puVar18 + -8) = 0x1404dcbd7;

-          _tlgWriteTransfer_EtwWriteTransfer(&DAT_3,&DAT_140044faa,0,0);

-        }

-        *(undefined8 *)(puVar18 + -8) = 0x1404dcbdf;

-        FsRtlpComputeShareableOplockState(puVar12);

-        if (bVar5) {

-          lVar14 = *plVar20;

-          *(longlong *)(puVar18 + 0x20) = lVar14 + 0x58;

-          uVar2 = *(undefined8 *)(lVar14 + 0x18);

-          *(undefined8 *)(puVar18 + -8) = 0x1404dcc04;

-          FsRtlpOplockTryPrepForAckTimeout(puVar12,uVar2,param_3,lVar14 + 0x48);

-        }

-        *plVar20 = 0;

-        if (param_4 == 0x10000) {

-          *(uint *)(puVar12 + 0x12) = *(uint *)(puVar12 + 0x12) | 0x10000;

-        }

-        goto LAB_9;

-      }

-      if (param_7 != '\0') goto LAB_11;

-      uVar11 = *(uint *)(puVar12 + 0x12);

-      if ((((((uVar11 & 1) != 0) || (uVar10 = uVar11 & 0x1f0ffdf, uVar10 == 0x10)) ||

-           (uVar10 == 0x1000)) ||

-          (((uVar10 == 0x1010 || (uVar10 == 0x3000)) ||

-           ((uVar10 == 0xb000 || ((uVar10 == 0x103000 || (uVar10 == 0x803000)))))))) ||

-         ((uVar11 >> 0x10 & 1) != 0)) {

-        plVar15 = (longlong *)puVar12[7];

-        if ((plVar15 != puVar12 + 7) || ((longlong *)puVar12[9] != puVar12 + 9)) {

-          for (; plVar15 != puVar12 + 7; plVar15 = (longlong *)*plVar15) {

-            uVar2 = plVar15[3];

-            uVar3 = *(undefined8 *)(param_2 + 0x30);

-            *(undefined8 *)(puVar18 + -8) = 0x1404dccdc;

-            cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

-            if (cVar7 != '\0') goto LAB_4;

-          }

-          for (plVar15 = (longlong *)puVar12[9]; plVar15 != puVar12 + 9;

-              plVar15 = (longlong *)*plVar15) {

-            uVar2 = plVar15[3];

-            uVar3 = *(undefined8 *)(param_2 + 0x30);

-            *(undefined8 *)(puVar18 + -8) = 0x1404dcd09;

-            cVar7 = FsRtlpOplockKeysEqual(uVar3,uVar2,0);

-            if (cVar7 != '\0') goto LAB_4;

-          }

-        }

-        uVar11 = *(uint *)(puVar12 + 0x12) & 0x1f0ffdf;

-        if ((((uVar11 != 0x10) && (uVar11 != 0x1000)) && (uVar11 != 0x1010)) && (uVar11 != 0xb000))

-        goto LAB_11;

-        plVar15 = (longlong *)puVar12[5];

-        do {

-          if (plVar15 == puVar12 + 5) {

+  if (uVar5 == 0x105040) {

+    if (5 < DAT_0) {

+      local_88 = local_b1c;

+      local_80 = 4;

+      local_b5c = param_6;

+      local_78 = &local_b5c;

+      local_70 = 4;

+      local_68 = &local_a60;

+      local_60 = 8;

+      local_58 = &local_b58;

+      local_50 = 4;

+      local_c80 = (undefined8 *)local_a8;

+      local_c88 = CONCAT44(local_c88._4_4_,6);

+      local_b58 = uVar7;

+      local_b1c[0] = param_4;

+      local_a60 = param_1;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_1400445d4,0,0);

+    }

+    if ((param_6 >> 0xc & 1) != 0) {

+      *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 0x805040;

+    }

 LAB_11:

-            *(byte *)((longlong)param_3[0x17] + 3) = *(byte *)((longlong)param_3[0x17] + 3) | 1;

-            *(undefined4 *)(param_3 + 6) = 0;

-            ppuVar19 = param_3 + 0x15;

-            plVar20 = puVar12 + 5;

-            puVar16 = (undefined8 *)*plVar20;

-            if ((longlong *)puVar16[1] == plVar20) goto LAB_12;

-            pcVar4 = (code *)swi(0x29);

-            (*pcVar4)(3);

-            puVar18 = puVar18 + 8;

-          }

-          else {

-            plVar20 = (longlong *)(plVar15[2] + 0x30);

-            if ((*(int *)(plVar15[2] + 0x18) == 0x90240) ||

-               (*plVar20 != *(longlong *)(param_2 + 0x30))) {

-              lVar14 = *plVar20;

-              uVar2 = *(undefined8 *)(param_2 + 0x30);

-              *(undefined8 *)(puVar18 + -8) = 0x1404dcd72;

-              cVar7 = FsRtlpOplockKeysEqual(uVar2,lVar14,0);

-              if (cVar7 != '\0') {

-                uVar2 = *(undefined8 *)plVar15[1];

-                *(undefined8 *)(puVar18 + -8) = 0x1404dcd94;

-                FsRtlpRemoveAndCompleteReadOnlyIrp(uVar2,0x215,param_4 & 0x7000,puVar12);

-                goto LAB_11;

-              }

-            }

-          }

-          plVar15 = (longlong *)*plVar15;

-        } while( true );

-      }

-      goto LAB_4;

-    }

-LAB_7:

-    if (param_4 != 0x10000) goto LAB_4;

-    plVar15 = (undefined8 *)0xc0000909;

+    plVar12 = local_c40;

+    if ((param_6 & 0x5000) == 0) goto LAB_8;

+LAB_12:

+    local_c48 = '\x01';

+    plVar12 = local_c40;

   }

   else {

-    *(undefined8 *)(puVar18 + -8) = 0x1404dc675;

-    iVar9 = MmDoesFileHaveUserWritableReferences();

-    if (iVar9 == 0) goto LAB_5;

-    if (param_4 != 0x10000) goto LAB_2;

-    plVar15 = (undefined8 *)0xc00000e2;

+    if ((uVar5 == 0x1000) || (uVar5 == 0x1010)) {

+LAB_14:

+      if (5 < DAT_0) {

+        local_3e8 = &local_bc4;

+        local_3e0 = 4;

+        local_bc0 = param_6;

+        local_3d8 = &local_bc0;

+        local_3d0 = 4;

+        local_3c8 = &local_a98;

+        local_3c0 = 8;

+        local_3b8 = local_bbc;

+        local_3b0 = 4;

+        local_c80 = (undefined8 *)local_408;

+        local_c88 = CONCAT44(local_c88._4_4_,6);

+        local_bc4 = param_4;

+        local_bbc[0] = uVar7;

+        local_a98 = param_1;

+        _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044d1e,0,0);

+      }

+      if ((param_6 & 0x1000) != 0) {

+        for (plVar12 = (longlong *)param_1[5]; local_c28 = plVar12, plVar12 != param_1 + 5;

+            plVar12 = (longlong *)*plVar12) {

+          if ((*(int *)(plVar12[2] + 0x18) == 0x90240) &&

+             ((local_c30[0] != 0 ||

+              (cVar3 = FsRtlpOplockKeysEqual

+                                 (*(undefined8 *)(local_c18 + 0x30),

+                                  *(undefined8 *)(plVar12[2] + 0x30)), cVar3 == '\0')))) {

+            if ((param_4 & 0x10010000) != 0) {

+              if (DAT_0 < 4) {

+                return 0xc0000909;

+              }

+              local_bbc[1] = 0xc0000909;

+              local_888 = local_bbc + 1;

+              local_880 = 4;

+              local_878 = local_bbc + 2;

+              local_870 = 4;

+              local_868 = &local_bb0;

+              local_860 = 4;

+              local_858 = &local_a90;

+              local_850 = 8;

+              local_bac = (undefined4)param_1[0x12];

+              local_848 = &local_bac;

+              local_840 = 4;

+              local_c80 = (undefined8 *)local_8a8;

+              puVar10 = &DAT_15;

+              local_bbc[2] = param_4;

+              local_bb0 = param_6;

+              local_a90 = param_1;

+              goto LAB_5;

+            }

+            plVar12 = (longlong *)plVar12[1];

+            local_c28 = plVar12;

+            FsRtlpRemoveAndCompleteReadOnlyIrp(*plVar12,0);

+          }

+        }

+      }

+      uVar7 = *(uint *)(param_1 + 0x12);

+      if ((uVar7 & 0x1f0ffdf) != 0xb000) {

+        FsRtlpComputeShareableOplockState(param_1);

+        plVar12 = local_c40;

+        goto LAB_8;

+      }

+    }

+    else if (uVar5 != 0x3000) {

+      if (uVar5 == 0x5040) {

+        if (5 < DAT_0) {

+          local_448 = &local_bd0;

+          local_440 = 4;

+          local_bcc = param_6;

+          local_438 = &local_bcc;

+          local_430 = 4;

+          local_428 = &local_aa0;

+          local_420 = 8;

+          local_418 = &local_bc8;

+          local_410 = 4;

+          local_c80 = (undefined8 *)local_468;

+          local_c88 = CONCAT44(local_c88._4_4_,6);

+          local_bd0 = param_4;

+          local_bc8 = uVar7;

+          local_aa0 = param_1;

+          _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044860,0,0);

+        }

+        if ((param_6 & 0x5000) == 0x5000) {

+          lVar1 = *param_1;

+          uVar4 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)(lVar1 + 0x45) = uVar4;

+          LOCK();

+          *(undefined8 *)(lVar1 + 0x68) = 0;

+          UNLOCK();

+          KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+          if (*(char *)(lVar1 + 0x44) != '\0') {

+LAB_16:

+            FsRtlpModifyThreadPriorities(param_1,0,0);

+            FsRtlpClearOwner(param_1,0);

+            *(undefined1 *)(param_1 + 4) = 0;

+            if (*(longlong **)(*param_1 + 0x38) == param_1) {

+              *(undefined8 *)(*param_1 + 0x38) = 0;

+            }

+            *(undefined4 *)(*param_1 + 0x30) = 0xc0000120;

+            IofCompleteRequest(*param_1,1);

+            *param_1 = 0;

+            ObfDereferenceObjectWithTag(param_1[1],0x746c6644);

+            param_1[1] = 0;

+            *(uint *)(param_1 + 0x12) = *(uint *)(param_1 + 0x12) & 0x20 | 1;

+            while (plVar12 = local_c40, (longlong *)param_1[0xb] != param_1 + 0xb) {

+              FsRtlpRemoveAndCompleteWaitingIrp();

+            }

+            goto LAB_8;

+          }

+          local_c00 = *(undefined8 **)(lVar1 + 0x18);

+          *local_c00 = 0;

+          local_c00[1] = 0;

+          local_c00[2] = 0;

+          *(undefined4 *)local_c00 = 0x180001;

+          *(uint *)((longlong)local_c00 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+          *(uint *)((longlong)local_c00 + 0xc) = *(uint *)((longlong)local_c00 + 0xc) | 1;

+          *(undefined8 *)(lVar1 + 0x38) = 0x18;

+          *(undefined4 *)(*param_1 + 0x30) = 0;

+          IofCompleteRequest(*param_1,1);

+          *param_1 = 0;

+          uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x805040;

+        }

+        else {

+          plVar12 = local_c40;

+          if ((param_6 & 0x4000) == 0) goto LAB_8;

+          lVar1 = *param_1;

+          uVar4 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)(lVar1 + 0x45) = uVar4;

+          LOCK();

+          *(undefined8 *)(lVar1 + 0x68) = 0;

+          UNLOCK();

+          KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+          if (*(char *)(lVar1 + 0x44) != '\0') goto LAB_16;

+          local_c00 = *(undefined8 **)(lVar1 + 0x18);

+          *local_c00 = 0;

+          local_c00[1] = 0;

+          local_c00[2] = 0;

+          *(undefined4 *)local_c00 = 0x180001;

+          *(uint *)((longlong)local_c00 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+          *(undefined4 *)(local_c00 + 1) = 1;

+          *(uint *)((longlong)local_c00 + 0xc) = *(uint *)((longlong)local_c00 + 0xc) | 1;

+          *(undefined8 *)(lVar1 + 0x38) = 0x18;

+          *(undefined4 *)(*param_1 + 0x30) = 0;

+          IofCompleteRequest(*param_1,1);

+          *param_1 = 0;

+          uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x105040;

+        }

+      }

+      else {

+        if (uVar5 != 0x7040) {

+          if (uVar5 != 0xb000) {

+            if (uVar5 != 0x103000) goto LAB_13;

+            if (5 < DAT_0) {

+              local_9c8 = &local_bf8;

+              local_9c0 = 4;

+              local_bf4 = param_6;

+              local_9b8 = &local_bf4;

+              local_9b0 = 4;

+              local_9a8 = &local_a70;

+              local_9a0 = 8;

+              local_998 = local_bf0;

+              local_990 = 4;

+              local_c80 = (undefined8 *)local_9e8;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_bf8 = param_4;

+              local_bf0[0] = uVar7;

+              local_a70 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044349,0,0);

+            }

+            bVar2 = false;

+            local_c20 = 0;

+            if ((param_6 & 0x1000) != 0) {

+              bVar2 = false;

+              for (plVar12 = (longlong *)param_1[9]; local_c28 = plVar12, plVar12 != param_1 + 9;

+                  plVar12 = (longlong *)*plVar12) {

+                if ((local_c30[0] != 0) ||

+                   (cVar3 = FsRtlpOplockKeysEqual

+                                      (*(undefined8 *)(local_c18 + 0x30),plVar12[3],param_4),

+                   cVar3 == '\0')) {

+                  bVar2 = true;

+                  local_c20 = 1;

+                  if ((param_4 & 0x10010000) != 0) {

+                    if (DAT_0 < 4) {

+                      return 0xc0000909;

+                    }

+                    local_bf0[1] = 0xc0000909;

+                    local_738 = local_bf0 + 1;

+                    local_730 = 4;

+                    local_728 = local_bf0 + 2;

+                    local_720 = 4;

+                    local_718 = &local_be4;

+                    local_710 = 4;

+                    local_708 = &local_a68;

+                    local_700 = 8;

+                    local_be0 = (undefined4)param_1[0x12];

+                    local_6f8 = &local_be0;

+                    local_6f0 = 4;

+                    local_c80 = (undefined8 *)local_758;

+                    puVar10 = &DAT_17;

+                    local_bf0[2] = param_4;

+                    local_be4 = param_6;

+                    local_a68 = param_1;

+                    goto LAB_5;

+                  }

+                  uVar7 = *(uint *)(plVar12 + 6);

+                  *(uint *)(plVar12 + 6) = uVar7 & 0xff0fffff;

+                  *(uint *)(plVar12 + 6) = uVar7 & 0xff0fffff | 0x800000;

+                }

+              }

+              FsRtlpComputeShareableOplockState(param_1);

+            }

+            plVar12 = local_c40;

+            if ((param_6 >> 0xd & 1) == 0) goto LAB_8;

+            if (!bVar2) {

+              if ((param_6 & 0x1000) == 0) {

+                for (plVar11 = (longlong *)param_1[9]; plVar12 = local_c40, local_c28 = plVar11,

+                    plVar11 != param_1 + 9; plVar11 = (longlong *)*plVar11) {

+                  if (((local_c30[0] != 0) ||

+                      (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),plVar11[3],0)

+                      , cVar3 == '\0')) &&

+                     (((param_4 & 0x40000080) != 0x40000080 ||

+                      (iVar6 = FsRtlpCheckSharingAgainstOplockOwner

+                                         (local_c40,plVar11[3],*param_7,*param_8), iVar6 < 0))))

+                  goto LAB_9;

+                }

+              }

+              goto LAB_8;

+            }

+            goto LAB_12;

+          }

+          goto LAB_14;

+        }

+        if (5 < DAT_0) {

+          local_2c8 = &local_bdc;

+          local_2c0 = 4;

+          local_bd8 = param_6;

+          local_2b8 = &local_bd8;

+          local_2b0 = 4;

+          local_2a8 = &local_a30;

+          local_2a0 = 8;

+          local_298 = &local_bd4;

+          local_290 = 4;

+          local_c80 = (undefined8 *)local_2e8;

+          local_c88 = CONCAT44(local_c88._4_4_,6);

+          local_bdc = param_4;

+          local_bd4 = uVar7;

+          local_a30 = param_1;

+          _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_1400447f6,0,0);

+        }

+        if (param_6 == 0x4000) {

+          lVar1 = *param_1;

+          uVar4 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)(lVar1 + 0x45) = uVar4;

+          LOCK();

+          *(undefined8 *)(lVar1 + 0x68) = 0;

+          UNLOCK();

+          KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+          if (*(char *)(lVar1 + 0x44) != '\0') goto LAB_16;

+          local_c00 = *(undefined8 **)(lVar1 + 0x18);

+          *local_c00 = 0;

+          local_c00[1] = 0;

+          local_c00[2] = 0;

+          *(undefined4 *)local_c00 = 0x180001;

+          *(uint *)((longlong)local_c00 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+          *(undefined4 *)(local_c00 + 1) = 3;

+          *(uint *)((longlong)local_c00 + 0xc) = *(uint *)((longlong)local_c00 + 0xc) | 1;

+          *(undefined8 *)(lVar1 + 0x38) = 0x18;

+          *(undefined4 *)(*param_1 + 0x30) = 0;

+          IofCompleteRequest(*param_1,1);

+          *param_1 = 0;

+          uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x507040;

+        }

+        else if (param_6 == 0x2000) {

+          lVar1 = *param_1;

+          if (((param_4 & 0x40000080) == 0x40000080) &&

+             (iVar6 = FsRtlpCheckSharingAgainstOplockOwner(local_c40,param_1[1],*param_7,*param_8),

+             plVar12 = local_c40, -1 < iVar6)) goto LAB_8;

+          uVar4 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)(lVar1 + 0x45) = uVar4;

+          LOCK();

+          *(undefined8 *)(lVar1 + 0x68) = 0;

+          UNLOCK();

+          KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+          if (*(char *)(lVar1 + 0x44) != '\0') goto LAB_16;

+          local_c00 = *(undefined8 **)(lVar1 + 0x18);

+          *local_c00 = 0;

+          local_c00[1] = 0;

+          local_c00[2] = 0;

+          *(undefined4 *)local_c00 = 0x180001;

+          *(uint *)((longlong)local_c00 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+          *(undefined4 *)(local_c00 + 1) = 5;

+          uVar7 = *(uint *)((longlong)local_c00 + 0xc);

+          *(uint *)((longlong)local_c00 + 0xc) = uVar7 | 1;

+          if (*local_c18 == '\0') {

+            *(uint *)((longlong)local_c00 + 0xc) = uVar7 | 3;

+            *(undefined4 *)(local_c00 + 2) =

+                 *(undefined4 *)(*(longlong *)(*(longlong *)(local_c18 + 8) + 8) + 0x14);

+            *(undefined2 *)((longlong)local_c00 + 0x14) = *(undefined2 *)(local_c18 + 0x1a);

+          }

+          *(undefined8 *)(lVar1 + 0x38) = 0x18;

+          *(undefined4 *)(*param_1 + 0x30) = 0;

+          IofCompleteRequest(*param_1,CONCAT71((int7)((ulonglong)local_c00 >> 8),1));

+          *param_1 = 0;

+          uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x307040;

+        }

+        else {

+          plVar12 = local_c40;

+          if ((param_6 & 0x5000) != 0x5000) goto LAB_8;

+          lVar1 = *param_1;

+          uVar4 = KeAcquireQueuedSpinLock(7);

+          *(undefined1 *)(lVar1 + 0x45) = uVar4;

+          LOCK();

+          *(undefined8 *)(lVar1 + 0x68) = 0;

+          UNLOCK();

+          KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

+          if (*(char *)(lVar1 + 0x44) != '\0') goto LAB_16;

+          local_c00 = *(undefined8 **)(lVar1 + 0x18);

+          *local_c00 = 0;

+          local_c00[1] = 0;

+          local_c00[2] = 0;

+          *(undefined4 *)local_c00 = 0x180001;

+          *(uint *)((longlong)local_c00 + 4) = *(uint *)(param_1 + 0x12) >> 0xc & 7;

+          *(uint *)((longlong)local_c00 + 0xc) = *(uint *)((longlong)local_c00 + 0xc) | 1;

+          *(undefined8 *)(lVar1 + 0x38) = 0x18;

+          *(undefined4 *)(*param_1 + 0x30) = 0;

+          IofCompleteRequest(*param_1,1);

+          *param_1 = 0;

+          uVar7 = *(uint *)(param_1 + 0x12) & 0x20 | 0x807040;

+        }

+      }

+      *(uint *)(param_1 + 0x12) = uVar7;

+      goto LAB_12;

+    }

+    if (5 < DAT_0) {

+      local_388 = &local_ba8;

+      local_380 = 4;

+      local_ba4 = param_6;

+      local_378 = &local_ba4;

+      local_370 = 4;

+      local_368 = &local_ac8;

+      local_360 = 8;

+      local_358 = &local_ba0;

+      local_350 = 4;

+      local_c80 = (undefined8 *)local_3a8;

+      local_c88 = CONCAT44(local_c88._4_4_,6);

+      local_ba8 = param_4;

+      local_ba0 = uVar7;

+      local_ac8 = param_1;

+      _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_1400443b5,0,0);

+    }

+    uVar7 = local_c30[0];

+    if (param_6 == 0x2000) {

+      for (plVar12 = (longlong *)param_1[7]; local_c28 = plVar12, plVar12 != param_1 + 7;

+          plVar12 = (longlong *)*plVar12) {

+        local_ac8 = plVar12;

+        if (((local_c30[0] != 0) ||

+            (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),plVar12[3],0),

+            cVar3 == '\0')) &&

+           (((param_4 & 0x40000080) != 0x40000080 ||

+            (iVar6 = FsRtlpCheckSharingAgainstOplockOwner(local_c40,plVar12[3],*param_7,*param_8),

+            iVar6 < 0)))) {

+          if ((param_4 & 0x10010000) != 0) {

+            if (DAT_0 < 4) {

+              return 0xc0000909;

+            }

+            local_b8c = 0xc0000909;

+            local_6c8 = &local_b8c;

+            local_6c0 = 4;

+            local_6b8 = &local_b88;

+            local_6b0 = 4;

+            local_6a8 = &local_b84;

+            local_6a0 = 4;

+            local_698 = &local_ac0;

+            local_690 = 8;

+            local_b80 = (undefined4)param_1[0x12];

+            local_688 = &local_b80;

+            local_680 = 4;

+            local_c80 = (undefined8 *)local_6e8;

+            puVar10 = &DAT_18;

+            local_b88 = param_4;

+            local_b84 = param_6;

+            local_ac0 = param_1;

+            goto LAB_5;

+          }

+          if (plVar12[7] == 0) {

+            plVar12 = (longlong *)plVar12[1];

+            uVar8 = 1;

+            local_b90 = 1;

+            uVar9 = 0;

+            local_c78 = 0;

+            if (*local_c18 == '\0') {

+              uVar8 = 3;

+              local_b90 = 3;

+              uVar9 = *(undefined4 *)(*(longlong *)(*(longlong *)(local_c18 + 8) + 8) + 0x14);

+              local_c78 = *(undefined2 *)(local_c18 + 0x1a);

+            }

+            local_c70 = local_c70 & 0xffffffffffffff00;

+            local_c80 = (undefined8 *)CONCAT44(local_c80._4_4_,uVar9);

+            local_c88 = CONCAT44(local_c88._4_4_,uVar8);

+            local_c28 = plVar12;

+            cVar3 = FsRtlpRemoveAndCompleteRHIrp(*plVar12,param_1,0,0x1000);

+            if (cVar3 == '\0') {

+              local_c38 = '\x01';

+            }

+            else {

+              local_c37 = '\0';

+              local_c48 = '\x01';

+              local_c36 = local_c30[0] != 0;

+              FsRtlpOplockTryStartBreakAckTimeout(local_ac8 + 9,local_ac8[0xb]);

+            }

+          }

+          else {

+            if (5 < DAT_0) {

+              local_328 = &local_b9c;

+              local_320 = 4;

+              local_b98 = param_6;

+              local_318 = &local_b98;

+              local_310 = 4;

+              local_308 = &local_a80;

+              local_300 = 8;

+              local_b94 = (undefined4)param_1[0x12];

+              local_2f8 = &local_b94;

+              local_2f0 = 4;

+              local_c80 = (undefined8 *)local_348;

+              local_c88 = CONCAT44(local_c88._4_4_,6);

+              local_b9c = param_4;

+              local_a80 = param_1;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044489,0,0);

+            }

+            local_c48 = '\x01';

+            FsRtlpOplockTryStartBreakAckTimeout(plVar12 + 9,plVar12[0xb]);

+          }

+        }

+      }

+    }

+    else if ((param_6 & 0x5000) == 0x5000) {

+      for (plVar12 = (longlong *)param_1[9]; plVar12 != param_1 + 9; plVar12 = (longlong *)*plVar12)

+      {

+        local_c28 = plVar12;

+        if ((uVar7 != 0) ||

+           (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),plVar12[3]),

+           cVar3 == '\0')) {

+          if ((param_4 & 0x10010000) != 0) {

+            if (DAT_0 < 4) {

+              return 0xc0000909;

+            }

+            local_b7c = 0xc0000909;

+            local_658 = &local_b7c;

+            local_650 = 4;

+            local_648 = &local_b78;

+            local_640 = 4;

+            local_638 = &local_b74;

+            local_630 = 4;

+            local_628 = &local_ab8;

+            local_620 = 8;

+            local_b70 = (undefined4)param_1[0x12];

+            local_618 = &local_b70;

+            local_610 = 4;

+            local_c80 = (undefined8 *)local_678;

+            puVar10 = &DAT_19;

+            local_b78 = param_4;

+            local_b74 = param_6;

+            local_ab8 = param_1;

+            goto LAB_5;

+          }

+          uVar5 = *(uint *)(plVar12 + 6);

+          *(uint *)(plVar12 + 6) = uVar5 & 0xff0fffff;

+          *(uint *)(plVar12 + 6) = uVar5 & 0xff0fffff | 0x800000;

+          if ((param_6 >> 0xd & 1) != 0) {

+            local_c48 = '\x01';

+          }

+        }

+      }

+      for (plVar12 = (longlong *)param_1[7]; local_c28 = plVar12, plVar12 != param_1 + 7;

+          plVar12 = (longlong *)*plVar12) {

+        if ((uVar7 != 0) ||

+           (cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(local_c18 + 0x30),plVar12[3],param_4),

+           cVar3 == '\0')) {

+          if ((param_4 & 0x10010000) != 0) {

+            if (DAT_0 < 4) {

+              return 0xc0000909;

+            }

+            local_b6c = 0xc0000909;

+            local_5e8 = &local_b6c;

+            local_5e0 = 4;

+            local_5d8 = &local_b68;

+            local_5d0 = 4;

+            local_5c8 = &local_b64;

+            local_5c0 = 4;

+            local_5b8 = &local_ab0;

+            local_5b0 = 8;

+            local_b60 = (undefined4)param_1[0x12];

+            local_5a8 = &local_b60;

+            local_5a0 = 4;

+            local_c80 = (undefined8 *)local_608;

+            puVar10 = &DAT_20;

+            local_b68 = param_4;

+            local_b64 = param_6;

+            local_ab0 = param_1;

+            goto LAB_5;

+          }

+          if (plVar12[7] == 0) {

+            plVar11 = (longlong *)plVar12[1];

+            local_c70 = local_c70 & 0xffffffffffffff00;

+            local_c78 = 0;

+            local_c80 = (undefined8 *)((ulonglong)local_c80 & 0xffffffff00000000);

+            local_c88 = CONCAT44(local_c88._4_4_,1);

+            local_c28 = plVar11;

+            cVar3 = FsRtlpRemoveAndCompleteRHIrp(*plVar11,param_1,0,0);

+            if (cVar3 == '\0') {

+              local_c38 = '\x01';

+              plVar12 = plVar11;

+            }

+            else {

+              local_c37 = '\0';

+              if ((param_6 >> 0xd & 1) != 0) {

+                local_c48 = '\x01';

+                FsRtlpOplockTryStartBreakAckTimeout(plVar12 + 9,plVar12[0xb]);

+              }

+              local_c36 = uVar7 != 0;

+              plVar12 = plVar11;

+            }

+          }

+          else if ((param_6 >> 0xd & 1) != 0) {

+            local_c48 = '\x01';

+            FsRtlpOplockTryStartBreakAckTimeout(plVar12 + 9,plVar12[0xb]);

+          }

+        }

+      }

+    }

+    if (local_c38 != '\0') {

+      FsRtlpReleaseIrpsWaitingForRH(param_1);

+    }

+    if (((local_c48 == '\0') && (plVar12 = (longlong *)param_1[9], plVar12 != param_1 + 9)) &&

+       ((param_6 >> 0xd & 1) != 0)) {

+      if (local_c30[0] == 0) {

+        for (; local_c28 = plVar12, plVar12 != param_1 + 9; plVar12 = (longlong *)*plVar12) {

+          cVar3 = FsRtlpOplockKeysEqual(plVar12[3],*(undefined8 *)(local_c18 + 0x30),0);

+          if (cVar3 == '\0') goto LAB_21;

+        }

+      }

+      else {

+LAB_21:

+        local_c48 = '\x01';

+      }

+    }

+    FsRtlpComputeShareableOplockState(param_1);

+    plVar12 = local_c40;

   }

-  goto LAB_8;

-LAB_12:

-  *ppuVar19 = puVar16;

-  param_3[0x16] = plVar20;

-  puVar16[1] = ppuVar19;

-  *plVar20 = (longlong)ppuVar19;

-  param_3[7] = puVar12;

-  *(undefined8 *)(puVar18 + -8) = 0x1404dcde1;

-  FsRtlpComputeShareableOplockState(puVar12);

-  if (puVar18[0x1d8] != '\0') {

-    uVar2 = *(undefined8 *)(param_2 + 0x30);

-    *(undefined8 *)(puVar18 + -8) = 0x1404dcdf9;

-    ObfReferenceObjectWithTag(uVar2,0x746c6644);

+LAB_8:

+  if (local_c48 == '\0') {

+    return local_c34;

   }

-  *(undefined8 *)(puVar18 + -8) = 0x1404dce03;

-  uVar8 = KeAcquireQueuedSpinLock(7);

-  *(undefined1 *)((longlong)param_3 + 0x45) = uVar8;

-  if (*(char *)((longlong)param_3 + 0x44) == '\0') {

-    LOCK();

-    param_3[0xd] = (undefined8 *)FsRtlpReadOnlyOplockIrpCancelRoutine;

-    UNLOCK();

-    uVar8 = *(undefined1 *)((longlong)param_3 + 0x45);

-    *(undefined8 *)(puVar18 + -8) = 0x1404dce31;

-    KeReleaseQueuedSpinLock(7,uVar8);

+  uVar7 = *(uint *)(param_1 + 0x12);

+  if ((param_4 & 1) == 0) {

+    if ((uVar7 & 0x40) != 0) {

+      FsRtlpOplockTryStartBreakAckTimeout(param_1 + 0x14,param_1[0x16]);

+    }

+    if (local_c37 != '\0') {

+      FsRtlpModifyThreadPriorities(param_1,0,1);

+      FsRtlpOplockSendModernAppTermination(param_1,0);

+    }

+    *(undefined1 *)local_aa8 = 0;

+    local_c58 = local_ab0;

+    local_c60 = param_14;

+    local_c68 = local_ab8;

+    local_c70 = param_12;

+    local_c78 = CONCAT11(local_c78._1_1_,local_c36);

+    local_c80 = &local_a08;

+    local_c88 = param_11;

+    uVar9 = FsRtlpWaitOnIrp(param_1,plVar12,local_ac0,param_10);

+    return uVar9;

   }

-  else {

-    *(undefined8 *)(puVar18 + -8) = 0x1404dce16;

-    FsRtlpCancelReadOnlyOplockIrp(param_3,1);

+  if ((uVar7 >> 0x10 & 1) != 0) {

+    *(uint *)(param_1 + 0x12) = uVar7 | 0x20000;

   }

-  bVar5 = true;

-  plVar15 = (undefined8 *)0x103;

-  *(undefined4 *)(puVar18 + 0x40) = 0x103;

-LAB_6:

-  if (bVar5) goto LAB_9;

-LAB_4:

-  plVar15 = (undefined8 *)0xc00000e2;

-  *(undefined4 *)(param_3 + 6) = 0xc00000e2;

-  *(undefined8 *)(puVar18 + -8) = 0x1404dce54;

-  IofCompleteRequest(param_3,1);

-LAB_8:

-  *(int *)(puVar18 + 0x40) = (int)plVar15;

-LAB_9:

-  if ((puVar18[0x44] != '\0') && (param_4 != 0x10000)) {

-    *(undefined8 *)(puVar18 + -8) = 0x1404dce72;

-    ExReleaseFastMutexUnsafe(*(undefined8 *)(puVar18 + 0x70));

-  }

-  *(undefined8 *)(puVar18 + -8) = 0x1404dce84;

-  return (ulonglong)plVar15 & 0xffffffff;

+  return 0x108;

 }
```

## `PopAdaptiveStandbyUpdateRegions`  (modified)

```diff
--- PopAdaptiveStandbyUpdateRegions
+++ PopAdaptiveStandbyPowerSettingCallback
@@ -1,28 +1,78 @@
 

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Type propagation algorithm not settling */

 

-void PopAdaptiveStandbyUpdateRegions(longlong param_1)

+undefined4

+PopAdaptiveStandbyPowerSettingCallback

+          (longlong *param_1,void *param_2,uint param_3,longlong *param_4)

 

 {

   int iVar1;

+  undefined4 uVar2;

+  undefined1 auStack_d8 [32];

+  undefined4 local_b8;

+  undefined1 *local_b0;

+  longlong local_a8;

+  undefined8 local_a0;

+  undefined8 uStack_98;

+  undefined8 local_90;

+  undefined1 local_88 [32];

+  longlong *local_68;

+  undefined4 local_60;

+  undefined4 local_5c;

+  undefined4 *local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  void *local_48;

+  uint local_40;

+  undefined4 local_3c;

+  ulonglong local_38;

   

-  iVar1 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

-  if (iVar1 == 6) {

-    DAT_0 = *(undefined4 *)(param_1 + 8);

-    _DAT_1 = *(undefined4 *)(param_1 + 4);

-    DAT_2 = *(undefined4 *)(param_1 + 0xc);

-    DAT_3 = *(undefined4 *)(param_1 + 0x10);

+  local_38 = __security_cookie ^ (ulonglong)auStack_d8;

+  local_90 = 0;

+  local_a0 = 0;

+  uStack_98 = 0;

+  EtwActivityIdControl(3,&local_a0);

+  local_90 = IoSetActivityIdThread(&local_a0);

+  if (5 < DAT_0) {

+    local_5c = 0;

+    local_58 = (undefined4 *)&local_a8;

+    local_4c = 0;

+    local_3c = 0;

+    local_40 = param_3 & 0xffff;

+    local_a8._0_4_ = CONCAT22(local_a8._2_2_,(short)param_3);

+    local_b0 = local_88;

+    local_60 = 0x10;

+    local_50 = 2;

+    local_b8 = 5;

+    local_68 = param_1;

+    local_48 = param_2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e181,&local_a0,local_90);

   }

-  else if (iVar1 == 9) {

-    _DAT_4 = *(undefined4 *)(param_1 + 8);

-    _DAT_5 = *(undefined4 *)(param_1 + 4);

-    _DAT_6 = *(undefined4 *)(param_1 + 0xc);

-    _DAT_7 = *(uint *)(param_1 + 0x10) >> 1;

-    _DAT_8 = *(undefined4 *)(param_1 + 8);

-    _DAT_9 = *(undefined4 *)(param_1 + 4);

-    _DAT_10 = *(undefined4 *)(param_1 + 0xc);

-    _DAT_11 = *(undefined4 *)(param_1 + 0x10);

+  PopAcquireRwLockExclusive(&PopAdaptiveStandbyLock);

+  if (((*param_1 == *(longlong *)*param_4) && (param_1[1] == ((longlong *)*param_4)[1])) &&

+     (param_3 == *(uint *)((longlong)param_4 + 0xc))) {

+    RtlCopyMemory(&PopAdaptiveStandbyContext + *(uint *)(param_4 + 1),param_2,(ulonglong)param_3);

+    uVar2 = 0;

+    iVar1 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+    if (iVar1 != 0) {

+      PopAdaptiveStandbyUpdateRegions(&DAT_1);

+    }

   }

-  return;

+  else {

+    uVar2 = 0xc000000d;

+  }

+  PopReleaseRwLock(&PopAdaptiveStandbyLock);

+  if (5 < DAT_0) {

+    local_5c = 0;

+    local_68 = &local_a8;

+    local_b0 = local_88;

+    local_b8 = 3;

+    local_60 = 4;

+    local_a8._0_4_ = uVar2;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e1ba,&local_a0,local_90);

+  }

+  IoClearActivityIdThread(local_90);

+  return uVar2;

 }
```

## `MiTransformValidPteViaIpi`  (modified)

```diff
--- MiTransformValidPteViaIpi
+++ MiTransformValidPteViaIpi
@@ -1,190 +1,23 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-

-undefined8 MiTransformValidPteViaIpi(longlong param_1,longlong param_2)

+void MiTransformValidPteViaIpi(ulonglong *param_1,undefined8 param_2,ulonglong param_3)

 

 {

-  ulonglong uVar1;

-  int iVar2;

-  byte bVar3;

-  int iVar4;

-  byte *in_RAX;

-  longlong lVar5;

-  undefined8 *puVar6;

-  ulonglong uVar7;

-  ulonglong *puVar8;

-  undefined8 uVar9;

-  ulonglong uVar10;

-  longlong lVar11;

-  ulonglong *puVar12;

-  longlong unaff_RBP;

-  ulonglong unaff_RSI;

-  uint uVar13;

-  int unaff_R12D;

-  ulonglong unaff_R13;

-  ulonglong uVar14;

-  longlong unaff_R15;

-  undefined1 in_stack_00000030;

-  int iStack0000000000000034;

-  int in_stack_00000038;

-  longlong in_stack_00000040;

-  ulonglong in_stack_00000048;

-  longlong in_stack_00000050;

-  longlong in_stack_00000068;

+  int iVar1;

   

-  bVar3 = (byte)in_RAX;

-  *in_RAX = *in_RAX + bVar3;

-  *(char *)(param_1 + -0x43) = *(char *)(param_1 + -0x43) + bVar3;

-  *in_RAX = *in_RAX + bVar3;

-  *in_RAX = *in_RAX & bVar3;

-  if (unaff_R12D != (int)unaff_R15) {

-    uVar10 = (ulonglong)(unaff_R12D - 1);

-    do {

-      unaff_RSI = (unaff_RSI >> 9 & 0x7ffffffff8) + param_2;

-      unaff_R13 = unaff_R13 << 9;

-      unaff_R15 = unaff_R15 << 9;

-      uVar10 = uVar10 - 1;

-    } while (uVar10 != 0);

-  }

-  uVar10 = MI_READ_PTE_LOCK_FREE(unaff_RSI);

-  lVar11 = 4;

-  uVar14 = uVar10 >> 0xc & 0xffffffffff;

-  lVar5 = unaff_RBP + -0x50;

-  do {

-    *(undefined8 *)(lVar5 + 0x10) = 0;

-    *(longlong *)(lVar5 + 8) = lVar5;

-    *(longlong *)lVar5 = lVar5;

-    lVar5 = lVar5 + 0x18;

-    lVar11 = lVar11 + -1;

-  } while (lVar11 != 0);

-  *(undefined2 **)(unaff_RBP + 0x10) = &MiSystemPartition;

-  iStack0000000000000034 = 3;

-  *(undefined4 *)(unaff_RBP + 0x28) = 3;

-  in_stack_00000048 = uVar10;

-  MiPageToNode(uVar14);

-  MiInitializeColorBase();

-  iVar4 = MiGetPageTablePages(unaff_RBP + -0x50,1,2,unaff_RBP + -0x68);

-  if (iVar4 < 0) {

-    uVar9 = 0;

+  if ((((MiFlags >> 0x27 & 1) == 0) || (KeNumberProcessors <= *(uint *)((longlong)FiberData + 0x24))

+      ) || ((MiFlags >> 0x28 & 1) != 0)) {

+    LOCK();

+    *param_1 = param_3 | 0x20;

+    UNLOCK();

+    iVar1 = MiPteInShadowRange();

+    if (iVar1 != 0) {

+      MiWritePteShadow(param_1,param_3 | 0x20);

+    }

+    MI_FLUSH_ENTIRE_TB(2);

   }

   else {

-    puVar6 = (undefined8 *)MiUnlinkPageChainHead(unaff_RBP + -0x68);

-    *(undefined8 **)(unaff_RBP + -0x80) = puVar6;

-    *puVar6 = 0;

-    in_stack_00000050 = ((longlong)(puVar6 + 0x44000000000) >> 4) * -0x5555555555555555;

-    uVar7 = MI_READ_PTE_LOCK_FREE((unaff_RSI >> 9 & 0x7ffffffff8) - 0x98000000000);

-    uVar13 = 0x84000004;

-    if (unaff_R12D == 1) {

-      uVar13 = 0x80000004;

-    }

-    if (((uVar10 >> 8 & 1) != 0) && (unaff_R12D == 1)) {

-      uVar13 = uVar13 | 0x20000000;

-    }

-    *(ulonglong *)(unaff_RBP + -0x70) = unaff_RSI * 0x2000000;

-    uVar10 = MiMakeValidPte((longlong)(unaff_RSI * 0x2000000) >> 0x10,uVar14,uVar13);

-    if ((DAT_0 & (byte)(1 << ((char)unaff_R12D - 1U & 0x1f))) != 0) {

-      uVar10 = uVar10 & 0xffffffffffffffdf;

-    }

-    puVar8 = (ulonglong *)MiMapPageInHyperSpaceWorker(in_stack_00000050,&stack0x00000030,0x80000000)

-    ;

-    puVar12 = puVar8;

-    do {

-      if ((((MiFlags >> 0x24 & 1) != 0) && ((uVar10 & 0x20) == 0)) &&

-         ((ulonglong *)0xfffff6bfffffffff < puVar12)) {

-        MiCheckLinearProtectedPteAccessedBit(puVar12,uVar10,0x80);

-      }

-      *puVar12 = uVar10;

-      uVar1 = uVar10 + unaff_R15 * 0x1000;

-      puVar12 = puVar12 + 1;

-      uVar10 = (uVar10 ^ uVar1) & 0xfff0000000000fff ^ uVar1;

-    } while (((ulonglong)puVar12 & 0xfff) != 0);

-    MiUnmapPageInHyperSpaceWorker(puVar8,in_stack_00000030,0x80000000);

-    uVar10 = MiMakeValidPte(unaff_RSI,uVar14,

-                            (uint)(in_stack_00000048 << 0x15) & 0x20000000 | 0x88000004);

-    lVar11 = in_stack_00000050;

-    MiInitializePfnForOtherProcess(in_stack_00000050,unaff_RSI,uVar7 >> 0xc & 0xffffffffff,0xa00);

-    in_stack_00000048 = in_stack_00000048 & 0xffffffff00000000;

-    lVar5 = *(longlong *)(unaff_RBP + -0x80);

-    while( true ) {

-      LOCK();

-      puVar12 = (ulonglong *)(lVar5 + 0x18);

-      uVar7 = *puVar12;

-      *puVar12 = *puVar12 | 0x8000000000000000;

-      UNLOCK();

-      if (-1 < (longlong)uVar7) break;

-      do {

-        KeYieldProcessorEx(&stack0x00000048);

-      } while (*(longlong *)(lVar5 + 0x18) < 0);

-    }

-    uVar7 = *(ulonglong *)(lVar5 + 0x18) + 0x200;

-    in_stack_00000040 = 0x200;

-    *(ulonglong *)(lVar5 + 0x18) =

-         (uVar7 ^ *(ulonglong *)(lVar5 + 0x18)) & 0xc000000000000000 ^ uVar7;

-    MiInitializeUsedPtesCount(lVar5,0x200);

-    iVar4 = in_stack_00000038;

-    LOCK();

-    *(ulonglong *)(lVar5 + 0x18) = *(ulonglong *)(lVar5 + 0x18) & 0x7fffffffffffffff;

-    UNLOCK();

-    MiTransformValidPteInPlace

-              (unaff_RSI,unaff_RSI,(lVar11 << 0xc ^ uVar10) & 0xfff0000000000fff ^ lVar11 << 0xc,

-               0x60,in_stack_00000038);

-    if (iVar4 == 3) {

-      uVar9 = MiVaToFlushVm(*(undefined8 *)(unaff_RBP + -0x78));

-      in_stack_00000068 = MiGetProcessorFlushList();

-      MiInitializeTbFlushList(in_stack_00000068,uVar9,*(undefined4 *)(in_stack_00000068 + 0xc),8,1);

-      MiInsertLargeTbFlushEntry();

-    }

-    lVar5 = uVar14 * 0x30 + -0x220000000000;

-    if ((*(ulonglong *)(uVar14 * 0x30 + -0x21ffffffffd8) >> 0x28 & 1) != 0) {

-      iStack0000000000000034 = MiGetPfnPageSizeIndex(lVar5);

-      iStack0000000000000034 = iStack0000000000000034 + 1;

-    }

-    iVar2 = in_stack_00000038;

-    iVar4 = iStack0000000000000034;

-    lVar11 = unaff_R15 * 0x6000 + lVar5;

-    uVar10 = *(longlong *)(unaff_RBP + -0x70) + 0x10000000 >> 0x10;

-    puVar12 = (ulonglong *)(lVar11 + 0x18);

-    do {

-      lVar11 = lVar11 + unaff_R15 * -0x30;

-      puVar12 = puVar12 + unaff_R15 * -6;

-      uVar10 = uVar10 - 8;

-      iStack0000000000000034 = 0;

-      while( true ) {

-        LOCK();

-        uVar7 = *puVar12;

-        *puVar12 = *puVar12 | 0x8000000000000000;

-        UNLOCK();

-        if (-1 < (longlong)uVar7) break;

-        do {

-          KeYieldProcessorEx(&stack0x00000034);

-        } while ((longlong)*puVar12 < 0);

-      }

-      if ((*(byte *)((longlong)puVar12 + 0xb) & 0x10) == 0) {

-        if ((puVar12[2] >> 0x28 & 1) != 0) {

-          if (iVar2 == 1) {

-            MiConvertLargePfnToSmall(lVar5,lVar11,0);

-          }

-          else {

-            MiUpdateDemotedSubPage(lVar5,lVar11,iVar4);

-          }

-        }

-        puVar12[-2] = uVar10;

-        MiSetPfnContainingFrame(lVar11,in_stack_00000050);

-      }

-      LOCK();

-      *puVar12 = *puVar12 & 0x7fffffffffffffff;

-      UNLOCK();

-      in_stack_00000040 = in_stack_00000040 + -1;

-    } while (in_stack_00000040 != 0);

-    if (iVar2 == 1) {

-      MiUpdateLargePageBitMap(&MiSystemPartition,uVar14,unaff_R13 >> 0xc,6);

-    }

-    if (in_stack_00000068 != 0) {

-      MiFlushTbList(in_stack_00000068);

-      MiReleaseProcessorFlushList();

-    }

-    uVar9 = 1;

+    MiWritePteHighLevel(param_1,param_2,param_3);

   }

-  return uVar9;

+  return;

 }
```

## `PopInitPlatformSettings`  (modified)

```diff
--- PopInitPlatformSettings
+++ PopInitPlatformSettings
@@ -1,11 +1,105 @@
 

-void PopInitPlatformSettings(void)

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+

+int PopInitPlatformSettings(void)

 

 {

-  code *pcVar1;

+  char cVar1;

+  int iVar2;

+  undefined4 *puVar3;

+  bool bVar4;

+  undefined1 auStack_68 [32];

+  undefined8 local_48;

+  int local_38 [2];

+  undefined4 local_30;

+  undefined4 local_2c;

+  undefined4 local_28;

+  undefined4 local_24;

+  undefined4 local_20;

+  ulonglong local_18;

   

-  pcVar1 = (code *)swi(1);

-  (*pcVar1)();

-  return;

+  local_18 = __security_cookie ^ (ulonglong)auStack_68;

+  local_20 = 0;

+  PopAcquirePolicyLock();

+  puVar3 = (undefined4 *)0x0;

+  local_30 = 0x41435049;

+  local_24 = 0;

+  local_38[0] = 0;

+  bVar4 = false;

+  local_28 = 0x50434146;

+  local_2c = 1;

+  iVar2 = ZwQuerySystemInformation(0x4c,&local_30,0x14,local_38);

+  if (iVar2 != -0x3fffffdd) {

+LAB_0:

+    PopReleasePolicyLock();

+    if (iVar2 < 0) {

+LAB_1:

+      local_48 = 0;

+                    /* WARNING: Subroutine does not return */

+      KeBugCheckEx(0xa0,0xe,(longlong)iVar2);

+    }

+    goto LAB_2;

+  }

+  puVar3 = (undefined4 *)ExAllocatePool2(0x100,local_38[0],0x206d654d);

+  if (puVar3 == (undefined4 *)0x0) {

+    iVar2 = -0x3fffff66;

+    PopReleasePolicyLock();

+    goto LAB_1;

+  }

+  *puVar3 = 0x41435049;

+  puVar3[1] = 1;

+  puVar3[2] = 0x50434146;

+  puVar3[3] = local_38[0] + -0x10;

+  iVar2 = ZwQuerySystemInformation(0x4c,puVar3,local_38[0],local_38);

+  if (iVar2 < 0) goto LAB_0;

+  if (2 < *(byte *)(puVar3 + 6)) {

+    PopFirmwarePlatformRole = (uint)*(byte *)((longlong)puVar3 + 0x3d);

+  }

+  cVar1 = (*(code *)PTR_xHalQueryWakeTime_140e00aa0)();

+  if (cVar1 != '\0') {

+    PopPlatformAoAc = '\x01';

+  }

+  if (PopPlatformRoleOverride != 0xffffffff) {

+    PopFirmwarePlatformRole = PopPlatformRoleOverride;

+  }

+  if (PopPlatformAoAcOverride != -1) {

+    PopPlatformAoAc = PopPlatformAoAcOverride != 0;

+  }

+  if ((HvlpFlags & 2) != 0) {

+    iVar2 = (-(uint)((HvlpEnlightenments & 0x10000) != 0) & 0xfffffff1) + 0x1f;

+    if (((HvlpRootFlags & 0x400) != 0) && (iVar2 = 0x1f, (HvlEnlightenments & 0x20000000) != 0)) {

+      iVar2 = 0x17;

+    }

+    PopLogSleepDisabled(0x12,iVar2,0);

+  }

+  if (PopPlatformAoAc == '\0') {

+    PopLogSleepDisabled(0x13,0x20,0);

+LAB_3:

+    PopPlatformAoAc = '\0';

+  }

+  else if (((InitSafeBootMode != 0) || (InitIsWinPEMode != '\0')) || (PopModernStandbyDisabled != 0)

+          ) goto LAB_3;

+  PopPlatformAoAcCapabilityInitialized = 1;

+  if (PopPlatformAoAc == '\0') {

+    KiForceIdleDisabled = 1;

+  }

+  if (8 < PopFirmwarePlatformRole) {

+    PopFirmwarePlatformRole = 0;

+  }

+  bVar4 = DAT_4 != (code *)0x0;

+  iVar2 = 0;

+  _PopPlatformRole = PopFirmwarePlatformRole;

+  PopReleasePolicyLock();

+LAB_2:

+  if (bVar4) {

+    (*DAT_4)(PopPlatformAoAc);

+  }

+  PopAdaptiveStandbyInitialize();

+  if (puVar3 != (undefined4 *)0x0) {

+    ExFreePoolWithTag(puVar3,0x206d654d);

+  }

+  return iVar2;

 }
```

## `PopAdaptiveStandbySessionStop`  (modified)

```diff
--- PopAdaptiveStandbySessionStop
+++ PopAdaptiveStandbySessionStop
@@ -1,25 +1,177 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

 

-undefined1 PopAdaptiveStandbySessionStop(char param_1,undefined8 param_2,longlong param_3)

+void PopAdaptiveStandbySessionStop(char *param_1,undefined4 param_2)

 

 {

-  char *in_RAX;

-  undefined8 uVar1;

-  undefined1 unaff_BL;

-  longlong unaff_RBP;

+  ulonglong uVar1;

+  char cVar2;

+  int iVar3;

+  undefined8 uVar4;

+  undefined *puVar5;

+  undefined1 auStack_f8 [32];

+  undefined4 local_d8;

+  undefined1 *local_d0;

+  undefined4 local_c8 [2];

+  longlong local_c0;

+  longlong local_b8;

+  ulonglong local_b0;

+  ulonglong local_a8 [2];

+  undefined1 local_98 [32];

+  ulonglong *local_78;

+  undefined8 local_70;

+  undefined4 *local_68;

+  undefined8 local_60;

+  longlong *local_58;

+  undefined8 local_50;

+  longlong *local_48;

+  undefined8 local_40;

+  ulonglong *local_38;

+  undefined8 local_30;

+  ulonglong local_28;

   

-  in_RAX[-0x39] = in_RAX[-0x39] + param_1;

-  in_RAX[param_3] = in_RAX[param_3] - (char)param_3;

-  *in_RAX = *in_RAX + (char)in_RAX;

-  *(undefined8 *)(unaff_RBP + 0x38) = 8;

-  *(undefined8 *)(unaff_RBP + 0x48) = 4;

-  *(undefined8 *)(unaff_RBP + 0x58) = 4;

-  *(undefined8 *)(unaff_RBP + 0x68) = 4;

-  *(undefined8 *)(unaff_RBP + -0x80) = 0x1000000;

-  *(undefined8 *)(unaff_RBP + 0x78) = 8;

-  uVar1 = IoGetActivityIdThread();

-  _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e76f,uVar1,0,0xe);

-  return unaff_BL;

+  uVar1 = _DAT_0;

+  local_28 = __security_cookie ^ (ulonglong)auStack_f8;

+  param_1[200] = '\0';

+  param_1[0xc9] = '\0';

+  param_1[0xca] = '\0';

+  param_1[0xcb] = '\0';

+  param_1[0xcc] = '\0';

+  param_1[0xcd] = '\0';

+  param_1[0xce] = '\0';

+  param_1[0xcf] = '\0';

+  param_1[0xd0] = '\0';

+  param_1[0xd1] = '\0';

+  param_1[0xd2] = '\0';

+  param_1[0xd3] = '\0';

+  param_1[0xd4] = '\0';

+  param_1[0xd5] = '\0';

+  param_1[0xd6] = '\0';

+  param_1[0xd7] = '\0';

+  param_1[0xb0] = '\0';

+  param_1[0xb1] = '\0';

+  param_1[0xb2] = '\0';

+  param_1[0xb3] = '\0';

+  param_1[0xb4] = '\0';

+  param_1[0xb5] = '\0';

+  param_1[0xb6] = '\0';

+  param_1[0xb7] = '\0';

+  param_1[0xb8] = '\0';

+  param_1[0xb9] = '\0';

+  param_1[0xba] = '\0';

+  param_1[0xbb] = '\0';

+  param_1[0xbc] = '\0';

+  param_1[0xbd] = '\0';

+  param_1[0xbe] = '\0';

+  param_1[0xbf] = '\0';

+  param_1[0xc0] = '\0';

+  param_1[0xc1] = '\0';

+  param_1[0xc2] = '\0';

+  param_1[0xc3] = '\0';

+  param_1[0x38] = '\0';

+  param_1[4] = '\0';

+  param_1[0x28] = '\0';

+  param_1[0x68] = '\0';

+  param_1[0x69] = '\0';

+  param_1[0x6a] = '\0';

+  param_1[0x6b] = '\0';

+  param_1[0x6c] = '\0';

+  param_1[0x6d] = '\0';

+  param_1[0x6e] = '\0';

+  param_1[0x6f] = '\0';

+  param_1[0x70] = '\0';

+  param_1[0x71] = '\0';

+  param_1[0x72] = '\0';

+  param_1[0x73] = '\0';

+  param_1[0x74] = '\0';

+  param_1[0x75] = '\0';

+  param_1[0x76] = '\0';

+  param_1[0x77] = '\0';

+  param_1[0x224] = '\0';

+  param_1[0x225] = '\0';

+  param_1[0x226] = '\0';

+  param_1[0x227] = '\0';

+  param_1[0xec] = '\0';

+  param_1[0xed] = '\0';

+  param_1[0xee] = '\0';

+  param_1[0xef] = '\0';

+  iVar3 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  local_c8[0] = param_2;

+  if (iVar3 == 0) {

+    if (DAT_1 < 6) {

+      return;

+    }

+    cVar2 = _tlgKeywordOn(&DAT_1,0x400000000000);

+    if (cVar2 == '\0') {

+      return;

+    }

+    local_78 = &local_b0;

+    local_68 = local_c8;

+    local_b8 = *(longlong *)(param_1 + 0xf0);

+    local_58 = &local_b8;

+    local_48 = &local_c0;

+    local_70 = 8;

+    local_60 = 4;

+    local_50 = 8;

+    local_c0 = 0x1000000;

+    local_40 = 8;

+    local_b0 = uVar1 / 10000000;

+    uVar4 = IoGetActivityIdThread();

+    puVar5 = &DAT_2;

+    local_d8 = 6;

+  }

+  else {

+    param_1[0xd8] = '\x03';

+    param_1[0xd9] = '\0';

+    param_1[0xda] = '\0';

+    param_1[0xdb] = '\0';

+    param_1[0xe8] = '\0';

+    param_1[0xe9] = '\0';

+    param_1[0xea] = '\0';

+    param_1[0xeb] = '\0';

+    param_1[0xe0] = '\0';

+    param_1[0xe1] = '\0';

+    param_1[0xe2] = '\0';

+    param_1[0xe3] = '\0';

+    param_1[0xe4] = '\0';

+    param_1[0xe5] = '\0';

+    param_1[0xe6] = '\0';

+    param_1[0xe7] = '\0';

+    if (*param_1 != '\0') {

+      param_1[0x144] = '\0';

+      KeCancelTimer2(param_1 + 0x150,0);

+    }

+    if (DAT_1 < 6) {

+      return;

+    }

+    cVar2 = _tlgKeywordOn(&DAT_1,0x400000000000);

+    if (cVar2 == '\0') {

+      return;

+    }

+    local_c0 = *(longlong *)(param_1 + 0xf0);

+    local_78 = local_a8;

+    local_68 = local_c8;

+    local_58 = &local_c0;

+    local_48 = &local_b8;

+    local_b8 = local_c0 + -1;

+    if (*(int *)(param_1 + 0xf8) != 2) {

+      local_b8 = local_c0;

+    }

+    local_38 = &local_b0;

+    local_70 = 8;

+    local_60 = 4;

+    local_50 = 8;

+    local_40 = 8;

+    local_b0 = 0x1000000;

+    local_30 = 8;

+    local_a8[0] = uVar1 / 10000000;

+    uVar4 = IoGetActivityIdThread();

+    puVar5 = &DAT_3;

+    local_d8 = 7;

+  }

+  local_d0 = local_98;

+  _tlgWriteTransfer_EtwWriteTransfer(&DAT_1,puVar5,uVar4,0);

+  return;

 }
```

## `PopAdaptiveStandbyCalculateBatteryRegion`  (modified)

```diff
--- PopAdaptiveStandbyCalculateBatteryRegion
+++ PopAdaptiveStandbyCalculateBatteryRegion
@@ -1,11 +1,22 @@
 

-void PopAdaptiveStandbyCalculateBatteryRegion(void)

+uint PopAdaptiveStandbyCalculateBatteryRegion(int param_1)

 

 {

-  code *pcVar1;

+  uint uVar1;

+  int *piVar2;

+  uint uVar3;

   

-  pcVar1 = (code *)swi(3);

-  (*pcVar1)();

-  return;

+  uVar3 = 0;

+  piVar2 = &PopAdaptiveStandbyRegions;

+  do {

+    if (*piVar2 < param_1) break;

+    uVar3 = uVar3 + 1;

+    piVar2 = piVar2 + 5;

+  } while (uVar3 < 3);

+  uVar1 = 2;

+  if (uVar3 < 2) {

+    uVar1 = uVar3;

+  }

+  return uVar1;

 }
```

## `FsRtlpRequestExclusiveOplock`  (modified)

```diff
--- FsRtlpRequestExclusiveOplock
+++ FsRtlpRequestExclusiveOplock
@@ -1,160 +1,407 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-int FsRtlpRequestExclusiveOplock(void)

+ulonglong FsRtlpRequestExclusiveOplock

+                    (undefined8 *param_1,char *param_2,longlong param_3,undefined4 param_4)

 

 {

   byte *pbVar1;

-  code *pcVar2;

-  char cVar3;

-  undefined1 uVar4;

-  int iVar5;

-  longlong *plVar6;

-  longlong *plVar7;

-  longlong lVar8;

-  longlong *unaff_RBX;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  longlong unaff_R13;

-  int unaff_R15D;

-  bool bVar9;

-  undefined1 auStackX_8 [24];

-  undefined4 uStackX_20;

-  longlong *in_stack_00000048;

-  char in_stack_000001d8;

-  char in_stack_000001e0;

+  longlong lVar2;

+  undefined8 *puVar3;

+  undefined8 uVar4;

+  code *pcVar5;

+  void *pvVar6;

+  ulonglong uVar7;

+  undefined1 *puVar8;

+  char cVar9;

+  char cVar10;

+  undefined1 uVar11;

+  int iVar12;

+  uint uVar13;

+  ulonglong uVar14;

+  longlong *plVar15;

+  longlong *plVar16;

+  ulonglong uVar17;

+  undefined1 *puVar18;

+  undefined1 *puVar19;

+  undefined8 uVar20;

+  longlong lVar21;

+  uint uVar22;

+  longlong *plVar23;

+  undefined8 uStack_140;

+  undefined1 auStack_138 [8];

+  undefined1 auStack_130 [24];

+  undefined8 uStack_118;

+  undefined4 local_110 [2];

+  undefined2 local_108 [4];

+  char local_100 [16];

+  uint local_f0 [4];

+  ulonglong local_e0;

+  longlong *local_d8;

+  longlong alStack_d0 [17];

+  ulonglong local_48;

   

-  bVar9 = (int)unaff_RBX[7] == 0;

-  while (!bVar9) {

-    do {

-      unaff_RBX = (longlong *)*unaff_RBX;

-      if (unaff_RBX == (longlong *)(unaff_RDI + 0x38)) goto LAB_0;

-      cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),unaff_RBX[3],0);

-    } while (cVar3 == '\0');

-    bVar9 = unaff_RBX[7] == 0;

+  puVar19 = auStack_138;

+  puVar18 = auStack_138;

+  local_48 = __security_cookie ^ (ulonglong)auStack_138;

+  uVar14 = 0;

+  local_f0[2] = 0;

+  cVar10 = '\0';

+  local_100[8] = 0;

+  local_e0 = 0;

+  plVar15 = (longlong *)*param_1;

+  local_f0[0] = param_4;

+  if (plVar15 == (longlong *)0x0) {

+    plVar15 = (longlong *)FsRtlpAllocateOplock();

+    *param_1 = plVar15;

   }

-  if (unaff_R15D == 0x10000) {

-    iVar5 = -0x3fffff1d;

-    goto LAB_1;

-  }

-  uStackX_20 = 0;

-  FsRtlpRemoveAndCompleteRHIrp(*(undefined8 *)unaff_RBX[1]);

+  local_d8 = plVar15;

+  ExAcquireFastMutexUnsafe(plVar15[0x13]);

+  uVar22 = *(uint *)(plVar15 + 0x12);

+  uVar17 = uVar14;

+  puVar8 = auStack_138;

+  if (((uVar22 >> 0x10 & 1) == 0) || (uVar17 = 0, puVar8 = auStack_138, *param_2 != '\r')) {

 LAB_0:

-  plVar7 = *(longlong **)(unaff_RDI + 0x48);

-  if (plVar7 != (longlong *)(unaff_RDI + 0x48)) {

-    for (; plVar7 != (undefined8 *)(unaff_RDI + 0x48); plVar7 = (longlong *)*plVar7) {

-      cVar3 = FsRtlpOplockKeysEqual(*(undefined8 *)(unaff_R13 + 0x30),plVar7[3]);

-      if (cVar3 != '\0') {

-        iVar5 = -0x3fffff1e;

-        if (unaff_R15D != 0x10000) {

-          *(undefined4 *)(unaff_RSI + 0x30) = 0xc00000e2;

-          IofCompleteRequest();

+    puVar19 = puVar8;

+    lVar21 = 0;

+    uVar22 = *(uint *)(puVar19 + 0x168);

+    uVar14 = (ulonglong)uVar22;

+    *(undefined8 *)(puVar19 + -8) = 0x1404dbde6;

+    cVar9 = FsRtlpOplockUpperLowerCompatible(uVar14,*(undefined4 *)(puVar19 + 0x170));

+    if (cVar9 == '\0') goto LAB_1;

+    if (((uVar22 >> 0xc & 1) != 0) && (*(longlong *)(*(longlong *)(param_2 + 0x30) + 0x28) != 0)) {

+      *(undefined8 *)(puVar19 + -8) = 0x1404dbe0f;

+      iVar12 = MmDoesFileHaveUserWritableReferences();

+      lVar21 = 0;

+      if (iVar12 != 0) {

+        lVar21 = *(longlong *)(param_3 + 0x18);

+        *(undefined4 *)(lVar21 + 8) = 0;

+        uVar20 = 4;

+        *(uint *)(lVar21 + 0xc) = *(uint *)(lVar21 + 0xc) | 4;

+        if (5 < DAT_2) {

+          *(undefined8 *)(puVar19 + -8) = 0x1404dbe52;

+          cVar10 = _tlgKeywordOn(&DAT_2,0x400000000000);

+          if (cVar10 != '\0') {

+            *(undefined8 *)(puVar19 + 0x70) = 1;

+            *(undefined1 **)(puVar19 + 0xb0) = puVar19 + 0x70;

+            *(undefined8 *)(puVar19 + 0xb8) = 8;

+            *(uint *)(puVar19 + 0x50) = uVar22;

+            *(undefined1 **)(puVar19 + 0xc0) = puVar19 + 0x50;

+            *(undefined8 *)(puVar19 + 200) = uVar20;

+            *(int *)(puVar19 + 0x48) = (int)plVar15[0x12];

+            *(undefined1 **)(puVar19 + 0xd0) = puVar19 + 0x48;

+            *(undefined8 *)(puVar19 + 0xd8) = uVar20;

+            *(undefined8 *)(puVar19 + 0x68) = 0x1000000;

+            *(undefined1 **)(puVar19 + 0xe0) = puVar19 + 0x68;

+            *(undefined8 *)(puVar19 + 0xe8) = 8;

+            *(undefined1 **)(puVar19 + 0x20) = puVar19 + 0x90;

+            *(undefined8 *)(puVar19 + -8) = 0x1404dbef7;

+            _tlgWriteAgg(&DAT_2,&DAT_140044f34);

+          }

         }

         goto LAB_1;

       }

     }

-  }

-  *(undefined8 *)(*in_stack_00000048 + 0x20) =

-       *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

-  *(undefined8 *)(*in_stack_00000048 + 0x18) = *(undefined8 *)(unaff_R13 + 0x30);

-  iVar5 = FsRtlpOplockEnqueueRH(unaff_RDI + 0x38,*in_stack_00000048);

-  if (iVar5 < 0) {

-    if (unaff_R15D != 0x10000) {

-      *(int *)(unaff_RSI + 0x30) = iVar5;

-      IofCompleteRequest();

-    }

-    goto LAB_1;

-  }

-  bVar9 = false;

-  if (unaff_R15D == 0x10000) {

-    plVar6 = (longlong *)(*in_stack_00000048 + 0x38);

-    plVar7 = (longlong *)(unaff_RDI + 0x78);

-    lVar8 = *plVar7;

-    if (*(longlong **)(lVar8 + 8) != plVar7) {

-      plVar7 = (longlong *)0x3;

-      pcVar2 = (code *)swi(0x29);

-      plVar6 = (longlong *)(*pcVar2)();

-      register0x00000020 = (BADSPACEBASE *)auStackX_8;

-    }

-    *plVar6 = lVar8;

-    plVar6[1] = (longlong)plVar7;

-    *(longlong **)(lVar8 + 8) = plVar6;

-    *plVar7 = (longlong)plVar6;

-    iVar5 = 0;

-    *(undefined4 *)((longlong)register0x00000020 + 0x40) = 0;

-LAB_2:

-    in_stack_000001e0 = *(char *)((longlong)register0x00000020 + 0x1e0);

-    bVar9 = true;

+LAB_3:

+    uVar22 = (uint)uVar14;

+    if (uVar22 == 200) {

+      *plVar15 = param_3;

+      plVar15[1] = *(longlong *)(param_2 + 0x30);

+      *(uint *)(plVar15 + 0x12) = *(uint *)(plVar15 + 0x12) & 0x20 | 200;

+      uVar17 = (ulonglong)*(uint *)(puVar19 + 0x50);

+      cVar10 = puVar19[0x40];

+LAB_4:

+      if (cVar10 == '\0') goto LAB_5;

+LAB_6:

+      *plVar15 = param_3;

+      plVar15[1] = *(longlong *)(param_2 + 0x30);

+      *(undefined8 *)(puVar19 + -8) = 0x1404dc329;

+      FsRtlpClearOwner(plVar15,0);

+      plVar15[2] = *(longlong *)((longlong)SystemReserved1[0xf] + 0xb8);

+      pvVar6 = SystemReserved1[0xf];

+      plVar15[3] = (longlong)SystemReserved1[0xf];

+      *(undefined8 *)(puVar19 + -8) = 0x1404dc354;

+      ObfReferenceObjectWithTag(pvVar6,0x746c6644);

+      *(undefined1 *)(plVar15 + 4) = 0;

+      *(uint *)(plVar15 + 0x12) = *(uint *)(plVar15 + 0x12) & 0x20 | uVar22;

+      uVar20 = *(undefined8 *)(param_2 + 0x30);

+      *(undefined8 *)(puVar19 + -8) = 0x1404dc378;

+      ObfReferenceObjectWithTag(uVar20,0x746c6644);

+      pbVar1 = (byte *)(*(longlong *)(param_3 + 0xb8) + 3);

+      *pbVar1 = *pbVar1 | 1;

+      *(longlong **)(param_3 + 0x38) = plVar15;

+      *(undefined8 *)(puVar19 + -8) = 0x1404dc395;

+      uVar11 = KeAcquireQueuedSpinLock(7);

+      *(undefined1 *)(param_3 + 0x45) = uVar11;

+      if (*(char *)(param_3 + 0x44) == '\0') {

+        LOCK();

+        *(code **)(param_3 + 0x68) = FsRtlpExclusiveIrpCancelRoutine;

+        UNLOCK();

+        uVar11 = *(undefined1 *)(param_3 + 0x45);

+        *(undefined8 *)(puVar19 + -8) = 0x1404dc3c4;

+        KeReleaseQueuedSpinLock(7,uVar11);

+        *(longlong **)(puVar19 + 0x20) = plVar15 + 0x16;

+        lVar21 = plVar15[1];

+        *(undefined8 *)(puVar19 + -8) = 0x1404dc3e6;

+        FsRtlpOplockTryPrepForAckTimeout(plVar15,lVar21,param_3,plVar15 + 0x14);

+      }

+      else {

+        *(undefined8 *)(puVar19 + -8) = 0x1404dc3ac;

+        FsRtlpCancelExclusiveIrp(param_3,1,1);

+      }

+      uVar17 = 0x103;

+      goto LAB_5;

+    }

+    uVar13 = *(uint *)(plVar15 + 0x12);

+    if ((uVar13 & 0x91) == 0) {

+      if ((((uVar13 & 0x7000) == 0) || ((uVar13 & 0x1f00f00) != 0)) ||

+         ((longlong *)plVar15[9] != plVar15 + 9)) {

+        if ((uVar22 >> 0x10 & 1) == 0) {

+          uVar17 = 0xc00000e2;

+          if (param_3 != 0) {

+            *(undefined4 *)(param_3 + 0x30) = 0xc00000e2;

+            *(undefined8 *)(puVar19 + -8) = 0x1404dc2ff;

+            IofCompleteRequest(param_3,1);

+          }

+          *(undefined4 *)(puVar19 + 0x50) = 0xc00000e2;

+          goto LAB_4;

+        }

+      }

+      else if ((uVar22 >> 0x10 & 1) == 0) {

+        if (((uVar14 & 0x7000) != 0) &&

+           ((lVar2 = *(longlong *)(param_2 + 0x30), *(char *)(lVar2 + 0x49) == (char)lVar21 ||

+            ((uVar22 >> 0xd & 1) == 0)))) {

+          uVar13 = uVar13 & 0x1f0ffdf;

+          if (uVar13 == 0x1000) {

+            if ((uVar22 - 0x5040 & 0xffffdfff) == 0) {

+              for (plVar16 = (longlong *)plVar15[5]; plVar16 != plVar15 + 5;

+                  plVar16 = (longlong *)*plVar16) {

+                lVar21 = plVar16[2];

+                *(longlong *)(puVar19 + 0x68) = lVar21;

+                uVar20 = *(undefined8 *)(lVar21 + 0x30);

+                uVar4 = *(undefined8 *)(param_2 + 0x30);

+                *(undefined8 *)(puVar19 + -8) = 0x1404dc271;

+                cVar10 = FsRtlpOplockKeysEqual(uVar4,uVar20,0);

+                if (cVar10 == '\0') goto LAB_7;

+              }

+              if ((*(uint *)(puVar19 + 0x48) < 2) || ((puVar19[0x160] & 1) != 0)) {

+                plVar16 = (longlong *)plVar15[5];

+                while (*(longlong **)(puVar19 + 0x48) = plVar16, plVar16 != plVar15 + 5) {

+                  puVar3 = (undefined8 *)plVar16[1];

+                  uVar20 = *puVar3;

+                  *(undefined8 *)(puVar19 + -8) = 0x1404dc2c4;

+                  FsRtlpRemoveAndCompleteReadOnlyIrp(uVar20,0x215,uVar22 & 0x7000,plVar15);

+                  plVar16 = (longlong *)*puVar3;

+                }

+                cVar10 = '\x01';

+                puVar19[0x40] = 1;

+                goto LAB_4;

+              }

+              goto LAB_1;

+            }

+          }

+          else if (uVar13 == 0x3000) {

+            if (uVar22 == 0x7040) {

+              for (plVar16 = (longlong *)plVar15[7]; plVar16 != plVar15 + 7;

+                  plVar16 = (longlong *)*plVar16) {

+                lVar21 = plVar16[3];

+                uVar20 = *(undefined8 *)(param_2 + 0x30);

+                *(undefined8 *)(puVar19 + -8) = 0x1404dc1b2;

+                cVar10 = FsRtlpOplockKeysEqual(uVar20,lVar21,0);

+                lVar21 = 0;

+                if (cVar10 == '\0') goto LAB_7;

+                if (plVar16[7] != 0) {

+                  uVar17 = 0xc00000e3;

+                  goto LAB_8;

+                }

+              }

+              if ((*(uint *)(puVar19 + 0x48) < 2) || ((puVar19[0x160] & 1) != 0)) {

+                plVar16 = (longlong *)plVar15[7];

+                while (*(longlong **)(puVar19 + 0x48) = plVar16, plVar16 != plVar15 + 7) {

+                  puVar3 = (undefined8 *)plVar16[1];

+                  puVar19[0x38] = (char)lVar21;

+                  *(short *)(puVar19 + 0x30) = (short)lVar21;

+                  *(int *)(puVar19 + 0x28) = (int)lVar21;

+                  *(int *)(puVar19 + 0x20) = (int)lVar21;

+                  uVar20 = *puVar3;

+                  *(undefined8 *)(puVar19 + -8) = 0x1404dc230;

+                  FsRtlpRemoveAndCompleteRHIrp(uVar20,plVar15,0x215,0x7000);

+                  lVar21 = 0;

+                  plVar16 = (longlong *)*puVar3;

+                }

+                goto LAB_6;

+              }

+              goto LAB_1;

+            }

+          }

+          else if (((uVar13 == 0x5040) || ((uVar13 == 0x7040 && (uVar22 == 0x7040)))) &&

+                  ((uVar22 - 0x5040 & 0xffffdfff) == 0)) {

+            lVar21 = plVar15[1];

+            *(undefined8 *)(puVar19 + -8) = 0x1404dc0cb;

+            cVar10 = FsRtlpOplockKeysEqual(lVar2,lVar21,0);

+            if (cVar10 != '\0') {

+              lVar21 = *plVar15;

+              *(longlong *)(puVar19 + 0x78) = lVar21;

+              *(undefined8 *)(puVar19 + -8) = 0x1404dc0eb;

+              uVar11 = KeAcquireQueuedSpinLock(7);

+              *(undefined1 *)(lVar21 + 0x45) = uVar11;

+              LOCK();

+              *(undefined8 *)(lVar21 + 0x68) = 0;

+              UNLOCK();

+              uVar11 = *(undefined1 *)(lVar21 + 0x45);

+              *(undefined8 *)(puVar19 + -8) = 0x1404dc100;

+              KeReleaseQueuedSpinLock(7,uVar11);

+              lVar2 = *(longlong *)(puVar19 + 0x78);

+              if (*(char *)(lVar2 + 0x44) == '\0') {

+                puVar3 = *(undefined8 **)(lVar2 + 0x18);

+                *(undefined8 **)(puVar19 + 0x80) = puVar3;

+                *puVar3 = 0;

+                puVar3[1] = 0;

+                puVar3[2] = 0;

+                *(undefined4 *)puVar3 = 0x180001;

+                *(uint *)((longlong)puVar3 + 4) = *(uint *)(plVar15 + 0x12) >> 0xc & 7;

+                *(uint *)(puVar3 + 1) = (uint)(uVar14 >> 0xc) & 7;

+                *(undefined8 *)(lVar21 + 0x38) = 0x18;

+                *(undefined4 *)(lVar21 + 0x30) = 0x215;

+              }

+              else {

+                *(undefined8 *)(lVar21 + 0x38) = 0;

+                *(undefined4 *)(lVar21 + 0x30) = 0xc0000120;

+              }

+              *(undefined8 *)(puVar19 + -8) = 0x1404dc16d;

+              IofCompleteRequest(lVar2,1);

+              *plVar15 = 0;

+              lVar21 = plVar15[1];

+              *(undefined8 *)(puVar19 + -8) = 0x1404dc17e;

+              ObfDereferenceObjectWithTag(lVar21,0x746c6644);

+              plVar15[1] = 0;

+              goto LAB_6;

+            }

+          }

+        }

+        goto LAB_7;

+      }

+LAB_9:

+      uVar17 = 0xc0000909;

+      goto LAB_5;

+    }

+    if (((uVar13 & 0x10) == 0) || ((uVar14 & 0x7000) == 0)) {

+      if ((char)uVar13 < '\0') {

+        lVar21 = plVar15[1];

+        uVar20 = *(undefined8 *)(param_2 + 0x30);

+        *(undefined8 *)(puVar19 + -8) = 0x1404dbf8a;

+        cVar10 = FsRtlpOplockKeysEqual(uVar20,lVar21,0);

+        lVar21 = 0;

+        if (cVar10 == '\0') goto LAB_10;

+      }

+      cVar10 = (char)lVar21;

+      uVar13 = *(uint *)(plVar15 + 0x12) & 0x1f0ffdf;

+      if (((uVar13 == 0x10) || (uVar13 == 0x1000)) || (uVar13 == 0x1010)) {

+        lVar21 = plVar15[5];

+        *(undefined8 *)(puVar19 + -8) = 0x1404dbfc0;

+        FsRtlpRemoveAndCompleteReadOnlyIrp(lVar21,0,0,plVar15);

+        cVar10 = '\0';

+      }

+      if (((*(uint *)(puVar19 + 0x48) < 2) || ((*(uint *)(plVar15 + 0x12) & 1) == 0)) ||

+         ((puVar19[0x160] & 1) != 0)) {

+        if ((*(char *)(*(longlong *)(param_2 + 0x30) + 0x49) == cVar10) ||

+           ((uVar22 >> 0xd & 1) == 0)) goto LAB_6;

+        if ((uVar22 >> 0x10 & 1) == 0) goto LAB_1;

+        goto LAB_9;

+      }

+      uVar17 = 0xc00000e2;

+      if (param_3 == 0) goto LAB_5;

+    }

+    else {

+LAB_10:

+      if ((uVar22 >> 0x10 & 1) != 0) goto LAB_9;

+LAB_7:

+      uVar17 = 0xc00000e2;

+    }

   }

   else {

-    *(void **)(*in_stack_00000048 + 0x28) = SystemReserved1[0xf];

-    ObfReferenceObjectWithTag(*(undefined8 *)(*in_stack_00000048 + 0x28),0x746c6644);

-    *(longlong *)(*in_stack_00000048 + 0x10) = unaff_RSI;

-    pbVar1 = (byte *)(*(longlong *)(unaff_RSI + 0xb8) + 3);

-    *pbVar1 = *pbVar1 | 1;

-    iVar5 = 0x103;

-    *(undefined4 *)(unaff_RSI + 0x30) = 0;

-    *(longlong *)(unaff_RSI + 0x38) = unaff_RDI;

-    if (in_stack_000001d8 != '\0') {

-      ObfReferenceObjectWithTag(*(undefined8 *)(*in_stack_00000048 + 0x18),0x746c6644);

-    }

-    uVar4 = KeAcquireQueuedSpinLock(7);

-    *(undefined1 *)(unaff_RSI + 0x45) = uVar4;

-    if (*(char *)(unaff_RSI + 0x44) == '\0') {

-      LOCK();

-      *(code **)(unaff_RSI + 0x68) = FsRtlpOplockRHIrpCancelRoutine;

-      UNLOCK();

-      KeReleaseQueuedSpinLock(7,*(undefined1 *)(unaff_RSI + 0x45));

-      iVar5 = 0x103;

-      goto LAB_2;

-    }

-    if ((in_stack_000001d8 == '\0') || (in_stack_000001e0 == '\0')) {

-      FsRtlpCancelOplockRHIrp();

-    }

-    else {

-      FsRtlpCancelOplockRHIrp();

-    }

+    cVar9 = FsRtlpCallerIsAtomicRequestor(plVar15,*(undefined8 *)(param_2 + 0x30),&local_e0);

+    uVar7 = local_e0;

+    lVar21 = 0;

+    uVar17 = uVar14;

+    puVar8 = auStack_138;

+    if (cVar9 == '\0') goto LAB_0;

+    if ((uVar22 >> 0x11 & 1) == 0) {

+LAB_11:

+      plVar16 = (longlong *)plVar15[0xb];

+      while (plVar16 != plVar15 + 0xb) {

+        plVar23 = plVar16;

+        if (*(char *)((longlong)plVar16 + 0x35) == (char)lVar21) {

+          plVar23 = (longlong *)plVar16[1];

+          *(undefined8 *)(puVar18 + -8) = 0x1404dbd4e;

+          FsRtlpRemoveAndCompleteWaitingIrp(plVar16);

+          lVar21 = 0;

+        }

+        plVar16 = (longlong *)*plVar23;

+      }

+      uVar14 = *(ulonglong *)(puVar18 + 0x58);

+      *(undefined8 *)(puVar18 + -8) = 0x1404dbd63;

+      FsRtlpOplockDequeueRH(uVar14);

+      plVar16 = (longlong *)(uVar14 + 0x38);

+      lVar2 = *plVar16;

+      plVar23 = *(longlong **)(uVar14 + 0x40);

+      if ((*(longlong **)(lVar2 + 8) == plVar16) && ((longlong *)*plVar23 == plVar16)) {

+        *plVar23 = lVar2;

+        *(longlong **)(lVar2 + 8) = plVar23;

+        if ((longlong *)plVar15[0xf] == plVar15 + 0xf) {

+          *(uint *)(plVar15 + 0x12) = *(uint *)(plVar15 + 0x12) & 0xfffcffff;

+        }

+        if (*(longlong *)(uVar14 + 0x28) != lVar21) {

+          *(undefined8 *)(puVar18 + -8) = 0x1404dbdac;

+          FsRtlpClearOwner(plVar15,uVar14);

+        }

+        *(undefined8 *)(puVar18 + -8) = 0x1404dbdbd;

+        FsRtlpFreeRHOpContext(uVar14,1);

+        *(undefined8 *)(puVar18 + 0x58) = 0;

+        *(undefined8 *)(puVar18 + -8) = 0x1404dbdcc;

+        FsRtlpComputeShareableOplockState(plVar15);

+        puVar8 = puVar18;

+        goto LAB_0;

+      }

+      pcVar5 = (code *)swi(0x29);

+      (*pcVar5)(3);

+      puVar19 = puVar18 + 8;

+      goto LAB_3;

+    }

+    FsRtlpOplockDequeueRH(local_e0);

+    plVar16 = (longlong *)(uVar7 + 0x38);

+    lVar2 = *plVar16;

+    plVar23 = *(longlong **)(uVar7 + 0x40);

+    if ((*(longlong **)(lVar2 + 8) != plVar16) || ((longlong *)*plVar23 != plVar16)) {

+      pcVar5 = (code *)swi(0x29);

+      (*pcVar5)(3);

+      puVar18 = auStack_130;

+      uVar17 = uVar7;

+      goto LAB_11;

+    }

+    *plVar23 = lVar2;

+    *(longlong **)(lVar2 + 8) = plVar23;

+    if ((longlong *)plVar15[0xf] == plVar15 + 0xf) {

+      *(uint *)(plVar15 + 0x12) = *(uint *)(plVar15 + 0x12) & 0xfffcffff;

+    }

+    if (*(longlong *)(uVar7 + 0x28) != lVar21) {

+      FsRtlpClearOwner(plVar15,uVar7);

+    }

+    FsRtlpFreeRHOpContext(uVar7,1);

+    local_e0 = 0;

+    FsRtlpComputeShareableOplockState(plVar15);

+LAB_1:

+    uVar17 = 0xc00000e2;

   }

-  if (5 < DAT_3) {

-    *(int *)((longlong)register0x00000020 + 0x60) = unaff_R15D;

-    *(undefined1 **)((longlong)register0x00000020 + 0x120) =

-         (undefined1 *)((longlong)register0x00000020 + 0x60);

-    *(undefined8 *)((longlong)register0x00000020 + 0x128) = 4;

-    *(char *)((longlong)register0x00000020 + 0x45) = in_stack_000001e0;

-    *(undefined1 **)((longlong)register0x00000020 + 0x130) =

-         (undefined1 *)((longlong)register0x00000020 + 0x45);

-    *(undefined8 *)((longlong)register0x00000020 + 0x138) = 1;

-    *(longlong *)((longlong)register0x00000020 + 0x88) = unaff_RDI;

-    *(undefined1 **)((longlong)register0x00000020 + 0x140) =

-         (undefined1 *)((longlong)register0x00000020 + 0x88);

-    *(undefined8 *)((longlong)register0x00000020 + 0x148) = 8;

-    *(undefined4 *)((longlong)register0x00000020 + 0x48) = *(undefined4 *)(unaff_RDI + 0x90);

-    *(undefined1 **)((longlong)register0x00000020 + 0x150) =

-         (undefined1 *)((longlong)register0x00000020 + 0x48);

-    *(undefined8 *)((longlong)register0x00000020 + 0x158) = 4;

-    *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-         (undefined1 *)((longlong)register0x00000020 + 0x100);

-    *(undefined4 *)((longlong)register0x00000020 + 0x20) = 6;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcbd7;

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_3,&DAT_140044faa,0,0);

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcbdf;

-  FsRtlpComputeShareableOplockState();

-  if (bVar9) {

-    *(longlong *)((longlong)register0x00000020 + 0x20) = *in_stack_00000048 + 0x58;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dcc04;

-    FsRtlpOplockTryPrepForAckTimeout();

-  }

-  *in_stack_00000048 = 0;

-  if (unaff_R15D == 0x10000) {

-    *(uint *)(unaff_RDI + 0x90) = *(uint *)(unaff_RDI + 0x90) | 0x10000;

-  }

-LAB_1:

-  if ((*(char *)((longlong)register0x00000020 + 0x44) != '\0') && (unaff_R15D != 0x10000)) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce72;

-    ExReleaseFastMutexUnsafe(*(undefined8 *)((longlong)register0x00000020 + 0x70));

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404dce84;

-  return iVar5;

+LAB_8:

+  *(int *)(param_3 + 0x30) = (int)uVar17;

+  *(undefined8 *)(puVar19 + -8) = 0x1404dbd24;

+  IofCompleteRequest(param_3,1);

+LAB_5:

+  lVar21 = plVar15[0x13];

+  *(undefined8 *)(puVar19 + -8) = 0x1404dc3f7;

+  ExReleaseFastMutexUnsafe(lVar21);

+  *(undefined8 *)(puVar19 + -8) = 0x1404dc409;

+  return uVar17 & 0xffffffff;

 }
```

## `PopAdaptiveStandbyInitialize`  (modified)

```diff
--- PopAdaptiveStandbyInitialize
+++ PopAdaptiveStandbyCheckHibernateBudgetAction
@@ -1,164 +1,296 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

-

-void PopAdaptiveStandbyInitialize(void)

+/* WARNING: Type propagation algorithm not settling */

+

+char PopAdaptiveStandbyCheckHibernateBudgetAction

+               (longlong param_1,uint *param_2,undefined4 *param_3,undefined4 *param_4)

 

 {

-  char cVar1;

-  int iVar2;

-  undefined **ppuVar3;

-  uint uVar4;

-  undefined8 **ppuVar5;

-  undefined4 uVar6;

-  undefined4 uVar7;

-  undefined1 auStack_b8 [32];

-  undefined **local_98;

-  undefined1 *local_90;

-  undefined4 local_88;

-  int local_78 [2];

+  undefined1 *puVar1;

+  undefined4 uVar2;

+  undefined4 uVar3;

+  char cVar4;

+  byte bVar5;

+  char cVar6;

+  int iVar7;

+  longlong lVar8;

+  undefined8 uVar9;

+  undefined *puVar10;

+  undefined4 uVar11;

+  uint uVar12;

+  undefined1 auStack_2c8 [32];

+  undefined4 local_2a8;

+  undefined1 *local_2a0;

+  byte local_298;

+  byte local_297 [3];

+  undefined4 local_294;

+  undefined8 local_290;

+  uint local_288;

+  undefined4 local_284;

+  uint local_280;

+  uint local_27c;

+  undefined4 local_278;

+  undefined4 local_274;

+  uint local_270;

+  uint local_26c;

+  undefined4 local_268;

+  uint local_264;

+  undefined4 local_260;

+  undefined4 local_25c;

+  undefined4 local_258;

+  undefined4 local_254;

+  undefined4 local_250;

+  undefined4 local_24c;

+  ulonglong local_248;

+  ulonglong local_240;

+  ulonglong local_238;

+  ulonglong local_230;

+  ulonglong local_228 [2];

+  undefined1 local_218 [32];

+  ulonglong *local_1f8;

+  undefined8 local_1f0;

+  undefined4 *local_1e8;

+  undefined8 local_1e0;

+  uint *local_1d8;

+  undefined8 local_1d0;

+  uint *local_1c8;

+  undefined8 local_1c0;

+  undefined4 *local_1b8;

+  undefined8 local_1b0;

+  uint *local_1a8;

+  undefined8 local_1a0;

+  undefined4 *local_198;

+  undefined8 local_190;

+  ulonglong *local_188;

+  undefined8 local_180;

+  ulonglong *local_178;

+  undefined8 local_170;

+  undefined4 *local_168;

+  undefined8 local_160;

+  ulonglong *local_158;

+  undefined8 local_150;

+  undefined4 *local_148;

+  undefined8 local_140;

+  ulonglong *local_138;

+  undefined8 local_130;

+  undefined4 *local_128;

+  undefined8 local_120;

+  undefined4 *local_118;

+  undefined8 local_110;

+  byte *local_108;

+  undefined8 local_100;

+  undefined4 *local_f8;

+  undefined8 local_f0;

+  undefined4 *local_e8;

+  undefined8 local_e0;

+  undefined4 *local_d8;

+  undefined8 local_d0;

+  uint *local_c8;

+  undefined8 local_c0;

+  byte *local_b8;

+  undefined8 local_b0;

+  undefined4 *local_a8;

+  undefined8 local_a0;

+  uint *local_98;

+  undefined8 local_90;

+  uint *local_88;

+  undefined8 local_80;

+  undefined4 *local_78;

   undefined8 local_70;

-  undefined8 uStack_68;

+  ulonglong *local_68;

   undefined8 local_60;

-  undefined8 *local_58 [3];

-  undefined1 local_40 [32];

-  int *local_20;

-  undefined4 local_18;

-  undefined4 local_14;

-  ulonglong local_10;

+  ulonglong local_58;

   

-  local_10 = __security_cookie ^ (ulonglong)auStack_b8;

-  local_60 = 0;

-  local_58[0] = &WNF_PO_COMPOSITE_BATTERY;

-  local_58[1] = &WNF_SEB_AUDIO_ACTIVITY;

-  local_58[2] = &WNF_PO_SLEEPSTUDY_SESSION_CHANGE;

-  local_70 = 0;

-  uStack_68 = 0;

-  TraceLoggingRegisterEx_EtwRegister_EtwSetInformation(&DAT_0,0,0);

-  EtwActivityIdControl(3,&local_70);

-  local_60 = IoSetActivityIdThread(&local_70);

-  if (5 < DAT_0) {

-    local_90 = local_40;

-    local_98 = (undefined **)CONCAT44(local_98._4_4_,2);

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e1e8,&local_70,local_60);

-  }

-  _DAT_1 = 0;

-  _PopAdaptiveStandbyLock = 0;

-  PopAcquireRwLockExclusive(&PopAdaptiveStandbyLock);

-  cVar1 = SSHSupportIsPlatformAoAc();

-  if (cVar1 != '\0') {

-    cVar1 = RtlIsMultiSessionSku();

-    if (cVar1 != '\0') {

-      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

-      if (iVar2 == 0) {

-        _DAT_2 = 1;

-        _DAT_3 = 0xffffffff;

-        _DAT_4 = 1;

-        _DAT_5 = 0x2a30;

+  local_58 = __security_cookie ^ (ulonglong)auStack_2c8;

+  puVar1 = (undefined1 *)(param_1 + 4);

+  iVar7 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  if (iVar7 == 0) {

+    bVar5 = PopAdaptiveStandbyCheckRefreshableBudgetAction(param_1,puVar1,param_2,param_3);

+    uVar12 = (uint)bVar5;

+  }

+  else {

+    lVar8 = (longlong)*(int *)(param_1 + 0xd8);

+    uVar11 = (&DAT_0)[lVar8 * 5];

+    uVar2 = (&DAT_1)[lVar8 * 5];

+    uVar3 = (&DAT_2)[lVar8 * 5];

+    *(undefined4 *)(param_1 + 0x18) = *(undefined4 *)(&DAT_3 + lVar8 * 0x14);

+    *(undefined4 *)(param_1 + 0x1c) = uVar11;

+    *(undefined4 *)(param_1 + 0x20) = uVar2;

+    *(undefined4 *)(param_1 + 0x24) = uVar3;

+    PopAdaptiveStandbySetPolicyTimer(param_1,*param_2,*(undefined4 *)(param_1 + 0x18));

+    cVar4 = PopAdaptiveStandbyCheckRefreshableBudgetActionPreconditions

+                      (param_1,puVar1,param_2,param_3);

+    if (cVar4 == '\0') {

+      uVar12 = 0;

+    }

+    else {

+      if ((int)param_2[3] < 0xb) {

+        if (0x707 < *param_2) {

+          uVar12 = 1;

+          *puVar1 = 1;

+          *param_3 = 0;

+          *param_4 = 4;

+          uVar11 = 1;

+          goto LAB_4;

+        }

+        PopAdaptiveStandbySetPolicyTimer(param_1);

       }

-      else {

-        _DAT_6 = 1;

-        DAT_7 = 0xffffffff;

-        DAT_8 = 1;

-        DAT_9 = 0x2a30;

+      bVar5 = PopAdaptiveStandbyCheckRefreshableBudgetActionV2(puVar1,param_2[5],param_2[1],param_3)

+      ;

+      uVar12 = (uint)bVar5;

+      if (bVar5 != 0) {

+        *param_4 = 1;

       }

-      _DAT_10 = _DAT_10 | 1;

-      _DAT_11 = 0;

-      _DAT_12 = 0;

-      _DAT_13 = 0xffffffff;

-      _DAT_14 = 0xffffffff;

-      _DAT_15 = PopAdaptiveStandbyActionWorker;

-      DAT_16 = 100;

-      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

-      if (iVar2 != 0) {

-        local_88 = 0x22;

-        local_90 = (undefined1 *)CONCAT44(local_90._4_4_,6);

-        PopInitializeIRTimer(&DAT_17,PopAdaptiveStandbyPolicyTimerCallback);

-      }

-      uVar4 = 0;

-      ppuVar3 = &PopAdaptiveStandbyPowerSettings;

-      do {

-        local_98 = ppuVar3 + 2;

-        iVar2 = PoRegisterPowerSettingCallback

-                          (0,*ppuVar3,PopAdaptiveStandbyPowerSettingCallback,ppuVar3);

-        if (iVar2 < 0) goto LAB_18;

-        uVar4 = uVar4 + 1;

-        ppuVar3 = ppuVar3 + 3;

-      } while (uVar4 < 7);

-      uVar4 = 0;

-      ppuVar5 = local_58;

-      do {

-        local_90 = (undefined1 *)0x0;

-        local_98 = (undefined **)PopAdaptiveStandbyWnfCallback;

-        iVar2 = ExSubscribeWnfStateChange(local_78,*ppuVar5,1);

-        if (iVar2 < 0) goto LAB_18;

-        uVar4 = uVar4 + 1;

-        ppuVar5 = ppuVar5 + 1;

-      } while (uVar4 < 3);

-      iVar2 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

-      if (iVar2 != 0) {

-        iVar2 = Feature_AdaptiveHibernateEnhancements__private_GetVariant();

-        if (iVar2 == 6) {

-          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsOEM;

-          _DAT_19 = uRam0000000140e0c330;

-          _DAT_20 = _DAT_140e0c348;

-          uRam0000000140e0c410 = uRam0000000140e0c350;

-          uVar6 = (undefined4)DAT_21;

-          uVar7 = (undefined4)((ulonglong)DAT_21 >> 0x20);

-          DAT_22 = _DAT_140e0c338;

-          DAT_23 = uRam0000000140e0c33c;

-          _DAT_24 = uRam0000000140e0c340;

-          _DAT_25 = uRam0000000140e0c344;

-          _DAT_26 = DAT_140e0c360;

-        }

-        else if ((iVar2 == 7) || (iVar2 == 8)) {

-          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsT3;

-          _DAT_19 = uRam0000000140e0c370;

-          _DAT_20 = _DAT_140e0c388;

-          uRam0000000140e0c410 = uRam0000000140e0c390;

-          uVar6 = (undefined4)DAT_27;

-          uVar7 = (undefined4)((ulonglong)DAT_27 >> 0x20);

-          DAT_22 = _DAT_140e0c378;

-          DAT_23 = uRam0000000140e0c37c;

-          _DAT_24 = uRam0000000140e0c380;

-          _DAT_25 = uRam0000000140e0c384;

-          _DAT_26 = DAT_140e0c3a0;

-        }

-        else {

-          if ((iVar2 != 9) && (iVar2 != 10)) goto LAB_28;

-          _PopAdaptiveStandbyRegions = _PopAdaptiveStandbyRegionsT35;

-          _DAT_19 = uRam0000000140e0c3b0;

-          _DAT_20 = _DAT_140e0c3c8;

-          uRam0000000140e0c410 = uRam0000000140e0c3d0;

-          uVar6 = (undefined4)DAT_29;

-          uVar7 = (undefined4)((ulonglong)DAT_29 >> 0x20);

-          DAT_22 = _DAT_140e0c3b8;

-          DAT_23 = uRam0000000140e0c3bc;

-          _DAT_24 = uRam0000000140e0c3c0;

-          _DAT_25 = uRam0000000140e0c3c4;

-          _DAT_26 = DAT_140e0c3e0;

-        }

-        _DAT_30 = CONCAT44(uVar7,uVar6);

-      }

-LAB_28:

-      PopAdaptiveStandbyContext = 1;

-      iVar2 = 0;

-      goto LAB_18;

-    }

-  }

-  iVar2 = -0x3fffff45;

-LAB_18:

-  PopReleaseRwLock(&PopAdaptiveStandbyLock);

-  if (5 < DAT_0) {

-    local_14 = 0;

-    local_20 = local_78;

-    local_90 = local_40;

-    local_98 = (undefined **)CONCAT44(local_98._4_4_,3);

-    local_18 = 4;

-    local_78[0] = iVar2;

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004e212,&local_70,local_60);

-  }

-  IoClearActivityIdThread(local_60);

-  return;

+    }

+  }

+  uVar11 = 0;

+LAB_4:

+  iVar7 = Feature_AdaptiveHibernateEnhancements__private_IsEnabledDeviceUsageNoInline();

+  cVar4 = (char)uVar12;

+  if (iVar7 == 0) {

+    if (DAT_5 < 6) {

+      return cVar4;

+    }

+    cVar6 = _tlgKeywordOn(&DAT_5,0x400000000000);

+    if (cVar6 == '\0') {

+      return cVar4;

+    }

+    local_238 = (ulonglong)*param_2;

+    local_1f8 = &local_238;

+    local_278 = *(undefined4 *)(param_1 + 8);

+    local_1e8 = &local_278;

+    local_27c = param_2[3];

+    local_1d8 = &local_27c;

+    local_280 = param_2[4];

+    local_1c8 = &local_280;

+    local_284 = *(undefined4 *)(param_1 + 0xc);

+    local_1b8 = &local_284;

+    local_1a8 = &local_288;

+    local_290._4_4_ = *param_3;

+    local_198 = (undefined4 *)((longlong)&local_290 + 4);

+    local_240 = *(ulonglong *)(param_1 + 0xf0);

+    local_188 = &local_240;

+    local_290._0_4_ = *(undefined4 *)(param_1 + 0x10);

+    local_178 = &local_290;

+    local_294 = *(undefined4 *)(param_1 + 0x14);

+    local_168 = &local_294;

+    local_158 = &local_248;

+    local_1f0 = 8;

+    local_1e0 = 4;

+    local_1d0 = 4;

+    local_1c0 = 4;

+    local_1b0 = 4;

+    local_1a0 = 4;

+    local_190 = 4;

+    local_180 = 8;

+    local_170 = 4;

+    local_160 = 4;

+    local_248 = 0x1000000;

+    local_150 = 8;

+    local_288 = uVar12;

+    uVar9 = IoGetActivityIdThread();

+    puVar10 = &DAT_6;

+    local_2a8 = 0xd;

+  }

+  else {

+    if ((cVar4 != '\0') && (*(char *)(param_1 + 0x144) != '\0')) {

+      *(undefined1 *)(param_1 + 0x144) = 0;

+      KeCancelTimer2(param_1 + 0x150,0);

+    }

+    if (DAT_5 < 6) {

+      return cVar4;

+    }

+    cVar6 = _tlgKeywordOn(&DAT_5,0x400000000000);

+    if (cVar6 == '\0') {

+      return cVar4;

+    }

+    local_230 = (ulonglong)*param_2;

+    local_228[0] = *(ulonglong *)(param_1 + 0xf0);

+    local_1f8 = &local_230;

+    local_274 = *(undefined4 *)(param_1 + 0x18);

+    local_248 = local_228[0] - 1;

+    if (*(int *)(param_1 + 0xf8) != 2) {

+      local_248 = local_228[0];

+    }

+    local_1e8 = &local_274;

+    local_270 = param_2[3];

+    local_1d8 = &local_270;

+    local_26c = param_2[4];

+    local_1c8 = &local_26c;

+    local_268 = *(undefined4 *)(param_1 + 0x1c);

+    local_1b8 = &local_268;

+    local_1a8 = &local_264;

+    local_260 = *param_3;

+    local_198 = &local_260;

+    local_188 = local_228;

+    local_178 = &local_248;

+    local_25c = *(undefined4 *)(param_1 + 0x20);

+    local_168 = &local_25c;

+    local_258 = *(undefined4 *)(param_1 + 0x24);

+    local_158 = (ulonglong *)&local_258;

+    local_254 = *(undefined4 *)(param_1 + 0xd8);

+    local_148 = &local_254;

+    local_240 = (ulonglong)param_2[1];

+    local_138 = &local_240;

+    local_128 = &local_250;

+    local_24c = *(undefined4 *)(param_1 + 0xec);

+    local_118 = &local_24c;

+    local_298 = *(byte *)(param_1 + 0x88) & 1;

+    local_1f0 = 8;

+    local_108 = &local_298;

+    local_1e0 = 4;

+    local_1d0 = 4;

+    local_1c0 = 4;

+    local_1b0 = 4;

+    local_1a0 = 4;

+    local_190 = 4;

+    local_180 = 8;

+    local_170 = 8;

+    local_160 = 4;

+    local_150 = 4;

+    local_140 = 4;

+    local_130 = 8;

+    local_120 = 4;

+    local_110 = 4;

+    local_294 = *(undefined4 *)(param_1 + 0x8c);

+    local_f8 = &local_294;

+    local_290._0_4_ = *(undefined4 *)(param_1 + 0x90);

+    local_e8 = (undefined4 *)&local_290;

+    local_290._4_4_ = *(undefined4 *)(param_1 + 0x94);

+    local_d8 = (undefined4 *)((longlong)&local_290 + 4);

+    local_288 = *(uint *)(param_1 + 0x98);

+    local_c8 = &local_288;

+    local_297[0] = *(byte *)(param_1 + 0x9c) & 1;

+    local_100 = 1;

+    local_b8 = local_297;

+    local_284 = *(undefined4 *)(param_1 + 0xa0);

+    local_a8 = &local_284;

+    local_280 = *(uint *)(param_1 + 0xa4);

+    local_98 = &local_280;

+    local_27c = *(uint *)(param_1 + 0xa8);

+    local_88 = &local_27c;

+    local_278 = *(undefined4 *)(param_1 + 0xac);

+    local_78 = &local_278;

+    local_68 = &local_238;

+    local_f0 = 4;

+    local_e0 = 4;

+    local_d0 = 4;

+    local_c0 = 4;

+    local_b0 = 1;

+    local_a0 = 4;

+    local_90 = 4;

+    local_80 = 4;

+    local_70 = 4;

+    local_238 = 0x1000000;

+    local_60 = 8;

+    local_264 = uVar12;

+    local_250 = uVar11;

+    uVar9 = IoGetActivityIdThread();

+    puVar10 = &DAT_7;

+    local_2a8 = 0x1c;

+  }

+  local_2a0 = local_218;

+  _tlgWriteTransfer_EtwWriteTransfer(&DAT_5,puVar10,uVar9,0);

+  return cVar4;

 }
```

## `RtlCopyFromUser`  (modified)

```diff
--- RtlCopyFromUser
+++ KeBugCheckEx
@@ -1,11 +1,16 @@
 

-void RtlCopyFromUser(void)

+void KeBugCheckEx(longlong param_1)

 

 {

-  code *pcVar1;

+  char *pcVar1;

+  char in_AL;

+  undefined6 in_register_00000002;

+  longlong unaff_RDI;

   

-  pcVar1 = (code *)swi(3);

-  (*pcVar1)();

+  pcVar1 = (char *)(unaff_RDI + 0x28 + param_1);

+  *pcVar1 = *pcVar1 + in_AL;

+  *(undefined1 *)CONCAT62(in_register_00000002,0x2400) =

+       *(undefined1 *)CONCAT62(in_register_00000002,0x2400);

   return;

 }
```

## `PspJobDelete`  (modified)

```diff
--- PspJobDelete
+++ PspJobDelete
@@ -1,13 +1,151 @@
 

-void PspJobDelete(void)

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+void PspJobDelete(longlong param_1)

 

 {

-  int unaff_ESI;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  void *pvVar6;

+  char cVar7;

+  undefined8 uVar8;

+  undefined1 auStack_a8 [48];

+  undefined8 local_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 uStack_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined4 local_28;

+  ulonglong local_20;

   

-  PspPostFreezeOperationWorkEnqueue();

-  if (((DAT_0 & 2) != 0) && (unaff_ESI != 0)) {

-    EtwTraceFreezeThawProcess();

+  pvVar6 = SystemReserved1[0xf];

+  local_20 = __security_cookie ^ (ulonglong)auStack_a8;

+  local_50 = 0;

+  local_28 = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_60 = 0;

+  uStack_58 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_78 = 0;

+  local_38 = 0;

+  uStack_30 = 0;

+  PspEmptyPropertySet(param_1 + 0x5e8);

+  PspJobDeleteStorageArrays(param_1);

+  if ((*(longlong *)(param_1 + 0x4d8) != 0) || (*(longlong *)(param_1 + 0x608) != 0)) {

+    PspLockRootJobExclusive(param_1,pvVar6,&local_78);

+    PspLockJobConditionally(param_1,&local_78);

+    if (*(longlong *)(param_1 + 0x4d8) != 0) {

+      PspRemoveCpuRateControl(param_1);

+    }

+    lVar2 = *(longlong *)(param_1 + 0x608);

+    if (lVar2 != 0) {

+      uStack_58 = 0;

+      uStack_68 = 0;

+      local_60 = 0;

+      local_50 = 4;

+      local_70 = *(undefined8 *)(lVar2 + 0x38);

+      PspNetRateControlDispatch(&local_70);

+      PspRemoveRateControl(param_1);

+    }

+    PspUnlockJobConditionally(param_1,&local_78);

+    PspUnlockJob(local_78,pvVar6);

   }

+  PspJobIoRateControlDisable(param_1);

+  if (*(longlong *)(param_1 + 0x630) != 0) {

+    PspLockRootJobExclusive(param_1,pvVar6,&local_78);

+    PspLockJobConditionally(param_1,&local_78);

+    if (*(longlong *)(param_1 + 0x630) != 0) {

+      PspRemoveIoAttribution(param_1);

+    }

+    PspUnlockJobConditionally(param_1,&local_78);

+    PspUnlockJob(local_78,pvVar6);

+  }

+  if (*(uint *)(param_1 + 0x240) < 0xfffffffe) {

+    cVar7 = IsWin32kJobNotifyCallOutPresent();

+    if ((cVar7 != '\0') && ((*(uint *)(param_1 + 0x610) & 0x10) != 0)) {

+      Win32kJobTerminateNotify(param_1);

+    }

+  }

+  *(undefined4 *)(param_1 + 0x100) = 0;

+  if (*(longlong *)(param_1 + 0x228) != 0) {

+    ObfDereferenceObjectWithTag(*(longlong *)(param_1 + 0x228),0x624a7350);

+    *(undefined8 *)(param_1 + 0x228) = 0;

+  }

+  if (*(longlong *)(param_1 + 0x210) != 0) {

+    SeReleaseSubjectContext(*(longlong *)(param_1 + 0x210) + 8);

+    ExFreePoolWithTag(*(undefined8 *)(param_1 + 0x210),0x614a7350);

+    PsReturnSharedPoolQuota(*(undefined8 *)(param_1 + 0x218),0x28);

+  }

+  PspLockJobListExclusive(pvVar6);

+  plVar1 = (longlong *)(param_1 + 0x18);

+  lVar2 = *plVar1;

+  if ((*(longlong **)(lVar2 + 8) == plVar1) &&

+     (plVar3 = *(longlong **)(param_1 + 0x20), (longlong *)*plVar3 == plVar1)) {

+    *plVar3 = lVar2;

+    *(longlong **)(lVar2 + 8) = plVar3;

+    PspUnlockJobListExclusive(pvVar6);

+    if (*(longlong *)(param_1 + 0x4c0) != 0) {

+      ExFreePoolWithTag(*(longlong *)(param_1 + 0x4c0),0x624a7350);

+      *(undefined8 *)(param_1 + 0x4c0) = 0;

+      PsReturnSharedPoolQuota(*(undefined8 *)(param_1 + 0x4c8),0x88,0);

+    }

+    if (*(longlong *)(param_1 + 0x4d0) != 0) {

+      IoFreeMiniCompletionPacket();

+    }

+    if ((*(uint *)(param_1 + 0x610) & 0x800) != 0) {

+      ZwDeleteWnfStateName(param_1 + 0x458);

+    }

+    PspGetJobLockHierarchyForDeletion(param_1,&local_48);

+    PspLockJobsAndProcessExclusive(&local_48,0,pvVar6,0);

+    plVar1 = (longlong *)(param_1 + 0x4f8);

+    plVar3 = (longlong *)*plVar1;

+    if (plVar3 != plVar1) {

+      if (((longlong *)plVar3[1] != plVar1) ||

+         (plVar4 = *(longlong **)(param_1 + 0x500), (longlong *)*plVar4 != plVar1))

+      goto LAB_0;

+      *plVar4 = (longlong)plVar3;

+      plVar3[1] = (longlong)plVar4;

+      *(longlong **)(param_1 + 0x500) = plVar1;

+      *plVar1 = (longlong)plVar1;

+      ObDereferenceObjectDeferDeleteWithTag(*(undefined8 *)(param_1 + 0x518),0x73507350);

+      *(undefined8 *)(param_1 + 0x518) = 0;

+    }

+    PspUnlockJobsAndProcessExclusive(&local_48,0,pvVar6);

+    ExDeleteResourceLite(param_1 + 0x38);

+    if ((*(longlong *)(param_1 + 0x538) != 0) && (*(longlong *)(param_1 + 0x540) != 0)) {

+      ExFreePoolWithTag(*(longlong *)(param_1 + 0x540),0x624a7350);

+      *(undefined8 *)(param_1 + 0x540) = 0;

+    }

+    if ((*(uint *)(param_1 + 0x610) & 0x40000000) != 0) {

+      PspDeleteSilo(param_1);

+    }

+    *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) =

+         *(short *)((longlong)SystemReserved1[0xf] + 0x1e4) + -1;

+    if (*(int *)(param_1 + 0x5bc) != 0) {

+      uVar8 = ExMapHandleToPointer(PspUniqueJobIdTable,*(int *)(param_1 + 0x5bc));

+      ExDestroyHandle(PspUniqueJobIdTable,*(undefined4 *)(param_1 + 0x5bc),uVar8);

+    }

+    KeLeaveCriticalRegion();

+    if (*(longlong *)(param_1 + 0x700) != 0) {

+      ObfDereferenceObjectWithTag(*(longlong *)(param_1 + 0x700),0x624a7350);

+    }

+    return;

+  }

+LAB_0:

+  pcVar5 = (code *)swi(0x29);

+  (*pcVar5)(3);

+  pcVar5 = (code *)swi(3);

+  (*pcVar5)();

   return;

 }
```

## `SeCaptureAtomTableCallout`  (modified)

```diff
--- SeCaptureAtomTableCallout
+++ SeCaptureAtomTableCallout
@@ -1,12 +1,49 @@
 

-undefined4 SeCaptureAtomTableCallout(void)

+void SeCaptureAtomTableCallout(void)

 

 {

-  undefined4 unaff_EBX;

-  longlong unaff_RSI;

-  undefined4 unaff_EDI;

+  ulonglong *puVar1;

+  longlong lVar2;

+  void *pvVar3;

+  longlong lVar4;

+  bool bVar5;

+  undefined1 local_res8 [8];

+  undefined1 local_res10 [8];

+  undefined1 local_res18 [8];

+  undefined8 local_28;

+  undefined8 uStack_20;

+  ulonglong local_18;

   

-  *(undefined4 *)(unaff_RSI * 3) = unaff_EBX;

-  return unaff_EDI;

+  pvVar3 = SystemReserved1[0xf];

+  local_18 = local_18 & 0xffffffff00000000;

+  local_28 = 0;

+  uStack_20 = 0;

+  lVar4 = PsReferenceEffectiveToken

+                    (SystemReserved1[0xf],0x74726853,local_res18,local_res8,local_res10,0);

+  if ((((*(uint *)(lVar4 + 200) & 0x4000) != 0) &&

+      (*(longlong *)(*(longlong *)(lVar4 + 0x438) + 0x30) == 0)) &&

+     ((lVar2 = *(longlong *)(*(longlong *)((longlong)pvVar3 + 0xb8) + 0x2a0), lVar2 == 0 ||

+      ((*(uint *)(lVar2 + 0x220) & 0x20) == 0)))) {

+    local_18 = 0;

+    local_28 = 0;

+    uStack_20 = 0;

+    PsInvokeWin32Callout(2,&local_28,0,0);

+    if (local_18 != 0) {

+      puVar1 = (ulonglong *)(*(longlong *)(lVar4 + 0x438) + 0x30);

+      LOCK();

+      bVar5 = *puVar1 == 0;

+      if (bVar5) {

+        *puVar1 = local_18;

+      }

+      UNLOCK();

+      if (bVar5) {

+        LOCK();

+        *(int *)(local_18 + 4) = *(int *)(local_18 + 4) + 1;

+        UNLOCK();

+      }

+    }

+  }

+  ObfDereferenceObjectWithTag(lVar4,0x74726853);

+  return;

 }
```

## `FsRtlpOpBatchBreakClosePending`  (modified)

```diff
--- FsRtlpOpBatchBreakClosePending
+++ FsRtlpOpBatchBreakClosePending
@@ -1,161 +1,50 @@
 

-/* WARNING: Instruction at (ram,0x00014070824e) overlaps instruction at (ram,0x00014070824c)

-    */

-/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

-

-undefined1 FsRtlpOpBatchBreakClosePending(undefined8 param_1,longlong param_2)

+undefined4 FsRtlpOpBatchBreakClosePending(longlong param_1,longlong param_2,longlong param_3)

 

 {

-  char *pcVar1;

-  undefined8 uVar2;

-  code *pcVar3;

-  longlong lVar4;

-  char cVar5;

-  undefined1 uVar6;

-  char *in_RAX;

-  longlong unaff_RBX;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  longlong unaff_R13;

-  undefined8 unaff_R14;

-  longlong unaff_R15;

-  bool in_ZF;

-  longlong unaff_retaddr;

-  undefined1 local_res8 [32];

-  longlong in_stack_00000068;

+  uint uVar1;

+  undefined4 uVar2;

+  undefined4 local_res20;

   

-  if (in_ZF) {

-    if ((((in_ZF) || (cVar5 = *(char *)(unaff_R15 + 5), cVar5 == '\0')) ||

-        (0x7fffffffffffffff - unaff_RDI < in_stack_00000068)) ||

-       (*(longlong *)(unaff_R15 + 0x18) < unaff_RBX)) goto LAB_0;

-    if (((char)param_2 != '\0') && (*(longlong *)(unaff_R15 + 0x28) < unaff_RBX))

-    goto code_r0x00014070825c;

+  uVar2 = 0;

+  local_res20 = 0;

+  if (param_1 == 0) {

+    *(undefined4 *)(param_3 + 0x30) = 0xc00000e3;

+    IofCompleteRequest(param_3,1);

+    uVar2 = 0xc00000e3;

   }

   else {

-    pcVar1 = (char *)(param_2 * 9 + 0x3b495974);

-    *pcVar1 = *pcVar1 + (char)in_RAX + *in_RAX;

-    register0x00000020 = (BADSPACEBASE *)local_res8;

-    *(char *)(unaff_RSI + 0x53) = *(char *)(unaff_RSI + 0x53) - (char)((ulonglong)unaff_RBX >> 8);

-    unaff_RDI = unaff_retaddr;

-code_r0x00014070825c:

-    uVar2 = *(undefined8 *)(unaff_R15 + 8);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708265;

-    ExReleaseResourceLite(uVar2);

-    uVar2 = *(undefined8 *)(unaff_R15 + 8);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708270;

-    ExAcquireResourceExclusiveLite(uVar2,1);

-    if (*(char *)((longlong)register0x00000020 + 0x52) != (char)unaff_RSI) {

-      unaff_RDI = *(longlong *)(unaff_R15 + 0x20);

-      *(longlong *)((longlong)register0x00000020 + 0x60) = unaff_RDI;

-      unaff_RBX = (ulonglong)*(uint *)((longlong)register0x00000020 + 0xe0) + unaff_RDI;

-      *(longlong *)((longlong)register0x00000020 + 0x58) = unaff_RBX;

-    }

-    if (((*(longlong *)(unaff_R13 + 0x30) == unaff_RSI) ||

-        (cVar5 = *(char *)(unaff_R15 + 5), cVar5 == '\0')) ||

-       (*(longlong *)(unaff_R15 + 0x18) < unaff_RBX)) goto LAB_0;

-  }

-  if (cVar5 == '\x02') {

-    pcVar3 = *(code **)(*(longlong *)

-                         (*(longlong *)(*(longlong *)((longlong)register0x00000020 + 0x100) + 8) +

-                         0x50) + 8);

-    *(longlong *)((longlong)register0x00000020 + 0x38) =

-         *(longlong *)((longlong)register0x00000020 + 0x100);

-    *(undefined8 *)((longlong)register0x00000020 + 0x30) =

-         *(undefined8 *)((longlong)register0x00000020 + 0xf8);

-    *(char *)((longlong)register0x00000020 + 0x28) = (char)unaff_RSI;

-    *(undefined4 *)((longlong)register0x00000020 + 0x20) =

-         *(undefined4 *)((longlong)register0x00000020 + 0xe8);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708305;

-    cVar5 = (*pcVar3)();

-    if (cVar5 == '\0') {

-LAB_0:

-      uVar2 = *(undefined8 *)(unaff_R15 + 8);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708489;

-      ExReleaseResourceLite(uVar2);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14070848e;

-      KeLeaveCriticalRegion();

-      return 0;

-    }

-  }

-  lVar4 = *(longlong *)(unaff_R15 + 0x20);

-  if (lVar4 < unaff_RBX) {

-    *(undefined1 *)((longlong)register0x00000020 + 0x51) = 1;

-    *(longlong *)((longlong)register0x00000020 + 0x70) = lVar4;

-    unaff_R14 = *(undefined8 *)(unaff_R15 + 0x28);

-    *(undefined8 *)((longlong)register0x00000020 + 0x78) = unaff_R14;

-    unaff_RSI = lVar4;

-    if ((*(int *)(unaff_R15 + 0x24) == *(int *)((longlong)register0x00000020 + 0x5c)) ||

-       (lVar4 = *(longlong *)(unaff_R15 + 0x10), lVar4 == 0)) {

-      *(longlong *)(unaff_R15 + 0x20) = unaff_RBX;

+    ExAcquireFastMutexUnsafe(*(undefined8 *)(param_1 + 0x98));

+    if ((*(longlong *)(param_1 + 8) == *(longlong *)(param_2 + 0x30)) &&

+       (uVar1 = *(uint *)(param_1 + 0x90), (uVar1 & 0x700) != 0)) {

+      if ((uVar1 & 0x82) == 0) {

+        *(uint *)(param_1 + 0x90) = uVar1 & 0xfe0ff0ff;

+        *(uint *)(param_1 + 0x90) = uVar1 & 0xfe0ff0ff | 0x800;

+      }

+      else {

+        FsRtlpModifyThreadPriorities(param_1,0,0);

+        FsRtlpClearOwner(param_1,0);

+        *(undefined1 *)(param_1 + 0x20) = 0;

+        if ((*(uint *)(param_1 + 0x90) & 2) != 0) {

+          ObfDereferenceObject(*(undefined8 *)(param_1 + 8));

+        }

+        *(uint *)(param_1 + 0x90) = *(uint *)(param_1 + 0x90) & 0x20 | 1;

+        *(undefined8 *)(param_1 + 8) = 0;

+        while (*(longlong **)(param_1 + 0x58) != (longlong *)(param_1 + 0x58)) {

+          FsRtlpRemoveAndCompleteWaitingIrp();

+        }

+        FsRtlpSyncWithAckTimeout(param_1 + 0xb0);

+        FsRtlpOplockPerfSendData(param_1 + 0xa0);

+        uVar2 = local_res20;

+      }

     }

     else {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708346;

-      ExAcquireResourceExclusiveLite(lVar4,1);

-      *(longlong *)(unaff_R15 + 0x20) = unaff_RBX;

-      uVar2 = *(undefined8 *)(unaff_R15 + 0x10);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708353;

-      ExReleaseResourceLite(uVar2);

+      uVar2 = 0xc00000e3;

     }

+    *(undefined4 *)(param_3 + 0x30) = uVar2;

+    IofCompleteRequest(param_3,1);

+    ExReleaseFastMutexUnsafe(*(undefined8 *)(param_1 + 0x98));

   }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708363;

-  IoSetTopLevelIrp(4);

-  if (*(longlong *)(unaff_R15 + 0x28) < unaff_RDI) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14070837d;

-    uVar6 = CcZeroData();

-    *(undefined1 *)((longlong)register0x00000020 + 0x50) = uVar6;

-  }

-  if (*(char *)((longlong)register0x00000020 + 0x50) != '\0') {

-    *(undefined8 *)((longlong)register0x00000020 + 0x20) =

-         *(undefined8 *)((longlong)register0x00000020 + 0xf8);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1407083b2;

-    CcPrepareMdlWrite();

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1407083df;

-  IoSetTopLevelIrp(0);

-  if (*(char *)((longlong)register0x00000020 + 0x50) == '\0') {

-    if (*(char *)((longlong)register0x00000020 + 0x51) != '\0') {

-      lVar4 = *(longlong *)(unaff_R15 + 0x10);

-      if (lVar4 == 0) {

-        *(longlong *)(unaff_R15 + 0x20) = unaff_RSI;

-        *(undefined8 *)(unaff_R15 + 0x28) = unaff_R14;

-      }

-      else {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708451;

-        ExAcquireResourceExclusiveLite(lVar4,1);

-        *(longlong *)(unaff_R15 + 0x20) = unaff_RSI;

-        *(undefined8 *)(unaff_R15 + 0x28) = unaff_R14;

-        uVar2 = *(undefined8 *)(unaff_R15 + 0x10);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708462;

-        ExReleaseResourceLite(uVar2);

-      }

-    }

-  }

-  else {

-    if (*(longlong *)(unaff_R15 + 0x28) < unaff_RBX) {

-      if ((*(int *)(unaff_R15 + 0x2c) == *(int *)((longlong)register0x00000020 + 0x5c)) ||

-         (lVar4 = *(longlong *)(unaff_R15 + 0x10), lVar4 == 0)) {

-        *(longlong *)(unaff_R15 + 0x28) = unaff_RBX;

-      }

-      else {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708406;

-        ExAcquireResourceExclusiveLite(lVar4,1);

-        *(longlong *)(unaff_R15 + 0x28) = unaff_RBX;

-        uVar2 = *(undefined8 *)(unaff_R15 + 0x10);

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708413;

-        ExReleaseResourceLite(uVar2);

-      }

-    }

-    *(uint *)(unaff_R13 + 0x50) = *(uint *)(unaff_R13 + 0x50) | 0x1000;

-    if (*(char *)((longlong)register0x00000020 + 0x51) != '\0') {

-      *(longlong *)(*(longlong *)(*(longlong *)(unaff_R13 + 0x28) + 8) + 8) = unaff_RBX;

-      *(uint *)(unaff_R13 + 0x50) = *(uint *)(unaff_R13 + 0x50) | 0x2000;

-    }

-  }

-  uVar2 = *(undefined8 *)(unaff_R15 + 8);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140708475;

-  ExReleaseResourceLite(uVar2);

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14070847a;

-  KeLeaveCriticalRegion();

-  return *(undefined1 *)((longlong)register0x00000020 + 0x50);

+  return uVar2;

 }
```

## `FsRtlpRemoveAndCompleteRHIrp`  (modified)

```diff
--- FsRtlpRemoveAndCompleteRHIrp
+++ FsRtlpAcknowledgeOplockBreakByCacheFlags
@@ -1,148 +1,541 @@
 

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-undefined1

-FsRtlpRemoveAndCompleteRHIrp

-          (longlong param_1,longlong param_2,uint param_3,uint param_4,uint param_5,

-          undefined4 param_6,ushort param_7,char param_8)

+undefined4

+FsRtlpAcknowledgeOplockBreakByCacheFlags

+          (longlong param_1,undefined8 param_2,longlong param_3,uint param_4,undefined8 param_5,

+          undefined4 param_6)

 

 {

-  longlong lVar1;

-  undefined4 *puVar2;

-  bool bVar3;

-  undefined1 uVar4;

-  undefined8 uVar5;

-  undefined1 auStack_138 [32];

-  undefined4 local_118;

-  undefined1 *local_110;

-  undefined1 local_108;

-  undefined4 local_104;

-  uint local_100;

-  uint local_fc;

-  uint local_f8;

-  uint local_f4;

-  undefined4 local_f0;

-  uint local_ec;

-  longlong local_e8 [2];

-  undefined1 local_d8 [32];

-  uint *local_b8;

-  undefined8 local_b0;

-  uint *local_a8;

-  undefined8 local_a0;

-  uint *local_98;

-  undefined8 local_90;

-  undefined4 *local_88;

-  undefined8 local_80;

-  uint *local_78;

-  undefined8 local_70;

-  longlong *local_68;

-  undefined8 local_60;

-  undefined4 *local_58;

-  undefined8 local_50;

+  byte *pbVar1;

+  longlong lVar2;

+  undefined8 uVar3;

+  code *pcVar4;

+  bool bVar5;

+  void *pvVar6;

+  char cVar7;

+  undefined1 uVar8;

+  undefined4 uVar9;

+  uint uVar10;

+  longlong *plVar11;

+  longlong lVar12;

+  longlong *plVar13;

+  longlong *plVar14;

+  uint uVar15;

+  undefined1 *puVar16;

+  undefined1 *puVar17;

+  char cVar18;

+  undefined8 *puVar19;

+  undefined8 uVar20;

+  longlong *plVar21;

+  longlong *plVar22;

+  uint uVar23;

+  int iVar24;

+  undefined8 uStack_280;

+  undefined1 auStack_278 [32];

+  undefined8 local_258;

+  undefined1 *local_250;

+  longlong local_248 [3];

+  undefined4 local_230 [2];

+  longlong local_228;

+  bool local_220 [4];

+  undefined4 uStack_21c;

+  char local_218 [8];

+  longlong *local_210;

+  undefined1 local_208;

+  undefined1 uStack_207;

+  undefined4 uStack_1fc;

+  longlong local_1f8 [3];

+  undefined4 local_1e0 [6];

+  uint local_1c8 [2];

+  longlong local_1c0 [4];

+  longlong local_1a0;

+  undefined1 local_138 [32];

+  uint *local_118 [26];

   ulonglong local_48;

+  longlong *plVar25;

   

-  local_48 = __security_cookie ^ (ulonglong)auStack_138;

-  uVar5 = 0;

-  local_108 = 1;

-  local_100 = param_4;

+  puVar17 = auStack_278;

+  puVar16 = auStack_278;

+  local_48 = __security_cookie ^ (ulonglong)auStack_278;

+  local_1f8[2] = param_5;

+  plVar11 = (longlong *)0x0;

+  uStack_21c = 0;

+  local_210 = (longlong *)0x0;

+  local_218[0] = 0;

+  local_218[4] = 0;

+  local_208 = 0;

+  local_218[1] = 0;

+  bVar5 = false;

+  uStack_207 = 0;

+  local_218[3] = 0;

+  local_218[2] = 0;

+  local_228 = param_1;

+  local_1f8[0] = param_2;

   if (5 < DAT_0) {

-    local_b8 = &local_fc;

-    local_a8 = &local_f8;

-    local_98 = &local_f4;

-    local_f0 = param_6;

-    local_88 = &local_f0;

-    local_ec = (uint)param_7;

-    local_78 = &local_ec;

-    local_68 = local_e8;

-    local_104 = *(undefined4 *)(param_2 + 0x90);

-    local_58 = &local_104;

-    local_110 = local_d8;

-    local_118 = 9;

-    local_b0 = 4;

-    local_a0 = 4;

-    local_f4 = param_5;

-    local_90 = 4;

-    local_80 = 4;

-    local_70 = 4;

-    local_60 = 8;

-    local_50 = 4;

-    local_fc = param_3;

-    local_f8 = param_4;

-    local_e8[0] = param_2;

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043e10,0,0);

+    local_118[0] = local_1c8;

+    local_118[1] = (uint *)0x4;

+    local_1e0[0] = param_6;

+    local_118[2] = local_1e0;

+    local_118[3] = (uint *)0x4;

+    local_118[4] = (uint *)local_1c0;

+    local_118[5] = (uint *)0x8;

+    uStack_1fc = *(undefined4 *)(param_1 + 0x90);

+    local_118[6] = &uStack_1fc;

+    local_118[7] = (uint *)0x4;

+    local_250 = local_138;

+    local_258._0_4_ = 6;

+    local_1c8[0] = param_4;

+    local_1c0[0] = param_1;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044a39,0,0);

   }

-  lVar1 = *(longlong *)(param_1 + 0x10);

-  *(undefined8 *)(param_1 + 0x10) = 0;

-  uVar4 = KeAcquireQueuedSpinLock(7);

-  *(undefined1 *)(lVar1 + 0x45) = uVar4;

-  LOCK();

-  *(undefined8 *)(lVar1 + 0x68) = 0;

-  UNLOCK();

-  KeReleaseQueuedSpinLock(7,*(undefined1 *)(lVar1 + 0x45));

-  FsRtlpOplockDequeueRH(param_1);

-  bVar3 = false;

-  if (*(char *)(lVar1 + 0x44) == '\0') {

-    puVar2 = *(undefined4 **)(lVar1 + 0x18);

-    *(undefined8 *)(puVar2 + 4) = 0;

-    uVar5 = 0x18;

-    *puVar2 = 0x180001;

-    puVar2[1] = 3;

-    puVar2[2] = local_100 >> 0xc & 7;

-    puVar2[3] = param_5;

-    if ((param_5 & 2) != 0) {

-      puVar2[4] = param_6;

-      *(ushort *)(puVar2 + 5) = param_7;

+  if (local_228 == 0) {

+    *(undefined4 *)(param_3 + 0x30) = 0xc00000e3;

+    IofCompleteRequest(param_3,1);

+    uVar9 = 0xc00000e3;

+    goto LAB_1;

+  }

+  ExAcquireFastMutexUnsafe(*(undefined8 *)(local_228 + 0x98));

+  uVar23 = *(uint *)(local_228 + 0x90);

+  if ((((uVar23 & 0xf00000) == 0) &&

+      (puVar17 = auStack_278, plVar14 = plVar11, ((uVar23 & 0x1f0ffdf) - 0x3000 & 0xffff7fff) != 0))

+     || ((((uVar23 & 0x1f0ffdf) - 0x3000 & 0xffff7fff) == 0 &&

+         (puVar17 = auStack_278, plVar14 = (longlong *)0x0,

+         *(longlong **)(local_228 + 0x48) == (longlong *)(local_228 + 0x48))))) {

+LAB_2:

+    *(undefined4 *)(puVar17 + 0x5c) = 0xc00000e3;

+    *(undefined4 *)(param_3 + 0x30) = 0xc00000e3;

+    *(undefined8 *)(puVar17 + -8) = 0x1404daba5;

+    IofCompleteRequest(param_3,1);

+    plVar11 = plVar14;

+  }

+  else {

+    local_1a0 = *(longlong *)(param_3 + 0x18);

+    uVar23 = *(uint *)(*(longlong *)(param_3 + 0x18) + 8) & 4;

+    plVar25 = (longlong *)(ulonglong)uVar23;

+    local_220[0] = uVar23 != 0;

+    if (uVar23 != 0) {

+      plVar11 = (longlong *)ExAllocatePool2(0x120,0x30,0x6f725346);

+      local_210 = plVar11;

     }

-    if ((param_5 & 1) == 0) {

-      ObfDereferenceObjectWithTag(*(undefined8 *)(param_1 + 0x18),0x746c6644);

-      if (*(longlong *)(param_1 + 0x28) != 0) {

-        FsRtlpClearOwner(param_2,param_1);

+    plVar22 = (longlong *)0x0;

+    uVar15 = *(uint *)(local_228 + 0x90) & 0x1f0ffdf;

+    uVar20 = 0x307040;

+    cVar18 = '\x01';

+    plVar14 = plVar11;

+    if (0x307040 < uVar15) goto LAB_3;

+    puVar17 = auStack_278;

+    if (uVar15 == 0x307040) goto LAB_4;

+    if (((uVar15 - 0x3000 & 0xffef7fff) != 0) || (puVar17 = auStack_278, uVar15 == 0x10b000)) {

+      puVar17 = auStack_278;

+      for (uVar15 = uVar15 - 0x105040; (uVar15 & 0xffffdfff) == 0; uVar15 = uVar15 - 0x805040) {

+LAB_4:

+        do {

+          iVar24 = (int)plVar25;

+          uVar23 = (uint)uVar20;

+          if (iVar24 == 0) {

+LAB_5:

+            uVar15 = uVar23;

+            if (*(longlong *)(*(longlong *)(puVar17 + 0x50) + 8) !=

+                *(longlong *)(*(longlong *)(puVar17 + 0x80) + 0x30)) goto LAB_2;

+            if (iVar24 != 0) goto LAB_6;

+LAB_7:

+            uVar23 = *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90);

+            uVar10 = uVar23 & 0x1f0ffdf;

+            if ((((((uVar10 == 0x105040) || (uVar10 == 0x107040)) || (uVar10 == uVar15)) ||

+                 ((uVar10 == 0x507040 || (uVar10 == 0x805040)))) || (uVar10 == 0x807040)) &&

+               ((((uVar23 >> 1 & 0x200000 | uVar23 & 0x100000) >> 1 | uVar23 & 0x200000) >> 7 <

+                 (param_4 & 0x7000) &&

+                (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) !=

+                 (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58))))) {

+              bVar5 = true;

+            }

+            if (bVar5) {

+              puVar19 = *(undefined8 **)(param_3 + 0x18);

+              *puVar19 = 0;

+              puVar19[1] = 0;

+              puVar19[2] = 0;

+              *(uint *)((longlong)puVar19 + 4) =

+                   *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) >> 0xc & 7;

+              uVar23 = *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90);

+              *(uint *)(puVar19 + 1) =

+                   ((uVar23 >> 1 & 0x200000 | uVar23 & 0x100000) >> 1 | uVar23 & 0x200000) >> 0x13;

+              *(uint *)((longlong)puVar19 + 0xc) = *(uint *)((longlong)puVar19 + 0xc) | 1;

+              *(undefined8 *)(param_3 + 0x38) = 0x18;

+              *(undefined4 *)(param_3 + 0x30) = 0x8000002e;

+              *(undefined8 *)(puVar17 + -8) = 0x1404db4a3;

+              IofCompleteRequest(param_3,1);

+              *(undefined4 *)(puVar17 + 0x5c) = 0x8000002e;

+              goto LAB_8;

+            }

+            *(undefined8 *)(puVar17 + -8) = 0x1404db4bb;

+            FsRtlpModifyThreadPriorities(*(undefined8 *)(puVar17 + 0x50),0,0);

+            *(undefined8 *)(puVar17 + -8) = 0x1404db4c7;

+            FsRtlpClearOwner(*(undefined8 *)(puVar17 + 0x50),0);

+            *(undefined1 *)(*(longlong *)(puVar17 + 0x50) + 0x20) = 0;

+            *(undefined4 *)(puVar17 + 0x48) = *(undefined4 *)(puVar17 + 0x2a8);

+            *(undefined1 **)(puVar17 + 0x40) = puVar17 + 99;

+            *(undefined1 **)(puVar17 + 0x38) = puVar17 + 0x62;

+            *(undefined1 **)(puVar17 + 0x30) = puVar17 + 0x68;

+            puVar17[0x28] = puVar17[0x58];

+            *(undefined8 *)(puVar17 + 0x20) = *(undefined8 *)(puVar17 + 0x90);

+            *(undefined8 *)(puVar17 + -8) = 0x1404db526;

+            uVar9 = FsRtlpGrantAnyOplockFromExclusive

+                              (*(undefined8 *)(puVar17 + 0x50),param_3,

+                               *(undefined8 *)(puVar17 + 0x80),param_4);

+            *(undefined4 *)(puVar17 + 0x5c) = uVar9;

+            plVar25 = *(longlong **)(puVar17 + 0x68);

+            goto LAB_9;

+          }

+          lVar12 = *(longlong *)(*(longlong *)(puVar17 + 0x50) + 8);

+          lVar2 = *(longlong *)(*(longlong *)(puVar17 + 0x80) + 0x30);

+          if (lVar12 == lVar2) goto LAB_2;

+          *(undefined8 *)(puVar17 + -8) = 0x1404dac5d;

+          cVar7 = FsRtlpOplockKeysEqual(lVar2,lVar12,0);

+          if (cVar7 == '\0') goto LAB_2;

+          uVar15 = 0x307040;

+          uVar23 = 0x307040;

+          if (iVar24 == 0) goto LAB_5;

+LAB_6:

+          plVar25 = (longlong *)0x0;

+          if (param_4 != 0) goto LAB_7;

+          uVar20 = 0;

+          *(undefined8 *)(puVar17 + -8) = 0x1404dacaf;

+          FsRtlpModifyThreadPriorities(*(undefined8 *)(puVar17 + 0x50),0);

+          *(undefined8 *)(puVar17 + -8) = 0x1404dacbb;

+          FsRtlpClearOwner(*(undefined8 *)(puVar17 + 0x50),0);

+          *(undefined1 *)(*(longlong *)(puVar17 + 0x50) + 0x20) = 0;

+          *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) =

+               *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) & 0x20 | 1;

+          plVar21 = *(longlong **)(puVar17 + 0x68);

+          plVar21[2] = *(longlong *)(*(longlong *)(puVar17 + 0x50) + 8);

+          *(undefined8 *)(puVar17 + -8) = 0x1404dad06;

+          FsRtlpOplockPerfMoveData(*(longlong *)(puVar17 + 0x50) + 0xa0,plVar21 + 3);

+          uVar15 = (uint)(plVar21 + 5);

+          *(undefined8 *)(puVar17 + -8) = 0x1404dad1b;

+          FsRtlpOplockMoveAckTimeout(*(longlong *)(puVar17 + 0x50) + 0xb0);

+          plVar13 = (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x68);

+          lVar12 = *plVar13;

+          if (*(longlong **)(lVar12 + 8) == plVar13) {

+            *plVar21 = lVar12;

+            plVar21[1] = (longlong)plVar13;

+            *(longlong **)(lVar12 + 8) = plVar21;

+            *plVar13 = (longlong)plVar21;

+            if (5 < DAT_0) {

+              *(longlong *)(puVar17 + 0xb8) = plVar21[2];

+              *(undefined1 **)(puVar17 + 0x160) = puVar17 + 0xb8;

+              *(undefined8 *)(puVar17 + 0x168) = 8;

+              *(longlong *)(puVar17 + 0x90) = *(longlong *)(puVar17 + 0x50);

+              *(undefined1 **)(puVar17 + 0x170) = puVar17 + 0x90;

+              *(undefined8 *)(puVar17 + 0x178) = 8;

+              *(undefined4 *)(puVar17 + 0x7c) =

+                   *(undefined4 *)(*(longlong *)(puVar17 + 0x50) + 0x90);

+              *(undefined1 **)(puVar17 + 0x180) = puVar17 + 0x7c;

+              *(undefined8 *)(puVar17 + 0x188) = 4;

+              *(undefined1 **)(puVar17 + 0x28) = puVar17 + 0x140;

+              *(undefined4 *)(puVar17 + 0x20) = 5;

+              *(undefined8 *)(puVar17 + -8) = 0x1404db372;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044b28,0,0);

+            }

+            *(undefined8 *)(puVar17 + 0x68) = 0;

+            *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 8) = 0;

+            *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) =

+                 *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) | 0x1000000;

+            *(undefined4 *)(param_3 + 0x30) = 0;

+            *(undefined8 *)(puVar17 + -8) = 0x1404db3a7;

+            IofCompleteRequest(param_3,1);

+            goto LAB_9;

+          }

+          pcVar4 = (code *)swi(0x29);

+          (*pcVar4)(3);

+          puVar16 = puVar17 + 8;

+LAB_3:

+          uVar23 = (uint)plVar25;

+          puVar17 = puVar16;

+        } while (uVar15 == 0x507040);

+        if (uVar15 == 0x803000) goto LAB_10;

       }

-      bVar3 = true;

-      uVar4 = local_108;

+      goto LAB_2;

     }

-    else {

-      *(uint *)(param_1 + 0x30) =

-           (-(uint)(local_100 != 0) & 0xff900000) + 0x800000 |

-           *(uint *)(param_1 + 0x30) & 0xff0fffff;

-      FsRtlpOplockEnqueueRH(param_2 + 0x48,param_1);

-      FsRtlpModifyThreadPriorities(param_2,param_1,1);

-      FsRtlpOplockSendModernAppTermination(param_2,param_1);

-      uVar4 = local_108;

+LAB_10:

+    for (puVar19 = *(undefined8 **)(*(longlong *)(puVar17 + 0x50) + 0x48);

+        *(undefined8 **)(puVar17 + 0x88) = puVar19, plVar25 = plVar11,

+        puVar19 != (undefined8 *)(*(longlong *)(puVar17 + 0x50) + 0x48);

+        puVar19 = (undefined8 *)*puVar19) {

+      if (uVar23 == 0) {

+        if (puVar19[3] == *(longlong *)(*(longlong *)(puVar17 + 0x80) + 0x30)) {

+LAB_11:

+          puVar17[0x60] = 1;

+          uVar9 = *(undefined4 *)(puVar17 + 0x2a8);

+          if ((*(uint *)(puVar19 + 6) & 0xf00000) == 0x800000) {

+            if (param_4 != 0) {

+              if (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) ==

+                  (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58)) {

+                *(undefined8 *)(puVar17 + -8) = 0x1404dae00;

+                cVar7 = FsRtlpOplockUpperLowerCompatible(param_4,uVar9);

+                if (cVar7 != '\0') goto LAB_12;

+              }

+              puVar19 = *(undefined8 **)(param_3 + 0x18);

+              *puVar19 = 0;

+              puVar19[1] = 0;

+              puVar19[2] = 0;

+              *(undefined4 *)((longlong)puVar19 + 4) = 3;

+              if (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) !=

+                  (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58)) {

+                uVar9 = 0;

+              }

+              *(undefined4 *)(puVar19 + 1) = uVar9;

+              *(uint *)((longlong)puVar19 + 0xc) = *(uint *)((longlong)puVar19 + 0xc) | 1;

+              *(undefined8 *)(param_3 + 0x38) = 0x18;

+              *(undefined4 *)(param_3 + 0x30) = 0x8000002e;

+              *(undefined8 *)(puVar17 + -8) = 0x1404dae5c;

+              IofCompleteRequest(param_3,1);

+              *(undefined4 *)(puVar17 + 0x5c) = 0x8000002e;

+              cVar18 = '\x01';

+              goto LAB_13;

+            }

+          }

+          else if (((*(uint *)(puVar19 + 6) & 0xf00000) == 0x100000) &&

+                  (0x3000 < (param_4 & 0x7000))) {

+            if (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) ==

+                (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58)) {

+              *(undefined8 *)(puVar17 + -8) = 0x1404dae9b;

+              cVar7 = FsRtlpOplockUpperLowerCompatible(param_4,uVar9);

+              if (cVar7 != '\0') goto LAB_12;

+            }

+            puVar19 = *(undefined8 **)(param_3 + 0x18);

+            *puVar19 = 0;

+            puVar19[1] = 0;

+            puVar19[2] = 0;

+            *(undefined4 *)((longlong)puVar19 + 4) = 3;

+            if (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) !=

+                (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58)) {

+              uVar9 = 1;

+            }

+            *(undefined4 *)(puVar19 + 1) = uVar9;

+            *(uint *)((longlong)puVar19 + 0xc) = *(uint *)((longlong)puVar19 + 0xc) | 1;

+            *(undefined8 *)(param_3 + 0x38) = 0x18;

+            *(undefined4 *)(param_3 + 0x30) = 0x8000002e;

+            *(undefined8 *)(puVar17 + -8) = 0x1404daeed;

+            IofCompleteRequest(param_3,1);

+            *(undefined4 *)(puVar17 + 0x5c) = 0x8000002e;

+            goto LAB_13;

+          }

+LAB_12:

+          *(undefined8 *)(puVar17 + -8) = 0x1404daf01;

+          FsRtlpOplockDequeueRH(puVar19);

+          if (uVar23 == 0) {

+            puVar17[0x61] = 1;

+            if (param_4 == 0) {

+              uVar3 = puVar19[3];

+              *(undefined8 *)(puVar17 + -8) = 0x1404db02d;

+              ObfDereferenceObjectWithTag(uVar3,0x746c6644);

+              goto LAB_14;

+            }

+LAB_15:

+            if (((param_4 & 0x3010) == 0) || ((param_4 & 0x4040) != 0)) {

+              **(longlong **)(puVar17 + 0x50) = param_3;

+              pbVar1 = (byte *)(*(longlong *)(param_3 + 0xb8) + 3);

+              *pbVar1 = *pbVar1 | 1;

+              *(undefined4 *)(puVar17 + 0x5c) = 0x103;

+              *(undefined8 *)(param_3 + 0x38) = *(undefined8 *)(puVar17 + 0x50);

+              *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 0x10) =

+                   *(undefined8 *)((longlong)SystemReserved1[0xf] + 0xb8);

+              pvVar6 = SystemReserved1[0xf];

+              *(void **)(puVar17 + 0xe0) = SystemReserved1[0xf];

+              *(void **)(*(longlong *)(puVar17 + 0x50) + 0x18) = SystemReserved1[0xf];

+              *(undefined8 *)(puVar17 + -8) = 0x1404db12d;

+              ObfReferenceObjectWithTag(pvVar6,0x746c6644);

+              *(undefined1 *)(*(longlong *)(puVar17 + 0x50) + 0x20) = 0;

+              if (uVar23 == 0) {

+                lVar12 = *(longlong *)(puVar17 + 0x88);

+                *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 8) = *(undefined8 *)(lVar12 + 0x18);

+              }

+              else {

+                lVar12 = *(longlong *)(puVar17 + 0x80);

+                uVar3 = *(undefined8 *)(lVar12 + 0x30);

+                *(undefined8 *)(puVar17 + -8) = 0x1404db151;

+                ObfReferenceObjectWithTag(uVar3,0x746c6644);

+                *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 8) = *(undefined8 *)(lVar12 + 0x30);

+                lVar12 = *(longlong *)(puVar17 + 0x88);

+              }

+              *(undefined8 *)(puVar17 + -8) = 0x1404db192;

+              FsRtlpOplockPerfMoveData(lVar12 + 0x48,*(longlong *)(puVar17 + 0x50) + 0xa0);

+              *(undefined8 *)(puVar17 + -8) = 0x1404db1a7;

+              FsRtlpOplockMoveAckTimeout(lVar12 + 0x58,*(longlong *)(puVar17 + 0x50) + 0xb0);

+              *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) =

+                   param_4 | *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) & 0x20 | 0x40;

+              *(undefined8 *)(puVar17 + -8) = 0x1404db1d2;

+              uVar8 = KeAcquireQueuedSpinLock(7);

+              *(undefined1 *)(param_3 + 0x45) = uVar8;

+              if (*(char *)(param_3 + 0x44) == '\0') {

+                LOCK();

+                *(code **)(param_3 + 0x68) = FsRtlpExclusiveIrpCancelRoutine;

+                UNLOCK();

+                uVar8 = *(undefined1 *)(param_3 + 0x45);

+                *(undefined8 *)(puVar17 + -8) = 0x1404db208;

+                KeReleaseQueuedSpinLock(7,uVar8);

+              }

+              else {

+                *(undefined8 *)(puVar17 + -8) = 0x1404db1ee;

+                FsRtlpCancelExclusiveIrp

+                          (param_3,1,CONCAT71((int7)((ulonglong)uVar20 >> 8),puVar17[0x58]) ^ 1);

+              }

+              puVar19 = *(undefined8 **)(puVar17 + 0x88);

+              plVar11 = *(longlong **)(puVar17 + 0x68);

+            }

+            else {

+              plVar14 = *(longlong **)(puVar17 + 0x90);

+              if (plVar14 != (longlong *)0x0) {

+                lVar12 = *plVar14;

+                *(undefined8 *)(puVar17 + -8) = 0x1404db084;

+                FsRtlpOplockPerfMoveData(puVar19 + 9,lVar12 + 0x48);

+                lVar12 = *plVar14;

+                *(undefined8 *)(puVar17 + -8) = 0x1404db094;

+                FsRtlpOplockMoveAckTimeout(puVar19 + 0xb,lVar12 + 0x58);

+              }

+              *(undefined4 *)(puVar17 + 0x38) = uVar9;

+              puVar17[0x30] = 1;

+              puVar17[0x28] = puVar17[0x58];

+              *(longlong **)(puVar17 + 0x20) = plVar14;

+              *(undefined8 *)(puVar17 + -8) = 0x1404db0c3;

+              uVar9 = FsRtlpRequestShareableOplock

+                                (puVar17 + 0x50,*(undefined8 *)(puVar17 + 0x80),param_3,param_4);

+              *(undefined4 *)(puVar17 + 0x5c) = uVar9;

+            }

+          }

+          else {

+            plVar11[2] = puVar19[3];

+            *(undefined8 *)(puVar17 + -8) = 0x1404daf1f;

+            FsRtlpOplockPerfMoveData(puVar19 + 9,plVar11 + 3);

+            *(undefined8 *)(puVar17 + -8) = 0x1404daf2c;

+            FsRtlpOplockMoveAckTimeout(puVar19 + 0xb,plVar11 + 5);

+            plVar14 = (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x68);

+            lVar12 = *plVar14;

+            if (*(longlong **)(lVar12 + 8) != plVar14) {

+              plVar14 = (longlong *)0x3;

+              pcVar4 = (code *)swi(0x29);

+              lVar12 = (*pcVar4)();

+              puVar17 = puVar17 + 8;

+            }

+            *plVar11 = lVar12;

+            plVar11[1] = (longlong)plVar14;

+            *(longlong **)(lVar12 + 8) = plVar11;

+            *plVar14 = (longlong)plVar11;

+            if (5 < DAT_0) {

+              *(longlong *)(puVar17 + 0xc0) = plVar11[2];

+              *(undefined1 **)(puVar17 + 0x1c0) = puVar17 + 0xc0;

+              *(undefined8 *)(puVar17 + 0x1c8) = 8;

+              *(longlong *)(puVar17 + 200) = *(longlong *)(puVar17 + 0x50);

+              *(undefined1 **)(puVar17 + 0x1d0) = puVar17 + 200;

+              *(undefined8 *)(puVar17 + 0x1d8) = 8;

+              *(undefined4 *)(puVar17 + 0x9c) =

+                   *(undefined4 *)(*(longlong *)(puVar17 + 0x50) + 0x90);

+              *(undefined1 **)(puVar17 + 0x1e0) = puVar17 + 0x9c;

+              *(undefined8 *)(puVar17 + 0x1e8) = 4;

+              *(undefined1 **)(puVar17 + 0x28) = puVar17 + 0x1a0;

+              *(undefined4 *)(puVar17 + 0x20) = 5;

+              uVar20 = 0;

+              *(undefined8 *)(puVar17 + -8) = 0x1404db008;

+              _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140044bae,0,0);

+              plVar22 = (longlong *)0x0;

+            }

+            *(longlong **)(puVar17 + 0x68) = plVar22;

+            plVar11 = plVar22;

+LAB_14:

+            if (param_4 != 0) goto LAB_15;

+            *(undefined8 *)(puVar17 + -8) = 0x1404db03c;

+            FsRtlpComputeShareableOplockState(*(undefined8 *)(puVar17 + 0x50));

+            *(undefined4 *)(puVar17 + 0x5c) = 0;

+            *(undefined4 *)(param_3 + 0x30) = 0;

+            *(undefined8 *)(puVar17 + -8) = 0x1404db050;

+            IofCompleteRequest(param_3,1);

+          }

+          *(undefined8 *)(puVar17 + -8) = 0x1404db225;

+          FsRtlpModifyThreadPriorities(*(undefined8 *)(puVar17 + 0x50),puVar19,0);

+          *(undefined8 *)(puVar17 + -8) = 0x1404db232;

+          FsRtlpClearOwner(*(undefined8 *)(puVar17 + 0x50),puVar19);

+          plVar14 = (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x48);

+          if ((longlong *)*plVar14 == plVar14) {

+            *(undefined1 *)(*(longlong *)(puVar17 + 0x50) + 0x20) = 0;

+          }

+          *(undefined8 *)(puVar17 + -8) = 0x1404db24d;

+          FsRtlpOplockPerfSendData(puVar19 + 9);

+          *(undefined8 *)(puVar17 + -8) = 0x1404db258;

+          FsRtlpFreeRHOpContext(puVar19,1);

+          plVar25 = plVar11;

+          if (uVar23 != 0) {

+            *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) =

+                 *(uint *)(*(longlong *)(puVar17 + 0x50) + 0x90) | 0x1000000;

+          }

+          goto LAB_13;

+        }

+      }

+      else {

+        lVar12 = puVar19[3];

+        lVar2 = *(longlong *)(*(longlong *)(puVar17 + 0x80) + 0x30);

+        if (lVar12 != lVar2) {

+          uVar20 = 0;

+          *(undefined8 *)(puVar17 + -8) = 0x1404dadb3;

+          cVar7 = FsRtlpOplockKeysEqual(lVar2,lVar12,0);

+          plVar22 = (longlong *)0x0;

+          if (cVar7 != '\0') goto LAB_11;

+        }

+      }

+    }

+    cVar18 = puVar17[100];

+LAB_13:

+    plVar14 = plVar25;

+    if (puVar17[0x60] == '\0') goto LAB_2;

+    if (puVar17[0x61] != '\0') {

+      *(undefined8 *)(puVar17 + -8) = 0x1404db2a7;

+      FsRtlpReleaseIrpsWaitingForRH(*(undefined8 *)(puVar17 + 0x50));

+    }

+    plVar11 = plVar25;

+    if (cVar18 == '\0') {

+LAB_9:

+      if (puVar17[0x62] != '\0') {

+        while (*(longlong **)(*(longlong *)(puVar17 + 0x50) + 0x58) !=

+               (longlong *)(*(longlong *)(puVar17 + 0x50) + 0x58)) {

+          *(undefined8 *)(puVar17 + -8) = 0x1404db54c;

+          FsRtlpRemoveAndCompleteWaitingIrp();

+        }

+      }

+      plVar11 = plVar25;

+      if (puVar17[99] != '\0') {

+        uVar20 = *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 8);

+        *(undefined8 *)(puVar17 + -8) = 0x1404db568;

+        ObfDereferenceObjectWithTag(uVar20,0x746c6644);

+        *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 8) = 0;

+      }

     }

   }

-  else {

-    param_3 = 0xc0000120;

-    ObfDereferenceObjectWithTag(*(undefined8 *)(param_1 + 0x18),0x746c6644);

-    if (*(longlong *)(param_1 + 0x28) != 0) {

-      FsRtlpClearOwner(param_2,param_1);

-    }

-    bVar3 = true;

-    uVar4 = 0;

+LAB_8:

+  if (plVar11 != (longlong *)0x0) {

+    *(undefined8 *)(puVar17 + -8) = 0x1404db580;

+    ExFreePoolWithTag(plVar11,0);

   }

-  *(undefined8 *)(lVar1 + 0x38) = uVar5;

-  if (bVar3) {

-    if (param_8 != '\0') {

-      *(undefined8 *)(param_1 + 0x58) = 0;

-    }

-    FsRtlpFreeRHOpContext(param_1,param_8 == '\0');

+  if (5 < DAT_0) {

+    *(undefined4 *)(puVar17 + 0x74) = *(undefined4 *)(puVar17 + 0x5c);

+    *(undefined1 **)(puVar17 + 0x110) = puVar17 + 0x74;

+    *(undefined8 *)(puVar17 + 0x118) = 4;

+    *(longlong *)(puVar17 + 0xa8) = *(longlong *)(puVar17 + 0x50);

+    *(undefined1 **)(puVar17 + 0x120) = puVar17 + 0xa8;

+    *(undefined8 *)(puVar17 + 0x128) = 8;

+    *(undefined4 *)(puVar17 + 0x78) = *(undefined4 *)(*(longlong *)(puVar17 + 0x50) + 0x90);

+    *(undefined1 **)(puVar17 + 0x130) = puVar17 + 0x78;

+    *(undefined8 *)(puVar17 + 0x138) = 4;

+    *(undefined1 **)(puVar17 + 0x28) = puVar17 + 0xf0;

+    *(undefined4 *)(puVar17 + 0x20) = 5;

+    *(undefined8 *)(puVar17 + -8) = 0x1404db628;

+    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_14004491e,0,0);

   }

-  *(uint *)(lVar1 + 0x30) = param_3;

-  IofCompleteRequest(lVar1,1);

-  if (5 < DAT_0) {

-    local_b8 = &local_100;

-    local_a8 = (uint *)local_e8;

-    local_b0 = 4;

-    local_104 = *(undefined4 *)(param_2 + 0x90);

-    local_98 = &local_104;

-    local_110 = local_d8;

-    local_118 = 5;

-    local_a0 = 8;

-    local_90 = 4;

-    local_100 = param_3;

-    local_e8[0] = param_2;

-    _tlgWriteTransfer_EtwWriteTransfer(&DAT_0,&DAT_140043db5,0,0);

-  }

-  return uVar4;

+  uVar20 = *(undefined8 *)(*(longlong *)(puVar17 + 0x50) + 0x98);

+  *(undefined8 *)(puVar17 + -8) = 0x1404db639;

+  ExReleaseFastMutexUnsafe(uVar20);

+  uVar9 = *(undefined4 *)(puVar17 + 0x5c);

+LAB_1:

+  *(undefined8 *)(puVar17 + -8) = 0x1404dab23;

+  return uVar9;

 }
```

## `SepCaptureHandles`  (modified)

```diff
--- SepCaptureHandles
+++ SeCaptureHandles
@@ -1,35 +1,35 @@
 

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* WARNING: Removing unreachable block (ram,0x000140606d42) */

 

-void SepCaptureHandles(longlong param_1,int param_2,undefined4 param_3,int param_4)

+undefined8 SeCaptureHandles(uint param_1,longlong param_2,longlong *param_3)

 

 {

-  byte *pbVar1;

-  byte in_AL;

-  undefined1 uVar2;

-  longlong unaff_RBX;

-  longlong lVar3;

-  int in_stack_00000060;

+  undefined8 uVar1;

+  longlong lVar2;

+  ulonglong uVar3;

   

-  pbVar1 = (byte *)(unaff_RBX + 0x60247c);

-  *pbVar1 = *pbVar1 & in_AL;

-  if (*pbVar1 == 0) {

-    lVar3 = 0;

+  *param_3 = 0;

+  if (param_1 < 0xb) {

+    if (param_1 == 0) {

+      uVar1 = 0;

+    }

+    else {

+      lVar2 = ExAllocatePool2(0x100,(ulonglong)param_1 << 3,0x63486553);

+      if (lVar2 == 0) {

+        uVar1 = 0xc000009a;

+      }

+      else {

+        for (uVar3 = 0; (uint)uVar3 < param_1; uVar3 = (ulonglong)((uint)uVar3 + 1)) {

+          *(undefined8 *)(lVar2 + uVar3 * 8) = *(undefined8 *)(param_2 + uVar3 * 8);

+        }

+        *param_3 = lVar2;

+        uVar1 = 0;

+      }

+    }

   }

   else {

-    lVar3 = _DAT_0 - _DAT_fffff780000003b0;

+    uVar1 = 0xc00000ef;

   }

-  uVar2 = ExAcquireSpinLockExclusive(param_1 + 0x698);

-  if (param_4 != *(int *)(param_1 + 0x6c4)) {

-    *(int *)(param_1 + 0x6b8) = *(int *)(param_1 + 0x6b8) + 1;

-    *(longlong *)(param_1 + 0x6b0) = *(longlong *)(param_1 + 0x6b0) * 2;

-  }

-  *(undefined4 *)(param_1 + 0x6c0) = param_3;

-  *(ulonglong *)(param_1 + 0x6b0) = *(ulonglong *)(param_1 + 0x6b0) | (ulonglong)(param_2 != 0);

-  if (in_stack_00000060 != 0) {

-    *(longlong *)(param_1 + 0x6c8) = lVar3;

-  }

-  ExReleaseSpinLockExclusive(param_1 + 0x698,uVar2);

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_KernelPnP_DeviceListFilterUpdates__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_KernelPnP_DeviceListFilterUpdates__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_KernelPnP_DeviceListFilterUpdates__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_KernelPnP_DeviceListFilterUpdates__private_IsEnabledFallback

+                      (Feature_KernelPnP_DeviceListFilterUpdates__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_KernelPnP_DeviceListFilterUpdates__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_KernelPnP_InterfaceListFilterUpdates__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_KernelPnP_InterfaceListFilterUpdates__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_KernelPnP_InterfaceListFilterUpdates__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_KernelPnP_InterfaceListFilterUpdates__private_IsEnabledFallback

+                      (Feature_KernelPnP_InterfaceListFilterUpdates__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_KernelPnP_InterfaceListFilterUpdates__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_Servicing_KeIntSteerProcessorIndex__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_Servicing_KeIntSteerProcessorIndex__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_Servicing_KeIntSteerProcessorIndex__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_Servicing_KeIntSteerProcessorIndex__private_IsEnabledFallback

+                      (Feature_Servicing_KeIntSteerProcessorIndex__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_Servicing_KeIntSteerProcessorIndex__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_Servicing_Alpc_LockOrdering__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_Servicing_Alpc_LockOrdering__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_Servicing_Alpc_LockOrdering__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_Servicing_Alpc_LockOrdering__private_IsEnabledFallback

+                      (Feature_Servicing_Alpc_LockOrdering__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_Servicing_Alpc_LockOrdering__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_Servicing_ThermalSxExitRereadZones__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_Servicing_ThermalSxExitRereadZones__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_Servicing_ThermalSxExitRereadZones__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_Servicing_ThermalSxExitRereadZones__private_IsEnabledFallback

+                      (Feature_Servicing_ThermalSxExitRereadZones__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_Servicing_ThermalSxExitRereadZones__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_2077227322__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_2077227322__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_2077227322__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_2077227322__private_IsEnabledFallback

+                      (Feature_2077227322__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_2077227322__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_1045423416__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_1045423416__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_1045423416__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_1045423416__private_IsEnabledFallback

+                      (Feature_1045423416__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_1045423416__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_1224463674__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_1224463674__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_1224463674__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_1224463674__private_IsEnabledFallback

+                      (Feature_1224463674__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_1224463674__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_1345841464__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_1345841464__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_1345841464__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_1345841464__private_IsEnabledFallback

+                      (Feature_1345841464__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_1345841464__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline`  (modified)

```diff
--- Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline
+++ Feature_CodeIntegrity_EccSupport__private_IsEnabledDeviceUsageNoInline
@@ -1,76 +1,16 @@
 

-void Feature_Servicing_WpsContainmentFixNoneZone__private_IsEnabledDeviceUsageNoInline

-               (undefined8 param_1,undefined8 param_2,short param_3)

+ulonglong Feature_CodeIntegrity_EccSupport__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  code *pcVar1;

-  char cVar2;

-  int iVar3;

-  ulonglong uVar4;

-  longlong lVar5;

-  ulonglong *puVar6;

-  uint uVar7;

-  ulonglong uVar8;

-  uint *unaff_RBX;

-  ulonglong unaff_RSI;

-  ulonglong uVar9;

-  ulonglong uVar10;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined1 local_res8 [24];

-  undefined8 uStack_8;

+  ulonglong uVar1;

   

-  uVar8 = unaff_RSI & 0xffffffff;

-  uVar9 = unaff_RSI;

-  if ((uint)unaff_RSI < *unaff_RBX) {

-    do {

-      uVar4 = *(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) >> 0xc;

-      uVar10 = (uVar4 - 1) + (ulonglong)((uint)*(ulonglong *)(unaff_RBX + uVar8 * 2 + 4) & 0xfff);

-      if (uVar4 <= uVar10) {

-        puVar6 = (ulonglong *)(unaff_RBX + 0x404 + uVar9 * 4);

-        uVar9 = (uVar9 - uVar4) + 1 + uVar10;

-        do {

-          *puVar6 = uVar4;

-          uVar4 = uVar4 + 1;

-          puVar6 = puVar6 + 2;

-        } while (uVar4 <= uVar10);

-      }

-      uVar7 = (int)uVar8 + 1;

-      uVar8 = (ulonglong)uVar7;

-    } while (uVar7 < *unaff_RBX);

+  if ((Feature_CodeIntegrity_EccSupport__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_CodeIntegrity_EccSupport__private_IsEnabledFallback

+                      (Feature_CodeIntegrity_EccSupport__private_featureState,3);

   }

-  iVar3 = HvlMapSparseGpaPages

-                    (*(undefined8 *)(unaff_R14 + 0x68),(-(uint)(param_3 != 0) & 0x8000) + 0x1010000,

-                     uVar9,unaff_RBX + 0x404,&stack0x00000078);

-  if (iVar3 < 0) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)local_res8;

+  else {

+    uVar1 = (ulonglong)(Feature_CodeIntegrity_EccSupport__private_featureState & 1);

   }

-  if (*(ulonglong *)((longlong)register0x00000020 + 0x78) != uVar9) {

-    pcVar1 = (code *)swi(0x2c);

-    (*pcVar1)();

-    register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

-  }

-  if (unaff_R13 != 0) {

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b40;

-    lVar5 = KeQueryUnbiasedInterruptTimePrecise((undefined1 *)((longlong)register0x00000020 + 0x78))

-    ;

-    lVar5 = lVar5 - unaff_R13;

-    if ((VmpTraceLoggingProvider != (uint *)0x0) && ((uint)unaff_RSI < *VmpTraceLoggingProvider)) {

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b5e;

-      cVar2 = _tlgKeywordOn();

-      if (cVar2 != '\0') {

-        *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(unaff_R14 + 0x68);

-        *(longlong *)((longlong)register0x00000020 + 0x20) = lVar5;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1404a4b84;

-        VmpLogTbFlushSlatInvalidate();

-      }

-    }

-  }

-  unaff_RBX[0] = 0;

-  unaff_RBX[1] = 0;

-  *(ulonglong *)(unaff_RBX + 2) = unaff_RSI;

-  return;

+  return uVar1;

 }
```

## `SepCheckCreateLowBox`  (modified)

```diff
--- SepCheckCreateLowBox
+++ SepCheckCreateAppContainer
@@ -1,8 +1,42 @@
 

-void SepCheckCreateLowBox(void)

+uint SepCheckCreateAppContainer(undefined8 param_1)

 

 {

-                    /* WARNING: Subroutine does not return */

-  KeBugCheckEx();

+  bool bVar1;

+  byte bVar2;

+  int iVar3;

+  uint uVar4;

+  longlong lVar5;

+  longlong local_28;

+  undefined8 uStack_20;

+  longlong local_18;

+  undefined8 uStack_10;

+  

+  uVar4 = 0;

+  local_28 = 0;

+  uStack_20 = 0;

+  local_18 = 0;

+  uStack_10 = 0;

+  bVar1 = true;

+  SeCaptureSubjectContext(&local_28);

+  lVar5 = local_18;

+  if ((local_28 == 0) || (lVar5 = local_28, 1 < (int)uStack_20)) {

+    iVar3 = Feature_DecoupleAppContainerAndIntegrityLevel__private_IsEnabledDeviceUsageNoInline();

+    if (iVar3 == 0) {

+      uVar4 = *(uint *)(lVar5 + 200) & 0x2000;

+    }

+    else {

+      uVar4 = ~(*(uint *)(lVar5 + 200) >> 0xe) & 1;

+    }

+  }

+  else {

+    bVar1 = false;

+  }

+  if (((uVar4 == 0) && (bVar1)) && ((*(uint *)(lVar5 + 200) & 0x4000) != 0)) {

+    bVar2 = RtlIsParentOfChildAppContainer(*(undefined8 *)(lVar5 + 0x310),param_1);

+    uVar4 = (uint)bVar2;

+  }

+  SeReleaseSubjectContext(&local_28);

+  return ~-(uint)(uVar4 != 0) & 0xc0000022;

 }
```

## `SC_DEVICE::GetStorageProperty`  (modified)

```diff
--- SC_DEVICE::GetStorageProperty
+++ SC_DEVICE::GetStorageProperty
@@ -1,2 +1,68 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_DEVICE::GetStorageProperty : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall replaced with injection: guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl SC_DEVICE::GetStorageProperty(enum _STORAGE_PROPERTY_ID,struct

+   _STORAGE_DESCRIPTOR_HEADER * __ptr64 * __ptr64) __ptr64 */

+

+long __thiscall

+SC_DEVICE::GetStorageProperty

+          (SC_DEVICE *this,_STORAGE_PROPERTY_ID param_1,_STORAGE_DESCRIPTOR_HEADER **param_2)

+

+{

+  uint uVar1;

+  int iVar2;

+  _STORAGE_DESCRIPTOR_HEADER *p_Var3;

+  ulong uVar4;

+  undefined8 uVar5;

+  uint uVar6;

+  uint *puVar7;

+  undefined1 auStack_88 [32];

+  _STORAGE_DESCRIPTOR_HEADER *local_68;

+  uint local_60;

+  uint local_48 [2];

+  uint local_40 [4];

+  ulonglong local_30;

+  

+  local_30 = __security_cookie ^ (ulonglong)auStack_88;

+  *param_2 = (_STORAGE_DESCRIPTOR_HEADER *)0x0;

+  puVar7 = local_48;

+  local_48[0] = 0;

+  uVar5 = 6;

+  local_40[2] = 0;

+  iVar2 = (**(code **)(*(longlong *)this + 0x20))();

+  if (-1 < iVar2) {

+    local_40[1] = 0;

+    local_40[0] = 6;

+    uVar6 = local_48[0];

+    while (p_Var3 = SC_ENV::Allocate((ulonglong)uVar6,(ulong)uVar5,(uchar)puVar7,0),

+          p_Var3 != (_STORAGE_DESCRIPTOR_HEADER *)0x0) {

+      puVar7 = local_40;

+      uVar5 = 0x2d1400;

+      local_68 = p_Var3;

+      local_60 = uVar6;

+      iVar2 = (**(code **)(*(longlong *)this + 0x10))(this);

+      uVar4 = (ulong)uVar5;

+      if (((iVar2 + 0x80000000U & 0x80000000) == 0) && (iVar2 != -0x7ffffffb)) {

+LAB_0:

+        SC_ENV::Free(p_Var3,uVar4);

+        return iVar2;

+      }

+      uVar1 = p_Var3->Size;

+      if (uVar1 <= uVar6) {

+        p_Var3->Size = uVar6;

+        uVar4 = 6;

+        iVar2 = (**(code **)(*(longlong *)this + 0x28))(this,6,p_Var3);

+        if (-1 < iVar2) {

+          *param_2 = p_Var3;

+          return iVar2;

+        }

+        goto LAB_0;

+      }

+      SC_ENV::Free(p_Var3,uVar4);

+      uVar6 = uVar1;

+    }

+    iVar2 = -0x3fffff66;

+  }

+  return iVar2;

+}

+
```

## `SC_RAW::ReadPartitionTable`  (modified)

```diff
--- SC_RAW::ReadPartitionTable
+++ SC_RAW::ReadPartitionTable
@@ -1,2 +1,50 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_RAW::ReadPartitionTable : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl SC_RAW::ReadPartitionTable(class SC_DISK_LAYOUT * __ptr64 * __ptr64) __ptr64

+    */

+

+long __thiscall SC_RAW::ReadPartitionTable(SC_RAW *this,SC_DISK_LAYOUT **param_1)

+

+{

+  MBR_HEADER *this_00;

+  ulong uVar1;

+  SC_DISK_LAYOUT *_Dst;

+  long lVar2;

+  uchar in_R8B;

+  SC_DISK_LAYOUT SVar3;

+  

+  lVar2 = 0;

+  this_00 = *(MBR_HEADER **)(*(longlong *)this + 0x108);

+  *param_1 = (SC_DISK_LAYOUT *)0x0;

+  _Dst = SC_ENV::Allocate(0xc0,(ulong)param_1,in_R8B,0);

+  if (_Dst == (SC_DISK_LAYOUT *)0x0) {

+    lVar2 = -0x3fffff66;

+  }

+  else {

+    memset(_Dst,0,0xc0);

+    if ((*(int *)(*(longlong *)this + 0xe0) == 0xb) || (*(short *)(this_00 + 0x1fe) == -0x55ab)) {

+      SVar3 = (SC_DISK_LAYOUT)0x1;

+      *(undefined4 *)(_Dst + 4) = 1;

+      *(undefined4 *)(_Dst + 8) = 1;

+      uVar1 = MBR_HEADER::CheckSum(this_00);

+      *(ulong *)(_Dst + 0xc) = uVar1;

+      *(undefined8 *)(_Dst + 0x38) = 0;

+      *(longlong *)(_Dst + 0x40) =

+           *(longlong *)(*(longlong *)this + 0xf8) <<

+           ((byte)*(undefined4 *)(*(longlong *)this + 0xf0) & 0x3f);

+      *(undefined4 *)(_Dst + 0x48) = 0;

+      *(undefined2 *)(_Dst + 0x50) = 4;

+      _Dst[0x52] = SVar3;

+      *(undefined4 *)(_Dst + 0x54) = 0;

+      *(undefined4 *)(_Dst + 0x58) = *(undefined4 *)(_Dst + 8);

+      *(undefined4 *)(_Dst + 0x5c) = 0;

+      *(undefined8 *)(_Dst + 0x60) = 0;

+    }

+    else {

+      uVar1 = MBR_HEADER::CheckSum(this_00);

+      *(ulong *)(_Dst + 0xc) = uVar1;

+    }

+    *param_1 = _Dst;

+  }

+  return lVar2;

+}

+
```

## `SC_GPT::ReadEntries`  (modified)

```diff
--- SC_GPT::ReadEntries
+++ SC_GPT::ReadEntries
@@ -1,2 +1,35 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_GPT::ReadEntries : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: long __cdecl SC_GPT::ReadEntries(class GPT_HEADER * __ptr64,class GPT_ENTRY * __ptr64 *

+   __ptr64) __ptr64 */

+

+long __thiscall SC_GPT::ReadEntries(SC_GPT *this,GPT_HEADER *param_1,GPT_ENTRY **param_2)

+

+{

+  int iVar1;

+  int iVar2;

+  longlong lVar3;

+  long lVar4;

+  GPT_ENTRY *pGVar5;

+  

+  lVar3 = *(longlong *)this;

+  iVar1 = *(int *)(param_1 + 0x54);

+  iVar2 = *(int *)(param_1 + 0x50);

+  *param_2 = (GPT_ENTRY *)0x0;

+  pGVar5 = SC_ENV::Allocate((ulonglong)

+                            (uint)(iVar1 * iVar2 + -1 + *(int *)(lVar3 + 0xec) &

+                                  -*(int *)(lVar3 + 0xec)),(ulong)param_1,(uchar)param_2,1);

+  if (pGVar5 == (GPT_ENTRY *)0x0) {

+    lVar4 = -0x3fffff66;

+  }

+  else {

+    lVar4 = ReadEntries(this,param_1,pGVar5);

+    if (lVar4 < 0) {

+      SC_ENV::Free(pGVar5,(ulong)param_1);

+    }

+    else {

+      *param_2 = pGVar5;

+    }

+  }

+  return lVar4;

+}

+
```

## `SC_ENV::Allocate`  (modified)

```diff
--- SC_ENV::Allocate
+++ SC_ENV::Allocate
@@ -1,2 +1,13 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_ENV::Allocate : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: static void * __ptr64 __cdecl SC_ENV::Allocate(unsigned __int64,unsigned long,unsigned

+   char,unsigned long) */

+

+void * __cdecl SC_ENV::Allocate(__uint64 param_1,ulong param_2,uchar param_3,ulong param_4)

+

+{

+  void *pvVar1;

+  

+  pvVar1 = (void *)ExAllocatePoolWithTag((param_4 & 1) * 4 + 0x200,param_1,0x54506f49);

+  return pvVar1;

+}

+
```

## `SC_MBR::ReadPartitionTable`  (modified)

```diff
--- SC_MBR::ReadPartitionTable
+++ SC_MBR::ReadPartitionTable
@@ -1,2 +1,146 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_MBR::ReadPartitionTable : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl SC_MBR::ReadPartitionTable(class SC_DISK_LAYOUT * __ptr64 * __ptr64) __ptr64

+    */

+

+long __thiscall SC_MBR::ReadPartitionTable(SC_MBR *this,SC_DISK_LAYOUT **param_1)

+

+{

+  MBR_HEADER MVar1;

+  MBR_HEADER *this_00;

+  bool bVar2;

+  uchar uVar3;

+  SC_DISK_LAYOUT SVar4;

+  ulong uVar5;

+  uint uVar6;

+  SC_DISK_LAYOUT *_Src;

+  SC_DISK_LAYOUT *_Dst;

+  ulonglong uVar7;

+  MBR_HEADER *pMVar8;

+  longlong lVar9;

+  ulonglong uVar10;

+  uchar in_R8B;

+  SC_MBR *pSVar11;

+  uint uVar12;

+  ulonglong uVar13;

+  MBR_HEADER *pMVar14;

+  int iVar15;

+  ulonglong uVar16;

+  uint local_68;

+  uint local_64;

+  

+  uVar10 = 0;

+  bVar2 = false;

+  local_64 = 0;

+  local_68 = 0;

+  this_00 = *(MBR_HEADER **)(*(longlong *)this + 0x108);

+  *param_1 = (SC_DISK_LAYOUT *)0x0;

+  _Src = SC_ENV::Allocate(0x270,(ulong)param_1,in_R8B,0);

+  if (_Src == (SC_DISK_LAYOUT *)0x0) {

+    local_64 = 0xc000009a;

+  }

+  else {

+    uVar7 = 0;

+    pSVar11 = (SC_MBR *)0x26c;

+    memset(_Src + 4,0,0x26c);

+    *(undefined4 *)_Src = 0;

+    *(undefined4 *)(_Src + 8) = *(undefined4 *)(this_00 + 0x1b8);

+    uVar5 = MBR_HEADER::CheckSum(this_00);

+    *(ulong *)(_Src + 0xc) = uVar5;

+    uVar13 = uVar10;

+    uVar16 = uVar10;

+    do {

+      pMVar8 = (MBR_HEADER *)0x0;

+      iVar15 = (int)uVar16;

+      uVar6 = (uint)uVar10;

+      if (*(short *)(this_00 + 0x1fe) != -0x55ab) {

+LAB_0:

+        *(uint *)(_Src + 4) = iVar15 + 3U & 0xfffffffc;

+        *param_1 = _Src;

+        return uVar6;

+      }

+      lVar9 = 4;

+      pMVar14 = this_00 + 0x1c2;

+      uVar10 = uVar16;

+      do {

+        MVar1 = *pMVar14;

+        uVar12 = (uint)uVar13;

+        uVar16 = uVar10;

+        if ((MVar1 == (MBR_HEADER)0x5) || (uVar6 = local_68, MVar1 == (MBR_HEADER)0xf)) {

+          if (pMVar8 == (MBR_HEADER *)0x0) {

+            pMVar8 = pMVar14 + -4;

+            uVar6 = uVar12;

+            goto LAB_1;

+          }

+          bVar2 = true;

+        }

+        else {

+LAB_1:

+          uVar7 = (ulonglong)uVar6;

+          pSVar11 = *(SC_MBR **)(*(longlong *)this + 0xf8);

+          uVar3 = MBR_ENTRY::Validate((MBR_ENTRY *)(pMVar14 + -4),uVar6,(__uint64)pSVar11);

+          if (uVar3 == '\0') {

+            bVar2 = true;

+          }

+          else {

+            uVar16 = (ulonglong)((int)uVar10 + 1);

+            if (MVar1 != (MBR_HEADER)0x0) {

+              *(undefined4 *)(_Src + uVar10 * 0x90 + 0x30) = 0;

+              uVar7 = (ulonglong)*(uint *)(pMVar14 + 4) + (ulonglong)uVar6 <<

+                      ((byte)*(undefined4 *)(*(longlong *)this + 0xf0) & 0x3f);

+              *(ulonglong *)(_Src + uVar10 * 0x90 + 0x38) = uVar7;

+              *(ulonglong *)(_Src + uVar10 * 0x90 + 0x40) =

+                   (ulonglong)*(uint *)(pMVar14 + 8) <<

+                   ((byte)*(undefined4 *)(*(longlong *)this + 0xf0) & 0x3f);

+              *(undefined4 *)(_Src + uVar10 * 0x90 + 0x48) = 0;

+              *(MBR_HEADER *)(_Src + uVar10 * 0x90 + 0x50) = *pMVar14;

+              _Src[uVar10 * 0x90 + 0x51] =

+                   (SC_DISK_LAYOUT)(*(MBR_ENTRY *)(pMVar14 + -4) == (MBR_ENTRY)0x80);

+              if ((0xf < (byte)*pMVar14) ||

+                 (SVar4 = (SC_DISK_LAYOUT)0x0, (0x8021U >> ((byte)*pMVar14 & 0x1f) & 1) == 0)) {

+                SVar4 = (SC_DISK_LAYOUT)0x1;

+              }

+              _Src[uVar10 * 0x90 + 0x52] = SVar4;

+              *(undefined4 *)(_Src + uVar10 * 0x90 + 0x54) = *(undefined4 *)(pMVar14 + 4);

+              *(undefined4 *)(_Src + uVar10 * 0x90 + 0x58) = *(undefined4 *)(_Src + 8);

+              *(undefined4 *)(_Src + uVar10 * 0x90 + 0x5c) = 0;

+              *(ulonglong *)(_Src + uVar10 * 0x90 + 0x60) = uVar7;

+              pSVar11 = this;

+            }

+          }

+        }

+        uVar5 = (ulong)uVar7;

+        iVar15 = (int)uVar16;

+        pMVar14 = pMVar14 + 0x10;

+        lVar9 = lVar9 + -1;

+        uVar10 = uVar16;

+      } while (lVar9 != 0);

+      uVar6 = local_64;

+      if ((bVar2) || (pMVar8 == (MBR_HEADER *)0x0)) goto LAB_0;

+      local_68 = *(uint *)(pMVar8 + 8) + uVar12;

+      if (uVar12 == 0) {

+        uVar13 = (ulonglong)*(uint *)(pMVar8 + 8);

+      }

+      _Dst = SC_ENV::Allocate((ulonglong)(iVar15 * 0x90 + 0x270),uVar5,(uchar)pSVar11,0);

+      if (_Dst == (SC_DISK_LAYOUT *)0x0) {

+        local_64 = 0xc000009a;

+        if (_Src == (SC_DISK_LAYOUT *)0x0) {

+          return -0x3fffff66;

+        }

+        break;

+      }

+      RtlCopyMemory(_Dst,_Src,(longlong)(iVar15 * 0x90 + 0x30));

+      uVar5 = 0;

+      memset(_Dst + uVar16 * 0x90 + 0x30,0,0x240);

+      SC_ENV::Free(_Src,uVar5);

+      uVar7 = 1;

+      pSVar11 = (SC_MBR *)(ulonglong)local_68;

+      local_64 = SC_DISK::ReadSectors(*(SC_DISK **)this,1,(__uint64)pSVar11,(void *)0x0);

+      uVar5 = (ulong)uVar7;

+      uVar10 = (ulonglong)local_64;

+      _Src = _Dst;

+    } while (-1 < (int)local_64);

+    SC_ENV::Free(_Src,uVar5);

+  }

+  return local_64;

+}

+
```

## `SC_DISK::GetStoragePropertyPost`  (modified)

```diff
--- SC_DISK::GetStoragePropertyPost
+++ SC_DISK::GetStoragePropertyPost
@@ -1,2 +1,47 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_DISK::GetStoragePropertyPost : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: virtual long __cdecl SC_DISK::GetStoragePropertyPost(enum _STORAGE_PROPERTY_ID,struct

+   _STORAGE_DESCRIPTOR_HEADER * __ptr64) __ptr64 */

+

+long __thiscall

+SC_DISK::GetStoragePropertyPost

+          (SC_DISK *this,_STORAGE_PROPERTY_ID param_1,_STORAGE_DESCRIPTOR_HEADER *param_2)

+

+{

+  uint uVar1;

+  long lVar2;

+  char *_Dst;

+  _UNICODE_STRING *p_Var3;

+  long lVar4;

+  

+  lVar4 = 0;

+  lVar2 = lVar4;

+  if ((int)param_1 < 0xf) {

+    lVar2 = 0;

+    if ((((param_1 != 0xe) && (lVar2 = lVar4, param_1 != 4)) && (param_1 == 6)) &&

+       (((uVar1 = *(uint *)(this + 0xec), param_2[2].Version != uVar1 || (param_2[2].Size < uVar1))

+        || (param_2[2].Size % uVar1 != 0)))) {

+      lVar2 = -0x3ffff6f5;

+    }

+  }

+  else if ((param_1 != 0x15) && (param_1 != 0x39)) {

+    if (param_1 == 0x3a) {

+      if ((param_2[4].Version < param_2->Version) || (param_2->Size - 1 < param_2[4].Version)) {

+        param_2[4].Version = 0;

+      }

+    }

+    else if ((param_1 != 0x3c) && (param_1 == 0x41)) {

+      _Dst = SC_ENV::Allocate((ulonglong)(param_2[1].Version + 1),5,(uchar)param_2,0);

+      if (_Dst == (char *)0x0) {

+        lVar2 = -0x3fffff66;

+      }

+      else {

+        RtlCopyMemory(_Dst,&param_2[1].Size,(ulonglong)param_2[1].Version);

+        p_Var3 = (_UNICODE_STRING *)(this + 0x120);

+        lVar2 = ScAnsiToUnicodeString(_Dst,p_Var3);

+        SC_ENV::Free(_Dst,(ulong)p_Var3);

+      }

+    }

+  }

+  return lVar2;

+}

+
```

## `SC_DISK::InitializePartitionCache`  (modified)

```diff
--- SC_DISK::InitializePartitionCache
+++ SC_DISK::InitializePartitionCache
@@ -1,2 +1,23 @@
-Failed to decompile ntoskrnl.exe - .ProgramDB SC_DISK::InitializePartitionCache : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl SC_DISK::InitializePartitionCache(void) __ptr64 */

+

+long __thiscall SC_DISK::InitializePartitionCache(SC_DISK *this)

+

+{

+  long lVar1;

+  void *pvVar2;

+  ulong in_EDX;

+  uchar in_R8B;

+  

+  pvVar2 = SC_ENV::Allocate((longlong)(1 << ((byte)*(undefined4 *)(this + 0xf0) & 0x1f)),in_EDX,

+                            in_R8B,1);

+  *(void **)(this + 0x108) = pvVar2;

+  if (pvVar2 == (void *)0x0) {

+    lVar1 = -0x3fffff66;

+  }

+  else {

+    lVar1 = ResetPartitionCache(this);

+  }

+  return lVar1;

+}

+
```
