# CVE-2026-97002 — vmswitch.sys patch diff

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

## `VmsVmNicMorph`  (modified)

```diff
--- VmsVmNicMorph
+++ VmsVmNicMorph
@@ -1,102 +1,460 @@
 

-int VmsVmNicMorph(void)

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

+                 byte *param_5,byte param_6,undefined8 param_7,longlong *param_8,byte param_9,

+                 undefined8 param_10,uint param_11,byte param_12,byte param_13,undefined1 param_14,

+                 longlong *param_15,byte param_16,undefined1 param_17,undefined1 param_18)

 

 {

-  undefined4 uVar1;

-  undefined4 uVar2;

-  undefined8 uVar3;

-  longlong lVar4;

-  undefined2 uVar5;

-  int iVar6;

-  undefined8 unaff_RBX;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

-  undefined4 *unaff_R13;

-  longlong unaff_R14;

-  longlong unaff_R15;

+  undefined4 *puVar1;

+  longlong lVar2;

+  byte bVar3;

+  undefined4 uVar4;

+  undefined4 uVar5;

+  char cVar6;

+  undefined1 uVar7;

+  int iVar8;

+  int iVar9;

+  uint uVar10;

+  longlong *plVar11;

+  longlong *plVar12;

+  uint uVar13;

+  undefined8 *puVar14;

+  undefined4 uVar15;

+  undefined1 local_148 [32];

+  longlong *local_128;

+  longlong *local_120;

+  undefined8 local_118;

+  undefined8 local_110;

+  undefined8 local_108;

+  uint local_100;

+  uint local_f8;

+  uint local_f0;

+  uint local_e8;

+  uint local_e0;

+  uint local_d8;

+  uint local_d0;

+  undefined8 local_c8;

+  longlong *local_c0;

+  uint local_b8;

+  undefined8 local_b0;

+  uint local_a8;

+  uint local_a0;

+  uint local_98;

+  int local_90;

+  int local_88;

+  char local_84;

+  char local_83;

+  undefined2 local_80;

+  undefined1 local_7e;

+  longlong *local_78;

+  undefined4 local_70;

+  undefined8 local_68;

+  ulonglong uStack_60;

+  undefined1 *local_58;

+  undefined4 local_48;

+  undefined4 uStack_44;

+  uint uStack_40;

+  undefined4 uStack_3c;

   

-  if (*(ulonglong *)(unaff_R14 + 0x760) == (ulonglong)*(uint *)(unaff_RDI + 0x760)) {

-    iVar6 = -0x3ffffff3;

-    WPP_RECORDER_SF_dZZqqd();

+  local_58 = local_148;

+  local_88 = 0xc0000001;

+  local_83 = 0;

+  local_78 = (longlong *)0x0;

+  local_80 = 0;

+  local_7e = 0;

+  local_84 = '\0';

+  local_70 = 0;

+  VmsOmObjectLockExclusive(param_1,&local_80,0);

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

+    local_88 = 0xc0000010;

+    local_118 = CONCAT44(local_118._4_4_,0xc0000010);

+    local_120 = (longlong *)CONCAT44(local_120._4_4_,*(int *)(param_1 + 0x750));

+    local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    WPP_RECORDER_SF_ld(VmsIfrNicLog,2,0x14,0xf);

+    _local_unwind(local_148,0x1401976e9);

+  }

+  *(undefined4 *)(param_1 + 0x750) = 3;

+  local_83 = '\x01';

+  NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38),&local_80);

+  *(undefined8 *)(param_1 + 0xcd0) = param_7;

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

+LAB_0:

+    uVar7 = 1;

   }

   else {

-    iVar6 = 0;

-  }

-  NdisReleaseRWLock(VmsOmObjectListLock,unaff_RBP + -0x18);

-  if (iVar6 != 0) goto LAB_0;

-  uVar1 = *(undefined4 *)(unaff_RDI + 0xd08);

-  uVar3 = *(undefined8 *)(unaff_RDI + 0x760);

-  *(undefined2 *)(unaff_RBP + 0x58) = *(undefined2 *)(unaff_RDI + 0xd0c);

-  *(undefined4 *)(unaff_RDI + 0xd08) = *unaff_R13;

-  *(undefined2 *)(unaff_RDI + 0xd0c) = *(undefined2 *)(unaff_R13 + 1);

-  *(undefined4 *)(unaff_RDI + 0x72e) = *unaff_R13;

-  *(undefined2 *)(unaff_RDI + 0x732) = *(undefined2 *)(unaff_R13 + 1);

-  VmsOmObjectLockExclusive(uVar3,unaff_RBP + -0x1c,0);

-  VmsOmObjectLockExclusive();

-  lVar4 = *(longlong *)(unaff_R15 + 0x510);

-  *(undefined8 *)(unaff_RBP + -8) = *(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x5e0);

-  if (lVar4 == 0) {

-    iVar6 = -0x3fdcffd2;

-    WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14,0x125);

-    NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

-    NdisReleaseRWLock(*(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x38),unaff_RBP + -0x1c);

-    goto LAB_0;

-  }

-  iVar6 = *(int *)(unaff_R15 + 0x880);

-  if (iVar6 == 1) {

-    uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

-    *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

-    *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

-    uVar5 = *(undefined2 *)(unaff_R15 + 0x888);

+    cVar6 = HviIsKernelApertureAvailable();

+    uVar7 = 0;

+    if (cVar6 == '\0') goto LAB_0;

+  }

+  *(undefined1 *)(param_1 + 0x755) = uVar7;

+  bVar3 = *param_5;

+  if (((bVar3 & 1) == 0) && ((*(int *)param_5 != 0 || (*(short *)(param_5 + 4) != 0)))) {

+    *(int *)(param_1 + 0xd0e) = *(int *)param_5;

+    *(undefined2 *)(param_1 + 0xd12) = *(undefined2 *)(param_5 + 4);

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

+    local_128 = (longlong *)&local_84;

+    VmsOmNicAssignMacAddress(param_1,param_5,param_6,puVar1);

+    if ((local_84 == '\0') || (param_6 != 0)) {

+      uVar15 = *puVar1;

+      *puVar1 = uVar15;

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

+      *(undefined4 *)(param_1 + 0x72e) = uVar15;

+      *(undefined2 *)(param_1 + 0x732) = *(undefined2 *)(param_1 + 0xd0c);

+      *(undefined4 *)(param_1 + 0x838) = *(undefined4 *)param_5;

+      *(undefined2 *)(param_1 + 0x83c) = *(undefined2 *)(param_5 + 4);

+      *(undefined4 *)(param_1 + 0x728) = *(undefined4 *)param_5;

+      *(undefined2 *)(param_1 + 0x72c) = *(undefined2 *)(param_5 + 4);

+      plVar11 = (longlong *)ExAllocatePool2(0x40,0x640,0x4e567356);

+      local_78 = plVar11;

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

+        local_88 = -0x3fffff66;

+        local_118 = CONCAT44(local_118._4_4_,0xc000009a);

+        local_120 = (longlong *)CONCAT44(local_120._4_4_,0x640);

+        local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+        WPP_RECORDER_SF_Ld(VmsIfrNicLog);

+      }

+      else {

+        uVar13 = 0x300;

+        if (param_11 < 0x300) {

+          uVar13 = param_11;

+        }

+        *(uint *)((longlong)plVar11 + 0x35c) = uVar13;

+        *(undefined4 *)(plVar11 + 0x41) = 0;

+        *(undefined4 *)((longlong)plVar11 + 0x20c) = 3;

+        *(undefined4 *)(plVar11 + 0x20) = 0;

+        *(undefined4 *)(plVar11 + 0x58) = 0x1c;

+        *(undefined4 *)(plVar11 + 0x4b) = 1;

+        *(undefined1 *)(plVar11 + 0x43) = 1;

+        plVar12 = plVar11 + 0x61;

+        plVar11[0x62] = (longlong)plVar12;

+        *plVar12 = (longlong)plVar12;

+        memset((void *)(param_1 + 0xd84),0,0x60);

+        *(byte *)(plVar11 + 0x74) = param_12;

+        plVar11[0x55] = param_1;

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

+        plVar12 = plVar11 + 0xaf;

+        plVar11[0xb0] = (longlong)plVar12;

+        *plVar12 = (longlong)plVar12;

+        plVar12 = plVar11 + 0xb1;

+        plVar11[0xb2] = (longlong)plVar12;

+        *plVar12 = (longlong)plVar12;

+        local_128 = plVar11 + 0xaa;

+        local_88 = NvIoCreateContext();

+        param_11 = uVar13;

+        if ((-1 < local_88) &&

+           (local_88 = VmsVmNicPvtCreateNetBufferListPool(plVar11), -1 < local_88)) {

+          *(undefined4 *)(plVar11 + 0x30) = 0;

+          *(undefined1 *)((longlong)plVar11 + 0x321) = 0;

+          plVar11[0x65] = 0;

+          plVar12 = (longlong *)(param_1 + 0x830);

+          if (*plVar12 == 0) {

+            local_120 = (longlong *)0x1401d0998;

+            local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+            WPP_RECORDER_SF_s(VmsIfrLog);

+            if (*plVar12 == 0) {

+              MicrosoftTelemetryAssertTriggeredNoArgsKM();

+            }

+          }

+          puVar14 = (undefined8 *)(param_1 + 0x830);

+          local_120 = plVar11 + 0x66;

+          local_128 = (longlong *)0x3;

+          local_88 = NvIoAllocateWorkItem(*plVar12,1,VmsOmNicCompleteUpLinkChangeIrp,plVar11);

+          if (local_88 < 0) {

+            local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+            local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+            WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+          }

+          else {

+            plVar11[0x67] = 0;

+            local_120 = plVar11 + 0x68;

+            local_128 = (longlong *)0x4;

+            local_88 = NvIoAllocateWorkItem

+                                 (*plVar12,1,VmsOmNicCompleteHwOptimizationChangeIrp,plVar11);

+            if (local_88 < 0) {

+              local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+              local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+              WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+            }

+            else {

+              lVar2 = param_1 + 0x1fe8;

+              *(longlong *)(param_1 + 0x1ff0) = lVar2;

+              *(longlong *)lVar2 = lVar2;

+              local_120 = plVar11 + 0x6a;

+              local_128 = (longlong *)0x2;

+              local_88 = NvIoAllocateWorkItem(*puVar14,1,VmsIovRevokeVFIfAssignedWorkItem,plVar11);

+              if (local_88 < 0) {

+                local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+                local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14,0x16);

+              }

+              else {

+                local_120 = plVar11 + 0xab;

+                local_128 = (longlong *)0xb;

+                local_88 = NvIoAllocateWorkItem(*puVar14,1,VmsVmnicPvtAllocateVmqWorkItem,plVar11);

+                if (local_88 < 0) {

+                  local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+                  local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                  WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+                }

+                else {

+                  local_120 = plVar11 + 0xad;

+                  local_128 = (longlong *)0xc;

+                  local_88 = NvIoAllocateWorkItem

+                                       (*puVar14,1,VmsVmNicUpdateExtensionsWorkItem,plVar11);

+                  if (local_88 < 0) {

+                    local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+                    local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                    WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+                  }

+                  else {

+                    local_120 = plVar11 + 0xb3;

+                    local_128 = (longlong *)0xd;

+                    local_88 = NvIoAllocateWorkItem(*puVar14,1,VmsVmNicIcmpEchoWorkRoutine,plVar11);

+                    if (local_88 < 0) {

+                      local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+                      local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                      WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+                    }

+                    else {

+                      iVar9 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+                      if (iVar9 != 0) {

+                        ExInitializeRundownProtection(plVar11 + 0xb4);

+                      }

+                      local_88 = VmbConvertVmbusHandleToKernelHandle(param_8,plVar11 + 1);

+                      if (local_88 < 0) {

+                        local_118 = CONCAT44(local_118._4_4_,local_88);

+                        local_120 = param_8;

+                        local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                        WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14);

+                      }

+                      else {

+                        local_88 = VmsQueueGroupInitialize(param_1 + 0x1640);

+                        if (local_88 < 0) {

+                          local_120 = (longlong *)CONCAT44(local_120._4_4_,local_88);

+                          local_128 = (longlong *)&WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                          WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14);

+                        }

+                        else {

+                          VmsScalerInitialize(param_1 + 0x1f80,1,param_1);

+                          local_88 = VmsQueueGroupPushScaler(param_1 + 0x1640,param_1 + 0x1f80);

+                          if (local_88 == 0) {

+                            *(uint *)(param_1 + 0x1668) =

+                                 ((uint)param_16 << 6 ^ *(uint *)(param_1 + 0x1668)) & 0x40 ^

+                                 *(uint *)(param_1 + 0x1668);

+                            *(undefined1 *)(param_1 + 0x1ff8) = param_17;

+                            local_120 = (longlong *)CONCAT71(local_120._1_7_,param_18);

+                            local_128 = param_15;

+                            local_88 = VmsVmNicChannelAllocatePrimaryChannel

+                                                 (plVar11,param_9,param_10,param_14);

+                            if (-1 < local_88) {

+                              *(undefined1 *)(plVar11 + 0x54) = 1;

+                              KeInitializeMutex(plVar11 + 0x97,0xffff);

+                              *(undefined4 *)(plVar11 + 0x96) = 1;

+                              if ((param_13 == 0) ||

+                                 (local_88 = VmsVmPDInitializeGuestPacketDirect(param_1,plVar11),

+                                 -1 < local_88)) {

+                                *(undefined4 *)(plVar11 + 0x38) = 7;

+                                if ((2 < (byte)(WPP_GLOBAL_Control[0x29] - 1)) ||

+                                   (*(short *)(WPP_GLOBAL_Control + 0x48) != 0)) {

+                                  local_128 = (longlong *)

+                                              &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                                  WPP_RECORDER_SF_(*(undefined8 *)(WPP_GLOBAL_Control + 0x40),0,10);

+                                }

+                                *(undefined4 *)((longlong)plVar11 + 0x204) = 1;

+                                local_88 = VmsVmNicPvtCreateRndisDevice(plVar11);

+                                if (-1 < local_88) {

+                                  local_88 = VmbChannelEnable(plVar11[2]);

+                                  if (local_88 < 0) {

+                                    local_118 = CONCAT44(local_118._4_4_,local_88);

+                                    local_120 = (longlong *)plVar11[2];

+                                    local_128 = (longlong *)

+                                                &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+                                    WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14);

+                                  }

+                                  else {

+                                    local_68 = 0;

+                                    uVar15 = local_48;

+                                    uVar4 = uStack_44;

+                                    uVar5 = uStack_3c;

+                                    do {

+                                      uStack_3c = uVar5;

+                                      uStack_44 = uVar4;

+                                      local_48 = uVar15;

+                                      uVar13 = *(uint *)(plVar11 + 0x10);

+                                      uStack_60 = (ulonglong)uVar13;

+                                      if ((uVar13 - 1 & 0xfffffffb) != 0) {

+                                        local_120 = (longlong *)CONCAT44(local_120._4_4_,uVar13);

+                                        local_128 = (longlong *)

+                                                    &WPP_7f9c2ac2fa983072b55dd04e2689be0b_Traceguids

+                                        ;

+                                        uVar15 = WPP_RECORDER_SF_L(VmsIfrLog,2,0x14);

+                                        MicrosoftTelemetryAssertTriggeredArgsMsgKM

+                                                  (uVar15,uVar13,0,

+                                                   "VmsVmChannelStateMarkEnabled: unexpected state")

+                                        ;

+                                        goto LAB_1;

+                                      }

+                                      local_48 = 0;

+                                      uStack_44 = 0;

+                                      uStack_3c = 0;

+                                      uStack_40 = uVar13 | 2;

+                                      LOCK();

+                                      uVar10 = *(uint *)(plVar11 + 0x10);

+                                      if (uVar13 == uVar10) {

+                                        *(uint *)(plVar11 + 0x10) = uStack_40;

+                                        uVar10 = uVar13;

+                                      }

+                                      UNLOCK();

+                                      uVar15 = 0;

+                                      uVar4 = 0;

+                                      uVar5 = 0;

+                                    } while (uVar10 != uVar13);

+                                    ExReInitializeRundownProtection();

 LAB_1:

-    *(undefined2 *)(unaff_RBP + -10) = uVar5;

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

+                                    local_88 = RndisDevChannelInit(*plVar11,0);

+                                    if (-1 < local_88) {

+                                      VmsVmNicPvtCreateControlPacketPool(plVar11);

+                                      *(undefined4 *)(plVar11 + 0x1e) = 0;

+                                      *(undefined4 *)((longlong)plVar11 + 0xf4) = 0;

+                                      *(undefined4 *)(plVar11 + 0x1f) = 0;

+                                      RtlCopyUnicodeString(param_1 + 0x268,param_2);

+                                      RtlCopyUnicodeString(param_1 + 0x508,param_2);

+                                      RtlCopyUnicodeString(param_1 + 0x840,param_3);

+                                      RtlCopyUnicodeString(param_1 + 0xa50,param_4);

+                                      *(code **)(param_1 + 0xcf8) = VmsVmNicPvtContextCleanup;

+                                      *(code **)(param_1 + 0xd00) = VmsVmNicPvtPrepareForDelete;

+                                      *(undefined4 *)(param_1 + 0x750) = 3;

+                                      *(code **)(param_1 + 0xc68) = VmsVmNicPvtPacketForward;

+                                      *(code **)(param_1 + 0xc60) = VmsVmNicPvtPacketRouted;

+                                      *(code **)(param_1 + 0xc80) = VmsVmNicPvtLinkStateChanged;

+                                      *(code **)(param_1 + 0xc88) = VmsVmNicPvtSendStatus;

+                                      *(code **)(param_1 + 0xc90) = VmsVmNicPvtSendRelearnPacket;

+                                      *(code **)(param_1 + 0xc98) = VmsVmNicPvtEnableOptimizations;

+                                      *(code **)(param_1 + 0xca0) = VmsVmNicPvtDisableOptimizations;

+                                      *(code **)(param_1 + 0xcb0) = VmsVmNicPvtSetPortInfo;

+                                      *(code **)(param_1 + 0xcb8) = VmsVmNicPvtPacketShortLifetime;

+                                      *(code **)(param_1 + 0xcc0) = VmsVmNicPvtDeliverPDBuffers;

+                                      *(code **)(param_1 + 0xca8) = VmsVmNicPvtAllowRef;

+                                      VmsOmNicPacketFilterAssign(param_1,0);

+                                      if (g_NVBugFixes2611Enabled != 0) {

+                                        LOCK();

+                                        UNLOCK();

+                                      }

+                                      *(undefined4 *)(param_1 + 0x44) = 1;

+                                      local_88 = 0;

+                                    }

+                                  }

+                                }

+                              }

+                            }

+                          }

+                        }

+                      }

+                    }

+                  }

+                }

+              }

+            }

+          }

+        }

+      }

+      goto LAB_2;

+    }

+    local_88 = -0x3fffffe8;

+    bVar3 = *param_5;

+    local_f0 = 0xc0000018;

   }

   else {

-    if (iVar6 == 2) {

-      uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

-      *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

-      *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

-      uVar5 = *(undefined2 *)(unaff_R15 + 0x88a);

-      goto LAB_1;

+    local_88 = -0x3ffffff3;

+    local_f0 = 0xc000000d;

+  }

+  local_f8 = (uint)param_5[5];

+  local_100 = (uint)param_5[4];

+  local_108 = CONCAT44(local_108._4_4_,(uint)param_5[3]);

+  local_110 = CONCAT44(local_110._4_4_,(uint)param_5[2]);

+  local_118 = CONCAT44(local_118._4_4_,(uint)param_5[1]);

+  local_120 = (longlong *)CONCAT44(local_120._4_4_,(uint)bVar3);

+  WPP_RECORDER_SF_DDDDDDd();

+LAB_2:

+  iVar9 = local_88;

+  if (local_88 < 0) {

+    VmsQueueGroupUninitialize(param_1 + 0x1640);

+    plVar11 = local_78;

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

+      if (local_78[0xaa] != 0) {

+        NvIoDeleteContext();

+        plVar11[0xaa] = 0;

+      }

+      VmsVmbDestroyChannels(plVar11);

+      VmsVmNicPvtPauseHostStack(plVar11[0x55]);

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

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

+      if (*plVar11 != 0) {

+        RndisDevDestroy();

+        *plVar11 = 0;

+      }

+      if (plVar11[0x1c] != 0) {

+        NdisFreeNetBufferListPool();

+        plVar11[0x1c] = 0;

+      }

+      if (plVar11[0x1d] != 0) {

+        NdisFreeNetBufferListPool();

+        plVar11[0x1d] = 0;

+      }

+      NvIoFreeWorkItem(plVar11 + 0x66);

+      NvIoFreeWorkItem(plVar11 + 0x68);

+      NvIoFreeWorkItem(plVar11 + 0x6a);

+      NvIoFreeWorkItem(plVar11 + 0xab);

+      NvIoFreeWorkItem(plVar11 + 0xad);

+      NvIoFreeWorkItem(plVar11 + 0xb3);

+      iVar8 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+      if (iVar8 == 0) {

+        VmsOmObjectLockExclusive(param_1,&local_80,0);

+        if ((longlong *)plVar11[0xaf] != plVar11 + 0xaf) {

+          VmsVmNicFlushIcmpRequestIrps(plVar11);

+        }

+        NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38),&local_80);

+      }

+      else {

+        VmsVmNicFlushIcmpRequestIrpsWithRundown(plVar11);

+      }

+      if (plVar11[1] != 0) {

+        ZwClose();

+        plVar11[1] = 0;

+      }

+      ExFreePoolWithTag(plVar11,0);

     }

-    if (iVar6 == 3) {

-      uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

-      *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

-      *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

-      uVar5 = *(undefined2 *)(unaff_R15 + 0x88c);

-      goto LAB_1;

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

+      VmsOmObjectLockExclusive(param_1,&local_80,0);

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

+      NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38),&local_80);

     }

-    WPP_RECORDER_SF_s(VmsIfrNicLog);

-    MicrosoftTelemetryAssertTriggeredNoArgsKM();

-  }

-  iVar6 = VmsRouterUpdateMacSpoofing

-                    (*(undefined8 *)(unaff_RBP + -8),lVar4,unaff_RBX,

-                     *(char *)(unaff_R15 + 6000) == '\0',*(char *)(unaff_R15 + 6000));

-  NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

-  NdisReleaseRWLock(*(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x38),unaff_RBP + -0x1c);

-  if (-1 < iVar6) {

-    iVar6 = VmsIovUpdateVfMacFilters();

-    if (-1 < iVar6) {

-      *(undefined2 *)(unaff_RDI + 0xd18) = *(undefined2 *)(unaff_RBP + 0x58);

-      *(undefined4 *)(unaff_RDI + 0xd14) = uVar1;

-      VmsOmNicUpdateExtensions(unaff_RDI + 0x4d0);

-      goto LAB_0;

-    }

-  }

-  uVar5 = *(undefined2 *)(unaff_RBP + 0x58);

-  *(undefined2 *)(unaff_RDI + 0xd0c) = uVar5;

-  *(undefined2 *)(unaff_RDI + 0x732) = uVar5;

-  *(undefined4 *)(unaff_RDI + 0xd08) = uVar1;

-  *(undefined4 *)(unaff_RDI + 0x72e) = uVar1;

-LAB_0:

-  KeReleaseMutex(&VmsOmIoctlMutex,0);

-  if (iVar6 < 0) {

-    WPP_RECORDER_SF_qqld(VmsIfrNicLog);

-  }

-  return iVar6;

+  }

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

+    iVar9 = -0x3fffffe8;

+  }

+  if (iVar9 < 0) {

+    local_98 = (uint)param_13;

+    local_a0 = (uint)param_12;

+    local_a8 = param_11;

+    local_b0 = param_10;

+    local_b8 = (uint)param_9;

+    local_c0 = param_8;

+    local_c8 = param_7;

+    local_d0 = (uint)param_6;

+    local_d8 = (uint)param_5[5];

+    local_e0 = (uint)param_5[4];

+    local_e8 = (uint)param_5[3];

+    local_f0 = (uint)param_5[2];

+    local_f8 = (uint)param_5[1];

+    local_100 = (uint)*param_5;

+    local_120 = (longlong *)param_1;

+    local_118 = param_2;

+    local_110 = param_3;

+    local_108 = param_4;

+    local_90 = iVar9;

+    WPP_RECORDER_SF_qZZZDDDDDDdIqdqLddd();

+  }

+  return iVar9;

 }
```

