# CVE-2026-62792 — netio.sys patch diff

`netio.sys` 10.0.26100.8875 -> 10.0.26100.9168 (ghidriff).

## `ArbitrateAndEnforce`  (modified)

```diff
--- ArbitrateAndEnforce
+++ ArbitrateAndEnforce
@@ -1,50 +1,580 @@
 

-/* WARNING: Instruction at (ram,0x00014004ed42) overlaps instruction at (ram,0x00014004ed40)

-    */

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

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

 

 longlong *

 ArbitrateAndEnforce(ushort param_1,ushort *param_2,char **param_3,longlong *param_4,char **param_5,

                    int param_6,uint param_7,longlong param_8,ulonglong *param_9,undefined4 *param_10

                    )

 

 {

-  byte *pbVar1;

-  byte bVar2;

-  longlong in_RAX;

-  longlong *unaff_RBX;

-  longlong unaff_RBP;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  longlong lVar3;

-  longlong unaff_R12;

-  undefined8 unaff_R15;

-  undefined1 auStackX_20 [8];

+  int iVar1;

+  undefined4 *puVar2;

+  int *piVar3;

+  longlong *plVar4;

+  undefined8 uVar5;

+  code *pcVar6;

+  longlong lVar7;

+  char cVar8;

+  int iVar9;

+  uint uVar10;

+  char *pcVar11;

+  longlong *plVar12;

+  ulonglong uVar13;

+  short *psVar14;

+  char **ppcVar15;

+  char **ppcVar16;

+  uint uVar17;

+  longlong lVar18;

+  longlong *plVar19;

+  undefined1 *puVar20;

+  undefined1 *puVar21;

+  undefined1 *puVar22;

+  undefined1 *puVar23;

+  longlong *plVar24;

+  char *pcVar25;

+  undefined8 *puVar26;

+  ulonglong uVar27;

+  undefined8 *puVar28;

+  short *psVar29;

+  int iVar30;

+  undefined1 auStackY_168 [8];

+  undefined1 auStackY_160 [24];

+  char *in_stack_fffffffffffffec0;

+  undefined4 uVar31;

+  uint local_104;

+  undefined2 local_fc;

+  undefined1 local_fa;

+  uint local_f8;

+  char *local_f0;

+  undefined8 local_e8;

+  uint local_e0;

+  uint local_dc;

+  int local_d8;

+  longlong *local_d0;

+  undefined8 *local_c8;

+  undefined8 *local_c0;

+  longlong local_b8;

+  char *local_b0;

+  longlong local_a8;

+  undefined4 *local_a0;

+  longlong *local_98;

+  ushort *local_90;

+  char **local_88;

+  ulonglong local_80;

+  ulonglong uStack_78;

+  ulonglong local_70;

+  undefined8 uStack_68;

+  ulonglong local_60;

+  ulonglong local_58;

   

-  LOCK();

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

-  bVar2 = *pbVar1;

-  *pbVar1 = *pbVar1 + (byte)param_1;

-  UNLOCK();

-  *(char *)(longlong)(int)in_RAX =

-       *(char *)(longlong)(int)in_RAX + (char)in_RAX + CARRY1(bVar2,(byte)param_1);

-  while( true ) {

-    lVar3 = unaff_RDI + 0x68;

-    unaff_RBP = unaff_RBP + -1;

-    if (unaff_RBP == 0) break;

-    *(longlong *)(unaff_RDI + 0x70) = lVar3;

-    *(longlong *)lVar3 = lVar3;

-    KeInitializeSpinLock(unaff_RDI + 0x60);

-    *(undefined8 *)(unaff_RDI + 0x58) = 0;

-    *(undefined8 *)(unaff_RDI + 0x78) = 0;

-    unaff_RDI = lVar3;

-  }

-  AleAcquireEndpointLockEx(unaff_RSI + -0x48,auStackX_20,0x140085df8);

-  *(undefined8 *)(unaff_RSI + 0x20) = unaff_R15;

-  AleReleaseEndpointLock(unaff_RSI + -0x48,auStackX_20);

-  KfdAleInsertFlowContextTable(unaff_RSI,unaff_R12);

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

-    WfpReportError(unaff_RBX,"KfdAleInitializeFlowTable");

-  }

-  return unaff_RBX;

+  puVar22 = auStackY_168;

+  puVar23 = auStackY_168;

+  puVar20 = auStackY_168;

+  puVar21 = auStackY_168;

+  local_58 = __security_cookie ^ (ulonglong)auStackY_168;

+  plVar19 = (longlong *)0x0;

+  local_88 = param_5;

+  local_a0 = param_10;

+  uVar10 = (uint)param_1;

+  local_dc = 0;

+  local_f8 = 0;

+  local_60 = local_60 & 0xffffffff00000000;

+  local_a8 = param_8;

+  local_f0 = (char *)0x0;

+  local_d8 = 0;

+  local_d0 = (longlong *)0x0;

+  local_80 = 0;

+  uStack_78 = 0;

+  local_e0 = 1;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_98 = param_4;

+  local_90 = param_2;

+  pcVar11 = WfpGetLayerStringFromLayerId(param_1);

+  local_b0 = pcVar11;

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

+      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+    WPP_SF_sqsd(WPP_GLOBAL_Control[3]);

+    uVar10 = (uint)param_1;

+    param_8 = local_a8;

+    in_stack_fffffffffffffec0 = pcVar11;

+  }

+  local_80 = *param_9;

+  uStack_78 = param_9[1];

+  local_70 = param_9[2];

+  uStack_68 = param_9[3];

+  local_60 = param_9[4];

+  if (param_3 == (char **)0x0) {

+LAB_0:

+    local_e8 = CONCAT44(local_e8._4_4_,uVar10) & 0xffffffff0000ffff;

+    if (((((uVar10 & 0xffff) - 0x2c & 0xfffffff9) == 0) && ((uVar10 & 0xffff) != 0x32)) ||

+       (local_b8 = 0, (short)uVar10 == 0x32)) {

+      local_b8 = 1;

+    }

+    plVar12 = (longlong *)GetNextFilter(param_4,&local_f0);

+    lVar18 = gWfpGlobal;

+    pcVar11 = local_f0;

+    iVar9 = -1;

+    while (puVar22 = auStackY_168, gWfpGlobal = lVar18, local_f0 = pcVar11,

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

+      uVar10 = 1;

+      if (pcVar11 == (char *)0x0) {

+LAB_1:

+        puVar21 = puVar20;

+        if (local_dc == 0) {

+          *(uint *)param_9 = (param_6 != 0) + 7;

+        }

+        else if (((int)*param_9 != 0x1002) && ((int)*param_9 != 0x1001)) {

+          *(undefined4 *)param_9 = 7;

+          param_9[2] = 0;

+        }

+        goto LAB_2;

+      }

+      iVar1 = *(int *)(pcVar11 + 0x3c);

+      if ((iVar9 != iVar1) || (iVar30 = iVar9, (int)plVar19 == 0)) {

+        iVar30 = iVar1;

+        plVar12 = (longlong *)0x0;

+        if (iVar9 == iVar1) {

+          iVar30 = iVar9;

+          plVar12 = plVar19;

+        }

+        plVar19 = plVar12;

+        local_104 = (uint)plVar19;

+        local_dc = uVar10;

+        if (param_7 != 0) {

+          if ((*(uint *)(*(longlong *)(pcVar11 + 0x18) + 0x28) & 0x4000) == 0) {

+LAB_3:

+            uVar27 = 0;

+            if (param_1 == 0x2c) {

+              psVar29 = &DAT_4;

+            }

+            else if (param_1 == 0x2e) {

+              psVar29 = &DAT_5;

+            }

+            else {

+              psVar29 = (short *)&DAT_6;

+              if (param_1 != 0x32) {

+                psVar29 = &DAT_7;

+              }

+            }

+            lVar18 = *(longlong *)(local_f0 + 0x18);

+            if (*(uint *)(lVar18 + 0x1c) != 0) {

+              do {

+                uVar17 = 0;

+                psVar14 = psVar29;

+                while (*psVar14 != *(short *)(*(longlong *)(lVar18 + 0x20) + uVar27 * 0x18)) {

+                  uVar17 = uVar17 + 1;

+                  psVar14 = psVar14 + 1;

+                  if (3 < uVar17) {

+                    uVar10 = (uint)(*(int *)(lVar18 + 0x28) == 0x1002);

+                    goto LAB_8;

+                  }

+                }

+                uVar17 = (int)uVar27 + 1;

+                uVar27 = (ulonglong)uVar17;

+              } while (uVar17 < *(uint *)(lVar18 + 0x1c));

+            }

+          }

+          else {

+            uVar17 = *(uint *)(*(longlong *)(pcVar11 + 0x18) + 0x2c);

+            local_fc = 0;

+            local_fa = 0;

+            cVar8 = KeGetCurrentIrql();

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

+              NdisAcquireRWLockRead();

+            }

+            else {

+              NdisAcquireRWLockRead(*(undefined8 *)(lVar18 + 0x80),&local_fc,0);

+              if (gWfpPerProContext != 0) {

+                iVar9 = KeGetCurrentProcessorNumberEx(0);

+                puVar2 = *(undefined4 **)

+                          ((ulonglong)(uint)(iVar9 * gWfpPerProContextSize) + gWfpPerProContext);

+                *(undefined8 *)(puVar2 + 2) = _DAT_9;

+                *puVar2 = 4;

+              }

+            }

+            if ((*(uint *)(gWfpGlobal + 0x198) <= uVar17) ||

+               (lVar18 = (ulonglong)uVar17 * 0x60 + *(longlong *)(gWfpGlobal + 0x1a0),

+               *(int *)(lVar18 + 4) == 0)) {

+              lVar18 = gFeCallout;

+            }

+            LOCK();

+            *(int *)(lVar18 + 0x38) = *(int *)(lVar18 + 0x38) + 1;

+            lVar7 = gWfpGlobal;

+            UNLOCK();

+            if (gWfpPerProContext != 0) {

+              iVar9 = KeGetCurrentProcessorNumberEx(0);

+              piVar3 = *(int **)((ulonglong)(uint)(iVar9 * gWfpPerProContextSize) +

+                                gWfpPerProContext);

+              if (*piVar3 == 4) {

+                *piVar3 = 0;

+              }

+            }

+            NdisReleaseRWLock(*(undefined8 *)(lVar7 + 0x80));

+            LOCK();

+            *(int *)(lVar18 + 0x38) = *(int *)(lVar18 + 0x38) + -1;

+            UNLOCK();

+            if ((*(uint *)(lVar18 + 0x30) & 1) != 0) goto LAB_3;

+            uVar10 = 0;

+          }

+LAB_8:

+          param_7 = param_7 & uVar10;

+        }

+        pcVar11 = local_f0;

+        ppcVar15 = (char **)0x0;

+        plVar24 = (longlong *)(local_f0 + 0x18);

+        uVar10 = *(uint *)(*(longlong *)(local_f0 + 0x18) + 0x28);

+        if ((uVar10 >> 0xe & 1) != 0) {

+          ppcVar16 = ppcVar15;

+          if ((param_3 != (char **)0x0) &&

+             (ppcVar16 = (char **)((longlong)param_3 + 0x21c),

+             *(int *)((longlong)param_3 + 0x214) == 0)) {

+            ppcVar15 = param_3 + 0x43;

+          }

+          in_stack_fffffffffffffec0 = local_f0;

+          plVar12 = (longlong *)

+                    ProcessCallout(param_1,local_90,param_3,local_88,local_a8,(longlong)local_f0,

+                                   (uint *)&local_80,&local_e0,(undefined4 *)ppcVar15,

+                                   (undefined4 *)ppcVar16);

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

+            if ((param_3 != (char **)0x0) &&

+               (local_f8 = local_f8 & 0xff, *(int *)(param_3 + 0x43) == 0)) {

+              local_f8 = 1;

+            }

+            if (local_e0 != 0) {

+              uVar10 = (uint)local_80;

+              uVar27 = local_80 & 0xffffffff;

+              if ((uint)local_80 < 0x2007) {

+                if ((uint)local_80 != 0x2006) {

+                  if ((uint)local_80 == 7) {

+                    pcVar25 = "FWP_ACTION_NONE";

+                  }

+                  else if ((uint)local_80 == 8) {

+                    pcVar25 = "FWP_ACTION_NONE_NO_MATCH";

+                  }

+                  else if ((uint)local_80 == 0x1001) {

+                    pcVar25 = "FWP_ACTION_BLOCK";

+                  }

+                  else {

+                    if ((uint)local_80 != 0x1002) goto LAB_10;

+                    pcVar25 = "FWP_ACTION_PERMIT";

+                  }

+LAB_11:

+                  if (((uint)local_80 >> 0xc & 1) != 0) {

+LAB_12:

+                    local_104 = 1;

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

+                        (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+                      in_stack_fffffffffffffec0 =

+                           (char *)CONCAT44((int)((ulonglong)in_stack_fffffffffffffec0 >> 0x20),

+                                            (undefined4)local_e8);

+                      WPP_SF_ssdsdI(WPP_GLOBAL_Control[3],0x22,pcVar25,uVar27,local_b0,

+                                    in_stack_fffffffffffffec0,pcVar25);

+                      uVar27 = local_80 & 0xffffffff;

+                    }

+                    if ((param_3 != (char **)0x0) && (local_b8 != 0)) {

+                      InsertTerminatingFilterToList

+                                ((longlong)(param_3 + 0x4e),(longlong)pcVar11,uVar10 | 0x4000,

+                                 (short *)(param_3 + 0x50));

+                      uVar27 = local_80 & 0xffffffff;

+                    }

+                  }

+                }

+              }

+              else if ((uint)local_80 != 0x4005) {

+                if ((uint)local_80 == 0x5003) {

+                  pcVar25 = "FWP_ACTION_CALLOUT_TERMINATING";

+                  goto LAB_12;

+                }

+                if ((uint)local_80 != 0x6004) {

+LAB_10:

+                  pcVar25 = "Action_Type_Not_Defined";

+                  goto LAB_11;

+                }

+              }

+              plVar19 = local_d0;

+              uVar17 = (uint)uVar27;

+              if ((uVar17 >> 0xc & 1) != 0) {

+                if (uVar17 != (uint)*param_9) {

+                  if ((param_9[3] & 1) == 0) {

+                    if ((uint)*param_9 == 0x1001) goto LAB_13;

+                    local_d8 = 1;

+                    *(undefined4 *)param_9 = 0x1001;

+                  }

+                  else {

+                    *(uint *)param_9 = uVar17;

+                  }

+                  param_9[2] = *(ulonglong *)*plVar24;

+                }

+LAB_13:

+                if (((param_9[3] & 1) != 0) && ((uStack_68 & 1) == 0)) {

+                  *(undefined4 *)(param_9 + 3) = 0;

+                }

+              }

+              if (uStack_78 != 0) {

+                param_9[1] = uStack_78;

+              }

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

+                *(int *)(param_9 + 4) = (int)local_60;

+              }

+              *(uint *)((longlong)param_9 + 0x1c) =

+                   *(uint *)((longlong)param_9 + 0x1c) | uStack_68._4_4_;

+              local_80 = *param_9;

+              uStack_78 = param_9[1];

+              local_c8 = (undefined8 *)0x0;

+              local_70 = param_9[2];

+              uStack_68 = param_9[3];

+              local_60 = param_9[4];

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

+LAB_14:

+                if (param_3 != (char **)0x0) {

+                  *(int *)((longlong)param_3 + 0x20c) = *(int *)((longlong)param_3 + 0x20c) + 1;

+                }

+              }

+              else {

+                lVar18 = WfpPoolAllocNonPaged(0x20,0x66637354,(longlong *)&local_c8);

+                if (lVar18 == 0) {

+                  local_c8[2] = pcVar11;

+                  LOCK();

+                  *(longlong *)(pcVar11 + 0x10) = *(longlong *)(pcVar11 + 0x10) + 0x100000001;

+                  UNLOCK();

+                  *(uint *)(local_c8 + 3) = uVar10;

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

+                  if ((longlong *)*plVar12 != plVar19) goto LAB_15;

+                  *local_c8 = plVar19;

+                  local_c8[1] = plVar12;

+                  *plVar12 = (longlong)local_c8;

+                  plVar19[1] = (longlong)local_c8;

+                  pcVar11 = local_f0;

+                  goto LAB_14;

+                }

+              }

+              plVar19 = (longlong *)(ulonglong)local_104;

+              if ((local_a0 != (undefined4 *)0x0) && (iVar30 == 2)) {

+                *local_a0 = 2;

+                local_a0[1] = *(undefined4 *)(*plVar24 + 0x2c);

+              }

+              goto LAB_16;

+            }

+            *(undefined4 *)param_9 = 7;

+            param_9[2] = *(ulonglong *)*plVar24;

+            HandleFilterDeref((longlong)pcVar11,'\0');

+            puVar21 = auStackY_168;

+          }

+          else {

+            *(undefined4 *)param_9 = 0x1001;

+            param_9[2] = *(ulonglong *)*plVar24;

+            HandleFilterDeref((longlong)pcVar11,'\0');

+          }

+LAB_2:

+          if (param_7 != 0) {

+            *(uint *)((longlong)param_9 + 0x1c) = *(uint *)((longlong)param_9 + 0x1c) & 0x10;

+          }

+          puVar22 = puVar21;

+          if (((plVar12 == (longlong *)0x0) && (puVar21[0x60] == '\0')) &&

+             (puVar23 = puVar21, puVar21[0x70] == '\0')) goto LAB_17;

+          break;

+        }

+        if ((((uVar10 >> 0xc & 1) != 0) && (uVar10 != (uint)*param_9)) && ((param_9[3] & 1) != 0)) {

+          *(uint *)param_9 = uVar10;

+          param_9[2] = *(ulonglong *)*plVar24;

+          if (uVar10 == 0x1001) {

+            *(undefined4 *)(param_9 + 3) = 0;

+          }

+          if ((*(byte *)(*plVar24 + 0x1a) & 1) != 0) {

+            *(undefined4 *)(param_9 + 3) = 0;

+          }

+          if ((param_9[1] == 0) && (*(ulonglong *)(*plVar24 + 0x30) != 0)) {

+            param_9[1] = *(ulonglong *)(*plVar24 + 0x30);

+          }

+        }

+        local_80 = *param_9;

+        uStack_78 = param_9[1];

+        local_c0 = (undefined8 *)0x0;

+        local_70 = param_9[2];

+        uStack_68 = param_9[3];

+        local_60 = param_9[4];

+        uVar31 = *(undefined4 *)(*plVar24 + 0x28);

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

+LAB_18:

+          pcVar11 = local_f0;

+          if (param_3 != (char **)0x0) {

+            *(int *)(param_3 + 0x41) = *(int *)(param_3 + 0x41) + 1;

+          }

+        }

+        else {

+          lVar18 = WfpPoolAllocNonPaged(0x20,0x66637354,(longlong *)&local_c0);

+          if (lVar18 == 0) {

+            local_c0[2] = pcVar11;

+            LOCK();

+            *(longlong *)(pcVar11 + 0x10) = *(longlong *)(pcVar11 + 0x10) + 0x100000001;

+            UNLOCK();

+            *(undefined4 *)(local_c0 + 3) = uVar31;

+            plVar12 = (longlong *)local_d0[1];

+            if ((longlong *)*plVar12 != local_d0) {

+LAB_15:

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

+              (*pcVar6)(3);

+              puVar20 = auStackY_160;

+              plVar12 = plVar19;

+              goto LAB_1;

+            }

+            *local_c0 = local_d0;

+            local_c0[1] = plVar12;

+            *plVar12 = (longlong)local_c0;

+            local_d0[1] = (longlong)local_c0;

+            goto LAB_18;

+          }

+        }

+        uVar31 = (undefined4)((ulonglong)in_stack_fffffffffffffec0 >> 0x20);

+        puVar26 = (undefined8 *)*plVar24;

+        if ((*(uint *)(puVar26 + 5) >> 0xc & 1) != 0) {

+          plVar19 = (longlong *)0x1;

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

+              (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+             ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+            puVar28 = WPP_GLOBAL_Control;

+            pcVar25 = WfpGetActionStringFromActionType(*(uint *)(puVar26 + 5));

+            in_stack_fffffffffffffec0 = (char *)CONCAT44(uVar31,(undefined4)local_e8);

+            WPP_SF_ssdsdI(puVar28[3],0x23,*puVar26,puVar28,local_b0,in_stack_fffffffffffffec0,

+                          pcVar25);

+          }

+          if ((local_a0 != (undefined4 *)0x0) && (iVar30 == 2)) {

+            *local_a0 = 2;

+            local_a0[1] = *(undefined4 *)(*plVar24 + 0x2c);

+          }

+          if ((param_3 != (char **)0x0) && (local_b8 != 0)) {

+            InsertTerminatingFilterToList

+                      ((longlong)(param_3 + 0x4e),(longlong)pcVar11,*(undefined4 *)(*plVar24 + 0x28)

+                       ,(short *)(param_3 + 0x50));

+          }

+        }

+      }

+LAB_16:

+      HandleFilterDeref((longlong)pcVar11,'\0');

+      plVar12 = (longlong *)GetNextFilter(local_98,&local_f0);

+      lVar18 = gWfpGlobal;

+      pcVar11 = local_f0;

+      iVar9 = iVar30;

+    }

+LAB_19:

+    *(undefined8 *)(puVar22 + -8) = 0x14004f8f9;

+    OptionalReleaseEffectiveMatchedFilters(local_d0);

+    puVar23 = puVar22;

+    if (param_3 == (char **)0x0) goto LAB_17;

+  }

+  else {

+    if (((ulonglong)*param_3 & 0x200000000) == 0) {

+      local_d0 = (longlong *)param_3[0x40];

+      *(undefined4 *)(param_3 + 0x42) = *(undefined4 *)(param_8 + 8);

+      *(undefined4 *)(param_3 + 0x43) = 1;

+      *(undefined4 *)((longlong)param_3 + 0x21c) = 1;

+      param_3[0x41] = (char *)0x0;

+      goto LAB_0;

+    }

+    local_e8 = 0;

+    param_9[1] = 0;

+    *(undefined4 *)param_9 = 0x1002;

+    plVar12 = (longlong *)GetNextFilter(param_4,&local_e8);

+    plVar24 = plVar19;

+    uVar27 = local_e8;

+    iVar9 = -1;

+    while (local_e8 = uVar27, plVar12 == (longlong *)0x0) {

+      if (uVar27 == 0) {

+        if (((int)plVar19 == 0) || (((int)*param_9 != 0x1002 && ((int)*param_9 != 0x1001)))) {

+          param_9[2] = 0;

+          *(undefined4 *)param_9 = 7;

+        }

+        goto LAB_20;

+      }

+      iVar1 = *(int *)(uVar27 + 0x3c);

+      plVar19 = (longlong *)0x1;

+      if ((iVar9 != iVar1) || (iVar30 = iVar9, (int)plVar24 == 0)) {

+        iVar30 = iVar1;

+        plVar12 = (longlong *)0x0;

+        if (iVar9 == iVar1) {

+          iVar30 = iVar9;

+          plVar12 = plVar24;

+        }

+        plVar24 = plVar12;

+        if (((*(uint *)(*(longlong *)(uVar27 + 0x18) + 0x28) & 0x4000) != 0) &&

+           (uVar13 = IsActiveCallout(uVar27,(uint *)param_3,1), (int)uVar13 != 0)) {

+          param_9[1] = 1;

+        }

+        uVar10 = *(uint *)(*(longlong *)(uVar27 + 0x18) + 0x28);

+        if ((uVar10 >> 0xc & 1) != 0) {

+          if (((uVar10 >> 0xe & 1) == 0) && (uVar10 == 0x1001)) {

+            *(undefined4 *)param_9 = 0x1001;

+            param_9[2] = **(ulonglong **)(uVar27 + 0x18);

+          }

+          plVar24 = (longlong *)0x1;

+        }

+      }

+      HandleFilterDeref(uVar27,'\0');

+      plVar12 = (longlong *)GetNextFilter(param_4,&local_e8);

+      uVar27 = local_e8;

+      iVar9 = iVar30;

+    }

+    if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+        (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) ||

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) == 0)) {

+LAB_20:

+      puVar22 = auStackY_168;

+      if (plVar12 == (longlong *)0x0) goto LAB_17;

+      goto LAB_19;

+    }

+    WPP_SF_sd(WPP_GLOBAL_Control[3],0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

+              "ArbitrateAndEnforceQuery");

+    OptionalReleaseEffectiveMatchedFilters((longlong *)0x0);

+  }

+  param_3[0x41] = (char *)0x0;

+  puVar23 = puVar22;

+LAB_17:

+  plVar24 = local_98;

+  plVar19 = (longlong *)*local_98;

+  iVar9 = local_d8;

+  while (local_d8 = iVar9, plVar19 != plVar24) {

+    plVar4 = (longlong *)*plVar19;

+    *(undefined8 *)(puVar23 + -8) = 0x14004f91b;

+    FreeMatchBufListInternal((longlong)plVar19);

+    plVar19 = plVar4;

+    iVar9 = local_d8;

+  }

+  uVar10 = (uint)param_9[4] & 0xefffffff;

+  *(uint *)(param_9 + 4) = uVar10;

+  if (iVar9 != 0) {

+    *(uint *)(param_9 + 4) = uVar10 | 0x10000000;

+  }

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

+      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+    uVar10 = (uint)*param_9;

+    *(undefined8 *)(puVar23 + -8) = 0x14004f96c;

+    puVar26 = WPP_GLOBAL_Control;

+    pcVar11 = WfpGetActionStringFromActionType(uVar10);

+    *(ulonglong *)(puVar23 + 0x50) = param_9[2];

+    *(int *)(puVar23 + 0x48) = iVar9;

+    *(uint *)(puVar23 + 0x40) = uVar10;

+    uVar5 = puVar26[3];

+    *(char **)(puVar23 + 0x38) = pcVar11;

+    *(uint *)(puVar23 + 0x30) = (uint)*(ushort *)(puVar23 + 0x68);

+    *(char **)(puVar23 + 0x28) = local_b0;

+    *(ushort **)(puVar23 + 0x20) = local_90;

+    *(undefined8 *)(puVar23 + -8) = 0x14004f9a9;

+    WPP_SF_sqsdsdlI(uVar5);

+  }

+  if (((plVar12 != (longlong *)0x0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control))

+     && ((1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)))) {

+    uVar5 = WPP_GLOBAL_Control[3];

+    *(int *)(puVar23 + 0x20) = (int)plVar12;

+    *(undefined8 *)(puVar23 + -8) = 0x14004f9f0;

+    WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"ArbitrateAndEnforce");

+  }

+  *(undefined8 *)(puVar23 + -8) = 0x14004f9ff;

+  return plVar12;

 }
```

