# CVE-2026-96981 — pci.sys patch diff

`pci.sys` 10.0.26100.9711 -> 10.0.26100.9974 (ghidriff).

## `PciReadSlotIdData`  (modified)

```diff
--- PciReadSlotIdData
+++ PciReadSlotIdData
@@ -1,99 +1,119 @@
 

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

-

-undefined ** PciReadSlotIdData(longlong param_1,ulonglong param_2,byte *param_3)

+undefined8 PciReadSlotIdData(longlong param_1,ulonglong param_2,char param_3,byte *param_4)

 

 {

-  uint uVar1;

-  longlong lVar2;

+  short sVar1;

+  char cVar2;

   ulonglong uVar3;

-  undefined1 uVar4;

-  char *in_RAX;

-  undefined8 uVar5;

-  undefined **ppuVar6;

-  uint *puVar7;

-  int unaff_EBP;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  int unaff_R14D;

-  undefined4 uStack0000000000000028;

-  uint uStack0000000000000030;

-  uint uStack0000000000000038;

-  uint uStack0000000000000050;

-  undefined8 uStack0000000000000060;

-  longlong in_stack_000000c0;

-  short sStack00000000000000c8;

-  short in_stack_000000d0;

-  uint in_stack_000000d8;

+  byte bVar4;

+  int *piVar5;

+  ulonglong uVar6;

+  uint uVar7;

+  int iVar8;

+  byte local_res20 [8];

+  undefined2 local_24;

+  ushort local_20 [4];

   

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

-  _sStack00000000000000c8 = in_RAX;

-  uStack0000000000000060 = PsGetCurrentThreadId();

-  uVar4 = KfRaiseIrql(0xf);

-  KeAcquireSpinLockAtDpcLevel(unaff_RSI + 8);

-  uVar1 = *(uint *)(unaff_RSI + 0x24);

-  if (uVar1 != 0) {

-    puVar7 = (uint *)(((ulonglong)(uVar1 - 1) % (ulonglong)PciCfgAccessLogSize) * 0x30 +

-                     *(longlong *)(unaff_RSI + 0x28));

-    if ((((((*puVar7 & 2) != 0) && ((*puVar7 & 1) == 0)) && ((short)puVar7[1] == in_stack_000000d0))

-        && ((*(short *)((longlong)puVar7 + 6) == sStack00000000000000c8 &&

-            ((short)puVar7[2] == (short)uStack0000000000000060)))) &&

-       (*(longlong *)(puVar7 + 10) == in_stack_000000c0)) {

-      uVar5 = KeQueryInterruptTimePrecise(&stack0x00000068);

-      puVar7[5] = puVar7[5] + 1;

-      *(short *)((longlong)puVar7 + 10) = (short)unaff_R14D;

-      *(short *)(puVar7 + 3) = (short)unaff_EBP;

-      goto LAB_0;

+  local_res20[0] = 0;

+  param_4[0] = 0;

+  param_4[1] = 0;

+  param_4[2] = 0;

+  param_4[3] = 0;

+  param_4[4] = 0;

+  param_4[5] = 0;

+  param_4[6] = 0;

+  param_4[7] = 0;

+  param_4[8] = 0;

+  param_4[9] = 0;

+  param_4[10] = 0;

+  param_4[0xb] = 0;

+  param_4[0xc] = 0;

+  param_4[0xd] = 0;

+  uVar7 = 0;

+  local_24 = 0;

+  local_20[0] = 0;

+  uVar6 = param_2 & 0xffffffff;

+  PciReadSlotConfig(param_1,param_2,param_4,0,2);

+  if (0xfffd < (ushort)(*(short *)param_4 - 1U)) {

+    return 0xc00000c0;

+  }

+  uVar3 = Feature_Servicing_PciCrsDeviceEnumeration__private_IsEnabledDeviceUsageNoInline();

+  if (((((int)uVar3 != 0) && (param_3 != '\0')) && (cVar2 = KeGetCurrentIrql(), cVar2 == '\0')) &&

+     ((*(longlong *)(param_1 + 0x90) != 0 &&

+      (piVar5 = *(int **)(*(longlong *)(param_1 + 0x90) + 0x3f0), piVar5 != (int *)0x0)))) {

+    iVar8 = *piVar5;

+    if (iVar8 != 4) {

+      if (iVar8 == 5) {

+        piVar5 = *(int **)(piVar5 + 0x24e);

+      }

+      else {

+        if (iVar8 != 6) goto LAB_0;

+        piVar5 = *(int **)(piVar5 + 0x27c);

+      }

+      if (piVar5 == (int *)0x0) goto LAB_0;

+    }

+    if ((*(byte *)(piVar5 + 0x27d) >> 4 & 1) != 0) {

+      sVar1 = *(short *)param_4;

+      while (sVar1 == 1) {

+        if (1000000 < uVar7) {

+          return 0xc00000c0;

+        }

+        KeStallExecutionProcessor(100000);

+        uVar7 = uVar7 + 100000;

+        PciReadSlotConfig(param_1,uVar6,param_4,0,2);

+        sVar1 = *(short *)param_4;

+      }

     }

   }

-  uVar3 = (ulonglong)PciCfgAccessLogSize;

-  *(uint *)(unaff_RSI + 0x24) = uVar1 + 1;

-  puVar7 = (uint *)(((ulonglong)uVar1 % uVar3) * 0x30 + *(longlong *)(unaff_RSI + 0x28));

-  *puVar7 = 2;

-  *(short *)((longlong)puVar7 + 10) = (short)unaff_R14D;

-  *(short *)(puVar7 + 3) = (short)unaff_EBP;

-  *(longlong *)(puVar7 + 10) = in_stack_000000c0;

-  *(short *)(puVar7 + 1) = in_stack_000000d0;

-  *(short *)((longlong)puVar7 + 6) = sStack00000000000000c8;

-  *(short *)(puVar7 + 2) = (short)uStack0000000000000060;

-  uVar5 = KeQueryInterruptTimePrecise(&stack0x00000068);

-  *(undefined8 *)(puVar7 + 6) = uVar5;

-  puVar7[5] = 1;

 LAB_0:

-  *(undefined8 *)(puVar7 + 8) = uVar5;

-  *puVar7 = *puVar7 | 4;

-  puVar7[4] = in_stack_000000d8;

-  KeReleaseSpinLockFromDpcLevel(unaff_RSI + 8);

-  KeLowerIrql(uVar4);

-  uStack0000000000000050 = 0x1000;

-  if ((*(uint *)(unaff_RDI + 0x698) >> 0x10 & 1) == 0) {

-    uStack0000000000000050 = 0x100;

+  PciReadSlotConfig(param_1,uVar6,param_4 + 2,2,2);

+  PciReadSlotConfig(param_1,uVar6,param_4 + 4,8,1);

+  PciReadSlotConfig(param_1,param_2 & 0xffffffff,param_4 + 5,9,1);

+  PciReadSlotConfig(param_1,param_2 & 0xffffffff,param_4 + 6,10,1);

+  PciReadSlotConfig(param_1,param_2 & 0xffffffff,param_4 + 7,0xb,1);

+  PciReadSlotConfig(param_1,uVar6,param_4 + 0xc,0xe,1);

+  bVar4 = param_4[0xc] & 0x7f;

+  if ((param_4[0xc] & 0x7f) == 0) {

+    PciReadSlotConfig(param_1,uVar6,param_4 + 8,0x2c,2);

+    iVar8 = 0x2e;

   }

-  if (uStack0000000000000050 < (uint)(unaff_R14D + unaff_EBP)) {

-    ppuVar6 = &WPP_RECORDER_INITIALIZED;

-    if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-       (ppuVar6 = (undefined **)(ulonglong)PciSkipWppTracing, PciSkipWppTracing == 0)) {

-      uStack0000000000000030 = *(uint *)(unaff_RDI + 0x24) & 0x1f;

-      uStack0000000000000038 = *(uint *)(unaff_RDI + 0x24) >> 5 & 7;

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

-      ppuVar6 = (undefined **)

-                WPP_RECORDER_SF_DDDDDD

-                          (*(undefined8 *)(*(longlong *)(unaff_RDI + 0x90) + 0x370),

-                           (ulonglong)uStack0000000000000030,7,0x10,

-                           &WPP_cd5fa9d375eb33698645c11310c46e53_Traceguids);

+  else if (bVar4 == 1) {

+    PciReadSlotConfig(param_1,uVar6,(byte *)local_20,6,2);

+    if ((local_20[0] & 0x10) == 0) {

+      return 0;

     }

+    PciReadSlotConfig(param_1,uVar6,local_res20,0x34,1);

+    if (local_res20[0] == 0) {

+      return 0;

+    }

+    while( true ) {

+      if (local_res20[0] < 0x40) {

+        return 0xc0000186;

+      }

+      if ((local_res20[0] & 3) != 0) {

+        return 0xc0000186;

+      }

+      if (local_res20[0] == 0xff) {

+        return 0xc0000186;

+      }

+      PciReadSlotConfig(param_1,uVar6,(byte *)&local_24,(uint)local_res20[0],2);

+      if ((byte)local_24 == 0xd) break;

+      local_res20[0] = local_24._1_1_;

+      if (local_24._1_1_ == 0) {

+        return 0;

+      }

+    }

+    PciReadSlotConfig(param_1,uVar6,param_4 + 8,local_res20[0] + 4,2);

+    iVar8 = local_res20[0] + 6;

   }

   else {

-    lVar2 = *(longlong *)(*(longlong *)(unaff_RDI + 0x88) + 0x20);

-    ppuVar6 = (undefined **)

-              (**(code **)(lVar2 + 0x28))

-                        (*(undefined8 *)(lVar2 + 8),*(undefined4 *)(unaff_RDI + 0x20),

-                         *(undefined4 *)(unaff_RDI + 0x24));

-    if ((int)ppuVar6 != unaff_EBP) {

-                    /* WARNING: Subroutine does not return */

-      KeBugCheckEx(0xc0,*(undefined4 *)(unaff_RDI + 0x20),*(undefined4 *)(unaff_RDI + 0x24));

+    if (bVar4 != 2) {

+      return 0xc0000186;

     }

+    PciReadSlotConfig(param_1,uVar6,param_4 + 8,0x40,2);

+    iVar8 = 0x42;

   }

-  return ppuVar6;

+  PciReadSlotConfig(param_1,uVar6,param_4 + 10,iVar8,2);

+  return 0;

 }
```