## `VmsVmNicPendIcmpEchoRequestIrp`  (modified)

```diff
--- VmsVmNicPendIcmpEchoRequestIrp
+++ VmsVmNicPendIcmpEchoRequestIrp
@@ -1,312 +1,94 @@
 

-/* WARNING: Instruction at (ram,0x0001401984cd) overlaps instruction at (ram,0x0001401984cc)

-    */

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

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

-

-undefined8 * VmsVmNicPendIcmpEchoRequestIrp(void)

+undefined8 VmsVmNicPendIcmpEchoRequestIrp(longlong param_1,longlong param_2)

 

 {

-  uint uVar1;

-  undefined4 uVar2;

-  longlong lVar3;

-  uint uVar4;

-  longlong lVar5;

-  undefined8 uVar6;

-  undefined8 *puVar7;

-  int *piVar8;

-  longlong lVar9;

-  uint uVar10;

-  int *piVar11;

-  uint *puVar12;

-  uint *puVar13;

-  longlong unaff_RBX;

-  int iVar14;

-  ulonglong unaff_RBP;

-  uint uVar15;

-  ulonglong uVar16;

-  ulonglong uVar17;

-  uint *puVar18;

-  uint *puVar19;

-  uint unaff_EDI;

-  uint *puVar20;

-  void *in_R10;

-  longlong *unaff_R12;

-  uint unaff_R13D;

-  undefined8 *unaff_R14;

-  undefined8 *puVar21;

-  void *unaff_R15;

-  bool bVar22;

-  uint uStack0000000000000030;

-  int iStack0000000000000034;

-  uint uStack0000000000000038;

-  uint uStack000000000000003c;

-  uint in_stack_00000040;

-  void *in_stack_00000048;

-  longlong in_stack_00000050;

-  undefined8 *in_stack_00000058;

-  undefined8 *in_stack_00000060;

-  longlong in_stack_00000068;

+  byte *pbVar1;

+  longlong lVar2;

+  undefined8 uVar3;

+  code *pcVar4;

+  char cVar5;

+  int iVar6;

+  longlong lVar7;

+  longlong *plVar8;

+  undefined1 *puVar9;

+  undefined8 uVar10;

+  longlong *plVar11;

+  undefined2 local_res8;

+  undefined1 local_resa;

+  undefined1 auStack_58 [8];

+  undefined1 auStack_50 [24];

+  undefined *local_38;

+  char *local_30;

+  ulonglong local_28;

+  undefined4 local_20;

   

-  *(char *)(unaff_RBP + 0x75) = *(char *)(unaff_RBP + 0x75) << 4;

-  bVar22 = *(int *)(unaff_RBX + 0x14) == (int)unaff_RBX;

-code_r0x0001401984d5:

-  if (!bVar22) {

-    BLFlushBatchOpContextEx();

-    in_R10 = in_stack_00000048;

+  puVar9 = auStack_58;

+  lVar2 = *(longlong *)(param_2 + 0xcf0);

+  local_res8 = 0;

+  local_resa = 0;

+  if (lVar2 == 0) {

+    local_30 = "vmNicExt != NULL";

+    local_38 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    WPP_RECORDER_SF_s(VmsIfrLog,param_2,0x13,0x144);

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

   }

-  if (((byte)*(undefined4 *)(unaff_RBX + 8) & 5) == 5) goto LAB_0;

-LAB_1:

-  if ((unaff_RBX == 0) || (((byte)*(undefined4 *)(unaff_RBX + 8) & 6) != 6)) {

-    memmove(unaff_R15,in_R10,unaff_RBP & 0xffffffff);

+  pbVar1 = (byte *)(*(longlong *)(param_1 + 0xb8) + 3);

+  *pbVar1 = *pbVar1 | 1;

+  LOCK();

+  lVar7 = *(longlong *)(param_1 + 0x68);

+  *(longlong *)(param_1 + 0x68) = (longlong)VmsVmNicIcmpEchoIrpCancelRoutine;

+  UNLOCK();

+  if (lVar7 != 0) {

+    local_30 = "PreviousCancelRoutine == NULL";

+    local_38 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    WPP_RECORDER_SF_s(VmsIfrLog);

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

+  }

+  uVar10 = 0x103;

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

+LAB_0:

+    iVar6 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+    if (iVar6 != 0) {

+      cVar5 = ExAcquireRundownProtection(lVar2 + 0x5a0);

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

+        LOCK();

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

+        UNLOCK();

+        goto LAB_1;

+      }

+    }

+    VmsOmObjectLockExclusive(param_2,&local_res8,0);

+    lVar7 = lVar2 + 0x578;

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

+    plVar8 = *(longlong **)(lVar2 + 0x580);

+    if (*plVar8 != lVar7) {

+      plVar8 = (longlong *)0x3;

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

+      lVar7 = (*pcVar4)();

+      puVar9 = auStack_50;

+    }

+    *plVar11 = lVar7;

+    *(longlong **)(param_1 + 0xb0) = plVar8;

+    *plVar8 = (longlong)plVar11;

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

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

+    *(undefined8 *)(puVar9 + -8) = 0x140198c59;

+    NdisReleaseRWLock(uVar3,puVar9 + 0x60);

   }

   else {

-LAB_0:

-    (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x20))();

-    memmove(unaff_R15,in_stack_00000048,unaff_RBP & 0xffffffff);

-    (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x28))();

+    LOCK();

+    lVar7 = *(longlong *)(param_1 + 0x68);

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

+    UNLOCK();

+    if (lVar7 == 0) goto LAB_0;

+LAB_1:

+    uVar10 = 0xc0000120;

+    local_20 = 0xc0000120;

+    local_28 = -(ulonglong)(param_2 != 0) & param_2 + 0x268U;

+    local_38 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    local_30 = (char *)param_2;

+    WPP_RECORDER_SF_qZd(VmsIfrLog,CONCAT71((int7)(local_28 >> 8),2),0x14,0x146);

   }

-LAB_2:

-  MmBuildMdlForNonPagedPool(unaff_R14);

-  do {

-    puVar21 = unaff_R14;

-    puVar7 = puVar21;

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

-      *in_stack_00000060 = puVar21;

-      puVar7 = in_stack_00000058;

-    }

-    in_stack_00000058 = puVar7;

-    iVar14 = (int)unaff_RBP;

-    unaff_R13D = unaff_R13D - iVar14;

-    uVar17 = (ulonglong)uStack0000000000000030;

-    uStack0000000000000038 = uStack0000000000000038 + iVar14;

-    unaff_EDI = unaff_EDI - iVar14;

-    uVar16 = (ulonglong)uStack0000000000000038;

-    while (unaff_R13D == 0) {

-      unaff_R12 = (longlong *)*unaff_R12;

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

-        BLFlushBatchOpContextEx();

-        puVar12 = (uint *)0x0;

-        puVar13 = puVar12;

-        puVar7 = in_stack_00000058;

-        puVar18 = puVar12;

-        puVar20 = puVar12;

-        goto LAB_3;

-      }

-      unaff_R13D = *(uint *)(unaff_R12 + 5);

-      uStack0000000000000038 = 0;

-      in_stack_00000050 = 0;

-      if ((unaff_EDI < unaff_R13D) || (uVar16 = 0, uStack000000000000003c != 0)) {

-        if ((*(byte *)((longlong)unaff_R12 + 10) & 5) == 0) {

-          in_stack_00000050 = MmMapLockedPagesSpecifyCache(unaff_R12,0,1,0,0);

-        }

-        else {

-          in_stack_00000050 = unaff_R12[3];

-        }

-        uVar16 = 0;

-        if (in_stack_00000050 == 0) goto LAB_4;

-      }

-    }

-    uVar4 = uStack000000000000003c;

-    in_stack_00000060 = puVar21;

-    if (unaff_EDI == 0) {

-      if ((((unaff_R13D < 0x2c) || (7 < uStack0000000000000030)) ||

-          ((uStack0000000000000030 == 0 && (*(int *)(uVar16 + in_stack_00000050) != 1)))) ||

-         (unaff_EDI = ((int *)(uVar16 + in_stack_00000050))[1], unaff_EDI < 0x2c))

-      goto LAB_4;

-      uStack0000000000000030 = uStack0000000000000030 + 1;

-      *(uint *)(&stack0x00000070 + uVar17 * 4) = unaff_EDI;

-      uStack000000000000003c = unaff_EDI;

-      uVar4 = VmsSafeHeaderSize + DAT_5;

-      if (unaff_EDI < (uint)(VmsSafeHeaderSize + DAT_5)) goto LAB_1401983c2;

-    }

-    uStack000000000000003c = uVar4;

-    if (uStack000000000000003c != 0) goto LAB_6;

-    uVar16 = (ulonglong)*(uint *)((longlong)unaff_R12 + 0x2c) + unaff_R12[4] + uVar16;

-    uVar4 = unaff_R13D;

-    if (unaff_EDI < unaff_R13D) {

-      uVar4 = unaff_EDI;

-    }

-    if (uVar4 < 0x40000) {

-      uVar4 = unaff_R13D;

-      if (unaff_EDI < unaff_R13D) {

-        uVar4 = unaff_EDI;

-      }

-      unaff_RBP = (ulonglong)uVar4;

-    }

-    else {

-      unaff_RBP = 0x40000;

-    }

-    MmSizeOfMdl(uVar16,unaff_RBP);

-    uVar6 = PplpRetrieveListIndex(DAT_7,in_stack_00000040);

-    unaff_R14 = (undefined8 *)ExAllocateFromLookasideListEx(uVar6);

-    if (unaff_R14 == (undefined8 *)0x0) goto LAB_4;

-    iStack0000000000000034 = iStack0000000000000034 + DAT_8;

-    *unaff_R14 = 0;

-    *(undefined2 *)((longlong)unaff_R14 + 10) = 0;

-    *(int *)(unaff_R14 + 5) = (int)unaff_RBP;

-    *(uint *)((longlong)unaff_R14 + 0x2c) = (uint)uVar16 & 0xfff;

-    *(short *)(unaff_R14 + 1) = ((short)((uVar16 & 0xfff) + 0xfff + unaff_RBP >> 0xc) + 6) * 8;

-    unaff_R14[4] = uVar16 & 0xfffffffffffff000;

-    IoBuildPartialMdl(unaff_R12,unaff_R14,uVar16);

-  } while( true );

-LAB_3:

-  uVar4 = (uint)puVar13;

-  uVar10 = (uint)puVar12;

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

-    LOCK();

-    *(int *)(in_stack_00000068 + 0x180) =

-         *(int *)(in_stack_00000068 + 0x180) + iStack0000000000000034;

-    UNLOCK();

-    if ((VmsDiagnosticFlags & 4) == 0) {

-      return in_stack_00000058;

-    }

-    LOCK();

-    piVar11 = (int *)((ulonglong)in_stack_00000040 * 0x1540 + 0x1f0 + VmsPlanCpuTable);

-    *piVar11 = *piVar11 + iStack0000000000000034;

-    UNLOCK();

-    return in_stack_00000058;

-  }

-  uVar1 = *(uint *)(puVar7 + 5);

-  puVar19 = puVar18;

-  if (uVar4 == 0) {

-    if ((*(byte *)((longlong)puVar7 + 10) & 5) == 0) {

-      lVar5 = MmMapLockedPagesSpecifyCache(puVar7,0,1,0,0);

-    }

-    else {

-      lVar5 = puVar7[3];

-    }

-    puVar20 = (uint *)(lVar5 + 4);

-    puVar19 = (uint *)(ulonglong)((int)puVar18 + 1);

-    uVar4 = *(uint *)(&stack0x00000070 + (longlong)puVar18 * 4);

-    if ((uVar4 != *puVar20) ||

-       (uVar10 = *(int *)(lVar5 + 0xc) + 8 + *(int *)(lVar5 + 8), uVar4 < uVar10)) {

-LAB_4:

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

-        VmsVmNicFreeShadowMdl(in_stack_00000058,0);

-        in_stack_00000058 = (undefined8 *)0x0;

-      }

-      return in_stack_00000058;

-    }

-  }

-  if (uVar4 < uVar1) goto LAB_4;

-  puVar13 = (uint *)(ulonglong)(uVar4 - uVar1);

-  if (uVar10 < uVar1) {

-    *(uint *)(puVar7 + 5) = uVar10;

-    *puVar20 = *puVar20 + (uVar10 - uVar1);

-  }

-  puVar12 = (uint *)(ulonglong)(uVar10 - *(int *)(puVar7 + 5));

-  puVar7 = (undefined8 *)*puVar7;

-  puVar18 = puVar19;

-  goto LAB_3;

-LAB_6:

-  uVar4 = unaff_R13D;

-  if (uStack000000000000003c < unaff_R13D) {

-    uVar4 = uStack000000000000003c;

-  }

-  unaff_RBP = (ulonglong)uVar4;

-  lVar5 = MmSizeOfMdl(0xfff,unaff_RBP);

-  uStack000000000000003c = uStack000000000000003c - uVar4;

-  uVar6 = PplpRetrieveListIndex(DAT_9,in_stack_00000040);

-  unaff_R14 = (undefined8 *)ExAllocateFromLookasideListEx(uVar6);

-  if (unaff_R14 == (undefined8 *)0x0) goto LAB_4;

-  iStack0000000000000034 = iStack0000000000000034 + DAT_10;

-  unaff_R15 = (void *)(lVar5 + (longlong)unaff_R14);

-  in_R10 = (void *)((ulonglong)uStack0000000000000038 + in_stack_00000050);

-  *unaff_R14 = 0;

-  *(undefined2 *)((longlong)unaff_R14 + 10) = 0;

-  *(uint *)(unaff_R14 + 5) = uVar4;

-  *(uint *)((longlong)unaff_R14 + 0x2c) = (uint)unaff_R15 & 0xfff;

-  *(short *)(unaff_R14 + 1) =

-       ((short)(((ulonglong)unaff_R15 & 0xfff) + 0xfff + unaff_RBP >> 0xc) + 6) * 8;

-  unaff_R14[4] = (ulonglong)unaff_R15 & 0xfffffffffffff000;

-  unaff_R14[3] = unaff_R15;

-  in_stack_00000048 = in_R10;

-  if (unaff_RBX == 0) goto LAB_1;

-  uVar10 = 0;

-  if ((*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') &&

-     (*(char *)(unaff_RBX + 4) == '\0')) {

-    *(undefined1 *)(unaff_RBX + 4) = 1;

-    lVar5 = 0;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-       (lVar9 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 = 0, lVar9 != 0)) {

-      lVar5 = lVar9 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-    }

-    LOCK();

-    *(short *)(lVar5 + 0x10) = *(short *)(lVar5 + 0x10) + 1;

-    UNLOCK();

-  }

-  uVar1 = *(uint *)(*(longlong *)(unaff_RBX + 0x50) + 4);

-  if (uVar1 == 0) {

-    bVar22 = *(int *)(unaff_RBX + 0x14) == 0;

-    goto code_r0x0001401984d5;

-  }

-  puVar7 = *(undefined8 **)(unaff_RBX + 0x20);

-  uVar15 = *(uint *)(puVar7 + 1);

-  if (*(uint *)((longlong)puVar7 + 0xc) <= *(uint *)(puVar7 + 1)) {

-    uVar15 = uVar10;

-    if (*(uint *)(unaff_RBX + 0x10) < uVar1) {

-      puVar7 = (undefined8 *)

-               ExAllocateFromNPagedLookasideList(*(longlong *)(unaff_RBX + 0x50) + 0x40);

-      piVar11 = (int *)0x0;

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

-        *puVar7 = 0;

-        *(undefined4 *)(puVar7 + 1) = 0;

-        uVar2 = *(undefined4 *)(*(longlong *)(unaff_RBX + 0x50) + 8);

-        puVar7[2] = puVar7 + 3;

-        *(undefined4 *)((longlong)puVar7 + 0xc) = uVar2;

-        **(undefined8 **)(unaff_RBX + 0x20) = puVar7;

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

-        *(undefined8 **)(unaff_RBX + 0x20) = puVar7;

-        if (*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') {

-          piVar8 = piVar11;

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-             (lVar5 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 != 0)) {

-            piVar8 = (int *)(lVar5 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-          }

-          LOCK();

-          *(short *)(piVar8 + 3) = (short)piVar8[3] + 1;

-          UNLOCK();

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-             (lVar5 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 != 0)) {

-            piVar11 = (int *)(lVar5 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-          }

-          LOCK();

-          *piVar11 = *piVar11 + 1;

-          UNLOCK();

-        }

-        goto LAB_11;

-      }

-    }

-    BLFlushBatchOpContextEx();

-    puVar7 = (undefined8 *)(unaff_RBX + 0x38);

-  }

-LAB_11:

-  lVar5 = 0;

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

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

-  if (*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') {

-    lVar9 = lVar5;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-       (lVar3 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar3 != 0)) {

-      lVar9 = lVar3 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-    }

-    LOCK();

-    *(short *)(lVar9 + 0xe) = *(short *)(lVar9 + 0xe) + 1;

-    UNLOCK();

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-       (lVar9 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar9 != 0)) {

-      lVar5 = lVar9 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-    }

-    LOCK();

-    *(int *)(lVar5 + 4) = *(int *)(lVar5 + 4) + 1;

-    UNLOCK();

-  }

-  lVar5 = puVar7[2];

-  uVar16 = (ulonglong)uVar15;

-  *(void **)(lVar5 + uVar16 * 0x18) = unaff_R15;

-  *(void **)(lVar5 + 8 + uVar16 * 0x18) = in_R10;

-  *(uint *)(lVar5 + 0x10 + uVar16 * 0x18) = uVar4 << 4 | 1;

-  goto LAB_2;

+  return uVar10;

 }
```

