# CVE-2026-96102 — tcpip.sys patch diff

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

## `Fl8AddGroup`  (modified)

```diff
--- Fl8AddGroup
+++ Fl8AddGroup
@@ -1,122 +1,264 @@
 

-void Fl8AddGroup(void)

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

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

+

+ulonglong Fl8AddGroup(undefined8 *param_1)

 

 {

-  undefined8 *puVar1;

-  longlong in_RAX;

-  undefined1 uVar2;

-  int unaff_EBX;

-  undefined1 *unaff_RDI;

-  uint uVar3;

-  uint in_R10D;

-  undefined4 in_register_00000094;

-  longlong in_R11;

-  uint unaff_R14D;

-  short unaff_R15W;

-  bool in_CF;

-  bool in_ZF;

-  short *in_stack_00000040;

+  byte bVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  undefined8 uVar4;

+  code *pcVar5;

+  undefined1 auVar6 [13];

+  undefined1 auVar7 [13];

+  uint5 uVar8;

+  undefined1 auVar9 [13];

+  undefined1 auVar10 [13];

+  ulonglong uVar11;

+  longlong *plVar12;

+  longlong *plVar13;

+  ulonglong uVar14;

+  byte *pbVar15;

+  longlong *plVar16;

+  int iVar17;

+  uint uVar18;

+  uint uVar19;

+  ulonglong uVar20;

+  uint uVar21;

+  longlong lVar22;

+  undefined1 *puVar23;

+  undefined1 *puVar24;

+  uint uVar25;

+  undefined8 *puVar26;

+  uint uVar27;

+  uint uVar29;

+  ulonglong uVar30;

+  int iVar31;

+  int iVar32;

+  int iVar33;

+  int iVar34;

+  int iVar35;

+  int iVar36;

+  int iVar37;

+  int iVar38;

+  undefined1 auStack_88 [8];

+  undefined1 auStack_80 [40];

+  undefined2 local_58;

+  undefined1 uStack_56;

+  undefined4 local_50;

+  uint auStack_4c [7];

+  ulonglong local_30;

+  ulonglong uVar28;

   

-  if (in_CF || in_ZF) {

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

+  puVar24 = auStack_88;

+  puVar23 = auStack_88;

+  local_30 = __security_cookie ^ (ulonglong)auStack_88;

+  uVar11 = 0;

+  uVar27 = 0;

+  uVar29 = 0;

+  lVar2 = *(longlong *)(param_1[2] + 0x48);

+  local_58 = 0;

+  uStack_56 = 0;

+  lVar22 = *(longlong *)(lVar2 + 0x20);

+  bVar1 = *(byte *)(lVar2 + 0x48a);

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

+  iVar31 = (**(code **)(lVar22 + 0x198))(&local_50,param_1[4],lVar2);

+  if (iVar31 != 0) {

+    uVar11 = 0xc0000001;

+    puVar24 = auStack_88;

+    goto LAB_0;

+  }

+  NdisAcquireRWLockWrite(*(undefined8 *)(lVar2 + 0x28),&local_58,0);

+  uVar25 = 0;

+  uVar21 = (uint)bVar1;

+  uVar14 = uVar11;

+  uVar28 = uVar11;

+  if (7 < uVar21) {

+    iVar35 = 0;

+    iVar36 = 0;

+    iVar37 = 0;

+    iVar38 = 0;

+    iVar31 = 0;

+    iVar32 = 0;

+    iVar33 = 0;

+    iVar34 = 0;

+    do {

+      iVar17 = (int)uVar14;

+      uVar19 = *(uint *)((longlong)auStack_4c + (uVar14 - 4));

+      uVar18 = iVar17 + 8;

+      uVar14 = (ulonglong)uVar18;

+      auVar6[0xc] = (char)(uVar19 >> 0x18);

+      auVar6._0_12_ = ZEXT712(0);

+      uVar8 = CONCAT32(auVar6._10_3_,(ushort)(byte)(uVar19 >> 0x10));

+      auVar9._5_8_ = 0;

+      auVar9._0_5_ = uVar8;

+      iVar35 = iVar35 + (uVar19 & 0xff);

+      iVar36 = iVar36 + (int)CONCAT72(SUB137(auVar9 << 0x40,6),(ushort)(byte)(uVar19 >> 8));

+      iVar37 = iVar37 + (int)uVar8;

+      iVar38 = iVar38 + (uint)(uint3)(auVar6._10_3_ >> 0x10);

+      uVar19 = *(uint *)((longlong)auStack_4c + ((ulonglong)(iVar17 + 4) - 4));

+      auVar7[0xc] = (char)(uVar19 >> 0x18);

+      auVar7._0_12_ = ZEXT712(0);

+      uVar8 = CONCAT32(auVar7._10_3_,(ushort)(byte)(uVar19 >> 0x10));

+      auVar10._5_8_ = 0;

+      auVar10._0_5_ = uVar8;

+      iVar31 = (uVar19 & 0xff) + iVar31;

+      iVar32 = (int)CONCAT72(SUB137(auVar10 << 0x40,6),(ushort)(byte)(uVar19 >> 8)) + iVar32;

+      iVar33 = (int)uVar8 + iVar33;

+      iVar34 = (uint)(uint3)(auVar7._10_3_ >> 0x10) + iVar34;

+    } while (uVar18 < (bVar1 & 0xfffffff8));

+    uVar28 = (ulonglong)

+             (uint)(iVar35 + iVar31 + iVar37 + iVar33 + iVar36 + iVar32 + iVar38 + iVar34);

+  }

+  iVar31 = (int)uVar28;

+  uVar19 = (uint)uVar14;

+  if (uVar19 < uVar21) {

+    if (uVar21 - uVar19 < 2) {

+LAB_1:

+      iVar31 = iVar31 + (uint)*(byte *)((longlong)auStack_4c + (uVar14 - 4));

+    }

+    else {

+      uVar18 = ((uVar21 - uVar19) - 2 >> 1) + 1;

+      uVar30 = (ulonglong)uVar18;

+      uVar28 = uVar11;

+      uVar20 = uVar11;

+      do {

+        uVar27 = (int)uVar28 + (uint)*(byte *)((longlong)auStack_4c + (uVar14 - 4));

+        uVar28 = (ulonglong)uVar27;

+        uVar29 = (int)uVar20 + (uint)*(byte *)((longlong)auStack_4c + (uVar14 - 3));

+        uVar20 = (ulonglong)uVar29;

+        uVar14 = uVar14 + 2;

+        uVar30 = uVar30 - 1;

+      } while (uVar30 != 0);

+      if (uVar19 + uVar18 * 2 < uVar21) goto LAB_1;

+    }

+    uVar28 = (ulonglong)(iVar31 + uVar29 + uVar27);

+  }

+  puVar26 = (undefined8 *)

+            (((ulonglong)(uint)((int)uVar28 + (int)(uVar28 / 0x1d) * -0x1d) + 0x15) * 0x10 + lVar2);

+  for (puVar3 = (undefined8 *)*puVar26; puVar3 != puVar26; puVar3 = (undefined8 *)*puVar3) {

+    plVar12 = puVar3 + -2;

+    iVar31 = memcmp(puVar3 + 3,&local_50,(ulonglong)bVar1);

+    if (iVar31 == 0) {

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

+        if ((Feature_4005012793__private_featureState & 0x10) == 0) {

+          uVar29 = Feature_4005012793__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          uVar29 = Feature_4005012793__private_featureState & 1;

+        }

+        if (uVar29 == 0) {

+          *(short *)(puVar3 + 2) = *(short *)(puVar3 + 2) + 1;

+          puVar24 = auStack_88;

+        }

+        else {

+          LOCK();

+          plVar13 = puVar3 + 2;

+          lVar22 = *plVar13;

+          *plVar13 = *plVar13 + 1;

+          UNLOCK();

+          if (lVar22 + 1 < 2) {

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

+            (*pcVar5)(0xe);

+            puVar24 = auStack_80;

+          }

+        }

+        goto LAB_2;

+      }

+      break;

+    }

+  }

+  lVar22 = (ulonglong)(SystemReserved1[0x12]._4_4_ + 1) * 0x80 + FlpGroupBlockPool;

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

+    PplpLazyInitializeLookasideList(FlpGroupBlockPool,lVar22 + 0x40);

+  }

+  plVar12 = (longlong *)ExAllocateFromLookasideListEx(lVar22 + 0x40);

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

+    if (DAT_3 < '\0') {

+      McTemplateK0z_EtwWriteTransfer(&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_MEMORY_FAILURES);

+    }

+    NdisReleaseRWLock(*(undefined8 *)(lVar2 + 0x28),&local_58);

+    uVar11 = 0xc000009a;

+    puVar24 = auStack_88;

+    goto LAB_0;

+  }

+  *plVar12 = lVar2;

+  *(undefined1 *)(plVar12 + 1) = 1;

+  if ((Feature_4005012793__private_featureState & 0x10) == 0) {

+    uVar29 = Feature_4005012793__private_IsEnabledDeviceUsageNoInline();

+  }

+  else {

+    uVar29 = Feature_4005012793__private_featureState & 1;

+  }

+  if (uVar29 == 0) {

+    *(undefined2 *)(plVar12 + 4) = 1;

+  }

+  else {

+    plVar12[4] = 1;

+  }

+  memmove(plVar12 + 5,&local_50,(ulonglong)*(byte *)(lVar2 + 0x48a));

+  uVar14 = uVar11;

+  uVar28 = uVar11;

+  if (uVar21 < 2) {

+    uVar20 = uVar11;

+    if (bVar1 != 0) goto LAB_4;

+  }

+  else {

+    uVar29 = (uVar21 - 2 >> 1) + 1;

+    uVar20 = (ulonglong)uVar29;

+    pbVar15 = (byte *)((longlong)plVar12 + 0x29);

+    do {

+      uVar14 = (ulonglong)((int)uVar14 + (uint)pbVar15[-1]);

+      uVar28 = (ulonglong)((int)uVar28 + (uint)*pbVar15);

+      uVar20 = uVar20 - 1;

+      pbVar15 = pbVar15 + 2;

+    } while (uVar20 != 0);

+    uVar20 = (ulonglong)uVar29 * 2;

+    if (uVar29 * 2 < uVar21) {

+LAB_4:

+      uVar25 = (uint)*(byte *)(uVar20 + 0x28 + (longlong)plVar12);

+    }

+  }

+  plVar13 = plVar12 + 2;

+  plVar16 = (longlong *)

+            ((ulonglong)((uVar25 + (int)uVar28 + (int)uVar14) % 0x1d) * 0x10 + 0x150 + lVar2);

+  lVar22 = *plVar16;

+  if (*(longlong **)(lVar22 + 8) != plVar16) {

+    plVar16 = (longlong *)0x3;

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

+    plVar13 = (longlong *)(*pcVar5)();

+    puVar23 = auStack_80;

+  }

+  *plVar13 = lVar22;

+  plVar13[1] = (longlong)plVar16;

+  *(longlong **)(lVar22 + 8) = plVar13;

+  *plVar16 = (longlong)plVar13;

+  *(int *)(lVar2 + 0x148) = *(int *)(lVar2 + 0x148) + 1;

+  puVar24 = puVar23;

+LAB_2:

+  if ((char)plVar12[1] != '\0') {

+    uVar4 = param_1[3];

+    *(undefined8 *)(puVar24 + 0x28) = *param_1;

+    *(undefined8 *)(puVar24 + 0x20) = param_1[1];

+    *(undefined8 *)(puVar24 + -8) = 0x14014ebd6;

+    uVar29 = FlpSerializedNdisRequestUnderLock(lVar2,FlpSerializedNdisAddGroupWorker,plVar12,uVar4);

+    uVar11 = (ulonglong)uVar29;

+    if ((int)uVar29 < 0) {

+      *(undefined8 *)(puVar24 + -8) = 0x14014ebe7;

+      FlpDeleteGroupUnderLock(lVar2,plVar12);

+      uVar4 = *(undefined8 *)(lVar2 + 0x28);

+      *(undefined8 *)(puVar24 + -8) = 0x14014ebf7;

+      NdisReleaseRWLock(uVar4,puVar24 + 0x30);

+      goto LAB_0;

+    }

+  }

+  uVar4 = *(undefined8 *)(lVar2 + 0x28);

+  *(undefined8 *)(puVar24 + -8) = 0x14014ec0e;

+  NdisReleaseRWLock(uVar4,puVar24 + 0x30);

+  *(longlong **)param_1[5] = plVar12;

 LAB_0:

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

-LAB_1:

-    uVar2 = 0;

-  }

-  else {

-    *(undefined1 *)(in_RAX + 0xd) = *(undefined1 *)(in_R11 + 0xd);

-    if (in_R10D < 0xf) goto LAB_0;

-    *(undefined1 *)(in_RAX + 0xe) = *(undefined1 *)(in_R11 + 0xe);

-    if (in_R10D < 0x10) goto LAB_1;

-    uVar2 = *(undefined1 *)(in_R11 + 0xf);

-  }

-  *(undefined1 *)(in_RAX + 0xf) = uVar2;

-  if (unaff_EBX != 0) {

-    *(byte *)(CONCAT44(in_register_00000094,in_R10D) + in_RAX) =

-         -1 << (8U - (char)unaff_EBX & 0x1f) &

-         *(byte *)(CONCAT44(in_register_00000094,in_R10D) + in_R11);

-  }

-  puVar1 = (undefined8 *)(in_RAX + 0x10);

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

-    *puVar1 = 0;

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

-    goto LAB_2;

-  }

-  uVar3 = unaff_R14D >> 3;

-  if (uVar3 == 0) {

-    *(undefined1 *)puVar1 = 0;

-LAB_3:

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

-LAB_4:

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

-LAB_5:

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

-LAB_6:

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

-LAB_7:

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

-LAB_8:

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

-LAB_9:

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

-LAB_10:

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

-LAB_11:

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

-LAB_12:

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

-LAB_13:

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

-LAB_14:

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

-LAB_15:

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

-LAB_16:

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

-LAB_17:

-    uVar2 = 0;

-  }

-  else {

-    *(undefined1 *)puVar1 = *unaff_RDI;

-    if (uVar3 < 2) goto LAB_3;

-    *(undefined1 *)(in_RAX + 0x11) = unaff_RDI[1];

-    if (uVar3 < 3) goto LAB_4;

-    *(undefined1 *)(in_RAX + 0x12) = unaff_RDI[2];

-    if (uVar3 < 4) goto LAB_5;

-    *(undefined1 *)(in_RAX + 0x13) = unaff_RDI[3];

-    if (uVar3 < 5) goto LAB_6;

-    *(undefined1 *)(in_RAX + 0x14) = unaff_RDI[4];

-    if (uVar3 < 6) goto LAB_7;

-    *(undefined1 *)(in_RAX + 0x15) = unaff_RDI[5];

-    if (uVar3 < 7) goto LAB_8;

-    *(undefined1 *)(in_RAX + 0x16) = unaff_RDI[6];

-    if (uVar3 < 8) goto LAB_9;

-    *(undefined1 *)(in_RAX + 0x17) = unaff_RDI[7];

-    if (uVar3 < 9) goto LAB_10;

-    *(undefined1 *)(in_RAX + 0x18) = unaff_RDI[8];

-    if (uVar3 < 10) goto LAB_11;

-    *(undefined1 *)(in_RAX + 0x19) = unaff_RDI[9];

-    if (uVar3 < 0xb) goto LAB_12;

-    *(undefined1 *)(in_RAX + 0x1a) = unaff_RDI[10];

-    if (uVar3 < 0xc) goto LAB_13;

-    *(undefined1 *)(in_RAX + 0x1b) = unaff_RDI[0xb];

-    if (uVar3 < 0xd) goto LAB_14;

-    *(undefined1 *)(in_RAX + 0x1c) = unaff_RDI[0xc];

-    if (uVar3 < 0xe) goto LAB_15;

-    *(undefined1 *)(in_RAX + 0x1d) = unaff_RDI[0xd];

-    if (uVar3 < 0xf) goto LAB_16;

-    *(undefined1 *)(in_RAX + 0x1e) = unaff_RDI[0xe];

-    if (uVar3 < 0x10) goto LAB_17;

-    uVar2 = unaff_RDI[0xf];

-  }

-  *(undefined1 *)(in_RAX + 0x1f) = uVar2;

-  if ((unaff_R14D & 7) != 0) {

-    *(char *)((ulonglong)uVar3 + (longlong)puVar1) =

-         -1 << (8U - (char)(unaff_R14D & 7) & 0x1f) & unaff_RDI[uVar3];

-  }

-LAB_2:

-  *in_stack_00000040 = (short)unaff_R14D + unaff_R15W;

-  return;

+  *(undefined8 *)(puVar24 + -8) = 0x14014ec46;

+  return uVar11;

 }
```

## `AleRedirectRecordsDeserializeFromBuffer`  (modified)

