# CVE-2026-119870 — rdbss.sys patch diff

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

## `RxpFinalizeCreateContext`  (modified)

```diff
--- RxpFinalizeCreateContext
+++ RxpFinalizeCreateContext
@@ -1,10 +1,217 @@
-

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

 

 void RxpFinalizeCreateContext(longlong **param_1,undefined8 param_2,longlong ***param_3)

 

 {

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

-  halt_baddata();

+  longlong ****pppplVar1;

+  longlong ***ppplVar2;

+  longlong *plVar3;

+  longlong **pplVar4;

+  undefined8 uVar5;

+  code *pcVar6;

+  undefined1 uVar7;

+  ulonglong uVar8;

+  longlong ***ppplVar9;

+  undefined *puVar10;

+  undefined1 *puVar11;

+  undefined1 *puVar12;

+  undefined8 unaff_RBP;

+  longlong ***unaff_RSI;

+  byte bVar13;

+  longlong ***unaff_R14;

+  undefined8 local_res8 [3];

+  undefined8 uStack_50;

+  undefined1 auStack_48 [32];

+  undefined8 local_28 [2];

+  

+  puVar12 = auStack_48;

+  puVar11 = auStack_48;

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

+     (puVar10 = WPP_GLOBAL_Control, puVar11 = auStack_48,

+     (*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) goto LAB_0;

+  do {

+    *(longlong ****)(puVar11 + 0x58) = unaff_RSI;

+    if ((*(byte *)((longlong)param_1 + 0x2dd) & 1) != 0) {

+      pppplVar1 = (longlong ****)param_1[7];

+      *(undefined8 *)(puVar11 + 0x50) = unaff_RBP;

+      bVar13 = *(byte *)((longlong)pppplVar1[1] + 0x1a) & 0x80;

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x100) != 0)) &&

+         (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+        uVar5 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+        param_3 = (longlong ***)&WPP_574cde0b3c2b3adc35718fe442671205_Traceguids;

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

+        WPP_SF_D(uVar5,0xd,&WPP_574cde0b3c2b3adc35718fe442671205_Traceguids,(uint)bVar13);

+      }

+      if (bVar13 == 0) {

+        if (param_1 < (longlong **)0xfffffffffffffffe) {

+LAB_1:

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

+        }

+      }

+      else if (param_1 < (longlong **)0xfffffffffffffffe) {

+        if ((*(int *)(pppplVar1[0x26] + 0x25) != 0) &&

+           ((*(uint *)((longlong)pppplVar1 + 0x9c) & 0x80000) == 0)) {

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

+          uVar8 = RxIsSafeToProcessBufferingStateChange((longlong)param_1,(longlong)pppplVar1);

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

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

+            RxProcessFcbChangeBufferingStateRequestInternal(pppplVar1,0,(uint *)param_3);

+          }

+        }

+        goto LAB_1;

+      }

+      ppplVar2 = pppplVar1[1];

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

+      ExReleaseResourceLite(ppplVar2);

+      *(byte *)((longlong)param_1 + 0x2dd) = *(byte *)((longlong)param_1 + 0x2dd) & 0xfe;

+      *(ushort *)((longlong)param_1 + 0x2da) = *(ushort *)((longlong)param_1 + 0x2da) & 0xfffb;

+      unaff_RBP = *(undefined8 *)(puVar11 + 0x50);

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

+    }

+    plVar3 = param_1[0x62];

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

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])

+         ) {

+        uVar5 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

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

+        WPP_SF_q(uVar5,0x13,&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,plVar3);

+        FUN_140026fb6();

+        return;

+      }

+      plVar3 = param_1[0x62];

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

+      ExFreePoolWithTag(plVar3);

+      param_1[0x62] = (longlong *)0x0;

+    }

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

+    RxFreeCanonicalNameBuffer((longlong)param_1);

+    pppplVar1 = (longlong ****)param_1[0x50];

+    param_1[0x65] = (longlong *)0x0;

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

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

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

+      RxDereference(pppplVar1,0);

+      param_1[0x50] = (longlong *)0x0;

+    }

+    pppplVar1 = (longlong ****)param_1[0xe];

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

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) &&

+       (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+      uVar5 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

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

+                    /* WARNING: Subroutine does not return */

+      *(undefined **)(puVar11 + -8) = &UNK_2;

+      WPP_SF_qq(uVar5,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+    }

+    *(longlong ****)(puVar11 + 0x60) = unaff_R14;

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

+    if ((*(char *)(param_1 + 4) == '\f') && (*(char *)((longlong)param_1 + 0x21) == '\x02')) {

+      unaff_RSI = pppplVar1[0x1c];

+    }

+    else {

+      unaff_RSI = pppplVar1[0x1b];

+    }

+    if ((*(uint *)(param_1 + 0xf) >> 0x12 & 1) == 0) goto LAB_4;

+    *(uint *)(param_1 + 0xf) = *(uint *)(param_1 + 0xf) & 0xfffbffff;

+    unaff_R14 = pppplVar1[0x1f];

+    if ((unaff_R14 == (longlong ***)0x0) || ((*(uint *)((longlong)unaff_R14 + 0x2c) & 1) == 0))

+    goto LAB_5;

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

+    uVar7 = KeAcquireSpinLockRaiseToDpc(unaff_R14 + 6);

+    param_3 = unaff_R14 + 2;

+    ppplVar2 = (longlong ***)unaff_R14[2];

+    do {

+      ppplVar9 = ppplVar2;

+      if (ppplVar9 == param_3) {

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

+        KeReleaseSpinLock(unaff_R14 + 6,uVar7);

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

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+           (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          uVar5 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

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

+                    /* WARNING: Subroutine does not return */

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

+          WPP_SF_qq(uVar5,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,param_1);

+        }

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

+        (*pcVar6)();

+        return;

+      }

+      ppplVar2 = (longlong ***)*ppplVar9;

+    } while (ppplVar9[7] != param_1);

+    if (((longlong ***)ppplVar2[1] == ppplVar9) &&

+       (pplVar4 = ppplVar9[1], (longlong ***)*pplVar4 == ppplVar9)) {

+      *pplVar4 = (longlong *)ppplVar2;

+      ppplVar2[1] = pplVar4;

+      ppplVar9[7] = (longlong **)0x0;

+      pplVar4 = *unaff_R14;

+      if ((longlong ***)pplVar4[1] == unaff_R14) {

+        *ppplVar9 = pplVar4;

+        ppplVar9[1] = (longlong **)unaff_R14;

+        pplVar4[1] = (longlong *)ppplVar9;

+        *unaff_R14 = (longlong **)ppplVar9;

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

+        KeReleaseSpinLock(unaff_R14 + 6);

+LAB_5:

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

+        RfsReleaseRundownProtectionCacheAware((longlong *)unaff_RSI);

+LAB_4:

+        param_1[0xe] = (longlong *)0x0;

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

+        RxDereference(pppplVar1,0);

+LAB_3:

+        plVar3 = param_1[0x46];

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

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

+          ExFreePoolWithTag(plVar3,0);

+          param_1[0x46] = (longlong *)0x0;

+        }

+        if (*(char *)((longlong)param_1 + 0x2dd) < '\0') {

+          plVar3 = param_1[0x61];

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

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

+            RxDereferenceCredential(plVar3);

+          }

+          param_1[0x5d] = (longlong *)0x0;

+          param_1[0x5e] = (longlong *)0x0;

+          param_1[0x5f] = (longlong *)0x0;

+          param_1[0x60] = (longlong *)0x0;

+          param_1[0x61] = (longlong *)0x0;

+          *(byte *)((longlong)param_1 + 0x2dd) = *(byte *)((longlong)param_1 + 0x2dd) & 0x7f;

+        }

+        pcVar6 = MmBadPointer_exref;

+        param_1[0x4e] = (longlong *)0x0;

+        param_1[0x4f] = (longlong *)0x0;

+        param_1[0x51] = (longlong *)0x0;

+        param_1[0x52] = *(longlong **)pcVar6;

+        param_1[0x53] = *(longlong **)pcVar6;

+        param_1[0x55] = *(longlong **)pcVar6;

+        param_1[0x42] = *(longlong **)pcVar6;

+        param_1[0x45] = *(longlong **)pcVar6;

+        param_1[0x46] = *(longlong **)pcVar6;

+        param_1[100] = (longlong *)0x0;

+        param_1[0x65] = (longlong *)0x0;

+        param_1[0x47] = (longlong *)0x0;

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

+        *(byte *)((longlong)param_1 + 0x2de) = *(byte *)((longlong)param_1 + 0x2de) & 0xfd;

+        return;

+      }

+    }

+    puVar10 = (undefined *)0x3;

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

+    (*pcVar6)();

+    puVar12 = puVar11 + 8;

+LAB_0:

+    puVar11 = puVar12;

+    if (3 < (byte)puVar10[0x29]) {

+      plVar3 = param_1[0x4a];

+      param_3 = (longlong ***)&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids;

+      uVar5 = *(undefined8 *)(puVar10 + 0x18);

+      *(undefined8 *)(puVar12 + -8) = 0x140005fa8;

+      WPP_SF_q(uVar5,0x12,&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,plVar3);

+    }

+  } while( true );

 }
```

## `RxDiagnosticInsertTrackerEntry`  (modified)

```diff
--- RxDiagnosticInsertTrackerEntry
+++ RxReleaseFcbForLogicalViewLookup
@@ -1,60 +1,10 @@
 

-void RxDiagnosticInsertTrackerEntry(longlong *param_1,undefined8 param_2,longlong param_3)

+void RxReleaseFcbForLogicalViewLookup(longlong param_1,longlong param_2)

 

 {

-  longlong *plVar1;

-  longlong *plVar2;

-  longlong lVar3;

-  code *pcVar4;

-  undefined1 uVar5;

-  longlong *plVar6;

-  undefined1 *puVar7;

-  undefined4 local_res10 [2];

-  undefined1 auStack_28 [8];

-  undefined1 auStack_20 [24];

+  longlong unaff_RBX;

   

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

-    return;

-  }

-  puVar7 = auStack_28;

-  local_res10[0] = 0;

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

-    return;

-  }

-  plVar1 = param_1 + 6;

-  uVar5 = KeAcquireSpinLockRaiseToDpc(plVar1);

-  if ((longlong *)*param_1 == param_1) {

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

-    (*pcVar4)();

-    return;

-  }

-  plVar2 = (longlong *)*param_1;

-  if (((longlong *)plVar2[1] == param_1) && (lVar3 = *plVar2, *(longlong **)(lVar3 + 8) == plVar2))

-  {

-    *param_1 = lVar3;

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

-    LOCK();

-    *(int *)(param_1 + 5) = (int)param_1[5] + 1;

-    UNLOCK();

-    KeReleaseSpinLock(plVar1,uVar5);

-    RtlCaptureStackBackTrace(1,5,plVar2 + 2,local_res10);

-    plVar2[7] = param_3;

-    uVar5 = KeAcquireSpinLockRaiseToDpc(plVar1);

-    plVar6 = (longlong *)param_1[3];

-    param_1 = param_1 + 2;

-    if ((longlong *)*plVar6 == param_1) goto LAB_0;

-  }

-  plVar6 = (longlong *)0x3;

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

-  uVar5 = (*pcVar4)();

-  puVar7 = auStack_20;

-LAB_0:

-  plVar2[1] = (longlong)plVar6;

-  *plVar2 = (longlong)param_1;

-  *plVar6 = (longlong)plVar2;

-  param_1[1] = (longlong)plVar2;

-  *(undefined8 *)(puVar7 + -8) = 0x14000c652;

-  KeReleaseSpinLock(plVar1,uVar5);

+  *(byte *)(unaff_RBX + 0x2de) = *(byte *)(unaff_RBX + 0x2de) & 0xfd;

   return;

 }
```

## `RxpPrepareCreateContextForReuse`  (modified)