## `VmsVmNicPvtContextCleanup`  (modified)

```diff
--- VmsVmNicPvtContextCleanup
+++ VmsVmNicPvtContextCleanup
@@ -1,312 +1,39 @@
 

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

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

-

-undefined8 * VmsVmNicPvtContextCleanup(undefined4 param_1)

+void VmsVmNicPvtContextCleanup(undefined8 param_1,longlong param_2)

 

 {

-  uint uVar1;

-  undefined4 uVar2;

-  longlong lVar3;

-  uint uVar4;

-  longlong lVar5;

-  undefined8 uVar6;

-  undefined8 *puVar7;

-  int *piVar8;

-  longlong lVar9;

-  ulonglong uVar10;

-  ulonglong in_RAX;

-  uint uVar11;

-  int *piVar12;

-  uint *puVar13;

-  uint *puVar14;

-  longlong unaff_RBX;

-  int iVar15;

-  ulonglong unaff_RBP;

-  uint uVar16;

-  ulonglong unaff_RSI;

-  ulonglong uVar17;

-  uint *puVar18;

-  uint *puVar19;

-  uint unaff_EDI;

-  uint *puVar20;

-  void *_Src;

-  longlong *unaff_R12;

-  uint unaff_R13D;

-  undefined8 *unaff_R14;

-  undefined8 *puVar21;

-  void *_Dst;

-  uint uStack0000000000000030;

-  int iStack0000000000000034;

-  uint uStack0000000000000038;

-  uint uStack000000000000003c;

-  uint in_stack_00000040;

-  longlong in_stack_00000050;

-  undefined8 *in_stack_00000058;

-  undefined8 *in_stack_00000060;

-  longlong in_stack_00000068;

+  int iVar1;

+  undefined2 local_res10;

+  undefined1 local_res12;

   

-  *(undefined4 *)(unaff_R14 + 1) = param_1;

-code_r0x000140198794:

-  unaff_R14[4] = in_RAX & 0xfffffffffffff000;

-  IoBuildPartialMdl(unaff_R12,unaff_R14,unaff_RSI,unaff_RBP & 0xffffffff);

-  do {

-    puVar21 = unaff_R14;

-    puVar7 = puVar21;

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

-      *in_stack_00000060 = puVar21;

-      puVar7 = in_stack_00000058;

+  local_res10 = 0;

+  local_res12 = 0;

+  VmsVmNicPvtVscCleanup();

+  VmsVmNicPvtPauseHostStack(*(undefined8 *)(param_2 + 0x2a8));

+  NvIoFreeWorkItem(param_2 + 0x330);

+  NvIoFreeWorkItem(param_2 + 0x340);

+  NvIoFreeWorkItem(param_2 + 0x350);

+  NvIoFreeWorkItem(param_2 + 0x558);

+  NvIoFreeWorkItem(param_2 + 0x568);

+  NvIoFreeWorkItem(param_2 + 0x598);

+  iVar1 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+  if (iVar1 == 0) {

+    VmsOmObjectLockExclusive(*(undefined8 *)(param_2 + 0x2a8),&local_res10,0);

+    if (*(longlong **)(param_2 + 0x578) != (longlong *)(param_2 + 0x578)) {

+      VmsVmNicFlushIcmpRequestIrps(param_2);

     }

-    in_stack_00000058 = puVar7;

-    iVar15 = (int)unaff_RBP;

-    unaff_R13D = unaff_R13D - iVar15;

-    uVar17 = (ulonglong)uStack0000000000000030;

-    uStack0000000000000038 = uStack0000000000000038 + iVar15;

-    unaff_EDI = unaff_EDI - iVar15;

-    uVar10 = (ulonglong)uStack0000000000000038;

-    while (unaff_R13D == 0) {

-      unaff_R12 = (longlong *)*unaff_R12;

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

-        BLFlushBatchOpContextEx();

-        puVar13 = (uint *)0x0;

-        puVar14 = puVar13;

-        puVar7 = in_stack_00000058;

-        puVar18 = puVar13;

-        puVar20 = puVar13;

-        goto LAB_0;

-      }

-      unaff_R13D = *(uint *)(unaff_R12 + 5);

-      uStack0000000000000038 = 0;

-      in_stack_00000050 = 0;

-      if ((unaff_EDI < unaff_R13D) || (uVar10 = 0, uStack000000000000003c != 0)) {

-        if ((*(byte *)((longlong)unaff_R12 + 10) & 5) == 0) {

-          in_stack_00000050 = MmMapLockedPagesSpecifyCache(unaff_R12,0,1,0,0);

-        }

-        else {

-          in_stack_00000050 = unaff_R12[3];

-        }

-        uVar10 = 0;

-        if (in_stack_00000050 == 0) goto LAB_1;

-      }

-    }

-    uVar4 = uStack000000000000003c;

-    in_stack_00000060 = puVar21;

-    if (unaff_EDI == 0) {

-      if ((((unaff_R13D < 0x2c) || (7 < uStack0000000000000030)) ||

-          ((uStack0000000000000030 == 0 && (*(int *)(uVar10 + in_stack_00000050) != 1)))) ||

-         (unaff_EDI = ((int *)(uVar10 + in_stack_00000050))[1], unaff_EDI < 0x2c))

-      goto LAB_1;

-      uStack0000000000000030 = uStack0000000000000030 + 1;

-      *(uint *)(&stack0x00000070 + uVar17 * 4) = unaff_EDI;

-      uStack000000000000003c = unaff_EDI;

-      uVar4 = VmsSafeHeaderSize + DAT_2;

-      if ((uint)(VmsSafeHeaderSize + DAT_2) <= unaff_EDI) goto LAB_1401983b9;

-    }

-    else {

-LAB_3:

-      uStack000000000000003c = uVar4;

-      if (uStack000000000000003c == 0) goto LAB_4;

-    }

-    uVar4 = unaff_R13D;

-    if (uStack000000000000003c < unaff_R13D) {

-      uVar4 = uStack000000000000003c;

-    }

-    unaff_RBP = (ulonglong)uVar4;

-    lVar5 = MmSizeOfMdl(0xfff,unaff_RBP);

-    uStack000000000000003c = uStack000000000000003c - uVar4;

-    uVar6 = PplpRetrieveListIndex(DAT_5,in_stack_00000040);

-    unaff_R14 = (undefined8 *)ExAllocateFromLookasideListEx(uVar6);

-    if (unaff_R14 == (undefined8 *)0x0) goto LAB_1;

-    iStack0000000000000034 = iStack0000000000000034 + DAT_6;

-    _Dst = (void *)(lVar5 + (longlong)unaff_R14);

-    _Src = (void *)((ulonglong)uStack0000000000000038 + in_stack_00000050);

-    *unaff_R14 = 0;

-    *(undefined2 *)((longlong)unaff_R14 + 10) = 0;

-    *(uint *)(unaff_R14 + 5) = uVar4;

-    *(uint *)((longlong)unaff_R14 + 0x2c) = (uint)_Dst & 0xfff;

-    *(short *)(unaff_R14 + 1) =

-         ((short)(((ulonglong)_Dst & 0xfff) + 0xfff + unaff_RBP >> 0xc) + 6) * 8;

-    unaff_R14[4] = (ulonglong)_Dst & 0xfffffffffffff000;

-    unaff_R14[3] = _Dst;

-    if (unaff_RBX == 0) {

-LAB_7:

-      if ((unaff_RBX == 0) || (((byte)*(undefined4 *)(unaff_RBX + 8) & 6) != 6)) {

-        memmove(_Dst,_Src,unaff_RBP);

-      }

-      else {

-LAB_8:

-        (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x20))();

-        memmove(_Dst,_Src,unaff_RBP);

-        (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x28))();

-      }

-    }

-    else {

-      uVar11 = 0;

-      if ((*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') &&

-         (*(char *)(unaff_RBX + 4) == '\0')) {

-        *(undefined1 *)(unaff_RBX + 4) = 1;

-        lVar5 = 0;

-        if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-           (lVar9 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 = 0, lVar9 != 0)) {

-          lVar5 = lVar9 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-        }

-        LOCK();

-        *(short *)(lVar5 + 0x10) = *(short *)(lVar5 + 0x10) + 1;

-        UNLOCK();

-      }

-      uVar1 = *(uint *)(*(longlong *)(unaff_RBX + 0x50) + 4);

-      if (uVar1 == 0) {

-        if (*(int *)(unaff_RBX + 0x14) != 0) {

-          BLFlushBatchOpContextEx();

-        }

-        if (((byte)*(undefined4 *)(unaff_RBX + 8) & 5) != 5) goto LAB_7;

-        goto LAB_8;

-      }

-      puVar7 = *(undefined8 **)(unaff_RBX + 0x20);

-      uVar16 = *(uint *)(puVar7 + 1);

-      if (*(uint *)((longlong)puVar7 + 0xc) <= *(uint *)(puVar7 + 1)) {

-        uVar16 = uVar11;

-        if (*(uint *)(unaff_RBX + 0x10) < uVar1) {

-          puVar7 = (undefined8 *)

-                   ExAllocateFromNPagedLookasideList(*(longlong *)(unaff_RBX + 0x50) + 0x40);

-          piVar12 = (int *)0x0;

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

-            *puVar7 = 0;

-            *(undefined4 *)(puVar7 + 1) = 0;

-            uVar2 = *(undefined4 *)(*(longlong *)(unaff_RBX + 0x50) + 8);

-            puVar7[2] = puVar7 + 3;

-            *(undefined4 *)((longlong)puVar7 + 0xc) = uVar2;

-            **(undefined8 **)(unaff_RBX + 0x20) = puVar7;

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

-            *(undefined8 **)(unaff_RBX + 0x20) = puVar7;

-            if (*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') {

-              piVar8 = piVar12;

-              if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-                 (lVar5 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 != 0)) {

-                piVar8 = (int *)(lVar5 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-              }

-              LOCK();

-              *(short *)(piVar8 + 3) = (short)piVar8[3] + 1;

-              UNLOCK();

-              if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-                 (lVar5 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar5 != 0)) {

-                piVar12 = (int *)(lVar5 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-              }

-              LOCK();

-              *piVar12 = *piVar12 + 1;

-              UNLOCK();

-            }

-            goto LAB_9;

-          }

-        }

-        BLFlushBatchOpContextEx();

-        puVar7 = (undefined8 *)(unaff_RBX + 0x38);

-      }

-LAB_9:

-      lVar5 = 0;

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

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

-      if (*(char *)(*(longlong *)(unaff_RBX + 0x50) + 1) == '\x01') {

-        lVar9 = lVar5;

-        if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-           (lVar3 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar3 != 0)) {

-          lVar9 = lVar3 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-        }

-        LOCK();

-        *(short *)(lVar9 + 0xe) = *(short *)(lVar9 + 0xe) + 1;

-        UNLOCK();

-        if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-           (lVar9 = *(longlong *)(*(longlong *)(unaff_RBX + 0x50) + 0x18), lVar9 != 0)) {

-          lVar5 = lVar9 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-        }

-        LOCK();

-        *(int *)(lVar5 + 4) = *(int *)(lVar5 + 4) + 1;

-        UNLOCK();

-      }

-      lVar5 = puVar7[2];

-      uVar10 = (ulonglong)uVar16;

-      *(void **)(lVar5 + uVar10 * 0x18) = _Dst;

-      *(void **)(lVar5 + 8 + uVar10 * 0x18) = _Src;

-      *(uint *)(lVar5 + 0x10 + uVar10 * 0x18) = uVar4 << 4 | 1;

-    }

-    MmBuildMdlForNonPagedPool(unaff_R14);

-  } while( true );

-LAB_0:

-  uVar4 = (uint)puVar14;

-  uVar11 = (uint)puVar13;

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

-    LOCK();

-    *(int *)(in_stack_00000068 + 0x180) =

-         *(int *)(in_stack_00000068 + 0x180) + iStack0000000000000034;

-    UNLOCK();

-    if ((VmsDiagnosticFlags & 4) == 0) {

-      return in_stack_00000058;

-    }

-    LOCK();

-    piVar12 = (int *)((ulonglong)in_stack_00000040 * 0x1540 + 0x1f0 + VmsPlanCpuTable);

-    *piVar12 = *piVar12 + iStack0000000000000034;

-    UNLOCK();

-    return in_stack_00000058;

+    NdisReleaseRWLock(*(undefined8 *)(*(longlong *)(param_2 + 0x2a8) + 0x38),&local_res10);

   }

-  uVar1 = *(uint *)(puVar7 + 5);

-  puVar19 = puVar18;

-  if (uVar4 == 0) {

-    if ((*(byte *)((longlong)puVar7 + 10) & 5) == 0) {

-      lVar5 = MmMapLockedPagesSpecifyCache(puVar7,0,1,0,0);

-    }

-    else {

-      lVar5 = puVar7[3];

-    }

-    puVar20 = (uint *)(lVar5 + 4);

-    puVar19 = (uint *)(ulonglong)((int)puVar18 + 1);

-    uVar4 = *(uint *)(&stack0x00000070 + (longlong)puVar18 * 4);

-    if ((uVar4 != *puVar20) ||

-       (uVar11 = *(int *)(lVar5 + 0xc) + 8 + *(int *)(lVar5 + 8), uVar4 < uVar11)) {

-LAB_1:

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

-        VmsVmNicFreeShadowMdl(in_stack_00000058,0);

-        in_stack_00000058 = (undefined8 *)0x0;

-      }

-      return in_stack_00000058;

+  else {

+    VmsVmNicFlushIcmpRequestIrpsWithRundown(param_2);

+  }

+  if (*(int *)(param_2 + 0x180) != 0) {

+    WPP_RECORDER_SF_s(VmsIfrLog);

+    if (*(int *)(param_2 + 0x180) != 0) {

+      MicrosoftTelemetryAssertTriggeredNoArgsKM();

     }

   }

-  if (uVar4 < uVar1) goto LAB_1;

-  puVar14 = (uint *)(ulonglong)(uVar4 - uVar1);

-  if (uVar11 < uVar1) {

-    *(uint *)(puVar7 + 5) = uVar11;

-    *puVar20 = *puVar20 + (uVar11 - uVar1);

-  }

-  puVar13 = (uint *)(ulonglong)(uVar11 - *(int *)(puVar7 + 5));

-  puVar7 = (undefined8 *)*puVar7;

-  puVar18 = puVar19;

-  goto LAB_0;

-LAB_4:

-  in_RAX = (ulonglong)*(uint *)((longlong)unaff_R12 + 0x2c) + unaff_R12[4] + uVar10;

-  uVar4 = unaff_R13D;

-  if (unaff_EDI < unaff_R13D) {

-    uVar4 = unaff_EDI;

-  }

-  if (uVar4 < 0x40000) {

-    uVar4 = unaff_R13D;

-    if (unaff_EDI < unaff_R13D) {

-      uVar4 = unaff_EDI;

-    }

-    unaff_RBP = (ulonglong)uVar4;

-  }

-  else {

-    unaff_RBP = 0x40000;

-  }

-  MmSizeOfMdl(in_RAX,unaff_RBP);

-  uVar6 = PplpRetrieveListIndex(DAT_10,in_stack_00000040);

-  unaff_R14 = (undefined8 *)ExAllocateFromLookasideListEx(uVar6);

-  if (unaff_R14 == (undefined8 *)0x0) goto LAB_1;

-  iStack0000000000000034 = iStack0000000000000034 + DAT_11;

-  *unaff_R14 = 0;

-  *(undefined2 *)((longlong)unaff_R14 + 10) = 0;

-  *(int *)(unaff_R14 + 5) = (int)unaff_RBP;

-  *(uint *)((longlong)unaff_R14 + 0x2c) = (uint)in_RAX & 0xfff;

-  *(short *)(unaff_R14 + 1) = ((short)((in_RAX & 0xfff) + 0xfff + unaff_RBP >> 0xc) + 6) * 8;

-  unaff_RSI = in_RAX;

-  goto code_r0x000140198794;

+  ExFreePoolWithTag(param_2,0);

+  return;

 }
```