## `ExpressSaveTphRequesterCapability`  (modified)

```diff
--- ExpressSaveTphRequesterCapability
+++ ExpressSaveTphRequesterCapability
@@ -1,42 +1,90 @@
+

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

 

 int ExpressSaveTphRequesterCapability(longlong param_1)

 

 {

-  char *pcVar1;

-  char cVar2;

-  int iVar3;

-  char *in_RAX;

-  ulonglong unaff_RBX;

-  longlong unaff_RBP;

-  undefined4 unaff_ESI;

-  char unaff_DIL;

-  int iVar4;

-  longlong unaff_R14;

-  int unaff_R15D;

+  uint uVar1;

+  int iVar2;

+  undefined8 uVar3;

+  ulonglong uVar4;

+  uint uVar5;

+  ulonglong uVar6;

+  ushort *puVar7;

+  undefined1 auStackY_a8 [32];

+  int local_78;

+  int local_74;

+  ushort local_70 [12];

+  undefined8 local_58 [4];

+  int *local_38;

+  undefined4 local_30;

+  undefined4 local_2c;

+  int *local_28;

+  undefined4 local_20;

+  undefined4 local_1c;

+  ulonglong local_18;

   

-  cVar2 = (char)in_RAX + *in_RAX;

-  pcVar1 = (char *)((unaff_RBX - 8) + param_1 * 4);

-  *pcVar1 = *pcVar1 + cVar2;

-  iVar4 = (int)CONCAT71((int7)((ulonglong)in_RAX >> 8),cVar2);

-  iVar3 = 0;

-  if (iVar4 != 0) {

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

-      iVar4 = iVar4 + 8;

-      PciReadConfigRaw(unaff_R14,unaff_ESI,unaff_RBX & 0xffffffff,(byte *)(unaff_RBP + -0x10),iVar4,

-                       2);

-      *(ushort *)(unaff_RBP + -0x10) = *(ushort *)(unaff_RBP + -0x10) | 0x10;

-      PciWriteConfigRaw(unaff_R14,unaff_ESI,(uint)unaff_RBX,(byte *)(unaff_RBP + -0x10),iVar4,2);

+  local_18 = __security_cookie ^ (ulonglong)auStackY_a8;

+  uVar6 = (ulonglong)*(ushort *)(param_1 + 0x964);

+  local_70[0] = 0;

+  local_70[1] = 0;

+  local_70[2] = 0;

+  local_70[3] = 0;

+  local_70[4] = 0;

+  local_70[5] = 0;

+  puVar7 = (ushort *)0xc;

+  local_70[6] = 0;

+  PciReadDeviceConfig(*(longlong *)(param_1 + 8),(byte *)(param_1 + 0x968),

+                      (uint)*(ushort *)(param_1 + 0x964),0xc);

+  uVar5 = (*(uint *)(param_1 + 0x96c) >> 0x10 & 0x7ff) + 1;

+  uVar1 = *(uint *)(param_1 + 0x96c) >> 9 & 3;

+  if (uVar1 == 0) {

+    iVar2 = 0;

+  }

+  else {

+    if (uVar1 == 1) {

+      uVar3 = ExpressSaveTphStEntries(param_1,uVar5);

+      iVar2 = (int)uVar3;

     }

-    PciReadConfigRaw(unaff_R14,unaff_ESI,unaff_RBX & 0xffffffff,(byte *)(unaff_RBP + -4),

-                     unaff_R15D + 0x14,2);

-    PciReadConfigRaw(unaff_R14,unaff_ESI,unaff_RBX & 0xffffffff,(byte *)(unaff_RBP + -0xc),

-                     unaff_R15D + 0xe,2);

-    PciReadConfigRaw(unaff_R14,unaff_ESI,unaff_RBX & 0xffffffff,(byte *)(unaff_RBP + -8),

-                     unaff_R15D + 0x16,2);

-    iVar3 = (uint)(ushort)(*(short *)(unaff_RBP + -0xc) - 1) * (uint)*(ushort *)(unaff_RBP + -8);

-    iVar3 = CONCAT22((short)((uint)iVar3 >> 0x10),

-                     (ushort)((short)iVar3 + *(short *)(unaff_RBP + -4)) >> 8);

+    else {

+      if (uVar1 != 2) {

+        iVar2 = -0x3ffffff3;

+        goto LAB_0;

+      }

+      uVar3 = ExpressSaveTphMsiXStEntries(param_1,uVar5);

+      iVar2 = (int)uVar3;

+    }

+    if (iVar2 < 0) goto LAB_0;

   }

-  return iVar3;

+  puVar7 = local_70;

+  uVar6 = 0;

+  uVar3 = PciReadSlotIdData(*(longlong *)(*(longlong *)(param_1 + 8) + 0x90),

+                            (ulonglong)*(uint *)(*(longlong *)(param_1 + 8) + 0x24),'\0',

+                            (byte *)puVar7);

+  if ((-1 < (int)uVar3) &&

+     (uVar4 = PciIsSameDevice(*(longlong *)(param_1 + 8),local_70), (char)uVar4 != '\0')) {

+    *(undefined1 *)(param_1 + 0x966) = 1;

+    LOCK();

+    PciDebugTphSaveDone = PciDebugTphSaveDone + 1;

+    UNLOCK();

+    return iVar2;

+  }

+LAB_0:

+  *(undefined1 *)(param_1 + 0x966) = 0;

+  LOCK();

+  PciDebugTphSaveNotDone = PciDebugTphSaveNotDone + 1;

+  UNLOCK();

+  if ((5 < DAT_1) && (uVar4 = _tlgKeywordOn(), (char)uVar4 != '\0')) {

+    local_2c = 0;

+    local_78 = PciDebugTphSaveNotDone;

+    local_38 = &local_78;

+    local_1c = 0;

+    local_74 = PciDebugTphSaveDone;

+    local_28 = &local_74;

+    local_30 = 4;

+    local_20 = 4;

+    _tlgWriteTransfer_EtwWriteTransfer(4,&DAT_2,uVar6,puVar7,4,local_58);

+  }

+  return iVar2;

 }
```