```diff
--- AleRedirectRecordsDeserializeFromBuffer
+++ AleRedirectRecordsDeserializeFromBuffer
@@ -1,30 +1,168 @@
 

-void AleRedirectRecordsDeserializeFromBuffer(void)

+longlong AleRedirectRecordsDeserializeFromBuffer

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

 

 {

-  undefined8 uVar1;

-  uint in_EAX;

-  uint uVar2;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

+  ushort uVar1;

+  ulonglong uVar2;

+  undefined4 uVar3;

+  undefined4 uVar4;

+  ulonglong *puVar5;

+  undefined2 *puVar6;

+  ulonglong *puVar7;

+  uint uVar8;

+  longlong lVar9;

+  ulonglong *puVar10;

+  ulonglong *puVar11;

+  ulonglong *puVar12;

+  ulonglong *puVar13;

+  ulonglong *puVar14;

+  ulonglong uVar15;

+  ulonglong local_res8;

+  ulonglong *local_res10;

+  ulonglong *local_res18;

+  ulonglong local_res20;

+  undefined2 *local_58 [3];

   

-  if ((in_EAX & 0x10) == 0) {

-    uVar2 = Feature_TCPIP_2025_2512_KCSAN_Fix__private_IsEnabledDeviceUsageNoInline();

+  local_res8 = 0;

+  puVar13 = &local_res8;

+  puVar14 = (ulonglong *)0x0;

+  local_res10 = (ulonglong *)0x0;

+  local_58[0] = (undefined2 *)0x0;

+  local_res18 = param_3;

+  if (param_2 < 8) {

+LAB_0:

+    lVar9 = WfpReportSysErrorAsNtStatus();

+    if (lVar9 == 0) {

+      return 0;

+    }

   }

   else {

-    uVar2 = in_EAX & 1;

+    uVar2 = *param_1;

+    param_1 = param_1 + 1;

+    puVar12 = (ulonglong *)(param_2 - 8);

+    if ((Feature_1204007226__private_featureState & 0x10) == 0) {

+      uVar8 = Feature_1204007226__private_IsEnabledDeviceUsageNoInline();

+    }

+    else {

+      uVar8 = Feature_1204007226__private_featureState & 1;

+    }

+    if (uVar8 != 0) {

+      lVar9 = WfpSizeTMultiply(uVar2,0x228,&local_res10);

+      if (lVar9 != 0) goto LAB_1;

+      if ((uVar2 != 0) && (local_res10 <= puVar12)) goto LAB_2;

+      goto LAB_0;

+    }

+    if ((uVar2 == 0) || (puVar12 < (ulonglong *)(uVar2 * 0x228))) goto LAB_0;

+LAB_2:

+    local_res20 = 0;

+    if (uVar2 != 0) {

+      do {

+        local_res10 = (ulonglong *)0x0;

+        if ((Feature_1204007226__private_featureState & 0x10) == 0) {

+          uVar8 = Feature_1204007226__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          uVar8 = Feature_1204007226__private_featureState & 1;

+        }

+        if ((uVar8 != 0) && (puVar12 < (ulonglong *)0x228)) goto LAB_0;

+        lVar9 = WfpPoolAllocNonPaged(0x228,0x6c637241,&local_res10);

+        puVar5 = local_res10;

+        if (lVar9 != 0) goto LAB_3;

+        lVar9 = 4;

+        *puVar13 = (ulonglong)local_res10;

+        puVar13 = param_1;

+        puVar7 = puVar5;

+        do {

+          puVar11 = puVar7;

+          puVar10 = puVar13;

+          uVar15 = puVar10[1];

+          *puVar11 = *puVar10;

+          puVar11[1] = uVar15;

+          uVar15 = puVar10[3];

+          puVar11[2] = puVar10[2];

+          puVar11[3] = uVar15;

+          uVar15 = puVar10[5];

+          puVar11[4] = puVar10[4];

+          puVar11[5] = uVar15;

+          uVar15 = puVar10[7];

+          puVar11[6] = puVar10[6];

+          puVar11[7] = uVar15;

+          uVar15 = puVar10[9];

+          puVar11[8] = puVar10[8];

+          puVar11[9] = uVar15;

+          uVar15 = puVar10[0xb];

+          puVar11[10] = puVar10[10];

+          puVar11[0xb] = uVar15;

+          uVar15 = puVar10[0xd];

+          puVar11[0xc] = puVar10[0xc];

+          puVar11[0xd] = uVar15;

+          uVar15 = puVar10[0xf];

+          puVar11[0xe] = puVar10[0xe];

+          puVar11[0xf] = uVar15;

+          lVar9 = lVar9 + -1;

+          puVar13 = puVar10 + 0x10;

+          puVar7 = puVar11 + 0x10;

+        } while (lVar9 != 0);

+        uVar3 = *(undefined4 *)((longlong)puVar10 + 0x84);

+        uVar15 = puVar10[0x11];

+        uVar4 = *(undefined4 *)((longlong)puVar10 + 0x8c);

+        param_1 = param_1 + 0x45;

+        puVar12 = puVar12 + -0x45;

+        *(int *)(puVar11 + 0x10) = (int)puVar10[0x10];

+        *(undefined4 *)((longlong)puVar11 + 0x84) = uVar3;

+        *(int *)(puVar11 + 0x11) = (int)uVar15;

+        *(undefined4 *)((longlong)puVar11 + 0x8c) = uVar4;

+        uVar3 = *(undefined4 *)((longlong)puVar10 + 0x94);

+        uVar15 = puVar10[0x13];

+        uVar4 = *(undefined4 *)((longlong)puVar10 + 0x9c);

+        *(int *)(puVar11 + 0x12) = (int)puVar10[0x12];

+        *(undefined4 *)((longlong)puVar11 + 0x94) = uVar3;

+        *(int *)(puVar11 + 0x13) = (int)uVar15;

+        *(undefined4 *)((longlong)puVar11 + 0x9c) = uVar4;

+        puVar11[0x14] = puVar10[0x14];

+        *(undefined4 *)(puVar5 + 0x3e) = 1;

+        puVar13 = (ulonglong *)puVar5[0x3d];

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

+          if (puVar12 < puVar13) goto LAB_0;

+          lVar9 = WfpPoolAllocNonPaged(puVar13,0x6c637241,puVar5 + 0x3c);

+          if (lVar9 != 0) goto LAB_3;

+          memmove((void *)puVar5[0x3c],param_1,puVar5[0x3d]);

+          param_1 = (ulonglong *)((longlong)param_1 + puVar5[0x3d]);

+          puVar12 = (ulonglong *)((longlong)puVar12 - puVar5[0x3d]);

+        }

+        puVar13 = puVar5 + 6;

+        if (local_res20 == uVar2 - 1) {

+          puVar14 = puVar5;

+        }

+        local_res20 = local_res20 + 1;

+      } while (local_res20 < uVar2);

+    }

+    if (puVar12 < (ulonglong *)0x4) goto LAB_0;

+    uVar1 = *(ushort *)((longlong)param_1 + 2);

+    uVar15 = (ulonglong)uVar1;

+    uVar2 = *param_1;

+    if ((longlong)puVar12 - 4U < uVar15) goto LAB_0;

+    lVar9 = WfpPoolAllocNonPaged(uVar15 + 0x10,0x6c637241,local_58);

+    puVar6 = local_58[0];

+    if (lVar9 == 0) {

+      *local_58[0] = (short)uVar2;

+      local_58[0][1] = uVar1;

+      *(undefined2 **)(local_58[0] + 4) = local_58[0] + 8;

+      memmove(local_58[0] + 8,(undefined2 *)((longlong)param_1 + 4),uVar15);

+      puVar14[7] = (ulonglong)puVar6;

+      *local_res18 = local_res8;

+      return 0;

+    }

   }

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

-  if (uVar2 == 0) {

-    *(byte *)(unaff_RBX + 0x28) = *(byte *)(unaff_RBX + 0x28) & 0xdf;

+LAB_3:

+  if (local_res8 != 0) {

+    AleRedirectRecordDereference();

   }

-  else {

-    *(undefined4 *)(unaff_RBP + 0x40) = *(undefined4 *)(unaff_RBX + 0x28);

-    *(byte *)(unaff_RBP + 0x40) = *(byte *)(unaff_RBP + 0x40) & 0xdf;

-    *(undefined4 *)(unaff_RBX + 0x28) = *(undefined4 *)(unaff_RBP + 0x40);

+LAB_1:

+  if (lVar9 != 0) {

+    WfpReportError(lVar9,"AleRedirectRecordsDeserializeFromBuffer");

   }

-  IppDereferenceRoute(uVar1);

-  KeReleaseInStackQueuedSpinLock(unaff_RBP + -0x20);

-  return;

+  return lVar9;

 }
```

## `AleInspectConnectRequest`  (modified)

```diff
--- AleInspectConnectRequest
+++ AleInspectConnectRequest
@@ -1,16 +1,442 @@
 

-void AleInspectConnectRequest(longlong param_1)

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

+

+ulonglong AleInspectConnectRequest

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

+                    undefined *param_5,uint param_6,longlong param_7,short *param_8,ushort *param_9,

+                    undefined8 *param_10,undefined1 *param_11,undefined8 param_12)

 

 {

-  byte in_AL;

-  undefined4 unaff_ESI;

-  undefined8 unaff_RDI;

-  longlong in_R10;

+  short sVar1;

+  undefined4 uVar2;

+  undefined4 uVar3;

+  undefined4 uVar4;

+  code *pcVar5;

+  ushort uVar6;

+  int iVar7;

+  uint uVar8;

+  ulonglong uVar9;

+  longlong lVar10;

+  code **ppcVar11;

+  code **ppcVar12;

+  uint uVar13;

+  code **ppcVar14;

+  code **ppcVar15;

+  size_t sVar16;

+  undefined *puVar17;

+  char cVar18;

+  ulonglong uVar19;

+  undefined4 extraout_XMM0_Da;

+  undefined1 auStack_928 [32];

+  code **local_908;

+  ulonglong *local_900;

+  undefined8 local_8f8;

+  undefined8 local_8f0;

+  undefined8 local_8e8;

+  longlong local_8e0;

+  char *local_8d8;

+  undefined8 local_8d0;

+  char local_8c8 [4];

+  uint local_8c4;

+  undefined *local_8c0;

+  undefined8 local_8b8;

+  undefined1 *puStack_8b0;

+  undefined8 local_8a8;

+  undefined8 local_8a0;

+  undefined8 local_898;

+  undefined8 *local_890;

+  undefined1 *local_888;

+  undefined8 local_880;

+  undefined8 uStack_878;

+  undefined8 local_870;

+  longlong lStack_868;

+  undefined8 local_860;

+  undefined8 uStack_858;

+  undefined8 local_850;

+  longlong lStack_848;

+  undefined8 local_840;

+  undefined8 uStack_838;

+  code *local_828;

+  code *local_820;

+  code *local_818;

+  code *local_810;

+  code *local_808;

+  code *local_800;

+  code *local_7f8;

+  code *local_7f0;

+  code *local_7e8;

+  undefined1 local_7e0;

+  undefined1 local_7df;

+  char local_7de;

+  undefined8 local_7d8;

+  undefined1 *local_7d0;

+  char local_7c8;

+  code **local_7c0;

+  longlong local_7b8;

+  code *local_7a8 [16];

+  undefined1 local_728 [128];

+  undefined8 local_6a8;

+  undefined4 local_6a0;

+  undefined8 local_688;

+  undefined8 local_680;

+  undefined8 local_678;

+  undefined1 local_658;

+  undefined2 local_657;

+  undefined1 local_655;

+  longlong local_650;

+  undefined8 local_648;

+  undefined8 local_640;

+  undefined *local_638;

+  undefined1 local_628 [128];

+  undefined1 local_5a8 [144];

+  ulonglong local_518 [6];

+  undefined1 local_4e8 [624];

+  undefined8 ******local_278;

+  undefined8 ******local_270;

+  undefined4 local_238 [2];

+  undefined8 *local_230;

+  undefined4 local_228;

+  undefined8 *local_220;

+  undefined4 local_218;

+  short *local_210;

+  undefined4 local_208;

+  undefined8 local_200;

+  undefined4 local_1f8;

+  ulonglong local_1f0;

+  undefined4 local_1e8;

+  ulonglong local_1e0;

+  undefined4 local_1d8;

+  ushort *local_1d0;

+  undefined4 local_1c8;

+  undefined8 local_1c0;

+  undefined4 local_1b8;

+  ulonglong local_1b0;

+  undefined4 local_1a8;

+  ulonglong local_1a0;

+  undefined4 local_198;

+  undefined8 *local_190;

+  undefined4 local_188;

+  undefined *local_180;

+  undefined4 local_178;

+  undefined8 *local_170;

+  undefined4 local_168;

+  ulonglong local_160;

+  undefined4 local_158;

+  undefined8 *local_150;

+  undefined1 local_148 [240];

+  ulonglong local_58;

   

-  *(byte *)(param_1 + -0x78) = *(byte *)(param_1 + -0x78) | in_AL;

-  *(undefined4 *)(in_R10 + 0x1c) = unaff_ESI;

-  *(undefined8 *)(in_R10 + 0x28) = unaff_RDI;

-  NetioInsertWorkQueue();

-  return;

+  local_58 = __security_cookie ^ (ulonglong)auStack_928;

+  local_8c0 = param_5;

+  local_890 = param_10;

+  local_888 = param_11;

+  uVar9 = 0;

+  local_898 = param_12;

+  local_880 = 0;

+  uStack_878 = 0;

+  local_870 = 0;

+  lStack_868 = 0;

+  local_860 = 0;

+  uStack_858 = 0;

+  local_840 = 0;

+  uStack_838 = 0;

+  local_850 = 0;

+  lStack_848 = 0;

+  local_8a8 = param_3;

+  local_8a0 = param_4;

+  memset(local_238,0,0xf0);

+  memset(local_148,0,0xf0);

+  local_657 = 0;

+  local_655 = 0;

+  local_8c8[0] = '\0';

+  local_518[0] = (ulonglong)(uint)local_518[0];

+  uVar6 = (*param_9 != 2) + 0x42;

+  local_8c4 = (uint)uVar6;

+  local_8b8 = 0;

+  puStack_8b0 = (undefined1 *)0x0;

+  iVar7 = KfdIsLayerEmpty(uVar6);

+  if (iVar7 != 0) {

+    return 0;

+  }

+  memset(local_4e8,0,0x2a8);

+  local_270 = &local_278;

+  local_278 = &local_278;

+  memset(&local_658,0,0x140);

+  memset(local_7a8,0,0x148);

+  memset(&local_828,0,0x78);

+  sVar1 = *(short *)(param_1 + 0x3c);

+  local_518[4] = 0;

+  local_518[0] = 0;

+  local_518[1] = 0;

+  local_518[2] = 0;

+  local_518[3] = 0;

+  uVar8 = 0x1c;

+  if (sVar1 != 0x17) {

+    uVar8 = 0x10;

+  }

+  memmove(local_7a8,param_8,(ulonglong)uVar8);

+  sVar16 = 0x1c;

+  if (sVar1 != 0x17) {

+    sVar16 = 0x10;

+  }

+  memmove(local_728,param_9,sVar16);

+  sVar16 = 0x1c;

+  if (sVar1 != 0x17) {

+    sVar16 = 0x10;

+  }

+  memmove(local_628,param_8,sVar16);

+  sVar16 = 0x1c;

+  if (sVar1 != 0x17) {

+    sVar16 = 0x10;

+  }

+  memmove(local_5a8,param_9,sVar16);

+  if (((*(uint *)(param_1 + 0x30) >> 9 & 1) == 0) &&

+     (uVar9 = InitializeEndpointContextFromParentContext(param_1), uVar8 = 0, uVar9 != 0))

+  goto LAB_0;

+  local_648 = local_8a8;

+  local_640 = local_8a0;

+  local_638 = local_8c0;

+  if (param_2 == 0) {

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

+      LOCK();

+      UNLOCK();

+      local_7b8 = gAleConnectRedirectConnectionCorrelationId + 1;

+      gAleConnectRedirectConnectionCorrelationId = gAleConnectRedirectConnectionCorrelationId + 1;

+    }

+    else {

+      local_7b8 = *(longlong *)(*(longlong *)(param_1 + 0x1c0) + 0x220);

+    }

+  }

+  else {

+    local_7b8 = *(longlong *)(param_2 + 0x220);

+  }

+  uVar13 = *(uint *)(param_1 + 0x30) & 0x10;

+  if (((*(uint *)(param_1 + 0x34) >> 0x10 & 1) != 0) || (param_2 != 0)) {

+    uVar13 = uVar13 | 0x200000;

+  }

+  lVar10 = *(longlong *)(param_1 + 0x1e8);

+  uStack_878 = *(undefined8 *)(*(longlong *)(param_1 + 0x1e0) + 0x10);

+  lStack_868 = lVar10 + 0xe0;

+  local_880 = CONCAT44(local_880._4_4_,(uint)*(ushort *)(*(longlong *)(param_1 + 0x1e0) + 10));

+  local_870 = CONCAT44(local_870._4_4_,*(undefined4 *)(lVar10 + 0x48));

+  local_8c0 = &gAleNullSid;

+  if (*(undefined **)(lVar10 + 0x118) != (undefined *)0x0) {

+    local_8c0 = *(undefined **)(lVar10 + 0x118);

+  }

+  local_850 = CONCAT44(local_850._4_4_,*(undefined4 *)(lVar10 + 0x48));

+  lStack_848 = lStack_868;

+  local_650 = param_1;

+  if ((*(longlong *)(lVar10 + 0x90) != 0) &&

+     (uVar9 = WfpAleMarshalFqbnValue

+                        (*(undefined8 *)(*(longlong *)(*(longlong *)(lVar10 + 0x90) + 8) + 0x20),

+                         &local_840), uVar8 = 0, uVar9 != 0)) goto LAB_0;

+  local_200 = 1;

+  local_218 = 0;

+  local_230 = &local_880;

+  local_220 = &local_870;

+  local_210 = param_8 + 4;

+  local_238[0] = 0x25;

+  local_228 = 0x26;

+  if (*param_8 != 0x17) {

+    local_210 = param_8 + 2;

+  }

+  local_208 = 7;

+  local_1d8 = 1;

+  if ((param_6 == 1) || (param_6 == 0x3a)) {

+    local_1f0 = (ulonglong)*(byte *)(param_7 + 4);

+    local_1f8 = 5;

+  }

+  else {

+    local_1f8 = 3;

+    local_1f0 = (ulonglong)(ushort)param_8[1];

+  }

+  uVar19 = (ulonglong)*param_9;

+  local_1e0 = (ulonglong)(param_6 & 0xff);

+  local_1d0 = param_9 + 4;

+  local_1e8 = 2;

+  if (*param_9 != 0x17) {

+    local_1d0 = param_9 + 2;

+  }

+  local_1c8 = 8;

+  if ((param_6 == 1) || (param_6 == 0x3a)) {

+    local_1b0 = (ulonglong)*(byte *)(param_7 + 5);

+    local_1b8 = 6;

+  }

+  else {

+    local_1b8 = 4;

+    local_1b0 = (ulonglong)param_9[1];

+  }

+  local_1a0 = (ulonglong)uVar13;

+  local_1a8 = 0x23;

+  local_198 = 0x25;

+  lVar10 = param_2;

+  puVar17 = local_8c0;

+  local_1c0 = local_200;

+  if (((param_2 == 0) &&

+      (lVar10 = *(longlong *)(param_1 + 0x1c0), *(longlong *)(param_1 + 0x1c0) == 0)) ||

+     (lVar10 = AleGetOriginalAppId(lVar10), lVar10 == 0)) {

+    local_190 = (undefined8 *)0x0;

+  }

+  else {

+    uStack_858 = *(undefined8 *)(lVar10 + 8);

+    local_860 = CONCAT44(local_860._4_4_,(uint)*(ushort *)(lVar10 + 2));

+    local_190 = &local_860;

+  }

+  local_170 = &local_840;

+  local_160 = (ulonglong)*(uint *)(param_1 + 0x264);

+  local_150 = &local_850;

+  local_188 = 0x2c;

+  local_178 = 0x2d;

+  local_168 = 0x2f;

+  local_158 = 0x30;

+  local_180 = puVar17;

+  WfpMarshalIncomingValues(uVar19 & 0xffff,local_238,0xf,local_148);

+  puStack_8b0 = local_148;

+  local_8b8 = CONCAT62(local_8b8._2_6_,(short)local_8c4);

+  local_8b8 = CONCAT44(0xf,(undefined4)local_8b8);

+  AlepSetConnectRedirectLayerMetadata(param_1,param_2,param_7,local_4e8);

+  local_828 = AlepDuplicateConnectRequestInspectContext;

+  local_7e0 = 1;

+  local_820 = AlepReleaseConnectRequestInspectContext;

+  local_818 = AlepDuplicateConnectRedirectLayerData;

+  local_810 = AlepReleseConnectRedirectLayerData;

+  local_7f8 = AlepAllocateCloneConnectRedirectLayerData;

+  local_7f0 = AlepFreeCloneConnectRedirectLayerData;

+  local_808 = AleInspectConnectRequestComplete;

+  local_7e8 = AleInspectSetLayerDataModifierFlags;

+  local_7d0 = &local_658;

+  local_800 = AlePostProcessClassify;

+  ppcVar14 = local_7a8;

+  cVar18 = local_8c8[0];

+  do {

+    local_900 = local_518;

+    local_908 = &local_828;

+    uVar8 = KfdClassify((undefined2)local_8c4,&local_8b8,local_4e8,ppcVar14);

+    ppcVar15 = local_7c0;

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

+    if (local_7c8 != '\0') goto LAB_2;

+    if (local_7c0 == (code **)0x0) break;

+    AlepValidateConnectRedirectLayerData();

+    lVar10 = 2;

+    ppcVar14 = local_7a8;

+    do {

+      ppcVar12 = ppcVar14;

+      ppcVar11 = local_7c0;

+      pcVar5 = ppcVar11[1];

+      *ppcVar12 = *ppcVar11;

+      ppcVar12[1] = pcVar5;

+      pcVar5 = ppcVar11[3];

+      ppcVar12[2] = ppcVar11[2];

+      ppcVar12[3] = pcVar5;

+      pcVar5 = ppcVar11[5];

+      ppcVar12[4] = ppcVar11[4];

+      ppcVar12[5] = pcVar5;

+      pcVar5 = ppcVar11[7];

+      ppcVar12[6] = ppcVar11[6];

+      ppcVar12[7] = pcVar5;

+      pcVar5 = ppcVar11[9];

+      ppcVar12[8] = ppcVar11[8];

+      ppcVar12[9] = pcVar5;

+      pcVar5 = ppcVar11[0xb];

+      ppcVar12[10] = ppcVar11[10];

+      ppcVar12[0xb] = pcVar5;

+      pcVar5 = ppcVar11[0xd];

+      ppcVar12[0xc] = ppcVar11[0xc];

+      ppcVar12[0xd] = pcVar5;

+      pcVar5 = ppcVar11[0xf];

+      ppcVar12[0xe] = ppcVar11[0xe];

+      ppcVar12[0xf] = pcVar5;

+      lVar10 = lVar10 + -1;

+      local_7c0 = ppcVar11 + 0x10;

+      ppcVar14 = ppcVar12 + 0x10;

+    } while (lVar10 != 0);

+    pcVar5 = ppcVar11[0x11];

+    cVar18 = '\x01';

+    ppcVar12[0x10] = ppcVar11[0x10];

+    ppcVar12[0x11] = pcVar5;

+    pcVar5 = ppcVar11[0x13];

+    ppcVar12[0x12] = ppcVar11[0x12];

+    ppcVar12[0x13] = pcVar5;

+    uVar2 = *(undefined4 *)((longlong)ppcVar11 + 0xa4);

+    uVar3 = *(undefined4 *)(ppcVar11 + 0x15);

+    uVar4 = *(undefined4 *)((longlong)ppcVar11 + 0xac);

+    *(undefined4 *)(ppcVar12 + 0x14) = *(undefined4 *)(ppcVar11 + 0x14);

+    *(undefined4 *)((longlong)ppcVar12 + 0xa4) = uVar2;

+    *(undefined4 *)(ppcVar12 + 0x15) = uVar3;

+    *(undefined4 *)((longlong)ppcVar12 + 0xac) = uVar4;

+    local_7c0 = (code **)0x0;

+    ppcVar12[0x16] = ppcVar11[0x16];

+    local_7df = 1;

+    *(uint *)(puStack_8b0 + 0x98) = *(uint *)(puStack_8b0 + 0x98) | 4;

+    ppcVar14 = ppcVar15;

+  } while (ppcVar15 != (code **)0x0);

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

+LAB_1:

+    ppcVar15 = ppcVar14;

+    if (cVar18 != '\0') goto LAB_3;

+  }

+  else {

+    local_908 = local_7a8;

+    uVar8 = AleInspectConnectRequestProcessLocalAddressRedirection

+                      (&local_828,&local_8b8,local_4e8,ppcVar14);

+    ppcVar15 = local_7c0;

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

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

+LAB_2:

+      uVar8 = 0x103;

+      goto LAB_0;

+    }

+    if (local_7c0 == (code **)0x0) goto LAB_1;

+    local_7c0 = (code **)0x0;

+    cVar18 = '\x01';

+LAB_3:

+    AlepCleanupModifiedConnectRedirectLayerData(ppcVar15);

+  }

+  if ((-1 < (int)uVar8) && (cVar18 != '\0')) {

+    local_8c8[0] = '\0';

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

+      AleInspectAdjustModifiedLayerDataLocalAddress(local_7a8,local_7a8);

+    }

+    local_8d0 = local_898;

+    local_8d8 = local_8c8;

+    local_8e0 = local_7b8;

+    local_8e8 = local_678;

+    local_8f0 = local_680;

+    local_8f8 = local_688;

+    local_900 = (ulonglong *)CONCAT44(local_900._4_4_,local_6a0);

+    local_908 = local_7a8;

+    uVar8 = AlepCreateRedirectRecord(param_1,param_9,local_728,param_8);

+    if (uVar8 == 0) {

+      LOCK();

+      *(uint *)(param_1 + 0x34) = *(uint *)(param_1 + 0x34) | 0x2000;

+      UNLOCK();

+      if (local_8c8[0] != '\0') {

+        sVar16 = 0x1c;

+        if (*param_9 != 0x17) {

+          sVar16 = 0x10;

+        }

+        memmove(param_8,local_7a8,sVar16);

+      }

+      uVar13 = 0x1c;

+      if (*param_9 != 0x17) {

+        uVar13 = 0x10;

+      }

+      memmove(param_9,local_728,(ulonglong)uVar13);

+      *local_890 = local_6a8;

+      *local_888 = 1;

+    }

+    else {

+      uVar9 = WfpReportSysErrorAsNtStatus(extraout_XMM0_Da,"AlepCreateRedirectRecord",uVar8);

+    }

+  }

+LAB_0:

+  WfpAleFreeMarshaledFqbnValue(&local_840);

+  uVar19 = uVar9 & 0xffffffff;

+  if (uVar9 == 0) {

+    uVar19 = (ulonglong)uVar8;

+  }

+  AlepCleanupModifiedConnectRedirectLayerData(local_7c0);

+  FeReleaseCalloutContextList(local_7d8);

+  return uVar19;

 }
```