## `VmsPtIpsecOffloadDirectOidProcessing`  (modified)

```diff
--- VmsPtIpsecOffloadDirectOidProcessing
+++ VmsPtIpsecOffloadDirectOidProcessing
@@ -1,10 +1,109 @@
 

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

-

-void VmsPtIpsecOffloadDirectOidProcessing(void)

+int VmsPtIpsecOffloadDirectOidProcessing

+              (longlong param_1,int param_2,undefined8 param_3,undefined4 param_4)

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  longlong lVar2;

+  bool bVar3;

+  char cVar4;

+  int iVar5;

+  int iVar6;

+  longlong lVar7;

+  undefined8 in_stack_ffffffffffffff68;

+  undefined4 uVar8;

+  undefined8 in_stack_ffffffffffffff70;

+  undefined4 uVar9;

+  undefined2 local_64;

+  undefined1 local_62;

+  undefined2 local_60;

+  undefined1 local_5e;

+  undefined2 local_5c;

+  undefined1 local_5a;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  

+  uVar8 = (undefined4)((ulonglong)in_stack_ffffffffffffff68 >> 0x20);

+  uVar9 = (undefined4)((ulonglong)in_stack_ffffffffffffff70 >> 0x20);

+  bVar3 = false;

+  local_60 = 0;

+  local_5e = 0;

+  lVar7 = 0;

+  local_64 = 0;

+  local_62 = 0;

+  local_5c = 0;

+  local_5a = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  iVar5 = Feature_1848274234__private_IsEnabledDeviceUsageNoInline();

+  if ((iVar5 != 0) && (cVar4 = VmsOmNicTryReferenceIfConnected(param_1), cVar4 == '\0')) {

+    iVar5 = -0x3fffffff;

+    goto LAB_0;

+  }

+  VmsOmObjectLockShared(param_1,&local_60,0);

+  if ((*(int *)(param_1 + 0x44) == 1) && (*(int *)(param_1 + 0x758) == 1)) {

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

+    VmsOmObjectLockShared(lVar1,&local_64,0);

+    lVar7 = *(longlong *)(lVar1 + 0x10a8);

+    if ((lVar7 != 0) && (*(int *)(lVar7 + 0x44) == 1)) {

+      VmsOmpObjectReference(lVar7,1);

+      lVar2 = *(longlong *)(param_1 + 0x7c0);

+      VmsOmObjectLockShared(lVar2,&local_5c,0);

+      VmsOmpObjectReference(lVar2,0);

+      NdisReleaseRWLock(*(undefined8 *)(lVar2 + 0x38),&local_5c);

+      NdisReleaseRWLock(*(undefined8 *)(lVar1 + 0x38),&local_64);

+      NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38),&local_60);

+      iVar5 = Feature_1848274234__private_IsEnabledDeviceUsageNoInline();

+      if ((iVar5 == 0) || (cVar4 = VmsOmNicTryReferenceIfConnected(lVar7), cVar4 != '\0')) {

+        if (param_2 != -0x3fcfdfd) {

+          if ((param_2 == -0x3fcfdfe) || (param_2 == -0x3fcfdfb)) {

+            iVar5 = VmsPtIpsecPvtAddOidProcessing

+                              (lVar2,lVar7,param_2,param_3,CONCAT44(uVar8,param_4));

+            goto LAB_1;

+          }

+          WPP_RECORDER_SF_s(VmsIfrLog);

+          MicrosoftTelemetryAssertTriggeredNoArgsKM();

+          uVar8 = 1;

+          WPP_RECORDER_SF_s(VmsIfrLog);

+          MicrosoftTelemetryAssertTriggeredNoArgsKM();

+        }

+        iVar5 = VmsPtIpsecPvtDelOidProcessing(lVar2,lVar7,param_2,param_3,CONCAT44(uVar8,param_4));

+      }

+      else {

+        iVar5 = -0x3ffeffef;

+      }

+LAB_1:

+      bVar3 = true;

+      VmsOmpObjectDereference(lVar2,0);

+      goto LAB_0;

+    }

+    iVar5 = -0x3ffeffef;

+    WPP_RECORDER_SF_L(VmsIfrNicLog,2,0x14,0x28,&WPP_10356112ee3331267da04e47a6b3cd93_Traceguids,

+                      CONCAT44(uVar9,0xc0010011));

+    NdisReleaseRWLock(*(undefined8 *)(lVar1 + 0x38),&local_64);

+  }

+  else {

+    iVar5 = -0x3fffffff;

+    WPP_RECORDER_SF_LLd(VmsIfrNicLog,2);

+  }

+  bVar3 = false;

+  NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38),&local_60);

+LAB_0:

+  iVar6 = Feature_1848274234__private_IsEnabledDeviceUsageNoInline();

+  if (iVar6 != 0) {

+    VmsOmNicReleaseReference(&local_58);

+    VmsOmNicReleaseReference(&local_48);

+  }

+  if (bVar3) {

+    VmsOmpObjectDereference(lVar7,1);

+  }

+  if (iVar5 != 0) {

+    WPP_RECORDER_SF_qDqLd();

+  }

+  return iVar5;

 }
```