## `ext_ms_win_ntos_ksr_l1_1_5_KsrFreePersistedMemory`  (modified)

```diff
--- ext_ms_win_ntos_ksr_l1_1_5_KsrFreePersistedMemory
+++ ext_ms_win_ntos_ksr_l1_1_5_KsrFreePersistedMemory
@@ -1,9 +1,7 @@
 

 undefined8 ext_ms_win_ntos_ksr_l1_1_5_KsrFreePersistedMemory(void)

 

 {

-  undefined8 in_RAX;

-  

-  return in_RAX;

+  return 0xc00000bb;

 }
```

## `ExpressBridgeSetTargetLinkSpeed`  (modified)

```diff
--- ExpressBridgeSetTargetLinkSpeed
+++ ExpressBridgeSetTargetLinkSpeed
@@ -1,157 +1,118 @@
 

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

-

-ulonglong ExpressBridgeSetTargetLinkSpeed(longlong param_1,uint param_2)

+int ExpressBridgeSetTargetLinkSpeed(int *param_1,uint param_2)

 

 {

-  int *in_RAX;

-  longlong lVar1;

-  ulonglong uVar2;

-  char *pcVar3;

-  undefined4 in_register_00000014;

-  longlong lVar4;

-  char *pcStack0000000000000028;

-  undefined1 *puStack0000000000000030;

-  undefined1 *puStack0000000000000038;

-  char *pcStack0000000000000040;

-  char *pcStack0000000000000048;

-  char *pcStack0000000000000050;

-  char *pcStack0000000000000058;

-  undefined1 *puStack0000000000000060;

-  undefined1 *puStack0000000000000068;

-  char *pcStack0000000000000070;

-  char *pcStack0000000000000078;

-  longlong lStack0000000000000080;

-  undefined8 uStack0000000000000088;

-  char *in_stack_000000e8;

-  char *in_stack_000000f8;

-  char *in_stack_00000100;

-  char *in_stack_00000110;

+  ushort *puVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  int iVar4;

+  ulonglong uVar5;

+  undefined8 uVar6;

+  ushort uVar7;

+  undefined2 uVar8;

+  undefined8 in_stack_ffffffffffffffc8;

+  undefined4 uVar9;

   

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

-  pcStack0000000000000048 = (char *)0x5;

-  if (((*(uint *)(CONCAT44(in_register_00000014,param_2) + 0x2c) & 2) != 0) &&

-     (3 < *(byte *)(CONCAT44(in_register_00000014,param_2) + 0x29))) {

-    pcStack0000000000000078 = pcStack0000000000000048;

-    if (in_stack_00000110 != (char *)0x0) {

-      lVar4 = -1;

-      do {

-        lVar1 = lVar4;

-        lVar4 = lVar1 + 1;

-      } while (in_stack_00000110[lVar4] != '\0');

-      pcStack0000000000000078 = (char *)(lVar1 + 2);

-    }

-    pcStack0000000000000070 = in_stack_00000110;

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

-      pcStack0000000000000070 = "NULL";

-    }

-    pcStack0000000000000058 = pcStack0000000000000048;

-    if (in_stack_00000100 != (char *)0x0) {

-      lVar4 = -1;

-      do {

-        lVar1 = lVar4;

-        lVar4 = lVar1 + 1;

-      } while (in_stack_00000100[lVar4] != '\0');

-      pcStack0000000000000058 = (char *)(lVar1 + 2);

-    }

-    pcStack0000000000000050 = in_stack_00000100;

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

-      pcStack0000000000000050 = "NULL";

-    }

-    if (in_stack_000000f8 != (char *)0x0) {

-      lVar4 = -1;

-      do {

-        lVar1 = lVar4;

-        lVar4 = lVar1 + 1;

-      } while (in_stack_000000f8[lVar4] != '\0');

-      pcStack0000000000000048 = (char *)(lVar1 + 2);

-    }

-    pcStack0000000000000040 = in_stack_000000f8;

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

-      pcStack0000000000000040 = "NULL";

-    }

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

-      pcStack0000000000000028 = (char *)0x5;

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

+  uVar7 = 0;

+  if ((*(byte *)(param_1 + 0x14) & 0xf) < 2) {

+    iVar4 = -0x3fffff45;

+  }

+  else if (((uint)param_1[0x25c] >> (param_2 & 0x1f) & 1) == 0) {

+    iVar4 = -0x3fffff10;

+  }

+  else {

+    iVar4 = ExpressBridgeLinkSpeedTargetMatchesCurrent((longlong)param_1,(short)param_2);

+    if ((char)iVar4 == '\0') {

+      lVar2 = **(longlong **)(param_1 + 2);

+      iVar4 = IoAcquireRemoveLockEx(lVar2 + 0x20,0,"",1,CONCAT44(uVar9,0x20));

+      if (iVar4 < 0) {

+        iVar4 = -0x3fffffaa;

+      }

+      else {

+        plVar3 = *(longlong **)(param_1 + 2);

+        puVar1 = (ushort *)((longlong)param_1 + 0x94a);

+        PciReadSlotConfig(*(longlong *)(*plVar3 + 0x68),(ulonglong)*(uint *)(plVar3 + 1),

+                          (byte *)puVar1,*(byte *)((longlong)plVar3 + 0x3a1) + 0x30,2);

+        *puVar1 = ((short)param_2 + 1U ^ *puVar1) & 0xf ^ *puVar1;

+        plVar3 = *(longlong **)(param_1 + 2);

+        PciWriteSlotConfig(*(longlong *)(*plVar3 + 0x68),*(uint *)(plVar3 + 1),(byte *)puVar1,

+                           *(byte *)((longlong)plVar3 + 0x3a1) + 0x30,2);

+        uVar5 = Feature_Servicing_PciDisableAspmDuringLinkRetrain__private_IsEnabledDeviceUsageNoInline

+                          ();

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

+          uVar6 = ExpressBridgeTriggerLinkRetrain((longlong)param_1);

+          iVar4 = (int)uVar6;

+        }

+        else {

+          uVar5 = ExpressBridgeRetrainLink(param_1);

+          iVar4 = (int)uVar5;

+        }

+        uVar5 = Feature_Servicing_PciDisableAspmDuringLinkRetrain__private_IsEnabledDeviceUsageNoInline

+                          ();

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

+          plVar3 = *(longlong **)(param_1 + 2);

+          PciReadSlotConfig(*(longlong *)(*plVar3 + 0x68),(ulonglong)*(uint *)(plVar3 + 1),

+                            (byte *)(param_1 + 0x252),*(byte *)((longlong)plVar3 + 0x3a1) + 0x12,2);

+          uVar7 = (*(ushort *)(param_1 + 0x252) & 0xf) - 1;

+        }

+        IoReleaseRemoveLockEx(lVar2 + 0x20,0,0x20);

+        uVar5 = Feature_Servicing_PciDisableAspmDuringLinkRetrain__private_IsEnabledDeviceUsageNoInline

+                          ();

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

+          if (-1 < iVar4) {

+            if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

+               (PciSkipWppTracing == '\0')) {

+              WPP_RECORDER_SF_qd(*(undefined8 *)(**(longlong **)(param_1 + 2) + 0x370),3,6,0xf,

+                                 &WPP_ede2d48580643fef9acd500631e15471_Traceguids);

+            }

+            plVar3 = *(longlong **)(param_1 + 2);

+            PciReadSlotConfig(*(longlong *)(*plVar3 + 0x68),(ulonglong)*(uint *)(plVar3 + 1),

+                              (byte *)(param_1 + 0x252),*(byte *)((longlong)plVar3 + 0x3a1) + 0x12,2

+                             );

+            return iVar4;

+          }

+          if ((undefined **)WPP_RECORDER_INITIALIZED == &WPP_RECORDER_INITIALIZED) {

+            return iVar4;

+          }

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

+            return iVar4;

+          }

+          uVar8 = 0x10;

+        }

+        else {

+          if ((iVar4 < 0) || (uVar7 != param_2)) {

+            if ((undefined **)WPP_RECORDER_INITIALIZED == &WPP_RECORDER_INITIALIZED) {

+              return iVar4;

+            }

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

+              return iVar4;

+            }

+            WPP_RECORDER_SF_qDD(*(undefined8 *)(**(longlong **)(param_1 + 2) + 0x370),3,6,0xe,

+                                &WPP_ede2d48580643fef9acd500631e15471_Traceguids);

+            return iVar4;

+          }

+          if ((undefined **)WPP_RECORDER_INITIALIZED == &WPP_RECORDER_INITIALIZED) {

+            return iVar4;

+          }

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

+            return iVar4;

+          }

+          uVar8 = 0xd;

+        }

+        WPP_RECORDER_SF_qd(*(undefined8 *)(**(longlong **)(param_1 + 2) + 0x370),3,6,uVar8,

+                           &WPP_ede2d48580643fef9acd500631e15471_Traceguids);

+      }

     }

     else {

-      lVar4 = -1;

-      do {

-        lVar1 = lVar4;

-        lVar4 = lVar1 + 1;

-      } while (in_stack_000000e8[lVar4] != '\0');

-      pcStack0000000000000028 = (char *)(lVar1 + 2);

+      if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

+         (PciSkipWppTracing == '\0')) {

+        WPP_RECORDER_SF_qd(*(undefined8 *)(**(longlong **)(param_1 + 2) + 0x370),3,6,0xc,

+                           &WPP_ede2d48580643fef9acd500631e15471_Traceguids);

+      }

+      iVar4 = 0;

     }

-    pcVar3 = in_stack_000000e8;

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

-      pcVar3 = "NULL";

-    }

-    lStack0000000000000080 = 0;

-    puStack0000000000000060 = &stack0x00000108;

-    puStack0000000000000068 = (undefined1 *)0x8;

-    puStack0000000000000030 = &stack0x000000f0;

-    puStack0000000000000038 = (undefined1 *)0x4;

-    (*pfnWppTraceMessage)

-              (*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x2b,

-               &WPP_8b0134a0f3e237a4893cae301d3e7733_Traceguids,0x10,pcVar3);

   }

-  puStack0000000000000030 = (undefined1 *)0x5;

-  lStack0000000000000080 = (longlong)puStack0000000000000030;

-  if (in_stack_00000110 != (char *)0x0) {

-    lVar4 = -1;

-    do {

-      lVar1 = lVar4;

-      lVar4 = lVar1 + 1;

-    } while (in_stack_00000110[lVar4] != '\0');

-    lStack0000000000000080 = lVar1 + 2;

-  }

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

-    in_stack_00000110 = "NULL";

-  }

-  puStack0000000000000060 = puStack0000000000000030;

-  if (in_stack_00000100 != (char *)0x0) {

-    lVar4 = -1;

-    do {

-      lVar1 = lVar4;

-      lVar4 = lVar1 + 1;

-    } while (in_stack_00000100[lVar4] != '\0');

-    puStack0000000000000060 = (undefined1 *)(lVar1 + 2);

-  }

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

-    in_stack_00000100 = "NULL";

-  }

-  pcStack0000000000000050 = puStack0000000000000030;

-  if (in_stack_000000f8 != (char *)0x0) {

-    lVar4 = -1;

-    do {

-      lVar1 = lVar4;

-      lVar4 = lVar1 + 1;

-    } while (in_stack_000000f8[lVar4] != '\0');

-    pcStack0000000000000050 = (char *)(lVar1 + 2);

-  }

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

-    in_stack_000000f8 = "NULL";

-  }

-  lVar4 = -1;

-  if (in_stack_000000e8 != (char *)0x0) {

-    do {

-      lVar1 = lVar4;

-      lVar4 = lVar1 + 1;

-    } while (in_stack_000000e8[lVar4] != '\0');

-    puStack0000000000000030 = (undefined1 *)(lVar1 + 2);

-  }

-  uStack0000000000000088 = 0;

-  puStack0000000000000068 = &stack0x00000108;

-  pcStack0000000000000070 = (char *)0x8;

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

-    in_stack_000000e8 = "NULL";

-  }

-  puStack0000000000000038 = &stack0x000000f0;

-  pcStack0000000000000040 = (char *)0x4;

-  pcStack0000000000000028 = in_stack_000000e8;

-  pcStack0000000000000048 = in_stack_000000f8;

-  pcStack0000000000000058 = in_stack_00000100;

-  pcStack0000000000000078 = in_stack_00000110;

-  uVar2 = WppAutoLogTrace(param_1,4,2,&WPP_8b0134a0f3e237a4893cae301d3e7733_Traceguids,0x10);

-  return uVar2;

+  return iVar4;

 }
```