## `Ipv6pHandleNeighborSolicitation`  (modified)

```diff
--- Ipv6pHandleNeighborSolicitation
+++ Ipv6pHandleNeighborSolicitation
@@ -1,35 +1,219 @@
 

-/* WARNING: Instruction at (ram,0x00014006010a) overlaps instruction at (ram,0x000140060108)

-    */

-

-bool Ipv6pHandleNeighborSolicitation(longlong param_1,int param_2,uint param_3)

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

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

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

+

+void Ipv6pHandleNeighborSolicitation(longlong param_1,longlong param_2)

 

 {

-  bool bVar1;

-  char in_AL;

-  undefined7 in_register_00000001;

-  uint uVar2;

-  longlong unaff_RBX;

-  undefined8 *unaff_RSI;

-  undefined4 *unaff_RDI;

+  undefined4 *puVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  undefined1 auVar5 [16];

+  undefined4 uVar6;

+  undefined4 uVar7;

+  char cVar8;

+  int iVar9;

+  uint uVar10;

+  longlong lVar11;

+  longlong lVar12;

+  longlong lVar13;

+  undefined1 *puVar14;

+  undefined4 uVar15;

+  ulonglong uVar16;

+  undefined8 uVar17;

+  undefined1 auStack_e8 [8];

+  undefined1 auStack_e0 [24];

+  longlong *local_c8;

+  undefined1 *local_c0;

+  undefined4 local_b8;

+  undefined4 local_b0;

+  undefined4 local_a8 [2];

+  longlong local_a0;

+  char *local_98;

+  longlong local_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined8 local_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined1 local_58 [32];

+  ulonglong local_38;

   

-  param_1 = param_1 + -1;

-  if (param_1 != 0) {

-    *(char *)CONCAT71(in_register_00000001,in_AL) =

-         *(char *)CONCAT71(in_register_00000001,in_AL) + in_AL;

-    *(char *)CONCAT71(in_register_00000001,in_AL) =

-         *(char *)CONCAT71(in_register_00000001,in_AL) + (char)param_1;

-  }

-  uVar2 = (uint)param_1;

-  uVar2 = (param_2 + uVar2 ^ uVar2) & param_3 ^ uVar2;

-  *(uint *)(unaff_RBX + 0xa0) = uVar2;

-  bVar1 = 0x8000000 < (uVar2 & param_3);

-  if (bVar1) {

-    *unaff_RDI = 0x3ae;

+  puVar14 = auStack_e8;

+  local_38 = __security_cookie ^ (ulonglong)auStack_e8;

+  puVar1 = *(undefined4 **)(param_2 + 0x18);

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

+  lVar13 = *(longlong *)(param_2 + 0xe0);

+  local_a8[0] = 0;

+  lVar2 = *(longlong *)(*(longlong *)(param_2 + 0xd8) + 8);

+  plVar3 = (longlong *)**(longlong **)(*(longlong *)(param_2 + 0xd8) + 0x10);

+  local_60 = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  cVar8 = *(char *)(*(longlong *)(lVar2 + 0x30) + 2);

+  local_a0 = 0;

+  local_90 = param_1;

+  if (((*(byte *)(param_2 + 0xb8) & 8) == 0) && ((*(byte *)(param_2 + 0xbb) & 1) == 0)) {

+    if (*(char *)(*(longlong *)(param_2 + 0x118) + 7) == -1) {

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

+        if (*(uint *)(lVar12 + 0x18) < 0x18) {

+          local_b0 = 0xe00041cb;

+          iVar9 = 0xf;

+        }

+        else {

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

+          lVar11 = NdisGetDataBuffer(lVar12,0x18,&local_70);

+          local_98 = (char *)(lVar11 + 8);

+          if (*local_98 == -1) {

+            local_b0 = 0xe00041cc;

+LAB_0:

+            iVar9 = 0x20;

+          }

+          else {

+            NetioAdvanceNetBuffer(lVar12,0x18);

+            if (((*(uint *)(*(longlong *)(lVar2 + 0x30) + 0x1c) & 0x210) == 0x10) && (cVar8 != '\0')

+               ) {

+              uVar17 = 1;

+            }

+            else {

+              uVar17 = 0;

+            }

+            local_c0 = local_58;

+            local_c8 = &local_a0;

+            iVar9 = NetioPhGetNdLinkLayerOptionAddress(lVar12,1,uVar17,cVar8);

+            NetioRetreatNetBuffer(lVar12,0x18);

+            if (((iVar9 + 0x80000000U & 0x80000000) == 0) && (iVar9 != -0x3ffffddb)) {

+              local_b0 = 0xe00041cd;

+              iVar9 = 0x1b;

+            }

+            else {

+              cVar8 = IN6_IS_ADDR_UNSPECIFIED(puVar1);

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

+                if (((*plVar3 != 0x2ff) || ((int)plVar3[1] != 0x1000000)) ||

+                   (*(char *)((longlong)plVar3 + 0xc) != -1)) {

+                  local_b0 = 0xe00041ce;

+                  goto LAB_0;

+                }

+                if (local_a0 != 0) {

+                  local_b0 = 0xe00041cf;

+                  iVar9 = 0x15;

+                  goto LAB_1;

+                }

+              }

+              local_c8 = (longlong *)local_a8;

+              lVar12 = IppHandleNeighborSolicitation(lVar13,local_a0,puVar1,local_98);

+              if (lVar12 != 0) {

+                if ((*(int *)(lVar12 + 0x18) == 1) ||

+                   (lVar11 = ExAllocatePool2(0x40,0x48,0x61613649), lVar11 == 0)) {

+                  Ipv6pSendNeighborAdvertisement(lVar13,0,puVar1,lVar12);

+                }

+                else {

+                  *(longlong *)(lVar11 + 0x28) = lVar13;

+                  local_88 = 0;

+                  uStack_80 = 0;

+                  local_78 = 0;

+                  LOCK();

+                  plVar3 = (longlong *)(lVar13 + 0x40);

+                  lVar13 = *plVar3;

+                  *plVar3 = *plVar3 + 1;

+                  UNLOCK();

+                  puVar14 = auStack_e8;

+                  if (lVar13 + 1 < 2) {

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

+                    (*pcVar4)(0xe);

+                    puVar14 = auStack_e0;

+                  }

+                  *(longlong *)(lVar11 + 0x30) = lVar12;

+                  uVar17 = *(undefined8 *)(lVar12 + 0x20);

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

+                  CarAcquireCacheAwareReference(uVar17,1);

+                  uVar15 = puVar1[1];

+                  uVar6 = puVar1[2];

+                  uVar7 = puVar1[3];

+                  *(undefined4 *)(lVar11 + 0x38) = *puVar1;

+                  *(undefined4 *)(lVar11 + 0x3c) = uVar15;

+                  *(undefined4 *)(lVar11 + 0x40) = uVar6;

+                  *(undefined4 *)(lVar11 + 0x44) = uVar7;

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

+                  TtInitializeTimer(lVar11);

+                  uVar16 = _DAT_2 / 10000;

+                  auVar5._8_8_ = 0;

+                  auVar5._0_8_ = uVar16;

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

+                  if ((Feature_3999242553__private_featureState & 0x10) == 0) {

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

+                    uVar10 = Feature_3999242553__private_IsEnabledDeviceUsageNoInline();

+                  }

+                  else {

+                    uVar10 = Feature_3999242553__private_featureState & 1;

+                  }

+                  if (uVar10 != 0) {

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

+                    RtlAcquireWriteLockAtDpcLevel(lVar2 + 0x178,&local_88);

+                  }

+                  IppRandomValue = IppRandomValue * 0x19660d + 0x3c6ef35f;

+                  LOCK();

+                  UNLOCK();

+                  uVar17 = *(undefined8 *)(lVar2 + 0x2c8);

+                  uVar15 = (undefined4)((uVar16 - lVar13 >> 1) + lVar13 >> 8);

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

+                  iVar9 = TtStartTimerEx(uVar17,lVar11,uVar15,1);

+                  if (iVar9 != 0) {

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

+                    IppTimerUpdateNextExpirationTick(uVar15,iVar9);

+                  }

+                  if ((Feature_3999242553__private_featureState & 0x10) == 0) {

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

+                    uVar10 = Feature_3999242553__private_IsEnabledDeviceUsageNoInline();

+                  }

+                  else {

+                    uVar10 = Feature_3999242553__private_featureState & 1;

+                  }

+                  if (uVar10 != 0) {

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

+                    KeReleaseInStackQueuedSpinLockFromDpcLevel(&local_88);

+                  }

+                }

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

+                IppDereferenceLocalAddress(lVar12);

+                *(undefined4 *)(*(longlong *)(param_2 + 8) + 0x8c) = 0;

+                goto LAB_3;

+              }

+              iVar9 = IppPktMonToIcmpDropReason(local_a8[0]);

+              local_b0 = 0xe00041d0;

+              puVar14 = auStack_e8;

+              if (iVar9 == 0x2c) goto LAB_3;

+            }

+          }

+        }

+      }

+      else {

+        local_b0 = 0xe00041ca;

+        iVar9 = 0x12;

+      }

+    }

+    else {

+      local_b0 = 0xe00041c9;

+      iVar9 = 0x11;

+    }

   }

   else {

-    *unaff_RSI = CONCAT71(in_register_00000001,in_AL);

+    local_b0 = 0xe0004244;

+    iVar9 = 0x2a;

   }

-  return !bVar1;

+LAB_1:

+  local_b8 = 8;

+  *(undefined4 *)(*(longlong *)(param_2 + 8) + 0x8c) = 0xc000021b;

+  local_c8 = (longlong *)CONCAT44(local_c8._4_4_,*(undefined4 *)(*(longlong *)(param_2 + 8) + 0x8c))

+  ;

+  local_c0 = (undefined1 *)param_2;

+  LogIcmpReceiveDrop(&Ipv6Global,0x87,*(undefined1 *)(local_90 + 1),iVar9);

+  puVar14 = auStack_e8;

+LAB_3:

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

+  return;

 }
```

## `InetWakeAcquirePortAf`  (modified)