```diff
--- RxpPrepareCreateContextForReuse
+++ RxpPrepareCreateContextForReuse
@@ -1,16 +1,188 @@
-

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

 

 void RxpPrepareCreateContextForReuse(ulonglong param_1)

 

 {

-  undefined1 *in_RAX;

-  undefined1 unaff_BH;

+  uint uVar1;

+  longlong ****pppplVar2;

+  longlong ***ppplVar3;

+  longlong lVar4;

+  longlong **pplVar5;

+  undefined8 uVar6;

+  undefined8 uVar7;

+  code *pcVar8;

+  undefined1 uVar9;

+  ulonglong uVar10;

+  longlong ***ppplVar11;

+  undefined *puVar12;

+  undefined1 *puVar13;

+  undefined1 *puVar14;

+  undefined8 unaff_RBP;

+  byte bVar15;

+  longlong ***unaff_RSI;

+  longlong ***in_R8;

+  longlong ***unaff_R14;

+  undefined8 local_res8 [3];

+  undefined8 uStack_50;

+  undefined1 auStack_48 [32];

+  undefined8 local_28 [2];

   

-  LOCK();

-  *in_RAX = unaff_BH;

-  UNLOCK();

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

-  halt_baddata();

+  puVar14 = auStack_48;

+  puVar13 = auStack_48;

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

+     (puVar12 = WPP_GLOBAL_Control, puVar13 = auStack_48,

+     (*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) goto LAB_0;

+  do {

+    *(longlong ****)(puVar13 + 0x58) = unaff_RSI;

+    if ((*(byte *)(param_1 + 0x2dd) & 1) != 0) {

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

+      *(undefined8 *)(puVar13 + 0x50) = unaff_RBP;

+      bVar15 = *(byte *)((longlong)pppplVar2[1] + 0x1a) & 0x80;

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x100) != 0)) &&

+         (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+        uVar6 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+        in_R8 = (longlong ***)&WPP_574cde0b3c2b3adc35718fe442671205_Traceguids;

+        *(undefined8 *)(puVar13 + -8) = 0x140005b9f;

+        WPP_SF_D(uVar6,0xd,&WPP_574cde0b3c2b3adc35718fe442671205_Traceguids,(uint)bVar15);

+      }

+      if (bVar15 == 0) {

+        if (param_1 < 0xfffffffffffffffe) {

+LAB_1:

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

+        }

+      }

+      else if (param_1 < 0xfffffffffffffffe) {

+        if ((*(int *)(pppplVar2[0x26] + 0x25) != 0) &&

+           ((*(uint *)((longlong)pppplVar2 + 0x9c) & 0x80000) == 0)) {

+          *(undefined8 *)(puVar13 + -8) = 0x140005a8d;

+          uVar10 = RxIsSafeToProcessBufferingStateChange(param_1,(longlong)pppplVar2);

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

+            *(undefined8 *)(puVar13 + -8) = 0x140005a9f;

+            RxProcessFcbChangeBufferingStateRequestInternal(pppplVar2,0,(uint *)in_R8);

+          }

+        }

+        goto LAB_1;

+      }

+      ppplVar3 = pppplVar2[1];

+      *(undefined8 *)(puVar13 + -8) = 0x14000596b;

+      ExReleaseResourceLite(ppplVar3);

+      *(byte *)(param_1 + 0x2dd) = *(byte *)(param_1 + 0x2dd) & 0xfe;

+      *(ushort *)(param_1 + 0x2da) = *(ushort *)(param_1 + 0x2da) & 0xfffb;

+      unaff_RBP = *(undefined8 *)(puVar13 + 0x50);

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

+    }

+    lVar4 = *(longlong *)(param_1 + 0x310);

+    if (lVar4 != 0) {

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])

+         ) {

+        uVar6 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+        *(undefined8 *)(puVar13 + -8) = 0x140005bde;

+        WPP_SF_q(uVar6,0x13,&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,lVar4);

+        FUN_140026f44();

+        return;

+      }

+      uVar6 = *(undefined8 *)(param_1 + 0x310);

+      *(undefined8 *)(puVar13 + -8) = 0x140026f54;

+      ExFreePoolWithTag(uVar6);

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

+    }

+    *(undefined8 *)(puVar13 + -8) = 0x1400059a4;

+    RxFreeCanonicalNameBuffer(param_1);

+    pppplVar2 = *(longlong *****)(param_1 + 0x280);

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

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

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

+      *(undefined8 *)(puVar13 + -8) = 0x1400059c6;

+      RxDereference(pppplVar2,0);

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

+    }

+    pppplVar2 = *(longlong *****)(param_1 + 0x70);

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

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) &&

+       (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+      uVar6 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+      *(longlong *****)(puVar13 + 0x20) = pppplVar2;

+                    /* WARNING: Subroutine does not return */

+      *(undefined **)(puVar13 + -8) = &UNK_2;

+      WPP_SF_qq(uVar6,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+    }

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

+      return;

+    }

+    if ((*(char *)(param_1 + 0x20) == '\f') && (*(char *)(param_1 + 0x21) == '\x02')) {

+      unaff_RSI = pppplVar2[0x1c];

+    }

+    else {

+      unaff_RSI = pppplVar2[0x1b];

+    }

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

+    *(longlong ****)(puVar13 + 0x60) = unaff_R14;

+    if ((uVar1 >> 0x12 & 1) == 0) goto LAB_3;

+    *(uint *)(param_1 + 0x78) = uVar1 & 0xfffbffff;

+    unaff_R14 = pppplVar2[0x1f];

+    if ((unaff_R14 == (longlong ***)0x0) || ((*(uint *)((longlong)unaff_R14 + 0x2c) & 1) == 0))

+    goto LAB_4;

+    *(undefined8 *)(puVar13 + -8) = 0x140005ad1;

+    uVar9 = KeAcquireSpinLockRaiseToDpc(unaff_R14 + 6);

+    in_R8 = unaff_R14 + 2;

+    ppplVar3 = (longlong ***)unaff_R14[2];

+    do {

+      ppplVar11 = ppplVar3;

+      if (ppplVar11 == in_R8) {

+        *(undefined8 *)(puVar13 + -8) = 0x140026f74;

+        KeReleaseSpinLock(unaff_R14 + 6,uVar9);

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

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+           (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          uVar6 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+          *(longlong ****)(puVar13 + 0x20) = unaff_R14;

+                    /* WARNING: Subroutine does not return */

+          *(undefined8 *)(puVar13 + -8) = 0x140026faf;

+          WPP_SF_qq(uVar6,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,param_1);

+        }

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

+        (*pcVar8)();

+        return;

+      }

+      ppplVar3 = (longlong ***)*ppplVar11;

+    } while (ppplVar11[7] != (longlong **)param_1);

+    if (((longlong ***)ppplVar3[1] == ppplVar11) &&

+       (pplVar5 = ppplVar11[1], (longlong ***)*pplVar5 == ppplVar11)) {

+      *pplVar5 = (longlong *)ppplVar3;

+      ppplVar3[1] = pplVar5;

+      ppplVar11[7] = (longlong **)0x0;

+      pplVar5 = *unaff_R14;

+      if ((longlong ***)pplVar5[1] == unaff_R14) {

+        *ppplVar11 = pplVar5;

+        ppplVar11[1] = (longlong **)unaff_R14;

+        pplVar5[1] = (longlong *)ppplVar11;

+        *unaff_R14 = (longlong **)ppplVar11;

+        *(undefined8 *)(puVar13 + -8) = 0x140005b38;

+        KeReleaseSpinLock(unaff_R14 + 6);

+LAB_4:

+        *(undefined8 *)(puVar13 + -8) = 0x140005a2d;

+        RfsReleaseRundownProtectionCacheAware((longlong *)unaff_RSI);

+LAB_3:

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

+        *(undefined8 *)(puVar13 + -8) = 0x140005a3b;

+        RxDereference(pppplVar2,0);

+        return;

+      }

+    }

+    puVar12 = (undefined *)0x3;

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

+    (*pcVar8)();

+    puVar14 = puVar13 + 8;

+LAB_0:

+    puVar13 = puVar14;

+    if (3 < (byte)puVar12[0x29]) {

+      uVar6 = *(undefined8 *)(param_1 + 0x250);

+      in_R8 = (longlong ***)&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids;

+      uVar7 = *(undefined8 *)(puVar12 + 0x18);

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

+      WPP_SF_q(uVar7,0x12,&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,uVar6);

+    }

+  } while( true );

 }
```

## `RfsReleaseRundownProtectionCacheAware`  (modified)

```diff
--- RfsReleaseRundownProtectionCacheAware
+++ RfsReleaseRundownProtectionCacheAware
@@ -1,50 +1,89 @@
 

-byte RfsReleaseRundownProtectionCacheAware(longlong *param_1)

+void RfsReleaseRundownProtectionCacheAware(longlong *param_1)

 

 {

-  undefined8 in_RDX;

-  char unaff_BL;

-  char unaff_SIL;

-  byte unaff_DIL;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  void *unaff_R15;

-  longlong in_stack_00000098;

+  ulonglong *puVar1;

+  code *pcVar2;

+  uint uVar3;

+  uint uVar4;

+  ulonglong uVar5;

+  ulonglong uVar6;

+  undefined1 *puVar7;

+  ulonglong *puVar8;

+  bool bVar9;

+  undefined8 uStack_30;

+  undefined1 auStack_28 [32];

   

-  RxReference((uint *)param_1);

-  if (unaff_R15 != (void *)0x0) {

-    *(longlong *)((longlong)unaff_R15 + 0x70) = unaff_R14;

-    if (unaff_DIL != 0) {

-      *(uint *)((longlong)unaff_R15 + 0x78) = *(uint *)((longlong)unaff_R15 + 0x78) | 0x40000;

+  puVar7 = auStack_28;

+  puVar8 = (ulonglong *)

+           ((ulonglong)

+            ((SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)param_1 + 0x14)) * (int)param_1[2])

+           + *param_1);

+  uVar5 = *puVar8;

+  while( true ) {

+    while ((uVar5 & 1) == 0) {

+      LOCK();

+      uVar6 = *puVar8;

+      bVar9 = uVar5 == uVar6;

+      if (bVar9) {

+        *puVar8 = uVar5 - 2;

+        uVar6 = uVar5;

+      }

+      UNLOCK();

+      uVar5 = uVar6;

+      if (bVar9) {

+        return;

+      }

     }

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

-      RfsReleaseRundownProtectionCacheAware(*(longlong **)(unaff_R14 + 0xe8));

-      unaff_BL = '\0';

+    if (uVar5 != 1) break;

+    *(undefined8 *)(puVar7 + -8) = 0x140005822;

+    uVar5 = Feature_Servicing_RfsRundownDeadlockFix__private_IsEnabledDeviceUsageNoInline();

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

+      return;

+    }

+    puVar1 = (ulonglong *)*param_1;

+    if (puVar8 == puVar1) {

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

+      (*pcVar2)();

+      puVar7 = puVar7 + 8;

+    }

+    uVar5 = *puVar1;

+    puVar8 = puVar1;

+  }

+  puVar8 = (ulonglong *)(uVar5 & 0xfffffffffffffffe);

+  *(undefined8 *)(puVar7 + -8) = 0x140005858;

+  uVar6 = Feature_Servicing_RfsRundownDeadlockFix__private_IsEnabledDeviceUsageNoInline();

+  LOCK();

+  uVar5 = *puVar8;

+  *puVar8 = *puVar8 - 1;

+  UNLOCK();

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

+    if (1 < uVar5) {

+      return;

     }

   }

-  if (unaff_DIL != 0) {

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

-      unaff_R15 = SystemReserved1[0xf];

-    }

-    RxDiagnosticInsertTrackerEntry(*(longlong **)(unaff_R14 + 0xf8),in_RDX,(longlong)unaff_R15);

+  else if (uVar5 != 1) {

+    return;

   }

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

-    if (in_stack_00000098 == 0) {

-      ExReleaseResourceLite(*(undefined8 *)(unaff_R13 + 8));

-    }

-    else {

-      __RxReleaseFcb(0,unaff_R13);

+  if ((puVar8[4] & 1) != 0) {

+    uVar4 = (uint)puVar8[4];

+    do {

+      LOCK();

+      uVar3 = (uint)puVar8[4];

+      bVar9 = uVar4 == uVar3;

+      if (bVar9) {

+        *(uint *)(puVar8 + 4) = uVar4 & 0xfffffffe;

+        uVar3 = uVar4;

+      }

+      uVar4 = uVar3;

+      UNLOCK();

+    } while (!bVar9);

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

+      return;

     }

   }

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

-    RfsReleaseRundownProtectionCacheAware(*(longlong **)(unaff_R14 + 0xe8));

-  }

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

-      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

-     ) {

-    WPP_SF_Dq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x1b,

-              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,(uint)unaff_DIL);

-  }

-  return unaff_DIL;

+  *(undefined8 *)(puVar7 + -8) = 0x1400058b1;

+  KeSetEvent(puVar8 + 1,0,0);

+  return;

 }
```

## `RxCompleteRequestEx`  (modified)