## `KfdAuditEvent`  (modified)

```diff
--- KfdAuditEvent
+++ ArbitrateAndEnforce
@@ -1,7 +1,50 @@
 

-void KfdAuditEvent(int *param_1)

+/* WARNING: Instruction at (ram,0x00014004ed42) overlaps instruction at (ram,0x00014004ed40)

+    */

+

+longlong *

+ArbitrateAndEnforce(ushort param_1,ushort *param_2,char **param_3,longlong *param_4,char **param_5,

+                   int param_6,uint param_7,longlong param_8,ulonglong *param_9,undefined4 *param_10

+                   )

 

 {

-  return;

+  byte *pbVar1;

+  byte bVar2;

+  longlong in_RAX;

+  longlong *unaff_RBX;

+  longlong unaff_RBP;

+  longlong unaff_RSI;

+  longlong unaff_RDI;

+  longlong lVar3;

+  longlong unaff_R12;

+  undefined8 unaff_R15;

+  undefined1 auStackX_20 [8];

+  

+  LOCK();

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

+  bVar2 = *pbVar1;

+  *pbVar1 = *pbVar1 + (byte)param_1;

+  UNLOCK();

+  *(char *)(longlong)(int)in_RAX =

+       *(char *)(longlong)(int)in_RAX + (char)in_RAX + CARRY1(bVar2,(byte)param_1);

+  while( true ) {

+    lVar3 = unaff_RDI + 0x68;

+    unaff_RBP = unaff_RBP + -1;

+    if (unaff_RBP == 0) break;

+    *(longlong *)(unaff_RDI + 0x70) = lVar3;

+    *(longlong *)lVar3 = lVar3;

+    KeInitializeSpinLock(unaff_RDI + 0x60);

+    *(undefined8 *)(unaff_RDI + 0x58) = 0;

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

+    unaff_RDI = lVar3;

+  }

+  AleAcquireEndpointLockEx(unaff_RSI + -0x48,auStackX_20,0x140085df8);

+  *(undefined8 *)(unaff_RSI + 0x20) = unaff_R15;

+  AleReleaseEndpointLock(unaff_RSI + -0x48,auStackX_20);

+  KfdAleInsertFlowContextTable(unaff_RSI,unaff_R12);

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

+    WfpReportError(unaff_RBX,"KfdAleInitializeFlowTable");

+  }

+  return unaff_RBX;

 }
```

## `KfdClassify`  (modified)

```diff
--- KfdClassify
+++ KfdClassify
@@ -1,127 +1,457 @@
 

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

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

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

-/* WARNING: Variable defined which should be unmapped: param_5 */

-/* WARNING: Variable defined which should be unmapped: param_6 */

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

 

 ulonglong KfdClassify(ushort param_1,ushort *param_2,char **param_3,char **param_4,longlong param_5,

                      ulonglong *param_6)

 

 {

-  undefined4 uVar1;

-  uint uVar2;

-  char *in_RAX;

-  ulonglong uVar3;

-  undefined6 in_register_0000000a;

-  char *pcVar4;

-  longlong lVar5;

-  undefined4 *unaff_RBX;

-  longlong unaff_RBP;

-  ulonglong unaff_RSI;

-  char *unaff_RDI;

-  longlong *plVar6;

-  undefined4 unaff_R12D;

-  ulonglong unaff_R13;

-  ulonglong unaff_R14;

-  uint uVar7;

-  ulonglong uVar8;

-  undefined4 uStack0000000000000040;

-  undefined4 uStack0000000000000048;

-  uint uStack0000000000000050;

-  undefined4 uStack0000000000000058;

-  undefined4 uStack0000000000000060;

-  longlong in_stack_00000070;

-  ulonglong in_stack_00000078;

+  int *piVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  undefined4 *puVar4;

+  undefined1 auVar5 [16];

+  longlong lVar6;

+  ushort *puVar7;

+  byte bVar8;

+  char cVar9;

+  int iVar10;

+  longlong *plVar11;

+  undefined4 uVar12;

+  longlong lVar13;

+  uint uVar14;

+  ulonglong uVar15;

+  char **ppcVar16;

+  undefined8 ******ppppppuVar17;

+  char **ppcVar18;

+  uint uVar19;

+  ulonglong uVar20;

+  bool bVar21;

+  undefined1 auStackY_328 [32];

+  undefined2 local_2d8;

+  undefined1 local_2d6;

+  char **local_2d0;

+  undefined2 local_2c8;

+  undefined1 local_2c6;

+  int local_2c4;

+  char **local_2c0;

+  int local_2b8 [2];

+  ushort *local_2b0;

+  ulonglong local_2a8 [2];

+  undefined8 local_298;

+  undefined8 uStack_290;

+  uint5 local_288;

+  undefined3 uStack_283;

+  longlong lStack_280;

+  ushort *local_278;

+  char **ppcStack_270;

+  char **local_268;

+  undefined8 uStack_260;

+  longlong local_258;

+  ulonglong local_248;

+  void *pvStack_240;

+  ushort local_238;

+  undefined4 local_236;

+  undefined2 local_232;

+  longlong local_230;

+  ushort *local_228;

+  char **local_220;

+  char **local_218;

+  undefined8 *local_210;

+  ulonglong *local_208;

+  longlong *local_200;

+  ushort local_1f8;

+  undefined4 local_1f6;

+  undefined2 local_1f2;

+  ushort *local_1f0;

+  char **local_1e8;

+  undefined8 *****local_1e0;

+  char **local_1d8;

+  int local_1d0;

+  uint local_1cc;

+  undefined8 *local_1c8;

+  ulonglong *local_1c0;

+  longlong *local_1b8;

+  undefined8 *local_1b0;

+  undefined8 local_1a8;

+  undefined4 local_1a0;

+  undefined8 *****local_198;

+  undefined8 *****local_190;

+  undefined2 local_188;

+  ulonglong local_58;

   

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

-  uStack0000000000000060 = SUB84(param_4,0);

-  uStack0000000000000058 = SUB84(in_RAX,0);

-  uStack0000000000000048 = *(undefined4 *)(unaff_RBP + 0xa0);

-  uStack0000000000000050 = (uint)*(byte *)(unaff_RBP + 0xa8);

-  uVar8 = unaff_R14;

-  uStack0000000000000040 = (int)unaff_R13;

-  WPP_SF_qqqqdDDllD(*(undefined8 *)(CONCAT62(in_register_0000000a,param_1) + 0x18),

-                    (ulonglong)*(byte *)(unaff_RBP + 0xa8),param_3,unaff_RDI);

-  plVar6 = *(longlong **)(unaff_RBP + -0x80);

-  *(undefined1 *)(unaff_RBP + -0x4c) = *(undefined1 *)(unaff_RBP + 0xa8);

-  *(undefined1 *)(unaff_RBP + -0x4b) = *(undefined1 *)(unaff_RBP + 0xb0);

-  *(undefined4 *)(unaff_RBP + -0x48) = *(undefined4 *)(unaff_RBP + 0xb8);

-  uVar1 = *(undefined4 *)(unaff_RBP + -0x50);

-  if (in_stack_00000070 == 0) {

-    uVar1 = *(undefined4 *)(unaff_RBP + 0xa0);

-  }

-  *(undefined4 *)(unaff_RBP + -0x50) = uVar1;

-  *(undefined4 *)(unaff_RBP + -0x2c) = *unaff_RBX;

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

-  uVar3 = unaff_R13 & 0xffff;

-  uVar8 = uVar8 & unaff_RSI;

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

-  *(undefined1 *)(unaff_RBP + -0x6c) = 1;

-  *(undefined1 *)(unaff_RBP + -0x60) = 1;

-  *(char **)(unaff_RBP + -0x68) = unaff_RDI;

-  uVar2 = func_0x00014001a190(uVar3,in_stack_00000078,plVar6,unaff_RBP + -0x70,uVar8);

-  uVar7 = (uint)uVar8;

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

-  *(ulonglong *)(unaff_RBP + -0x58) = *(ulonglong *)(unaff_RBP + -0x58) & unaff_RSI;

-  in_stack_00000070 = lVar5;

-  if ((int)uVar2 < 0) {

-    pcVar4 = "KfdClassify";

-    plVar6 = (longlong *)(ulonglong)uVar2;

-    unaff_RSI = WfpReportSysErrorAsNtStatus(uVar3,"KfdClassify",uVar2,1);

+                    /* 0x1a190  181  KfdClassify */

+  local_58 = __security_cookie ^ (ulonglong)auStackY_328;

+  plVar11 = (longlong *)0x0;

+  bVar21 = false;

+  uVar15 = (ulonglong)param_1;

+  local_2a8[0] = 0;

+  uVar19 = 0;

+  ppcVar16 = param_4;

+  local_2d0 = param_3;

+  local_2c0 = param_4;

+  local_2b0 = param_2;

+  memset(&local_198,0,0x138);

+  local_2c4 = 0;

+  local_2b8[0] = 0;

+  uVar14 = uVar19;

+  if (param_3 != (char **)0x0) {

+    uVar14 = *(uint *)((longlong)param_3 + 4) & 0x80000;

+  }

+  local_2d8 = 0;

+  local_2d6 = 0;

+  local_1a8 = 0;

+  local_1a0 = 0;

+  local_258 = 0;

+  local_298 = 0;

+  uStack_290 = 0;

+  _local_288 = 0;

+  lStack_280 = 0;

+  local_278 = (ushort *)0x0;

+  ppcStack_270 = (char **)0x0;

+  local_268 = (char **)0x0;

+  uStack_260 = 0;

+  ppcVar18 = param_3;

+  if (uVar14 != 0) {

+    *(undefined4 *)param_6 = 0x1002;

+    goto LAB_0;

+  }

+  if (((((param_1 - 0x2c & 0xfffffff9) == 0) && (param_1 != 0x32)) || (param_1 == 0x32)) &&

+     (uVar19 = 0, (*(byte *)((longlong)param_6 + 0x1c) & 8) != 0)) {

+    uVar19 = 1;

+  }

+  *param_6 = 0;

+  param_6[1] = 0;

+  param_6[2] = 0;

+  param_6[3] = 0;

+  param_6[4] = 0;

+  *(undefined4 *)(param_6 + 3) = 1;

+  if (*(int *)(gWfpGlobal + 0xb8) != 1) {

+    *(undefined4 *)param_6 = 0x1001;

+    goto LAB_0;

+  }

+  plVar11 = (longlong *)FeAcquireReadEngineLock(&local_2d8,1);

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

+  local_2c4 = 1;

+  if (((*(int *)(gWfpGlobal + 0x588) != 0) && (*(longlong *)(gWfpGlobal + 0x580) != 0)) &&

+     (1 < (ushort)(param_1 - 0x50))) {

+    cVar9 = *(char *)(gWfpGlobal + 0x58c + uVar15);

+    if (cVar9 == -1) {

+      uVar14 = 0;

+      if (*(int *)(gWfpGlobal + 0x198) != 0) {

+        do {

+          lVar13 = (ulonglong)uVar14 * 0x60 + *(longlong *)(gWfpGlobal + 0x1a0);

+          if (((*(ushort *)(lVar13 + 0x4c) == param_1) && (*(int *)(lVar13 + 4) != 0)) &&

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

+            local_248 = 0;

+            pvStack_240 = (void *)0x0;

+            RtlInitUnicodeString(&local_248,L"\\Driver\\Ndu");

+            if ((((*(longlong *)(lVar13 + 0x40) == 0) ||

+                 (lVar13 = *(longlong *)(*(longlong *)(lVar13 + 0x40) + 8), lVar13 == 0)) ||

+                (*(void **)(lVar13 + 0x40) == (void *)0x0)) ||

+               (((short)local_248 != *(short *)(lVar13 + 0x38) ||

+                (iVar10 = memcmp(pvStack_240,*(void **)(lVar13 + 0x40),local_248 & 0xffff),

+                iVar10 != 0)))) {

+              cVar9 = '\x01';

+              goto LAB_1;

+            }

+          }

+          uVar14 = uVar14 + 1;

+        } while (uVar14 < *(uint *)(gWfpGlobal + 0x198));

+      }

+      cVar9 = '\0';

+LAB_1:

+      *(char *)(uVar15 + 0x58c + gWfpGlobal) = cVar9;

+      param_3 = local_2d0;

+    }

+    bVar21 = false;

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

+      bVar21 = true;

+    }

+  }

+  if (param_1 < *(ushort *)(gWfpGlobal + 0x180)) {

+    uVar12 = *(undefined4 *)(uVar15 * 0x88 + 0x44 + *(longlong *)(gWfpGlobal + 0x178));

+  }

+  else {

+    uVar12 = 0;

+  }

+  local_258 = 0;

+  local_278 = local_2b0;

+  lStack_280 = param_5;

+  local_298 = CONCAT44(local_298._4_4_,0x5f636357);

+  uStack_290 = CONCAT44(uStack_290._4_4_,uVar12);

+  local_288 = (uint5)(uint)local_288;

+  ppcStack_270 = param_3;

+  local_268 = param_4;

+  KeInitializeSpinLock(&uStack_260);

+  plVar11 = (longlong *)GetLayerFromIdRead(param_1,(longlong *)local_2a8);

+  puVar7 = local_2b0;

+  ppcVar18 = local_2d0;

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

+  lVar13 = *(longlong *)(local_2a8[0] + 0x78);

+  if ((lVar13 == 0) || ((param_3 != (char **)0x0 && (((ulonglong)*param_3 & 0x200000000) != 0)))) {

+    local_190 = &local_198;

+    ppppppuVar17 = &local_198;

+    local_198 = &local_198;

+    local_188 = 0;

+    plVar11 = (longlong *)

+              FindMatchingEntries(local_2a8[0],(undefined *)local_2b0,(undefined *)param_3,

+                                  (undefined *)ppppppuVar17,local_2b8);

+    lVar13 = gWfpGlobal;

+    ppcVar18 = local_2d0;

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

+    if (gWfpPerProContext != 0) {

+      iVar10 = KeGetCurrentProcessorNumberEx(0);

+      piVar1 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+      if (*piVar1 == 4) {

+        *piVar1 = 0;

+      }

+    }

+    NdisReleaseRWLock(*(undefined8 *)(lVar13 + 0x80),&local_2d8);

+    ppcVar18 = local_2d0;

+    local_2c4 = 0;

+    if (!bVar21) {

+      plVar11 = ArbitrateAndEnforce(param_1,puVar7,local_2d0,(longlong *)&local_198,local_2c0,

+                                    local_2b8[0],uVar19,(longlong)&local_298,param_6,

+                                    (undefined4 *)&local_1a8);

+      goto LAB_0;

+    }

+    local_1e8 = local_2d0;

+    local_1e0 = &local_198;

+    local_1d8 = local_2c0;

+    local_1d0 = local_2b8[0];

+    local_1c8 = &local_298;

+    local_1b0 = &local_1a8;

+    local_1f6 = 0;

+    local_1f2 = 0;

+    local_1f0 = puVar7;

+    local_1c0 = param_6;

+    local_1b8 = (longlong *)0x0;

+    local_1f8 = param_1;

+    local_1cc = uVar19;

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

+        (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+      WPP_SF_(WPP_GLOBAL_Control[3],0x1e,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids);

+    }

+    uVar14 = SystemReserved1[0x12]._4_4_;

+    bVar8 = KeGetCurrentIrql();

+    uVar15 = NetioExpandKernelStackAndCallout

+                       (*(longlong *)(gWfpGlobal + 0x580),ArbitrateAndEnforceCallout,&local_1f8,

+                        ppppppuVar17,uVar14,bVar8);

+    iVar10 = (int)uVar15;

+    plVar11 = local_1b8;

+    ppcVar18 = local_2d0;

+    if (-1 < iVar10) goto LAB_0;

+LAB_2:

+    plVar11 = (longlong *)(longlong)iVar10;

+    ppcVar18 = local_2d0;

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

+        (ppcVar18 = local_2d0, 1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       (ppcVar18 = local_2d0, (*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

+      WPP_SF_sd(WPP_GLOBAL_Control[3],10,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

+                "NetioExpandKernelStackAndCallout");

+      ppcVar18 = local_2d0;

+    }

+  }

+  else {

+    LOCK();

+    *(longlong *)(lVar13 + 0x10) = *(longlong *)(lVar13 + 0x10) + 1;

+    lVar3 = gWfpGlobal;

+    UNLOCK();

+    if (gWfpPerProContext != 0) {

+      iVar10 = KeGetCurrentProcessorNumberEx(0);

+      piVar1 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+      if (*piVar1 == 4) {

+        *piVar1 = 0;

+      }

+    }

+    NdisReleaseRWLock(*(undefined8 *)(lVar3 + 0x80),&local_2d8);

+    local_2c4 = 0;

+    if (bVar21) {

+      local_228 = local_2b0;

+      local_220 = local_2d0;

+      local_218 = local_2c0;

+      local_210 = &local_298;

+      local_236 = 0;

+      local_232 = 0;

+      local_208 = param_6;

+      local_200 = (longlong *)0x0;

+      local_238 = param_1;

+      local_230 = lVar13;

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

+          (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+        WPP_SF_(WPP_GLOBAL_Control[3],0x1d,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids);

+      }

+      uVar14 = SystemReserved1[0x12]._4_4_;

+      bVar8 = KeGetCurrentIrql();

+      uVar15 = NetioExpandKernelStackAndCallout

+                         (*(longlong *)(gWfpGlobal + 0x580),ProcessFastCalloutClassifyCallout,

+                          &local_238,ppcVar16,uVar14,bVar8);

+      iVar10 = (int)uVar15;

+      plVar11 = local_200;

+      if (iVar10 < 0) goto LAB_2;

+    }

+    else {

+      plVar11 = (longlong *)

+                ProcessFastCalloutClassify

+                          (param_1,lVar13,local_2b0,local_2d0,local_2c0,(longlong)&local_298,

+                           (uint *)param_6);

+    }

+    if (*(short *)(*(longlong *)(lVar13 + 0x18) + 0x18) == 2) {

+      local_1a8 = CONCAT44(*(undefined4 *)(*(longlong *)(lVar13 + 0x18) + 0x2c),2);

+    }

+    HandleFilterDeref(lVar13,'\0');

+    ppcVar18 = local_2d0;

+  }

 LAB_0:

-    if (((unaff_RSI != 0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-       ((1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29) &&

-        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)))) {

-      uStack0000000000000040 = unaff_R12D;

-      uStack0000000000000048 = (int)unaff_R13;

-      WPP_SF_DqqqqdD(WPP_GLOBAL_Control[3],pcVar4,plVar6,(int)unaff_RSI);

+  lVar13 = lStack_280;

+  if (local_258 == 0) {

+    if (lStack_280 != 0) {

+      lVar3 = *(longlong *)(lStack_280 + 0x50);

+      while (lVar6 = lVar3, lVar6 != 0) {

+        lVar3 = *(longlong *)(lVar6 + 0x50);

+        LOCK();

+        piVar1 = (int *)(lVar6 + -0x34);

+        iVar10 = *piVar1;

+        *piVar1 = *piVar1 + -1;

+        UNLOCK();

+        if ((iVar10 == 1) && (*(code **)(lVar6 + -0x28) != (code *)0x0)) {

+          (**(code **)(lVar6 + -0x28))();

+        }

+      }

+      *(undefined8 *)(lVar13 + 0x50) = 0;

     }

   }

   else {

-    if (*(char *)(unaff_RBP + -0x30) != (char)unaff_RSI) {

-      if ((((lVar5 == 0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-          (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

-        uVar8 = unaff_R14;

-        WPP_SF_qqqq(WPP_GLOBAL_Control[3],0x40,&WPP_7c3d35a92e0a3f1f9ef5aac07361a0fc_Traceguids,

-                    unaff_RDI);

-        uVar7 = (uint)uVar8;

-      }

-      StreamDropConnection(&stack0x00000070,unaff_RDI);

-      lVar5 = in_stack_00000070;

-      if (((in_stack_00000070 != 0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control))

-         && ((2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29) &&

-             ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)))) {

-        WPP_SF_qqqq(WPP_GLOBAL_Control[3],0x41,&WPP_7c3d35a92e0a3f1f9ef5aac07361a0fc_Traceguids,

-                    unaff_RDI);

-        uVar7 = (uint)unaff_R14;

-      }

-      plVar6 = *(longlong **)(unaff_RBP + -0x80);

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

-      (*DAT_1)(unaff_R13 & 0xffff,in_stack_00000078,plVar6,0,uVar7 & (uint)unaff_RSI);

-      goto LAB_2;

-    }

-    if (lVar5 != 0) {

-      in_stack_00000078 = in_stack_00000078 & unaff_RSI;

-      KfdAleFindFlowContextTable

-                (*(ulonglong *)(*(longlong *)(unaff_RBP + -0x80) + 0x20),

-                 (longlong *)&stack0x00000078);

-      uVar8 = in_stack_00000078;

-      WfpAleDereferenceEndpoint(in_stack_00000078 - 0x48);

-      plVar6 = &stack0x00000070;

-      pcVar4 = unaff_RDI;

-      unaff_RSI = StreamPermitData(uVar8,unaff_RDI,plVar6);

-      lVar5 = in_stack_00000070;

-      if (unaff_RSI != 0) goto LAB_0;

-    }

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

-    lVar5 = in_stack_00000070;

-  }

-LAB_2:

-  if (lVar5 != 0) {

-    StreamDataClose(unaff_RDI,lVar5,CONCAT71((int7)((ulonglong)plVar6 >> 8),1));

-    PplFreeToLookasideList(DAT_3,lVar5);

-  }

-  return unaff_RSI;

+    if (*(char *)(local_258 + 0x60) == '\0') {

+      if ((*(longlong *)(local_258 + 0x70) != 0) && (lStack_280 != 0)) {

+        *(longlong *)(lStack_280 + 0x50) = *(longlong *)(local_258 + 0x78) + 0x38;

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

+        *(undefined8 *)(lStack_280 + 0x68) = *(undefined8 *)(local_258 + 0x70);

+        *(undefined8 *)(local_258 + 0x70) = 0;

+      }

+    }

+    else if (lStack_280 != 0) {

+      *(undefined1 *)(lStack_280 + 0x60) = 1;

+    }

+    LOCK();

+    piVar1 = (int *)(local_258 + 4);

+    iVar10 = *piVar1;

+    *piVar1 = *piVar1 + -1;

+    UNLOCK();

+    if ((iVar10 == 1) && (*(code **)(local_258 + 0x10) != (code *)0x0)) {

+      (**(code **)(local_258 + 0x10))();

+    }

+  }

+  lVar13 = gWfpGlobal;

+  if (local_2c4 != 0) {

+    if (gWfpPerProContext != 0) {

+      iVar10 = KeGetCurrentProcessorNumberEx(0);

+      piVar1 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+      if (*piVar1 == 4) {

+        *piVar1 = 0;

+      }

+    }

+    NdisReleaseRWLock(*(undefined8 *)(lVar13 + 0x80),&local_2d8);

+  }

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

+    if (((int)*param_6 == 0x1001) && ((*(uint *)((longlong)param_6 + 0x1c) & 1) == 0)) {

+      cVar9 = '\x01';

+    }

+    else {

+      cVar9 = '\0';

+    }

+    local_1a0 = CONCAT31(local_1a0._1_3_,cVar9);

+    if ((cVar9 != '\0') && ((int)local_1a8 == 2)) {

+      LOCK();

+      bVar21 = gAuditModeEnabled != 0;

+      iVar10 = 0;

+      if (bVar21) {

+        iVar10 = gAuditModeEnabled;

+      }

+      gAuditModeEnabled = iVar10;

+      UNLOCK();

+      if (bVar21) {

+        FwAuditModeAuditEvent

+                  (param_1,(longlong)local_2b0,(uint *)ppcVar18,(longlong)param_6,

+                   (undefined4 *)&local_1a8);

+        *(undefined4 *)param_6 = 0x1002;

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

+            (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+          WPP_SF_D(WPP_GLOBAL_Control[3],0x1f,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids,

+                   (uint)param_1);

+        }

+      }

+    }

+    UpdateClassifyStats(param_1,(longlong)local_2b0,(longlong)ppcVar18,(uint *)param_6);

+  }

+  else {

+    *param_6 = 0;

+    param_6[1] = 0;

+    param_6[2] = 0;

+    param_6[3] = 0;

+    param_6[4] = 0;

+  }

+  if ((ppcVar18 != (char **)0x0) && (ppcVar18[0x30] != (char *)0x0)) {

+    *(uint *)(ppcVar18[0x30] + 4) = (uint)((int)*param_6 == 8);

+  }

+  local_2c8 = 0;

+  local_2c6 = 0;

+  if (*(int *)(gWfpGlobal + 0xb0) != 0) {

+    uVar20 = _DAT_3 / 10000;

+    LOCK();

+    plVar2 = (longlong *)(gWfpGlobal + 0x500);

+    lVar13 = *plVar2;

+    *plVar2 = *plVar2;

+    lVar3 = gWfpGlobal;

+    UNLOCK();

+    uVar15 = uVar20 - lVar13;

+    auVar5._8_8_ = 0;

+    auVar5._0_8_ = uVar15;

+    lVar13 = SUB168(ZEXT816(0x624dd2f1a9fbe77) * auVar5,8);

+    uVar15 = (uVar15 - lVar13 >> 1) + lVar13 >> 9;

+    if (9 < uVar15) {

+      local_2c0 = (char **)0x0;

+      cVar9 = KeGetCurrentIrql();

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

+        NdisAcquireRWLockWrite();

+      }

+      else {

+        NdisAcquireRWLockWrite(*(undefined8 *)(lVar3 + 0x6c0),&local_2c8,0);

+        if (gWfpPerProContext != 0) {

+          iVar10 = KeGetCurrentProcessorNumberEx(0);

+          puVar4 = *(undefined4 **)

+                    ((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+          *(ulonglong *)(puVar4 + 2) = _DAT_3;

+          *puVar4 = 4;

+        }

+      }

+      if ((*(char *)(gWfpGlobal + 0x4f8) == '\0') &&

+         (lVar13 = WfpPoolAllocNonPaged(0x10,0x4c706657,(longlong *)&local_2c0), lVar13 == 0)) {

+        *local_2c0 = (char *)0x0;

+        local_2c0[1] = (char *)0x0;

+        *(int *)(local_2c0 + 1) = (int)(uVar15 / 10);

+        NetioInsertWorkQueue(gWfpGlobal + 0x508,local_2c0);

+        *(undefined1 *)(gWfpGlobal + 0x4f8) = 1;

+        LOCK();

+        *(ulonglong *)(gWfpGlobal + 0x500) = uVar20;

+        UNLOCK();

+      }

+      lVar13 = gWfpGlobal;

+      if (gWfpPerProContext != 0) {

+        iVar10 = KeGetCurrentProcessorNumberEx(0);

+        piVar1 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+        if (*piVar1 == 4) {

+          *piVar1 = 0;

+        }

+      }

+      NdisReleaseRWLock(*(undefined8 *)(lVar13 + 0x6c0),&local_2c8);

+    }

+  }

+  return (ulonglong)plVar11 & 0xffffffff;

 }
```