## `VmsVmNicFindAndDequeueIcmpRequestIrp`  (modified)

```diff
--- VmsVmNicFindAndDequeueIcmpRequestIrp
+++ VmsVmNicFindAndDequeueIcmpRequestIrp
@@ -1,148 +1,62 @@
 

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

-

-void VmsVmNicFindAndDequeueIcmpRequestIrp

-               (undefined8 param_1,undefined8 param_2,undefined8 *param_3,undefined8 param_4,

-               undefined8 param_5,ulonglong param_6)

+longlong * VmsVmNicFindAndDequeueIcmpRequestIrp(longlong param_1,int param_2,int param_3)

 

 {

-  uint uVar1;

-  undefined4 uVar2;

-  longlong lVar3;

-  longlong lVar4;

-  ulonglong uVar5;

-  int *piVar6;

-  longlong unaff_RBX;

-  uint unaff_EBP;

-  undefined8 *unaff_RSI;

-  longlong *unaff_RDI;

-  uint in_R10D;

-  void *in_R11;

-  longlong unaff_R12;

-  void *unaff_R13;

-  char cVar7;

-  short sVar8;

-  uint unaff_R14D;

-  longlong *unaff_R15;

+  longlong lVar1;

+  char *pcVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  longlong *plVar5;

+  int iVar6;

+  longlong *plVar7;

   

-code_r0x000140195a50:

-  *(int *)(unaff_RBX + 0x14) = *(int *)(unaff_RBX + 0x14) + unaff_R14D;

-  *(uint *)(param_3 + 1) = *(int *)(param_3 + 1) + unaff_R14D;

-  cVar7 = (char)unaff_R14D;

-  sVar8 = (short)unaff_R14D;

-  if (*(char *)(*unaff_RDI + 1) == cVar7) {

-    lVar4 = 0;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-       (lVar3 = *(longlong *)(*unaff_RDI + 0x18), lVar3 != 0)) {

-      lVar4 = lVar3 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

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

+  if (lVar1 == 0) {

+    WPP_RECORDER_SF_s(VmsIfrLog,param_2,0x13,0x13f,&WPP_07ff703e40ac37709b78062530a71188_Traceguids,

+                      "vmNicExt != NULL");

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

+  }

+  plVar7 = (longlong *)(lVar1 + 0x578);

+  plVar3 = (longlong *)*plVar7;

+  while( true ) {

+    do {

+      plVar5 = plVar3;

+      if (plVar5 == plVar7) {

+        return (longlong *)0x0;

+      }

+      pcVar2 = (char *)plVar5[-6];

+      plVar3 = (longlong *)*plVar5;

+    } while (((*pcVar2 != '\0') || (*(int *)(pcVar2 + 4) != param_2)) ||

+            (*(int *)(pcVar2 + 8) != param_3));

+    if ((*(longlong *)(pcVar2 + 0x18) == 0) &&

+       (WPP_RECORDER_SF_s(VmsIfrLog), *(longlong *)(pcVar2 + 0x18) == 0)) {

+      MicrosoftTelemetryAssertTriggeredNoArgsKM();

     }

     LOCK();

-    *(short *)(lVar4 + 0xe) = *(short *)(lVar4 + 0xe) + sVar8;

+    lVar1 = plVar5[-8];

+    plVar5[-8] = 0;

     UNLOCK();

-    lVar4 = 0;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) && (*(longlong *)(*unaff_RDI + 0x18) != 0)) {

-      lVar4 = *(longlong *)(*unaff_RDI + 0x18) + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

+    if (lVar1 != 0) break;

+    iVar6 = Feature_4078833978__private_IsEnabledDeviceUsageNoInline();

+    if (iVar6 == 0) {

+      if ((*(char *)((longlong)plVar5 + -100) == '\0') &&

+         (WPP_RECORDER_SF_s(VmsIfrLog), *(char *)((longlong)plVar5 + -100) == '\0')) {

+        MicrosoftTelemetryAssertTriggeredNoArgsKM();

+      }

+      plVar5[1] = (longlong)plVar5;

+      *plVar5 = (longlong)plVar5;

+      return (longlong *)0x0;

     }

-    LOCK();

-    *(int *)(lVar4 + 4) = *(int *)(lVar4 + 4) + unaff_R14D;

-    UNLOCK();

   }

-  lVar4 = param_3[2];

-  uVar5 = (ulonglong)unaff_EBP;

-  *(void **)(lVar4 + uVar5 * 0x18) = unaff_R13;

-  *(void **)(lVar4 + 8 + uVar5 * 0x18) = in_R11;

-  *(uint *)(lVar4 + 0x10 + uVar5 * 0x18) = in_R10D << 4 | unaff_R14D;

-  do {

-    unaff_R15 = (longlong *)*unaff_R15;

-    lVar4 = 0;

-    unaff_R13 = (void *)((longlong)unaff_R13 + (ulonglong)in_R10D);

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

-      BLFlushBatchOpContextEx();

-      *(int *)(unaff_RSI + 5) = (int)unaff_R12;

-      *unaff_RSI = 0;

-      *(undefined2 *)((longlong)unaff_RSI + 10) = 0;

-      unaff_RSI[4] = param_6 & 0xfffffffffffff000;

-      *(short *)(unaff_RSI + 1) = ((short)((param_6 & 0xfff) + 0xfff + unaff_R12 >> 0xc) + 6) * 8;

-      *(uint *)((longlong)unaff_RSI + 0x2c) = (uint)param_6 & 0xfff;

-      MmBuildMdlForNonPagedPool();

-      return;

-    }

-    in_R11 = (void *)unaff_R15[3];

-    in_R10D = *(uint *)(unaff_R15 + 5);

-    if (unaff_RBX == 0) {

-LAB_0:

-      if (unaff_RBX != 0) goto LAB_1;

-LAB_2:

-      memmove(unaff_R13,in_R11,(ulonglong)in_R10D);

-    }

-    else {

-      unaff_RDI = (longlong *)(unaff_RBX + 0x50);

-      if ((*(char *)(*unaff_RDI + 1) != cVar7) || (*(char *)(unaff_RBX + 4) != '\0'))

-      goto LAB_0;

-      *(char *)(unaff_RBX + 4) = cVar7;

-      if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-         (lVar3 = *(longlong *)(*unaff_RDI + 0x18), lVar3 != 0)) {

-        lVar4 = lVar3 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-      }

-      LOCK();

-      *(short *)(lVar4 + 0x10) = *(short *)(lVar4 + 0x10) + sVar8;

-      UNLOCK();

-LAB_1:

-      uVar1 = *(uint *)(*unaff_RDI + 4);

-      if (uVar1 != 0) break;

-      if (*(int *)(unaff_RBX + 0x14) != 0) {

-        BLFlushBatchOpContextEx();

-      }

-      if ((((byte)*(undefined4 *)(unaff_RBX + 8) & 5) != 5) &&

-         ((unaff_RBX == 0 || (((byte)*(undefined4 *)(unaff_RBX + 8) & 6) != 6))))

-      goto LAB_2;

-      (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x20))();

-      memmove(unaff_R13,in_R11,(ulonglong)in_R10D);

-      (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x28))();

-    }

-    unaff_RDI = (longlong *)(unaff_RBX + 0x50);

-  } while( true );

-  param_3 = *(undefined8 **)(unaff_RBX + 0x20);

-  unaff_EBP = *(uint *)(param_3 + 1);

-  if (*(uint *)((longlong)param_3 + 0xc) <= unaff_EBP) {

-    unaff_EBP = 0;

-    if (*(uint *)(unaff_RBX + 0x10) < uVar1) {

-      param_3 = (undefined8 *)ExAllocateFromNPagedLookasideList(*unaff_RDI + 0x40);

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

-        *param_3 = 0;

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

-        uVar2 = *(undefined4 *)(*unaff_RDI + 8);

-        param_3[2] = param_3 + 3;

-        *(undefined4 *)((longlong)param_3 + 0xc) = uVar2;

-        **(undefined8 **)(unaff_RBX + 0x20) = param_3;

-        lVar4 = *unaff_RDI;

-        *(int *)(unaff_RBX + 0x10) = *(int *)(unaff_RBX + 0x10) + unaff_R14D;

-        *(undefined8 **)(unaff_RBX + 0x20) = param_3;

-        if (*(char *)(lVar4 + 1) == cVar7) {

-          lVar3 = 0;

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-             (lVar4 = *(longlong *)(lVar4 + 0x18), lVar3 = 0, lVar4 != 0)) {

-            lVar3 = lVar4 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-          }

-          LOCK();

-          *(short *)(lVar3 + 0xc) = *(short *)(lVar3 + 0xc) + sVar8;

-          UNLOCK();

-          piVar6 = (int *)0x0;

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) && (*(longlong *)(*unaff_RDI + 0x18) != 0))

-          {

-            piVar6 = (int *)(*(longlong *)(*unaff_RDI + 0x18) +

-                            (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-          }

-          LOCK();

-          *piVar6 = *piVar6 + unaff_R14D;

-          UNLOCK();

-        }

-        goto code_r0x000140195a50;

-      }

-    }

-    BLFlushBatchOpContextEx();

-    param_3 = (undefined8 *)(unaff_RBX + 0x38);

+  lVar1 = *plVar5;

+  if ((*(longlong **)(lVar1 + 8) == plVar5) &&

+     (plVar3 = (longlong *)plVar5[1], (longlong *)*plVar3 == plVar5)) {

+    *plVar3 = lVar1;

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

+    return plVar5 + -0x15;

   }

-  goto code_r0x000140195a50;

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

+  (*pcVar4)(3);

+  return (longlong *)0x0;

 }
```

## `VmsVmNicIcmpEchoIrpCancelRoutine`  (modified)

```diff
--- VmsVmNicIcmpEchoIrpCancelRoutine
+++ VmsVmNicIcmpEchoIrpCancelRoutine
@@ -1,11 +1,50 @@
 

-void VmsVmNicIcmpEchoIrpCancelRoutine(void)

+void VmsVmNicIcmpEchoIrpCancelRoutine(undefined8 param_1,longlong param_2)

 

 {

-  code *pcVar1;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong lVar3;

+  longlong lVar4;

+  longlong *plVar5;

+  code *pcVar6;

+  int iVar7;

+  longlong lVar8;

+  undefined2 local_res10;

+  undefined1 local_res12;

   

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

-  (*pcVar1)();

+  local_res10 = 0;

+  local_res12 = 0;

+  lVar8 = 0;

+  IoReleaseCancelSpinLock(*(undefined1 *)(param_2 + 0x45));

+  lVar2 = *(longlong *)(param_2 + 0x78);

+  LibIoctlDeinitializeOperation(*(undefined8 *)(lVar2 + 0x18));

+  lVar3 = *(longlong *)(lVar2 + 0x10);

+  iVar7 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+  if (iVar7 != 0) {

+    lVar8 = *(longlong *)(lVar3 + 0xcf0);

+  }

+  VmsOmObjectLockExclusive(lVar3,&local_res10,0);

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

+  lVar4 = *plVar1;

+  if ((*(longlong **)(lVar4 + 8) == plVar1) &&

+     (plVar5 = *(longlong **)(param_2 + 0xb0), (longlong *)*plVar5 == plVar1)) {

+    *plVar5 = lVar4;

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

+    NdisReleaseRWLock(*(undefined8 *)(lVar3 + 0x38),&local_res10);

+    ExFreePoolWithTag(lVar2,0);

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

+    IofCompleteRequest(param_2,0);

+    iVar7 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+    if (iVar7 != 0) {

+      ExReleaseRundownProtection(lVar8 + 0x5a0);

+    }

+    return;

+  }

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

+  (*pcVar6)(3);

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

+  (*pcVar6)();

   return;

 }
```

## `VmsVmNicFlushIcmpRequestIrps`  (modified)

```diff
--- VmsVmNicFlushIcmpRequestIrps
+++ VmsVmNicFlushIcmpRequestIrps
@@ -1,22 +1,58 @@
 

-void VmsVmNicFlushIcmpRequestIrps(longlong param_1)

+void VmsVmNicFlushIcmpRequestIrps(longlong param_1,undefined8 param_2)

 

 {

-  char *pcVar1;

-  char *in_RAX;

-  longlong unaff_RBX;

+  longlong lVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  code *pcVar5;

+  int iVar6;

+  longlong *plVar7;

   

-  pcVar1 = (char *)(CONCAT71((int7)((ulonglong)in_RAX >> 8),(char)in_RAX + *in_RAX) + -0x73);

-  *pcVar1 = *pcVar1 + (char)param_1;

-  *(undefined4 *)(unaff_RBX + 0x224) = 0;

-  *(undefined4 *)(unaff_RBX + 0x240) = 0;

-  *(undefined8 *)(unaff_RBX + 0x128) = 0;

-  *(undefined4 *)(unaff_RBX + 0x130) = 0;

-  *(undefined8 *)(unaff_RBX + 0x4a8) = 0;

-  *(undefined8 *)(unaff_RBX + 0x140) = 0;

-  *(undefined8 *)(unaff_RBX + 0x138) = 0;

-  *(undefined8 *)(unaff_RBX + 0x148) = 0;

-  NdisReleaseRWLock(*(undefined8 *)(param_1 + 0x38));

-  return;

+  if (param_1 == 0) {

+    WPP_RECORDER_SF_s(VmsIfrLog,param_2,0x13,0x13e,&WPP_07ff703e40ac37709b78062530a71188_Traceguids,

+                      "VmNicExt != NULL");

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

+  }

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

+LAB_0:

+  plVar7 = plVar2;

+  if (plVar7 == (longlong *)(param_1 + 0x578)) {

+    return;

+  }

+  plVar2 = (longlong *)*plVar7;

+  iVar6 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+  if (iVar6 != 0) goto code_r0x000140195fca;

+  goto LAB_1;

+code_r0x000140195fca:

+  LOCK();

+  lVar1 = plVar7[-8];

+  plVar7[-8] = 0;

+  UNLOCK();

+  if (lVar1 != 0) {

+LAB_1:

+    lVar1 = plVar7[-6];

+    LibIoctlDeinitializeOperation(*(undefined8 *)(lVar1 + 0x18));

+    lVar3 = *plVar7;

+    if ((*(longlong **)(lVar3 + 8) != plVar7) ||

+       (plVar4 = (longlong *)plVar7[1], (longlong *)*plVar4 != plVar7)) {

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

+      (*pcVar5)(3);

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

+      (*pcVar5)();

+      return;

+    }

+    *plVar4 = lVar3;

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

+    iVar6 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+    if (iVar6 != 0) {

+      ExReleaseRundownProtection(param_1 + 0x5a0);

+    }

+    ExFreePoolWithTag(lVar1,0);

+    *(undefined4 *)(plVar7 + -0xf) = 0xc0000001;

+    IofCompleteRequest(plVar7 + -0x15,0);

+  }

+  goto LAB_0;

 }
```

## `VmsVmNicFindAndDequeueIcmpListenerIrp`  (modified)