```diff
--- InetWakeAcquirePortAf
+++ InetWakeAcquirePortAf
@@ -1,35 +1,182 @@
 

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

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

 

-undefined8 InetWakeAcquirePortAf(longlong param_1,undefined8 param_2,undefined4 param_3)

+ulonglong InetWakeAcquirePortAf

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

 

 {

-  longlong lVar1;

+  longlong *plVar1;

   code *pcVar2;

-  int iVar3;

-  undefined8 in_RAX;

-  longlong in_R11;

-  undefined8 uStack0000000000000030;

-  undefined8 uStack0000000000000038;

-  undefined4 uStack0000000000000044;

+  char cVar3;

+  uint uVar4;

+  uint uVar5;

+  int iVar6;

+  longlong lVar7;

+  longlong *plVar8;

+  ulonglong uVar9;

+  undefined4 uVar10;

+  undefined1 auStack_178 [32];

+  undefined4 local_158;

+  undefined1 *local_150;

+  undefined4 local_148;

+  undefined4 local_140;

+  undefined1 local_138;

+  longlong local_130;

+  undefined1 local_128 [36];

+  ushort local_104;

+  undefined4 local_100;

+  undefined4 local_60;

+  undefined4 local_58;

+  ulonglong local_48;

   

-  uStack0000000000000044 = 0;

-  uStack0000000000000030 = 0;

-  uStack0000000000000038 = 0;

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

-  lVar1 = *(longlong *)(param_1 + 0x30);

-  *(undefined8 *)(in_R11 + -0x30) = param_2;

-  *(undefined4 *)(in_R11 + -0x18) = param_3;

-  pcVar2 = *(code **)(lVar1 + 200);

-  if (pcVar2 == IpNlpReferenceInterface) {

-    iVar3 = IpNlpReferenceInterface();

+  local_48 = __security_cookie ^ (ulonglong)auStack_178;

+  uVar10 = 0;

+  uVar5 = 0;

+  local_130 = param_2;

+  local_138 = KeAcquireSpinLockRaiseToDpc(param_4);

+  lVar7 = InetWakeLookupPort(param_1,param_2,param_3,param_4);

+  if (lVar7 == 0) {

+    plVar8 = (longlong *)ExAllocatePool2(0x40,0x30,0x50576e49);

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

+      uVar5 = 0xc0000017;

+    }

+    else {

+      *(undefined4 *)(plVar8 + 2) = 1;

+      if ((Feature_3131548987__private_featureState & 0x10) == 0) {

+        uVar4 = Feature_3131548987__private_IsEnabledDeviceUsageNoInline();

+      }

+      else {

+        uVar4 = Feature_3131548987__private_featureState & 1;

+      }

+      if (uVar4 != 0) {

+        *(undefined4 *)((longlong)plVar8 + 0x14) = 0;

+      }

+      plVar1 = (longlong *)(param_4 + 0x10);

+      *(ushort *)((longlong)plVar8 + 0x1c) = param_1;

+      plVar8[4] = param_2;

+      plVar8[5] = (longlong)param_3;

+      lVar7 = *plVar1;

+      if (*(longlong **)(lVar7 + 8) != plVar1) goto LAB_0;

+      *plVar8 = lVar7;

+      plVar8[1] = (longlong)plVar1;

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

+      *plVar1 = (longlong)plVar8;

+      cVar3 = IsPortWithinRange(param_1,param_4 + 0x20);

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

+        if ((Feature_3131548987__private_featureState & 0x10) == 0) {

+          uVar5 = Feature_3131548987__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          uVar5 = Feature_3131548987__private_featureState & 1;

+        }

+        if (uVar5 == 0) {

+          *(int *)(plVar8 + 2) = (int)plVar8[2] + 1;

+        }

+        else {

+          *(undefined4 *)((longlong)plVar8 + 0x14) = 1;

+        }

+        KeReleaseSpinLock(param_4);

+        memset(local_128,0,0xd8);

+        local_100 = *(undefined4 *)(param_4 + 8);

+        local_150 = local_128;

+        local_148 = 0xd8;

+        local_158 = 0;

+        local_60 = 3;

+        local_104 = param_1;

+        uVar5 = InetSetInterfacePropertyAf(param_2,param_3,0,0x12);

+        local_138 = KeAcquireSpinLockRaiseToDpc(param_4);

+        if ((Feature_3131548987__private_featureState & 0x10) == 0) {

+          uVar4 = Feature_3131548987__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          uVar4 = Feature_3131548987__private_featureState & 1;

+        }

+        if (uVar4 == 0) {

+          iVar6 = (int)plVar8[2] + -1;

+          *(int *)(plVar8 + 2) = iVar6;

+          if (iVar6 != 0) goto LAB_1;

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

+            KeReleaseSpinLock(param_4);

+            local_150 = local_128;

+            local_148 = 0xd8;

+            local_158 = 0;

+            InetSetInterfacePropertyAf(param_2,param_3,0,0x13);

+            lVar7 = *plVar8;

+            if ((*(longlong **)(lVar7 + 8) != plVar8) ||

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

+            *plVar1 = lVar7;

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

+            goto LAB_2;

+          }

+        }

+        else {

+          *(undefined4 *)((longlong)plVar8 + 0x14) = 0;

+          if ((int)plVar8[2] == 0) {

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

+              KeReleaseSpinLock(param_4);

+              local_150 = local_128;

+              local_148 = 0xd8;

+              local_158 = 0;

+              InetSetInterfacePropertyAf(param_2,param_3,0,0x13);

+LAB_2:

+              ExFreePoolWithTag(plVar8,0);

+              goto LAB_3;

+            }

+          }

+          else {

+LAB_1:

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

+              *(undefined4 *)(plVar8 + 3) = local_58;

+              goto LAB_4;

+            }

+          }

+        }

+        if ((Feature_3131548987__private_featureState & 0x10) == 0) {

+          uVar4 = Feature_3131548987__private_IsEnabledDeviceUsageNoInline();

+        }

+        else {

+          uVar4 = Feature_3131548987__private_featureState & 1;

+        }

+        if (uVar4 == 0) {

+          lVar7 = *plVar8;

+          if ((*(longlong **)(lVar7 + 8) != plVar8) ||

+             (plVar1 = (longlong *)plVar8[1], (longlong *)*plVar1 != plVar8)) {

+LAB_0:

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

+            (*pcVar2)(3);

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

+            uVar9 = (*pcVar2)();

+            return uVar9;

+          }

+          *plVar1 = lVar7;

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

+        }

+        else {

+          InetWakeRemovePortEntryIfPresent(plVar8);

+        }

+        ExFreePoolWithTag(plVar8,0);

+      }

+    }

   }

   else {

-    iVar3 = (*pcVar2)(in_R11 + -0x38);

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

   }

-  if (iVar3 < 0) {

-    uStack0000000000000038 = 0;

+LAB_4:

+  KeReleaseSpinLock(param_4,local_138);

+LAB_3:

+  if ((Microsoft_Windows_TCPIPEnableBits & 8) != 0) {

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

+      local_140 = 0;

+    }

+    else {

+      uVar10 = *(undefined4 *)(param_3 + 1);

+      local_140 = *(undefined4 *)*param_3;

+    }

+    local_150 = (undefined1 *)CONCAT44(local_150._4_4_,(uint)*(ushort *)(local_130 + 0x18));

+    local_158 = CONCAT22(local_158._2_2_,param_1 >> 8 | param_1 << 8);

+    local_148 = uVar10;

+    McTemplateK0qhqqq_EtwWriteTransfer();

   }

-  return uStack0000000000000038;

+  return (ulonglong)uVar5;

 }
```

## `UdpConnectRedirect`  (modified)

```diff
--- UdpConnectRedirect
+++ UdpConnectRedirect
@@ -1,38 +1,183 @@
 

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

 

-undefined8 UdpConnectRedirect(undefined8 param_1,undefined8 param_2,undefined8 param_3)

+ulonglong UdpConnectRedirect(longlong param_1,longlong param_2)

 

 {

-  byte *pbVar1;

-  byte bVar2;

-  int iVar3;

-  longlong in_RAX;

-  ulonglong in_RCX;

-  longlong unaff_RBX;

-  int *unaff_RBP;

-  uint *unaff_RDI;

-  byte unaff_R12B;

-  int unaff_R13D;

-  undefined8 in_XMM0_Qb;

+  longlong lVar1;

+  short sVar2;

+  short *_Src;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  code *pcVar5;

+  longlong *plVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  longlong lVar9;

+  undefined1 *puVar10;

+  undefined1 *puVar11;

+  longlong *plVar12;

+  size_t _Size;

+  undefined8 uStack_f0;

+  undefined1 auStack_e8 [8];

+  undefined1 auStack_e0 [24];

+  undefined2 local_c8 [4];

+  undefined8 uStack_c0;

+  uint local_b8 [2];

+  longlong local_b0 [5];

+  undefined1 local_88 [8];

+  longlong *local_80;

+  undefined8 local_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  longlong local_58 [4];

   

-  *(char *)((longlong)unaff_RBP + 0x33) = *(char *)((longlong)unaff_RBP + 0x33) + (char)in_RAX;

-  pbVar1 = (byte *)(in_RAX + 0x7c + in_RCX * 4);

-  *pbVar1 = *pbVar1 << 4 | *pbVar1 >> 4;

-  *(byte *)(in_RAX + -0x75) = *(byte *)(in_RAX + -0x75) ^ (byte)in_RCX;

-  bVar2 = (byte)in_RCX & 0x1f;

-  *unaff_RDI = *unaff_RDI >> bVar2 | *unaff_RDI << 0x20 - bVar2;

-  *unaff_RBP = *unaff_RBP + (int)in_RAX + (uint)((in_RCX & 0x1f) != 0 && (int)*unaff_RDI < 0);

-  *(undefined8 *)(unaff_RBP + -4) = param_1;

-  *(undefined8 *)(unaff_RBP + -2) = in_XMM0_Qb;

-  *unaff_RBP = unaff_R13D;

-  iVar3 = IppUpdateUnicastRoute(unaff_R13D);

-  if ((((iVar3 < 0) && ((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

-      (2 < (byte)WPP_GLOBAL_Control[0x29])) &&

-     ((unaff_R12B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0)) {

-    WPP_SF_D_IPV6_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x12,param_3,

-                    *(undefined4 *)(unaff_RBX + 8));

+  puVar11 = auStack_e8;

+  puVar10 = auStack_e8;

+  local_58[2] = __security_cookie ^ (ulonglong)auStack_e8;

+  if ((Feature_TCPIP_Stack_Var_To_Heap_Fix__private_featureState & 0x10) == 0) {

+    uVar7 = Feature_TCPIP_Stack_Var_To_Heap_Fix__private_IsEnabledDeviceUsageNoInline();

   }

-  return 0;

+  else {

+    uVar7 = Feature_TCPIP_Stack_Var_To_Heap_Fix__private_featureState & 1;

+  }

+  if (uVar7 == 0) {

+    uVar8 = UdpConnectRedirectObsolete(param_1,param_2);

+    puVar10 = auStack_e8;

+    goto LAB_0;

+  }

+  _Src = *(short **)(param_1 + 0x20);

+  local_78 = 0;

+  local_88[0] = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_60 = 0;

+  local_80 = (longlong *)0x0;

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

+    uVar7 = UdpSetDestinationEndpoint(param_2,_Src,1);

+    uVar8 = (ulonglong)uVar7;

+    goto LAB_0;

+  }

+  uVar7 = CreateUdpConnectRedirectCallbackContext(&local_80,param_1,param_2);

+  uVar8 = (ulonglong)uVar7;

+  puVar10 = auStack_e8;

+  plVar12 = local_80;

+  if (uVar7 == 0) {

+    if (((*(uint *)(param_2 + 0x18) & 0x20) == 0) || (*_Src != 0x17)) {

+      _Size = 0x1c;

+      if (*_Src != 0x17) {

+        _Size = 0x10;

+      }

+      memmove(local_80 + 0x15,_Src,_Size);

+    }

+    else {

+      if (((((_Src[4] != 0) || (_Src[5] != 0)) || (_Src[6] != 0)) ||

+          ((_Src[7] != 0 || (_Src[8] != 0)))) || (_Src[9] != -1)) {

+        uVar8 = 0xc0000207;

+        puVar10 = auStack_e8;

+        goto LAB_1;

+      }

+      sVar2 = _Src[1];

+      *(undefined4 *)((longlong)local_80 + 0xac) = *(undefined4 *)(_Src + 10);

+      *(undefined2 *)(local_80 + 0x15) = 2;

+      *(short *)((longlong)local_80 + 0xaa) = sVar2;

+      local_80[0x16] = 0;

+    }

+    KeAcquireInStackQueuedSpinLock(param_2,&local_70);

+    do {

+    } while (*(int *)(param_2 + 8) != 0);

+    uVar3 = *(undefined8 *)(param_2 + 0x48);

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

+      *(short *)(local_80 + 5) = (short)local_80[0x15];

+      *(undefined2 *)((longlong)local_80 + 0x2a) = *(undefined2 *)(param_2 + 0xa8);

+    }

+    else {

+      puVar4 = *(undefined8 **)(*(longlong *)(param_2 + 0x68) + 0x10);

+      local_c8[0] = *(undefined2 *)(param_2 + 0xa8);

+      INETADDR_SETSOCKADDR

+                (*(undefined2 *)(*(longlong *)(param_2 + 0x70) + 0x18),local_80 + 5,*puVar4,

+                 *(undefined4 *)(puVar4 + 1));

+    }

+    KeReleaseInStackQueuedSpinLock(&local_70);

+    lVar9 = 1;

+    LOCK();

+    plVar12 = (longlong *)(param_2 + 0x10);

+    lVar1 = *plVar12;

+    *plVar12 = *plVar12 + 1;

+    UNLOCK();

+    if (lVar1 + 1 < 2) {

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

+      (*pcVar5)(0xe);

+      puVar11 = auStack_e0;

+    }

+    LOCK();

+    lVar1 = *local_80;

+    *local_80 = *local_80 + lVar9;

+    UNLOCK();

+    if (lVar1 + 1 < 2) {

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

+      (*pcVar5)(0xe);

+      puVar11 = puVar11 + 8;

+    }

+    plVar12 = local_80;

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

+    *(undefined1 **)(puVar11 + 0x50) = local_88;

+    *(undefined8 **)(puVar11 + 0x48) = &local_78;

+    *(longlong **)(puVar11 + 0x40) = plVar12 + 0x15;

+    *(longlong **)(puVar11 + 0x38) = plVar12 + 5;

+    *(undefined8 *)(puVar11 + 0x30) = 0;

+    *(undefined4 *)(puVar11 + 0x28) = 0x11;

+    *(longlong **)(puVar11 + 0x20) = plVar12;

+    *(undefined8 *)(puVar11 + -8) = 0x14013df8f;

+    uVar7 = AleInspectConnectRequest(uVar3,0,0,UdpConnectRedirectCallback);

+    uVar8 = (ulonglong)uVar7;

+    if ((DAT_2 != 0) && ((DAT_1402336ec & 8) != 0)) {

+      *(uint *)(puVar11 + 0x38) = uVar7;

+      local_58[1] = 0;

+      *(uint *)(puVar11 + 0x30) = ~uVar7 >> 0x1f;

+      *(undefined4 *)(puVar11 + 0x28) = 0xf;

+      *(undefined8 *)(puVar11 + 0x20) = uVar3;

+      *(undefined8 *)(puVar11 + -8) = 0x14013dfdf;

+      local_58[0] = param_2;

+      McTemplateK0ppqqq_EtwWriteTransfer

+                (&MICROSOFT_TCPIP_PROVIDER_Context,&INET_INSPECT,local_58,param_2);

+    }

+    puVar10 = puVar11;

+    if (uVar7 != 0x103) {

+      *(undefined8 *)(puVar11 + 0x28) = local_78;

+      *(longlong **)(puVar11 + 0x20) = plVar12 + 0x15;

+      *(undefined8 *)(puVar11 + -8) = 0x14013e013;

+      UdpConnectRedirectCallback(plVar12,uVar8,local_88[0],plVar12 + 5);

+      uVar8 = 0x103;

+    }

+  }

+LAB_1:

+  plVar6 = local_80;

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

+    LOCK();

+    lVar1 = *plVar12;

+    *plVar12 = *plVar12 + -1;

+    UNLOCK();

+    if (lVar1 < 2) {

+      if (lVar1 == 1) {

+        lVar1 = local_80[3];

+        if (lVar1 != 0) {

+          *(undefined8 *)(puVar10 + -8) = 0x14013e036;

+          ExFreePoolWithTag(lVar1,0x74727543);

+        }

+        *(undefined8 *)(puVar10 + -8) = 0x14013e04a;

+        ExFreePoolWithTag(plVar6,0x74727543);

+      }

+      else {

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

+        (*pcVar5)(0xe);

+        puVar10 = puVar10 + 8;

+      }

+    }

+  }

+LAB_0:

+  *(undefined8 *)(puVar10 + -8) = 0x14013e07f;

+  return uVar8;

 }
```

## `RawBindEndpointInspectComplete`  (modified)

```diff
--- RawBindEndpointInspectComplete
+++ RawBindEndpointInspectComplete
@@ -1,10 +1,135 @@
 

-undefined4 RawBindEndpointInspectComplete(void)

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

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

+

+void RawBindEndpointInspectComplete(longlong param_1,uint param_2)

 

 {

-  undefined4 unaff_EBX;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  char cVar5;

+  undefined1 uVar6;

+  undefined1 uVar7;

+  longlong *plVar8;

+  longlong *plVar9;

+  undefined2 uVar10;

+  int unaff_ESI;

+  int unaff_R12D;

+  ushort unaff_R13W;

+  undefined8 auStack_a8 [4];

+  undefined4 uStack_88;

+  undefined1 uStack_60;

+  longlong *plStack_40;

+  undefined8 uStack_38;

+  undefined8 uStack_30;

+  ulonglong local_28;

   

-  KeLeaveCriticalRegion();

-  return unaff_EBX;

+  local_28 = __security_cookie ^ (ulonglong)auStack_a8;

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

+  plVar9 = (longlong *)(ulonglong)param_2;

+  KeAcquireInStackQueuedSpinLock(plVar8,&stack0xffffffffffffffa8);

+  do {

+  } while ((int)plVar8[1] != 0);

+  if ((int)param_2 < 0) {

+    if ((*(uint *)(plVar8 + 3) & 1) != 0) {

+      uStack_30 = 0;

+      plStack_40 = (longlong *)0x0;

+      uStack_38 = 0;

+      *(uint *)(plVar8 + 3) = *(uint *)(plVar8 + 3) & 0xfffffffe;

+      RtlAcquireWriteLockAtDpcLevel(&RawEndpointMrswLock,&plStack_40);

+      plVar1 = plVar8 + 4;

+      lVar2 = *plVar1;

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

+         (plVar3 = (longlong *)plVar8[5], (longlong *)*plVar3 != plVar1)) {

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

+        (*pcVar4)(3);

+LAB_0:

+        auStack_a8[0] = 0x1401c83cb;

+        uVar6 = KfRaiseIrql(unaff_R13W & 0xff);

+        auStack_a8[0] = 0x1401c83dc;

+        uVar7 = SOCKADDR_SIZE(*(undefined2 *)((longlong)plVar9 + 0x34));

+        auStack_a8[0] = 0x1401c8405;

+        TcpRecentFailureTrace(uVar7,(longlong)plVar9 + 0x34,0,0);

+        auStack_a8[0] = 0x1401c8410;

+        KeLowerIrql(uVar6);

+        do {

+          auStack_a8[0] = 0x140058164;

+          TcpBindEndpointRequestInspectComplete(plVar9,unaff_ESI,uStack_60,(longlong)plVar9 + 0x34);

+          do {

+            plVar9 = plVar8;

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

+              return;

+            }

+            uStack_60 = (undefined1)unaff_R12D;

+            plVar8 = (longlong *)*plVar9;

+            lVar2 = plVar9[1];

+            auStack_a8[0] = 0x1400580d8;

+            KeWaitForSingleObject(lVar2 + 0x100,0,0,0);

+            if (*(short *)((longlong)plVar9 + 0x34) == 0x17) {

+              auStack_a8[0] = 0x1400581a2;

+              cVar5 = IN6_IS_ADDR_V4MAPPED((longlong)plVar9 + 0x3c);

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

+                *(int *)(plVar9 + 7) = (int)plVar9[9];

+                *(ushort *)((longlong)plVar9 + 0x34) = unaff_R13W;

+                *(undefined2 *)((longlong)plVar9 + 0x36) = *(undefined2 *)((longlong)plVar9 + 0x36);

+                *(undefined8 *)((longlong)plVar9 + 0x3c) = 0;

+                *(byte *)((longlong)plVar9 + 0x32) = *(byte *)((longlong)plVar9 + 0x32) | 1;

+              }

+            }

+            auStack_a8[0] = 0x140058116;

+            unaff_ESI = AleInspectBindRequest(*(undefined8 *)(lVar2 + 0x50));

+            if (DAT_1 != unaff_R12D) {

+              if ((DAT_2 & 8) != 0) {

+                auStack_a8[0] = 0x14005820b;

+                McTemplateK0ppqqq_EtwWriteTransfer(&MICROSOFT_TCPIP_PROVIDER_Context);

+              }

+            }

+            if (unaff_ESI < 0) goto LAB_0;

+          } while (unaff_ESI == 0x103);

+        } while( true );

+      }

+      *plVar3 = lVar2;

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

+      KeReleaseInStackQueuedSpinLockFromDpcLevel(&plStack_40);

+    }

+    *(uint *)(plVar8 + 3) = *(uint *)(plVar8 + 3) & 0xffffffef;

+    plVar8[0xf] = plVar8[7];

+    plVar8[0xe] = 0;

+    *(undefined2 *)(plVar8 + 0xd) = 0;

+  }

+  else {

+    *(longlong *)(param_1 + 0x28) = plVar8[7];

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

+    if ((DAT_1 != 0) && ((Microsoft_Windows_TCPIPEnableBits & 8) != 0)) {

+      if ((*(uint *)(plVar8 + 3) & 0x10) == 0) {

+        uVar10 = *(undefined2 *)(plVar8[7] + 0x18);

+      }

+      else {

+        uVar10 = 0x17;

+      }

+      uStack_38 = 0;

+      plStack_40 = plVar8;

+      InetFormatLocalSockAddrAtDispatchLevel

+                (plVar8[7],(*(uint *)(plVar8 + 3) & 0x10) != 0,plVar8[0xe],0);

+      SOCKADDR_SIZE(uVar10);

+      uStack_88 = (undefined4)plVar8[8];

+      McTemplateK0pqqbr2qq_EtwWriteTransfer

+                (&MICROSOFT_TCPIP_PROVIDER_Context,&RAW_BIND_ENDPOINT_COMPLETE,&plStack_40,plVar8);

+    }

+  }

+  KeReleaseInStackQueuedSpinLock(&stack0xffffffffffffffa8);

+  KeReleaseSemaphore(plVar8 + 0x1c,0,1);

+  (**(code **)(param_1 + 0x10))(*(undefined8 *)(param_1 + 0x18),plVar9,0);

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

+    InetDereferenceLocalAddressAf(*(undefined8 *)(param_1 + 0x28));

+  }

+  if ((*(longlong *)(param_1 + 0x28) != 0) && (*(longlong *)(param_1 + 0x28) != plVar8[7])) {

+    _InetDereferenceAf();

+  }

+  RawDereferenceEndpoint(*(undefined8 *)(param_1 + 8));

+  ExFreePoolWithTag(param_1,0x57456152);

+  return;

 }
```