```diff
--- RxCompleteRequestEx
+++ RxCompleteRequestEx
@@ -1,632 +1,526 @@
 

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

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

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

 

-undefined ** RxCompleteRequestEx(longlong ***param_1,longlong ****param_2,uint *param_3)

+void RxCompleteRequestEx(longlong ***param_1,longlong ****param_2,ulonglong param_3)

 

 {

-  char cVar1;

-  short *psVar2;

-  undefined *puVar3;

-  longlong ****pppplVar4;

-  code *pcVar5;

-  ushort *puVar6;

-  undefined8 uVar7;

+  uint uVar1;

+  longlong **pplVar2;

+  longlong *plVar3;

+  longlong *plVar4;

+  longlong *plVar5;

+  longlong lVar6;

+  code *pcVar7;

   byte bVar8;

   undefined1 uVar9;

-  char cVar10;

-  undefined2 uVar11;

-  int iVar12;

-  undefined4 uVar13;

-  uint uVar14;

+  int iVar10;

+  ulonglong uVar11;

+  longlong ***ppplVar12;

+  longlong ***ppplVar13;

+  longlong *plVar14;

   uint uVar15;

-  int iVar16;

-  longlong *_Dst;

-  longlong *plVar17;

-  ulonglong uVar18;

-  undefined **ppuVar19;

-  ushort uVar20;

-  undefined8 *puVar21;

-  undefined8 *puVar22;

-  char unaff_BL;

-  longlong lVar23;

-  longlong *unaff_RSI;

-  undefined **ppuVar24;

-  code *pcVar25;

-  ulonglong unaff_R12;

-  char unaff_R13B;

-  longlong *unaff_R14;

-  byte *unaff_R15;

-  undefined1 auStackX_8 [24];

-  undefined8 in_stack_00000020;

-  undefined1 uStack0000000000000060;

-  char in_stack_00000061;

-  char in_stack_00000062;

-  undefined4 uStack0000000000000064;

-  char in_stack_00000069;

-  int iStack000000000000006c;

-  longlong in_stack_00000078;

-  uint in_stack_00000090;

+  undefined *puVar16;

+  longlong ****pppplVar17;

+  undefined1 *puVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  undefined1 *puVar21;

+  undefined1 *puVar22;

+  longlong ****unaff_RBP;

+  uint uVar23;

+  longlong ***ppplVar24;

+  uint *puVar25;

+  undefined8 uVar26;

+  longlong ***ppplVar27;

+  longlong ***ppplVar28;

+  longlong ****pppplVar29;

+  undefined1 auStack_d8 [32];

+  longlong ****local_b8;

+  longlong ***local_b0;

+  longlong ***local_a8;

+  longlong ****pppplStack_a0;

+  undefined4 uStack_98;

+  longlong ****pppplStack_90;

+  undefined *puStack_88;

+  uint uStack_80;

+  undefined1 local_78 [8];

+  longlong ***local_70;

+  ulonglong local_48;

   

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

-  uStack0000000000000060 = (undefined1)((ulonglong)param_1 >> 8);

-  iStack000000000000006c = 0x288;

-  ppuVar24 = (undefined **)0xc00000fb;

-  uStack0000000000000064 = 0xc00000fb;

-  ppuVar19 = (undefined **)0x0;

-  ExReleasePushLockSharedEx(&RxContextStartStopLock);

-  if ((in_stack_00000061 != '\0') && ((unaff_R12 & 0xfffffffd) == 0)) {

-    param_3 = *(uint **)(unaff_R15 + 0x30);

-    puVar6 = *(ushort **)((longlong)param_3 + 0x18);

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

-       (((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0 && (WPP_GLOBAL_Control[0x29] != '\0')))) {

-      WPP_SF_qllqq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),(ulonglong)*unaff_R15,param_3,

-                   unaff_RSI);

-    }

-    ppuVar19 = &WPP_GLOBAL_Control;

-    if ((((puVar6 != (ushort *)0x0) && (puVar6 != (ushort *)&RxDeviceFCB)) &&

-        ((*puVar6 & 0xfff0) == 0xec20)) &&

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

-         ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0)) && (WPP_GLOBAL_Control[0x29] != '\0'))))

+                    /* 0x4050  29  RxCompleteRequestEx */

+  puVar18 = auStack_d8;

+  puVar19 = auStack_d8;

+  puVar22 = auStack_d8;

+  puVar20 = auStack_d8;

+  puVar21 = auStack_d8;

+  local_48 = __security_cookie ^ (ulonglong)auStack_d8;

+  uVar11 = 0;

+  ppplVar24 = (longlong ***)(param_3 & 0xffffffff);

+  uVar23 = (uint)param_3;

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

+    puVar22 = auStack_d8;

+    if ((undefined **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) goto LAB_0;

+    puVar22 = auStack_d8;

+    if ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) == 0) goto LAB_0;

+    puVar22 = auStack_d8;

+    if ((byte)WPP_GLOBAL_Control[0x29] < 2) goto LAB_0;

+    WPP_SF_q(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x12,

+             &WPP_96827b6dd34a386711706634456502bf_Traceguids,param_1);

+    puVar22 = auStack_d8;

+    goto LAB_0;

+  }

+  uVar15 = 0;

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

+    uVar11 = (ulonglong)

+             ((uint)*(ushort *)((longlong)param_1 + 0x1aa) % RxActiveContextNodeBucketSize +

+              *(ushort *)(param_1 + 0x35) * RxActiveContextNodeBucketSize & 0x3f);

+  }

+  bVar8 = KeAcquireSpinLockRaiseToDpc(&DAT_1 + uVar11 * 0xc0);

+  puVar25 = (uint *)(ulonglong)bVar8;

+  LOCK();

+  ppplVar28 = param_2[0xd];

+  param_2[0xd] = (longlong ***)0x0;

+  UNLOCK();

+  LOCK();

+  param_2[0xf] = (longlong ***)0x0;

+  UNLOCK();

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

+    uVar15 = (uint)*(ushort *)((longlong)param_1 + 0x1aa) % RxActiveContextNodeBucketSize;

+    iVar10 = *(ushort *)(param_1 + 0x35) * RxActiveContextNodeBucketSize;

+    param_1[5] = (longlong **)0x0;

+    param_1[6] = (longlong **)0x0;

+    uVar15 = uVar15 + iVar10 & 0x3f;

+  }

+  KeReleaseSpinLock(&DAT_1 + (ulonglong)uVar15 * 0xc0,puVar25);

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

+    local_78[0] = 0;

+    IoAcquireCancelSpinLock(local_78);

+    IoReleaseCancelSpinLock(local_78[0]);

+  }

+  ppplVar28 = param_2[0x17];

+  if (uVar23 == 0xffffffff) {

+LAB_2:

+    if (((ulonglong)param_2[2] & 0x40) != 0) {

+      param_2[7] = (longlong ***)0x0;

+    }

+  }

+  else {

+    if (uVar23 == RxDebugBreakStatus) {

+      if (RxDebugBreakOpcode == 0xffffffff) {

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

+        (*pcVar7)();

+        return;

+      }

+      if (RxDebugBreakOpcode == *(byte *)(param_1 + 4)) {

+        FUN_140026c04();

+        return;

+      }

+    }

+    if ((uVar23 & 0xc0000000) == 0xc0000000) goto LAB_2;

+  }

+  *(uint *)(param_2 + 6) = uVar23;

+  puVar16 = WPP_GLOBAL_Control;

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+    local_a8 = (longlong ***)CONCAT44(local_a8._4_4_,*(undefined4 *)(param_2 + 7));

+    local_b0 = (longlong ***)CONCAT44(local_b0._4_4_,uVar23);

+    local_b8 = (longlong ****)CONCAT44(local_b8._4_4_,(uint)*(byte *)param_2[0x17]);

+    WPP_SF_qLDD(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),WPP_GLOBAL_Control,puVar25,param_2);

+  }

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

+    unaff_RBP = (longlong ****)ppplVar28[6];

+    pppplVar29 = (longlong ****)&DpcDummyName;

+    iVar10 = *(int *)(ppplVar28 + 2);

+    bVar8 = KeGetCurrentIrql();

+    if (bVar8 < 2) {

+      pppplVar29 = unaff_RBP + 0xb;

+    }

+    if ((((ulonglong)param_1[4] & 0xfd) == 0) || (param_1[7] != (longlong **)&RxDeviceFCB)) {

+      puVar16 = (undefined *)0x80000000;

+      if (((uVar23 + 0x80000000 & 0x80000000) == 0) && (uVar23 != 0x80000005)) {

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

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0)) && (WPP_GLOBAL_Control[0x29] != '\0')

+           ) {

+          FUN_140026c0a(_DAT_3);

+          return;

+        }

+      }

+      else if ((((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

+               ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 4) != 0)) &&

+              (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+        puVar25 = (uint *)(ulonglong)*(byte *)(param_1 + 4);

+        uStack_98 = *(undefined4 *)(param_2 + 7);

+        puVar16 = (undefined *)((ulonglong)(_DAT_3 - (longlong)param_1[3]) / 10000);

+        pppplStack_a0 = (longlong ****)CONCAT44(pppplStack_a0._4_4_,uVar23);

+        local_b0 = (longlong ***)CONCAT44(local_b0._4_4_,(uint)*(byte *)((longlong)param_1 + 0x21));

+        local_b8 = (longlong ****)CONCAT62(local_b8._2_6_,(ushort)*(byte *)(param_1 + 4));

+        local_a8 = param_1;

+        pppplStack_90 = unaff_RBP;

+        puStack_88 = puVar16;

+        WPP_SF_qhDqDDqi(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),puVar16,puVar25,param_2);

+      }

+    }

+    if (*(char *)(param_1 + 4) == '\x06') {

+      if (iVar10 - 10U < 2) goto LAB_4;

+    }

+    else if ((*(char *)(param_1 + 4) == '\f') && (*(char *)((longlong)param_1 + 0x21) == '\x01')) {

+LAB_4:

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

+        SeReleaseSubjectContext(param_1 + 0x3a);

+        *(undefined1 *)((longlong)param_1 + 0x1ce) = 0;

+      }

+    }

+    if ((Microsoft_Windows_Remotefs_RdbssEnableBits & 2) != 0) {

+      puVar25 = (uint *)((longlong)param_1 + 0x18c);

+      puStack_88 = (undefined *)CONCAT62(puStack_88._2_6_,(ushort)*(byte *)ppplVar28);

+      pppplStack_90 = (longlong ****)pppplVar29[1];

+      local_a8 = unaff_RBP[4];

+      uStack_98 = CONCAT22(uStack_98._2_2_,*(ushort *)pppplVar29 >> 1);

+      local_b0 = unaff_RBP[3];

+      local_b8 = (longlong ****)param_1;

+      pppplStack_a0 = unaff_RBP;

+      uStack_80 = uVar23;

+      McTemplateK0ppppphzr5hq_EtwWriteTransfer

+                ((ulonglong)(*(ushort *)pppplVar29 >> 1),puVar16,puVar25,param_2);

+    }

+  }

+  uVar15 = (uint)puVar16;

+  if ((*(byte *)ppplVar28 != 0) || (uVar23 == 0x103)) {

+    puVar18 = auStack_d8;

+    puVar19 = auStack_d8;

+    if (param_1 == (longlong ***)0x0) goto LAB_5;

+    goto LAB_6;

+  }

+  if (param_1 == (longlong ***)0x0) goto LAB_5;

+  if (uVar23 == 0x8000002d) {

+    *(undefined4 *)(param_2 + 6) = 0x104;

+    if (param_1[0x62] == (longlong **)0x0) {

+      param_2[0x14] = (longlong ***)0x0;

+      param_2[7] = (longlong ***)0x0;

+    }

+    else {

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

+         ) {

+        puVar25 = (uint *)&WPP_96827b6dd34a386711706634456502bf_Traceguids;

+        uVar15 = 0x11;

+        WPP_SF_q(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x11,

+                 &WPP_96827b6dd34a386711706634456502bf_Traceguids,param_1[0x62]);

+      }

+      param_2[0x14] = (longlong ***)param_1[0x62];

+      param_2[7] = (longlong ***)(ulonglong)*(uint *)param_1[0x62];

+      if ((*(byte *)((longlong)param_1 + 0x2da) & 2) != 0) {

+        *(short *)((longlong)param_1[0x62] + 6) = *(short *)((longlong)param_1[0x62] + 6) + 2;

+      }

+      param_1[0x62] = (longlong **)0x0;

+    }

+  }

+  if (param_1[0x52] != (longlong **)0x0) {

+    FsRtlAcknowledgeEcp();

+  }

+  if ((*(byte *)((longlong)param_1 + 0x2da) & 2) != 0) {

+    *(short *)(ppplVar28[6] + 0xb) = *(short *)(ppplVar28[6] + 0xb) + 2;

+  }

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+    puVar25 = (uint *)&WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids;

+    uVar15 = 0x12;

+    WPP_SF_q(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x12,

+             &WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,param_1[0x4a]);

+  }

+  if ((*(byte *)((longlong)param_1 + 0x2dd) & 1) == 0) goto LAB_7;

+  pppplVar29 = (longlong ****)param_1[7];

+  bVar8 = *(byte *)((longlong)pppplVar29[1] + 0x1a) & 0x80;

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x100) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])

+     ) {

+    puVar25 = (uint *)&WPP_574cde0b3c2b3adc35718fe442671205_Traceguids;

+    uVar15 = 0xd;

+    WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xd,

+             &WPP_574cde0b3c2b3adc35718fe442671205_Traceguids,(uint)bVar8);

+  }

+  if (bVar8 == 0) {

+    if (param_1 < (longlong ***)0xfffffffffffffffe) {

+LAB_8:

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

+    }

+  }

+  else if (param_1 < (longlong ***)0xfffffffffffffffe) {

+    if ((*(int *)(pppplVar29[0x26] + 0x25) != 0) &&

+       ((*(uint *)((longlong)pppplVar29 + 0x9c) & 0x80000) == 0)) {

+      pppplVar17 = pppplVar29;

+      uVar11 = RxIsSafeToProcessBufferingStateChange((longlong)param_1,(longlong)pppplVar29);

+      uVar15 = (uint)pppplVar17;

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

+        uVar15 = 0;

+        RxProcessFcbChangeBufferingStateRequestInternal(pppplVar29,0,puVar25);

+      }

+    }

+    goto LAB_8;

+  }

+  ExReleaseResourceLite(pppplVar29[1]);

+  *(byte *)((longlong)param_1 + 0x2dd) = *(byte *)((longlong)param_1 + 0x2dd) & 0xfe;

+  *(ushort *)((longlong)param_1 + 0x2da) = *(ushort *)((longlong)param_1 + 0x2da) & 0xfffb;

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

+LAB_7:

+  if (param_1[0x62] != (longlong **)0x0) {

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

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 8) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29]))

     {

-      WPP_SF_llZ(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),&WPP_GLOBAL_Control,param_3,

-                 *(undefined4 *)(puVar6 + 0x60),CONCAT44(uVar13,*(undefined4 *)(puVar6 + 0x5c)),

-                 (wchar_t *)(puVar6 + 0xa8));

-    }

-  }

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

+      WPP_SF_q(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x13,

+               &WPP_44b450df3aba3946594abe084a3a9cdc_Traceguids,param_1[0x62]);

+      FUN_140026da2();

+      return;

+    }

+    uVar15 = 0;

+    ExFreePoolWithTag(param_1[0x62]);

+    param_1[0x62] = (longlong **)0x0;

+  }

+  RxFreeCanonicalNameBuffer((longlong)param_1);

+  param_1[0x65] = (longlong **)0x0;

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

+  if ((longlong ****)param_1[0x50] != (longlong ****)0x0) {

+    uVar15 = 0;

+    RxDereference((longlong ****)param_1[0x50],0);

+    param_1[0x50] = (longlong **)0x0;

+  }

+  unaff_RBP = (longlong ****)param_1[0xe];

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])

+     ) {

+    local_b8 = unaff_RBP;

+                    /* WARNING: Subroutine does not return */

+    WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x15,

+              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+  }

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

+  if ((*(char *)(param_1 + 4) == '\f') && (*(char *)((longlong)param_1 + 0x21) == '\x02')) {

+    ppplVar27 = unaff_RBP[0x1c];

+  }

+  else {

+    ppplVar27 = unaff_RBP[0x1b];

+  }

+  if ((*(uint *)(param_1 + 0xf) >> 0x12 & 1) == 0) goto LAB_10;

+  *(uint *)(param_1 + 0xf) = *(uint *)(param_1 + 0xf) & 0xfffbffff;

+  ppplVar13 = unaff_RBP[0x1f];

+  local_70 = ppplVar13;

+  if (ppplVar13 != (longlong ***)0x0) goto LAB_11;

+LAB_12:

+  do {

+    uVar23 = (uint)ppplVar24;

+    *(undefined8 *)(puVar19 + -8) = 0x1400045b7;

+    RfsReleaseRundownProtectionCacheAware((longlong *)ppplVar27);

+    puVar20 = puVar19;

+LAB_10:

+    uVar15 = 0;

+    param_1[0xe] = (longlong **)0x0;

+    *(undefined8 *)(puVar20 + -8) = 0x1400045c8;

+    RxDereference(unaff_RBP,0);

+    puVar21 = puVar20;

+LAB_9:

+    if (param_1[0x46] != (longlong **)0x0) {

+      uVar15 = 0;

+      *(undefined8 *)(puVar21 + -8) = 0x14000469d;

+      ExFreePoolWithTag();

+      param_1[0x46] = (longlong **)0x0;

+    }

+    if (*(char *)((longlong)param_1 + 0x2dd) < '\0') {

+      pplVar2 = param_1[0x61];

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

+        *(undefined8 *)(puVar21 + -8) = 0x14000468f;

+        RxDereferenceCredential(pplVar2);

+      }

+      param_1[0x5d] = (longlong **)0x0;

+      param_1[0x5e] = (longlong **)0x0;

+      param_1[0x5f] = (longlong **)0x0;

+      param_1[0x60] = (longlong **)0x0;

+      param_1[0x61] = (longlong **)0x0;

+      *(byte *)((longlong)param_1 + 0x2dd) = *(byte *)((longlong)param_1 + 0x2dd) & 0x7f;

+    }

+    pcVar7 = MmBadPointer_exref;

+    param_1[0x4e] = (longlong **)0x0;

+    param_1[0x4f] = (longlong **)0x0;

+    param_1[0x51] = (longlong **)0x0;

+    param_1[0x52] = *(longlong ***)pcVar7;

+    param_1[0x53] = *(longlong ***)pcVar7;

+    param_1[0x55] = *(longlong ***)pcVar7;

+    param_1[0x42] = *(longlong ***)pcVar7;

+    param_1[0x45] = *(longlong ***)pcVar7;

+    param_1[0x46] = *(longlong ***)pcVar7;

+    param_1[100] = (longlong **)0x0;

+    param_1[0x65] = (longlong **)0x0;

+    param_1[0x47] = (longlong **)0x0;

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

+    *(byte *)((longlong)param_1 + 0x2de) = *(byte *)((longlong)param_1 + 0x2de) & 0xfd;

+    puVar19 = puVar21;

+LAB_6:

+    puVar18 = puVar19;

+    if ((*(byte *)ppplVar28 != 0) && (param_1[7] != (longlong **)0x0)) {

+      *(undefined8 *)(puVar18 + -8) = 0x140004284;

+      KeGetCurrentIrql();

+    }

+    if (((*(byte *)ppplVar28 & 0xed) != 0) || (*(byte *)ppplVar28 == 0x10)) {

+      *(undefined8 *)(puVar18 + -8) = 0x14000429c;

+      bVar8 = KeGetCurrentIrql();

+      if ((bVar8 < 2) &&

+         ((pplVar2 = param_1[8], pplVar2 != (longlong **)0x0 && (uVar23 != 0xc0000016)))) {

+        *(undefined4 *)(pplVar2 + 0x20) = *(undefined4 *)((longlong)pplVar2 + 0x104);

+        *(uint *)((longlong)pplVar2 + 0x104) = uVar23;

+      }

+    }

+LAB_5:

+    if (((RxEnablePerProcessCounters != '\0') && (param_1 != (longlong ***)0x0)) &&

+       (pplVar2 = param_1[0x19], pplVar2 != (longlong **)0x0)) {

+      uVar23 = *(uint *)((longlong)param_1 + 0xc4);

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

+      *(undefined8 *)(puVar18 + -8) = 0x1400042f5;

+      RdbssStatisticsEntryUpdateSocketCounters((longlong *)pplVar2,uVar15,uVar1,uVar23);

+      param_1[0x18] = (longlong **)0x0;

+    }

+    *(undefined8 *)(puVar18 + -8) = 0x14000430c;

+    IofCompleteRequest(param_2);

+    puVar22 = puVar18;

 LAB_0:

-    iVar12 = (int)ppuVar24;

-    if ((*unaff_R15 == 0xc) && (unaff_R15[1] == 2)) {

-      if (iStack000000000000006c == 0) {

-        iStack000000000000006c = 0x32a;

-      }

-      *(int *)(unaff_RSI + 6) = iVar12;

-      unaff_RSI[7] = (longlong)unaff_R14;

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

-          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 4) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

-         ) {

-        WPP_SF_qqhDD(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x14,param_3,in_stack_00000078);

-      }

-      plVar17 = (longlong *)0x0;

-      IofCompleteRequest();

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

+    if (param_1 == (longlong ***)0x0) goto LAB_13;

+    if (Microsoft_Windows_Networking_CorrelationEnabled != 0) {

+      *(undefined4 *)(puVar22 + 0x68) = 0;

+      if (Microsoft_Windows_Networking_CorrelationTraceActivityPayload == 0) {

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

+        uVar26 = 0;

+      }

+      else {

+        *(undefined8 *)(puVar22 + 0x78) = 0x10;

+        *(undefined **)(puVar22 + 0x70) = &Microsoft_Windows_Networking_ProviderId;

+        uVar26 = 2;

+        *(undefined8 *)(puVar22 + 0x88) = 4;

+        *(undefined1 **)(puVar22 + 0x80) = puVar22 + 0x68;

+        *(undefined1 **)(puVar22 + 0x20) = puVar22 + 0x70;

+      }

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

+      EtwWrite(Microsoft_Windows_Networking_CorrelationHandle,&ActivityStop,

+               (longlong)param_1 + 0x18c,uVar26);

+    }

+    param_2 = (longlong ****)param_1[0xe];

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

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) &&

+       (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+      uVar26 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

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

+                    /* WARNING: Subroutine does not return */

+      *(undefined **)(puVar22 + -8) = &UNK_14;

+      WPP_SF_qq(uVar26,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+    }

+    if (param_2 == (longlong ****)0x0) goto LAB_15;

+    if ((*(char *)(param_1 + 4) == '\f') && (*(char *)((longlong)param_1 + 0x21) == '\x02')) {

+      ppplVar24 = param_2[0x1c];

     }

     else {

-      if ((iVar12 < 0) &&

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

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

-          (3 < (byte)WPP_GLOBAL_Control[0x29])))) {

-        WPP_SF_dD(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),ppuVar19,param_3,iStack000000000000006c

-                 );

-      }

-      if (iStack000000000000006c == 0) {

-        iStack000000000000006c = 0x30f;

-      }

-      *(byte *)(unaff_RSI[0x17] + 3) = *(byte *)(unaff_RSI[0x17] + 3) | 1;

-      *(int *)(unaff_RSI + 6) = iVar12;

-      unaff_RSI[7] = (longlong)unaff_R14;

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

-          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 4) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

-         ) {

-        WPP_SF_qqhDD(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x13,param_3,in_stack_00000078);

-      }

-      plVar17 = (longlong *)0x0;

-      IofCompleteRequest();

-      ppuVar24 = (undefined **)0x103;

-      uStack0000000000000064 = 0x103;

-    }

-    goto LAB_1;

-  }

-  if (((*unaff_R15 == 0) ||

-      (param_3 = *(uint **)(unaff_R15 + 0x30), (undefined **)param_3 == (undefined **)0x0)) ||

-     (psVar2 = *(short **)((longlong)param_3 + 0x18), psVar2 == (short *)0x0)) {

-LAB_2:

-    if (unaff_R13B == '\0') goto LAB_0;

-  }

-  else {

-    bVar8 = 0;

-    if ((((*psVar2 != -0x13dd) &&

-         (bVar8 = (byte)(*(uint *)(psVar2 + 0x4e) >> 7) & 1,

-         (*(uint *)(psVar2 + 0x4e) >> 7 & 1) == 0)) &&

-        (puVar3 = *(undefined **)((longlong)param_3 + 0x20), puVar3 != (undefined *)0x0)) &&

-       ((bVar8 = (byte)(*(uint *)(puVar3 + 0x48) >> 1) & 1, (*(uint *)(puVar3 + 0x48) >> 1 & 1) == 0

-        && (ppuVar19 = *(undefined ***)(puVar3 + 0x20), ppuVar19 != (undefined **)0x0)))) {

-      bVar8 = (byte)(*(uint *)(ppuVar19 + 9) >> 10) & 1;

-    }

-    if (bVar8 == 0) goto LAB_2;

-    if ((in_stack_00000061 == '\0') && (in_stack_00000069 == '\0')) {

-      uStack0000000000000060 = 0;

-      ppuVar24 = (undefined **)0xc00000c4;

-      uStack0000000000000064 = 0xc00000c4;

-      unaff_R13B = '\0';

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

-         ((unaff_R13B = '\0', (*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0 &&

-          (WPP_GLOBAL_Control[0x29] != '\0')))) {

+      ppplVar24 = param_2[0x1b];

+    }

+    if ((*(uint *)(param_1 + 0xf) >> 0x12 & 1) == 0) goto LAB_16;

+    *(uint *)(param_1 + 0xf) = *(uint *)(param_1 + 0xf) & 0xfffbffff;

+    ppplVar28 = param_2[0x1f];

+    if ((ppplVar28 == (longlong ***)0x0) || ((*(uint *)((longlong)ppplVar28 + 0x2c) & 1) == 0))

+    goto LAB_17;

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

+    uVar9 = KeAcquireSpinLockRaiseToDpc(ppplVar28 + 6);

+    ppplVar13 = (longlong ***)ppplVar28[2];

+    do {

+      ppplVar12 = ppplVar13;

+      if (ppplVar12 == ppplVar28 + 2) {

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

+        KeReleaseSpinLock(ppplVar28 + 6,uVar9);

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

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+           (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          uVar26 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+          *(longlong ****)(puVar22 + 0x20) = ppplVar28;

                     /* WARNING: Subroutine does not return */

-        WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x10,

-                  &WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,psVar2);

-      }

-      goto LAB_2;

-    }

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

-        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29]))

-    {

-                    /* WARNING: Subroutine does not return */

-      WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x11,

-                &WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,psVar2);

-    }

-    uStack0000000000000060 = 1;

-  }

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

-    in_stack_00000090 = 2;

-  }

-  uVar15 = (uint)unaff_R14;

-  uVar11 = KeGetCurrentNodeNumber();

-  iVar12 = SystemReserved1[0x12]._4_4_;

-  lVar23 = (ulonglong)(SystemReserved1[0x12]._4_4_ + 1) * 0x80 + RxContextLookasideList;

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

-    ppuVar19 = (undefined **)(lVar23 + 0x40);

-    PplpLazyInitializeLookasideList(RxContextLookasideList,(longlong)ppuVar19);

-  }

-  _Dst = (longlong *)ExAllocateFromLookasideListEx(lVar23 + 0x40);

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

-    if ((*(char *)unaff_RSI[0x17] == '\x02') || (*(char *)unaff_RSI[0x17] == '\x12')) {

-      _Dst = (longlong *)ExpInterlockedPopEntrySList(&MustSucceedRxContextSList);

-      while (_Dst == (longlong *)0x0) {

-        param_3 = (uint *)0x0;

-        ppuVar19 = (undefined **)0x0;

-        iVar16 = KeWaitForSingleObject(&MustSucceedRxContextEvent);

-        _Dst = unaff_R14;

-        if (iVar16 != 0) goto LAB_3;

-        _Dst = (longlong *)ExpInterlockedPopEntrySList(&MustSucceedRxContextSList);

-      }

-      uVar14 = uVar15 | 0x8000000;

-      goto LAB_4;

-    }

-  }

-  else {

-    uVar14 = 1;

-LAB_4:

-    memset(_Dst,0,0x350);

-    *(uint *)(_Dst + 0xf) = uVar14;

-    *(undefined2 *)(_Dst + 0x35) = uVar11;

-    *(short *)((longlong)_Dst + 0x1aa) = (short)iVar12;

-    RxInitializeContext(unaff_RSI,in_stack_00000078,in_stack_00000090,(undefined4 *)_Dst);

-    uVar18 = (ulonglong)

-             ((uint)*(ushort *)((longlong)_Dst + 0x1aa) % RxActiveContextNodeBucketSize +

-              *(ushort *)(_Dst + 0x35) * RxActiveContextNodeBucketSize & 0x3f);

-    bVar8 = KeAcquireSpinLockRaiseToDpc(&DAT_5 + uVar18 * 0xc0);

-    param_3 = (uint *)(ulonglong)bVar8;

-    plVar17 = _Dst + 1;

-    puVar21 = &RxActiveContexts + uVar18 * 0x18;

-    puVar22 = (undefined8 *)(&DAT_6)[uVar18 * 0x18];

-    if ((undefined8 *)*puVar22 != puVar21) {

-      puVar21 = (undefined8 *)0x3;

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

-      plVar17 = (longlong *)(*pcVar25)();

-      register0x00000020 = (BADSPACEBASE *)auStackX_8;

-    }

-    *plVar17 = (longlong)puVar21;

-    plVar17[1] = (longlong)puVar22;

-    *puVar22 = plVar17;

-    puVar21[1] = plVar17;

-    ppuVar19 = (undefined **)((ulonglong)param_3 & 0xff);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000300e;

-    KeReleaseSpinLock(&DAT_5 + uVar18 * 0xc0);

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

-      *(undefined8 *)((longlong)register0x00000020 + 0x120) = 0;

-      *(undefined8 *)((longlong)register0x00000020 + 0x128) = 0;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003037;

-      EtwActivityIdControl(1,(undefined1 *)((longlong)register0x00000020 + 0x120));

-      ppuVar24 = (undefined **)((longlong)_Dst + 0x18c);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003050;

-      ppuVar19 = ppuVar24;

-      iVar12 = IoGetActivityIdIrp();

-      if (iVar12 < 0) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003068;

-        ppuVar19 = ppuVar24;

-        EtwActivityIdControl(3);

-      }

-      if (Microsoft_Windows_Networking_CorrelationEnabled != 0) {

-        *(uint *)((longlong)register0x00000020 + 0xa0) = uVar15;

-        ppuVar19 = (undefined **)&ActivityStart;

-        param_3 = (uint *)ppuVar24;

-        if (Microsoft_Windows_Networking_CorrelationTraceActivityPayload == 0) {

-          *(longlong **)((longlong)register0x00000020 + 0x20) = unaff_R14;

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400036fe;

-          EtwWrite(Microsoft_Windows_Networking_CorrelationHandle);

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

+          WPP_SF_qq(uVar26,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,param_1);

         }

-        else {

-          *(undefined **)((longlong)register0x00000020 + 0x140) =

-               &Microsoft_Windows_Networking_ProviderId;

-          *(undefined8 *)((longlong)register0x00000020 + 0x148) = 0x10;

-          *(undefined1 **)((longlong)register0x00000020 + 0x150) =

-               (undefined1 *)((longlong)register0x00000020 + 0xa0);

-          *(undefined8 *)((longlong)register0x00000020 + 0x158) = 4;

-          *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-               (undefined1 *)((longlong)register0x00000020 + 0x140);

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003625;

-          EtwWrite();

-        }

-      }

-      if (Microsoft_Windows_Networking_CorrelationEnabled != 0) {

-        *(uint *)((longlong)register0x00000020 + 0xa8) = uVar15;

-        *(undefined4 *)((longlong)register0x00000020 + 0x130) = 0x1000ea63;

-        *(undefined4 *)((longlong)register0x00000020 + 0x134) = 0x901;

-        *(undefined4 *)((longlong)register0x00000020 + 0x138) = 1;

-        *(undefined4 *)((longlong)register0x00000020 + 0x13c) = 0x80000000;

-        ppuVar19 = (undefined **)((longlong)register0x00000020 + 0x130);

-        if (Microsoft_Windows_Networking_CorrelationTraceActivityPayload == 0) {

-          *(longlong **)((longlong)register0x00000020 + 0x28) = unaff_R14;

-          *(uint *)((longlong)register0x00000020 + 0x20) = uVar15;

-        }

-        else {

-          *(undefined **)((longlong)register0x00000020 + 0x160) =

-               &Microsoft_Windows_Networking_ProviderId;

-          *(undefined8 *)((longlong)register0x00000020 + 0x168) = 0x10;

-          *(undefined1 **)((longlong)register0x00000020 + 0x170) =

-               (undefined1 *)((longlong)register0x00000020 + 0xa8);

-          *(undefined8 *)((longlong)register0x00000020 + 0x178) = 4;

-          *(undefined1 **)((longlong)register0x00000020 + 0x28) =

-               (undefined1 *)((longlong)register0x00000020 + 0x160);

-          *(undefined4 *)((longlong)register0x00000020 + 0x20) = 2;

-        }

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400035a3;

-        EtwWriteTransfer(Microsoft_Windows_Networking_CorrelationHandle);

-        param_3 = (uint *)ppuVar24;

-      }

-    }

-    if ((*(longlong *)(_Dst[10] + 0x160) != 0) &&

-       (pcVar25 = *(code **)(*(longlong *)(_Dst[10] + 0x160) + 0x290), pcVar25 != (code *)0x0)) {

-      ppuVar19 = (undefined **)0x0;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400030b6;

-      (*pcVar25)(_Dst);

-    }

-  }

-LAB_3:

-  *(longlong **)((longlong)register0x00000020 + 0xb8) = _Dst;

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

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

-        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 4) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29]))

-    {

-      bVar8 = *unaff_R15;

-      *(undefined8 *)((longlong)register0x00000020 + 0x30) = 0;

-      *(ushort *)((longlong)register0x00000020 + 0x28) = (ushort)bVar8;

-      *(longlong **)((longlong)register0x00000020 + 0x20) = unaff_RSI;

-      uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000373e;

-      WPP_SF_qqhq(uVar7,ppuVar19,param_3,*(undefined8 *)((longlong)register0x00000020 + 0x78));

-    }

-    ppuVar24 = (undefined **)0xc000009a;

-    *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc000009a;

-    *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 0x34b;

-    param_3 = (uint *)0xc000009a;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000350d;

-    func_0x000140004050(0);

-    in_stack_00000062 = *(char *)((longlong)register0x00000020 + 0x62);

-    plVar17 = unaff_RSI;

-    goto LAB_1;

-  }

-  *(longlong **)((longlong)register0x00000020 + 0xe8) = _Dst;

-  if ((Microsoft_Windows_Remotefs_RdbssEnableBits & 2) != 0) {

-    lVar23 = *(longlong *)((longlong)register0x00000020 + 0x80);

-    uVar20 = *(ushort *)(lVar23 + 0x58) >> 1;

-    *(ushort *)((longlong)register0x00000020 + 0x50) = (ushort)*unaff_R15;

-    *(undefined8 *)((longlong)register0x00000020 + 0x48) = *(undefined8 *)(lVar23 + 0x60);

-    *(ushort *)((longlong)register0x00000020 + 0x40) = uVar20;

-    *(longlong *)((longlong)register0x00000020 + 0x38) = lVar23;

-    *(undefined8 *)((longlong)register0x00000020 + 0x30) = *(undefined8 *)(lVar23 + 0x20);

-    *(undefined8 *)((longlong)register0x00000020 + 0x28) = *(undefined8 *)(lVar23 + 0x18);

-    *(longlong **)((longlong)register0x00000020 + 0x20) = _Dst;

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003680;

-    McTemplateK0ppppphzr5h_EtwWriteTransfer

-              ((ulonglong)uVar20,lVar23,(longlong)_Dst + 0x18c,unaff_RSI);

-  }

-  in_stack_00000062 = *(char *)((longlong)register0x00000020 + 0x62);

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

-    *(longlong **)((longlong)register0x00000020 + 0x108) = _Dst;

-  }

-  pppplVar4 = (longlong ****)_Dst[7];

-  if ((((pppplVar4 == (longlong ****)0x0) || ((*(ushort *)pppplVar4 & 0xfff0) != 0xec20)) ||

-      ((*(ushort *)pppplVar4 == 0xec24 ||

-       ((pppplVar4[0x10] == (longlong ***)0x0 || ((char)_Dst[4] == '\0')))))) ||

-     (uVar14 = *(uint *)(_Dst + 0xf), (uVar14 & 0x20) != 0)) {

-LAB_7:

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

-      uVar14 = (uint)*(ushort *)((longlong)_Dst + 0x1aa) % RxActiveContextNodeBucketSize +

-               *(ushort *)(_Dst + 0x35) * RxActiveContextNodeBucketSize & 0x3f;

-      *(uint *)((longlong)register0x00000020 + 0xe0) = uVar14;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003247;

-      uVar9 = KeAcquireSpinLockRaiseToDpc(&DAT_8 + (ulonglong)uVar14 * 0xc0);

-      *(undefined1 *)((longlong)register0x00000020 + 0x6b) = uVar9;

-      plVar17 = unaff_R14;

-      if (*(char *)((longlong)register0x00000020 + 0x6a) != '\0') {

-        plVar17 = *(longlong **)((longlong)register0x00000020 + 0xc0);

-      }

-      LOCK();

-      unaff_RSI[0xd] = (longlong)plVar17;

-      UNLOCK();

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

-        param_3 = (uint *)(ulonglong)(*(ushort *)(_Dst + 0x35) * RxActiveContextNodeBucketSize);

-        uVar14 = (uint)*(ushort *)((longlong)_Dst + 0x1aa) % RxActiveContextNodeBucketSize +

-                 *(ushort *)(_Dst + 0x35) * RxActiveContextNodeBucketSize & 0x3f;

-        *(uint *)((longlong)register0x00000020 + 0x78) = uVar14;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400032b3;

-        KeReleaseSpinLock(&DAT_8 + (ulonglong)uVar14 * 0xc0,

-                          *(undefined1 *)((longlong)register0x00000020 + 0x6b));

-        unaff_RSI[7] = (longlong)unaff_R14;

-        *(uint *)(unaff_RSI + 6) = uVar15;

-        bVar8 = *unaff_R15;

-        plVar17 = (longlong *)(ulonglong)bVar8;

-        pcVar25 = *(code **)(*(longlong *)((longlong)register0x00000020 + 0xb0) +

-                            (longlong)plVar17 * 0x10);

-        *(code **)((longlong)register0x00000020 + 200) = pcVar25;

-        if ((bVar8 == 3) || (bVar8 == 4)) {

-          if ((unaff_R15[1] & 4) == 0) {

-            if ((unaff_R15[1] & 1) == 0) {

-              if (bVar8 == 3) {

-                *(longlong **)((longlong)register0x00000020 + 0xd0) = unaff_R14;

-                *(longlong **)((longlong)register0x00000020 + 0xd8) = unaff_R14;

-                plVar17 = (longlong *)((longlong)register0x00000020 + 0xd0);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003452;

-                IoGetStackLimits((undefined1 *)((longlong)register0x00000020 + 0xd8));

-                if ((undefined1 *)

-                    ((longlong)register0x00000020 +

-                    (0xd0 - *(longlong *)((longlong)register0x00000020 + 0xd8))) <

-                    (undefined1 *)0xe00) {

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

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

-                     (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-                    param_3 = (uint *)&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids;

-                    uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003d71;

-                    WPP_SF_(uVar7,0x18,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids);

-                  }

-                  *(undefined1 *)((longlong)_Dst + 0x22) = 1;

-                  plVar17 = *(longlong **)(*(longlong *)(unaff_R15 + 0x30) + 0x18);

-                  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000349e;

-                  uVar18 = RxPostStackOverflowRead((ulonglong)_Dst,(longlong)plVar17);

-                  ppuVar24 = (undefined **)(uVar18 & 0xffffffff);

-                  *(int *)((longlong)register0x00000020 + 100) = (int)uVar18;

-                  if ((int)uVar18 != 0x103) {

-                    *(undefined1 *)((longlong)_Dst + 0x22) = 0;

-                    param_3 = (uint *)(uVar18 & 0xffffffff);

-                    plVar17 = (longlong *)_Dst[5];

-                    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400034c2;

-                    func_0x000140004050(_Dst);

-                  }

-                  goto LAB_1;

-                }

-              }

-            }

-            else {

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

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

-                 (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-                plVar17 = (longlong *)0x17;

-                param_3 = (uint *)&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids;

-                uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003d3d;

-                WPP_SF_(uVar7,0x17,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids);

-              }

-              *(undefined1 *)((longlong)register0x00000020 + 0x71) = 1;

-            }

-          }

-          else {

-            pcVar25 = RxCompleteMdl;

-            *(code **)((longlong)register0x00000020 + 200) = RxCompleteMdl;

-          }

-        }

-        _Dst[0x23] = (longlong)pcVar25;

-        if (pcVar25 == (code *)0x0) {

-          ppuVar24 = (undefined **)0xc0000002;

-        }

-        else {

-          *(undefined1 *)((longlong)_Dst + 0x22) = 1;

-          if (*(char *)((longlong)register0x00000020 + 0x71) != '\0') {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003d7e;

-            uVar18 = RxFsdPostRequest(_Dst,plVar17,param_3);

-            ppuVar24 = (undefined **)(uVar18 & 0xffffffff);

-            *(int *)((longlong)register0x00000020 + 100) = (int)uVar18;

-            goto LAB_1;

-          }

-          do {

-            *(uint *)(_Dst + 0x16) = uVar15;

-            if ((*(longlong *)(_Dst[10] + 0x160) != 0) &&

-               (pcVar5 = *(code **)(*(longlong *)(_Dst[10] + 0x160) + 0x298), pcVar5 != (code *)0x0)

-               ) {

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000333d;

-              (*pcVar5)(_Dst,1);

-            }

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000334b;

-            plVar17 = unaff_RSI;

-            uVar14 = (*pcVar25)(_Dst);

-            ppuVar24 = (undefined **)(ulonglong)uVar14;

-            *(uint *)((longlong)register0x00000020 + 100) = uVar14;

-            if ((uVar14 == 0xc0410001) && (lVar23 = _Dst[0x31], (int)lVar23 != 0)) {

-              *(longlong **)((longlong)register0x00000020 + 0x80) = unaff_R14;

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

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

-                  (3 < (byte)WPP_GLOBAL_Control[0x29])))) {

-                uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-                *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003dd6;

-                WPP_SF_D(uVar7,0x19,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,(int)lVar23);

-              }

-              *(undefined8 *)((longlong)register0x00000020 + 0x80) = 0xffffffffffffd8f0;

-              *(ulonglong *)((longlong)register0x00000020 + 0x80) =

-                   (ulonglong)*(uint *)(_Dst + 0x31) * -10000;

-              param_3 = (uint *)((longlong)register0x00000020 + 0x80);

-              plVar17 = (longlong *)0x0;

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003e0a;

-              KeDelayExecutionThread(0);

-              *(uint *)(_Dst + 0x31) = uVar15;

-            }

-            if (uVar14 == 0x103) goto LAB_1;

-          } while (uVar14 == 0xc0410001);

-          if (((((longlong *)_Dst[5] == (longlong *)0x0) || ((longlong *)_Dst[5] != unaff_RSI)) ||

-              ((byte *)_Dst[6] != unaff_R15)) ||

-             ((*(byte *)(_Dst + 4) != *unaff_R15 ||

-              (*(byte *)((longlong)_Dst + 0x21) != unaff_R15[1])))) {

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003e2c;

-            DbgPrint("RXCONTEXT CONTAMINATED!!!!  (RxContext = %p)\n",_Dst);

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

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

-                (3 < (byte)WPP_GLOBAL_Control[0x29])))) {

-              *(longlong *)((longlong)register0x00000020 + 0x20) = _Dst[5];

-              uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-                    /* WARNING: Subroutine does not return */

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003e72;

-              WPP_SF_qq(uVar7,0x1a,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,unaff_RSI);

-            }

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

+        (*pcVar7)();

+        return;

+      }

+      ppplVar13 = (longlong ***)*ppplVar12;

+    } while ((longlong ***)ppplVar12[7] != param_1);

+    if (((longlong ***)ppplVar13[1] == ppplVar12) &&

+       (pplVar2 = ppplVar12[1], (longlong ***)*pplVar2 == ppplVar12)) {

+      *pplVar2 = (longlong *)ppplVar13;

+      ppplVar13[1] = pplVar2;

+      ppplVar12[7] = (longlong **)0x0;

+      pplVar2 = *ppplVar28;

+      if ((longlong ***)pplVar2[1] == ppplVar28) {

+        *ppplVar12 = pplVar2;

+        ppplVar12[1] = (longlong **)ppplVar28;

+        pplVar2[1] = (longlong *)ppplVar12;

+        *ppplVar28 = (longlong **)ppplVar12;

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

+        KeReleaseSpinLock(ppplVar28 + 6);

+LAB_17:

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

+        RfsReleaseRundownProtectionCacheAware((longlong *)ppplVar24);

+LAB_16:

+        param_1[0xe] = (longlong **)0x0;

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

+        RxDereference(param_2,0);

+LAB_15:

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

+        RxDereferenceAndDeleteRxContext_Real((longlong)param_1);

+LAB_13:

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

+        return;

+      }

+    }

+    do {

+      do {

+        ppplVar13 = (longlong ***)0x3;

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

+        (*pcVar7)();

+        puVar22 = puVar22 + 8;

+LAB_11:

+        puVar19 = puVar22;

+        if ((*(uint *)((longlong)ppplVar13 + 0x2c) & 1) == 0) goto LAB_12;

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

+        uVar9 = KeAcquireSpinLockRaiseToDpc(ppplVar13 + 6);

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

+        plVar4 = (longlong *)plVar3[2];

+        do {

+          plVar14 = plVar4;

+          if (plVar14 == plVar3 + 2) {

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

+            KeReleaseSpinLock(plVar3 + 6,uVar9);

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

                 ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

-               (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-              *(longlong *)((longlong)register0x00000020 + 0x20) = _Dst[6];

-              uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+              uVar26 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+              *(undefined8 *)(puVar22 + 0x20) = *(undefined8 *)(puVar22 + 0x68);

                     /* WARNING: Subroutine does not return */

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003eac;

-              WPP_SF_qq(uVar7,0x1b,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,unaff_R15);

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

+              WPP_SF_qq(uVar26,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,param_1);

             }

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

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

-               (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-              bVar8 = *unaff_R15;

-              *(uint *)((longlong)register0x00000020 + 0x20) = (uint)*(byte *)(_Dst + 4);

-              uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003ee6;

-              WPP_SF_Ld(uVar7,0x1c,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,(uint)bVar8);

-            }

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

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

-               (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-              bVar8 = unaff_R15[1];

-              *(uint *)((longlong)register0x00000020 + 0x20) =

-                   (uint)*(byte *)((longlong)_Dst + 0x21);

-              uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003f2d;

-              WPP_SF_Ld(uVar7,0x1d,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids,(uint)bVar8);

-            }

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

+            (*pcVar7)();

+            return;

           }

-          *(undefined1 *)((longlong)_Dst + 0x22) = 0;

-          param_3 = (uint *)(ulonglong)uVar14;

-          plVar17 = (longlong *)_Dst[5];

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400033c5;

-          func_0x000140004050(_Dst);

-        }

-        *(int *)((longlong)register0x00000020 + 100) = (int)ppuVar24;

-        goto LAB_1;

-      }

-      LOCK();

-      unaff_RSI[0xd] = (longlong)unaff_R14;

-      UNLOCK();

-      LOCK();

-      unaff_RSI[0xf] = (longlong)unaff_R14;

-      UNLOCK();

-      uVar15 = (uint)*(ushort *)((longlong)_Dst + 0x1aa) % RxActiveContextNodeBucketSize +

-               *(ushort *)(_Dst + 0x35) * RxActiveContextNodeBucketSize & 0x3f;

-      *(uint *)((longlong)register0x00000020 + 0xb0) = uVar15;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400036d4;

-      KeReleaseSpinLock(&DAT_8 + (ulonglong)uVar15 * 0xc0,

-                        *(undefined1 *)((longlong)register0x00000020 + 0x6b));

-      ppuVar24 = (undefined **)0xc0000120;

-      *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc0000120;

-      *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 0x404;

-    }

-    else {

-      ppuVar24 = (undefined **)0xc0000120;

-      *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc0000120;

-      *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 999;

-    }

-  }

-  else {

-    *(undefined1 *)((longlong)register0x00000020 + 0x70) = 0;

-    *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-         (undefined1 *)((longlong)register0x00000020 + 0x70);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003172;

-    uVar13 = RxWaitForStableLViewOnFcbAndAcquireRundown

-                       (_Dst,pppplVar4,(byte)(uVar14 >> 0x1a) & 1,'\0',

-                        *(undefined1 **)((longlong)register0x00000020 + 0x20));

-    if (((char)uVar13 == '\0') && (*(char *)((longlong)register0x00000020 + 0x70) == '\0')) {

-      ppuVar24 = (undefined **)0xc0000054;

-      *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc0000054;

-      *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 0x39c;

-    }

-    else {

-      if ((*(char *)((longlong)register0x00000020 + 0x61) == '\0') &&

-         (*(char *)((longlong)register0x00000020 + 0x69) == '\0')) {

-        uVar14 = *(uint *)(_Dst[7] + 0x9c) >> 7;

-        bVar8 = (byte)uVar14 & 1;

-        *(byte *)((longlong)register0x00000020 + 0x73) = bVar8;

-        if ((((uVar14 & 1) == 0) && (_Dst[8] != 0)) &&

-           (lVar23 = *(longlong *)(_Dst[8] + 0x20), lVar23 != 0)) {

-          bVar8 = (byte)(*(uint *)(lVar23 + 0x48) >> 10) & 1;

-          *(byte *)((longlong)register0x00000020 + 0x73) = bVar8;

-        }

-        if (bVar8 != 0) {

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

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

-             (1 < (byte)WPP_GLOBAL_Control[0x29])) {

-            uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003778;

-            WPP_SF_(uVar7,0x16,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids);

-          }

-          ppuVar24 = (undefined **)0xc00000c4;

-          *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc00000c4;

-          *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 0x3b7;

-          param_3 = (uint *)0xc00000c4;

-          plVar17 = (longlong *)_Dst[5];

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003798;

-          func_0x000140004050(_Dst);

-          goto LAB_1;

-        }

-      }

-      if ((((char)*(undefined4 *)(_Dst[7] + 0x9c) < '\0') || (_Dst[0xe] == 0)) ||

-         (_Dst[10] ==

-          *(longlong *)

-           (*(longlong *)(*(longlong *)(*(longlong *)(_Dst[7] + 0x80) + 0x20) + 0x20) + 0x30)))

-      goto LAB_7;

-      ppuVar24 = (undefined **)0xc0000016;

-      *(undefined4 *)((longlong)register0x00000020 + 100) = 0xc0000016;

-      *(undefined4 *)((longlong)register0x00000020 + 0x6c) = 0x3da;

-    }

-  }

-  plVar17 = (longlong *)_Dst[5];

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400033f9;

-  param_3 = (uint *)ppuVar24;

-  func_0x000140004050(_Dst);

-LAB_1:

-  cVar1 = *(char *)((longlong)register0x00000020 + 0x72);

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

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003f84;

-    RxUnwindTopLevelIrp((longlong)((longlong)register0x00000020 + 0xf8));

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003f8b;

-  KeLeaveCriticalRegion();

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003f97;

-  cVar10 = KeAreApcsDisabled();

-  if (cVar10 != *(char *)((longlong)register0x00000020 + 0x75)) {

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

-        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 1) != 0)) && (WPP_GLOBAL_Control[0x29] != '\0')) {

-      uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004015;

-      WPP_SF_(uVar7,0x1e,&WPP_a4d91997cd8a3822f4898165ed80c825_Traceguids);

-      ppuVar19 = (undefined **)FUN_140026bfe();

-      return ppuVar19;

-    }

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

-    ppuVar19 = (undefined **)(*pcVar25)();

-    return ppuVar19;

-  }

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

-      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-    *(undefined4 *)((longlong)register0x00000020 + 0x28) =

-         *(undefined4 *)((longlong)register0x00000020 + 0x6c);

-    *(int *)((longlong)register0x00000020 + 0x20) = (int)ppuVar24;

-    uVar7 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000403a;

-    WPP_SF_hLd(uVar7,plVar17,param_3,(short)cVar1);

-  }

-  *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140003fc7;

-  return ppuVar24;

+          plVar4 = (longlong *)*plVar14;

+        } while ((longlong ***)plVar14[7] != param_1);

+      } while (((longlong *)plVar4[1] != plVar14) ||

+              (plVar5 = (longlong *)plVar14[1], (longlong *)*plVar5 != plVar14));

+      *plVar5 = (longlong)plVar4;

+      plVar4[1] = (longlong)plVar5;

+      plVar14[7] = 0;

+      lVar6 = *plVar3;

+    } while (*(longlong **)(lVar6 + 8) != plVar3);

+    *plVar14 = lVar6;

+    plVar14[1] = (longlong)plVar3;

+    *(longlong **)(lVar6 + 8) = plVar14;

+    *plVar3 = (longlong)plVar14;

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

+    KeReleaseSpinLock(plVar3 + 6);

+  } while( true );

 }
```