```diff
--- VmsVmNicFindAndDequeueIcmpListenerIrp
+++ VmsVmNicMorph
@@ -1,174 +1,102 @@
 

-/* WARNING: Instruction at (ram,0x0001401958c1) overlaps instruction at (ram,0x0001401958c0)

-    */

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

-

-void VmsVmNicFindAndDequeueIcmpListenerIrp

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

-               undefined8 param_5,ulonglong param_6)

+int VmsVmNicMorph(void)

 

 {

-  uint uVar1;

+  undefined4 uVar1;

   undefined4 uVar2;

-  ulonglong uVar3;

-  undefined8 *puVar4;

-  longlong lVar5;

-  longlong lVar6;

-  int *piVar7;

-  longlong unaff_RBX;

-  short unaff_BP;

-  uint uVar8;

-  undefined8 *unaff_RSI;

-  longlong *unaff_RDI;

-  uint uVar9;

-  uint in_R10D;

-  void *in_R11;

-  longlong unaff_R12;

-  void *unaff_R13;

-  char cVar10;

-  short sVar11;

-  uint unaff_R14D;

-  longlong *unaff_R15;

-  uint in_stack_00000090;

-  void *in_stack_00000098;

+  undefined8 uVar3;

+  longlong lVar4;

+  undefined2 uVar5;

+  int iVar6;

+  undefined8 unaff_RBX;

+  longlong unaff_RBP;

+  longlong unaff_RDI;

+  undefined4 *unaff_R13;

+  longlong unaff_R14;

+  longlong unaff_R15;

   

-  uVar3 = param_1 & 0xffffffff;

-code_r0x0001401958c4:

-  cVar10 = (char)unaff_R14D;

-  *(char *)(unaff_RBX + 4) = cVar10;

-  if (((int)param_1 != -1) && (*(longlong *)(param_2 + 0x18) != 0)) {

-    uVar3 = *(longlong *)(param_2 + 0x18) + param_1 * 0x14;

+  if (*(ulonglong *)(unaff_R14 + 0x760) == (ulonglong)*(uint *)(unaff_RDI + 0x760)) {

+    iVar6 = -0x3ffffff3;

+    WPP_RECORDER_SF_dZZqqd();

   }

-  LOCK();

-  sVar11 = (short)unaff_R14D;

-  *(short *)(uVar3 + 0x10) = *(short *)(uVar3 + 0x10) + sVar11;

-  UNLOCK();

-  uVar3 = param_4;

-  while( true ) {

-    uVar1 = *(uint *)(*unaff_RDI + 4);

-    uVar9 = (uint)uVar3;

-    if (uVar1 != 0) break;

-    if (*(uint *)(unaff_RBX + 0x14) != uVar9) {

-      BLFlushBatchOpContextEx();

-      in_R11 = in_stack_00000098;

-      in_R10D = in_stack_00000090;

+  else {

+    iVar6 = 0;

+  }

+  NdisReleaseRWLock(VmsOmObjectListLock,unaff_RBP + -0x18);

+  if (iVar6 != 0) goto LAB_0;

+  uVar1 = *(undefined4 *)(unaff_RDI + 0xd08);

+  uVar3 = *(undefined8 *)(unaff_RDI + 0x760);

+  *(undefined2 *)(unaff_RBP + 0x58) = *(undefined2 *)(unaff_RDI + 0xd0c);

+  *(undefined4 *)(unaff_RDI + 0xd08) = *unaff_R13;

+  *(undefined2 *)(unaff_RDI + 0xd0c) = *(undefined2 *)(unaff_R13 + 1);

+  *(undefined4 *)(unaff_RDI + 0x72e) = *unaff_R13;

+  *(undefined2 *)(unaff_RDI + 0x732) = *(undefined2 *)(unaff_R13 + 1);

+  VmsOmObjectLockExclusive(uVar3,unaff_RBP + -0x1c,0);

+  VmsOmObjectLockExclusive();

+  lVar4 = *(longlong *)(unaff_R15 + 0x510);

+  *(undefined8 *)(unaff_RBP + -8) = *(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x5e0);

+  if (lVar4 == 0) {

+    iVar6 = -0x3fdcffd2;

+    WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14,0x125);

+    NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

+    NdisReleaseRWLock(*(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x38),unaff_RBP + -0x1c);

+    goto LAB_0;

+  }

+  iVar6 = *(int *)(unaff_R15 + 0x880);

+  if (iVar6 == 1) {

+    uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

+    *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

+    *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

+    uVar5 = *(undefined2 *)(unaff_R15 + 0x888);

+LAB_1:

+    *(undefined2 *)(unaff_RBP + -10) = uVar5;

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

+  }

+  else {

+    if (iVar6 == 2) {

+      uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

+      *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

+      *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

+      uVar5 = *(undefined2 *)(unaff_R15 + 0x88a);

+      goto LAB_1;

     }

-    if (((byte)*(undefined4 *)(unaff_RBX + 8) & 5) != 5) {

-      if (unaff_RBX == 0) goto LAB_0;

-      if ((byte)((byte)*(undefined4 *)(unaff_RBX + 8) & (byte)unaff_BP) != (byte)unaff_BP)

+    if (iVar6 == 3) {

+      uVar2 = *(undefined4 *)(unaff_RDI + 0xd08);

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

+      *(undefined4 *)(unaff_RBP + -0x10) = uVar2;

+      *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RDI + 0xd0c);

+      uVar5 = *(undefined2 *)(unaff_R15 + 0x88c);

+      goto LAB_1;

+    }

+    WPP_RECORDER_SF_s(VmsIfrNicLog);

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

+  }

+  iVar6 = VmsRouterUpdateMacSpoofing

+                    (*(undefined8 *)(unaff_RBP + -8),lVar4,unaff_RBX,

+                     *(char *)(unaff_R15 + 6000) == '\0',*(char *)(unaff_R15 + 6000));

+  NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

+  NdisReleaseRWLock(*(undefined8 *)(*(longlong *)(unaff_RDI + 0x760) + 0x38),unaff_RBP + -0x1c);

+  if (-1 < iVar6) {

+    iVar6 = VmsIovUpdateVfMacFilters();

+    if (-1 < iVar6) {

+      *(undefined2 *)(unaff_RDI + 0xd18) = *(undefined2 *)(unaff_RBP + 0x58);

+      *(undefined4 *)(unaff_RDI + 0xd14) = uVar1;

+      VmsOmNicUpdateExtensions(unaff_RDI + 0x4d0);

       goto LAB_0;

     }

-    (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x20))();

-    memmove(unaff_R13,in_stack_00000098,(ulonglong)in_stack_00000090);

-    (**(code **)(*(longlong *)(unaff_RBX + 0x50) + 0x28))();

-    while( true ) {

-      unaff_RDI = (longlong *)(unaff_RBX + 0x50);

-LAB_1:

-      unaff_R15 = (longlong *)*unaff_R15;

-      uVar3 = 0;

-      unaff_R13 = (void *)((longlong)unaff_R13 + (ulonglong)in_stack_00000090);

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

-        BLFlushBatchOpContextEx();

-        *(int *)(unaff_RSI + 5) = (int)unaff_R12;

-        *unaff_RSI = 0;

-        *(undefined2 *)((longlong)unaff_RSI + 10) = 0;

-        unaff_RSI[4] = param_6 & 0xfffffffffffff000;

-        *(short *)(unaff_RSI + 1) =

-             ((short)((param_6 & 0xfff) + 0xfff + unaff_R12 >> 0xc) + unaff_BP) * 8;

-        *(uint *)((longlong)unaff_RSI + 0x2c) = (uint)param_6 & 0xfff;

-        MmBuildMdlForNonPagedPool();

-        return;

-      }

-      in_R11 = (void *)unaff_R15[3];

-      in_stack_00000090 = *(uint *)(unaff_R15 + 5);

-      in_stack_00000098 = in_R11;

-      in_R10D = in_stack_00000090;

-      if (unaff_RBX != 0) {

-        unaff_RDI = (longlong *)(unaff_RBX + 0x50);

-        param_2 = *unaff_RDI;

-        if ((*(char *)(param_2 + 1) == cVar10) && (*(char *)(unaff_RBX + 4) == '\0')) {

-          param_1 = (ulonglong)*(uint *)(unaff_RBX + 0xc);

-          param_4 = uVar3;

-          goto code_r0x0001401958c4;

-        }

-      }

-      if (unaff_RBX != 0) break;

+  }

+  uVar5 = *(undefined2 *)(unaff_RBP + 0x58);

+  *(undefined2 *)(unaff_RDI + 0xd0c) = uVar5;

+  *(undefined2 *)(unaff_RDI + 0x732) = uVar5;

+  *(undefined4 *)(unaff_RDI + 0xd08) = uVar1;

+  *(undefined4 *)(unaff_RDI + 0x72e) = uVar1;

 LAB_0:

-      memmove(unaff_R13,in_R11,(ulonglong)in_R10D);

-    }

+  KeReleaseMutex(&VmsOmIoctlMutex,0);

+  if (iVar6 < 0) {

+    WPP_RECORDER_SF_qqld(VmsIfrNicLog);

   }

-  puVar4 = *(undefined8 **)(unaff_RBX + 0x20);

-  uVar8 = *(uint *)(puVar4 + 1);

-  if (*(uint *)((longlong)puVar4 + 0xc) <= *(uint *)(puVar4 + 1)) {

-    uVar8 = uVar9;

-    if (*(uint *)(unaff_RBX + 0x10) < uVar1) {

-      puVar4 = (undefined8 *)ExAllocateFromNPagedLookasideList(*unaff_RDI + 0x40);

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

-        *puVar4 = 0;

-        *(undefined4 *)(puVar4 + 1) = 0;

-        uVar2 = *(undefined4 *)(*unaff_RDI + 8);

-        puVar4[2] = puVar4 + 3;

-        *(undefined4 *)((longlong)puVar4 + 0xc) = uVar2;

-        **(undefined8 **)(unaff_RBX + 0x20) = puVar4;

-        lVar6 = *unaff_RDI;

-        *(int *)(unaff_RBX + 0x10) = *(int *)(unaff_RBX + 0x10) + unaff_R14D;

-        *(undefined8 **)(unaff_RBX + 0x20) = puVar4;

-        in_R11 = in_stack_00000098;

-        in_R10D = in_stack_00000090;

-        if (*(char *)(lVar6 + 1) == cVar10) {

-          lVar5 = 0;

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-             (lVar6 = *(longlong *)(lVar6 + 0x18), lVar5 = 0, lVar6 != 0)) {

-            lVar5 = lVar6 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-          }

-          LOCK();

-          *(short *)(lVar5 + 0xc) = *(short *)(lVar5 + 0xc) + sVar11;

-          UNLOCK();

-          piVar7 = (int *)0x0;

-          if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) && (*(longlong *)(*unaff_RDI + 0x18) != 0))

-          {

-            piVar7 = (int *)(*(longlong *)(*unaff_RDI + 0x18) +

-                            (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14);

-          }

-          LOCK();

-          *piVar7 = *piVar7 + unaff_R14D;

-          UNLOCK();

-        }

-        goto LAB_2;

-      }

-    }

-    BLFlushBatchOpContextEx();

-    puVar4 = (undefined8 *)(unaff_RBX + 0x38);

-    in_R11 = in_stack_00000098;

-    in_R10D = in_stack_00000090;

-  }

-LAB_2:

-  *(int *)(unaff_RBX + 0x14) = *(int *)(unaff_RBX + 0x14) + unaff_R14D;

-  *(uint *)(puVar4 + 1) = *(int *)(puVar4 + 1) + unaff_R14D;

-  if (*(char *)(*unaff_RDI + 1) == cVar10) {

-    lVar6 = 0;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) &&

-       (lVar5 = *(longlong *)(*unaff_RDI + 0x18), lVar5 != 0)) {

-      lVar6 = lVar5 + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-    }

-    LOCK();

-    *(short *)(lVar6 + 0xe) = *(short *)(lVar6 + 0xe) + sVar11;

-    UNLOCK();

-    lVar6 = 0;

-    if ((*(uint *)(unaff_RBX + 0xc) != 0xffffffff) && (*(longlong *)(*unaff_RDI + 0x18) != 0)) {

-      lVar6 = *(longlong *)(*unaff_RDI + 0x18) + (ulonglong)*(uint *)(unaff_RBX + 0xc) * 0x14;

-    }

-    LOCK();

-    *(int *)(lVar6 + 4) = *(int *)(lVar6 + 4) + unaff_R14D;

-    UNLOCK();

-  }

-  lVar6 = puVar4[2];

-  uVar3 = (ulonglong)uVar8;

-  *(void **)(lVar6 + uVar3 * 0x18) = unaff_R13;

-  unaff_BP = 6;

-  *(void **)(lVar6 + 8 + uVar3 * 0x18) = in_R11;

-  *(uint *)(lVar6 + 0x10 + uVar3 * 0x18) = in_R10D << 4 | unaff_R14D;

-  in_stack_00000090 = in_R10D;

-  goto LAB_1;

+  return iVar6;

 }
```

## `VmsVmNicIcmpEchoWorkRoutine`  (modified)