## `KfdClassify2`  (modified)

```diff
--- KfdClassify2
+++ KfdClassify2
@@ -1,18 +1,512 @@
 

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

 

 ulonglong KfdClassify2(ushort *param_1,int *param_2)

 

 {

-  longlong in_RAX;

-  ulonglong unaff_RDI;

+  ushort uVar1;

+  undefined4 uVar2;

+  longlong *plVar3;

+  int *piVar4;

+  undefined8 uVar5;

+  undefined8 *puVar6;

+  undefined4 *puVar7;

+  code *pcVar8;

+  undefined1 uVar9;

+  int iVar10;

+  uint uVar11;

+  longlong *extraout_RAX;

+  longlong *extraout_RAX_00;

+  longlong lVar12;

+  ulonglong uVar13;

+  longlong *plVar14;

+  longlong *plVar15;

+  undefined1 *puVar16;

+  undefined1 *puVar17;

+  undefined1 *puVar18;

+  longlong *plVar19;

+  bool bVar20;

+  undefined1 auStack_6e8 [8];

+  undefined1 auStack_6e0 [24];

+  undefined4 local_6c8;

+  undefined2 local_6b8;

+  undefined1 local_6b6;

+  undefined2 local_6b4;

+  undefined1 local_6b2;

+  longlong *local_6b0;

+  longlong local_6a8 [2];

+  longlong *local_698 [2];

+  ushort *local_688;

+  int *local_680;

+  undefined4 local_678;

+  undefined8 local_674;

+  undefined8 local_66c;

+  undefined4 local_664;

+  undefined4 local_660;

+  undefined8 local_65c;

+  undefined4 local_654;

+  longlong local_650;

+  int local_648;

+  undefined4 local_644;

+  undefined1 local_5e8 [800];

+  undefined8 ***local_2c8;

+  undefined8 ***local_2c0;

+  undefined2 local_2b8;

+  undefined1 local_2b6 [302];

+  undefined8 ***local_188;

+  undefined8 ***local_180;

+  undefined2 local_178;

+  undefined1 local_176 [302];

+  ulonglong local_48;

   

-  if ((((unaff_RDI != 0) && (WPP_GLOBAL_Control != in_RAX)) &&

-      (1 < *(byte *)(WPP_GLOBAL_Control + 0x29))) &&

-     ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

-    WPP_SF_sd(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xf,

-              &WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"ArbitrateAndEnforce");

+                    /* 0x4fa80  182  KfdClassify2 */

+  puVar18 = local_5e8;

+  puVar17 = auStack_6e8;

+  puVar16 = auStack_6e8;

+  local_48 = __security_cookie ^ (ulonglong)auStack_6e8;

+  plVar14 = (longlong *)0x0;

+  uVar9 = 0;

+  local_674 = 0;

+  local_66c = 0;

+  local_664 = 0;

+  local_65c = 0;

+  plVar15 = (longlong *)0x0;

+  local_654 = 0;

+  local_644 = 0;

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

+    *param_2 = 0x1002;

+    plVar15 = plVar14;

+    puVar17 = auStack_6e8;

+    goto LAB_0;

   }

-  return unaff_RDI;

+  if (*(int *)(gWfpGlobal + 0xb8) != 1) {

+    *param_2 = 0x1001;

+    goto LAB_0;

+  }

+  local_648 = *(int *)(gWfpGlobal + 0xbc);

+  local_650 = (ulonglong)*param_1 * 0x88 + *(longlong *)(gWfpGlobal + 0x178);

+  param_2[0] = 0;

+  param_2[1] = 0;

+  param_2[2] = 0;

+  param_2[3] = 0;

+  param_2[4] = 0;

+  param_2[5] = 0;

+  param_2[6] = 0;

+  param_2[7] = 0;

+  param_2[8] = 0;

+  param_2[9] = 0;

+  param_2[6] = -1;

+  local_660 = 0xffffffff;

+  local_678 = 0;

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

+    *param_2 = 0x1001;

+    local_678 = 0x1001;

+  }

+  local_688 = param_1;

+  local_680 = param_2;

+  if (local_648 < 3) {

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

+      uVar9 = KfRaiseIrql(2);

+    }

+    if (*(int *)(gWfpGlobal + 0xbc) == 0) {

+LAB_1:

+      plVar15 = (longlong *)KfdClassifyFast((longlong *)&local_688);

+      puVar17 = auStack_6e8;

+      if ((*(uint *)(local_688 + 0x20) & 1) == 0) {

+        KeLowerIrql(uVar9);

+        puVar17 = auStack_6e8;

+      }

+LAB_2:

+      if (plVar15 != (longlong *)0x0) goto LAB_3;

+    }

+    else {

+      if (*(int *)(gWfpGlobal + 0xbc) < 3) {

+        LOCK();

+        bVar20 = *(int *)(gWfpGlobal + 0xbc) == 2;

+        if (bVar20) {

+          *(int *)(gWfpGlobal + 0xbc) = 0;

+        }

+        UNLOCK();

+        if (bVar20) goto LAB_1;

+      }

+      if ((*(uint *)(local_688 + 0x20) & 1) == 0) {

+        KeLowerIrql(uVar9);

+      }

+      memset(local_2b6,0,0x126);

+      local_698[0] = (longlong *)0x0;

+      local_6b8 = 0;

+      local_6b6 = 0;

+      local_2c0 = &local_2c8;

+      local_2b8 = 0;

+      local_2c8 = &local_2c8;

+      plVar15 = (longlong *)FeAcquireReadEngineLock(&local_6b8,1);

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

+        if ((*(int *)(local_650 + 0x48) == 0) || ((int)(*(longlong **)(local_650 + 0x68))[1] == 4))

+        {

+LAB_4:

+          lVar12 = gWfpGlobal;

+          if (gWfpPerProContext != 0) {

+            iVar10 = KeGetCurrentProcessorNumberEx(0);

+            piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext

+                              );

+            if (*piVar4 == 4) {

+              *piVar4 = 0;

+            }

+          }

+          NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80));

+        }

+        else {

+          plVar3 = (longlong *)**(longlong **)(local_650 + 0x68);

+          plVar19 = (longlong *)*plVar3;

+          plVar15 = plVar14;

+          if (plVar19 != plVar3) {

+            do {

+              puVar18 = (undefined1 *)

+                        InsertFilterToMatchBuf

+                                  ((longlong)plVar15,(longlong)plVar19,(longlong *)local_698,

+                                   (longlong)(puVar18 + 800));

+              plVar15 = extraout_RAX;

+              if (extraout_RAX != (longlong *)0x0) goto LAB_4;

+              plVar19 = (longlong *)*plVar19;

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

+                plVar14 = local_698[0];

+              }

+              plVar15 = local_698[0];

+            } while (plVar19 != plVar3);

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

+              plVar15 = *(longlong **)(puVar18 + 0x328);

+              if ((undefined1 *)*plVar15 != puVar18 + 800) goto LAB_5;

+              plVar14[1] = (longlong)plVar15;

+              *plVar14 = (longlong)(puVar18 + 800);

+              *plVar15 = (longlong)plVar14;

+              *(longlong **)(puVar18 + 0x328) = plVar14;

+            }

+          }

+          lVar12 = gWfpGlobal;

+          if (gWfpPerProContext != 0) {

+            iVar10 = KeGetCurrentProcessorNumberEx(0);

+            piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext

+                              );

+            if (*piVar4 == 4) {

+              *piVar4 = 0;

+            }

+          }

+          NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80),&local_6b8);

+          local_6a8[0] = 0;

+          plVar15 = (longlong *)GetNextFilter((longlong *)(puVar18 + 800),local_6a8);

+          lVar12 = local_6a8[0];

+          while (((local_6a8[0] = lVar12, plVar15 == (longlong *)0x0 && (lVar12 != 0)) &&

+                 (plVar15 = (longlong *)ProcessCallout2(lVar12,(longlong *)&local_688),

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

+            HandleFilterDeref(lVar12,'\0');

+            plVar15 = (longlong *)GetNextFilter((longlong *)(puVar18 + 800),local_6a8);

+            lVar12 = local_6a8[0];

+          }

+          plVar14 = *(longlong **)(puVar18 + 800);

+          if (*(longlong **)(puVar18 + 800) != (longlong *)(puVar18 + 800)) {

+            do {

+              plVar3 = (longlong *)*plVar14;

+              FreeMatchBufListInternal((longlong)plVar14);

+              plVar14 = plVar3;

+            } while (plVar3 != (longlong *)(puVar18 + 800));

+          }

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

+               ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

+              (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+             ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

+            local_6c8 = SUB84(plVar15,0);

+            WPP_SF_sd(WPP_GLOBAL_Control[3],0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

+                      "ArbitrateSlow");

+          }

+        }

+      }

+      puVar17 = auStack_6e8;

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

+        puVar17 = auStack_6e8;

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

+            (puVar17 = auStack_6e8, 1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           (puVar17 = auStack_6e8, (*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0))

+        {

+          local_6c8 = SUB84(plVar15,0);

+          WPP_SF_sd(WPP_GLOBAL_Control[3],0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

+                    "IndexListClassify2Slow");

+          puVar17 = auStack_6e8;

+        }

+        goto LAB_6;

+      }

+    }

+LAB_7:

+    uVar2 = *(undefined4 *)(puVar18 + -0x5c);

+    if ((*param_2 == 0x1001) && (param_2[6] == 2)) {

+      LOCK();

+      bVar20 = gAuditModeEnabled == 0;

+      if (bVar20) {

+        gAuditModeEnabled = 0;

+      }

+      UNLOCK();

+      if (!bVar20) {

+        uVar1 = *param_1;

+        *(undefined8 *)(puVar17 + -8) = 0x14005028f;

+        memset(puVar18 + -0x50,0,0x368);

+        lVar12 = *(longlong *)(param_2 + 4);

+        *(ulonglong *)(puVar18 + 0xb8) = (ulonglong)uVar1;

+        *(undefined2 *)(puVar18 + 0x108) = 0x10;

+        *(undefined4 *)(puVar18 + 0xd0) = 0x1428;

+        *(undefined1 **)(puVar17 + 0x20) = puVar18 + 0x2ec;

+        *(undefined4 *)(puVar18 + -0x50) = 6;

+        *(undefined8 *)(puVar17 + 0x58) = 0;

+        *(undefined8 *)(puVar17 + -8) = 0x1400502dd;

+        lVar12 = SetFirewallAuditMetadata

+                           (lVar12,uVar1,(longlong *)(puVar17 + 0x58),puVar18 + 0x2d8,

+                            *(byte **)(puVar17 + 0x20));

+        if (lVar12 == 0) {

+          if (uVar1 == 0x4e) {

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

+            puVar6 = (undefined8 *)**(undefined8 **)(*(longlong *)(lVar12 + 0x20) + 0x10);

+            if (param_1[0x14] == 2) {

+              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

+              *(undefined2 *)(puVar18 + -0x48) = 2;

+              *(undefined4 *)(puVar18 + -0x44) = *(undefined4 *)puVar6;

+              puVar7 = *(undefined4 **)(lVar12 + 0x18);

+              uVar1 = param_1[0x16];

+              *(undefined2 *)(puVar18 + 0x38) = 2;

+              *(ushort *)(puVar18 + 0x3a) = uVar1;

+              *(undefined4 *)(puVar18 + 0x3c) = *puVar7;

+            }

+            else if (param_1[0x14] == 0x17) {

+              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

+              *(undefined2 *)(puVar18 + -0x48) = 0x17;

+              uVar5 = puVar6[1];

+              uVar1 = param_1[0x16];

+              *(undefined8 *)(puVar18 + -0x40) = *puVar6;

+              *(undefined8 *)(puVar18 + -0x38) = uVar5;

+              puVar6 = *(undefined8 **)(lVar12 + 0x18);

+              *(undefined2 *)(puVar18 + 0x38) = 0x17;

+              *(ushort *)(puVar18 + 0x3a) = uVar1;

+              uVar5 = puVar6[1];

+              *(undefined8 *)(puVar18 + 0x40) = *puVar6;

+              *(undefined8 *)(puVar18 + 0x48) = uVar5;

+            }

+            *(undefined8 *)(puVar18 + 0x128) =

+                 *(undefined8 *)(*(longlong *)(*(longlong *)(lVar12 + 0x20) + 8) + 0x10);

+            *(undefined4 *)(puVar18 + 0x13c) = 0x3900;

+            uVar11 = *(byte *)(lVar12 + 0x10) & 1;

+LAB_8:

+            *(uint *)(puVar18 + 0x140) = uVar11;

+          }

+          else if (uVar1 == 0x4f) {

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

+            puVar6 = (undefined8 *)**(undefined8 **)(*plVar14 + 0x10);

+            if (param_1[0x14] == 2) {

+              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

+              *(undefined2 *)(puVar18 + -0x48) = 2;

+              *(undefined4 *)(puVar18 + -0x44) = *(undefined4 *)puVar6;

+              puVar7 = (undefined4 *)plVar14[1];

+              uVar1 = param_1[0x16];

+              *(undefined2 *)(puVar18 + 0x38) = 2;

+              *(ushort *)(puVar18 + 0x3a) = uVar1;

+              *(undefined4 *)(puVar18 + 0x3c) = *puVar7;

+            }

+            else if (param_1[0x14] == 0x17) {

+              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

+              *(undefined2 *)(puVar18 + -0x48) = 0x17;

+              uVar5 = puVar6[1];

+              uVar1 = param_1[0x16];

+              *(undefined8 *)(puVar18 + -0x40) = *puVar6;

+              *(undefined8 *)(puVar18 + -0x38) = uVar5;

+              puVar6 = (undefined8 *)plVar14[1];

+              *(undefined2 *)(puVar18 + 0x38) = 0x17;

+              *(ushort *)(puVar18 + 0x3a) = uVar1;

+              uVar5 = puVar6[1];

+              *(undefined8 *)(puVar18 + 0x40) = *puVar6;

+              *(undefined8 *)(puVar18 + 0x48) = uVar5;

+            }

+            *(undefined8 *)(puVar18 + 0x128) = *(undefined8 *)(*(longlong *)(*plVar14 + 8) + 0x10);

+            *(undefined4 *)(puVar18 + 0x13c) = 0x3901;

+            uVar11 = (uint)*(byte *)((longlong)plVar14 + 0x2c);

+            goto LAB_8;

+          }

+          *(undefined4 *)(puVar18 + 0x30c) = 2;

+          *(undefined4 *)(puVar18 + 0x310) = uVar2;

+          switch(*(undefined4 *)(puVar18 + -0x50)) {

+          case 1:

+            *(undefined8 *)(puVar17 + -8) = 0x14005048b;

+            WfpAuditEventGeneral((longlong)(puVar18 + -0x50));

+            break;

+          case 2:

+            *(undefined8 *)(puVar17 + -8) = 0x14005052c;

+            WfpAuditEventVeto((longlong)(puVar18 + -0x50));

+            break;

+          case 3:

+            *(undefined8 *)(puVar17 + -8) = 0x14005053a;

+            WfpAuditBindEvent((longlong)(puVar18 + -0x50));

+            break;

+          case 4:

+            *(undefined8 *)(puVar17 + -8) = 0x140050548;

+            WfpAuditListenEvent((longlong)(puVar18 + -0x50));

+            break;

+          case 5:

+            *(undefined8 *)(puVar17 + -8) = 0x140050556;

+            WfpAuditConnectAcceptEvent((longlong)(puVar18 + -0x50));

+            break;

+          case 6:

+            *(undefined8 *)(puVar17 + -8) = 0x140050564;

+            WfpAuditFirewallAuditEvent((longlong)(puVar18 + -0x50));

+            break;

+          default:

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

+            (*pcVar8)(0x25);

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

+            uVar13 = (*pcVar8)();

+            return uVar13;

+          }

+        }

+        if (*(longlong *)(puVar17 + 0x58) != 0) {

+          *(undefined8 *)(puVar17 + -8) = 0x14005049e;

+          ExFreePoolWithTag(*(longlong *)(puVar17 + 0x58),0);

+        }

+        *param_2 = 0x1002;

+        if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+            (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 3)) ||

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) == 0)) goto LAB_0;

+        uVar1 = *param_1;

+        uVar5 = WPP_GLOBAL_Control[3];

+        *(undefined8 *)(puVar17 + -8) = 0x1400504e7;

+        WPP_SF_D(uVar5,0x1c,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids,(uint)uVar1);

+      }

+    }

+  }

+  else {

+    memset(local_176,0,0x126);

+    local_6b0 = (longlong *)0x0;

+    local_6b4 = 0;

+    local_6b2 = 0;

+    local_180 = &local_188;

+    local_178 = 0;

+    local_188 = &local_188;

+    plVar15 = (longlong *)FeAcquireReadEngineLock(&local_6b4,1);

+    puVar17 = auStack_6e8;

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

+      if ((*(int *)(local_650 + 0x48) == 0) || ((int)(*(longlong **)(local_650 + 0x68))[1] == 4)) {

+LAB_9:

+        lVar12 = gWfpGlobal;

+        if (gWfpPerProContext != 0) {

+          iVar10 = KeGetCurrentProcessorNumberEx(0);

+          piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+          if (*piVar4 == 4) {

+            *piVar4 = 0;

+          }

+        }

+        NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80));

+        puVar17 = auStack_6e8;

+      }

+      else {

+        plVar3 = (longlong *)**(longlong **)(local_650 + 0x68);

+        plVar19 = (longlong *)*plVar3;

+        puVar17 = auStack_6e8;

+        plVar15 = plVar14;

+        if (plVar19 != plVar3) {

+          do {

+            puVar18 = (undefined1 *)

+                      InsertFilterToMatchBuf

+                                ((longlong)plVar15,(longlong)plVar19,(longlong *)&local_6b0,

+                                 (longlong)(puVar18 + 0x460));

+            plVar15 = extraout_RAX_00;

+            if (extraout_RAX_00 != (longlong *)0x0) goto LAB_9;

+            plVar19 = (longlong *)*plVar19;

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

+              plVar14 = local_6b0;

+            }

+            plVar15 = local_6b0;

+          } while (plVar19 != plVar3);

+          puVar17 = auStack_6e8;

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

+            plVar15 = *(longlong **)(puVar18 + 0x468);

+            if ((undefined1 *)*plVar15 != puVar18 + 0x460) {

+LAB_5:

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

+              plVar15 = (longlong *)(*pcVar8)(3);

+              puVar16 = auStack_6e0;

+            }

+            plVar14[1] = (longlong)plVar15;

+            *plVar14 = (longlong)(puVar18 + 0x460);

+            *plVar15 = (longlong)plVar14;

+            *(longlong **)(puVar18 + 0x468) = plVar14;

+            puVar17 = puVar16;

+          }

+        }

+        lVar12 = gWfpGlobal;

+        if (gWfpPerProContext != 0) {

+          *(undefined8 *)(puVar17 + -8) = 0x140050038;

+          iVar10 = KeGetCurrentProcessorNumberEx(0);

+          piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

+          if (*piVar4 == 4) {

+            *piVar4 = 0;

+          }

+        }

+        uVar5 = *(undefined8 *)(lVar12 + 0x80);

+        *(undefined8 *)(puVar17 + -8) = 0x140050073;

+        NdisReleaseRWLock(uVar5,puVar17 + 0x34);

+        *(undefined8 *)(puVar17 + 0x48) = 0;

+        *(undefined8 *)(puVar17 + -8) = 0x14005008e;

+        plVar15 = (longlong *)

+                  GetNextFilter((longlong *)(puVar18 + 0x460),(undefined8 *)(puVar17 + 0x48));

+        while ((plVar15 == (longlong *)0x0 && (lVar12 = *(longlong *)(puVar17 + 0x48), lVar12 != 0))

+              ) {

+          *(undefined8 *)(puVar17 + -8) = 0x1400500ad;

+          plVar15 = (longlong *)ProcessCallout2(lVar12,(longlong *)(puVar17 + 0x60));

+          if (plVar15 != (longlong *)0x0) break;

+          *(undefined8 *)(puVar17 + -8) = 0x1400500bf;

+          HandleFilterDeref(lVar12,'\0');

+          *(undefined8 *)(puVar17 + -8) = 0x1400500d0;

+          plVar15 = (longlong *)

+                    GetNextFilter((longlong *)(puVar18 + 0x460),(undefined8 *)(puVar17 + 0x48));

+        }

+        plVar14 = *(longlong **)(puVar18 + 0x460);

+        if (plVar14 != (longlong *)(puVar18 + 0x460)) {

+          do {

+            plVar3 = (longlong *)*plVar14;

+            *(undefined8 *)(puVar17 + -8) = 0x1400500f8;

+            FreeMatchBufListInternal((longlong)plVar14);

+            plVar14 = plVar3;

+          } while (plVar3 != (longlong *)(puVar18 + 0x460));

+        }

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

+             ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

+            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

+          uVar5 = WPP_GLOBAL_Control[3];

+          *(int *)(puVar17 + 0x20) = (int)plVar15;

+          *(undefined8 *)(puVar17 + -8) = 0x14005015a;

+          WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"ArbitrateSlow");

+        }

+      }

+    }

+    if (plVar15 == (longlong *)0x0) goto LAB_7;

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

+        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

+      uVar5 = WPP_GLOBAL_Control[3];

+      *(int *)(puVar17 + 0x20) = (int)plVar15;

+      *(undefined8 *)(puVar17 + -8) = 0x1400501ff;

+      WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"IndexListClassify2Slow")

+      ;

+    }

+LAB_6:

+    if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+        (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) ||

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) == 0)) goto LAB_2;

+    uVar5 = WPP_GLOBAL_Control[3];

+    *(int *)(puVar17 + 0x20) = (int)plVar15;

+    *(undefined8 *)(puVar17 + -8) = 0x14005023a;

+    WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"KfdClassifySlow");

+  }

+LAB_3:

+  if (*param_2 == 0) {

+    *param_2 = 7;

+  }

+LAB_0:

+  *(undefined8 *)(puVar17 + -8) = 0x140050507;

+  return (ulonglong)plVar15 & 0xffffffff;

 }
```