## `UdpSetDestinationEndpoint`  (modified)

```diff
--- UdpSetDestinationEndpoint
+++ UdpConnectRedirectObsolete
@@ -1,59 +1,119 @@
 

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

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

 

-void UdpSetDestinationEndpoint(void)

+int UdpConnectRedirectObsolete(longlong param_1,longlong param_2)

 

 {

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  int unaff_ESI;

-  int unaff_R12D;

-  undefined8 *unaff_R13;

-  uint unaff_R14D;

-  undefined8 unaff_R15;

-  byte in_stack_00000060;

+  longlong *plVar1;

+  longlong lVar2;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  code *pcVar5;

+  uint uVar6;

+  char cVar7;

+  int iVar8;

+  short *psVar9;

+  short *_Src;

+  undefined1 *puVar10;

+  undefined1 auStack_1a8 [8];

+  undefined1 auStack_1a0 [24];

+  undefined2 local_188;

+  undefined1 local_158;

+  undefined8 local_150;

+  undefined8 local_148;

+  undefined8 local_140;

+  undefined8 uStack_138;

+  undefined8 local_130;

+  undefined2 local_128;

+  short local_126;

+  undefined4 local_124;

+  undefined8 local_120;

+  undefined2 local_a8;

+  undefined2 local_a6;

+  ulonglong local_28;

   

-  TcpTraceConnectionEstablishment();

-  KeAcquireSpinLockAtDpcLevel();

-  *(uint *)(unaff_RBX + 0x328) =

-       ((uint)in_stack_00000060 << 8 ^ *(uint *)(unaff_RBX + 0x328)) & unaff_R14D ^

-       *(uint *)(unaff_RBX + 0x328);

-  KeReleaseSpinLockFromDpcLevel();

-  (*(code *)*unaff_R13)(unaff_R13[1],unaff_ESI);

-  if ((*(ushort *)(unaff_RBX + 0x80) & 0x600) != 0) {

-    if (((DAT_0 != 0) &&

-        ((TcpipTraceFiltersExist == '\0' || (*(char *)(unaff_RBX + 0x324) < '\0')))) &&

-       ((DAT_1 & 0x40) != 0)) {

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

-      *(longlong *)(unaff_RBP + 0x18) = unaff_RBX;

-      McTemplateK0pzqqp_EtwWriteTransfer(&MICROSOFT_TCPIP_PROVIDER_Context);

+  puVar10 = auStack_1a8;

+  local_28 = __security_cookie ^ (ulonglong)auStack_1a8;

+  memset(&local_a8,0,0x80);

+  local_148 = 0;

+  local_158 = 0;

+  memset(&local_128,0,0x80);

+  _Src = *(short **)(param_1 + 0x20);

+  local_150 = 0;

+  local_140 = 0;

+  uStack_138 = 0;

+  local_130 = 0;

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

+    iVar8 = UdpSetDestinationEndpoint(param_2,_Src,1);

+  }

+  else {

+    if (((*(uint *)(param_2 + 0x18) & 0x20) == 0) || (*_Src != 0x17)) {

+      uVar6 = 0x1c;

+      if (*_Src != 0x17) {

+        uVar6 = 0x10;

+      }

+      memmove(&local_128,_Src,(ulonglong)uVar6);

     }

-    (*(code *)unaff_R13[0x23])(unaff_R13[0x25],unaff_ESI,unaff_R13[0x2b]);

-    FUN_14002f6c0();

-    return;

+    else {

+      psVar9 = _Src + 4;

+      cVar7 = IN6_IS_ADDR_V4MAPPED();

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

+        iVar8 = -0x3ffffdf9;

+        puVar10 = auStack_1a8;

+        goto LAB_0;

+      }

+      local_124 = *(undefined4 *)(psVar9 + 6);

+      local_126 = _Src[1];

+      local_120 = 0;

+      local_128 = 2;

+    }

+    RtlAcquireWriteLock(param_2,&local_140);

+    puVar10 = auStack_1a8;

+    uVar3 = *(undefined8 *)(param_2 + 0x48);

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

+      local_a8 = local_128;

+      local_a6 = *(undefined2 *)(param_2 + 0xa8);

+    }

+    else {

+      puVar4 = *(undefined8 **)(*(longlong *)(param_2 + 0x68) + 0x10);

+      local_188 = *(undefined2 *)(param_2 + 0xa8);

+      INETADDR_SETSOCKADDR

+                (*(undefined2 *)(*(longlong *)(param_2 + 0x70) + 0x18),&local_a8,*puVar4,

+                 *(undefined4 *)(puVar4 + 1));

+    }

+    KeReleaseInStackQueuedSpinLock(&local_140);

+    iVar8 = CreateUdpConnectRedirectCallbackContext(&local_150,param_1,param_2);

+    if (iVar8 == 0) {

+      LOCK();

+      plVar1 = (longlong *)(param_2 + 0x10);

+      lVar2 = *plVar1;

+      *plVar1 = *plVar1 + 1;

+      UNLOCK();

+      puVar10 = auStack_1a8;

+      if (lVar2 + 1 < 2) {

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

+        (*pcVar5)(0xe);

+        puVar10 = auStack_1a0;

+      }

+      *(undefined1 **)(puVar10 + 0x48) = puVar10 + 0x50;

+      *(undefined1 **)(puVar10 + 0x40) = puVar10 + 0x60;

+      *(undefined2 **)(puVar10 + 0x30) = &local_128;

+      *(undefined2 **)(puVar10 + 0x28) = &local_a8;

+      *(undefined8 *)(puVar10 + 0x20) = uVar3;

+      *(undefined8 *)(puVar10 + -8) = 0x1401640ee;

+      iVar8 = InetInspectConnectRequest

+                        (param_2,UdpConnectRedirectCallback,*(undefined8 *)(puVar10 + 0x58),0x11);

+      if (iVar8 != 0x103) {

+        *(undefined8 *)(puVar10 + 0x28) = *(undefined8 *)(puVar10 + 0x60);

+        *(undefined2 **)(puVar10 + 0x20) = &local_128;

+        *(undefined8 *)(puVar10 + -8) = 0x140164121;

+        UdpConnectRedirectCallback(*(undefined8 *)(puVar10 + 0x58),iVar8,puVar10[0x50],&local_a8);

+        iVar8 = 0x103;

+      }

+    }

   }

-  ExFreePoolWithTag();

-  KeAcquireSpinLockAtDpcLevel();

-  if (-1 < unaff_R12D) {

-    *(uint *)(unaff_RBX + 0x7c) = *(uint *)(unaff_RBX + 0x7c) & 0xfffffffe;

-    TcpLeaveTcbDelivery();

-  }

-  if ((unaff_ESI < 0) && ((*(uint *)(unaff_RBX + 0x7c) & 2) == 0)) {

-    TcpShutdownTcb();

-    KeReleaseSpinLockFromDpcLevel();

-    if ((DAT_0 != 0) &&

-       (((TcpipTraceFiltersExist == '\0' || (*(char *)(unaff_RBX + 0x324) < '\0')) &&

-        ((DAT_2 & 4) != 0)))) {

-      *(undefined8 *)(unaff_RBP + 0x30) = unaff_R15;

-      *(longlong *)(unaff_RBP + 0x28) = unaff_RBX;

-      McTemplateK0pqq_EtwWriteTransfer

-                (&MICROSOFT_TCPIP_PROVIDER_Context,&TCP_CONNECT_TCB_FAILED_ACTIVE_CONNECT,

-                 unaff_RBP + 0x28);

-    }

-    TcpCloseTcb();

-    KeAcquireSpinLockAtDpcLevel();

-  }

-  return;

+LAB_0:

+  *(undefined8 *)(puVar10 + -8) = 0x140164143;

+  return iVar8;

 }
```

## `UdpConnectRedirectCallback`  (modified)

```diff
--- UdpConnectRedirectCallback
+++ UdpConnectRedirectCallback
@@ -1,36 +1,54 @@
 

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

 

-void UdpConnectRedirectCallback(undefined8 param_1,undefined8 param_2,char param_3)

+void UdpConnectRedirectCallback

+               (longlong param_1,ulonglong param_2,char param_3,undefined8 param_4,short *param_5)

 

 {

-  char *in_RAX;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  int unaff_ESI;

-  int unaff_R12D;

-  undefined8 unaff_R15;

+  uint uVar1;

+  char cVar2;

+  ulonglong uVar3;

+  short *psVar4;

+  short sVar5;

+  longlong lVar6;

+  undefined1 auStack_58 [32];

+  short local_38 [16];

+  ulonglong local_18;

   

-  *in_RAX = *in_RAX + param_3;

-  if (-1 < unaff_R12D) {

-    *(uint *)(unaff_RBX + 0x7c) = *(uint *)(unaff_RBX + 0x7c) & 0xfffffffe;

-    TcpLeaveTcbDelivery();

+  local_18 = __security_cookie ^ (ulonglong)auStack_58;

+  local_38[8] = 0;

+  local_38[9] = 0;

+  local_38[10] = 0;

+  local_38[0xb] = 0;

+  local_38[0xc] = 0;

+  local_38[0xd] = 0;

+  uVar3 = param_2 & 0xffffffff;

+  local_38[0] = 0;

+  local_38[1] = 0;

+  local_38[2] = 0;

+  local_38[3] = 0;

+  local_38[4] = 0;

+  local_38[5] = 0;

+  local_38[6] = 0;

+  local_38[7] = 0;

+  if ((-1 < (int)param_2) && (param_2 = uVar3, param_3 != '\0')) {

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

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

+      IN6ADDR_SETV4MAPPED(local_38,param_5 + 2,0,param_5[1]);

+      param_5 = local_38;

+    }

+    sVar5 = *param_5;

+    psVar4 = param_5;

+    cVar2 = INETADDR_ISEQUAL(lVar6);

+    if ((cVar2 == '\0') || (*(short *)(lVar6 + 2) != psVar4[1])) {

+      uVar1 = 0x1c;

+      if (sVar5 != 0x17) {

+        uVar1 = 0x10;

+      }

+      memmove(*(void **)(param_1 + 0x18),param_5,(ulonglong)uVar1);

+    }

   }

-  if ((unaff_ESI < 0) && ((*(uint *)(unaff_RBX + 0x7c) & 2) == 0)) {

-    TcpShutdownTcb();

-    KeReleaseSpinLockFromDpcLevel();

-    if ((DAT_0 != 0) &&

-       (((TcpipTraceFiltersExist == '\0' || (*(char *)(unaff_RBX + 0x324) < '\0')) &&

-        ((DAT_1 & 4) != 0)))) {

-      *(undefined8 *)(unaff_RBP + 0x30) = unaff_R15;

-      *(longlong *)(unaff_RBP + 0x28) = unaff_RBX;

-      McTemplateK0pqq_EtwWriteTransfer

-                (&MICROSOFT_TCPIP_PROVIDER_Context,&TCP_CONNECT_TCB_FAILED_ACTIVE_CONNECT,

-                 unaff_RBP + 0x28);

-    }

-    TcpCloseTcb();

-    KeAcquireSpinLockAtDpcLevel();

-  }

+  UdpConnectRedirectCallbackContinue(param_1,param_2);

   return;

 }
```

## `IppReassemblyInterfaceCleanup`  (modified)

```diff
--- IppReassemblyInterfaceCleanup
+++ IppReassemblyInterfaceCleanup
@@ -1,51 +1,46 @@
 

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

-

-void IppReassemblyInterfaceCleanup(char *param_1,undefined8 param_2,undefined4 param_3)

+void IppReassemblyInterfaceCleanup(longlong *param_1)

 

 {

-  int iVar1;

-  longlong lVar2;

-  longlong unaff_RBP;

-  undefined4 uStack0000000000000030;

-  undefined8 uStack0000000000000058;

-  undefined8 uStack0000000000000068;

+  longlong lVar1;

+  undefined1 uVar2;

+  longlong lVar3;

+  longlong lVar4;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

   

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

-  *(undefined8 *)(unaff_RBP + -0x61) = *(undefined8 *)(unaff_RBP + 0x57);

-  *(longlong *)(unaff_RBP + -0x51) = unaff_RBP + 0x5f;

-  uStack0000000000000030 = (undefined4)param_2;

-  uStack0000000000000058 = 4;

-  *(undefined8 *)(unaff_RBP + -0x79) = param_2;

-  *(undefined8 *)(unaff_RBP + -0x69) = param_2;

-  *(undefined8 *)(unaff_RBP + -0x59) = param_2;

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

-  if (param_1 == (char *)0x0) {

-    iVar1 = 5;

+  lVar1 = *(longlong *)(*param_1 + 0x28);

+  local_48 = 0;

+  uStack_40 = 0;

+  lVar4 = lVar1 + 0x5750;

+  local_38 = 0;

+  uStack_30 = 0;

+  local_28 = 0;

+  uVar2 = KeAcquireSpinLockRaiseToDpc(lVar4);

+  lVar1 = lVar1 + 0x5758;

+  RtlInitEnumerationHashTable(lVar1,&local_48);

+  while( true ) {

+    lVar3 = RtlEnumerateEntryHashTable(lVar1,&local_48);

+    if (lVar3 == 0) break;

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

+      IppRemoveReassembly(lVar4,lVar3);

+      KeAcquireSpinLockAtDpcLevel(lVar3 + 0x30);

+      if (*(int *)(lVar3 + 0x44) == 1) {

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

+        *(undefined4 *)(lVar3 + 0x44) = 2;

+        KeReleaseSpinLockFromDpcLevel();

+      }

+      else {

+        KeReleaseSpinLockFromDpcLevel(lVar3 + 0x30);

+        IppDeleteReassembly(lVar3);

+      }

+    }

   }

-  else {

-    lVar2 = -1;

-    do {

-      lVar2 = lVar2 + 1;

-    } while (param_1[lVar2] != (char)param_3);

-    iVar1 = (int)lVar2 + 1;

-  }

-  *(int *)(unaff_RBP + -0x39) = iVar1;

-  *(undefined4 *)(unaff_RBP + -0x35) = param_3;

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

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

-  if (param_1 == (char *)0x0) {

-    param_1 = "NULL";

-  }

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

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

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

-  *(undefined8 *)(unaff_RBP + -9) = 4;

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

-  uStack0000000000000068 = param_2;

-  McGenEventWrite_EtwWriteTransfer

-            (&MICROSOFT_TCPIP_PROVIDER_Context,&IP_SORTED_ADDRESS_PAIRS_V1,&MICROSOFT_TCPIP_PROVIDER

-             ,0xb,&stack0x00000040);

+  RtlEndEnumerationHashTable(lVar1,&local_48);

+  KeReleaseSpinLock(lVar4,uVar2);

   return;

 }
```

## `FlpDeleteGroupUnderLock`  (modified)