## `PciBridgeReevaluateWindows`  (modified)

```diff
--- PciBridgeReevaluateWindows
+++ PciBridgeReevaluateWindows
@@ -1,10 +1,37 @@
 

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

-

-void PciBridgeReevaluateWindows(longlong *param_1)

+void PciBridgeReevaluateWindows(longlong param_1)

 

 {

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

-  halt_baddata();

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

+    *(undefined1 *)(param_1 + 0xf0) = 0;

+    *(undefined8 *)(param_1 + 0xf8) = 0x1000;

+    *(undefined8 *)(param_1 + 0x100) = 0x1000;

+  }

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

+    *(undefined1 *)(param_1 + 400) = 0;

+    *(undefined8 *)(param_1 + 0x198) = 0x1000;

+    *(undefined8 *)(param_1 + 0x1a0) = 0x1000;

+  }

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

+    *(undefined1 *)(param_1 + 0xb0) = 0;

+    *(undefined8 *)(param_1 + 0xb8) = 0x100000;

+    *(undefined8 *)(param_1 + 0xc0) = 0x100000;

+  }

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

+    *(undefined1 *)(param_1 + 0x150) = 0;

+    *(undefined8 *)(param_1 + 0x158) = 0x100000;

+    *(undefined8 *)(param_1 + 0x160) = 0x100000;

+  }

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

+    *(undefined1 *)(param_1 + 0xd0) = 0;

+    *(undefined8 *)(param_1 + 0xd8) = 0x100000;

+    *(undefined8 *)(param_1 + 0xe0) = 0x100000;

+  }

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

+    *(undefined1 *)(param_1 + 0x170) = 0;

+    *(undefined8 *)(param_1 + 0x178) = 0x100000;

+    *(undefined8 *)(param_1 + 0x180) = 0x100000;

+  }

+  return;

 }
```