## `KfdClassify2`  (modified)

```diff
--- KfdClassify2
+++ KfdDirectClassify
@@ -1,512 +1,104 @@
 

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

 

-ulonglong KfdClassify2(ushort *param_1,int *param_2)

+longlong KfdDirectClassify(ushort param_1,ushort *param_2,char **param_3,char **param_4,

+                          undefined8 *param_5,uint *param_6)

 

 {

-  ushort uVar1;

-  undefined4 uVar2;

-  longlong *plVar3;

-  int *piVar4;

-  undefined8 uVar5;

-  undefined8 *puVar6;

-  undefined4 *puVar7;

-  code *pcVar8;

-  undefined1 uVar9;

-  int iVar10;

-  uint uVar11;

-  longlong *extraout_RAX;

-  longlong *extraout_RAX_00;

-  longlong lVar12;

-  ulonglong uVar13;

-  longlong *plVar14;

-  longlong *plVar15;

-  undefined1 *puVar16;

-  undefined1 *puVar17;

-  undefined1 *puVar18;

-  longlong *plVar19;

-  bool bVar20;

-  undefined1 auStack_6e8 [8];

-  undefined1 auStack_6e0 [24];

-  undefined4 local_6c8;

-  undefined2 local_6b8;

-  undefined1 local_6b6;

-  undefined2 local_6b4;

-  undefined1 local_6b2;

-  longlong *local_6b0;

-  longlong local_6a8 [2];

-  longlong *local_698 [2];

-  ushort *local_688;

-  int *local_680;

-  undefined4 local_678;

-  undefined8 local_674;

-  undefined8 local_66c;

-  undefined4 local_664;

-  undefined4 local_660;

-  undefined8 local_65c;

-  undefined4 local_654;

-  longlong local_650;

-  int local_648;

-  undefined4 local_644;

-  undefined1 local_5e8 [800];

-  undefined8 ***local_2c8;

-  undefined8 ***local_2c0;

-  undefined2 local_2b8;

-  undefined1 local_2b6 [302];

-  undefined8 ***local_188;

-  undefined8 ***local_180;

-  undefined2 local_178;

-  undefined1 local_176 [302];

-  ulonglong local_48;

+  uint uVar1;

+  undefined8 *puVar2;

+  byte bVar3;

+  int iVar4;

+  byte bVar5;

+  longlong lVar6;

+  longlong lVar7;

+  undefined1 auStackY_e8 [32];

+  int local_98 [2];

+  undefined8 local_90;

+  undefined4 local_88;

+  char **local_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  ulonglong local_50;

   

-                    /* 0x4fa80  182  KfdClassify2 */

-  puVar18 = local_5e8;

-  puVar17 = auStack_6e8;

-  puVar16 = auStack_6e8;

-  local_48 = __security_cookie ^ (ulonglong)auStack_6e8;

-  plVar14 = (longlong *)0x0;

-  uVar9 = 0;

-  local_674 = 0;

-  local_66c = 0;

-  local_664 = 0;

-  local_65c = 0;

-  plVar15 = (longlong *)0x0;

-  local_654 = 0;

-  local_644 = 0;

-  if ((*(uint *)(param_1 + 0x20) & 2) != 0) {

-    *param_2 = 0x1002;

-    plVar15 = plVar14;

-    puVar17 = auStack_6e8;

-    goto LAB_0;

-  }

-  if (*(int *)(gWfpGlobal + 0xb8) != 1) {

-    *param_2 = 0x1001;

-    goto LAB_0;

-  }

-  local_648 = *(int *)(gWfpGlobal + 0xbc);

-  local_650 = (ulonglong)*param_1 * 0x88 + *(longlong *)(gWfpGlobal + 0x178);

-  param_2[0] = 0;

-  param_2[1] = 0;

-  param_2[2] = 0;

-  param_2[3] = 0;

-  param_2[4] = 0;

-  param_2[5] = 0;

-  param_2[6] = 0;

-  param_2[7] = 0;

-  param_2[8] = 0;

-  param_2[9] = 0;

-  param_2[6] = -1;

-  local_660 = 0xffffffff;

-  local_678 = 0;

-  if ((*(uint *)(param_1 + 0x20) & 4) != 0) {

-    *param_2 = 0x1001;

-    local_678 = 0x1001;

-  }

-  local_688 = param_1;

-  local_680 = param_2;

-  if (local_648 < 3) {

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

-      uVar9 = KfRaiseIrql(2);

+                    /* 0x50580  189  KfdDirectClassify */

+  local_50 = __security_cookie ^ (ulonglong)auStackY_e8;

+  lVar6 = 0;

+  param_6[0] = 0;

+  param_6[1] = 0;

+  param_6[2] = 0;

+  param_6[3] = 0;

+  param_6[4] = 0;

+  param_6[5] = 0;

+  param_6[6] = 0;

+  param_6[7] = 0;

+  param_6[8] = 0;

+  param_6[9] = 0;

+  param_6[6] = 1;

+  local_98[0] = 0;

+  local_90 = 0;

+  local_88 = 0;

+  if (*(int *)(gWfpGlobal + 0xb8) == 1) {

+    local_78 = *(undefined8 *)param_6;

+    uStack_70 = *(undefined8 *)(param_6 + 2);

+    local_68 = *(undefined8 *)(param_6 + 4);

+    uStack_60 = *(undefined8 *)(param_6 + 6);

+    local_58 = *(undefined8 *)(param_6 + 8);

+    local_80 = param_4;

+    lVar7 = lVar6;

+    for (puVar2 = (undefined8 *)*param_5; iVar4 = (int)lVar7, puVar2 != param_5;

+        puVar2 = (undefined8 *)*puVar2) {

+      lVar6 = puVar2[2];

+      if ((*(uint *)(*(longlong *)(lVar6 + 0x18) + 0x28) & 0x4000) != 0) {

+        ProcessCallout(param_1,param_2,param_3,local_80,lVar7,lVar6,(uint *)&local_78,(uint *)lVar7,

+                       (undefined4 *)lVar7,(undefined4 *)lVar7);

+        if ((((uint)local_78 ^ *(uint *)(puVar2 + 3)) >> 0xc & 1) != 0) {

+          return (ulonglong)(uint3)(((uint)local_78 ^ *(uint *)(puVar2 + 3)) >> 8) << 8;

+        }

+        iVar4 = 1;

+        lVar7 = 0;

+      }

+      UpdateClassifyOut((uint *)&local_78,param_6,lVar6,iVar4,local_98);

     }

-    if (*(int *)(gWfpGlobal + 0xbc) == 0) {

-LAB_1:

-      plVar15 = (longlong *)KfdClassifyFast((longlong *)&local_688);

-      puVar17 = auStack_6e8;

-      if ((*(uint *)(local_688 + 0x20) & 1) == 0) {

-        KeLowerIrql(uVar9);

-        puVar17 = auStack_6e8;

+    bVar5 = 1;

+    CheckAndSetDefaultAction((int *)param_6);

+    uVar1 = param_6[8];

+    param_6[8] = uVar1 & 0xefffffff;

+    if (local_98[0] != iVar4) {

+      param_6[8] = uVar1 & 0xefffffff | 0x10000000;

+    }

+    if (*param_6 == 0x1001) {

+      bVar3 = (byte)local_88;

+      if (((byte)param_6[7] & bVar5) == 0) {

+        bVar3 = bVar5;

       }

-LAB_2:

-      if (plVar15 != (longlong *)0x0) goto LAB_3;

+      local_88 = CONCAT31(local_88._1_3_,bVar3);

     }

-    else {

-      if (*(int *)(gWfpGlobal + 0xbc) < 3) {

-        LOCK();

-        bVar20 = *(int *)(gWfpGlobal + 0xbc) == 2;

-        if (bVar20) {

-          *(int *)(gWfpGlobal + 0xbc) = 0;

-        }

-        UNLOCK();

-        if (bVar20) goto LAB_1;

-      }

-      if ((*(uint *)(local_688 + 0x20) & 1) == 0) {

-        KeLowerIrql(uVar9);

-      }

-      memset(local_2b6,0,0x126);

-      local_698[0] = (longlong *)0x0;

-      local_6b8 = 0;

-      local_6b6 = 0;

-      local_2c0 = &local_2c8;

-      local_2b8 = 0;

-      local_2c8 = &local_2c8;

-      plVar15 = (longlong *)FeAcquireReadEngineLock(&local_6b8,1);

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

-        if ((*(int *)(local_650 + 0x48) == 0) || ((int)(*(longlong **)(local_650 + 0x68))[1] == 4))

-        {

-LAB_4:

-          lVar12 = gWfpGlobal;

-          if (gWfpPerProContext != 0) {

-            iVar10 = KeGetCurrentProcessorNumberEx(0);

-            piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext

-                              );

-            if (*piVar4 == 4) {

-              *piVar4 = 0;

-            }

-          }

-          NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80));

-        }

-        else {

-          plVar3 = (longlong *)**(longlong **)(local_650 + 0x68);

-          plVar19 = (longlong *)*plVar3;

-          plVar15 = plVar14;

-          if (plVar19 != plVar3) {

-            do {

-              puVar18 = (undefined1 *)

-                        InsertFilterToMatchBuf

-                                  ((longlong)plVar15,(longlong)plVar19,(longlong *)local_698,

-                                   (longlong)(puVar18 + 800));

-              plVar15 = extraout_RAX;

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

-              plVar19 = (longlong *)*plVar19;

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

-                plVar14 = local_698[0];

-              }

-              plVar15 = local_698[0];

-            } while (plVar19 != plVar3);

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

-              plVar15 = *(longlong **)(puVar18 + 0x328);

-              if ((undefined1 *)*plVar15 != puVar18 + 800) goto LAB_5;

-              plVar14[1] = (longlong)plVar15;

-              *plVar14 = (longlong)(puVar18 + 800);

-              *plVar15 = (longlong)plVar14;

-              *(longlong **)(puVar18 + 0x328) = plVar14;

-            }

-          }

-          lVar12 = gWfpGlobal;

-          if (gWfpPerProContext != 0) {

-            iVar10 = KeGetCurrentProcessorNumberEx(0);

-            piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext

-                              );

-            if (*piVar4 == 4) {

-              *piVar4 = 0;

-            }

-          }

-          NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80),&local_6b8);

-          local_6a8[0] = 0;

-          plVar15 = (longlong *)GetNextFilter((longlong *)(puVar18 + 800),local_6a8);

-          lVar12 = local_6a8[0];

-          while (((local_6a8[0] = lVar12, plVar15 == (longlong *)0x0 && (lVar12 != 0)) &&

-                 (plVar15 = (longlong *)ProcessCallout2(lVar12,(longlong *)&local_688),

-                 plVar15 == (longlong *)0x0))) {

-            HandleFilterDeref(lVar12,'\0');

-            plVar15 = (longlong *)GetNextFilter((longlong *)(puVar18 + 800),local_6a8);

-            lVar12 = local_6a8[0];

-          }

-          plVar14 = *(longlong **)(puVar18 + 800);

-          if (*(longlong **)(puVar18 + 800) != (longlong *)(puVar18 + 800)) {

-            do {

-              plVar3 = (longlong *)*plVar14;

-              FreeMatchBufListInternal((longlong)plVar14);

-              plVar14 = plVar3;

-            } while (plVar3 != (longlong *)(puVar18 + 800));

-          }

-          if ((((plVar15 != (longlong *)0x0) &&

-               ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-              (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-             ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

-            local_6c8 = SUB84(plVar15,0);

-            WPP_SF_sd(WPP_GLOBAL_Control[3],0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

-                      "ArbitrateSlow");

-          }

-        }

-      }

-      puVar17 = auStack_6e8;

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

-        puVar17 = auStack_6e8;

+    if (lVar6 != 0) {

+      local_90 = CONCAT44(*(undefined4 *)(*(longlong *)(lVar6 + 0x18) + 0x2c),

+                          (uint)*(ushort *)(*(longlong *)(lVar6 + 0x18) + 0x18));

+      iVar4 = IsAuditApplicableAndEnabledForSublayer((int *)&local_90);

+      if (iVar4 != 0) {

+        FwAuditModeAuditEvent

+                  (param_1,(longlong)param_2,(uint *)param_3,(longlong)param_6,

+                   (undefined4 *)&local_90);

+        *param_6 = 0x1002;

         if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

-            (puVar17 = auStack_6e8, 1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-           (puVar17 = auStack_6e8, (*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0))

-        {

-          local_6c8 = SUB84(plVar15,0);

-          WPP_SF_sd(WPP_GLOBAL_Control[3],0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,

-                    "IndexListClassify2Slow");

-          puVar17 = auStack_6e8;

-        }

-        goto LAB_6;

-      }

-    }

-LAB_7:

-    uVar2 = *(undefined4 *)(puVar18 + -0x5c);

-    if ((*param_2 == 0x1001) && (param_2[6] == 2)) {

-      LOCK();

-      bVar20 = gAuditModeEnabled == 0;

-      if (bVar20) {

-        gAuditModeEnabled = 0;

-      }

-      UNLOCK();

-      if (!bVar20) {

-        uVar1 = *param_1;

-        *(undefined8 *)(puVar17 + -8) = 0x14005028f;

-        memset(puVar18 + -0x50,0,0x368);

-        lVar12 = *(longlong *)(param_2 + 4);

-        *(ulonglong *)(puVar18 + 0xb8) = (ulonglong)uVar1;

-        *(undefined2 *)(puVar18 + 0x108) = 0x10;

-        *(undefined4 *)(puVar18 + 0xd0) = 0x1428;

-        *(undefined1 **)(puVar17 + 0x20) = puVar18 + 0x2ec;

-        *(undefined4 *)(puVar18 + -0x50) = 6;

-        *(undefined8 *)(puVar17 + 0x58) = 0;

-        *(undefined8 *)(puVar17 + -8) = 0x1400502dd;

-        lVar12 = SetFirewallAuditMetadata

-                           (lVar12,uVar1,(longlong *)(puVar17 + 0x58),puVar18 + 0x2d8,

-                            *(byte **)(puVar17 + 0x20));

-        if (lVar12 == 0) {

-          if (uVar1 == 0x4e) {

-            lVar12 = *(longlong *)(param_1 + 0xc);

-            puVar6 = (undefined8 *)**(undefined8 **)(*(longlong *)(lVar12 + 0x20) + 0x10);

-            if (param_1[0x14] == 2) {

-              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

-              *(undefined2 *)(puVar18 + -0x48) = 2;

-              *(undefined4 *)(puVar18 + -0x44) = *(undefined4 *)puVar6;

-              puVar7 = *(undefined4 **)(lVar12 + 0x18);

-              uVar1 = param_1[0x16];

-              *(undefined2 *)(puVar18 + 0x38) = 2;

-              *(ushort *)(puVar18 + 0x3a) = uVar1;

-              *(undefined4 *)(puVar18 + 0x3c) = *puVar7;

-            }

-            else if (param_1[0x14] == 0x17) {

-              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

-              *(undefined2 *)(puVar18 + -0x48) = 0x17;

-              uVar5 = puVar6[1];

-              uVar1 = param_1[0x16];

-              *(undefined8 *)(puVar18 + -0x40) = *puVar6;

-              *(undefined8 *)(puVar18 + -0x38) = uVar5;

-              puVar6 = *(undefined8 **)(lVar12 + 0x18);

-              *(undefined2 *)(puVar18 + 0x38) = 0x17;

-              *(ushort *)(puVar18 + 0x3a) = uVar1;

-              uVar5 = puVar6[1];

-              *(undefined8 *)(puVar18 + 0x40) = *puVar6;

-              *(undefined8 *)(puVar18 + 0x48) = uVar5;

-            }

-            *(undefined8 *)(puVar18 + 0x128) =

-                 *(undefined8 *)(*(longlong *)(*(longlong *)(lVar12 + 0x20) + 8) + 0x10);

-            *(undefined4 *)(puVar18 + 0x13c) = 0x3900;

-            uVar11 = *(byte *)(lVar12 + 0x10) & 1;

-LAB_8:

-            *(uint *)(puVar18 + 0x140) = uVar11;

-          }

-          else if (uVar1 == 0x4f) {

-            plVar14 = *(longlong **)(param_1 + 0x10);

-            puVar6 = (undefined8 *)**(undefined8 **)(*plVar14 + 0x10);

-            if (param_1[0x14] == 2) {

-              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

-              *(undefined2 *)(puVar18 + -0x48) = 2;

-              *(undefined4 *)(puVar18 + -0x44) = *(undefined4 *)puVar6;

-              puVar7 = (undefined4 *)plVar14[1];

-              uVar1 = param_1[0x16];

-              *(undefined2 *)(puVar18 + 0x38) = 2;

-              *(ushort *)(puVar18 + 0x3a) = uVar1;

-              *(undefined4 *)(puVar18 + 0x3c) = *puVar7;

-            }

-            else if (param_1[0x14] == 0x17) {

-              *(ushort *)(puVar18 + -0x46) = param_1[0x15];

-              *(undefined2 *)(puVar18 + -0x48) = 0x17;

-              uVar5 = puVar6[1];

-              uVar1 = param_1[0x16];

-              *(undefined8 *)(puVar18 + -0x40) = *puVar6;

-              *(undefined8 *)(puVar18 + -0x38) = uVar5;

-              puVar6 = (undefined8 *)plVar14[1];

-              *(undefined2 *)(puVar18 + 0x38) = 0x17;

-              *(ushort *)(puVar18 + 0x3a) = uVar1;

-              uVar5 = puVar6[1];

-              *(undefined8 *)(puVar18 + 0x40) = *puVar6;

-              *(undefined8 *)(puVar18 + 0x48) = uVar5;

-            }

-            *(undefined8 *)(puVar18 + 0x128) = *(undefined8 *)(*(longlong *)(*plVar14 + 8) + 0x10);

-            *(undefined4 *)(puVar18 + 0x13c) = 0x3901;

-            uVar11 = (uint)*(byte *)((longlong)plVar14 + 0x2c);

-            goto LAB_8;

-          }

-          *(undefined4 *)(puVar18 + 0x30c) = 2;

-          *(undefined4 *)(puVar18 + 0x310) = uVar2;

-          switch(*(undefined4 *)(puVar18 + -0x50)) {

-          case 1:

-            *(undefined8 *)(puVar17 + -8) = 0x14005048b;

-            WfpAuditEventGeneral((longlong)(puVar18 + -0x50));

-            break;

-          case 2:

-            *(undefined8 *)(puVar17 + -8) = 0x14005052c;

-            WfpAuditEventVeto((longlong)(puVar18 + -0x50));

-            break;

-          case 3:

-            *(undefined8 *)(puVar17 + -8) = 0x14005053a;

-            WfpAuditBindEvent((longlong)(puVar18 + -0x50));

-            break;

-          case 4:

-            *(undefined8 *)(puVar17 + -8) = 0x140050548;

-            WfpAuditListenEvent((longlong)(puVar18 + -0x50));

-            break;

-          case 5:

-            *(undefined8 *)(puVar17 + -8) = 0x140050556;

-            WfpAuditConnectAcceptEvent((longlong)(puVar18 + -0x50));

-            break;

-          case 6:

-            *(undefined8 *)(puVar17 + -8) = 0x140050564;

-            WfpAuditFirewallAuditEvent((longlong)(puVar18 + -0x50));

-            break;

-          default:

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

-            (*pcVar8)(0x25);

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

-            uVar13 = (*pcVar8)();

-            return uVar13;

-          }

-        }

-        if (*(longlong *)(puVar17 + 0x58) != 0) {

-          *(undefined8 *)(puVar17 + -8) = 0x14005049e;

-          ExFreePoolWithTag(*(longlong *)(puVar17 + 0x58),0);

-        }

-        *param_2 = 0x1002;

-        if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

-            (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 3)) ||

-           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) == 0)) goto LAB_0;

-        uVar1 = *param_1;

-        uVar5 = WPP_GLOBAL_Control[3];

-        *(undefined8 *)(puVar17 + -8) = 0x1400504e7;

-        WPP_SF_D(uVar5,0x1c,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids,(uint)uVar1);

-      }

-    }

-  }

-  else {

-    memset(local_176,0,0x126);

-    local_6b0 = (longlong *)0x0;

-    local_6b4 = 0;

-    local_6b2 = 0;

-    local_180 = &local_188;

-    local_178 = 0;

-    local_188 = &local_188;

-    plVar15 = (longlong *)FeAcquireReadEngineLock(&local_6b4,1);

-    puVar17 = auStack_6e8;

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

-      if ((*(int *)(local_650 + 0x48) == 0) || ((int)(*(longlong **)(local_650 + 0x68))[1] == 4)) {

-LAB_9:

-        lVar12 = gWfpGlobal;

-        if (gWfpPerProContext != 0) {

-          iVar10 = KeGetCurrentProcessorNumberEx(0);

-          piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

-          if (*piVar4 == 4) {

-            *piVar4 = 0;

-          }

-        }

-        NdisReleaseRWLock(*(undefined8 *)(lVar12 + 0x80));

-        puVar17 = auStack_6e8;

-      }

-      else {

-        plVar3 = (longlong *)**(longlong **)(local_650 + 0x68);

-        plVar19 = (longlong *)*plVar3;

-        puVar17 = auStack_6e8;

-        plVar15 = plVar14;

-        if (plVar19 != plVar3) {

-          do {

-            puVar18 = (undefined1 *)

-                      InsertFilterToMatchBuf

-                                ((longlong)plVar15,(longlong)plVar19,(longlong *)&local_6b0,

-                                 (longlong)(puVar18 + 0x460));

-            plVar15 = extraout_RAX_00;

-            if (extraout_RAX_00 != (longlong *)0x0) goto LAB_9;

-            plVar19 = (longlong *)*plVar19;

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

-              plVar14 = local_6b0;

-            }

-            plVar15 = local_6b0;

-          } while (plVar19 != plVar3);

-          puVar17 = auStack_6e8;

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

-            plVar15 = *(longlong **)(puVar18 + 0x468);

-            if ((undefined1 *)*plVar15 != puVar18 + 0x460) {

-LAB_5:

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

-              plVar15 = (longlong *)(*pcVar8)(3);

-              puVar16 = auStack_6e0;

-            }

-            plVar14[1] = (longlong)plVar15;

-            *plVar14 = (longlong)(puVar18 + 0x460);

-            *plVar15 = (longlong)plVar14;

-            *(longlong **)(puVar18 + 0x468) = plVar14;

-            puVar17 = puVar16;

-          }

-        }

-        lVar12 = gWfpGlobal;

-        if (gWfpPerProContext != 0) {

-          *(undefined8 *)(puVar17 + -8) = 0x140050038;

-          iVar10 = KeGetCurrentProcessorNumberEx(0);

-          piVar4 = *(int **)((ulonglong)(uint)(iVar10 * gWfpPerProContextSize) + gWfpPerProContext);

-          if (*piVar4 == 4) {

-            *piVar4 = 0;

-          }

-        }

-        uVar5 = *(undefined8 *)(lVar12 + 0x80);

-        *(undefined8 *)(puVar17 + -8) = 0x140050073;

-        NdisReleaseRWLock(uVar5,puVar17 + 0x34);

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

-        *(undefined8 *)(puVar17 + -8) = 0x14005008e;

-        plVar15 = (longlong *)

-                  GetNextFilter((longlong *)(puVar18 + 0x460),(undefined8 *)(puVar17 + 0x48));

-        while ((plVar15 == (longlong *)0x0 && (lVar12 = *(longlong *)(puVar17 + 0x48), lVar12 != 0))

-              ) {

-          *(undefined8 *)(puVar17 + -8) = 0x1400500ad;

-          plVar15 = (longlong *)ProcessCallout2(lVar12,(longlong *)(puVar17 + 0x60));

-          if (plVar15 != (longlong *)0x0) break;

-          *(undefined8 *)(puVar17 + -8) = 0x1400500bf;

-          HandleFilterDeref(lVar12,'\0');

-          *(undefined8 *)(puVar17 + -8) = 0x1400500d0;

-          plVar15 = (longlong *)

-                    GetNextFilter((longlong *)(puVar18 + 0x460),(undefined8 *)(puVar17 + 0x48));

-        }

-        plVar14 = *(longlong **)(puVar18 + 0x460);

-        if (plVar14 != (longlong *)(puVar18 + 0x460)) {

-          do {

-            plVar3 = (longlong *)*plVar14;

-            *(undefined8 *)(puVar17 + -8) = 0x1400500f8;

-            FreeMatchBufListInternal((longlong)plVar14);

-            plVar14 = plVar3;

-          } while (plVar3 != (longlong *)(puVar18 + 0x460));

-        }

-        if ((((plVar15 != (longlong *)0x0) &&

-             ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

-          uVar5 = WPP_GLOBAL_Control[3];

-          *(int *)(puVar17 + 0x20) = (int)plVar15;

-          *(undefined8 *)(puVar17 + -8) = 0x14005015a;

-          WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"ArbitrateSlow");

+            (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x2000) != 0)) {

+          WPP_SF_D(WPP_GLOBAL_Control[3],0x20,&WPP_63a4375d56693418a53442f6c0b04376_Traceguids,

+                   (uint)param_1);

         }

       }

     }

-    if (plVar15 == (longlong *)0x0) goto LAB_7;

-    if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

-        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) != 0)) {

-      uVar5 = WPP_GLOBAL_Control[3];

-      *(int *)(puVar17 + 0x20) = (int)plVar15;

-      *(undefined8 *)(puVar17 + -8) = 0x1400501ff;

-      WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"IndexListClassify2Slow")

-      ;

-    }

-LAB_6:

-    if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

-        (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) ||

-       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x1000) == 0)) goto LAB_2;

-    uVar5 = WPP_GLOBAL_Control[3];

-    *(int *)(puVar17 + 0x20) = (int)plVar15;

-    *(undefined8 *)(puVar17 + -8) = 0x14005023a;

-    WPP_SF_sd(uVar5,0xf,&WPP_c15558396cc63da9014e9889efdb8f36_Traceguids,"KfdClassifySlow");

+    UpdateClassifyStats(param_1,(longlong)param_2,(longlong)param_3,param_6);

   }

-LAB_3:

-  if (*param_2 == 0) {

-    *param_2 = 7;

+  else {

+    *param_6 = 0x1001;

   }

-LAB_0:

-  *(undefined8 *)(puVar17 + -8) = 0x140050507;

-  return (ulonglong)plVar15 & 0xffffffff;

+  return 1;

 }
```