```diff
--- FlpDeleteGroupUnderLock
+++ FlpDeleteGroupUnderLock
@@ -1,134 +1,57 @@
 

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

-

-ulonglong FlpDeleteGroupUnderLock(undefined8 param_1,undefined8 param_2)

+void FlpDeleteGroupUnderLock(longlong param_1,longlong param_2)

 

 {

-  int iVar1;

-  ulonglong uVar2;

-  undefined8 in_RDX;

-  undefined8 *unaff_RBP;

-  undefined8 *puVar3;

-  undefined8 *puVar4;

-  int iVar5;

-  ulonglong unaff_R13;

-  char cVar6;

-  char cVar8;

-  undefined8 extraout_XMM0_Qa;

-  undefined8 extraout_XMM0_Qa_00;

-  undefined8 extraout_XMM0_Qa_01;

-  undefined8 extraout_XMM0_Qa_02;

-  undefined8 extraout_XMM0_Qa_03;

-  undefined8 uVar10;

-  undefined8 in_XMM0_Qb;

-  ulonglong in_XMM1_Qb;

-  undefined4 uVar12;

-  ulonglong uVar11;

-  undefined8 *puStack0000000000000038;

-  undefined8 *puStack0000000000000040;

-  undefined8 uStack0000000000000070;

-  char cVar7;

-  char cVar9;

+  short *psVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  uint uVar6;

   

-  unaff_RBP[-0xd] = L"NTLM";

-  iVar1 = (int)unaff_R13;

-  iVar5 = iVar1 + 2;

-  *(int *)((longlong)unaff_RBP + -0x4c) = iVar1 + 1;

-  *(int *)((longlong)unaff_RBP + -0x5c) = iVar1 + 1;

-  unaff_RBP[-9] = unaff_RBP + -0x10;

-  *(int *)(unaff_RBP + -10) = iVar1;

-  unaff_RBP[-0xb] = &stack0x00000070;

-  puStack0000000000000040 = (undefined8 *)&stack0x00000068;

-  *(int *)(unaff_RBP + -0xc) = iVar1;

-  puStack0000000000000038 = unaff_RBP + -3;

-  uVar2 = unaff_R13 & 0xffffffff;

-  cVar7 = (char)unaff_R13;

-  unaff_RBP[-0x10] = param_1;

-  unaff_RBP[-0xf] = in_XMM0_Qb;

-  puVar3 = (undefined8 *)(unaff_R13 & 0xffffffff);

-  unaff_RBP[-3] = param_1;

-  unaff_RBP[-2] = in_XMM0_Qb;

-  puVar4 = (undefined8 *)(unaff_R13 & 0xffffffff);

-  *(int *)((longlong)unaff_RBP + -0x7c) = iVar5;

-  unaff_RBP[-5] = param_2;

-  unaff_RBP[-4] = in_XMM1_Qb;

-  uStack0000000000000070 = CONCAT44(iVar5,(int)param_2);

-  unaff_RBP[-1] = param_1;

-  *unaff_RBP = in_XMM0_Qb;

-  unaff_RBP[-7] = param_2;

-  unaff_RBP[-6] = in_XMM1_Qb;

-  iVar5 = AcquireCredentialsHandleW(0,unaff_RBP + -0xe,iVar5,unaff_RBP + -8);

-  uVar10 = extraout_XMM0_Qa;

-  cVar9 = cVar7;

-  if (iVar5 == 0) {

-    puStack0000000000000040 = (undefined8 *)&stack0x00000068;

-    puStack0000000000000038 = unaff_RBP + -5;

-    cVar9 = '\x01';

-    cVar8 = '\x01';

-    uVar11 = unaff_R13;

-    iVar5 = AcquireCredentialsHandleW(0,unaff_RBP + -0xe,iVar1 + 1,0);

-    uVar10 = extraout_XMM0_Qa_00;

-    if (iVar5 == 0) {

-      cVar7 = '\x01';

-      cVar6 = '\x01';

-      do {

-        uVar12 = (undefined4)(uVar11 >> 0x20);

-        if (unaff_RBP[-0xf] != 0) {

-          FreeContextBuffer();

-          *(int *)(unaff_RBP + -0x10) = iVar1;

-          unaff_RBP[-0xf] = unaff_R13;

-        }

-        puStack0000000000000040 = unaff_RBP + -1;

-        puStack0000000000000038 = (undefined8 *)CONCAT44(puStack0000000000000038._4_4_,iVar1);

-        uVar10 = CONCAT44(uVar12,iVar1);

-        iVar5 = InitializeSecurityContextW(unaff_RBP + -3,puVar3,0,0x100,uVar10);

-        uVar12 = (undefined4)((ulonglong)uVar10 >> 0x20);

-        if ((iVar5 != 0) && (uVar10 = extraout_XMM0_Qa_01, iVar5 != 0x90312)) goto LAB_0;

-        puVar3 = unaff_RBP + -1;

-        if (in_XMM1_Qb != 0) {

-          FreeContextBuffer();

-          uStack0000000000000070 = CONCAT44(uStack0000000000000070._4_4_,iVar1);

-          in_XMM1_Qb = unaff_R13;

-        }

-        puStack0000000000000040 = (undefined8 *)&stack0x00000068;

-        puStack0000000000000038 = (undefined8 *)&stack0x00000060;

-        uVar11 = CONCAT44(uVar12,0x10);

-        iVar5 = AcceptSecurityContext(unaff_RBP + -5,puVar4,unaff_RBP + -10,0x100,uVar11);

-        uVar10 = extraout_XMM0_Qa_02;

-        if ((iVar5 != 0) && (iVar5 != 0x90312)) goto LAB_0;

-        puVar4 = unaff_RBP + -7;

-      } while (iVar5 == 0x90312);

-      if ((iVar5 == 0) &&

-         (iVar5 = QuerySecurityContextToken(unaff_RBP + -7,in_RDX), uVar10 = extraout_XMM0_Qa_03,

-         iVar5 == 0)) goto LAB_1;

+  if ((Feature_4005012793__private_featureState & 0x10) == 0) {

+    uVar6 = Feature_4005012793__private_IsEnabledDeviceUsageNoInline();

+  }

+  else {

+    uVar6 = Feature_4005012793__private_featureState & 1;

+  }

+  if (uVar6 == 0) {

+    psVar1 = (short *)(param_2 + 0x20);

+    *psVar1 = *psVar1 + -1;

+    if (*psVar1 != 0) {

+      return;

     }

   }

-LAB_0:

-  cVar8 = cVar9;

-  cVar6 = cVar7;

-  uVar2 = WfpReportSysErrorAsWinError(uVar10,"WfpAlepCreateTokenFromLogonId",iVar5);

-LAB_1:

-  if (in_XMM1_Qb != 0) {

-    FreeContextBuffer();

+  else {

+    LOCK();

+    plVar2 = (longlong *)(param_2 + 0x20);

+    lVar3 = *plVar2;

+    *plVar2 = *plVar2 + -1;

+    UNLOCK();

+    if (1 < lVar3) {

+      return;

+    }

+    if (lVar3 != 1) {

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

+      (*pcVar5)(0xe);

+      return;

+    }

   }

-  if (unaff_RBP[-0xf] != 0) {

-    FreeContextBuffer();

+  plVar2 = (longlong *)(param_2 + 0x10);

+  lVar3 = *plVar2;

+  if ((*(longlong **)(lVar3 + 8) == plVar2) &&

+     (plVar4 = *(longlong **)(param_2 + 0x18), (longlong *)*plVar4 == plVar2)) {

+    *plVar4 = lVar3;

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

+    *(int *)(param_1 + 0x148) = *(int *)(param_1 + 0x148) + -1;

+    FlpSerializedNdisRequestUnderLock(param_1,FlpSerializedNdisDeleteGroupWorker,0,0,0,0);

+    PplFreeToLookasideList(FlpGroupBlockPool,param_2);

+    return;

   }

-  if (puVar4 != (undefined8 *)0x0) {

-    DeleteSecurityContext(puVar4);

-  }

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

-    DeleteSecurityContext(puVar3);

-  }

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

-    FreeCredentialsHandle(unaff_RBP + -5);

-  }

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

-    FreeCredentialsHandle(unaff_RBP + -3);

-  }

-  if (uVar2 != 0) {

-    WfpReportError(uVar2,"WfpAlepCreateTokenFromLogonId");

-  }

-  return uVar2;

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

+  (*pcVar5)(3);

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

+  (*pcVar5)();

+  return;

 }
```

## `UdpConnectRedirectCallbackContinue`  (modified)

```diff
--- UdpConnectRedirectCallbackContinue
+++ UdpConnectRedirectCallbackContinue
@@ -1,10 +1,31 @@
 

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

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

 

-void UdpConnectRedirectCallbackContinue(void)

+void UdpConnectRedirectCallbackContinue(longlong param_1,int param_2)

 

 {

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

-  halt_baddata();

+  uint uVar1;

+  

+  if (-1 < param_2) {

+    param_2 = UdpSetDestinationEndpoint

+                        (*(undefined8 *)(param_1 + 0x20),*(undefined8 *)(param_1 + 0x18),1);

+  }

+  if (*(code **)(param_1 + 8) != (code *)0x0) {

+    (**(code **)(param_1 + 8))(*(undefined8 *)(param_1 + 0x10),param_2,0);

+  }

+  UdpDereferenceEndpoint(*(undefined8 *)(param_1 + 0x20));

+  if ((Feature_TCPIP_Stack_Var_To_Heap_Fix__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_TCPIP_Stack_Var_To_Heap_Fix__private_IsEnabledDeviceUsageNoInline();

+  }

+  else {

+    uVar1 = Feature_TCPIP_Stack_Var_To_Heap_Fix__private_featureState & 1;

+  }

+  if (uVar1 == 0) {

+    DestroyUdpConnectRedirectCallbackContext(param_1);

+  }

+  else {

+    ReleaseUdpConnectRedirectCallbackContext();

+  }

+  return;

 }
```

## `WfpAleStreamLayerChanged`  (modified)