## `RxReleaseLViewRundown`  (modified)

```diff
--- RxReleaseLViewRundown
+++ RxReleaseLViewRundown
@@ -1,7 +1,115 @@
 

 void RxReleaseLViewRundown(longlong **param_1)

 

 {

+  char cVar1;

+  uint uVar2;

+  longlong ****pppplVar3;

+  longlong ***ppplVar4;

+  longlong **pplVar5;

+  undefined8 uVar6;

+  code *pcVar7;

+  undefined1 uVar8;

+  longlong ***ppplVar9;

+  undefined *puVar10;

+  undefined1 *puVar11;

+  undefined1 *puVar12;

+  undefined8 unaff_RBP;

+  longlong ***unaff_RSI;

+  undefined8 unaff_R12;

+  longlong ***unaff_R14;

+  undefined8 local_res8 [4];

+  undefined8 uStack_50;

+  undefined1 auStack_48 [32];

+  undefined8 local_28 [2];

+  

+  puVar12 = auStack_48;

+  pppplVar3 = (longlong ****)param_1[0xe];

+  puVar11 = auStack_48;

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

+     (puVar10 = WPP_GLOBAL_Control, puVar11 = auStack_48,

+     (*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) goto LAB_0;

+  while( true ) {

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

+      return;

+    }

+    cVar1 = *(char *)(param_1 + 4);

+    *(undefined8 *)(puVar11 + 0x60) = unaff_R12;

+    *(longlong ****)(puVar11 + 0x58) = unaff_RSI;

+    if ((cVar1 == '\f') && (*(char *)((longlong)param_1 + 0x21) == '\x02')) {

+      unaff_RSI = pppplVar3[0x1c];

+    }

+    else {

+      unaff_RSI = pppplVar3[0x1b];

+    }

+    uVar2 = *(uint *)(param_1 + 0xf);

+    unaff_R12 = 0;

+    *(undefined8 *)(puVar11 + 0x50) = unaff_RBP;

+    *(longlong ****)(puVar11 + 0x68) = unaff_R14;

+    if ((uVar2 >> 0x12 & 1) == 0) goto LAB_1;

+    *(uint *)(param_1 + 0xf) = uVar2 & 0xfffbffff;

+    unaff_R14 = pppplVar3[0x1f];

+    if ((unaff_R14 == (longlong ***)0x0) || ((*(uint *)((longlong)unaff_R14 + 0x2c) & 1) == 0))

+    break;

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

+    uVar8 = KeAcquireSpinLockRaiseToDpc(unaff_R14 + 6);

+    ppplVar4 = (longlong ***)unaff_R14[2];

+    do {

+      ppplVar9 = ppplVar4;

+      if (ppplVar9 == unaff_R14 + 2) {

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

+        KeReleaseSpinLock(unaff_R14 + 6,uVar8);

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

+            ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+           (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          uVar6 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

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

+                    /* WARNING: Subroutine does not return */

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

+          WPP_SF_qq(uVar6,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,param_1);

+        }

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

+        (*pcVar7)();

+        return;

+      }

+      ppplVar4 = (longlong ***)*ppplVar9;

+    } while (ppplVar9[7] != param_1);

+    if (((longlong ***)ppplVar4[1] == ppplVar9) &&

+       (pplVar5 = ppplVar9[1], (longlong ***)*pplVar5 == ppplVar9)) {

+      *pplVar5 = (longlong *)ppplVar4;

+      ppplVar4[1] = pplVar5;

+      ppplVar9[7] = (longlong **)0x0;

+      pplVar5 = *unaff_R14;

+      if ((longlong ***)pplVar5[1] == unaff_R14) {

+        *ppplVar9 = pplVar5;

+        ppplVar9[1] = (longlong **)unaff_R14;

+        pplVar5[1] = (longlong *)ppplVar9;

+        *unaff_R14 = (longlong **)ppplVar9;

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

+        KeReleaseSpinLock(unaff_R14 + 6);

+        break;

+      }

+    }

+    puVar10 = (undefined *)0x3;

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

+    (*pcVar7)();

+    puVar12 = puVar11 + 8;

+LAB_0:

+    puVar11 = puVar12;

+    if (3 < (byte)puVar10[0x29]) {

+      uVar6 = *(undefined8 *)(puVar10 + 0x18);

+      *(longlong *****)(puVar12 + 0x20) = pppplVar3;

+                    /* WARNING: Subroutine does not return */

+      *(undefined **)(puVar12 + -8) = &UNK_2;

+      WPP_SF_qq(uVar6,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+    }

+  }

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

+  RfsReleaseRundownProtectionCacheAware((longlong *)unaff_RSI);

+LAB_1:

+  param_1[0xe] = (longlong *)0x0;

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

+  RxDereference(pppplVar3,0);

   return;

 }
```