```diff
--- VmsVmNicIcmpEchoWorkRoutine
+++ VmsVmNicIcmpEchoWorkRoutine
@@ -1,131 +1,77 @@
 

-int VmsVmNicIcmpEchoWorkRoutine(int param_1,undefined8 param_2)

+void VmsVmNicIcmpEchoWorkRoutine(undefined8 param_1,longlong param_2)

 

 {

-  int iVar1;

-  int iVar2;

-  longlong lVar3;

-  int iVar4;

-  char cVar5;

-  undefined2 uVar6;

-  undefined8 unaff_RBX;

-  longlong unaff_RBP;

-  int unaff_ESI;

-  int *unaff_R13;

-  undefined8 *puVar7;

-  longlong unaff_R15;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  longlong lVar4;

+  undefined8 uVar5;

+  code *pcVar6;

+  uint uVar7;

+  int iVar8;

+  longlong lVar9;

+  undefined1 *puVar10;

+  longlong *plVar11;

+  undefined2 local_res10;

+  undefined1 local_res12;

+  undefined1 auStack_68 [8];

+  undefined1 auStack_60 [56];

   

-  if (unaff_R15 == 0) {

-    WPP_RECORDER_SF_s(VmsIfrNicLog,param_2,param_1 + 0x12,0x121,

-                      &WPP_07ff703e40ac37709b78062530a71188_Traceguids);

-    MicrosoftTelemetryAssertTriggeredNoArgsKM();

-  }

-  if (*(char *)(unaff_R15 + 0x177c) == '\0') {

-    WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14,0x122,&WPP_07ff703e40ac37709b78062530a71188_Traceguids);

-    goto LAB_0;

-  }

-  if ((*unaff_R13 == 0) && ((short)unaff_R13[1] == 0)) {

-    unaff_ESI = -0x3ffffff3;

-    WPP_RECORDER_SF_q_MAC_d

-              (VmsIfrNicLog,2,0x14,0x123,&WPP_07ff703e40ac37709b78062530a71188_Traceguids);

-    goto LAB_0;

-  }

-  if ((*(int *)((longlong)unaff_R13 + 2) != CONCAT22(uRam00000000000014d8,uRam00000000000014d6)) ||

-     ((short)*unaff_R13 != sRam00000000000014d4)) {

-    VmsUtilLockShared();

-    if ((0 < VmsOmNicCount) && ((undefined8 **)VmsOmNicList != &VmsOmNicList)) {

-      puVar7 = VmsOmNicList;

-      do {

-        if ((*(int *)((longlong)puVar7 + 0xd0a) == *(int *)((longlong)unaff_R13 + 2)) &&

-           (*(short *)(puVar7 + 0x1a1) == (short)*unaff_R13)) {

-          iVar1 = *(int *)(puVar7 + 0xea);

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

-          if ((iVar1 == 3) &&

-             ((cVar5 = VmsUtilStrMatch(puVar7 + 0x14a,0x1210), cVar5 != '\0' &&

-              (puVar7[0xec] != lRam0000000000000f20)))) {

-            unaff_ESI = 0;

-          }

-          else {

-            unaff_ESI = -0x3ffffff3;

-            WPP_RECORDER_SF_dZZqqd();

-          }

-          break;

-        }

-        puVar7 = (undefined8 *)*puVar7;

-      } while ((undefined8 **)puVar7 != &VmsOmNicList);

+  puVar10 = auStack_68;

+  lVar2 = *(longlong *)(param_2 + 0x2a8);

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

+  local_res10 = 0;

+  local_res12 = 0;

+  do {

+    plVar11 = (longlong *)0x0;

+    VmsOmObjectLockExclusive(lVar2,&local_res10,0);

+    plVar3 = (longlong *)*plVar1;

+    if (plVar3 != plVar1) {

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

+         (lVar4 = *plVar3, *(longlong **)(lVar4 + 8) != plVar3)) {

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

+        (*pcVar6)(3);

+        puVar10 = auStack_60;

+LAB_0:

+        *(ulonglong *)(puVar10 + 0x38) = -(ulonglong)(lVar2 != 0) & lVar2 + 0x840U;

+        *(undefined4 *)(puVar10 + 0x30) = 8;

+        *(ulonglong *)(puVar10 + 0x28) = -(ulonglong)(lVar2 != 0) & lVar2 + 0xa50U;

+        *(undefined4 *)(puVar10 + 0x20) = 7;

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

+        ExecMonitorOperationContextInfoUpdate(param_1,8,1,-(ulonglong)(lVar2 != 0) & lVar2 + 0x48U);

+        return;

+      }

+      *plVar1 = lVar4;

+      plVar11 = plVar3 + -3;

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

+      plVar3[1] = 0;

+      *plVar3 = 0;

     }

-    NdisReleaseRWLock(VmsOmObjectListLock,unaff_RBP + -0x18);

-    if (unaff_ESI != 0) goto LAB_0;

-  }

-  iVar1 = iRam00000000000014c8;

-  lVar3 = lRam0000000000000f20;

-  *(short *)(unaff_RBP + 0x58) = sRam00000000000014cc;

-  iRam00000000000014c8 = *unaff_R13;

-  sRam00000000000014cc = (short)unaff_R13[1];

-  iRam0000000000000eee = *unaff_R13;

-  sRam0000000000000ef2 = (short)unaff_R13[1];

-  VmsOmObjectLockExclusive(lVar3,unaff_RBP + -0x1c,0);

-  VmsOmObjectLockExclusive();

-  lVar3 = *(longlong *)(unaff_R15 + 0x510);

-  *(undefined8 *)(unaff_RBP + -8) = *(undefined8 *)(lRam0000000000000f20 + 0x5e0);

-  iVar4 = iRam00000000000014c8;

-  if (lVar3 == 0) {

-    unaff_ESI = -0x3fdcffd2;

-    WPP_RECORDER_SF_id(VmsIfrNicLog,2,0x14,0x125,&WPP_07ff703e40ac37709b78062530a71188_Traceguids);

-    NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

-    NdisReleaseRWLock(*(undefined8 *)(lRam0000000000000f20 + 0x38),unaff_RBP + -0x1c);

-    goto LAB_0;

-  }

-  iVar2 = *(int *)(unaff_R15 + 0x880);

-  if (iVar2 == 1) {

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

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

-    *(short *)(unaff_RBP + -0xc) = sRam00000000000014cc;

-    uVar6 = *(undefined2 *)(unaff_R15 + 0x888);

-LAB_1:

-    *(undefined2 *)(unaff_RBP + -10) = uVar6;

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

-  }

-  else {

-    if (iVar2 == 2) {

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

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

-      *(short *)(unaff_RBP + -0xc) = sRam00000000000014cc;

-      uVar6 = *(undefined2 *)(unaff_R15 + 0x88a);

-      goto LAB_1;

+    NdisReleaseRWLock(*(undefined8 *)(lVar2 + 0x38));

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

+    lVar4 = plVar11[2];

+    uVar5 = *(undefined8 *)(lVar4 + 0x78);

+    VmsNblHelperInitializeOriginalNbl(plVar11[1],5);

+    VmsNblHelperSetSourceInContext(plVar11[1],lVar2);

+    lVar9 = VmsPtGetNicHeaderAtIndex(lVar2,0);

+    if (lVar9 != 0) {

+      uVar7 = KeGetCurrentProcessorNumberEx(0);

+      LOCK();

+      plVar3 = (longlong *)((ulonglong)uVar7 * 0x40 + 8 + *(longlong *)(lVar9 + 0x18));

+      *plVar3 = *plVar3 + 1;

+      UNLOCK();

     }

-    if (iVar2 == 3) {

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

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

-      *(short *)(unaff_RBP + -0xc) = sRam00000000000014cc;

-      uVar6 = *(undefined2 *)(unaff_R15 + 0x88c);

-      goto LAB_1;

+    VmsExtPtRouteNetBufferListsWithBwCap(lVar2,plVar11[1]);

+    ExFreePoolWithTag(uVar5,0);

+    ExFreePoolWithTag(plVar11,0);

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

+    *(undefined4 *)(lVar4 + 0x30) = 0;

+    IofCompleteRequest(lVar4,0);

+    iVar8 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+    if (iVar8 != 0) {

+      ExReleaseRundownProtection(param_2 + 0x5a0);

     }

-    WPP_RECORDER_SF_s(VmsIfrNicLog);

-    MicrosoftTelemetryAssertTriggeredNoArgsKM();

-  }

-  unaff_ESI = VmsRouterUpdateMacSpoofing

-                        (*(undefined8 *)(unaff_RBP + -8),lVar3,unaff_RBX,

-                         *(char *)(unaff_R15 + 6000) == '\0',*(char *)(unaff_R15 + 6000));

-  NdisReleaseRWLock(*(undefined8 *)(unaff_R15 + 0x38),unaff_RBP + -0x20);

-  NdisReleaseRWLock(*(undefined8 *)(lRam0000000000000f20 + 0x38),unaff_RBP + -0x1c);

-  if ((unaff_ESI < 0) || (unaff_ESI = VmsIovUpdateVfMacFilters(), unaff_ESI < 0)) {

-    sRam0000000000000ef2 = *(short *)(unaff_RBP + 0x58);

-    iRam0000000000000eee = iVar1;

-    iRam00000000000014c8 = iVar1;

-    sRam00000000000014cc = sRam0000000000000ef2;

-  }

-  else {

-    uRam00000000000014d8 = *(undefined2 *)(unaff_RBP + 0x58);

-    sRam00000000000014d4 = (short)iVar1;

-    uRam00000000000014d6 = (undefined2)((uint)iVar1 >> 0x10);

-    VmsOmNicUpdateExtensions(0xc90);

-  }

-LAB_0:

-  KeReleaseMutex(&VmsOmIoctlMutex,0);

-  if (unaff_ESI < 0) {

-    WPP_RECORDER_SF_qqld(VmsIfrNicLog);

-  }

-  return unaff_ESI;

+  } while( true );

 }
```

## `VmsVmNicGetIdealProcessorIndexForVpIndex`  (modified)

```diff
--- VmsVmNicGetIdealProcessorIndexForVpIndex
+++ VmsVmNicGetIdealProcessorIndexForVpIndex
@@ -1,16 +1,96 @@
 

-undefined8 VmsVmNicGetIdealProcessorIndexForVpIndex(undefined8 param_1,undefined8 param_2)

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

+

+int VmsVmNicGetIdealProcessorIndexForVpIndex(longlong param_1,uint param_2)

 

 {

-  longlong unaff_RBX;

-  longlong unaff_RDI;

+  char cVar1;

+  int iVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  ulonglong uVar5;

+  int iVar6;

+  undefined8 *puVar7;

+  uint uVar8;

+  undefined1 auStack_188 [32];

+  undefined *local_168;

+  char *local_160;

+  uint local_158;

+  int local_154 [3];

+  uint local_148 [64];

+  ulonglong local_48;

   

-  WPP_RECORDER_SF_s(param_1,param_2,0x13,0x143,&WPP_07ff703e40ac37709b78062530a71188_Traceguids);

-  if (*(char *)(unaff_RDI + 0x44) == '\0') {

-    MicrosoftTelemetryAssertTriggeredNoArgsKM();

+  local_48 = __security_cookie ^ (ulonglong)auStack_188;

+  local_158 = 0;

+  local_154[0] = -1;

+  uVar5 = (ulonglong)param_2;

+  iVar6 = -1;

+  if (param_1 != 0) {

+    cVar1 = ExAcquireRundownProtection(param_1 + 0x78);

+    iVar6 = -1;

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

+      uVar3 = *(int *)(param_1 + 0x90) + 1;

+      if (uVar3 <= param_2) {

+        uVar5 = (ulonglong)param_2 % (ulonglong)uVar3;

+      }

+      uVar3 = VmbChannelGetVirtualProcessorCount(*(undefined8 *)(param_1 + 0x10));

+      if (uVar3 <= (uint)uVar5) {

+        uVar5 = uVar5 % (ulonglong)uVar3;

+      }

+      VmbChannelGetNumaNodeMap(*(undefined8 *)(param_1 + 0x10),0x40,local_148,&local_158);

+      uVar4 = (ulonglong)local_158;

+      if (local_158 == 0) {

+        local_168 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+        WPP_RECORDER_SF_(VmsIfrLog,3,0x14,0x139);

+        uVar4 = 1;

+        local_158 = 1;

+      }

+      uVar4 = uVar3 / uVar4;

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

+        uVar4 = 1;

+      }

+      iVar2 = Feature_2743228729__private_IsEnabledDeviceUsageNoInline();

+      if (iVar2 == 0) {

+        uVar3 = (uint)(uVar5 / uVar4);

+      }

+      else {

+        uVar3 = VmsVmNicGetVirtualNodeIndexForVpIndex(uVar5,uVar3,local_158);

+      }

+      if (local_158 <= uVar3) {

+        local_160 = "vNodeIndex < nodeCount";

+        local_168 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+        WPP_RECORDER_SF_s(VmsIfrLog);

+        if (local_158 <= uVar3) {

+          MicrosoftTelemetryAssertTriggeredNoArgsKM();

+        }

+      }

+      puVar7 = &DAT_0 + (ulonglong)local_148[uVar3] * 0x62;

+      uVar3 = VmsCpuSetCountProcessors(puVar7);

+      uVar8 = (uint)(uVar5 % uVar4);

+      if (uVar8 < uVar3) {

+        cVar1 = VmsCpuSetScanForward(local_154,puVar7);

+        iVar6 = local_154[0];

+        for (uVar3 = 0; (local_154[0] = iVar6, cVar1 != '\0' && (uVar3 != uVar8)); uVar3 = uVar3 + 1

+            ) {

+          cVar1 = VmsCpuSetScanForward(local_154,puVar7);

+          iVar6 = local_154[0];

+        }

+        if (iVar6 == -1) {

+          local_160 = "cpuIndex != VMS_CPU_INVALID";

+          local_168 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+          WPP_RECORDER_SF_s(VmsIfrLog);

+          MicrosoftTelemetryAssertTriggeredNoArgsKM();

+        }

+      }

+      else {

+        local_160 = "!\"vNuma size cannot be greater than hNuma!\"";

+        local_168 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+        WPP_RECORDER_SF_s(VmsIfrLog);

+        MicrosoftTelemetryAssertTriggeredNoArgsKM();

+      }

+      ExReleaseRundownProtection(param_1 + 0x78);

+    }

   }

-  *(longlong *)(unaff_RBX + 8) = unaff_RBX;

-  *(longlong *)unaff_RBX = unaff_RBX;

-  return 0;

+  return iVar6;

 }
```

## `VmsVmNicHandleIcmpEchoRequest`  (modified)