## `IsAuditApplicableAndEnabledForSublayer`  (modified)

```diff
--- IsAuditApplicableAndEnabledForSublayer
+++ IsAuditApplicableAndEnabledForSublayer
@@ -1,67 +1,25 @@
 

 undefined4 IsAuditApplicableAndEnabledForSublayer(int *param_1)

 

 {

-  longlong in_RAX;

-  uint in_EDX;

-  longlong lVar1;

-  ulonglong uVar2;

-  longlong lVar3;

-  ulonglong uVar4;

-  undefined4 in_R8D;

-  uint uVar5;

-  longlong lVar6;

-  longlong *in_R9;

-  ulonglong uStackX_20;

-  longlong in_stack_00000078;

-  undefined4 *in_stack_00000080;

+  undefined4 uVar1;

+  bool bVar2;

   

-  uVar5 = 0;

-  uVar4 = 0;

-  uVar2 = (ulonglong)in_EDX;

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

-  *(undefined8 *)(in_RAX + -0x38) = 0;

-  *in_stack_00000080 = 0;

-  lVar1 = 0;

-  *in_R9 = 0;

-  if (in_EDX != 0) {

-    for (; uVar5 < in_EDX; uVar5 = uVar5 + 1) {

-      lVar1 = -1;

-      do {

-        lVar1 = lVar1 + 1;

-      } while (*(short *)(*(longlong *)(param_1 + (ulonglong)uVar5 * 2) + lVar1 * 2) != 0);

-      lVar1 = WfpSizeTAdd(uVar4,lVar1 * 2 + 2,(longlong *)&uStackX_20);

-      if (lVar1 != 0) goto LAB_0;

-      uVar4 = uStackX_20;

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

+    return 0;

+  }

+  uVar1 = 0;

+  if (((char)param_1[2] != '\0') && (uVar1 = 0, *param_1 == 2)) {

+    LOCK();

+    bVar2 = gAuditModeEnabled == 0;

+    if (bVar2) {

+      gAuditModeEnabled = 0;

     }

-    lVar1 = WfpPoolAllocNonPaged(uVar4,in_R8D,&stack0x00000078);

-    if (lVar1 == 0) {

-      lVar3 = 0;

-      if (in_EDX != 0) {

-        do {

-          lVar6 = -1;

-          do {

-            lVar6 = lVar6 + 1;

-          } while (*(short *)((longlong)*(void **)param_1 + lVar6 * 2) != 0);

-          memmove((void *)(lVar3 + in_stack_00000078),*(void **)param_1,lVar6 * 2 + 2);

-          lVar6 = -1;

-          do {

-            lVar6 = lVar6 + 1;

-          } while (*(short *)(*(longlong *)param_1 + lVar6 * 2) != 0);

-          param_1 = (int *)((longlong)param_1 + 8);

-          lVar3 = lVar3 + lVar6 * 2 + 2;

-          uVar2 = uVar2 - 1;

-        } while (uVar2 != 0);

-      }

-      *in_stack_00000080 = (int)(uVar4 >> 1);

-      *in_R9 = in_stack_00000078;

-    }

-    else {

-LAB_0:

-      WfpNamedPoolFree(in_R8D,&stack0x00000078);

-      WfpReportError(lVar1,"WfpStringCombineStrArray");

+    UNLOCK();

+    if (!bVar2) {

+      uVar1 = 1;

     }

   }

-  return (int)lVar1;

+  return uVar1;

 }
```

## `Pdcv2ActivationClientDeactivate`  (modified)

```diff
--- Pdcv2ActivationClientDeactivate
+++ Pdcv2ActivationClientDeactivate
@@ -1,70 +1,95 @@
 

-int Pdcv2ActivationClientDeactivate(longlong *param_1)

+ulonglong Pdcv2ActivationClientDeactivate(longlong *param_1)

 

 {

-  char cVar1;

-  ulonglong in_RAX;

-  ulonglong unaff_RBX;

-  longlong unaff_RBP;

-  ulonglong unaff_RSI;

-  ulonglong uVar2;

-  int unaff_EDI;

-  undefined8 in_R8;

-  ulonglong uVar3;

-  longlong unaff_R14;

-  uint uVar4;

-  ulonglong uVar5;

-  bool in_CF;

-  bool in_ZF;

-  undefined4 uStack0000000000000028;

+  int *piVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  uint uVar5;

+  ulonglong uVar6;

+  int *piVar7;

+  char local_res8 [8];

+  undefined1 local_328 [40];

+  undefined4 local_300;

+  uint local_2f0;

+  longlong local_2e8;

   

-  if (!in_CF && !in_ZF) {

-    unaff_RSI = unaff_RBX;

+  memset(local_328,0,800);

+  local_res8[0] = '\0';

+  piVar7 = (int *)0x0;

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

+    param_1 = (longlong *)0x0;

+    uVar5 = 0xc00000ef;

   }

-  uVar2 = unaff_RSI & 0xffffffff;

-  uVar3 = 0;

-  uVar5 = 0;

-  if ((int)in_RAX == 0) {

-    cVar1 = '\0';

+  else if ((int)param_1[3] == 0x41434450) {

+    piVar7 = (int *)param_1[4];

+    if (*piVar7 == 0x32414450) {

+      plVar3 = (longlong *)(piVar7 + 2);

+      PdcAcquireRwLockExclusive2(plVar3,local_res8);

+      if (SystemReserved1[0xf] != *(void **)(piVar7 + 0x1a)) {

+        while (*(longlong **)(piVar7 + 0x1e) == param_1) {

+          PdcReleaseRwLockExclusive2(plVar3,local_res8);

+          PdcWaitForEvent(*(undefined8 *)(piVar7 + 0x1c));

+          PdcAcquireRwLockExclusive2(plVar3,local_res8);

+        }

+      }

+      if (*(longlong *)(piVar7 + 10) == 0) {

+        uVar5 = 0xc0000700;

+      }

+      else if (piVar7[(longlong)(int)param_1[7] + 0x42] == 0) {

+        uVar5 = 0xc0000001;

+      }

+      else {

+        local_2e8 = param_1[0x4b];

+        local_300 = 0xd;

+        uVar5 = PdcPortSendMessageSynchronously(*(longlong *)(piVar7 + 10),(longlong)local_328);

+        if ((-1 < (int)uVar5) && (uVar5 = local_2f0, -1 < (int)local_2f0)) {

+          lVar2 = param_1[4];

+          piVar1 = (int *)(lVar2 + 0x108 + (longlong)(int)param_1[7] * 4);

+          *piVar1 = *piVar1 + -1;

+          piVar1 = (int *)(lVar2 + 0x104);

+          *piVar1 = *piVar1 + -1;

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

+          Pdcv2EventWrite_ACTIVATION_CLIENT_DEACTIVATE((longlong)param_1,(longlong)piVar7,0);

+          uVar6 = Feature_Servicing_PDCActivationsAVL__private_IsEnabledDeviceUsageNoInline();

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

+            lVar2 = *param_1;

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

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

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

+              (*pcVar4)(3);

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

+              uVar6 = (*pcVar4)();

+              return uVar6;

+            }

+            *plVar3 = lVar2;

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

+          }

+          else {

+            RtlAvlRemoveNode(param_1[4] + 0x60,param_1);

+          }

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

+          ExFreePoolWithTag(param_1,0);

+          goto LAB_0;

+        }

+      }

+    }

+    else {

+      param_1 = (longlong *)0x0;

+      piVar7 = (int *)0x0;

+      uVar5 = 0xc00000ef;

+    }

   }

   else {

-    do {

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

-      unaff_EDI = PsGetJobServerSilo(*(undefined8 *)(unaff_RBX + uVar5 * 8),unaff_RBP + -0x10);

-      if (((unaff_EDI < 0) ||

-          (cVar1 = PsIsHostSilo(*(undefined8 *)(unaff_RBP + -0x10)), cVar1 != '\0')) ||

-         (*(undefined1 *)(unaff_RBP + 0x50) = 1, uVar2 == 0)) {

-        ObfDereferenceObject(*(undefined8 *)(unaff_RBX + uVar5 * 8));

-      }

-      else {

-        ObfReferenceObjectWithTag(*(undefined8 *)(unaff_RBP + -0x10),0x4369734e);

-        ObfDereferenceObject(*(undefined8 *)(unaff_RBX + uVar5 * 8));

-        *(undefined8 *)(uVar2 + uVar3 * 8) = *(undefined8 *)(unaff_RBP + -0x10);

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

-      }

-      in_RAX = (ulonglong)*(uint *)(unaff_RBP + 0x58);

-      uVar4 = (int)uVar5 + 1;

-      uVar5 = (ulonglong)uVar4;

-    } while (uVar4 < *(uint *)(unaff_RBP + 0x58));

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

-    if ((cVar1 != '\0') && (unaff_R14 != 0)) {

-      *(ulonglong *)(unaff_R14 + 0x10) = uVar2;

-      *(int *)(unaff_R14 + 8) = (int)uVar3;

-      if (uVar2 == unaff_RBX) goto LAB_0;

-    }

+    param_1 = (longlong *)0x0;

+    uVar5 = 0xc00000ef;

   }

-  if ((unaff_RBX != 0) && (unaff_RBX != unaff_RBP - 8U)) {

-    ExFreePoolWithTag();

-    in_RAX = (ulonglong)*(uint *)(unaff_RBP + 0x58);

+  Pdcv2EventWrite_ACTIVATION_CLIENT_DEACTIVATE((longlong)param_1,(longlong)piVar7,uVar5);

+LAB_0:

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

+    PdcReleaseRwLockExclusive2((longlong *)(piVar7 + 2),local_res8);

   }

-LAB_0:

-  if ((((unaff_EDI < 0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-      (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

-    uStack0000000000000028 = (undefined4)in_RAX;

-    in_RAX = WPP_SF_Ddd(WPP_GLOBAL_Control[3],(ulonglong)**(uint **)(unaff_RBP + 0x40),in_R8,

-                        unaff_EDI);

-  }

-  return (int)CONCAT71((int7)(in_RAX >> 8),cVar1);

+  return (ulonglong)uVar5;

 }
```