## `PciDevice_Eject`  (modified)

```diff
--- PciDevice_Eject
+++ PciDevice_Eject
@@ -1,250 +1,40 @@
 

-ulonglong PciDevice_Eject(longlong param_1,ulonglong param_2,longlong param_3)

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

+

+ulonglong PciDevice_Eject(longlong param_1,undefined8 param_2,longlong param_3)

 

 {

-  longlong lVar1;

+  uint uVar1;

   ulonglong uVar2;

-  ulonglong uVar3;

-  undefined8 uVar4;

-  ulonglong in_RAX;

-  ulonglong uVar5;

-  undefined8 *puVar6;

-  longlong lVar7;

-  undefined8 *puVar8;

-  undefined8 *puVar9;

-  ulonglong uVar10;

-  longlong unaff_RBP;

-  uint uVar11;

-  longlong lVar12;

-  longlong unaff_RDI;

-  undefined8 uVar13;

-  ulonglong uVar14;

-  ulonglong in_R9;

-  char cVar15;

-  ulonglong unaff_R12;

-  uint *puVar16;

-  int iVar17;

+  undefined8 uVar3;

+  undefined1 auStack_48 [32];

+  ushort local_28 [8];

+  ulonglong local_18;

   

-  if (in_RAX < in_R9) {

-    in_R9 = in_RAX;

-  }

-  uVar13 = 0;

-  *(ulonglong *)(unaff_RBP + -0x19) = in_R9;

-  uVar5 = PciFpbFindLongestConsecutiveMemoryRangeAvailable

-                    ((longlong *)param_1,param_2,'\0',(ulonglong *)(unaff_RBP + 0x67));

-  uVar10 = *(ulonglong *)(*(longlong *)(unaff_RDI + 0x3c8) + 0xf8);

-  if (uVar5 < uVar10) {

-    uVar10 = uVar5;

-  }

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

-  if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-     (uVar5 = CONCAT71((int7)(uVar5 >> 8),PciSkipWppTracing), PciSkipWppTracing == '\0')) {

-    uVar5 = WPP_RECORDER_SF_qDii(*(undefined8 *)(unaff_RDI + 0x370),uVar10,uVar13,0x31);

-  }

-  if ((*(ulonglong *)(unaff_RBP + -0x19) == unaff_R12) &&

-     (*(ulonglong *)(unaff_RBP + -0x11) == unaff_R12)) {

-    return uVar5;

-  }

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

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

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

-  KeEnterCriticalRegion();

-  uVar10 = 0;

-  KeWaitForSingleObject(unaff_RDI + 0xa8,0);

-  lVar7 = *(longlong *)(unaff_RDI + 0x98);

-  if (lVar7 != 0) {

-    do {

-      puVar6 = PciFindResourceHintBySlot(*(longlong *)(unaff_RDI + 0x3c8),*(int *)(lVar7 + 0x24));

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

-        if (puVar6[0xc] != unaff_R12) {

-          if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-             (PciSkipWppTracing == '\0')) {

-            uVar10 = (ulonglong)(*(uint *)(lVar7 + 0x24) & 0x1f);

-            WPP_RECORDER_SF_DDDiii(*(undefined8 *)(unaff_RDI + 0x370),puVar6[0xc],uVar10,0x32);

-          }

-          *(longlong *)(unaff_RBP + -9) = *(longlong *)(unaff_RBP + -9) + puVar6[0xc];

-        }

-        if (puVar6[0xd] != unaff_R12) {

-          if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-             (PciSkipWppTracing == '\0')) {

-            uVar10 = (ulonglong)(*(uint *)(lVar7 + 0x24) & 0x1f);

-            WPP_RECORDER_SF_DDDiii(*(undefined8 *)(unaff_RDI + 0x370),puVar6[0xd],uVar10,0x33);

-          }

-          *(longlong *)(unaff_RBP + -1) = *(longlong *)(unaff_RBP + -1) + puVar6[0xd];

-        }

-        cVar15 = (char)unaff_R12;

-        if (*(char *)((longlong)puVar6 + 0x46) == cVar15) {

-          if (*(char *)(puVar6 + 0xe) == cVar15) {

-            if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-               (PciSkipWppTracing == '\0')) {

-              uVar10 = (ulonglong)(*(uint *)(lVar7 + 0x24) & 0x1f);

-              WPP_RECORDER_SF_DDDiii(*(undefined8 *)(unaff_RDI + 0x370),puVar6[0xf],uVar10,0x35);

-            }

-            *(longlong *)(unaff_RBP + -9) = *(longlong *)(unaff_RBP + -9) + puVar6[0xf];

-          }

-          if (*(char *)(puVar6 + 0x12) == cVar15) {

-            if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-               (PciSkipWppTracing == '\0')) {

-              uVar10 = (ulonglong)(*(uint *)(lVar7 + 0x24) & 0x1f);

-              WPP_RECORDER_SF_DDDiii(*(undefined8 *)(unaff_RDI + 0x370),puVar6[0x13],uVar10,0x36);

-            }

-            *(longlong *)(unaff_RBP + -1) = *(longlong *)(unaff_RBP + -1) + puVar6[0x13];

-          }

-          if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-             (PciSkipWppTracing == '\0')) {

-            WPP_RECORDER_SF_DDDii

-                      (*(undefined8 *)(unaff_RDI + 0x370),

-                       (ulonglong)(*(uint *)(lVar7 + 0x24) & 0x1f),uVar10,0x37);

-          }

-        }

-        else {

-          *(int *)(unaff_RBP + 0x6f) = *(int *)(unaff_RBP + 0x6f) + 1;

-          *(int *)(unaff_RBP + 0x73) = *(int *)(unaff_RBP + 0x73) + 1;

-          *(undefined2 *)((longlong)puVar6 + 0x47) = 0;

-          if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-             (PciSkipWppTracing == '\0')) {

-            WPP_RECORDER_SF_DDDiiii(*(undefined8 *)(unaff_RDI + 0x370));

-          }

-        }

-      }

-      lVar7 = *(longlong *)(lVar7 + 0x98);

-    } while (lVar7 != 0);

-    if ((*(int *)(unaff_RBP + 0x6f) != (int)unaff_R12) ||

-       (*(int *)(unaff_RBP + 0x73) != (int)unaff_R12)) {

-      uVar5 = unaff_R12 & 0xffffffff;

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

-      uVar10 = unaff_R12;

-      do {

-        uVar2 = *(ulonglong *)(unaff_RBP + -0x19 + uVar10);

-        uVar3 = *(ulonglong *)(unaff_RBP + -9 + uVar10);

-        uVar14 = unaff_R12;

-        if (uVar3 < uVar2) {

-          uVar14 = uVar2 - uVar3;

-        }

-        *(ulonglong *)(unaff_RBP + -0x19 + uVar10) = uVar14;

-        uVar11 = *puVar16;

-        *(ulonglong *)(unaff_RBP + 7 + uVar10) = uVar14 / uVar11;

-        if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-           (PciSkipWppTracing == '\0')) {

-          WPP_RECORDER_SF_qDsidi

-                    (*(undefined8 *)(unaff_RDI + 0x370),uVar14 % (ulonglong)uVar11,uVar14,0x39);

-        }

-        uVar11 = (int)uVar5 + 1;

-        uVar5 = (ulonglong)uVar11;

-        puVar16 = puVar16 + 1;

-        uVar10 = uVar10 + 8;

-      } while ((int)uVar11 < 2);

-      while( true ) {

-        if ((*(uint *)(unaff_RBP + 0x6f) <= (uint)unaff_R12) &&

-           (*(uint *)(unaff_RBP + 0x73) <= (uint)unaff_R12)) goto LAB_0;

-        if ((*(ulonglong *)(unaff_RBP + -0x19) == unaff_R12) &&

-           (*(ulonglong *)(unaff_RBP + -0x11) == unaff_R12)) break;

-        uVar10 = unaff_R12 & 0xffffffff;

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

-        *(uint **)(unaff_RBP + 0x77) = puVar16;

-        do {

-          lVar7 = 0;

-          uVar11 = *puVar16;

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

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

-          iVar17 = (int)uVar10;

-          if (uVar11 != 0) {

-            lVar12 = *(longlong *)(unaff_RDI + 0x98);

-            lVar1 = unaff_R12 * 8;

-            if (lVar12 != 0) {

-              do {

-                puVar6 = PciFindResourceHintBySlot

-                                   (*(longlong *)(unaff_RDI + 0x3c8),*(int *)(lVar12 + 0x24));

-                if (((puVar6 == (undefined8 *)0x0) || (*(char *)((longlong)puVar6 + 0x46) == '\0'))

-                   || (*(char *)(unaff_R12 + 0x47 + (longlong)puVar6) != '\0')) {

-LAB_1:

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

-                }

-                else {

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

-                  if (iVar17 == 0) {

-                    uVar10 = puVar6[0xf];

-                    puVar8 = puVar6 + 0x1a;

-                    puVar9 = puVar6 + 0xe;

-                  }

-                  else {

-                    uVar10 = puVar6[0x13];

-                    puVar8 = puVar6 + 0x1e;

-                    puVar9 = puVar6 + 0x12;

-                  }

-                  if (uVar10 <= *(ulonglong *)(unaff_RBP + 7 + lVar1)) goto LAB_1;

-                  *(undefined1 *)(unaff_R12 + 0x47 + (longlong)puVar6) = 1;

-                  uVar11 = uVar11 - 1;

-                  uVar13 = puVar9[1];

-                  puVar16 = *(uint **)(unaff_RBP + 0x77);

-                  *puVar8 = *puVar9;

-                  puVar8[1] = uVar13;

-                  uVar13 = puVar9[2];

-                  uVar4 = puVar9[3];

-                  *puVar16 = uVar11;

-                  puVar8[2] = uVar13;

-                  puVar8[3] = uVar4;

-                  if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-                     (PciSkipWppTracing == '\0')) {

-                    WPP_RECORDER_SF_DDDsii(*(undefined8 *)(unaff_RDI + 0x370));

-                  }

-                  lVar7 = 0;

-                  uVar5 = *(ulonglong *)(unaff_RBP + -0x19 + lVar1);

-                  if (uVar10 < uVar5) {

-                    lVar7 = uVar5 - uVar10;

-                  }

-                  *(longlong *)(unaff_RBP + -0x19 + lVar1) = lVar7;

-                  cVar15 = '\0';

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

-                }

-                lVar12 = *(longlong *)(lVar12 + 0x98);

-              } while (lVar12 != 0);

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

-                if (uVar11 != 0) {

-                  uVar10 = *(ulonglong *)(unaff_RBP + -0x19 + unaff_R12 * 8);

-                  *(ulonglong *)(unaff_RBP + 7 + unaff_R12 * 8) = uVar10 / uVar11;

-                  if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-                     (PciSkipWppTracing == '\0')) {

-                    WPP_RECORDER_SF_qDsidi

-                              (*(undefined8 *)(unaff_RDI + 0x370),"prefetch",uVar10,0x3c);

-                  }

-                }

-                puVar16 = *(uint **)(unaff_RBP + 0x77);

-                goto LAB_2;

-              }

-              puVar16 = *(uint **)(unaff_RBP + 0x77);

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

-            }

-            PciBridgeSpreadExtraResourcesApplyAverage

-                      (unaff_RDI,iVar17,*(longlong *)(unaff_RBP + 7 + lVar1),

-                       *(ulonglong *)(unaff_RBP + -0x19 + lVar1),lVar7);

-            *puVar16 = 0;

-          }

-LAB_2:

-          puVar16 = puVar16 + 1;

-          uVar10 = (ulonglong)(iVar17 + 1U);

-          unaff_R12 = unaff_R12 + 1;

-          *(uint **)(unaff_RBP + 0x77) = puVar16;

-        } while ((int)(iVar17 + 1U) < 2);

-        unaff_R12 = 0;

-      }

-      if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-         (PciSkipWppTracing == '\0')) {

-        WPP_RECORDER_SF_qd(*(undefined8 *)(unaff_RDI + 0x370),4,4,0x3a,

-                           &WPP_85009aef1a87317bf9cbfdaa632c9b2a_Traceguids);

-      }

-      goto LAB_0;

+  local_18 = __security_cookie ^ (ulonglong)auStack_48;

+  uVar1 = *(uint *)(param_1 + 0x30);

+  local_28[0] = 0;

+  local_28[1] = 0;

+  local_28[2] = 0;

+  local_28[3] = 0;

+  local_28[4] = 0;

+  local_28[5] = 0;

+  local_28[6] = 0;

+  if ((*(longlong *)(param_3 + 0xe0) != 0) &&

+     (*(char *)(*(longlong *)(param_3 + 0xe0) + 0xd1) != '\0')) {

+    uVar2 = PciReadSlotIdData(*(longlong *)(param_3 + 0x90),(ulonglong)*(uint *)(param_3 + 0x24),

+                              '\0',(byte *)local_28);

+    uVar1 = (uint)uVar2;

+    if ((int)uVar1 < 0) {

+      return uVar2;

+    }

+    uVar2 = PciIsSameDevice(param_3,local_28);

+    if (((char)uVar2 != '\0') || (local_28[0] == 0xffff)) {

+      uVar3 = PciHandleHotPlugDriverRemoval(*(uint **)(param_3 + 0xe0));

+      uVar1 = (uint)uVar3;

     }

   }

-  if (((undefined **)WPP_RECORDER_INITIALIZED != &WPP_RECORDER_INITIALIZED) &&

-     (PciSkipWppTracing == '\0')) {

-    WPP_RECORDER_SF_qd(*(undefined8 *)(unaff_RDI + 0x370),4,4,0x38,

-                       &WPP_85009aef1a87317bf9cbfdaa632c9b2a_Traceguids);

-  }

-LAB_0:

-  PciBridgeRevalidateSpreadResources(unaff_RDI);

-  KeSetEvent(unaff_RDI + 0xa8,0,0);

-  uVar10 = KeLeaveCriticalRegion();

-  return uVar10;

+  PciDeleteVolatileInterruptRoutingData(param_3);

+  return (ulonglong)uVar1;

 }
```