```diff
--- WfpAleStreamLayerChanged
+++ WfpAleStreamLayerChanged
@@ -1,355 +1,200 @@
 

-void WfpAleStreamLayerChanged(undefined8 param_1)

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

+

+longlong ******* WfpAleStreamLayerChanged(short param_1)

 

 {

-  ulonglong uVar1;

-  byte bVar2;

-  ushort uVar3;

-  undefined4 uVar4;

-  int iVar5;

-  undefined4 uVar6;

-  undefined8 uVar7;

-  undefined8 uVar8;

-  uint *puVar9;

-  undefined8 *puVar10;

-  code *pcVar11;

-  longlong *plVar12;

-  short sVar13;

-  int in_EAX;

-  int iVar14;

-  longlong lVar15;

-  longlong lVar16;

-  uint uVar17;

-  uint uVar18;

-  ulonglong uVar19;

-  byte *unaff_RBX;

-  longlong *plVar20;

-  longlong *unaff_RBP;

-  longlong lVar21;

-  char cVar22;

-  undefined1 uVar23;

-  longlong unaff_RDI;

-  char cVar24;

-  ushort unaff_R12W;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  undefined2 uVar25;

-  undefined4 unaff_R15D;

-  ulonglong uVar26;

+  int iVar1;

+  longlong *******ppppppplVar2;

+  code *pcVar3;

+  uint *puVar4;

+  longlong lVar5;

+  char cVar6;

+  undefined1 uVar7;

+  int iVar8;

+  longlong lVar9;

+  longlong lVar10;

+  uint *puVar11;

+  uint uVar12;

+  longlong *******unaff_RBX;

+  longlong *******ppppppplVar14;

+  ulonglong uVar15;

+  longlong *******ppppppplVar16;

+  bool bVar17;

+  undefined4 extraout_XMM0_Da;

+  undefined4 uVar18;

+  longlong local_res10 [3];

+  longlong ******pppppplVar19;

+  undefined4 in_stack_fffffffffffffed0;

+  undefined2 uVar20;

+  longlong *******local_a8;

+  longlong *******local_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  longlong *******local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong uVar13;

   

-  lVar21 = *unaff_RBP;

-  plVar20 = unaff_RBP + 1;

-  plVar12 = unaff_RBP + 1;

-  if ((in_EAX == 0) || (plVar12 = unaff_RBP + 1, unaff_R12W != 0)) {

+  local_70 = 0;

+  local_88 = 0;

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

+  bVar17 = true;

+  local_a0 = (longlong *******)&local_a8;

+  local_68 = (longlong *******)0x0;

+  uStack_60 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_80 = 0;

+  uStack_78 = 0;

+  local_98 = 0;

+  uStack_90 = 0;

+  uVar15 = 0;

+  if (*endpointHandleTable != 0) {

+    do {

+      puVar4 = endpointHandleTable;

+      KeAcquireInStackQueuedSpinLock(endpointHandleTable + uVar15 * 0x60 + 0x10,&local_80);

+      if (-1 < (int)puVar4[uVar15 * 0x60 + 0x12]) {

+        puVar11 = puVar4 + uVar15 * 0x60 + 0x20;

+        uVar13 = 0;

+        do {

+          do {

+          } while (*puVar11 != 0);

+          uVar12 = (int)uVar13 + 1;

+          uVar13 = (ulonglong)uVar12;

+          puVar11 = puVar11 + 0x10;

+        } while ((int)uVar12 <= (int)puVar4[uVar15 * 0x60 + 0x12]);

+      }

+      ppppppplVar14 = (longlong *******)(endpointHandleTable + uVar15 * 0x60 + 0x60);

+      RtlInitEnumerationHashTable(ppppppplVar14,&uStack_60);

+      local_68 = ppppppplVar14;

+      while (unaff_RBX = local_68, lVar9 = RtlEnumerateEntryHashTable(local_68,&uStack_60),

+            lVar9 != 0) {

+        unaff_RBX = (longlong *******)(lVar9 + -0x200);

+        AleAcquireEndpointLockEx(unaff_RBX,&local_98,"WfpAleStreamLayerChanged");

+        if ((((*(int *)(lVar9 + -0x1d8) == 6) &&

+             (cVar6 = WfpAleCompareFlagVolatile(lVar9 + -0x1d0,0x10), cVar6 == '\0')) &&

+            (cVar6 = WfpAleCompareFlagVolatile(extraout_XMM0_Da,0x20), cVar6 != '\0')) &&

+           (((cVar6 = WfpAleCompareFlagVolatile(lVar9 + -0x1cc,0x100), cVar6 == '\0' &&

+             (*(short *)(lVar9 + -0x1c4) == param_1)) &&

+            (cVar6 = WfpAleReferenceEndpoint(unaff_RBX,0xf), cVar6 != '\0')))) {

+          ppppppplVar14 = (longlong *******)(lVar9 + 0x28);

+          if ((longlong ********)*local_a0 != &local_a8) goto LAB_0;

+          *(longlong ********)(lVar9 + 0x30) = local_a0;

+          *ppppppplVar14 = (longlong ******)&local_a8;

+          *local_a0 = (longlong ******)ppppppplVar14;

+          local_a0 = ppppppplVar14;

+        }

+        AleReleaseEndpointLock(unaff_RBX,&local_98);

+      }

+      RtlEndEnumerationHashTable(local_68,&uStack_60);

+      KeReleaseInStackQueuedSpinLock(&local_80);

+      uVar12 = (int)uVar15 + 1;

+      uVar15 = (ulonglong)uVar12;

+    } while (uVar12 < *endpointHandleTable);

+  }

+  while( true ) {

+    ppppppplVar14 = local_a8;

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

+      return (longlong *******)&local_a8;

+    }

+    ppppppplVar2 = (longlong *******)*local_a8;

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

+       ((longlong *******)ppppppplVar2[1] != local_a8)) break;

+    ppppppplVar2[1] = (longlong ******)&local_a8;

+    ppppppplVar16 = local_a8 + -0x45;

+    local_a8 = ppppppplVar2;

+    lVar9 = WfpAleOobAcquireStreamEndpoint(ppppppplVar16);

+    uVar20 = (undefined2)((uint)in_stack_fffffffffffffed0 >> 0x10);

+    if (lVar9 != 0) {

+      local_res10[1] = 0;

+      local_res10[0] = 0;

+      lVar10 = IppInspectAcquireNexthopInterface(*(undefined8 *)(lVar9 + 0x20),local_res10);

+      KfdAleAcquireFlowHandleForFlow(ppppppplVar16,0,local_res10 + 1);

+      lVar5 = local_res10[0];

+      pppppplVar19 = ppppppplVar14[-10];

+      in_stack_fffffffffffffed0 = CONCAT22(uVar20,*(undefined2 *)((longlong)ppppppplVar14 + -0x1ea))

+      ;

+      iVar8 = WfpAleReauthorizeConnection

+                        (ppppppplVar16,*(undefined2 *)((longlong)ppppppplVar14 + -0x1ec),0,0,

+                         pppppplVar19,in_stack_fffffffffffffed0,6,ppppppplVar14[-0x41],

+                         *(undefined2 *)(ppppppplVar14 + -0x3d));

+      uVar18 = (undefined4)((ulonglong)pppppplVar19 >> 0x20);

+      if (lVar10 != 0) {

+        iVar1 = *(int *)(lVar10 + 0x28);

+        IppDereferenceInterface(lVar10);

+        bVar17 = iVar1 != 0;

+      }

+      if (lVar5 != 0) {

+        IpNlpDereferenceNextHop(lVar5);

+      }

+      unaff_RBX = ppppppplVar14 + -0x3f;

+      if (iVar8 < 0) {

+        uVar12 = 0x800;

+        cVar6 = WfpAleCompareFlagVolatile(unaff_RBX);

+        uVar20 = (undefined2)((uint)in_stack_fffffffffffffed0 >> 0x10);

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

+          LOCK();

+          *(uint *)unaff_RBX = *(uint *)unaff_RBX | uVar12;

+          UNLOCK();

+          in_stack_fffffffffffffed0 = CONCAT22(uVar20,*(undefined2 *)(ppppppplVar14 + -0x3d));

+          AleRequestTcpConnectionAbort

+                    (*(undefined2 *)((longlong)ppppppplVar14 + -0x1ec),ppppppplVar14[-10],

+                     *(undefined2 *)((longlong)ppppppplVar14 + -0x1ea),ppppppplVar14[-0x41],

+                     CONCAT44(uVar18,*(undefined4 *)((longlong)ppppppplVar14 + -0x1fc)),

+                     in_stack_fffffffffffffed0);

+        }

+      }

+      else {

+        uVar18 = WfpAleCompareFlagVolatile(unaff_RBX,0x100000);

+        uVar15 = (ulonglong)*(ushort *)((longlong)ppppppplVar14 + -0x1ea);

+        WfpAleCompareFlagVolatile(uVar18,0x1000000);

+        in_stack_fffffffffffffed0 = 0;

+        cVar6 = WfpStreamIsFilterPresent

+                          (*(undefined2 *)((longlong)ppppppplVar14 + -0x1ec),uVar15 & 0xffff,

+                           *(undefined2 *)(ppppppplVar14 + -0x3d));

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

+          uVar7 = KeAcquireSpinLockRaiseToDpc(lVar9);

+          *(uint *)(lVar9 + 0x328) = *(uint *)(lVar9 + 0x328) | 0x100;

+          KeReleaseSpinLock(lVar9,uVar7);

+          AleAcquireEndpointLockEx(ppppppplVar16,&local_98,"WfpAleStreamLayerChanged");

+          LOCK();

+          *(uint *)((longlong)ppppppplVar14 + -500) =

+               *(uint *)((longlong)ppppppplVar14 + -500) | 0x100;

+          UNLOCK();

+          cVar6 = WfpAleCompareFlagVolatile(unaff_RBX,0x1000000);

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

+            LOCK();

+            *(uint *)((longlong)ppppppplVar14 + -500) =

+                 *(uint *)((longlong)ppppppplVar14 + -500) | 0x200;

+            UNLOCK();

+          }

+          LOCK();

+          *(uint *)((longlong)ppppppplVar14 + -500) =

+               *(uint *)((longlong)ppppppplVar14 + -500) | 0x400;

+          UNLOCK();

+          AleReleaseEndpointLock(ppppppplVar16,&local_98);

+        }

+      }

+      KfdAleReleaseFlowHandleForFlow(ppppppplVar16);

+      TcpDereferenceTcb(lVar9);

+    }

+    WfpAleDereferenceEndpoint(ppppppplVar16,0xf);

+  }

 LAB_0:

-    plVar20 = plVar12;

-    uVar7 = *(undefined8 *)(unaff_RDI + 0x118);

-    uVar4 = *(undefined4 *)(unaff_RBX + 4);

-    uVar8 = *(undefined8 *)(lVar21 + -0x39);

-    *(undefined8 *)(lVar21 + -0x11) = uVar7;

-    *(undefined8 *)((longlong)plVar20 + -8) = 0x140104c58;

-    lVar15 = Ipv6pFragmentLookup(uVar8,uVar4,uVar7,lVar21 + 0x67);

-    uVar23 = *(undefined1 *)(lVar21 + 0x67);

-    if (lVar15 == 0) {

-      lVar15 = *(longlong *)(lVar21 + -0x41);

-      uVar7 = *(undefined8 *)(lVar21 + -0x39);

-      uVar8 = *(undefined8 *)(unaff_RDI + 0x118);

-      *(undefined1 *)((longlong)plVar20 + 0x20) = uVar23;

-      uVar4 = *(undefined4 *)(lVar15 + 4);

-      *(undefined8 *)((longlong)plVar20 + -8) = 0x140104c8a;

-      lVar15 = IppCreateInReassemblySet(unaff_R14 + 0x5750,uVar8,uVar7,uVar4);

-      cVar22 = DAT_1;

-      if (lVar15 != 0) {

-        *(undefined4 *)(lVar15 + 200) = *(undefined4 *)(*(longlong *)(unaff_RDI + 8) + 0x110);

-        goto LAB_2;

-      }

-      *(undefined4 *)(lVar21 + 0x6f) = 3;

-      if (cVar22 < '\0') {

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104cc1;

-        McTemplateK0z_EtwWriteTransfer(&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_MEMORY_FAILURES);

-      }

-LAB_3:

-      lVar15 = *(longlong *)(lVar21 + -1);

-      *(int *)(*(longlong *)(lVar21 + -0x19) + 8) = *(int *)(*(longlong *)(lVar21 + -0x19) + 8) + 1;

-      *(int *)(lVar15 + 0x8c) = *(int *)(lVar15 + 0x8c) + 1;

-    }

-    else {

-      if (*(int *)(lVar15 + 200) != *(int *)(*(longlong *)(unaff_RDI + 8) + 0x110)) {

-        *(undefined4 *)(lVar15 + 200) = 0;

-      }

-LAB_2:

-      uVar7 = *(undefined8 *)(lVar15 + 0xd0);

-      uVar8 = *(undefined8 *)(lVar21 + -0x49);

-      *(undefined8 *)((longlong)plVar20 + -8) = 0x140104d02;

-      iVar14 = WfpTransferReassemblyContextForFragments(uVar8,uVar7);

-      if ((iVar14 < 0) && ((DAT_4 & 0x20) != 0)) {

-        lVar16 = *(longlong *)(lVar21 + -0x39);

-        *(undefined4 *)((longlong)plVar20 + 0x28) = 0x17;

-        *(undefined4 *)((longlong)plVar20 + 0x20) = *(undefined4 *)(lVar16 + 8);

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104d47;

-        McTemplateK0qqq_EtwWriteTransfer

-                  (&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_IP_REASSEMBLY_WFP,

-                   &MICROSOFT_TCPIP_PROVIDER,1);

-      }

-      lVar16 = *(longlong *)(lVar21 + -0x49);

-      puVar9 = *(uint **)(lVar21 + -0x11);

-      uVar17 = *(uint *)(lVar16 + 0x88) & 0xfff00003 | *(uint *)(lVar15 + 0xb8);

-      *(uint *)(lVar15 + 0xb8) = uVar17;

-      *(uint *)(lVar15 + 0xb8) = 1 << ((byte)(*puVar9 >> 0xc) & 3) | uVar17;

-      if (0xffff < (uint)unaff_R12W + *(int *)(unaff_R13 + 0x18)) {

-        *(undefined4 *)(lVar21 + 0x6f) = 5;

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104da8;

-        IppDeleteFromReassemblySet

-                  (unaff_R14 + 0x5750,lVar15,CONCAT71((int7)((ulonglong)puVar9 >> 8),uVar23));

-        uVar17 = *(int *)(unaff_RDI + 0x30) - 6;

-        *(undefined1 *)((longlong)plVar20 + 0x30) = 0;

-        *(uint *)((longlong)plVar20 + 0x28) =

-             uVar17 >> 0x18 | (uVar17 & 0xff0000) >> 8 | (uVar17 & 0xff00) << 8 | uVar17 * 0x1000000

-        ;

-LAB_5:

-        *(undefined1 *)((longlong)plVar20 + 0x20) = 0;

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x1401049e8;

-        IppSendError(0,&Ipv6Global);

-        goto LAB_3;

-      }

-      *(uint **)((longlong)plVar20 + 0x20) = puVar9 + 6;

-      uVar4 = *(undefined4 *)(unaff_R14 + 0x18);

-      *(undefined8 *)((longlong)plVar20 + -8) = 0x140104de3;

-      iVar14 = IPsecVerifyFragment(lVar15 + 0xc0,lVar16,uVar4,puVar9 + 2);

-      if (iVar14 < 0) {

-LAB_6:

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104df9;

-        IppDeleteFromReassemblySet(unaff_R14 + 0x5750,lVar15,uVar23);

-        goto LAB_7;

-      }

-      uVar17 = *(uint *)(unaff_R13 + 0x18);

-      if ((uVar17 == 0) &&

-         ((unaff_R12W != 0 || ((*(ushort *)(*(longlong *)(lVar21 + -0x41) + 2) & 0x100) != 0)))) {

-        unaff_R15D = 9;

-        goto LAB_6;

-      }

-      if ((*(ushort *)(*(longlong *)(lVar21 + -0x41) + 2) & 0x100) == 0) {

-        if (*(int *)(lVar15 + 0x8c) == -1) {

-          uVar18 = unaff_R12W + uVar17;

-          *(uint *)(lVar15 + 0x8c) = uVar18;

-          if (*(ushort *)(lVar15 + 0x54) <= uVar18) {

-            uVar17 = (uint)*(ushort *)(lVar15 + 0x56);

-            goto LAB_8;

-          }

-LAB_9:

-          unaff_R15D = 0xb;

-        }

-        else {

-          if (unaff_R12W + uVar17 == *(int *)(lVar15 + 0x8c)) goto LAB_10;

-          unaff_R15D = 10;

-        }

-        goto LAB_6;

-      }

-      if ((uVar17 & 7) != 0) {

-        *(undefined4 *)(lVar21 + 0x6f) = 6;

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104fff;

-        IppDeleteFromReassemblySet(unaff_R14 + 0x5750,lVar15,uVar23);

-        *(undefined1 *)((longlong)plVar20 + 0x30) = 0;

-        *(undefined4 *)((longlong)plVar20 + 0x28) = 0x4000000;

-        goto LAB_5;

-      }

-      uVar18 = *(uint *)(lVar15 + 0x8c);

-      if (uVar18 != 0xffffffff) {

-        uVar17 = unaff_R12W + uVar17;

-LAB_8:

-        if (uVar18 < uVar17) goto LAB_9;

-      }

-LAB_10:

-      *(longlong *)((longlong)plVar20 + 0x28) = lVar21 + 0x6f;

-      *(undefined1 *)((longlong)plVar20 + 0x20) = uVar23;

-      *(undefined8 *)((longlong)plVar20 + -8) = 0x140104e99;

-      lVar16 = IppReassemblyFindLocation();

-      *(longlong *)(lVar21 + -0x49) = lVar16;

-      if (lVar16 != 0) {

-        uVar4 = *(undefined4 *)(unaff_R13 + 0x18);

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104eb6;

-        lVar16 = MmSizeOfMdl(0xfff,uVar4);

-        uVar26 = lVar16 + 7U & 0xfffffffffffffff8;

-        *(ulonglong *)(lVar21 + 7) = uVar26;

-        uVar1 = uVar26 + 0x10;

-        if ((0xf < uVar1) && (uVar19 = *(uint *)(unaff_R13 + 0x18) + uVar1, uVar1 <= uVar19)) {

-          *(undefined8 *)(lVar21 + -0x29) = 0;

-          *(undefined8 *)(lVar21 + -0x31) = 1;

-          *(undefined4 *)((longlong)plVar20 + 0x20) = 1;

-          *(undefined8 *)((longlong)plVar20 + -8) = 0x140104f02;

-          lVar16 = ExAllocatePool3(0x42,uVar19,0x65725049,lVar21 + -0x31);

-          *(longlong *)(lVar21 + 0x6f) = lVar16;

-          if (lVar16 != 0) {

-            uVar17 = *(uint *)(unaff_R13 + 0x18);

-            *(undefined8 *)(lVar16 + 0x10) = 0;

-            uVar26 = lVar16 + 0x10 + uVar26;

-            *(undefined2 *)(lVar16 + 0x1a) = 0;

-            *(uint *)(lVar16 + 0x38) = uVar17;

-            uVar18 = (uint)uVar26;

-            *(ulonglong *)(lVar16 + 0x30) = uVar26 & 0xfffffffffffff000;

-            uVar25 = 6;

-            *(uint *)(lVar16 + 0x3c) = uVar18 & 0xfff;

-            *(short *)(lVar16 + 0x18) =

-                 ((short)((ulonglong)uVar17 + 0xfff + (ulonglong)(uVar18 & 0xfff) >> 0xc) + 6) * 8;

-            *(undefined8 *)((longlong)plVar20 + -8) = 0x14010509a;

-            MmBuildMdlForNonPagedPool();

-            puVar10 = *(undefined8 **)(lVar21 + 0x6f);

-            *(undefined2 *)(puVar10 + 1) = *(undefined2 *)(unaff_R13 + 0x18);

-            *puVar10 = 0;

-            *(ushort *)((longlong)puVar10 + 10) = unaff_R12W;

-            if (*(longlong *)(lVar21 + -0x49) == lVar15 + 0x60) {

-              *(undefined1 *)(lVar15 + 0xbe) = **(undefined1 **)(lVar21 + -0x41);

-              if ((Feature_TCPIP_USGv6_FirstFragmentSecurityHeaderFix__private_featureState & 0x10)

-                  == 0) {

-                *(undefined8 *)((longlong)plVar20 + -8) = 0x1401050eb;

-                uVar17 = Feature_TCPIP_USGv6_FirstFragmentSecurityHeaderFix__private_IsEnabledDeviceUsageNoInline

-                                   ();

-              }

-              else {

-                uVar17 = Feature_TCPIP_USGv6_FirstFragmentSecurityHeaderFix__private_featureState &

-                         1;

-              }

-              if (uVar17 == 0) {

-                uVar3 = *(ushort *)(*(longlong *)(lVar21 + -0x11) + 4);

-                *(uint *)(lVar15 + 0xe0) =

-                     (uint)(ushort)(uVar3 >> 8 | uVar3 << 8) + (uint)*(ushort *)(unaff_R14 + 0x28);

-              }

-              *(undefined4 *)(lVar15 + 0xd8) = *(undefined4 *)(unaff_RDI + 0x13c);

-              *(undefined1 *)(lVar15 + 0xdc) = *(undefined1 *)(unaff_RDI + 0x138);

-              sVar13 = *(short *)(unaff_RDI + 0x30) + -0x30;

-              *(short *)(lVar15 + 0x88) = sVar13;

-              if (sVar13 != 0) {

-                *(undefined8 *)(lVar21 + -0x31) = 1;

-                *(undefined8 *)(lVar21 + -0x29) = 0;

-                uVar25 = *(undefined2 *)(lVar15 + 0x88);

-                *(undefined4 *)((longlong)plVar20 + 0x20) = 1;

-                *(undefined8 *)((longlong)plVar20 + -8) = 0x14010516a;

-                lVar16 = ExAllocatePool3(0x40,uVar25,0x65725049,lVar21 + -0x31);

-                *(longlong *)(lVar15 + 0x80) = lVar16;

-                cVar22 = DAT_1;

-                if (lVar16 == 0) {

-                  *(undefined4 *)(lVar21 + 0x6f) = 3;

-                  if (cVar22 < '\0') {

-                    *(undefined8 *)((longlong)plVar20 + -8) = 0x1401051a6;

-                    McTemplateK0z_EtwWriteTransfer

-                              (&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_MEMORY_FAILURES);

-                  }

-                  uVar23 = *(undefined1 *)(lVar21 + 0x67);

-                  *(undefined8 *)((longlong)plVar20 + -8) = 0x1401051b9;

-                  IppDeleteFromReassemblySet(unaff_R14 + 0x5750,lVar15,uVar23);

-                  *(undefined8 *)((longlong)plVar20 + -8) = 0x1401051c5;

-                  ExFreePoolWithTag(puVar10,0);

-                  goto LAB_3;

-                }

-                uVar25 = *(undefined2 *)(lVar15 + 0x88);

-                *(undefined8 *)((longlong)plVar20 + -8) = 0x1401051e9;

-                IppIncreaseReassemblySize(unaff_R14 + 0x5750,lVar15,uVar25,uVar25);

-                iVar14 = *(int *)(unaff_R13 + 0x28);

-                iVar5 = *(int *)(unaff_RDI + 0x30);

-                uVar25 = *(undefined2 *)(lVar15 + 0x88);

-                uVar7 = *(undefined8 *)(lVar15 + 0x80);

-                uVar8 = *(undefined8 *)(unaff_R13 + 0x20);

-                *(longlong *)((longlong)plVar20 + 0x20) = lVar21 + -9;

-                *(undefined8 *)((longlong)plVar20 + -8) = 0x140105217;

-                RtlCopyMdlToBuffer(uVar8,(ulonglong)(uint)(iVar14 - iVar5) + 0x28,uVar7,uVar25);

-                uVar25 = *(undefined2 *)(unaff_RDI + 0x122);

-              }

-              *(undefined2 *)(lVar15 + 0xbc) = uVar25;

-              uVar23 = *(undefined1 *)(lVar21 + 0x67);

-              *(undefined8 *)(lVar15 + 0x90) = **(undefined8 **)(unaff_RDI + 0x118);

-            }

-            lVar16 = *(longlong *)(lVar21 + 7);

-            uVar4 = *(undefined4 *)(unaff_R13 + 0x18);

-            uVar6 = *(undefined4 *)(unaff_R13 + 0x28);

-            uVar7 = *(undefined8 *)(unaff_R13 + 0x20);

-            *(longlong *)((longlong)plVar20 + 0x20) = lVar21 + -9;

-            *(undefined8 *)((longlong)plVar20 + -8) = 0x140105268;

-            RtlCopyMdlToBuffer(uVar7,uVar6,lVar16 + 0x10 + (longlong)puVar10,uVar4);

-            uVar7 = *(undefined8 *)(lVar21 + -0x49);

-            *(undefined8 *)((longlong)plVar20 + -8) = 0x14010527c;

-            IppReassemblyInsertFragment(lVar15,uVar7,puVar10);

-            iVar14 = *(int *)(unaff_R13 + 0x18);

-            *(undefined8 *)((longlong)plVar20 + -8) = 0x140105296;

-            IppIncreaseReassemblySize(unaff_R14 + 0x5750,lVar15,iVar14 + 0x100);

-            if ((uint)*(ushort *)(lVar15 + 0x54) == *(uint *)(lVar15 + 0x8c)) {

-              *(undefined8 *)((longlong)plVar20 + -8) = 0x1401052b0;

-              Ipv6pReassembleDatagram();

-            }

-            else {

-              *(undefined8 *)((longlong)plVar20 + -8) = 0x1401052be;

-              IppCheckReassemblyQuota(unaff_R14 + 0x5750,lVar15,uVar23);

-            }

-            *(undefined4 *)(*(longlong *)(unaff_RDI + 8) + 0x8c) = 0xc0000240;

-            goto LAB_11;

-          }

-          if (DAT_1 < '\0') {

-            *(undefined8 *)((longlong)plVar20 + -8) = 0x140104f3b;

-            McTemplateK0z_EtwWriteTransfer(&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_MEMORY_FAILURES)

-            ;

-          }

-        }

-        *(undefined4 *)(lVar21 + 0x6f) = 3;

-        *(undefined8 *)((longlong)plVar20 + -8) = 0x140104f54;

-        IppDeleteFromReassemblySet(unaff_R14 + 0x5750,lVar15,uVar23);

-        goto LAB_3;

-      }

-    }

-    unaff_R15D = *(undefined4 *)(lVar21 + 0x6f);

-  }

-  else {

-    bVar2 = *unaff_RBX;

-    *(int *)(lVar21 + 0x7f) = (int)param_1;

-    *(undefined8 *)(lVar21 + -0x21) = param_1;

-    cVar22 = (char)param_1;

-    *(uint *)(lVar21 + 0x77) = (uint)bVar2;

-    *unaff_RBP = 0x140104ba7;

-    iVar14 = NetioPhSkipAllIpv6Options();

-    if (-1 < iVar14) {

-      cVar24 = '\x01';

-      if (*(int *)(lVar21 + 0x77) == 0x32 || *(int *)(lVar21 + 0x77) == 0x33) {

-        *unaff_RBP = 0x140104bdc;

-        IppFindNlExtensionHeaderClient();

-        cVar24 = '\x01';

-      }

-      else {

-        *unaff_RBP = 0x140104bcd;

-        IppFindNlFinalHeaderClient();

-      }

-      if ((*(uint **)(lVar21 + -0x21) != (uint *)0x0) &&

-         (*(uint *)(unaff_R13 + 0x18) < **(uint **)(lVar21 + -0x21))) {

-        cVar22 = cVar24;

-      }

-    }

-    *unaff_RBP = 0x140104c03;

-    iVar14 = NetioRetreatNetBuffer();

-    if (iVar14 < 0) {

-      pcVar11 = (code *)swi(0x2c);

-      (*pcVar11)(0);

-      plVar20 = unaff_RBP + 2;

-    }

-    plVar12 = plVar20;

-    if (cVar22 == '\0') goto LAB_0;

-    *(undefined1 *)((longlong)plVar20 + 0x30) = 0;

-    *(undefined4 *)((longlong)plVar20 + 0x28) = 0;

-    *(undefined1 *)((longlong)plVar20 + 0x20) = 3;

-    unaff_R15D = 0x11;

-    *(undefined8 *)((longlong)plVar20 + -8) = 0x140104c35;

-    IppSendError();

-  }

-LAB_7:

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

-    *(undefined4 *)((longlong)plVar20 + 0x28) = *(undefined4 *)(*(longlong *)(lVar21 + -0x39) + 8);

-    *(undefined4 *)((longlong)plVar20 + 0x20) = 2;

-    *(undefined8 *)((longlong)plVar20 + -8) = 0x140104faf;

-    McTemplateK0qqq_EtwWriteTransfer

-              (&MICROSOFT_TCPIP_PROVIDER_Context,&TCPIP_IP_REASSEMBLY_DROP,&MICROSOFT_TCPIP_PROVIDER

-               ,unaff_R15D);

-  }

-  if (*(longlong *)(unaff_RDI + 8) != 0) {

-    *(undefined4 *)(*(longlong *)(unaff_RDI + 8) + 0x8c) = 0xc000021b;

-  }

-LAB_11:

-  *(undefined4 *)(unaff_RDI + 0x2c) = 0x3b;

-  return;

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

+  (*pcVar3)(3);

+  NetioDereferenceNetBufferList(*unaff_RBX,0);

+  *unaff_RBX = (longlong ******)0x0;

+  return (longlong *******)0xc000009a;

 }
```

## `InetWakeReleasePortAf`  (modified)

```diff
--- InetWakeReleasePortAf
+++ InetWakeReleasePortAf
@@ -1,10 +1,75 @@
 

-undefined4 InetWakeReleasePortAf(void)

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

+

+undefined8

+InetWakeReleasePortAf(undefined2 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

 

 {

-  undefined4 unaff_ESI;

+  longlong lVar1;

+  longlong *plVar2;

+  code *pcVar3;

+  undefined1 uVar4;

+  char cVar5;

+  uint uVar6;

+  longlong *plVar7;

+  undefined8 uVar8;

+  undefined1 auStack_168 [32];

+  undefined4 local_148;

+  undefined1 *local_140;

+  undefined4 local_138;

+  undefined1 local_128 [208];

+  undefined4 local_58;

+  ulonglong local_48;

   

-  ExFreePoolWithTag();

-  return unaff_ESI;

+  local_48 = __security_cookie ^ (ulonglong)auStack_168;

+  uVar4 = KeAcquireSpinLockRaiseToDpc(param_4);

+  plVar7 = (longlong *)InetWakeLookupPort(param_1,param_2,param_3,param_4);

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

+    KeReleaseSpinLock(param_4,uVar4);

+    return 0xc0000225;

+  }

+  plVar2 = plVar7 + 2;

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

+  if ((int)*plVar2 == 0) {

+    if ((Feature_3131548987__private_featureState & 0x10) == 0) {

+      uVar6 = Feature_3131548987__private_IsEnabledDeviceUsageNoInline();

+    }

+    else {

+      uVar6 = Feature_3131548987__private_featureState & 1;

+    }

+    if (uVar6 == 0) {

+      lVar1 = *plVar7;

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

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

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

+        (*pcVar3)(3);

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

+        uVar8 = (*pcVar3)();

+        return uVar8;

+      }

+      *plVar2 = lVar1;

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

+    }

+    else {

+      InetWakeRemovePortEntryIfPresent(plVar7);

+      if (*(int *)((longlong)plVar7 + 0x14) != 0) goto LAB_0;

+    }

+    KeReleaseSpinLock(param_4,uVar4);

+    cVar5 = IsPortWithinRange(param_1);

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

+      memset(local_128,0,0xd8);

+      local_58 = (undefined4)plVar7[3];

+      local_140 = local_128;

+      local_138 = 0xd8;

+      local_148 = 0;

+      InetSetInterfacePropertyAf(param_2,param_3,0,0x13);

+    }

+    ExFreePoolWithTag(plVar7,0);

+  }

+  else {

+LAB_0:

+    KeReleaseSpinLock(param_4,uVar4);

+  }

+  return 0;

 }
```