## `RtlStringCchCopyW`  (modified)

```diff
--- RtlStringCchCopyW
+++ RtlStringCopyWorkerW
@@ -1,15 +1,29 @@
 

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

 

-uint RtlStringCchCopyW(short *param_1,longlong param_2,undefined8 param_3)

+uint RtlStringCopyWorkerW

+               (short *param_1,longlong param_2,undefined8 param_3,longlong param_4,longlong param_5

+               )

 

 {

-  char *pcVar1;

-  uint in_EAX;

-  undefined4 in_register_00000004;

+  uint uVar1;

+  int *in_RAX;

+  undefined8 unaff_RBX;

+  undefined8 *unaff_RSI;

+  undefined8 unaff_RDI;

+  ulonglong uStack0000000000000058;

+  undefined1 *puStack0000000000000060;

   

-  pcVar1 = (char *)(CONCAT44(in_register_00000004,in_EAX) + 0x73);

-  *pcVar1 = *pcVar1 >> 8;

-  return in_EAX;

+  uStack0000000000000058 = (ulonglong)(uint)((int)in_RAX + *in_RAX);

+  puStack0000000000000060 = &stack0x00000070;

+  uVar1 = Pdcv2ActivationClientActivate

+                    ((int *)param_4,(int *)&stack0x00000048,unaff_RDI,(uint)param_4,

+                     CONCAT71((int7)((ulonglong)param_1 >> 8),

+                              (byte)param_1 & (byte)((ulonglong)unaff_RBX >> 8)),param_5,unaff_RSI,

+                     (int *)&stack0x00000040);

+  if ((int)uVar1 < 0) {

+    *unaff_RSI = 0;

+  }

+  return uVar1;

 }
```

## `StreamNormalizeClassifyOut`  (modified)

```diff
--- StreamNormalizeClassifyOut
+++ StreamNormalizeClassifyOut
@@ -1,89 +1,265 @@
-

-/* WARNING: Variable defined which should be unmapped: param_5 */

-/* WARNING: Variable defined which should be unmapped: param_6 */

 

 void StreamNormalizeClassifyOut

-               (longlong param_1,ushort *param_2,longlong param_3,longlong param_4,longlong *param_5

-               ,int *param_6)

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

+               longlong *param_5,int *param_6)

 

 {

-  uint uVar1;

-  int *piVar2;

-  int iVar3;

-  undefined2 uVar4;

-  longlong unaff_RBP;

-  uint *unaff_RSI;

-  longlong unaff_RDI;

-  uint in_R10D;

-  longlong unaff_R12;

-  undefined8 unaff_R14;

-  byte bVar5;

-  int unaff_R15D;

-  uint uStack0000000000000040;

-  longlong lStack0000000000000048;

-  undefined4 uStack0000000000000050;

+  ulonglong uVar1;

+  longlong lVar2;

+  char cVar3;

+  int iVar4;

+  ushort uVar5;

+  undefined8 uVar6;

+  uint uVar7;

+  uint *puVar8;

+  uint *puVar9;

+  uint *puVar10;

+  char *pcVar11;

+  uint local_38;

+  undefined4 uStack_34;

+  uint local_30;

   

-  uStack0000000000000050 = (undefined4)param_3;

-  lStack0000000000000048 = 4;

-  uStack0000000000000040 = in_R10D;

-  WPP_SF_PPqqqLqL(*(undefined8 *)(param_1 + 0x18),0x6f,param_3,param_4);

-  *(longlong *)(unaff_RSI + 0x12) = unaff_RDI;

-  uVar1 = *unaff_RSI;

-  if (((uVar1 == 4) || (uVar1 == 5)) && (*(int *)(unaff_R12 + 0x20) != unaff_R15D)) {

-    *(longlong *)(unaff_RSI + 0x10) =

-         *(longlong *)(unaff_RSI + 0x10) - *(longlong *)(unaff_R12 + 0x18);

+  puVar9 = (uint *)0x0;

+  uVar7 = 0;

+  if ((*(longlong *)(*param_5 + 0x30) == 0) &&

+     (*(longlong *)(*(longlong *)(param_3 + 0x10) + 0x80) != 0)) {

+    if ((3 < DAT_0) && (cVar3 = _tlgKeywordOn(0x140094098,2), cVar3 != '\0')) {

+      if ((param_2 == (ushort *)0x0) || (*(longlong *)(param_2 + 0x14) == 0)) {

+        if (param_2 != (ushort *)0x0) goto LAB_1;

+        uVar5 = 0;

+      }

+      else {

+        uVar7 = *(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+LAB_1:

+        uVar5 = *param_2;

+      }

+      WfpStreamCalloutDiagTraceInvalidDataLength(uVar5,uVar7);

+    }

+    uVar6 = 0x5003;

+    StreamVerifierBreak(0x5003,*(undefined8 *)(*param_5 + 0x30),

+                        *(undefined8 *)(*(longlong *)(param_3 + 0x10) + 0x80),0);

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

+        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+      uVar6 = WPP_GLOBAL_Control[3];

+      WPP_SF_qLIDDII(uVar6,*(undefined8 *)(param_3 + 0x10),WPP_GLOBAL_Control,param_1);

+    }

+    iVar4 = (int)param_5[4];

+    if (iVar4 == 4) {

+      if (param_5[3] != 0) goto LAB_2;

+LAB_3:

+      *param_6 = 7;

+      *(undefined4 *)(param_5 + 4) = 2;

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

+          (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+        puVar10 = puVar9;

+        if ((((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) ||

+            (param_2 != (ushort *)0x0)) && (*(longlong *)(param_2 + 0x14) != 0)) {

+          puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+        }

+        WPP_SF_LDqDI(WPP_GLOBAL_Control[3],0x5d,puVar10,2);

+      }

+    }

+    else {

+      if ((iVar4 != 0) || (*param_6 == 7)) goto LAB_3;

+LAB_2:

+      if (g_LogStreamInvalidData == 0) {

+        if (iVar4 == 4) {

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

+            iVar4 = *param_6;

+            pcVar11 = "StreamInvalidDataLength-StreamActionAllow";

+LAB_4:

+            MicrosoftTelemetryAssertTriggeredArgsMsgKM(uVar6,(int)param_5[3],iVar4,pcVar11);

+          }

+        }

+        else if ((iVar4 == 0) && (iVar4 = *param_6, iVar4 != 7)) {

+          pcVar11 = "StreamInvalidDataLength-StreamActionNone";

+          goto LAB_4;

+        }

+        g_LogStreamInvalidData = 1;

+      }

+    }

+    *(undefined8 *)(*param_5 + 0x30) = *(undefined8 *)(*(longlong *)(param_3 + 0x10) + 0x80);

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

+        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+      puVar10 = puVar9;

+      if ((((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) ||

+          (param_2 != (ushort *)0x0)) && (*(longlong *)(param_2 + 0x14) != 0)) {

+        puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+      }

+      WPP_SF_PqDI(WPP_GLOBAL_Control[3],0x5e,puVar10,*(undefined8 *)(*param_5 + 0x30));

+    }

+  }

+  uVar1 = param_5[3];

+  if (uVar1 == 0) {

+    param_5[3] = *(ulonglong *)(*param_5 + 0x30);

+  }

+  else if (*(ulonglong *)(*param_5 + 0x30) < uVar1) {

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

+        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+      puVar10 = puVar9;

+      if ((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) {

+        puVar10 = *(uint **)(*(longlong *)(param_2 + 0x10) + 0x20);

+      }

+      WPP_SF_qLDDI(WPP_GLOBAL_Control[3],WPP_GLOBAL_Control,puVar10,param_1);

+    }

+    StreamVerifierBreak(0x5000,param_5[3],*(undefined8 *)(*param_5 + 0x30),0);

+    lVar2 = *(longlong *)(*param_5 + 0x30);

+    param_5[3] = lVar2;

     if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

         (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

-      lStack0000000000000048 = *(longlong *)(unaff_RSI + 4);

-      if (lStack0000000000000048 == 0) {

-        uStack0000000000000050 = 4;

+      puVar10 = puVar9;

+      if ((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) {

+        puVar10 = *(uint **)(*(longlong *)(param_2 + 0x10) + 0x20);

+      }

+      WPP_SF_PqDI(WPP_GLOBAL_Control[3],0x60,puVar10,lVar2);

+    }

+  }

+  puVar10 = (uint *)&WPP_GLOBAL_Control;

+  iVar4 = (int)param_5[4];

+  if (iVar4 == 1) {

+    *param_6 = 7;

+    if ((((*(uint *)(*(longlong *)(param_3 + 0x10) + 0xc4) & 0x18000c) == 0) &&

+        ((param_6[7] & 4U) == 0)) &&

+       ((*(uint *)(param_5 + 2) < 0x800000 && (*(char *)(param_3 + 0x38) == '\0')))) {

+      if ((ulonglong)*(uint *)(param_5 + 2) <= *(ulonglong *)(*param_5 + 0x30)) {

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

+            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+          puVar10 = puVar9;

+          if ((((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) ||

+              (param_2 != (ushort *)0x0)) && (*(longlong *)(param_2 + 0x14) != 0)) {

+            puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+          }

+          WPP_SF_qPPDID(WPP_GLOBAL_Control[3],puVar10,WPP_GLOBAL_Control,param_1);

+        }

+        puVar10 = *(uint **)(*param_5 + 0x30);

+        StreamVerifierBreak(0x5001,(ulonglong)*(uint *)(param_5 + 2),puVar10,0);

+      }

+    }

+    else {

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

+          (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+        if (*(longlong *)(param_3 + 0x10) != 0) {

+          puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_3 + 0x10) + 0xc4);

+        }

+        WPP_SF_qLlDDPlDDI(WPP_GLOBAL_Control[3],(ulonglong)*(uint *)(param_5 + 2),puVar10,param_1);

+      }

+      puVar10 = (uint *)(longlong)(int)param_5[4];

+      StreamVerifierBreak(0x5002,(ulonglong)*(uint *)(*(longlong *)(param_3 + 0x10) + 0xc4),puVar10,

+                          (ulonglong)(uint)param_6[7]);

+      iVar4 = *(int *)(param_4 + 0x28);

+      *(uint *)(param_5 + 4) = -(uint)(iVar4 != 0x6004) & 2;

+      if (iVar4 == 0x6004) {

+        iVar4 = 0x2006;

+        if (*(int *)(param_4 + 0x28) != 0x6004) {

+          iVar4 = 0x1002;

+        }

+        *param_6 = iVar4;

+      }

+      *(undefined4 *)(param_5 + 2) = 0;

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

+          (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+        if ((((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) ||

+            (puVar10 = puVar9, param_2 != (ushort *)0x0)) &&

+           (puVar10 = puVar9, *(longlong *)(param_2 + 0x14) != 0)) {

+          puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+        }

+        WPP_SF_LDqDI(WPP_GLOBAL_Control[3],0x62,puVar10,(int)param_5[4]);

+      }

+    }

+    goto LAB_5;

+  }

+  if (iVar4 == 3) {

+    *param_6 = 7;

+    goto LAB_5;

+  }

+  if (iVar4 != 4) {

+    uVar7 = *(uint *)(param_4 + 0x28);

+    puVar10 = (uint *)(ulonglong)uVar7;

+    if (iVar4 == 2) {

+      if (uVar7 == 0x6004) {

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

+            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+          puVar10 = puVar9;

+          if ((param_2 == (ushort *)0x0) || (*(longlong *)(param_2 + 0x10) == 0)) {

+            puVar8 = puVar9;

+            if (param_2 != (ushort *)0x0) goto LAB_6;

+          }

+          else {

+            puVar8 = *(uint **)(*(longlong *)(param_2 + 0x10) + 0x20);

+LAB_6:

+            if (*(longlong *)(param_2 + 0x14) != 0) {

+              puVar10 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+            }

+          }

+          WPP_SF_qDI(WPP_GLOBAL_Control[3],puVar10,puVar8,param_1);

+        }

+        puVar10 = (uint *)(longlong)(int)param_5[4];

+        StreamVerifierBreak(0x5002,(ulonglong)*(uint *)*param_5,puVar10,(ulonglong)(uint)param_6[7])

+        ;

+        iVar4 = 0x2006;

+        *(undefined4 *)(param_5 + 4) = 0;

       }

       else {

-        uStack0000000000000050 = *(undefined4 *)(lStack0000000000000048 + 0x50);

-      }

-      uStack0000000000000040 = uVar1;

-      WPP_SF_PPqqqLqL(WPP_GLOBAL_Control[3],0x70,(ulonglong)uVar1,*(undefined8 *)(unaff_RSI + 0x10))

-      ;

-    }

-  }

-  if (gWfpPerProContext != unaff_RDI) {

-    iVar3 = KeGetCurrentProcessorNumberEx(0);

-    piVar2 = *(int **)((ulonglong)(uint)(iVar3 * gWfpPerProContextSize) + gWfpPerProContext);

-    if (*piVar2 == 4) {

-      *piVar2 = (int)unaff_RDI;

-    }

-  }

-  KeReleaseInStackQueuedSpinLock(unaff_RBP + -0x51);

-  uVar1 = *(uint *)(unaff_R12 + 0x20);

-  uStack0000000000000040 = **(int **)(unaff_RBP + 0x6f);

-  bVar5 = (byte)unaff_R15D;

-  if (uStack0000000000000040 == 7) {

-    if (((uVar1 == 1) || (uVar1 - 2 < 2)) ||

-       (((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control ||

-        ((*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < bVar5 ||

-         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) == 0)))))) goto LAB_0;

-    uVar4 = 0x71;

-  }

-  else {

-    if (uVar1 != 4) {

-      if ((((uVar1 != 0) && ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-          (bVar5 <= *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

-         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

-        WPP_SF_qqqLLD(WPP_GLOBAL_Control[3],0x73,(ulonglong)uVar1,unaff_R14);

-      }

-      unaff_RDI = 1;

-      goto LAB_0;

-    }

-    if (((uStack0000000000000040 == 0x1002) ||

-        ((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control)) ||

-       ((*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < bVar5 ||

-        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) == 0)))) goto LAB_0;

-    uVar4 = 0x72;

-  }

-  WPP_SF_qqqLLD(WPP_GLOBAL_Control[3],uVar4,(ulonglong)uVar1,unaff_R14);

-LAB_0:

-  **(undefined1 **)(unaff_RBP + 0x7f) = (char)unaff_RDI;

+        iVar4 = 7;

+      }

+      *param_6 = iVar4;

+      goto LAB_5;

+    }

+    if (uVar7 == 0x6004) {

+      *param_6 = 0x2006;

+      goto LAB_5;

+    }

+    if (((uVar7 != 0x5003) || (*param_6 != 0x2006)) && (*param_6 != 7)) goto LAB_5;

+  }

+  *param_6 = 0x1002;

+LAB_5:

+  if (param_5[3] == *(longlong *)(*param_5 + 0x30)) {

+    local_30 = 0;

+    if (*param_6 == 0x1001) {

+      local_30 = (uint)((*(byte *)(param_6 + 7) & 1) == 0);

+    }

+    _local_38 = CONCAT44(*(undefined4 *)(param_4 + 0x2c),(uint)*(ushort *)(param_4 + 0x18));

+    iVar4 = IsAuditApplicableAndEnabledForSublayer((int *)&local_38);

+    if (iVar4 != 0) {

+      puVar10 = *(uint **)(param_2 + 0x10);

+      FwAuditModeAuditEvent

+                (*param_2,*(longlong *)(param_2 + 0xc),puVar10,(longlong)param_6,&local_38);

+      *param_6 = 0x1002;

+      *(undefined4 *)(param_5 + 4) = 4;

+      if ((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) {

+        return;

+      }

+      if ((3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29)) &&

+         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+        puVar10 = puVar9;

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

+          puVar10 = *(uint **)(*(longlong *)(param_2 + 0x10) + 0x20);

+        }

+        puVar8 = puVar9;

+        if (*(longlong *)(param_2 + 0x14) != 0) {

+          puVar8 = (uint *)(ulonglong)*(uint *)(*(longlong *)(param_2 + 0x14) + 0x2c);

+        }

+        WPP_SF_PqDILD(WPP_GLOBAL_Control[3],puVar8,puVar10,param_5[3]);

+      }

+    }

+  }

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

+      (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x4000) != 0)) {

+    if ((param_2 != (ushort *)0x0) && (*(longlong *)(param_2 + 0x10) != 0)) {

+      puVar9 = *(uint **)(*(longlong *)(param_2 + 0x10) + 0x20);

+    }

+    WPP_SF_LqDID(WPP_GLOBAL_Control[3],puVar9,puVar10,(int)param_5[4]);

+  }

   return;

 }
```

## `Pdcv2ActivationClientActivate`  (modified)

```diff
--- Pdcv2ActivationClientActivate
+++ Pdcv2ActivationClientActivate
@@ -1,30 +1,181 @@
+

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

 

 int Pdcv2ActivationClientActivate

               (int *param_1,int *param_2,longlong param_3,uint param_4,longlong param_5,

               undefined8 param_6,undefined8 *param_7,int *param_8)

 

 {

-  int *piVar1;

-  code *pcVar2;

-  int in_EAX;

-  int iVar3;

-  longlong unaff_RBX;

+  code *pcVar1;

+  undefined1 auVar2 [16];

+  longlong *plVar3;

+  int iVar4;

+  ulonglong uVar5;

+  undefined8 uVar6;

+  longlong *plVar7;

+  int *piVar8;

+  longlong *plVar9;

+  undefined1 *puVar10;

+  undefined1 *puVar11;

+  undefined4 uVar12;

+  uint local_res20 [2];

+  undefined1 auStack_378 [8];

+  undefined1 auStack_370 [24];

+  undefined1 local_358 [40];

+  undefined4 local_330;

+  int local_320;

+  int local_31c;

+  longlong local_318;

+  undefined4 local_310;

+  undefined8 local_308;

+  undefined4 local_300;

+  int local_2fc;

+  short local_2f8 [128];

+  short local_1f8 [140];

+  uint local_e0 [42];

   

-  LOCK();

-  piVar1 = (int *)(unaff_RBX + 0x10);

-  iVar3 = *piVar1;

-  *piVar1 = *piVar1 + in_EAX;

-  UNLOCK();

-  if (iVar3 == 0) {

-    *(void **)(unaff_RBX + 8) = SystemReserved1[0xf];

+  puVar11 = auStack_378;

+  puVar10 = auStack_378;

+  local_res20[0] = param_4;

+  memset(local_358,0,800);

+  local_res20[0] = local_res20[0] & 0xffffff00;

+  if (param_8 == (int *)0x0) {

+    param_1 = (int *)0x0;

+    local_320 = -0x3fffff0a;

+LAB_0:

+    plVar7 = (longlong *)0x0;

+    puVar10 = auStack_378;

+    iVar4 = local_320;

   }

-  if (*(void **)(unaff_RBX + 8) == SystemReserved1[0xf]) {

-    return (int)SystemReserved1[0xf];

+  else {

+    *param_8 = 1;

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

+      param_1 = (int *)0x0;

+      local_320 = -0x3fffff0b;

+      goto LAB_0;

+    }

+    *param_7 = 0;

+    if ((param_1 == (int *)0x0) || (*param_1 != 0x32414450)) {

+      param_1 = (int *)0x0;

+      local_320 = -0x3fffff11;

+      goto LAB_0;

+    }

+    uVar5 = Pdcv2pValidateActivationParameters(param_2);

+    if (((char)uVar5 == '\0') ||

+       (uVar6 = Pdcv2pValidateExtraActivationParameters(param_2), (char)uVar6 == '\0')) {

+      local_320 = -0x3fffff10;

+      goto LAB_0;

+    }

+    if (param_5 == 0) {

+      local_320 = -0x3fffff0d;

+      goto LAB_0;

+    }

+    PdcAcquireRwLockExclusive2((undefined8 *)(param_1 + 2),(undefined1 *)local_res20);

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

+      local_320 = -0x3ffff900;

+      goto LAB_0;

+    }

+    plVar7 = (longlong *)PdcAllocate('\x01');

+    uVar12 = 0;

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

+      local_320 = -0x3fffffe9;

+      goto LAB_0;

+    }

+    *(undefined4 *)(plVar7 + 3) = 0x41434450;

+    *(undefined4 *)((longlong)plVar7 + 0x1c) = 1;

+    plVar7[4] = (longlong)param_1;

+    auVar2._8_8_ = 0;

+    auVar2._0_8_ = _DAT_1 << 8;

+    plVar7[6] = SUB168(auVar2 * (ZEXT416(_DAT_2) << 0x20),8);

+    plVar7[5] = param_3;

+    iVar4 = param_2[1];

+    *(undefined4 *)(plVar7 + 7) = 0;

+    *(int *)((longlong)plVar7 + 0x3c) = iVar4;

+    RtlStringCchCopyW((short *)(plVar7 + 10),0x80,param_5);

+    if (*(longlong *)(param_2 + 4) != 0) {

+      RtlStringCchCopyW((short *)(plVar7 + 0x2a),0x80,*(longlong *)(param_2 + 4));

+    }

+    local_308 = *(undefined8 *)(param_2 + 2);

+    uVar5 = 0x80;

+    local_2fc = param_2[1];

+    local_330 = 10;

+    local_310 = uVar12;

+    local_300 = uVar12;

+    RtlStringCchCopyW(local_2f8,0x80,param_5);

+    if (*(longlong *)(param_2 + 4) != 0) {

+      RtlStringCchCopyW(local_1f8,uVar5 & 0xffffffff,*(longlong *)(param_2 + 4));

+    }

+    if (*(ulonglong **)(param_2 + 6) != (ulonglong *)0x0) {

+      PdcpResizeDiagnosticContext(*(ulonglong **)(param_2 + 6),local_e0);

+    }

+    iVar4 = PdcPortSendMessageSynchronously(*(longlong *)(param_1 + 10),(longlong)local_358);

+    if (iVar4 < 0) {

+      ExFreePoolWithTag(plVar7,0);

+      local_320 = iVar4;

+      goto LAB_0;

+    }

+    *param_8 = local_31c;

+    iVar4 = local_320;

+    if ((local_320 < 0) || (local_31c == 300)) {

+      ExFreePoolWithTag(plVar7,0);

+      if (-1 < local_320) goto LAB_3;

+      goto LAB_0;

+    }

+    plVar7[0x4b] = local_318;

+    *(undefined1 *)((longlong)plVar7 + 0x44) = 0;

+    *(int *)(plVar7 + 8) = local_31c;

+    param_1[0x40] = param_1[0x40] + 1;

+    param_1[0x41] = param_1[0x41] + 1;

+    param_1[0x42] = param_1[0x42] + 1;

+    uVar5 = Feature_Servicing_PDCActivationsAVL__private_IsEnabledDeviceUsageNoInline();

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

+      piVar8 = param_1 + 0x14;

+      plVar9 = *(longlong **)(param_1 + 0x16);

+      puVar10 = auStack_378;

+      if ((int *)*plVar9 != piVar8) {

+        plVar9 = (longlong *)0x3;

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

+        piVar8 = (int *)(*pcVar1)();

+        puVar10 = auStack_370;

+      }

+      *plVar7 = (longlong)piVar8;

+      plVar7[1] = (longlong)plVar9;

+      *plVar9 = (longlong)plVar7;

+      *(longlong **)(piVar8 + 2) = plVar7;

+    }

+    else {

+      plVar9 = *(longlong **)(param_1 + 0x18);

+      uVar6 = 0;

+      plVar3 = plVar9;

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

+        do {

+          while (plVar9 = plVar3,

+                uVar5 = PdcpActivationClientTableCompareRoutine

+                                  ((ulonglong *)(plVar7 + 0x4b),(longlong)plVar9), -1 < (int)uVar5)

+          {

+            plVar3 = (longlong *)plVar9[1];

+            if ((longlong *)plVar9[1] == (longlong *)0x0) {

+              uVar6 = 1;

+              goto LAB_4;

+            }

+          }

+          plVar3 = (longlong *)*plVar9;

+        } while ((longlong *)*plVar9 != (longlong *)0x0);

+        uVar6 = 0;

+      }

+LAB_4:

+      RtlAvlInsertNodeEx(param_1 + 0x18,plVar9,uVar6,plVar7);

+    }

+    *param_7 = plVar7;

   }

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

-  (*pcVar2)(0x28);

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

-  iVar3 = (*pcVar2)();

-  return iVar3;

+  *(undefined8 *)(puVar10 + -8) = 0x1400a6ca2;

+  Pdcv2EventWrite_ACTIVATION_CLIENT_ACTIVATE((longlong)plVar7,(longlong)param_1);

+  puVar11 = puVar10;

+LAB_3:

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

+    *(undefined8 *)(puVar11 + -8) = 0x1400a6cbb;

+    PdcReleaseRwLockExclusive2((longlong *)(param_1 + 2),(undefined1 *)local_res20);

+  }

+  return iVar4;

 }
```