```diff
--- VmsVmNicHandleIcmpEchoRequest
+++ VmsVmNicHandleIcmpEchoRequest
@@ -1,144 +1,104 @@
 

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

 

-void VmsVmNicHandleIcmpEchoRequest(void)

+undefined8

+VmsVmNicHandleIcmpEchoRequest

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

 

 {

-  undefined8 uVar1;

-  undefined4 uVar2;

-  undefined4 uVar3;

-  undefined4 uVar4;

-  undefined4 uVar5;

+  longlong lVar1;

+  code *pcVar2;

+  int iVar3;

+  longlong lVar4;

+  longlong *plVar5;

   undefined8 uVar6;

-  undefined8 uVar7;

-  undefined8 uVar8;

-  undefined8 uVar9;

-  longlong lVar10;

-  char cVar11;

-  int *in_RAX;

-  longlong *unaff_RBX;

-  undefined8 *unaff_RBP;

-  longlong unaff_RSI;

-  undefined8 *unaff_RDI;

-  undefined8 in_R9;

-  undefined4 extraout_XMM0_Da;

-  undefined4 uVar12;

-  undefined2 uVar13;

-  undefined8 in_stack_00000030;

-  undefined8 in_stack_00000038;

-  undefined8 in_stack_00000040;

-  undefined8 in_stack_00000048;

-  undefined8 in_stack_00000050;

-  undefined8 in_stack_00000058;

-  undefined8 in_stack_00000060;

-  undefined8 in_stack_00000068;

-  undefined4 uStack0000000000000070;

-  undefined4 uStack0000000000000074;

+  longlong lVar7;

+  longlong *plVar8;

+  char *pcVar9;

+  undefined1 *puVar10;

+  undefined1 auStack_1b8 [8];

+  undefined1 auStack_1b0 [24];

+  undefined *local_198;

+  char *local_190;

+  undefined1 local_188 [320];

+  ulonglong local_48;

   

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

-  memset(&stack0x00000030,0,0x48);

-  uVar13 = 0;

-  cVar11 = ExAcquireRundownProtection(unaff_RBX + 0xf);

-  uVar12 = extraout_XMM0_Da;

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

-    VmbChannelGetStatistics(unaff_RBX[2],unaff_RBP + -0x10);

-    uVar12 = ExReleaseRundownProtection(unaff_RBX + 0xf);

+  puVar10 = auStack_1b8;

+  local_48 = __security_cookie ^ (ulonglong)auStack_1b8;

+  pcVar9 = (char *)0x0;

+  memset(local_188,0,0x13c);

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

+  if (lVar1 == 0) {

+    local_190 = "vmNicExt != NULL";

+    local_198 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    WPP_RECORDER_SF_s(VmsIfrLog);

+    MicrosoftTelemetryAssertTriggeredNoArgsKM();

   }

-  VmsOmObjectLockShared(uVar12,&stack0x00000020,0,in_R9,uVar13);

-  if (*unaff_RBX != 0) {

-    RndisDevHostGetInternalStatistics(*unaff_RBX + 0x3d1bb0,&stack0x00000030);

+  lVar4 = VmsVmNicFindAndDequeueIcmpListenerIrp(param_1,param_2,param_3,param_4);

+  if (lVar4 != 0) {

+    pcVar9 = *(char **)(lVar4 + 0x78);

+    if (*pcVar9 != '\x01') {

+      local_190 = "icmpEchoContext->Listener == TRUE";

+      local_198 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+      WPP_RECORDER_SF_s(VmsIfrLog);

+      if (*pcVar9 != '\x01') {

+        MicrosoftTelemetryAssertTriggeredNoArgsKM();

+      }

+    }

+    local_198 = local_188;

+    VmsVmNicCreateIcmpEchoReply

+              (param_3,*(undefined4 *)(pcVar9 + 4),*(undefined4 *)(pcVar9 + 8),

+               *(undefined4 *)(pcVar9 + 0x20));

+    plVar5 = (longlong *)ExAllocatePool2(0x40,0x28,0x4e567356);

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

+      local_190 = (char *)CONCAT44(local_190._4_4_,0x28);

+      local_198 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+      WPP_RECORDER_SF_L(VmsIfrLog,2,0x14,0x14e);

+    }

+    else {

+      lVar7 = VmsPktAllocateAndBuildIcmpPacket(*(undefined8 *)(pcVar9 + 0x10),local_188);

+      if (lVar7 != 0) {

+        *(uint *)(lVar7 + 300) = *(uint *)(lVar7 + 300) & 0xfeffffff | 0x400;

+        plVar8 = plVar5 + 3;

+        plVar5[1] = lVar7;

+        lVar7 = lVar1 + 0x588;

+        plVar5[4] = (longlong)plVar8;

+        *plVar8 = (longlong)plVar8;

+        plVar5[2] = lVar4;

+        *plVar5 = param_1;

+        plVar5 = *(longlong **)(lVar1 + 0x590);

+        puVar10 = auStack_1b8;

+        if (*plVar5 != lVar7) {

+          lVar7 = 3;

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

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

+          puVar10 = auStack_1b0;

+        }

+        *plVar8 = lVar7;

+        plVar8[1] = (longlong)plVar5;

+        *plVar5 = (longlong)plVar8;

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

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

+        NvIoQueueWorkItem(lVar1 + 0x598,0);

+        uVar6 = 1;

+        goto LAB_0;

+      }

+      local_198 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+      WPP_RECORDER_SF_(VmsIfrLog,2,0x14,0x14f);

+      ExFreePoolWithTag(plVar5,0x4e567356);

+    }

   }

-  NdisReleaseRWLock(*(undefined8 *)(unaff_RSI + 0x38),&stack0x00000020);

-  unaff_RDI[7] = 0;

-  uVar6 = unaff_RBP[10];

-  uVar7 = unaff_RBP[0xb];

-  uVar8 = unaff_RBP[0xc];

-  uVar9 = unaff_RBP[0xd];

-  *unaff_RDI = unaff_RBP[-0x10];

-  unaff_RDI[1] = unaff_RBP[-0xf];

-  unaff_RDI[2] = unaff_RBP[-9];

-  unaff_RDI[3] = unaff_RBP[-8];

-  uVar1 = unaff_RBP[-7];

-  unaff_RDI[0xd] = uVar6;

-  unaff_RDI[0xe] = uVar7;

-  unaff_RDI[4] = uVar1;

-  uVar1 = unaff_RBP[-6];

-  uVar6 = unaff_RBP[0xe];

-  uVar7 = unaff_RBP[0xf];

-  unaff_RDI[0xf] = uVar8;

-  unaff_RDI[0x10] = uVar9;

-  unaff_RDI[5] = uVar1;

-  uVar8 = unaff_RBP[0x10];

-  uVar9 = unaff_RBP[0x11];

-  unaff_RDI[6] = unaff_RBP[-5];

-  uVar1 = unaff_RBP[-3];

-  unaff_RDI[0x11] = uVar6;

-  unaff_RDI[0x12] = uVar7;

-  unaff_RDI[8] = uVar1;

-  uVar6 = unaff_RBP[0x12];

-  uVar7 = unaff_RBP[0x13];

-  uVar1 = unaff_RBP[-0xe];

-  unaff_RDI[0x13] = uVar8;

-  unaff_RDI[0x14] = uVar9;

-  unaff_RDI[9] = uVar1;

-  uVar8 = unaff_RBP[0x14];

-  uVar9 = unaff_RBP[0x15];

-  uVar1 = unaff_RBP[-0xb];

-  unaff_RDI[0x15] = uVar6;

-  unaff_RDI[0x16] = uVar7;

-  unaff_RDI[10] = uVar1;

-  uVar1 = unaff_RBP[-1];

-  uVar6 = *unaff_RBP;

-  unaff_RDI[0xb] = unaff_RBP[-10];

-  uVar12 = *(undefined4 *)(unaff_RBP + 8);

-  unaff_RDI[0x19] = uVar1;

-  unaff_RDI[0x1a] = uVar6;

-  *(undefined4 *)(unaff_RDI + 0xc) = uVar12;

-  uVar12 = *(undefined4 *)(unaff_RBP + 6);

-  uVar2 = *(undefined4 *)(unaff_RBP + 3);

-  uVar3 = *(undefined4 *)((longlong)unaff_RBP + 0x1c);

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

-  uVar5 = *(undefined4 *)((longlong)unaff_RBP + 0x24);

-  unaff_RDI[0x17] = uVar8;

-  unaff_RDI[0x18] = uVar9;

-  uVar1 = unaff_RBP[2];

-  unaff_RDI[0x1b] = unaff_RBP[1];

-  unaff_RDI[0x1c] = uVar1;

-  uVar1 = unaff_RBP[5];

-  *(undefined4 *)(unaff_RDI + 0x1d) = uVar2;

-  *(undefined4 *)((longlong)unaff_RDI + 0xec) = uVar3;

-  *(undefined4 *)(unaff_RDI + 0x1e) = uVar4;

-  *(undefined4 *)((longlong)unaff_RDI + 0xf4) = uVar5;

-  unaff_RDI[0x1f] = uVar1;

-  *(undefined4 *)(unaff_RDI + 0x20) = uVar12;

-  *(undefined4 *)(unaff_RDI + 0x24) = *(undefined4 *)((longlong)unaff_RBX + 0x244);

-  *(int *)((longlong)unaff_RDI + 0x124) = (int)unaff_RBX[0x4b];

-  unaff_RDI[0x21] = unaff_RBX[0x21];

-  unaff_RDI[0x22] = unaff_RBX[0x22];

-  unaff_RDI[0x23] = unaff_RBX[0x23];

-  uVar12 = VmsOmpNicHeaderGetPacketCount(unaff_RBX[0x55] + 0x4d0,1);

-  *(undefined4 *)(unaff_RDI + 0x25) = uVar12;

-  lVar10 = unaff_RBX[0x3c];

-  *(undefined4 *)(unaff_RDI + 0x26) = 0;

-  *(uint *)((longlong)unaff_RDI + 300) = (uint)((char)lVar10 == '\0');

-  *(int *)((longlong)unaff_RDI + 0x134) = (int)unaff_RBX[0x38];

-  *(int *)(unaff_RDI + 0x27) = (int)unaff_RBX[0x26];

-  *(int *)((longlong)unaff_RDI + 0x13c) = (int)unaff_RBX[0x48];

-  *(int *)(unaff_RDI + 0x28) = (int)unaff_RBX[0x46];

-  *(undefined4 *)((longlong)unaff_RDI + 0x144) = *(undefined4 *)((longlong)unaff_RBX + 0x22c);

-  unaff_RDI[0x29] = in_stack_00000030;

-  unaff_RDI[0x2a] = in_stack_00000038;

-  *(undefined4 *)((longlong)unaff_RDI + 0x194) = uStack0000000000000070;

-  unaff_RDI[0x2b] = in_stack_00000040;

-  unaff_RDI[0x2c] = in_stack_00000048;

-  unaff_RDI[0x2d] = in_stack_00000050;

-  unaff_RDI[0x2e] = in_stack_00000058;

-  unaff_RDI[0x2f] = in_stack_00000060;

-  unaff_RDI[0x30] = in_stack_00000068;

-  *(int *)(unaff_RDI + 0x31) = (int)unaff_RBX[0x1e];

-  *(undefined4 *)((longlong)unaff_RDI + 0x18c) = *(undefined4 *)((longlong)unaff_RBX + 0xf4);

-  *(int *)(unaff_RDI + 0x32) = (int)unaff_RBX[0x1f];

-  *(undefined4 *)(unaff_RDI + 0x33) = uStack0000000000000074;

-  return;

+  iVar3 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

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

+    LibIoctlDeinitializeOperation(*(undefined8 *)(pcVar9 + 0x18));

+    ExFreePoolWithTag(pcVar9,0);

+    *(undefined4 *)(lVar4 + 0x30) = 0xc000009a;

+    IofCompleteRequest(lVar4,0);

+    ExReleaseRundownProtection(lVar1 + 0x5a0);

+  }

+  uVar6 = 0;

+LAB_0:

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

+  return uVar6;

 }
```

## `VmsVmNicHandleIcmpEchoReply`  (modified)

```diff
--- VmsVmNicHandleIcmpEchoReply
+++ VmsVmNicHandleIcmpEchoReply
@@ -1,58 +1,64 @@
 

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

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

 

-int VmsVmNicHandleIcmpEchoReply(uint param_1)

+undefined8 VmsVmNicHandleIcmpEchoReply(longlong param_1)

 

 {

-  char cVar1;

-  int iVar2;

-  uint uVar3;

-  uint unaff_EBX;

-  int unaff_ESI;

-  undefined8 *puVar4;

-  uint unaff_R14D;

-  uint uVar5;

-  ulonglong uVar6;

-  uint uStack0000000000000030;

-  int iStack0000000000000034;

+  char *pcVar1;

+  undefined1 auVar2 [16];

+  int iVar3;

+  longlong lVar4;

+  ulonglong uVar5;

+  undefined4 *local_res20;

+  undefined *in_stack_ffffffffffffffd8;

   

-  uVar6 = (ulonglong)unaff_R14D / (ulonglong)param_1;

-  if ((int)uVar6 == 0) {

-    uVar6 = 1;

+  local_res20 = (undefined4 *)0x0;

+  iVar3 = -0x3ffffddb;

+  lVar4 = VmsVmNicFindAndDequeueIcmpRequestIrp();

+  if (lVar4 == 0) {

+    return 0;

   }

-  uStack0000000000000030 = param_1;

-  iVar2 = Feature_2743228729__private_IsEnabledDeviceUsageNoInline();

-  if (iVar2 == 0) {

-    uVar3 = (uint)(unaff_EBX / uVar6);

-  }

-  else {

-    uVar3 = VmsVmNicGetVirtualNodeIndexForVpIndex(unaff_EBX,unaff_R14D,uStack0000000000000030);

-  }

-  if ((uStack0000000000000030 <= uVar3) &&

-     (WPP_RECORDER_SF_s(VmsIfrLog), uStack0000000000000030 <= uVar3)) {

-    MicrosoftTelemetryAssertTriggeredNoArgsKM();

-  }

-  puVar4 = &DAT_0 + (ulonglong)*(uint *)(&stack0x00000040 + (ulonglong)uVar3 * 4) * 0x62;

-  uVar3 = VmsCpuSetCountProcessors(puVar4);

-  uVar5 = (uint)((ulonglong)unaff_EBX % uVar6);

-  if (uVar5 < uVar3) {

-    cVar1 = VmsCpuSetScanForward((longlong)&stack0x00000030 + 4,puVar4);

-    unaff_ESI = iStack0000000000000034;

-    for (uVar3 = 0; (cVar1 != '\0' && (uVar3 != uVar5)); uVar3 = uVar3 + 1) {

-      iStack0000000000000034 = unaff_ESI;

-      cVar1 = VmsCpuSetScanForward((longlong)&stack0x00000030 + 4,puVar4);

-      unaff_ESI = iStack0000000000000034;

-    }

-    if (unaff_ESI == -1) {

-      WPP_RECORDER_SF_s(VmsIfrLog);

+  pcVar1 = *(char **)(lVar4 + 0x78);

+  if (*(longlong *)(pcVar1 + 0x18) == 0) {

+    in_stack_ffffffffffffffd8 = &WPP_07ff703e40ac37709b78062530a71188_Traceguids;

+    WPP_RECORDER_SF_s(VmsIfrLog);

+    if (*(longlong *)(pcVar1 + 0x18) == 0) {

       MicrosoftTelemetryAssertTriggeredNoArgsKM();

     }

   }

-  else {

+  if (*(longlong *)(pcVar1 + 0x18) != 0) {

+    iVar3 = LibIoctlAddRecordEx(*(longlong *)(pcVar1 + 0x18),0x58,1,4,

+                                (ulonglong)in_stack_ffffffffffffffd8 & 0xffffffff00000000,

+                                &local_res20);

+    if (-1 < iVar3) {

+      if ((*pcVar1 != '\0') && (WPP_RECORDER_SF_s(VmsIfrLog), *pcVar1 != '\0')) {

+        MicrosoftTelemetryAssertTriggeredNoArgsKM();

+      }

+      auVar2._8_8_ = 0;

+      auVar2._0_8_ = _DAT_0;

+      uVar5 = _DAT_0 / 10000 - *(longlong *)(pcVar1 + 0x28);

+      if (0xfffffffe < uVar5) {

+        WPP_RECORDER_SF_s(VmsIfrLog,SUB168(ZEXT816(0x346dc5d63886594b) * auVar2,8),0x13,0x14a,

+                          &WPP_07ff703e40ac37709b78062530a71188_Traceguids,"deltaTicks < (ULONG)-1")

+        ;

+        MicrosoftTelemetryAssertTriggeredNoArgsKM();

+      }

+      *local_res20 = (int)uVar5;

+      LibIoctlFinalizeAndDeinitializeOperationEx(*(undefined8 *)(pcVar1 + 0x18),0);

+      goto LAB_1;

+    }

     WPP_RECORDER_SF_s(VmsIfrLog);

     MicrosoftTelemetryAssertTriggeredNoArgsKM();

   }

-  ExReleaseRundownProtection();

-  return unaff_ESI;

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

+LAB_1:

+  *(int *)(lVar4 + 0x30) = iVar3;

+  IofCompleteRequest(lVar4,0);

+  ExFreePoolWithTag(pcVar1,0);

+  iVar3 = Feature_863654203__private_IsEnabledDeviceUsageNoInline();

+  if (iVar3 != 0) {

+    ExReleaseRundownProtection(*(longlong *)(param_1 + 0xcf0) + 0x5a0);

+  }

+  return 1;

 }
```

## `NTOSKRNL.EXE::ExWaitForRundownProtectionRelease`  (modified)

```diff
--- NTOSKRNL.EXE::ExWaitForRundownProtectionRelease calling
+++ NTOSKRNL.EXE::ExWaitForRundownProtectionRelease calling
@@ -10,0 +11 @@
+VmsVmNicFlushIcmpRequestIrpsWithRundown
```

## `NTOSKRNL.EXE::ExAcquireRundownProtection`  (modified)

```diff
--- NTOSKRNL.EXE::ExAcquireRundownProtection calling
+++ NTOSKRNL.EXE::ExAcquireRundownProtection calling
@@ -14,0 +15 @@
+VmsVmNicPendIcmpEchoRequestIrp
```

## `NTOSKRNL.EXE::IofCompleteRequest`  (modified)

```diff
--- NTOSKRNL.EXE::IofCompleteRequest calling
+++ NTOSKRNL.EXE::IofCompleteRequest calling
@@ -20,0 +21 @@
+VmsVmNicHandleIcmpEchoRequest
```

## `NDIS.SYS::NdisReleaseRWLock`  (modified)

```diff
--- NDIS.SYS::NdisReleaseRWLock calling
+++ NDIS.SYS::NdisReleaseRWLock calling
@@ -215,0 +216 @@
+VmsOmNicTryReferenceIfConnected
@@ -454,0 +456 @@
+VmsVmNicFlushIcmpRequestIrpsWithRundown
```

## `NTOSKRNL.EXE::ExInitializeRundownProtection`  (modified)

```diff
--- NTOSKRNL.EXE::ExInitializeRundownProtection calling
+++ NTOSKRNL.EXE::ExInitializeRundownProtection calling
@@ -6,0 +7 @@
+VmsVmNicMorph
```

## `NTOSKRNL.EXE::ExReleaseRundownProtection`  (modified)

```diff
--- NTOSKRNL.EXE::ExReleaseRundownProtection calling
+++ NTOSKRNL.EXE::ExReleaseRundownProtection calling
@@ -13,0 +14 @@
+VmsVmNicFlushIcmpRequestIrps
@@ -15,0 +17,4 @@
+VmsVmNicHandleIcmpEchoReply
+VmsVmNicHandleIcmpEchoRequest
+VmsVmNicIcmpEchoIrpCancelRoutine
+VmsVmNicIcmpEchoWorkRoutine
```