## `RxWaitForStableLViewOnFcbAndAcquireRundown`  (modified)

```diff
--- RxWaitForStableLViewOnFcbAndAcquireRundown
+++ RxWaitForStableLViewOnFcbAndAcquireRundown
@@ -1,250 +1,349 @@
 

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

-

-ulonglong RxWaitForStableLViewOnFcbAndAcquireRundown

-                    (longlong ***param_1,longlong ****param_2,byte param_3,byte param_4,

-                    undefined8 param_5)

+undefined4

+RxWaitForStableLViewOnFcbAndAcquireRundown

+          (void *param_1,longlong ****param_2,byte param_3,char param_4,undefined1 *param_5)

 

 {

   longlong ****pppplVar1;

   longlong ***ppplVar2;

-  longlong ***ppplVar3;

-  longlong **pplVar4;

-  longlong *plVar5;

-  longlong *plVar6;

-  longlong *plVar7;

-  code *pcVar8;

-  undefined8 *puVar9;

-  byte bVar10;

-  undefined1 uVar11;

-  ulonglong uVar12;

-  longlong ***ppplVar13;

-  longlong lVar14;

-  longlong *plVar15;

-  longlong **unaff_RBX;

-  undefined8 *puVar16;

-  longlong ****unaff_RBP;

-  longlong ***ppplVar17;

-  undefined7 in_register_00000081;

-  undefined8 uVar18;

-  longlong **unaff_R13;

-  undefined *unaff_R15;

+  bool bVar3;

+  bool bVar4;

+  char cVar5;

+  int iVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  uint uVar9;

+  longlong ****pppplVar10;

+  undefined4 uVar11;

+  longlong ***ppplVar12;

+  ulonglong *puVar13;

+  longlong ****pppplVar14;

+  bool bVar15;

+  longlong ****local_res10;

   

-  *(char *)((longlong)param_2 + 0x12) =

-       *(char *)((longlong)param_2 + 0x12) + (char)((ulonglong)unaff_RBX >> 8);

-  uVar12 = WPP_SF_q(param_1,(short)param_2,CONCAT71(in_register_00000081,param_3),unaff_RBX);

+  bVar3 = false;

+  bVar15 = false;

+  uVar11 = 0;

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

+  pppplVar10 = param_2;

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) && (3 < (byte)WPP_GLOBAL_Control[0x29])

+     ) {

+    pppplVar10 = (longlong ****)0x17;

+    WPP_SF_qqdd(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x17,

+                &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,param_1);

+  }

+  if (param_5 != (undefined1 *)0x0) {

+    *param_5 = 0;

+  }

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

+    local_res10 = (longlong ****)((ulonglong)(param_3 != 0) - 2);

+  }

+  if ((param_2[0x10] != (longlong ***)0x0) &&

+     (cVar5 = ExIsResourceAcquiredSharedLite(param_2[1]), cVar5 == '\0')) {

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

+      pppplVar10 = (longlong ****)CONCAT71((int7)((ulonglong)pppplVar10 >> 8),param_3 == 0);

+      cVar5 = ExAcquireResourceSharedLite(param_2[1]);

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

+      bVar15 = true;

+    }

+    else {

+      pppplVar10 = local_res10;

+      iVar6 = __RxAcquireFcb(param_2,(ulonglong)local_res10,(longlong ****)0x2,(ulonglong)param_3);

+      if (iVar6 != 0) goto LAB_0;

+      bVar15 = true;

+    }

+  }

+  pppplVar14 = (longlong ****)param_2[0x10];

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

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

+        ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) &&

+       (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+      WPP_SF_(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x18,

+              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids);

+    }

+    if (param_5 != (undefined1 *)0x0) {

+      *param_5 = 1;

+    }

+  }

+  else if (SystemReserved1[0xf] == pppplVar14[0x1e]) {

+    RxReference((uint *)pppplVar14);

+    bVar4 = true;

+LAB_1:

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

+      if (bVar4) {

+        *(longlong *****)((longlong)param_1 + 0x70) = pppplVar14;

+      }

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

+        *(uint *)((longlong)param_1 + 0x78) = *(uint *)((longlong)param_1 + 0x78) | 0x40000;

+      }

+      if (bVar3) {

+        RfsReleaseRundownProtectionCacheAware((longlong *)pppplVar14[0x1d]);

+        bVar3 = false;

+      }

+    }

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

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

+        param_1 = SystemReserved1[0xf];

+      }

+      RxDiagnosticInsertTrackerEntry((longlong *)pppplVar14[0x1f],pppplVar10,(longlong)param_1);

+    }

+  }

+  else {

+    if (!bVar15) {

+      iVar6 = RxAcquireFcbForLogicalViewLookup((ulonglong)local_res10,param_2,param_3);

+      if (iVar6 != 0) goto LAB_0;

+      bVar15 = true;

+    }

+    pppplVar14 = (longlong ****)param_2[0x10];

+    while (pppplVar14 != (longlong ****)0x0) {

+      RxReference((uint *)pppplVar14);

+      if (((param_1 == (void *)0x0) || (*(char *)((longlong)param_1 + 0x20) != '\f')) ||

+         (*(char *)((longlong)param_1 + 0x21) != '\x02')) {

+        ppplVar12 = pppplVar14[0x1b];

+      }

+      else {

+        ppplVar12 = pppplVar14[0x1c];

+      }

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

+        ExReleaseResourceLite(param_2[1]);

+      }

+      else {

+        __RxReleaseFcb(0,(longlong)param_2);

+      }

+      pppplVar1 = pppplVar14 + 0x1d;

+      if (param_3 == 0) {

+LAB_2:

+        do {

+          uVar8 = RxWaitForStableCondition

+                            ((ulonglong)param_1,(int *)(pppplVar14 + 0x18),

+                             (longlong)(pppplVar14 + 0x19),'\x01');

+        } while ((int)uVar8 != 0);

+        ppplVar2 = *pppplVar1;

+        puVar13 = (ulonglong *)

+                  ((ulonglong)

+                   ((SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)ppplVar2 + 0x14)) *

+                   *(int *)(ppplVar2 + 2)) + (longlong)*ppplVar2);

+        uVar7 = *puVar13 & 0xfffffffffffffffe;

+        LOCK();

+        uVar8 = *puVar13;

+        if (uVar7 == uVar8) {

+          *puVar13 = uVar7 + 2;

+        }

+        UNLOCK();

+        if (uVar7 != uVar8) goto code_r0x000140005326;

+        bVar3 = true;

+        goto LAB_3;

+      }

+      ppplVar2 = *pppplVar1;

+      puVar13 = (ulonglong *)

+                ((ulonglong)

+                 ((SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)ppplVar2 + 0x14)) *

+                 *(int *)(ppplVar2 + 2)) + (longlong)*ppplVar2);

+      uVar7 = *puVar13 & 0xfffffffffffffffe;

+      LOCK();

+      uVar8 = *puVar13;

+      if (uVar7 == uVar8) {

+        *puVar13 = uVar7 + 2;

+      }

+      UNLOCK();

+      if (uVar7 != uVar8) {

+        uVar8 = *puVar13;

+        if ((*puVar13 & 1) == 0) {

+          while( true ) {

+            LOCK();

+            uVar7 = *puVar13;

+            bVar15 = uVar8 == uVar7;

+            if (bVar15) {

+              *puVar13 = uVar8 + 2;

+              uVar7 = uVar8;

+            }

+            UNLOCK();

+            if (bVar15) break;

+            uVar8 = uVar7;

+            if ((uVar7 & 1) != 0) goto LAB_4;

+          }

+          goto LAB_5;

+        }

+LAB_4:

+        bVar3 = false;

+LAB_6:

+        uVar11 = 0;

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

+        RxDereference(pppplVar14,0);

+        bVar4 = false;

+        bVar15 = false;

+        goto LAB_1;

+      }

+LAB_5:

+      bVar3 = true;

+      if (*(int *)(pppplVar14 + 0x18) != 3) {

+LAB_7:

+        RfsReleaseRundownProtectionCacheAware((longlong *)pppplVar14[0x1d]);

+        uVar8 = Feature_Servicing_RfsRundownDeadlockFix__private_IsEnabledDeviceUsageNoInline();

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

+          bVar3 = false;

+        }

+        goto LAB_6;

+      }

+      uVar9 = (SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)ppplVar12 + 0x14)) *

+              *(int *)(ppplVar12 + 2);

+      puVar13 = (ulonglong *)((ulonglong)uVar9 + (longlong)*ppplVar12);

+      uVar7 = *puVar13 & 0xfffffffffffffffe;

+      LOCK();

+      uVar8 = *puVar13;

+      if (uVar7 == uVar8) {

+        *puVar13 = uVar7 + 2;

+      }

+      UNLOCK();

+      if (uVar7 != uVar8) {

+        uVar8 = *puVar13;

+        do {

+          if ((uVar8 & 1) != 0) goto LAB_7;

+          LOCK();

+          uVar7 = *puVar13;

+          bVar15 = uVar8 == uVar7;

+          if (bVar15) {

+            *puVar13 = uVar8 + 2;

+            uVar7 = uVar8;

+          }

+          UNLOCK();

+          uVar8 = uVar7;

+        } while (!bVar15);

+      }

+      uVar11 = 1;

+LAB_8:

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

+        pppplVar10 = (longlong ****)(ulonglong)CONCAT31((int3)(uVar9 >> 8),param_3 == 0);

+        cVar5 = ExAcquireResourceSharedLite();

+        if (cVar5 == '\0') goto LAB_9;

+      }

+      else {

+        pppplVar10 = local_res10;

+        iVar6 = __RxAcquireFcb(param_2,(ulonglong)local_res10,(longlong ****)0x2,(ulonglong)param_3)

+        ;

+        if (iVar6 != 0) {

+LAB_9:

+          RfsReleaseRundownProtectionCacheAware((longlong *)ppplVar12);

+          uVar11 = 0;

+          RfsReleaseRundownProtectionCacheAware((longlong *)*pppplVar1);

+          RxDereference(pppplVar14,0);

+          goto LAB_0;

+        }

+      }

+      bVar15 = true;

+      if ((longlong ****)param_2[0x10] == pppplVar14) {

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

+          ExReleaseResourceLite();

+          bVar4 = true;

+          bVar15 = false;

+        }

+        else {

+          pppplVar10 = param_2;

+          __RxReleaseFcb(0,(longlong)param_2);

+          bVar4 = true;

+          bVar15 = false;

+        }

+        goto LAB_1;

+      }

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

+          ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) &&

+         (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+                    /* WARNING: Subroutine does not return */

+        WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x1a,

+                  &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,pppplVar14);

+      }

+      RfsReleaseRundownProtectionCacheAware((longlong *)ppplVar12);

+      RfsReleaseRundownProtectionCacheAware((longlong *)pppplVar14[0x1d]);

+      RxDereference(pppplVar14,0);

+      pppplVar14 = (longlong ****)param_2[0x10];

+    }

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

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

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

+      WPP_SF_(*(undefined **)((longlong)WPP_GLOBAL_Control + 0x18),0x19,

+              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids);

+    }

+    if (param_5 != (undefined1 *)0x0) {

+      *param_5 = 1;

+    }

+    bVar3 = false;

+    uVar11 = 0;

+  }

+  if (bVar15) {

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

+      ExReleaseResourceLite(param_2[1]);

+    }

+    else {

+      __RxReleaseFcb(0,(longlong)param_2);

+    }

+  }

+  if (bVar3) {

+    RfsReleaseRundownProtectionCacheAware((longlong *)pppplVar14[0x1d]);

+  }

+LAB_0:

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

+      ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0)) && (1 < (byte)WPP_GLOBAL_Control[0x29])

+     ) {

+    WPP_SF_Dq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x1b,

+              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,uVar11);

+  }

+  return uVar11;

+code_r0x000140005326:

+  uVar8 = *puVar13;

   do {

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

-LAB_0:

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400043a5;

-      return uVar12;

-    }

-    if (Microsoft_Windows_Networking_CorrelationEnabled != 0) {

-      *(int *)((longlong)register0x00000020 + 0x68) = (int)unaff_R13;

-      if (Microsoft_Windows_Networking_CorrelationTraceActivityPayload == 0) {

-        *(longlong ***)((longlong)register0x00000020 + 0x20) = unaff_R13;

-        uVar18 = 0;

-      }

-      else {

-        *(undefined8 *)((longlong)register0x00000020 + 0x78) = 0x10;

-        *(undefined **)((longlong)register0x00000020 + 0x70) =

-             &Microsoft_Windows_Networking_ProviderId;

-        uVar18 = 2;

-        *(undefined8 *)((longlong)register0x00000020 + 0x88) = 4;

-        *(undefined1 **)((longlong)register0x00000020 + 0x80) =

-             (undefined1 *)((longlong)register0x00000020 + 0x68);

-        *(undefined1 **)((longlong)register0x00000020 + 0x20) =

-             (undefined1 *)((longlong)register0x00000020 + 0x70);

-      }

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400047db;

-      EtwWrite(Microsoft_Windows_Networking_CorrelationHandle,&ActivityStop,

-               (longlong)unaff_RBX + 0x18c,uVar18);

-    }

-    pppplVar1 = (longlong ****)unaff_RBX[0xe];

-    if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0))

-       && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

-      uVar18 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-      *(longlong *****)((longlong)register0x00000020 + 0x20) = pppplVar1;

-                    /* WARNING: Subroutine does not return */

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004aba;

-      WPP_SF_qq(uVar18,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,unaff_RBX);

-    }

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

-LAB_1:

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004395;

-      uVar12 = func_0x000140004c90();

-      goto LAB_0;

-    }

-    if ((*(char *)(unaff_RBX + 4) == '\f') && (*(char *)((longlong)unaff_RBX + 0x21) == '\x02')) {

-      ppplVar17 = pppplVar1[0x1c];

-    }

-    else {

-      ppplVar17 = pppplVar1[0x1b];

-    }

-    if ((*(uint *)(unaff_RBX + 0xf) >> 0x12 & 1) == 0) {

-LAB_2:

-      unaff_RBX[0xe] = (longlong *)unaff_R13;

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000438d;

-      RxDereference(pppplVar1,0);

-      goto LAB_1;

-    }

-    *(uint *)(unaff_RBX + 0xf) = *(uint *)(unaff_RBX + 0xf) & 0xfffbffff;

-    ppplVar2 = pppplVar1[0x1f];

-    if ((ppplVar2 == (longlong ***)0x0) || ((*(uint *)((longlong)ppplVar2 + 0x2c) & 1) == 0)) {

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

+      bVar3 = false;

+      goto LAB_10;

+    }

+    LOCK();

+    uVar7 = *puVar13;

+    bVar15 = uVar8 == uVar7;

+    if (bVar15) {

+      *puVar13 = uVar8 + 2;

+      uVar7 = uVar8;

+    }

+    UNLOCK();

+    uVar8 = uVar7;

+  } while (!bVar15);

+  bVar3 = true;

+LAB_10:

+  if (!bVar3) goto LAB_2;

 LAB_3:

-      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000437f;

-      RfsReleaseRundownProtectionCacheAware((longlong *)ppplVar17);

-      goto LAB_2;

-    }

-    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400047fc;

-    uVar11 = KeAcquireSpinLockRaiseToDpc(ppplVar2 + 6);

-    ppplVar3 = (longlong ***)ppplVar2[2];

+  uVar9 = (SystemReserved1[0x12]._4_4_ % *(uint *)((longlong)ppplVar12 + 0x14)) *

+          *(int *)(ppplVar12 + 2);

+  puVar13 = (ulonglong *)((ulonglong)uVar9 + (longlong)*ppplVar12);

+  uVar7 = *puVar13 & 0xfffffffffffffffe;

+  LOCK();

+  uVar8 = *puVar13;

+  if (uVar7 == uVar8) {

+    *puVar13 = uVar7 + 2;

+  }

+  UNLOCK();

+  if (uVar7 != uVar8) {

+    uVar8 = *puVar13;

     do {

-      ppplVar13 = ppplVar3;

-      if (ppplVar13 == ppplVar2 + 2) {

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026e27;

-        KeReleaseSpinLock(ppplVar2 + 6,uVar11);

-        if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0))

-           && (1 < (byte)WPP_GLOBAL_Control[0x29])) {

-          uVar18 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-          *(longlong ****)((longlong)register0x00000020 + 0x20) = ppplVar2;

-                    /* WARNING: Subroutine does not return */

-          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026e62;

-          WPP_SF_qq(uVar18,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,unaff_RBX);

-        }

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

-        uVar12 = (*pcVar8)();

-        return uVar12;

-      }

-      ppplVar3 = (longlong ***)*ppplVar13;

-    } while (ppplVar13[7] != unaff_RBX);

-    puVar9 = (undefined8 *)register0x00000020;

-    if (((longlong ***)ppplVar3[1] == ppplVar13) &&

-       (pplVar4 = ppplVar13[1], (longlong ***)*pplVar4 == ppplVar13)) {

-      *pplVar4 = (longlong *)ppplVar3;

-      ppplVar3[1] = pplVar4;

-      ppplVar13[7] = unaff_R13;

-      pplVar4 = *ppplVar2;

-      if ((longlong ***)pplVar4[1] == ppplVar2) {

-        *ppplVar13 = pplVar4;

-        ppplVar13[1] = (longlong **)ppplVar2;

-        pplVar4[1] = (longlong *)ppplVar13;

-        *ppplVar2 = (longlong **)ppplVar13;

-        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004863;

-        KeReleaseSpinLock(ppplVar2 + 6);

-        goto LAB_3;

-      }

-    }

-    do {

-      do {

-        puVar16 = puVar9;

-        lVar14 = 3;

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

-        (*pcVar8)();

-        register0x00000020 = (BADSPACEBASE *)(puVar16 + 1);

-        if ((*(uint *)(lVar14 + 0x2c) & 1) == 0) goto LAB_4;

-        *puVar16 = 0x14000489f;

-        uVar11 = KeAcquireSpinLockRaiseToDpc(lVar14 + 0x30);

-        plVar5 = (longlong *)puVar16[0xe];

-        plVar6 = (longlong *)plVar5[2];

-        do {

-          plVar15 = plVar6;

-          if (plVar15 == plVar5 + 2) {

-            *puVar16 = 0x140026dd2;

-            KeReleaseSpinLock(plVar5 + 6,uVar11);

-            if (((WPP_GLOBAL_Control != unaff_R15) &&

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

-               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

-              uVar18 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

-              puVar16[5] = puVar16[0xe];

-                    /* WARNING: Subroutine does not return */

-              *puVar16 = 0x140026e12;

-              WPP_SF_qq(uVar18,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,unaff_RBX);

-            }

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

-            uVar12 = (*pcVar8)();

-            return uVar12;

-          }

-          plVar6 = (longlong *)*plVar15;

-        } while ((longlong **)plVar15[7] != unaff_RBX);

-        puVar9 = puVar16 + 1;

-      } while (((longlong *)plVar6[1] != plVar15) ||

-              (plVar7 = (longlong *)plVar15[1], puVar9 = puVar16 + 1, (longlong *)*plVar7 != plVar15

-              ));

-      *plVar7 = (longlong)plVar6;

-      plVar6[1] = (longlong)plVar7;

-      plVar15[7] = 0;

-      lVar14 = *plVar5;

-      puVar9 = puVar16 + 1;

-    } while (*(longlong **)(lVar14 + 8) != plVar5);

-    *plVar15 = lVar14;

-    plVar15[1] = (longlong)plVar5;

-    *(longlong **)(lVar14 + 8) = plVar15;

-    *plVar5 = (longlong)plVar15;

-    *puVar16 = 0x14000490f;

-    KeReleaseSpinLock(plVar5 + 6);

-LAB_4:

-    *puVar16 = 0x1400045b7;

-    RfsReleaseRundownProtectionCacheAware((longlong *)unaff_R13);

-    unaff_R13 = (longlong **)0x0;

-    unaff_RBX[0xe] = (longlong *)0x0;

-    *puVar16 = 0x1400045c8;

-    RxDereference(unaff_RBP,0);

-    plVar5 = unaff_RBX[0x46];

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

-      *puVar16 = 0x14000469d;

-      ExFreePoolWithTag(plVar5,0);

-      unaff_RBX[0x46] = (longlong *)0x0;

-    }

-    if (*(char *)((longlong)unaff_RBX + 0x2dd) < '\0') {

-      plVar5 = unaff_RBX[0x61];

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

-        *puVar16 = 0x14000468f;

-        RxDereferenceCredential(plVar5);

-      }

-      unaff_RBX[0x5d] = (longlong *)0x0;

-      unaff_RBX[0x5e] = (longlong *)0x0;

-      unaff_RBX[0x5f] = (longlong *)0x0;

-      unaff_RBX[0x60] = (longlong *)0x0;

-      unaff_RBX[0x61] = (longlong *)0x0;

-      *(byte *)((longlong)unaff_RBX + 0x2dd) = *(byte *)((longlong)unaff_RBX + 0x2dd) & 0x7f;

-    }

-    pcVar8 = MmBadPointer_exref;

-    unaff_RBX[0x4e] = (longlong *)0x0;

-    unaff_RBX[0x4f] = (longlong *)0x0;

-    unaff_RBX[0x51] = (longlong *)0x0;

-    unaff_RBX[0x52] = *(longlong **)pcVar8;

-    unaff_RBX[0x53] = *(longlong **)pcVar8;

-    unaff_RBX[0x55] = *(longlong **)pcVar8;

-    unaff_RBX[0x42] = *(longlong **)pcVar8;

-    unaff_RBX[0x45] = *(longlong **)pcVar8;

-    unaff_RBX[0x46] = *(longlong **)pcVar8;

-    unaff_RBX[100] = (longlong *)0x0;

-    unaff_RBX[0x65] = (longlong *)0x0;

-    unaff_RBX[0x47] = (longlong *)0x0;

-    unaff_RBX[0x48] = (longlong *)0x0;

-    *(byte *)((longlong)unaff_RBX + 0x2de) = *(byte *)((longlong)unaff_RBX + 0x2de) & 0xfd;

-    if ((*(byte *)ppplVar2 != 0) && (unaff_RBX[7] != (longlong *)0x0)) {

-      *puVar16 = 0x140004284;

-      KeGetCurrentIrql();

-    }

-    if (((*(byte *)ppplVar2 & 0xed) != 0) || (*(byte *)ppplVar2 == 0x10)) {

-      *puVar16 = 0x14000429c;

-      bVar10 = KeGetCurrentIrql();

-      if ((bVar10 < 2) &&

-         ((plVar5 = unaff_RBX[8], plVar5 != (longlong *)0x0 && ((int)ppplVar17 != -0x3fffffea)))) {

-        *(undefined4 *)(plVar5 + 0x20) = *(undefined4 *)((longlong)plVar5 + 0x104);

-        *(int *)((longlong)plVar5 + 0x104) = (int)ppplVar17;

-      }

-    }

-    if (((RxEnablePerProcessCounters != '\0') && (unaff_RBX != (longlong **)0x0)) &&

-       (unaff_RBX[0x19] != (longlong *)0x0)) {

-      *puVar16 = 0x1400042f5;

-      func_0x000140004ad0();

-      unaff_RBX[0x18] = (longlong *)0x0;

-    }

-    *puVar16 = 0x14000430c;

-    uVar12 = IofCompleteRequest(pppplVar1);

-  } while( true );

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

+        uVar11 = 0;

+        goto LAB_11;

+      }

+      LOCK();

+      uVar7 = *puVar13;

+      bVar15 = uVar8 == uVar7;

+      if (bVar15) {

+        *puVar13 = uVar8 + 2;

+        uVar7 = uVar8;

+      }

+      UNLOCK();

+      uVar8 = uVar7;

+    } while (!bVar15);

+    uVar11 = 1;

+LAB_11:

+    if ((char)uVar11 != '\0') goto LAB_8;

+    RfsReleaseRundownProtectionCacheAware((longlong *)*pppplVar1);

+    goto LAB_2;

+  }

+  uVar11 = 1;

+  goto LAB_8;

 }
```