## `Pdcv2ActivationClientRegister`  (modified)

```diff
--- Pdcv2ActivationClientRegister
+++ Pdcv2ActivationClientRegister
@@ -1,10 +1,88 @@
 

-int Pdcv2ActivationClientRegister(ulonglong *param_1,int *param_2,undefined8 *param_3)

+ulonglong Pdcv2ActivationClientRegister(undefined8 param_1,int *param_2,undefined8 *param_3)

 

 {

-  if (*param_1 < *(ulonglong *)(param_2 + 0x96)) {

-    return -1;

+  longlong *plVar1;

+  undefined4 *puVar2;

+  undefined8 uVar3;

+  uint uVar4;

+  undefined4 *puVar5;

+  ulonglong uVar6;

+  longlong lVar7;

+  longlong lVar8;

+  undefined8 uVar9;

+  ulonglong uVar10;

+  code *local_res18;

+  undefined8 in_stack_ffffffffffffffb8;

+  undefined8 in_stack_ffffffffffffffc0;

+  undefined8 in_stack_ffffffffffffffd0;

+  

+  *param_3 = 0;

+  if ((*param_2 == 1) && (*(longlong *)(param_2 + 2) != 0)) {

+    puVar5 = (undefined4 *)PdcAllocate('\x01');

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

+      uVar10 = 0xc0000017;

+    }

+    else {

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

+      uVar6 = PdcRwLockInitialize2(plVar1);

+      uVar10 = uVar6 & 0xffffffff;

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

+        PdcAcquireRwLockExclusive2(plVar1,(undefined1 *)0x0);

+        uVar9 = 0x18;

+        lVar8 = 0;

+        lVar7 = PdcAllocate('\0');

+        if (lVar7 != 0) {

+          uVar9 = 0;

+          lVar8 = lVar7;

+          KeInitializeEvent(lVar7,0,1);

+        }

+        *(longlong *)(puVar5 + 0x1c) = lVar7;

+        if (lVar7 == 0) {

+          uVar10 = 0xc000009a;

+        }

+        else {

+          *puVar5 = 0x32414450;

+          puVar5[8] = 9;

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

+          uVar10 = Feature_Servicing_PDCActivationsAVL__private_IsEnabledDeviceUsageNoInline();

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

+            puVar2 = puVar5 + 0x14;

+            *(undefined4 **)(puVar5 + 0x16) = puVar2;

+            *(undefined4 **)puVar2 = puVar2;

+          }

+          else {

+            *(undefined8 *)(puVar5 + 0x18) = 0;

+          }

+          uVar3 = *(undefined8 *)(param_2 + 2);

+          local_res18 = Pdcv2pActivationClientCallback;

+          *(undefined8 *)(puVar5 + 0xc) = *(undefined8 *)param_2;

+          *(undefined8 *)(puVar5 + 0xe) = uVar3;

+          *(undefined8 *)(puVar5 + 0x10) = *(undefined8 *)(param_2 + 4);

+          uVar4 = PdcPortOpenCommon(lVar8,uVar9,puVar5,(longlong *)&local_res18,

+                                    in_stack_ffffffffffffffb8,in_stack_ffffffffffffffc0,0,

+                                    in_stack_ffffffffffffffd0,(undefined8 *)(puVar5 + 10));

+          uVar10 = (ulonglong)uVar4;

+          if (uVar4 == 0) {

+            *param_3 = puVar5;

+            PdcInitializeETW();

+            Pdcv2EventWrite_ACTIVATION_CLIENT_REGISTER((longlong)puVar5,0);

+            PdcReleaseRwLockExclusive2(plVar1,(undefined1 *)0x0);

+            return 0;

+          }

+          PdcCloseEvent(*(longlong *)(puVar5 + 0x1c));

+        }

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

+        PdcReleaseRwLockExclusive2(plVar1,(undefined1 *)0x0);

+        ExFreePoolWithTag(*plVar1,0);

+        *plVar1 = 0;

+      }

+      ExFreePoolWithTag(puVar5,0);

+    }

   }

-  return (int)(*param_1 != *(ulonglong *)(param_2 + 0x96));

+  else {

+    uVar10 = 0xc00000f0;

+  }

+  return uVar10;

 }
```

## `PdcReleaseRwLockExclusive2`  (modified)

```diff
--- PdcReleaseRwLockExclusive2
+++ PdcAllocate
@@ -1,33 +1,8 @@
 

-void PdcReleaseRwLockExclusive2(longlong *param_1,undefined1 *param_2)

+void PdcAllocate(char param_1)

 

 {

-  longlong *plVar1;

-  code *pcVar2;

-  longlong lVar3;

-  

-  if (param_2 != (undefined1 *)0x0) {

-    *param_2 = 1;

-  }

-  if (((*param_1 != 0) && ((void *)param_1[1] == SystemReserved1[0xf])) && (0 < (int)param_1[2])) {

-    LOCK();

-    plVar1 = param_1 + 2;

-    lVar3 = *plVar1;

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

-    UNLOCK();

-    if ((int)lVar3 == 1) {

-      param_1[1] = 0;

-    }

-    KeReleaseMutex(*param_1,0);

-    if (param_2 != (undefined1 *)0x0) {

-      *param_2 = 0;

-    }

-    return;

-  }

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

-  (*pcVar2)(5);

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

-  (*pcVar2)();

+  ExAllocatePool2((-(uint)(param_1 != '\0') & 0xc0) + 0x40);

   return;

 }
```

## `PdcpActivationClientTableCompareRoutine`  (modified)

```diff
--- PdcpActivationClientTableCompareRoutine
+++ Pdcv2ActivationClientUnregister
@@ -1,10 +1,114 @@
 

-ulonglong PdcpActivationClientTableCompareRoutine(ulonglong *param_1,longlong param_2)

+undefined4 Pdcv2ActivationClientUnregister(int *param_1)

 

 {

-  if (*param_1 < *(ulonglong *)(param_2 + 600)) {

-    return 0xffffffff;

+  longlong *plVar1;

+  longlong *plVar2;

+  int *piVar3;

+  undefined4 *puVar4;

+  longlong *plVar5;

+  longlong lVar6;

+  undefined8 *puVar7;

+  code *pcVar8;

+  ulonglong uVar9;

+  undefined8 *puVar10;

+  undefined4 uVar11;

+  undefined8 *puVar12;

+  undefined1 *puVar13;

+  undefined1 local_res8 [8];

+  undefined1 auStack_28 [8];

+  undefined1 auStack_20 [24];

+  

+  puVar13 = auStack_28;

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

+    uVar11 = 0xc00000ef;

+    param_1 = (int *)0x0;

   }

-  return (ulonglong)(*param_1 != *(ulonglong *)(param_2 + 600));

+  else if (*param_1 == 0x32414450) {

+    plVar1 = (longlong *)(param_1 + 2);

+    PdcAcquireRwLockExclusive2(plVar1,local_res8);

+    if (*(void **)(param_1 + 0x1a) != SystemReserved1[0xf]) {

+      puVar4 = *(undefined4 **)(param_1 + 10);

+      param_1[10] = 0;

+      param_1[0xb] = 0;

+      *(undefined1 *)(param_1 + 0x12) = 0;

+      PdcReleaseRwLockExclusive2(plVar1,local_res8);

+      PdcPortClose(puVar4);

+      PdcAcquireRwLockExclusive2(plVar1,local_res8);

+      uVar9 = Feature_Servicing_PDCActivationsAVL__private_IsEnabledDeviceUsageNoInline();

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

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

+        while (plVar5 = (longlong *)*plVar2, puVar13 = auStack_28, plVar5 != plVar2) {

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

+             (lVar6 = *plVar5, (longlong *)*(longlong *)(lVar6 + 8) != plVar5)) {

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

+            (*pcVar8)(3);

+            puVar13 = auStack_20;

+            goto LAB_0;

+          }

+          *plVar2 = lVar6;

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

+          lVar6 = plVar5[4];

+          piVar3 = (int *)(lVar6 + 0x108 + (longlong)*(int *)(plVar5 + 7) * 4);

+          *piVar3 = *piVar3 + -1;

+          piVar3 = (int *)(lVar6 + 0x104);

+          *piVar3 = *piVar3 + -1;

+          *(undefined4 *)(plVar5 + 3) = 0;

+          ExFreePoolWithTag();

+        }

+LAB_1:

+        *param_1 = 0;

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2a61;

+        Pdcv2EventWrite_ACTIVATION_CLIENT_UNREGISTER((longlong)param_1,0);

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2a6e;

+        PdcReleaseRwLockExclusive2(plVar1,puVar13 + 0x30);

+        lVar6 = *plVar1;

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2a7a;

+        ExFreePoolWithTag(lVar6,0);

+        *plVar1 = 0;

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

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2a8b;

+        PdcCloseEvent(lVar6);

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2a97;

+        ExFreePoolWithTag(param_1,0);

+        *(undefined8 *)(puVar13 + -8) = 0x1400a2aa1;

+        PdcUninitializeETW();

+        return 0;

+      }

+LAB_0:

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

+joined_r0x0001400a2a13:

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

+        do {

+          puVar10 = puVar12;

+          puVar7 = (undefined8 *)*puVar12;

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

+            puVar7 = (undefined8 *)puVar12[1];

+            puVar10 = puVar12 + 1;

+            if (puVar7 == (undefined8 *)0x0) goto LAB_2;

+          }

+          puVar12 = puVar7;

+          *puVar10 = 0;

+        } while( true );

+      }

+      param_1[0x18] = 0;

+      param_1[0x19] = 0;

+      goto LAB_1;

+    }

+    uVar11 = 0xc00000bb;

+    PdcReleaseRwLockExclusive2(plVar1,local_res8);

+  }

+  else {

+    uVar11 = 0xc00000ef;

+    param_1 = (int *)0x0;

+  }

+  Pdcv2EventWrite_ACTIVATION_CLIENT_UNREGISTER((longlong)param_1,uVar11);

+  return uVar11;

+LAB_2:

+  uVar9 = puVar12[2];

+  *(undefined8 *)(puVar13 + -8) = 0x1400a2a42;

+  PdcpActivationClientTableDeleteRoutine((longlong)puVar12);

+  puVar12 = (undefined8 *)(uVar9 & 0xfffffffffffffffc);

+  goto joined_r0x0001400a2a13;

 }
```

## `NetioPhChecksumIpDatagramWithInitialChecksum`  (modified)

```diff
--- NetioPhChecksumIpDatagramWithInitialChecksum
+++ NetioPhChecksumIpDatagramWithInitialChecksum
@@ -1,17 +1,52 @@
 

 uint NetioPhChecksumIpDatagramWithInitialChecksum(longlong param_1,uint param_2,uint param_3)

 

 {

-  undefined8 uVar1;

-  uint in_EAX;

-  longlong in_R10;

-  byte in_CF;

+  undefined8 *puVar1;

+  uint uVar2;

+  uint uVar3;

+  longlong lVar4;

+  uint uVar5;

+  uint uVar6;

   

-  *(uint *)param_1 = *(int *)param_1 + in_EAX + (uint)in_CF;

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

-  *(undefined8 *)(param_1 + 0x10) = *(undefined8 *)(in_R10 + 0x10);

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

-  *(undefined8 *)(param_1 + 0x20) = *(undefined8 *)(in_R10 + 0x20);

-  return in_EAX;

+                    /* 0x4e100  346  NetioPhChecksumIpDatagramWithInitialChecksum */

+  puVar1 = *(undefined8 **)(param_1 + 8);

+  uVar6 = 0;

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

+  while( true ) {

+    if (param_2 == 0) {

+      uVar2 = (param_3 >> 0x10) + (param_3 & 0xffff);

+      uVar2 = (uVar2 >> 0x10) + (uVar2 & 0xffff);

+      if (uVar2 != 0xffff) {

+        uVar2 = (uint)(ushort)~(ushort)uVar2;

+      }

+      return uVar2;

+    }

+    if ((Feature_3488336184__private_featureState & 0x10) == 0) {

+      Feature_3488336184__private_IsEnabledDeviceUsageNoInline();

+    }

+    if ((*(byte *)((longlong)puVar1 + 10) & 5) == 0) {

+      lVar4 = MmMapLockedPagesSpecifyCache(puVar1,0,1,0,0,0x40000000);

+    }

+    else {

+      lVar4 = puVar1[3];

+    }

+    if (lVar4 == 0) break;

+    uVar5 = param_2;

+    if (*(int *)(puVar1 + 5) - uVar2 <= param_2) {

+      uVar5 = *(int *)(puVar1 + 5) - uVar2;

+    }

+    uVar2 = tcpxsum(0,(ulonglong *)((ulonglong)uVar2 + lVar4),uVar5);

+    uVar3 = uVar2 & 0xffff;

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

+      uVar3 = (uVar3 >> 8) + (uVar2 & 0xff) * 0x100;

+    }

+    puVar1 = (undefined8 *)*puVar1;

+    param_3 = param_3 + uVar3;

+    uVar6 = uVar6 + uVar5;

+    param_2 = param_2 - uVar5;

+    uVar2 = 0;

+  }

+  return 0;

 }
```

## `FwAuditModeRegKeyChangeCallback`  (modified)

```diff
--- FwAuditModeRegKeyChangeCallback
+++ FwAuditModeRegKeyChangeCallback
@@ -1,9 +1,34 @@
 

-byte FwAuditModeRegKeyChangeCallback(void)

+ulonglong FwAuditModeRegKeyChangeCallback(void)

 

 {

-  byte in_AL;

+  uint uVar1;

+  ulonglong uVar2;

+  int local_res18 [2];

+  int local_res20 [2];

+  uint local_18 [2];

+  longlong local_10;

   

-  return in_AL & 1;

+  local_10 = 0;

+  local_res18[0] = 0;

+  uVar2 = WfpRegOpenKey(&local_10,

+                        L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\BFE\\Parameters\\Policy\\Options"

+                        ,local_res18);

+  if ((uVar2 == 0) && (local_res18[0] != 0)) {

+    local_18[0] = 0;

+    local_res20[0] = 0;

+    uVar2 = WfpRegGetUint32Value(local_10,L"EnableAuditMode",local_18,local_res20);

+    uVar1 = gAuditModeEnabled;

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

+      LOCK();

+      gAuditModeEnabled = local_18[0];

+      uVar2 = (ulonglong)uVar1;

+      UNLOCK();

+    }

+  }

+  if (local_10 != 0) {

+    uVar2 = ZwClose();

+  }

+  return uVar2;

 }
```

## `NsiGetParameterEx`  (modified)