## `NTOSKRNL.EXE::PsGetCurrentProcessId`  (modified)

```diff
--- NTOSKRNL.EXE::PsGetCurrentProcessId calling
+++ NTOSKRNL.EXE::PsGetCurrentProcessId calling
@@ -9 +8,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KfRaiseIrql`  (modified)

```diff
--- NTOSKRNL.EXE::KfRaiseIrql calling
+++ NTOSKRNL.EXE::KfRaiseIrql calling
@@ -18 +17,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeAcquireSpinLockAtDpcLevel`  (modified)

```diff
--- NTOSKRNL.EXE::KeAcquireSpinLockAtDpcLevel calling
+++ NTOSKRNL.EXE::KeAcquireSpinLockAtDpcLevel calling
@@ -15 +14,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx`  (modified)

```diff
--- NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx calling
+++ NTOSKRNL.EXE::KeGetCurrentProcessorNumberEx calling
@@ -9 +8,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel`  (modified)

```diff
--- NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel calling
+++ NTOSKRNL.EXE::KeReleaseSpinLockFromDpcLevel calling
@@ -12 +11,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeLowerIrql`  (modified)

```diff
--- NTOSKRNL.EXE::KeLowerIrql calling
+++ NTOSKRNL.EXE::KeLowerIrql calling
@@ -15 +14,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeGetCurrentIrql`  (modified)