## `IpGetAllSortedAddressParameters`  (modified)

```diff
--- IpGetAllSortedAddressParameters
+++ IpGetAllSortedAddressParameters
@@ -1,8 +1,45 @@
 

-void IpGetAllSortedAddressParameters(void)

+undefined4 IpGetAllSortedAddressParameters(longlong param_1)

 

 {

-  cRam00000001000bc993 = cRam00000001000bc993 << 1;

-  return;

+  int *piVar1;

+  void *_Dst;

+  char cVar2;

+  uint uVar3;

+  undefined4 uVar4;

+  longlong lVar5;

+  

+  piVar1 = *(int **)(param_1 + 0x10);

+  _Dst = *(void **)(param_1 + 0x38);

+  if ((Feature_4272399675__private_featureState & 0x10) == 0) {

+    uVar3 = Feature_4272399675__private_IsEnabledDeviceUsageNoInline();

+  }

+  else {

+    uVar3 = Feature_4272399675__private_featureState & 1;

+  }

+  if ((uVar3 == 0) || ((uint)piVar1[0xdad] < 0x1f5)) {

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

+      return 0xc00000bb;

+    }

+    if ((*(int *)(param_1 + 0x20) == 0) && (_Dst != (void *)0x0)) {

+      lVar5 = IppFindCompartmentById(&Ipv6Global);

+      if (lVar5 != 0) {

+        if ((*piVar1 == 0) || (cVar2 = IppIsCompartmentAccessibleByThread(lVar5,0,1), cVar2 != '\0')

+           ) {

+          memset(_Dst,0,0x4658);

+          uVar4 = IppCreateSortedAddressPairsEx

+                            (lVar5,piVar1[0xdae],_Dst,(longlong)_Dst + 14000,piVar1 + 1,

+                             piVar1[0xdad],(longlong)_Dst + 0x36b4,(longlong)_Dst + 0x4654);

+        }

+        else {

+          uVar4 = 0xc0000225;

+        }

+        IppDereferenceCompartment(lVar5);

+        return uVar4;

+      }

+      return 0xc0000225;

+    }

+  }

+  return 0xc000000d;

 }
```

## `IppDeleteSitePrefixes`  (modified)

```diff
--- IppDeleteSitePrefixes
+++ IppDeleteSitePrefixes
@@ -1,174 +1,20 @@
 

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

+void IppDeleteSitePrefixes(longlong param_1,longlong param_2,int param_3)

 

 {

-  byte *pbVar1;

-  char *pcVar2;

-  int iVar3;

-  byte bVar4;

-  uint uVar5;

-  uint uVar6;

-  int iVar7;

-  byte bVar8;

-  char *in_RAX;

-  undefined8 uVar9;

-  byte unaff_BL;

-  undefined4 *unaff_RSI;

-  longlong unaff_RDI;

-  byte bVar10;

-  byte bVar11;

-  longlong in_R10;

-  byte in_R11B;

+  undefined8 *puVar1;

+  undefined8 *puVar2;

+  undefined1 uVar3;

   

-  bVar8 = (char)in_RAX + *in_RAX;

-  pcVar2 = (char *)(unaff_RDI + -0x4a + param_1);

-  *pcVar2 = *pcVar2 + bVar8;

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

-  *pbVar1 = *pbVar1 << 6 | *pbVar1 >> 2;

-  bVar10 = param_3 >> 2 & 1;

-  if (bVar10 == ((byte)(param_1 >> 2) & 1)) {

-    if (((param_4 ^ bVar8) & 8) == 0) {

-      bVar10 = in_R11B & 1;

-      if (bVar10 == (unaff_BL & 1)) {

-        uVar5 = *(uint *)(in_R10 + 8);

-        if (((uVar5 != 0xffffffff) && (uVar6 = *(uint *)(param_2 + 8), uVar6 != 0xffffffff)) &&

-           (uVar5 != uVar6)) {

-          *unaff_RSI = 0x60;

-          if (uVar5 <= uVar6) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        if (*(int *)(in_R10 + 0x20) == *(int *)(param_2 + 0x20)) {

-          bVar10 = *(byte *)(in_R10 + 0x1c);

-          bVar11 = *(byte *)(param_2 + 0x1c);

-          if (bVar10 != bVar11) {

-            *unaff_RSI = 0x61;

-            if (bVar10 <= bVar11) {

-              return 0xffffffff;

-            }

-            return 1;

-          }

-        }

-        if (bVar8 >> 7 != param_4 >> 7) {

-          *unaff_RSI = 0x70;

-          if ((char)bVar8 < '\0') {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        uVar6 = *(uint *)(in_R10 + 4);

-        uVar5 = *(uint *)(param_2 + 4);

-        if (uVar6 != uVar5) {

-          *unaff_RSI = 0x71;

-          if (uVar5 <= uVar6) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        bVar10 = *(byte *)(in_R10 + 0xc);

-        bVar11 = *(byte *)(param_2 + 0xc);

-        if (bVar10 != bVar11) {

-          *unaff_RSI = 0x80;

-          if (bVar11 <= bVar10) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        bVar11 = bVar8 >> 4 & 1;

-        if (bVar11 != (param_4 >> 4 & 1)) {

-          *unaff_RSI = 0x110;

-joined_r0x000140068516:

-          if (bVar11 == 0) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        bVar11 = *(byte *)(in_R10 + 0xe);

-        bVar4 = *(byte *)(param_2 + 0xe);

-        if (bVar11 != bVar4) {

-          *unaff_RSI = 0x120;

-          if (bVar4 <= bVar11) {

-            if (bVar10 <= bVar4) {

-              return 0xffffffff;

-            }

-            return 1;

-          }

-          if (bVar11 < bVar10) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        iVar7 = *(int *)(in_R10 + 0x10);

-        iVar3 = *(int *)(param_2 + 0x10);

-        if (iVar7 != iVar3) {

-          *unaff_RSI = 0x130;

-          if (iVar7 <= iVar3) {

-            return 0xffffffff;

-          }

-          return 1;

-        }

-        bVar10 = bVar8 >> 5 & 1;

-        if (bVar10 == (param_4 >> 5 & 1)) {

-          bVar10 = in_R11B >> 1 & 1;

-          if (bVar10 == (unaff_BL >> 1 & 1)) {

-            bVar11 = bVar8 >> 6 & 1;

-            if (bVar11 == (param_4 >> 6 & 1)) {

-              uVar6 = *(uint *)(in_R10 + 0x18);

-              uVar5 = *(uint *)(param_2 + 0x18);

-              if (uVar6 != uVar5) {

-                *unaff_RSI = 0x171;

-                if (uVar6 <= uVar5) {

-                  return 0xffffffff;

-                }

-                return 1;

-              }

-              bVar10 = *(byte *)(in_R10 + 0x14);

-              bVar8 = *(byte *)(param_2 + 0x14);

-              if (bVar10 != bVar8) {

-                *unaff_RSI = 0x172;

-                if (bVar10 <= bVar8) {

-                  return 0xffffffff;

-                }

-                return 1;

-              }

-              bVar10 = *(byte *)(in_R10 + 0xd);

-              bVar8 = *(byte *)(param_2 + 0xd);

-              if (bVar10 != bVar8) {

-                *unaff_RSI = 400;

-                uVar9 = 0xffffffff;

-                if (bVar8 < bVar10) {

-                  uVar9 = 1;

-                }

-                return uVar9;

-              }

-              *unaff_RSI = 0x1a0;

-              return 0;

-            }

-            *unaff_RSI = 0x170;

-            goto joined_r0x000140068516;

-          }

-          *unaff_RSI = 0x151;

-        }

-        else {

-          *unaff_RSI = 0x150;

-        }

-      }

-      else {

-        *unaff_RSI = 0x51;

-      }

-    }

-    else {

-      *unaff_RSI = 0x50;

-      bVar10 = bVar8 & 8;

+  uVar3 = KeAcquireSpinLockRaiseToDpc(param_1 + 0x2e0);

+  puVar1 = *(undefined8 **)(param_1 + 0x2e8);

+  while (puVar2 = puVar1, puVar2 != (undefined8 *)(param_1 + 0x2e8)) {

+    puVar1 = (undefined8 *)*puVar2;

+    if ((puVar2[2] == param_2) && ((param_3 == 2 || (*(int *)(puVar2 + 7) == param_3)))) {

+      IppRemoveSitePrefixEntry();

     }

   }

-  else {

-    *unaff_RSI = 0x30;

-  }

-  if (bVar10 != 0) {

-    return 0xffffffff;

-  }

-  return 1;

+  KeReleaseSpinLock(param_1 + 0x2e0,uVar3);

+  return;

 }
```

## `FUN_1401c83a8`  (modified)

```diff
--- FUN_1401c83a8
+++ InetWakeRemovePortEntryIfPresent
@@ -1,31 +1,26 @@
 

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

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

-

-void FUN_1401c83a8(void)

+void InetWakeRemovePortEntryIfPresent(longlong *param_1)

 

 {

-  undefined4 in_EAX;

-  longlong unaff_RBX;

-  undefined4 unaff_EBP;

-  longlong unaff_RDI;

-  undefined8 unaff_R14;

+  longlong *plVar1;

+  longlong *plVar2;

+  code *pcVar3;

   

-  *(undefined4 *)(unaff_RBX + 0x78) = in_EAX;

-  *(undefined8 *)(unaff_RBX + 0x70) = unaff_R14;

-  *(short *)(unaff_RBX + 0x68) = (short)unaff_R14;

-  KeReleaseInStackQueuedSpinLock(&stack0x00000050);

-  KeReleaseSemaphore(unaff_RBX + 0xe0,0,1);

-  (**(code **)(unaff_RDI + 0x10))(*(undefined8 *)(unaff_RDI + 0x18),unaff_EBP,0);

-  if (*(longlong *)(unaff_RDI + 0x20) != 0) {

-    InetDereferenceLocalAddressAf(*(undefined8 *)(unaff_RDI + 0x28));

+  plVar1 = (longlong *)*param_1;

+  if (plVar1 != param_1) {

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

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

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

+      (*pcVar3)(3);

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

+      (*pcVar3)();

+      return;

+    }

+    *plVar2 = (longlong)plVar1;

+    plVar1[1] = (longlong)plVar2;

+    param_1[1] = (longlong)param_1;

+    *param_1 = (longlong)param_1;

   }

-  if ((*(longlong *)(unaff_RDI + 0x28) != 0) &&

-     (*(longlong *)(unaff_RDI + 0x28) != *(longlong *)(unaff_RBX + 0x38))) {

-    _InetDereferenceAf();

-  }

-  RawDereferenceEndpoint(*(undefined8 *)(unaff_RDI + 8));

-  ExFreePoolWithTag();

   return;

 }
```

## `FUN_1401c8cf0`  (modified)

```diff
--- FUN_1401c8cf0
+++ FUN_1401cb93a
@@ -1,57 +1,75 @@
 

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

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

+/* PDB: Separated code (from the compiler): 1401cb93a - 1401cb951 for parent address: 140075260 */

 

-void FUN_1401c8cf0(void)

+void FUN_1401cb93a(void)

 

 {

-  longlong lVar1;

-  longlong lVar2;

-  char cVar3;

+  undefined8 *puVar1;

+  code *pcVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  longlong *unaff_RBX;

   longlong unaff_RBP;

-  longlong *unaff_RDI;

-  longlong lVar4;

-  longlong *plVar5;

-  longlong unaff_R15;

-  longlong in_stack_00000058;

-  undefined8 *in_stack_00000060;

-  longlong in_stack_00000068;

-  longlong *in_stack_00000070;

+  longlong *unaff_RSI;

+  longlong unaff_RDI;

+  longlong unaff_R14;

+  undefined1 unaff_R15B;

   

-  lVar2 = in_stack_00000068;

-  lVar4 = 0;

-  plVar5 = in_stack_00000070;

   do {

-    if (in_stack_00000058 != lVar4) {

-      (**(code **)(*(longlong *)(unaff_R15 + 0x50) + 0x10))

-                (*(undefined8 *)(unaff_R15 + 0x58),lVar2,*(undefined4 *)*plVar5,

-                 *(undefined4 *)(*plVar5 + 0x14),(int)plVar5[1]);

-      lVar4 = 0;

-    }

-    cVar3 = IppPrepareIpsReceiveContext(lVar2,&stack0x00000050);

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

-      lVar1 = *(longlong *)(unaff_RBP + -0x78);

+    plVar4 = unaff_RBX;

+    if (plVar4 == unaff_RSI) {

       do {

-        if (*(char *)(unaff_R15 + 0x3e) != (char)lVar4) {

-          *(byte *)(lVar2 + 0x28) = *(byte *)(lVar2 + 0x28) | 2;

-        }

-        unaff_RDI = (longlong *)*unaff_RDI;

-        if (unaff_RDI == (longlong *)lVar1) {

-          IppCompleteIpsReceiveContext(lVar2,*(undefined8 *)(unaff_RBP + -0x70));

+        *(undefined4 *)(unaff_RDI + 0x7c) = 0;

+        *(undefined4 *)(unaff_RDI + 0x80) = 0;

+        *(undefined4 *)(unaff_RDI + 0x84) = 0;

+        CarAcquireCacheAwareReference(*(undefined8 *)(unaff_RDI + 0x20),1);

+        IppCancelMulticastTimer(*(undefined8 *)(unaff_RBP + 0x2d0),unaff_RDI + 0x88,unaff_RDI);

+        IppCancelMulticastTimer(*(undefined8 *)(unaff_RBP + 0x2d8),unaff_RDI + 0xa0,unaff_RDI);

+        IppCancelMulticastTimer(*(undefined8 *)(unaff_RBP + 0x2e0),unaff_RDI + 0xb8,unaff_RDI);

+        IppDereferenceLocalMulticastAddressUnderLock(unaff_RDI);

+        lVar3 = IppEnumerateAdaptiveTableEntry();

+        if (lVar3 == 0) {

           return;

         }

-        unaff_R15 = unaff_RDI[2];

-        cVar3 = IppPrepareIpsReceiveContext(lVar2,&stack0x00000050);

-        plVar5 = in_stack_00000070;

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

+        unaff_RDI = lVar3 + -0x48;

+        unaff_RSI = (longlong *)(lVar3 + 0x20);

+        plVar4 = (longlong *)*unaff_RSI;

+      } while (plVar4 == unaff_RSI);

     }

-    if (((*(char *)(unaff_RBP + 0x3e0) == (char)lVar4) &&

-        (*(char *)(unaff_R15 + 0x3e) != (char)lVar4)) && ((*(byte *)(lVar2 + 0x28) & 2) == 0)) {

-      in_stack_00000060 = &stack0x00000058;

-      in_stack_00000058 = 0;

-      FUN_1401c8cbe();

-      return;

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

+    unaff_RBX = (longlong *)*plVar4;

+    *(undefined1 *)((longlong)plVar4 + 0x1c) = 0;

+  } while (((int)plVar4[2] != 0) || (*(int *)((longlong)plVar4 + 0x14) != 0));

+  if (((longlong *)unaff_RBX[1] == plVar4) &&

+     (puVar1 = (undefined8 *)plVar4[1], (longlong *)*puVar1 == plVar4)) {

+    *puVar1 = unaff_RBX;

+    unaff_RBX[1] = (longlong)puVar1;

+    ExFreePoolWithTag(plVar4,0);

+    FUN_1401cb93a();

+    return;

+  }

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

+  (*pcVar2)(3);

+  do {

+    KeReleaseSpinLockFromDpcLevel();

+    IppDeleteReassembly(unaff_RBX);

+    while( true ) {

+      do {

+        unaff_RBX = (longlong *)RtlEnumerateEntryHashTable();

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

+          RtlEndEnumerationHashTable();

+          KeReleaseSpinLock(unaff_RSI,unaff_R15B);

+          return;

+        }

+      } while (unaff_RBX[7] != unaff_R14);

+      IppRemoveReassembly(unaff_RSI,unaff_RBX);

+      KeAcquireSpinLockAtDpcLevel(unaff_RBX + 6);

+      if (*(int *)((longlong)unaff_RBX + 0x44) != 1) break;

+      unaff_RBX[7] = 0;

+      *(undefined4 *)((longlong)unaff_RBX + 0x44) = 2;

+      KeReleaseSpinLockFromDpcLevel(unaff_RBX + 6);

     }

   } while( true );

 }
```

## `NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLockFromDpcLevel`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLockFromDpcLevel calling
+++ NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLockFromDpcLevel calling
@@ -5,3 +5,3 @@
-FUN_1401c6505
-FUN_1401ce512
-FUN_1401d264a
+FUN_1401c429f
+FUN_1401ce798
+FUN_1401d0db4
@@ -92,0 +93 @@
+Ipv6pHandleNeighborSolicitation
@@ -104 +104,0 @@
-RawBindEndpointInspectComplete
```

## `NDIS.SYS::NdisAcquireRWLockWrite`  (modified)

```diff
--- NDIS.SYS::NdisAcquireRWLockWrite calling
+++ NDIS.SYS::NdisAcquireRWLockWrite calling
@@ -0,0 +1 @@
+Fl8AddGroup
```

## `NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel calling
+++ NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel calling
@@ -2,3 +2,3 @@
-FUN_140003ce0
-FUN_140041bba
-FUN_1401c9e42
+FUN_14002c47a
+FUN_14002f6c0
+FUN_1401ccc22
```

## `NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLock`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLock calling
+++ NTOSKRNL.EXE::KeReleaseInStackQueuedSpinLock calling
@@ -19,13 +19,13 @@
-FUN_140059e1f
-FUN_1400c0704
-FUN_1401c572a
-FUN_1401c8944
-FUN_1401c8bfe
-FUN_1401c8c41
-FUN_1401cfd86
-FUN_1401d16e8
-FUN_1401d2199
-FUN_1401d64e9
-FUN_1401da01e
-FUN_1401db6a4
-FUN_14028053e
+FUN_140018cff
+FUN_1400b1bc4
+FUN_1401c8736
+FUN_1401cfe52
+FUN_1401d0903
+FUN_1401d2048
+FUN_1401d51ec
+FUN_1401d54b0
+FUN_1401d54f3
+FUN_1401d73c5
+FUN_1401da8be
+FUN_1401dbeb4
+FUN_14028153e
@@ -252,0 +253 @@
+UdpConnectRedirectObsolete
```

## `NDIS.SYS::NdisReleaseRWLock`  (modified)

```diff
--- NDIS.SYS::NdisReleaseRWLock calling
+++ NDIS.SYS::NdisReleaseRWLock calling
@@ -0,0 +1 @@
+Fl8AddGroup
```

## `NTOSKRNL.EXE::KeReleaseSpinLock`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseSpinLock calling
+++ NTOSKRNL.EXE::KeReleaseSpinLock calling
@@ -2,3 +2,3 @@
-FUN_1401c9e42
-FUN_1401cf2f6
-FUN_1401d630d
+FUN_1401ccc22
+FUN_1401cfd44
+FUN_1401d71e9
@@ -160,0 +161 @@
+WfpAleStreamLayerChanged
```