```diff
--- NsiGetParameterEx
+++ NsiGetParameterEx
@@ -1,9 +1,419 @@
+

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

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

 

 int * NsiGetParameterEx(longlong *param_1,undefined8 param_2,undefined8 **param_3)

 

 {

-  int *in_RAX;

+  uint uVar1;

+  int iVar2;

+  code *pcVar3;

+  byte bVar4;

+  uint uVar5;

+  uint extraout_EAX;

+  int *piVar6;

+  ulonglong uVar7;

+  void *_Dst;

+  undefined8 *puVar8;

+  undefined2 uVar9;

+  int *piVar10;

+  uint *puVar11;

+  uint *puVar12;

+  undefined1 auStackY_168 [32];

+  int local_108 [2];

+  undefined8 *local_100;

+  undefined8 local_f8;

+  undefined8 local_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  undefined4 local_d8;

+  undefined4 uStack_d4;

+  undefined4 uStack_d0;

+  undefined4 uStack_cc;

+  ulonglong local_c8;

+  undefined8 uStack_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98 [2];

+  undefined8 local_88;

+  undefined8 uStack_80;

+  longlong local_78;

+  longlong lStack_70;

+  longlong local_68;

+  longlong lStack_60;

+  longlong local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong local_38;

   

-  return in_RAX;

+                    /* 0x2b880  431  NsiGetParameterEx */

+  local_38 = __security_cookie ^ (ulonglong)auStackY_168;

+  piVar10 = (int *)0x0;

+  local_88 = 0;

+  uStack_80 = 0;

+  local_108[0] = 0;

+  local_78 = 0;

+  lStack_70 = 0;

+  local_100 = (undefined8 *)((ulonglong)local_100 & 0xffffffff00000000);

+  local_68 = 0;

+  lStack_60 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  if ((4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29)) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+    puVar8 = (undefined8 *)(param_1[2] + 8);

+    local_48 = 0;

+    uStack_40 = 0;

+    if (param_1[2] == 0) {

+      puVar8 = &local_48;

+    }

+    PsGetCurrentProcessId();

+    if ((local_108[0] == 0) && ((int)local_100 == 0)) {

+      param_3 = &local_100;

+      NdisGetThreadObjectCompartmentScope(SystemReserved1[0xf],local_108);

+    }

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

+        (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+       ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+      WPP_SF_s_guid_dddqdd(WPP_GLOBAL_Control[3],0,param_3,"NsiGetParameterEx",puVar8);

+    }

+  }

+  _Dst = (void *)0x0;

+  uVar5 = *(uint *)(param_1 + 4);

+  if (uVar5 < 4) {

+    if (*(uint *)((longlong)param_1 + 0x24) < 3) {

+      if (uVar5 == 2) {

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

+            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+          uVar9 = 0x10;

+LAB_0:

+          WPP_SF_(WPP_GLOBAL_Control[3],uVar9,&WPP_becc514261ff315f80948044332aa980_Traceguids);

+        }

+      }

+      else {

+        if (*(uint *)(param_1 + 7) < 3) {

+          if (*param_1 != 0) {

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

+                (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+              WPP_SF_(WPP_GLOBAL_Control[3],0x12,&WPP_becc514261ff315f80948044332aa980_Traceguids);

+            }

+            piVar10 = (int *)0xc0000002;

+            goto LAB_1;

+          }

+          if (0xffffffff <

+              (ulonglong)*(uint *)((longlong)param_1 + 0x4c) + (ulonglong)*(uint *)(param_1 + 9)) {

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

+                (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+              uVar9 = 0x13;

+              goto LAB_0;

+            }

+            goto LAB_2;

+          }

+          piVar6 = piVar10;

+          if (uVar5 != 0) {

+            piVar6 = NsipGetNmpContext((uint *)(param_1 + 1));

+          }

+          iVar2 = (int)param_1[4];

+          if (iVar2 == 0) {

+LAB_3:

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

+              if (param_1[2] == 0) {

+                if (iVar2 != 0) goto LAB_4;

+                piVar6 = NsipGetNmpContext((uint *)(param_1 + 1));

+                if (piVar6 == (int *)0x0) goto LAB_2;

+                param_1[2] = *(longlong *)(piVar6 + 6);

+              }

+              NsipReadPersistentData

+                        ((uint *)(param_1 + 1),*(int *)((longlong)param_1 + 0x24),param_1 + 5,

+                         (undefined1 *)param_1[8],(undefined1 *)0x0,(uint *)(param_1 + 9),

+                         *(uint *)((longlong)param_1 + 0x4c));

+              piVar10 = (int *)(ulonglong)extraout_EAX;

+              if (piVar6 != (int *)0x0) {

+                param_1[2] = 0;

+                NsipDereferenceNmpContext(piVar6);

+              }

+              goto LAB_1;

+            }

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

+                (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+              WPP_SF_(WPP_GLOBAL_Control[3],0x14,&WPP_becc514261ff315f80948044332aa980_Traceguids);

+            }

+LAB_4:

+            piVar10 = (int *)0xc000000d;

+          }

+          else {

+            if (iVar2 == 3) {

+              if (piVar6 == (int *)0x0) goto LAB_3;

+            }

+            else if (piVar6 == (int *)0x0) {

+              piVar10 = (int *)0xc00000bb;

+              goto LAB_1;

+            }

+            bVar4 = KeGetCurrentIrql();

+            if (1 < bVar4) {

+LAB_5:

+              uVar5 = *(uint *)(param_1 + 3);

+              uVar7 = (ulonglong)uVar5;

+              if (uVar5 < *(uint *)(*(longlong *)(piVar6 + 0xc) + 4)) {

+                uVar5 = *(uint *)(param_1 + 6);

+                puVar12 = (uint *)(uVar7 * 0x68 + *(longlong *)(*(longlong *)(piVar6 + 0xc) + 8));

+                if (*puVar12 == uVar5) {

+                  if (uVar5 == 0) {

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

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

+                          (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                        WPP_SF_(WPP_GLOBAL_Control[3],0x17,

+                                &WPP_becc514261ff315f80948044332aa980_Traceguids);

+                      }

+                      param_1[5] = 0;

+                    }

+                  }

+                  else if (param_1[5] == 0) goto LAB_6;

+                  if ((param_1[8] != 0) && ((int)param_1[9] == 0)) {

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

+                       ((2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29) &&

+                        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)))) {

+                      WPP_SF_(WPP_GLOBAL_Control[3],0x18,

+                              &WPP_becc514261ff315f80948044332aa980_Traceguids);

+                    }

+                    param_1[8] = 0;

+                  }

+                  if (*(longlong *)(puVar12 + 8) == 0) {

+                    if (*(longlong *)(puVar12 + 0xc) == 0) {

+                      piVar10 = (int *)0xc00000bb;

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

+                          (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                         ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                        uVar9 = 0x1f;

+LAB_7:

+                        WPP_SF_(WPP_GLOBAL_Control[3],uVar9,

+                                &WPP_becc514261ff315f80948044332aa980_Traceguids);

+                      }

+                    }

+                    else {

+                      iVar2 = (int)param_1[7];

+                      local_98[0] = 0;

+                      uStack_c0 = 0;

+                      local_c8 = (ulonglong)*(uint *)((longlong)param_1 + 0x24);

+                      local_e8 = 0;

+                      uStack_e0 = 0;

+                      local_b8 = 0;

+                      uStack_b0 = 0;

+                      local_a8 = 0;

+                      uStack_a0 = 0;

+                      local_d8 = (undefined4)param_1[5];

+                      uStack_d4 = *(undefined4 *)((longlong)param_1 + 0x2c);

+                      uStack_d0 = (undefined4)param_1[6];

+                      uStack_cc = *(undefined4 *)((longlong)param_1 + 0x34);

+                      if (iVar2 == 0) {

+                        uVar5 = puVar12[1];

+                        local_100 = &uStack_c0;

+                        puVar11 = (uint *)&local_b8;

+                      }

+                      else if (iVar2 == 1) {

+                        uVar5 = puVar12[2];

+                        local_100 = &uStack_b0;

+                        puVar11 = (uint *)&local_a8;

+                      }

+                      else {

+                        if (iVar2 != 2) goto LAB_4;

+                        uVar5 = puVar12[3];

+                        local_100 = &uStack_a0;

+                        puVar11 = (uint *)local_98;

+                      }

+                      if (uVar5 == 0) {

+                        piVar10 = (int *)0xc00000bb;

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

+                            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                          uVar9 = 0x19;

+                          goto LAB_7;

+                        }

+                      }

+                      else {

+                        bVar4 = (byte)puVar12[4] & 2;

+                        if ((bVar4 == 0) &&

+                           (uVar5 < (uint)((int)param_1[9] + *(int *)((longlong)param_1 + 0x4c)))) {

+                          piVar10 = (int *)0xc000000d;

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

+                              (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                             ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                            uVar9 = 0x1a;

+                            goto LAB_7;

+                          }

+                        }

+                        else {

+                          uVar1 = (int)param_1[9] + *(int *)((longlong)param_1 + 0x4c);

+                          if (uVar1 < uVar5) {

+                            uVar1 = uVar5;

+                          }

+                          uVar7 = (ulonglong)uVar1;

+                          if (bVar4 == 0) goto joined_r0x00014002bdd8;

+                          if (uVar1 < 0x100000) {

+                            do {

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

+                                ExFreePoolWithTag(_Dst,0);

+                              }

+                              local_f0 = 0;

+                              local_f8 = 1;

+                              _Dst = (void *)ExAllocatePool3(0x40,uVar7,0x7249534e,&local_f8);

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

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

+                                    (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                                   ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                                  WPP_SF_(WPP_GLOBAL_Control[3],0x1c,

+                                          &WPP_becc514261ff315f80948044332aa980_Traceguids);

+                                }

+                                piVar10 = (int *)0xc000009a;

+                                goto LAB_8;

+                              }

+                              memset(_Dst,0,uVar7);

+                              local_e8 = *(undefined8 *)(piVar6 + 10);

+                              uStack_e0 = *(undefined8 *)(puVar12 + 6);

+                              *local_100 = _Dst;

+                              pcVar3 = *(code **)(puVar12 + 0xc);

+                              *puVar11 = (uint)uVar7;

+                              uVar5 = (*pcVar3)(&local_e8);

+                              piVar10 = (int *)(ulonglong)uVar5;

+                              if (uVar5 != 0xc0000023) {

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

+                                if ((uint)(*(int *)((longlong)param_1 + 0x4c) + (int)param_1[9]) <=

+                                    *puVar11) goto LAB_9;

+                              }

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

+                                  (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                                 ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                                WPP_SF_DD(WPP_GLOBAL_Control[3],0x1d,

+                                          &WPP_becc514261ff315f80948044332aa980_Traceguids,uVar5);

+                              }

+                              uVar1 = (uint)uVar7 * 2;

+                              uVar7 = (ulonglong)uVar1;

+joined_r0x00014002bdd8:

+                            } while (uVar1 < 0x100000);

+                            if ((int)piVar10 < 0) {

+LAB_8:

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

+                                  (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                                 ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                                WPP_SF_D(WPP_GLOBAL_Control[3],0x1e,

+                                         &WPP_becc514261ff315f80948044332aa980_Traceguids,

+                                         (int)piVar10);

+                              }

+                            }

+                            else {

+LAB_9:

+                              memmove((void *)param_1[8],

+                                      (void *)((ulonglong)*(uint *)((longlong)param_1 + 0x4c) +

+                                              (longlong)_Dst),(ulonglong)*(uint *)(param_1 + 9));

+                            }

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

+                              ExFreePoolWithTag(_Dst,0);

+                            }

+                          }

+                          else {

+                            piVar10 = (int *)0xc000000d;

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

+                                (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+                               ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+                              uVar9 = 0x1b;

+                              goto LAB_7;

+                            }

+                          }

+                        }

+                      }

+                    }

+                  }

+                  else {

+                    local_78 = param_1[5];

+                    lStack_70 = param_1[6];

+                    local_68 = param_1[7];

+                    lStack_60 = param_1[8];

+                    uStack_50 = CONCAT44(uStack_50._4_4_,*(undefined4 *)((longlong)param_1 + 0x24));

+                    local_58 = param_1[9];

+                    local_88 = *(undefined8 *)(piVar6 + 10);

+                    uStack_80 = *(undefined8 *)(puVar12 + 6);

+                    uVar5 = (**(code **)(puVar12 + 8))(&local_88);

+                    piVar10 = (int *)(ulonglong)uVar5;

+                  }

+                  goto LAB_10;

+                }

+LAB_6:

+                if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+                    (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) ||

+                   ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) == 0))

+                goto LAB_4;

+                uVar9 = 0x16;

+              }

+              else {

+                if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+                    (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) ||

+                   ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) == 0))

+                goto LAB_4;

+                uVar9 = 0x15;

+              }

+              WPP_SF_DD(WPP_GLOBAL_Control[3],uVar9,&WPP_becc514261ff315f80948044332aa980_Traceguids

+                        ,uVar5);

+              goto LAB_4;

+            }

+            uVar7 = NsipAccessCheck((uint *)(param_1 + 1),'\x01','\0');

+            piVar10 = (int *)(uVar7 & 0xffffffff);

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

+          }

+LAB_10:

+          if (piVar6 != (int *)0x0) {

+            NsipDereferenceNmpContext(piVar6);

+          }

+          goto LAB_1;

+        }

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

+            (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+           ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+          uVar9 = 0x11;

+          uVar5 = *(uint *)(param_1 + 7);

+          goto LAB_11;

+        }

+      }

+    }

+    else if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+            ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+      uVar9 = 0xf;

+      uVar5 = *(uint *)((longlong)param_1 + 0x24);

+      goto LAB_11;

+    }

+  }

+  else if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) &&

+          ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+    uVar9 = 0xe;

+LAB_11:

+    WPP_SF_D(WPP_GLOBAL_Control[3],uVar9,&WPP_becc514261ff315f80948044332aa980_Traceguids,uVar5);

+  }

+LAB_2:

+  piVar10 = (int *)0xc000000d;

+LAB_1:

+  if ((4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29)) &&

+     ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x10) != 0)) {

+    puVar8 = (undefined8 *)(param_1[2] + 8);

+    local_48 = 0;

+    uStack_40 = 0;

+    if (param_1[2] == 0) {

+      puVar8 = &local_48;

+    }

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

+      WPP_SF_s_guid_dddqddD

+                (WPP_GLOBAL_Control[3],0,(ulonglong)*(uint *)(param_1 + 4),"NsiGetParameterEx",

+                 puVar8);

+    }

+  }

+  return piVar10;

 }
```

## `WfpSetAuditMode`  (modified)

```diff
--- WfpSetAuditMode
+++ IsAuditApplicableAndEnabledForSublayer
@@ -1,62 +1,67 @@
 

-longlong WfpSetAuditMode(undefined4 param_1)

+undefined4 IsAuditApplicableAndEnabledForSublayer(int *param_1)

 

 {

+  longlong in_RAX;

+  uint in_EDX;

   longlong lVar1;

-  longlong unaff_RBP;

-  uint uVar2;

-  ulonglong unaff_RSI;

-  short in_R8W;

+  ulonglong uVar2;

   longlong lVar3;

-  longlong *unaff_R12;

-  undefined4 *unaff_R13;

-  longlong *unaff_R14;

-  undefined4 unaff_R15D;

+  ulonglong uVar4;

+  undefined4 in_R8D;

+  uint uVar5;

+  longlong lVar6;

+  longlong *in_R9;

   ulonglong uStackX_20;

   longlong in_stack_00000078;

+  undefined4 *in_stack_00000080;

   

+  uVar5 = 0;

+  uVar4 = 0;

+  uVar2 = (ulonglong)in_EDX;

+  *(undefined8 *)(in_RAX + 0x20) = 0;

+  *(undefined8 *)(in_RAX + -0x38) = 0;

+  *in_stack_00000080 = 0;

   lVar1 = 0;

-  do {

-    if (lVar1 != 0) {

+  *in_R9 = 0;

+  if (in_EDX != 0) {

+    for (; uVar5 < in_EDX; uVar5 = uVar5 + 1) {

+      lVar1 = -1;

+      do {

+        lVar1 = lVar1 + 1;

+      } while (*(short *)(*(longlong *)(param_1 + (ulonglong)uVar5 * 2) + lVar1 * 2) != 0);

+      lVar1 = WfpSizeTAdd(uVar4,lVar1 * 2 + 2,(longlong *)&uStackX_20);

+      if (lVar1 != 0) goto LAB_0;

+      uVar4 = uStackX_20;

+    }

+    lVar1 = WfpPoolAllocNonPaged(uVar4,in_R8D,&stack0x00000078);

+    if (lVar1 == 0) {

+      lVar3 = 0;

+      if (in_EDX != 0) {

+        do {

+          lVar6 = -1;

+          do {

+            lVar6 = lVar6 + 1;

+          } while (*(short *)((longlong)*(void **)param_1 + lVar6 * 2) != 0);

+          memmove((void *)(lVar3 + in_stack_00000078),*(void **)param_1,lVar6 * 2 + 2);

+          lVar6 = -1;

+          do {

+            lVar6 = lVar6 + 1;

+          } while (*(short *)(*(longlong *)param_1 + lVar6 * 2) != 0);

+          param_1 = (int *)((longlong)param_1 + 8);

+          lVar3 = lVar3 + lVar6 * 2 + 2;

+          uVar2 = uVar2 - 1;

+        } while (uVar2 != 0);

+      }

+      *in_stack_00000080 = (int)(uVar4 >> 1);

+      *in_R9 = in_stack_00000078;

+    }

+    else {

 LAB_0:

-      WfpNamedPoolFree(unaff_R15D,&stack0x00000078);

+      WfpNamedPoolFree(in_R8D,&stack0x00000078);

       WfpReportError(lVar1,"WfpStringCombineStrArray");

-      return lVar1;

     }

-    uVar2 = (int)unaff_RSI + 1;

-    unaff_RSI = (ulonglong)uVar2;

-    if ((uint)unaff_RBP <= uVar2) {

-      lVar1 = WfpPoolAllocNonPaged(uStackX_20,unaff_R15D,&stack0x00000078);

-      if (lVar1 == 0) {

-        lVar1 = 0;

-        if ((uint)unaff_RBP != 0) {

-          do {

-            lVar3 = -1;

-            do {

-              lVar3 = lVar3 + 1;

-            } while (*(short *)(*unaff_R14 + lVar3 * 2) != 0);

-            memmove((void *)(lVar1 + in_stack_00000078),(void *)*unaff_R14,lVar3 * 2 + 2);

-            lVar3 = -1;

-            do {

-              lVar3 = lVar3 + 1;

-            } while (*(short *)(*unaff_R14 + lVar3 * 2) != 0);

-            unaff_R14 = unaff_R14 + 1;

-            lVar1 = lVar1 + lVar3 * 2 + 2;

-            unaff_RBP = unaff_RBP + -1;

-          } while (unaff_RBP != 0);

-        }

-        *unaff_R13 = (int)(uStackX_20 >> 1);

-        *unaff_R12 = in_stack_00000078;

-        return 0;

-      }

-      goto LAB_0;

-    }

-    lVar1 = -1;

-    do {

-      lVar1 = lVar1 + 1;

-    } while (*(short *)(unaff_R14[unaff_RSI] + lVar1 * 2) != in_R8W);

-    lVar1 = WfpSizeTAdd(uStackX_20,lVar1 * 2 + 2,(longlong *)&uStackX_20);

-    in_R8W = 0;

-  } while( true );

+  }

+  return (int)lVar1;

 }
```

## `PdcReleaseRwLockExclusive2`  (modified)

```diff
--- PdcReleaseRwLockExclusive2
+++ PdcRwLockInitialize2
@@ -1,33 +1,22 @@
 

-void PdcReleaseRwLockExclusive2(longlong *param_1,undefined1 *param_2)

+undefined8 PdcRwLockInitialize2(longlong *param_1)

 

 {

-  longlong *plVar1;

-  code *pcVar2;

-  longlong lVar3;

+  longlong lVar1;

+  undefined8 uVar2;

   

-  if (param_2 != (undefined1 *)0x0) {

-    *param_2 = 1;

+  lVar1 = PdcAllocate('\0');

+  uVar2 = 0;

+  if (lVar1 == 0) {

+    uVar2 = 0xc0000017;

   }

-  if (((*param_1 != 0) && ((void *)param_1[1] == SystemReserved1[0xf])) && (0 < (int)param_1[2])) {

-    LOCK();

-    plVar1 = param_1 + 2;

-    lVar3 = *plVar1;

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

-    UNLOCK();

-    if ((int)lVar3 == 1) {

-      param_1[1] = 0;

-    }

-    KeReleaseMutex(*param_1,0);

-    if (param_2 != (undefined1 *)0x0) {

-      *param_2 = 0;

-    }

-    return;

+  else {

+    *param_1 = 0;

+    param_1[1] = 0;

+    param_1[2] = 0;

+    KeInitializeMutex(lVar1,0);

+    *param_1 = lVar1;

   }

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

-  (*pcVar2)(5);

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

-  (*pcVar2)();

-  return;

+  return uVar2;

 }
```

## `Pdcv2pActivationClientCallback`  (modified)

```diff
--- Pdcv2pActivationClientCallback
+++ Pdcv2pActivationClientCallback
@@ -1,2 +1,108 @@
-Failed to decompile netio.sys - .ProgramDB Pdcv2pActivationClientCallback : Error: Decompile error: 
-Low-level Error: DuplicateFunctionError, but could not recover original symbol+

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

+

+ulonglong Pdcv2pActivationClientCallback(int *param_1,longlong param_2)

+

+{

+  longlong *plVar1;

+  ulonglong uVar2;

+  ulonglong uVar3;

+  ulonglong uVar4;

+  int *piVar5;

+  uint uVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  char local_res8 [8];

+  ulonglong local_res18 [2];

+  

+  uVar6 = 0;

+  uVar7 = 0;

+  local_res8[0] = '\0';

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

+    uVar8 = 0xc00000ef;

+    uVar7 = uVar6;

+  }

+  else if (*param_1 == 0x32414450) {

+    if (*(int *)(param_2 + 0x28) == 0xc) {

+      piVar5 = param_1;

+      uVar2 = IoctlKfdQueryEnumFilters();

+      uVar8 = uVar2 & 0xffffffff;

+      plVar1 = (longlong *)(piVar5 + 2);

+      while (PdcAcquireRwLockExclusive2(plVar1,local_res8), *(longlong *)(param_1 + 0x1a) != 0) {

+        PdcReleaseRwLockExclusive2(plVar1,local_res8);

+        PdcWaitForEvent(*(undefined8 *)(param_1 + 0x1c));

+      }

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

+        uVar8 = 0xc0000700;

+      }

+      else {

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

+        uVar7 = *(uint *)(param_2 + 0x40);

+        local_res18[0] = uVar4;

+        uVar3 = Feature_Servicing_PDCActivationsAVL__private_IsEnabledDeviceUsageNoInline();

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

+          for (piVar5 = *(int **)(param_1 + 0x14); piVar5 != param_1 + 0x14;

+              piVar5 = *(int **)piVar5) {

+            if (*(ulonglong *)(piVar5 + 0x96) == uVar4) goto LAB_0;

+          }

+        }

+        else {

+          piVar5 = *(int **)(param_1 + 0x18);

+          while (piVar5 != (int *)0x0) {

+            uVar4 = PdcpActivationClientTableCompareRoutine(local_res18,(longlong)piVar5);

+            if ((int)uVar4 < 0) {

+              piVar5 = *(int **)piVar5;

+            }

+            else {

+              if ((int)uVar4 < 1) break;

+              piVar5 = *(int **)(piVar5 + 2);

+            }

+          }

+LAB_0:

+          if (piVar5 != (int *)0x0) {

+            if (100 < (int)uVar7) {

+              piVar5[0x13] = piVar5[0x13] + 1;

+              *(undefined1 *)(piVar5 + 0x11) = 1;

+            }

+            Pdcv2EventWrite_ACTIVATION_CLIENT_CALLBACK

+                      ((longlong)piVar5,(longlong)param_1,uVar7,(int)uVar2);

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

+            *(int **)(param_1 + 0x1e) = piVar5;

+            PdcResetEvent();

+            *(void **)(*(longlong *)(param_1 + 10) + 0x6e0) = SystemReserved1[0xf];

+            PdcReleaseRwLockExclusive2(plVar1,local_res8);

+            (**(code **)(param_1 + 0xe))

+                      (piVar5,uVar7,*(undefined8 *)(param_1 + 0x10),*(undefined8 *)(piVar5 + 10));

+            PdcAcquireRwLockExclusive2(plVar1,local_res8);

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

+              *(undefined8 *)(*(longlong *)(param_1 + 10) + 0x6e0) = 0;

+            }

+            param_1[0x1a] = 0;

+            param_1[0x1b] = 0;

+            param_1[0x1e] = 0;

+            param_1[0x1f] = 0;

+            KeSetEvent(*(undefined8 *)(param_1 + 0x1c),0,0);

+            goto LAB_1;

+          }

+        }

+        uVar8 = 0xc0000189;

+      }

+    }

+    else {

+      uVar8 = 0xc0000702;

+      uVar7 = uVar6;

+    }

+  }

+  else {

+    uVar8 = 0xc00000ef;

+    param_1 = (int *)0x0;

+    uVar7 = uVar6;

+  }

+  Pdcv2EventWrite_ACTIVATION_CLIENT_CALLBACK(0,(longlong)param_1,uVar7,(int)uVar8);

+LAB_1:

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

+    PdcReleaseRwLockExclusive2((longlong *)(param_1 + 2),local_res8);

+  }

+  return uVar8;

+}

+
```

## `NTOSKRNL.EXE::KeReleaseMutex`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseMutex calling
+++ NTOSKRNL.EXE::KeReleaseMutex calling
@@ -9,2 +8,0 @@
-Pdcv2ActivationClientActivate
-Pdcv2ActivationClientDeactivate
```

## `NDIS.SYS::NdisReleaseRWLock`  (modified)

```diff
--- NDIS.SYS::NdisReleaseRWLock calling
+++ NDIS.SYS::NdisReleaseRWLock calling
@@ -30 +29,0 @@
-ProcessCallout2
```

## `NDIS.SYS::NdisAcquireRWLockRead`  (modified)

```diff
--- NDIS.SYS::NdisAcquireRWLockRead calling
+++ NDIS.SYS::NdisAcquireRWLockRead calling
@@ -10 +9,0 @@
-ProcessCallout2
```

## `NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx`  (modified)

```diff
--- NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx calling
+++ NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx calling
@@ -25 +24,0 @@
-ProcessCallout2
```

## `NTOSKRNL.EXE::ExFreePoolWithTag`  (modified)

```diff
--- NTOSKRNL.EXE::ExFreePoolWithTag calling
+++ NTOSKRNL.EXE::ExFreePoolWithTag calling
@@ -102,0 +103 @@
+PdcpActivationClientTableDeleteRoutine
```

## `NTOSKRNL.EXE::KeGetCurrentIrql`  (modified)

```diff
--- NTOSKRNL.EXE::KeGetCurrentIrql calling
+++ NTOSKRNL.EXE::KeGetCurrentIrql calling
@@ -33 +32,0 @@
-ProcessCallout2
```

## `NTOSKRNL.EXE::KeBugCheckEx`  (modified)

```diff
--- NTOSKRNL.EXE::KeBugCheckEx calling
+++ NTOSKRNL.EXE::KeBugCheckEx calling
@@ -1,0 +2 @@
+KfdClassifyFast
```

## `NTOSKRNL.EXE::ExAllocatePool2`  (modified)

```diff
--- NTOSKRNL.EXE::ExAllocatePool2 calling
+++ NTOSKRNL.EXE::ExAllocatePool2 calling
@@ -53 +52,0 @@
-Pdcv2ActivationClientActivate
```