```diff
--- NTOSKRNL.EXE::KeGetCurrentIrql calling
+++ NTOSKRNL.EXE::KeGetCurrentIrql calling
@@ -16,0 +17 @@
+PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeQueryInterruptTimePrecise`  (modified)

```diff
--- NTOSKRNL.EXE::KeQueryInterruptTimePrecise calling
+++ NTOSKRNL.EXE::KeQueryInterruptTimePrecise calling
@@ -14 +13,0 @@
-PciReadSlotIdData
```

## `NTOSKRNL.EXE::KeBugCheckEx`  (modified)

```diff
--- NTOSKRNL.EXE::KeBugCheckEx calling
+++ NTOSKRNL.EXE::KeBugCheckEx calling
@@ -18 +17,0 @@
-PciReadSlotIdData
```

## `HAL.DLL::KeStallExecutionProcessor`  (modified)

```diff
--- HAL.DLL::KeStallExecutionProcessor calling
+++ HAL.DLL::KeStallExecutionProcessor calling
@@ -3,0 +4 @@
+PciReadSlotIdData
```

## `NTOSKRNL.EXE::IoInvalidateDeviceState`  (modified)

```diff
--- NTOSKRNL.EXE::IoInvalidateDeviceState calling
+++ NTOSKRNL.EXE::IoInvalidateDeviceState calling
@@ -1 +0,0 @@
-PciBridgeReevaluateWindows
```

## `NTOSKRNL.EXE::PsGetCurrentThreadId`  (modified)

```diff
--- NTOSKRNL.EXE::PsGetCurrentThreadId calling
+++ NTOSKRNL.EXE::PsGetCurrentThreadId calling
@@ -9 +8,0 @@
-PciReadSlotIdData
```