## `FUN_1400272ea`  (modified)

```diff
--- FUN_1400272ea
+++ FUN_140026da2
@@ -1,16 +1,271 @@
 

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

-

-void FUN_1400272ea(void)

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

+

+void FUN_140026da2(void)

 

 {

-  undefined1 *in_RAX;

-  undefined1 unaff_BH;

+  uint uVar1;

+  uint uVar2;

+  longlong ****pppplVar3;

+  longlong *plVar4;

+  longlong **pplVar5;

+  longlong *plVar6;

+  longlong *plVar7;

+  longlong lVar8;

+  code *pcVar9;

+  byte bVar10;

+  undefined1 uVar11;

+  longlong ***ppplVar12;

+  longlong ***ppplVar13;

+  longlong *plVar14;

+  uint uVar15;

+  longlong **unaff_RBX;

+  int iVar16;

+  longlong ***unaff_RSI;

+  longlong ****unaff_RDI;

+  undefined8 uVar17;

+  longlong ***unaff_R13;

+  longlong ***unaff_R14;

+  undefined *unaff_R15;

   

-  LOCK();

-  *in_RAX = unaff_BH;

-  UNLOCK();

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

-  halt_baddata();

+  iVar16 = (int)unaff_RSI;

+  uVar15 = 0;

+  ExFreePoolWithTag(unaff_RBX[0x62]);

+  unaff_RBX[0x62] = (longlong *)unaff_R13;

+  RxFreeCanonicalNameBuffer((longlong)unaff_RBX);

+  unaff_RBX[0x65] = (longlong *)unaff_R13;

+  *(short *)(unaff_RBX + 100) = (short)unaff_R13;

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

+    uVar15 = 0;

+    RxDereference((longlong ****)unaff_RBX[0x50],0);

+    unaff_RBX[0x50] = (longlong *)unaff_R13;

+  }

+  pppplVar3 = (longlong ****)unaff_RBX[0xe];

+  if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0))

+     && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+                    /* WARNING: Subroutine does not return */

+    WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x15,

+              &WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,unaff_RBX);

+  }

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

+  if ((*(char *)(unaff_RBX + 4) == '\f') && (*(char *)((longlong)unaff_RBX + 0x21) == '\x02')) {

+    unaff_R13 = pppplVar3[0x1c];

+  }

+  else {

+    unaff_R13 = pppplVar3[0x1b];

+  }

+  if ((*(uint *)(unaff_RBX + 0xf) >> 0x12 & 1) == 0) goto LAB_1;

+  *(uint *)(unaff_RBX + 0xf) = *(uint *)(unaff_RBX + 0xf) & 0xfffbffff;

+  ppplVar13 = pppplVar3[0x1f];

+  if (ppplVar13 != (longlong ***)0x0) goto LAB_2;

+LAB_3:

+  do {

+    iVar16 = (int)unaff_RSI;

+    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400045b7;

+    RfsReleaseRundownProtectionCacheAware((longlong *)unaff_R13);

+LAB_1:

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

+    uVar15 = 0;

+    unaff_RBX[0xe] = (longlong *)0x0;

+    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400045c8;

+    RxDereference(pppplVar3,0);

+LAB_0:

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

+      uVar15 = 0;

+      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000469d;

+      ExFreePoolWithTag();

+      unaff_RBX[0x46] = (longlong *)unaff_R13;

+    }

+    if (*(char *)((longlong)unaff_RBX + 0x2dd) < '\0') {

+      plVar4 = unaff_RBX[0x61];

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

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000468f;

+        RxDereferenceCredential(plVar4);

+      }

+      unaff_RBX[0x5d] = (longlong *)0x0;

+      unaff_RBX[0x5e] = (longlong *)0x0;

+      unaff_RBX[0x5f] = (longlong *)0x0;

+      unaff_RBX[0x60] = (longlong *)0x0;

+      unaff_RBX[0x61] = (longlong *)0x0;

+      *(byte *)((longlong)unaff_RBX + 0x2dd) = *(byte *)((longlong)unaff_RBX + 0x2dd) & 0x7f;

+    }

+    pcVar9 = MmBadPointer_exref;

+    unaff_RBX[0x4e] = (longlong *)unaff_R13;

+    unaff_RBX[0x4f] = (longlong *)unaff_R13;

+    unaff_RBX[0x51] = (longlong *)unaff_R13;

+    unaff_RBX[0x52] = *(longlong **)pcVar9;

+    unaff_RBX[0x53] = *(longlong **)pcVar9;

+    unaff_RBX[0x55] = *(longlong **)pcVar9;

+    unaff_RBX[0x42] = *(longlong **)pcVar9;

+    unaff_RBX[0x45] = *(longlong **)pcVar9;

+    unaff_RBX[0x46] = *(longlong **)pcVar9;

+    unaff_RBX[100] = (longlong *)0x0;

+    unaff_RBX[0x65] = (longlong *)0x0;

+    unaff_RBX[0x47] = (longlong *)0x0;

+    unaff_RBX[0x48] = (longlong *)0x0;

+    *(byte *)((longlong)unaff_RBX + 0x2de) = *(byte *)((longlong)unaff_RBX + 0x2de) & 0xfd;

+    if ((*(byte *)unaff_R14 != 0) && (unaff_RBX[7] != (longlong *)0x0)) {

+      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004284;

+      KeGetCurrentIrql();

+    }

+    if (((*(byte *)unaff_R14 & 0xed) != 0) || (*(byte *)unaff_R14 == 0x10)) {

+      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000429c;

+      bVar10 = KeGetCurrentIrql();

+      if ((bVar10 < 2) &&

+         ((plVar4 = unaff_RBX[8], plVar4 != (longlong *)0x0 && (iVar16 != -0x3fffffea)))) {

+        *(undefined4 *)(plVar4 + 0x20) = *(undefined4 *)((longlong)plVar4 + 0x104);

+        *(int *)((longlong)plVar4 + 0x104) = iVar16;

+      }

+    }

+    if (((RxEnablePerProcessCounters != '\0') && (unaff_RBX != (longlong **)0x0)) &&

+       (plVar4 = unaff_RBX[0x19], plVar4 != (longlong *)0x0)) {

+      uVar1 = *(uint *)((longlong)unaff_RBX + 0xc4);

+      uVar2 = *(uint *)(unaff_RBX + 0x18);

+      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400042f5;

+      RdbssStatisticsEntryUpdateSocketCounters(plVar4,uVar15,uVar2,uVar1);

+      unaff_RBX[0x18] = (longlong *)0x0;

+    }

+    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000430c;

+    IofCompleteRequest(unaff_RDI);

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

+    if (Microsoft_Windows_Networking_CorrelationEnabled != 0) {

+      *(int *)((longlong)register0x00000020 + 0x68) = (int)unaff_R13;

+      if (Microsoft_Windows_Networking_CorrelationTraceActivityPayload == 0) {

+        *(longlong ****)((longlong)register0x00000020 + 0x20) = unaff_R13;

+        uVar17 = 0;

+      }

+      else {

+        *(undefined8 *)((longlong)register0x00000020 + 0x78) = 0x10;

+        *(undefined **)((longlong)register0x00000020 + 0x70) =

+             &Microsoft_Windows_Networking_ProviderId;

+        uVar17 = 2;

+        *(undefined8 *)((longlong)register0x00000020 + 0x88) = 4;

+        *(undefined1 **)((longlong)register0x00000020 + 0x80) =

+             (undefined1 *)((longlong)register0x00000020 + 0x68);

+        *(undefined1 **)((longlong)register0x00000020 + 0x20) =

+             (undefined1 *)((longlong)register0x00000020 + 0x70);

+      }

+      *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400047db;

+      EtwWrite(Microsoft_Windows_Networking_CorrelationHandle,&ActivityStop,

+               (longlong)unaff_RBX + 0x18c,uVar17);

+    }

+    unaff_RDI = (longlong ****)unaff_RBX[0xe];

+    if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x400) != 0))

+       && (3 < (byte)WPP_GLOBAL_Control[0x29])) {

+      uVar17 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+      *(longlong *****)((longlong)register0x00000020 + 0x20) = unaff_RDI;

+                    /* WARNING: Subroutine does not return */

+      *(undefined **)((longlong)register0x00000020 + -8) = &UNK_5;

+      WPP_SF_qq(uVar17,0x15,&WPP_dfd0ea1244783654c393e29ad22b4feb_Traceguids,unaff_RBX);

+    }

+    if (unaff_RDI == (longlong ****)0x0) goto LAB_6;

+    if ((*(char *)(unaff_RBX + 4) == '\f') && (*(char *)((longlong)unaff_RBX + 0x21) == '\x02')) {

+      unaff_RSI = unaff_RDI[0x1c];

+    }

+    else {

+      unaff_RSI = unaff_RDI[0x1b];

+    }

+    if ((*(uint *)(unaff_RBX + 0xf) >> 0x12 & 1) == 0) goto LAB_7;

+    *(uint *)(unaff_RBX + 0xf) = *(uint *)(unaff_RBX + 0xf) & 0xfffbffff;

+    unaff_R14 = unaff_RDI[0x1f];

+    if ((unaff_R14 == (longlong ***)0x0) || ((*(uint *)((longlong)unaff_R14 + 0x2c) & 1) == 0))

+    goto LAB_8;

+    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400047fc;

+    uVar11 = KeAcquireSpinLockRaiseToDpc(unaff_R14 + 6);

+    ppplVar13 = (longlong ***)unaff_R14[2];

+    do {

+      ppplVar12 = ppplVar13;

+      if (ppplVar12 == unaff_R14 + 2) {

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026e27;

+        KeReleaseSpinLock(unaff_R14 + 6,uVar11);

+        if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0))

+           && (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+          uVar17 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+          *(longlong ****)((longlong)register0x00000020 + 0x20) = unaff_R14;

+                    /* WARNING: Subroutine does not return */

+          *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026e62;

+          WPP_SF_qq(uVar17,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,unaff_RBX);

+        }

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

+        (*pcVar9)();

+        return;

+      }

+      ppplVar13 = (longlong ***)*ppplVar12;

+    } while (ppplVar12[7] != unaff_RBX);

+    if (((longlong ***)ppplVar13[1] == ppplVar12) &&

+       (pplVar5 = ppplVar12[1], (longlong ***)*pplVar5 == ppplVar12)) {

+      *pplVar5 = (longlong *)ppplVar13;

+      ppplVar13[1] = pplVar5;

+      ppplVar12[7] = (longlong **)unaff_R13;

+      pplVar5 = *unaff_R14;

+      if ((longlong ***)pplVar5[1] == unaff_R14) {

+        *ppplVar12 = pplVar5;

+        ppplVar12[1] = (longlong **)unaff_R14;

+        pplVar5[1] = (longlong *)ppplVar12;

+        *unaff_R14 = (longlong **)ppplVar12;

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004863;

+        KeReleaseSpinLock(unaff_R14 + 6);

+LAB_8:

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000437f;

+        RfsReleaseRundownProtectionCacheAware((longlong *)unaff_RSI);

+LAB_7:

+        unaff_RBX[0xe] = (longlong *)unaff_R13;

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000438d;

+        RxDereference(unaff_RDI,0);

+LAB_6:

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140004395;

+        RxDereferenceAndDeleteRxContext_Real((longlong)unaff_RBX);

+LAB_4:

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x1400043a5;

+        return;

+      }

+    }

+    do {

+      do {

+        ppplVar13 = (longlong ***)0x3;

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

+        (*pcVar9)();

+        register0x00000020 = (BADSPACEBASE *)((longlong)register0x00000020 + 8);

+LAB_2:

+        if ((*(uint *)((longlong)ppplVar13 + 0x2c) & 1) == 0) goto LAB_3;

+        *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000489f;

+        uVar11 = KeAcquireSpinLockRaiseToDpc(ppplVar13 + 6);

+        plVar4 = *(longlong **)((longlong)register0x00000020 + 0x68);

+        plVar6 = (longlong *)plVar4[2];

+        do {

+          plVar14 = plVar6;

+          if (plVar14 == plVar4 + 2) {

+            *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026dd2;

+            KeReleaseSpinLock(plVar4 + 6,uVar11);

+            if (((WPP_GLOBAL_Control != unaff_R15) &&

+                ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 2) != 0)) &&

+               (1 < (byte)WPP_GLOBAL_Control[0x29])) {

+              uVar17 = *(undefined8 *)(WPP_GLOBAL_Control + 0x18);

+              *(undefined8 *)((longlong)register0x00000020 + 0x20) =

+                   *(undefined8 *)((longlong)register0x00000020 + 0x68);

+                    /* WARNING: Subroutine does not return */

+              *(undefined8 *)((longlong)register0x00000020 + -8) = 0x140026e12;

+              WPP_SF_qq(uVar17,10,&WPP_6c13c8cc71fc32210c6697666eba2ea7_Traceguids,unaff_RBX);

+            }

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

+            (*pcVar9)();

+            return;

+          }

+          plVar6 = (longlong *)*plVar14;

+        } while ((longlong **)plVar14[7] != unaff_RBX);

+      } while (((longlong *)plVar6[1] != plVar14) ||

+              (plVar7 = (longlong *)plVar14[1], (longlong *)*plVar7 != plVar14));

+      *plVar7 = (longlong)plVar6;

+      plVar6[1] = (longlong)plVar7;

+      plVar14[7] = 0;

+      lVar8 = *plVar4;

+    } while (*(longlong **)(lVar8 + 8) != plVar4);

+    *plVar14 = lVar8;

+    plVar14[1] = (longlong)plVar4;

+    *(longlong **)(lVar8 + 8) = plVar14;

+    *plVar4 = (longlong)plVar14;

+    *(undefined8 *)((longlong)register0x00000020 + -8) = 0x14000490f;

+    KeReleaseSpinLock(plVar4 + 6);

+  } while( true );

 }
```

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

```diff
--- NTOSKRNL.EXE::RtlCaptureStackBackTrace calling
+++ NTOSKRNL.EXE::RtlCaptureStackBackTrace calling
@@ -1 +1,2 @@
-FUN_140028124
+FUN_140027a46
+RxDiagnosticInsertTrackerEntry
@@ -3 +3,0 @@
-RxWaitForStableLViewOnFcbAndAcquireRundown
```

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

```diff
--- NTOSKRNL.EXE::KeSetEvent calling
+++ NTOSKRNL.EXE::KeSetEvent calling
@@ -1,13 +1,3 @@
-FUN_1400049e8
-FUN_140027363
-FUN_1400273e3
-FUN_1400274a0
-FUN_1400274d1
-FUN_140027502
-FUN_140027532
-FUN_140027562
-FUN_14002765a
-FUN_140027a53
-FUN_140027af5
-FUN_1400281b2
-FUN_14007eef6
+FUN_140004f08
+FUN_14007ef06
+RfsReleaseRundownProtectionCacheAware
```

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

```diff
--- NTOSKRNL.EXE::KeAcquireSpinLockRaiseToDpc calling
+++ NTOSKRNL.EXE::KeAcquireSpinLockRaiseToDpc calling
@@ -1 +1 @@
-FUN_140027b26
+FUN_140027448
@@ -25,0 +26 @@
+RxDiagnosticInsertTrackerEntry
@@ -53 +53,0 @@
-RxWaitForStableLViewOnFcbAndAcquireRundown
```
