# CVE-2026-95891 — tm.sys patch diff

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

## `TmpInternalCrmNotification`  (modified)

```diff
--- TmpInternalCrmNotification
+++ TmpInternalCrmNotification
@@ -1,12 +1,296 @@
-

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

 

 ulonglong TmpInternalCrmNotification

                     (longlong param_1,longlong *param_2,ulonglong *param_3,uint param_4,

                     longlong *param_5,undefined8 param_6,undefined4 param_7)

 

 {

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

-  halt_baddata();

+  longlong *plVar1;

+  undefined8 uVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  undefined4 *puVar5;

+  longlong lVar6;

+  longlong lVar7;

+  ulonglong uVar8;

+  ulonglong uVar9;

+  ulonglong uVar10;

+  undefined4 *puVar12;

+  ulonglong uVar13;

+  bool bVar15;

+  undefined4 local_res8 [2];

+  ulonglong local_res10;

+  undefined4 *puVar16;

+  code **ppcVar17;

+  ulonglong *puVar18;

+  undefined4 local_78;

+  undefined4 local_74;

+  undefined4 local_70;

+  undefined4 local_6c;

+  undefined4 local_68 [2];

+  ulonglong local_60;

+  ulonglong local_58;

+  longlong local_50;

+  code *local_48;

+  code *local_40;

+  ulonglong local_38;

+  ulonglong uVar11;

+  ulonglong uVar14;

+  

+  uVar9 = 0;

+  uVar8 = 0;

+  uVar14 = 0;

+  uVar13 = 0;

+  local_60 = 0;

+  uVar11 = 0;

+  uVar10 = 0;

+  local_res10 = 0;

+  lVar7 = 0;

+  local_50 = 0;

+  if (param_1 != 0) {

+    ObfReferenceObject();

+    uVar4 = Feature_1882352953__private_IsEnabledDeviceUsageNoInline();

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

+      TmpAcquireTransactionMutex(*(longlong *)(param_1 + 0xa0));

+    }

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

+    if (lVar6 != 0) {

+      local_50 = lVar6;

+      ObfReferenceObject(lVar6);

+      lVar7 = lVar6;

+    }

+    uVar4 = Feature_1882352953__private_IsEnabledDeviceUsageNoInline();

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

+      param_2 = (longlong *)0x0;

+      KeReleaseMutex(*(longlong *)(*(longlong *)(param_1 + 0xa0) + 0x58) + 0x20);

+    }

+  }

+  if (param_4 == 0x2000) goto LAB_0;

+  uVar4 = Feature_1882352953__private_IsEnabledDeviceUsageNoInline();

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

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

+  }

+  if ((((param_4 == 0x100) || (param_4 == 0x800)) && (lVar7 != 0)) ||

+     (((param_4 != 0x100 && (param_4 != 0x800)) && ((param_4 != 0x2000000 && (lVar7 == 0))))))

+  goto LAB_0;

+  param_2 = (longlong *)0x80;

+  uVar11 = uVar10;

+  uVar14 = uVar13;

+  if (param_4 < 0x81) {

+    if (param_4 == 0x80) {

+      param_5 = (longlong *)0x0;

+      uVar3 = TmRollbackComplete(lVar7,(longlong *)0x0);

+    }

+    else if (param_4 == 1) {

+      uVar3 = TmPrePrepareEnlistment(lVar7,param_5);

+    }

+    else {

+      if (param_4 == 2) {

+        uVar3 = TmPrepareEnlistment(lVar7,param_5);

+        param_2 = param_5;

+        uVar9 = (ulonglong)uVar3;

+        if ((int)uVar3 < 0) {

+          param_2 = (longlong *)0x0;

+          TmRollbackEnlistment(param_1,(longlong *)0x0);

+        }

+        goto LAB_0;

+      }

+      param_2 = (longlong *)0x2;

+      if (param_4 == 4) goto LAB_1;

+      if (param_4 == 8) {

+        uVar3 = TmRollbackEnlistment(lVar7,param_5);

+      }

+      else {

+        if (param_4 == 0x10) {

+          local_68[0] = 0x10a;

+          local_6c = 0x111;

+          local_70 = 8;

+          local_40 = TmpTxActionDoPrePrepareComplete;

+          local_74 = 2;

+          puVar18 = (ulonglong *)&local_74;

+          ppcVar17 = &local_40;

+          puVar16 = &local_70;

+          puVar5 = &local_6c;

+          puVar12 = local_68;

+        }

+        else {

+          if (param_4 != 0x20) {

+            if (param_4 != 0x40) goto LAB_2;

+            param_5 = (longlong *)0x0;

+            uVar3 = TmCommitComplete(lVar7,(longlong *)0x0);

+            goto LAB_3;

+          }

+          local_78 = 0x101;

+          param_7 = 0x102;

+          local_res8[0] = 2;

+          local_48 = TmpTxActionDoPrepareComplete;

+          local_res10 = local_res10 & 0xffffffff00000000;

+          puVar18 = &local_res10;

+          ppcVar17 = &local_48;

+          puVar16 = local_res8;

+          puVar5 = &param_7;

+          puVar12 = &local_78;

+        }

+        param_5 = (longlong *)0x0;

+        param_3 = (ulonglong *)0x1;

+        uVar3 = TmpProcessNotificationResponse

+                          (lVar7,(longlong *)0x0,1,(longlong)puVar12,(longlong)puVar5,

+                           (longlong)puVar16,(longlong)ppcVar17,(longlong)puVar18);

+      }

+    }

+  }

+  else {

+    uVar9 = uVar8;

+    if (param_4 == 0x100) {

+LAB_4:

+      local_58 = 0;

+      plVar1 = (longlong *)(param_1 + 0x118);

+      param_3 = &local_58;

+      param_2 = plVar1;

+      TmpNamespaceLookup(0x140008520,plVar1,param_3);

+      uVar14 = local_58;

+      local_38 = local_58;

+      if (local_58 == 0) {

+        TmpTransactionManagerNeededForRecovery(plVar1);

+        goto LAB_0;

+      }

+      param_2 = (longlong *)(param_1 + 0x128);

+      param_3 = &local_60;

+      uVar8 = TmpFindResourceManagerTm(local_58,param_2,param_3);

+      uVar9 = uVar8 & 0xffffffff;

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

+      param_2 = (longlong *)(param_1 + 0x108);

+      param_3 = &local_res10;

+      uVar8 = TmpFindEnlistmentResourceManager(local_60,param_2,param_3);

+      uVar11 = local_res10;

+      uVar9 = uVar8 & 0xffffffff;

+      if ((int)uVar8 == -0x3fe6ffb0) {

+        TmRecoverEnlistment(param_1,0);

+        param_2 = (longlong *)0x0;

+        if (param_4 == 0x100) {

+          TmCommitComplete(param_1,(longlong *)0x0);

+          uVar11 = local_res10;

+        }

+        else {

+          TmRollbackEnlistment(param_1,(longlong *)0x0);

+          uVar11 = local_res10;

+        }

+      }

+      else {

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

+        lVar7 = local_res10 + 0x40;

+        KeWaitForSingleObject(lVar7,0,0,0,0);

+        param_3 = (ulonglong *)0x10;

+        lVar6 = RtlCompareMemory(uVar11 + 0x108);

+        if (lVar6 == 0x10) {

+          param_3 = (ulonglong *)0x10;

+          lVar6 = RtlCompareMemory(uVar11 + 0x128);

+          if (lVar6 == 0x10) {

+            param_3 = (ulonglong *)0x10;

+            lVar6 = RtlCompareMemory(uVar11 + 0x118);

+            if (lVar6 == 0x10) {

+              uVar9 = Feature_2864344377__private_IsEnabledDeviceUsageNoInline();

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

+                *(ulonglong *)(param_1 + 0xf0) = uVar11;

+                ObfReferenceObject(uVar11);

+                *(longlong *)(uVar11 + 0xf0) = param_1;

+                ObfReferenceObject(param_1);

+                KeReleaseMutex(lVar7);

+              }

+              else {

+                KeReleaseMutex(lVar7);

+                uVar11 = local_res10;

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

+                  lVar7 = *(longlong *)(local_res10 + 0xa0);

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

+                }

+                else {

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

+                  lVar6 = *(longlong *)(local_res10 + 0xa0);

+                }

+                TmpAcquireTransactionMutex(lVar6);

+                uVar2 = *(undefined8 *)(lVar6 + 0x58);

+                bVar15 = *(longlong *)(lVar7 + 0x58) == lVar7;

+                if (bVar15) {

+                  ObfReferenceObject(uVar2);

+                }

+                KeReleaseMutex(*(longlong *)(lVar6 + 0x58) + 0x20);

+                KeWaitForSingleObject(lVar7 + 0x20,0,0,0,0);

+                if (*(longlong *)(lVar7 + 0x58) == lVar7) {

+                  *(undefined8 *)(lVar7 + 0x58) = uVar2;

+                }

+                else if (bVar15) {

+                  ObfDereferenceObject(uVar2);

+                }

+                param_3 = (ulonglong *)0x0;

+                KeWaitForSingleObject(uVar11 + 0x40,0,0,0,0);

+                if ((*(longlong *)(param_1 + 0xf0) == 0) && (*(longlong *)(uVar11 + 0xf0) == 0)) {

+                  *(ulonglong *)(param_1 + 0xf0) = uVar11;

+                  ObfReferenceObject(uVar11);

+                  *(longlong *)(uVar11 + 0xf0) = param_1;

+                  ObfReferenceObject(param_1);

+                }

+                KeReleaseMutex(uVar11 + 0x40);

+                KeReleaseMutex(lVar7 + 0x20);

+                uVar14 = local_38;

+              }

+              TmRecoverEnlistment(param_1,0);

+              param_2 = (longlong *)0x0;

+              TmRecoverEnlistment(uVar11,0);

+              goto LAB_5;

+            }

+          }

+        }

+        param_2 = (longlong *)0x0;

+        KeReleaseMutex(lVar7);

+      }

+LAB_5:

+      uVar9 = 0;

+      goto LAB_0;

+    }

+    if (param_4 == 0x200) {

+LAB_1:

+      param_5 = (longlong *)0x0;

+      uVar3 = TmCommitEnlistment(lVar7,(longlong *)0x0);

+    }

+    else {

+      if (param_4 == 0x800) goto LAB_4;

+      if (param_4 == 0x4000) goto LAB_0;

+      if (param_4 == 0x1000000) {

+        TmpRmDisconnectTransaction(lVar7);

+        goto LAB_0;

+      }

+      if (param_4 != 0x20000000) {

+LAB_2:

+        uVar9 = 0xc0000001;

+        goto LAB_0;

+      }

+      param_5 = (longlong *)0x0;

+      uVar3 = TmRequestOutcomeEnlistment(lVar7,(longlong *)0x0);

+    }

+  }

+LAB_3:

+  param_2 = param_5;

+  uVar9 = (ulonglong)uVar3;

+LAB_0:

+  if ((((int)uVar9 < 0) && ((undefined **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

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

+    WPP_SF_DDq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),param_2,param_3,(int)uVar9);

+  }

+  if (local_50 != 0) {

+    ObDereferenceObjectDeferDelete();

+  }

+  if (param_1 != 0) {

+    ObDereferenceObjectDeferDelete(param_1);

+  }

+  if (uVar11 != 0) {

+    ObDereferenceObjectDeferDelete(uVar11);

+  }

+  if (uVar14 != 0) {

+    ObDereferenceObjectDeferDelete(uVar14);

+  }

+  if (local_60 != 0) {

+    ObDereferenceObjectDeferDelete();

+  }

+  return uVar9;

 }
```

## `TmpFinalizeTransaction`  (modified)

```diff
--- TmpFinalizeTransaction
+++ TmpFinalizeTransaction
@@ -1,65 +1,123 @@
 

-ulonglong TmpFinalizeTransaction(longlong param_1)

+undefined8 TmpFinalizeTransaction(longlong param_1)

 

 {

-  undefined8 *puVar1;

-  undefined8 uVar2;

-  undefined8 uVar3;

-  undefined8 uVar4;

-  undefined8 uVar5;

-  int in_EAX;

-  uint in_EDX;

-  longlong unaff_RSI;

-  ulonglong unaff_RDI;

-  undefined8 *in_R8;

-  ulonglong unaff_R12;

-  longlong unaff_R13;

-  int unaff_R14D;

-  longlong unaff_R15;

-  undefined4 in_stack_00000030;

-  uint in_stack_00000040;

-  int in_stack_00000048;

-  undefined8 *in_stack_00000050;

-  longlong in_stack_00000088;

-  longlong in_stack_00000090;

-  undefined8 *in_stack_00000098;

-  undefined4 *in_stack_00000180;

-  ulonglong uVar6;

+  longlong *plVar1;

+  longlong lVar2;

+  longlong *plVar3;

+  code *pcVar4;

+  bool bVar5;

+  uint uVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  undefined8 *unaff_RBX;

+  undefined8 *puVar9;

+  undefined1 *puVar10;

+  undefined1 *puVar11;

+  undefined8 *puVar12;

+  undefined1 auStack_48 [8];

+  undefined1 auStack_40 [24];

+  undefined8 local_28;

   

-  uVar6 = (ulonglong)(in_EAX + 0x20);

-  while (param_1 + uVar6 <= unaff_R12) {

-    KeWaitForSingleObject(in_R8 + 8,0,0,0);

-    uVar2 = in_stack_00000050[6];

-    uVar3 = in_stack_00000050[7];

-    uVar4 = *(undefined8 *)(in_stack_00000050[0x13] + 0x88);

-    uVar5 = *(undefined8 *)(in_stack_00000050[0x13] + 0x90);

-    KeReleaseMutex(in_R8 + 8,0);

-    in_stack_00000040 = in_stack_00000040 + 1;

-    *(undefined8 *)(in_stack_00000088 + in_stack_00000090) = uVar2;

-    ((undefined8 *)(in_stack_00000088 + in_stack_00000090))[1] = uVar3;

-    puVar1 = (undefined8 *)(in_stack_00000088 + 0x10 + in_stack_00000090);

-    *puVar1 = uVar4;

-    puVar1[1] = uVar5;

-    in_EDX = 0x80000005;

-    do {

-      if (in_stack_00000098 == (undefined8 *)(unaff_RSI + 200)) goto LAB_0;

-      in_R8 = in_stack_00000098 + -0xf;

-      in_stack_00000098 = (undefined8 *)*in_stack_00000098;

-    } while (in_R8 == *(undefined8 **)(unaff_RSI + 0xf0));

-    in_stack_00000088 = (ulonglong)in_stack_00000040 * 0x20;

-    param_1 = in_stack_00000090;

-    in_stack_00000050 = in_R8;

-    uVar6 = (in_stack_00000088 - unaff_R13) + 0x20;

+  puVar10 = auStack_48;

+  bVar5 = false;

+  if ((*(uint *)(param_1 + 0xc4) & 0x10000000) != 0) {

+    return 0;

   }

-  unaff_RDI = (ulonglong)in_EDX;

+  LOCK();

+  *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) | 0x10000000;

+  UNLOCK();

+  uVar8 = Feature_1546284347__private_IsEnabledDeviceUsageNoInline();

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

+    if ((*(uint *)(param_1 + 0xc4) >> 0x17 & 1) == 0) goto LAB_0;

+    local_28 = 0;

+    KeWaitForSingleObject(*(longlong *)(param_1 + 0x200) + 0x200,0,0,0);

+    if ((*(uint *)(param_1 + 0xc4) >> 0x17 & 1) != 0) {

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

+      if (*(longlong **)(*(longlong *)(param_1 + 0x200) + 0x238) == plVar1) {

+        uVar6 = ClfsLsnContainer(*(longlong *)(param_1 + 0x200) + 0x288);

+        unaff_RBX = (undefined8 *)(ulonglong)uVar6;

+        uVar7 = ClfsLsnContainer(param_1 + 0xf8);

+        bVar5 = false;

+        if (uVar6 < uVar7) {

+          bVar5 = true;

+        }

+      }

+      lVar2 = *plVar1;

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

+         (plVar3 = *(longlong **)(param_1 + 0x1f0), (longlong *)*plVar3 != plVar1)) {

+LAB_1:

+        puVar12 = (undefined8 *)(param_1 + 0x1e8);

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

+        (*pcVar4)(3);

+        puVar10 = auStack_40;

+        goto LAB_2;

+      }

+      *plVar3 = lVar2;

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

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

+      LOCK();

+      *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) & 0xff7fffff;

+      UNLOCK();

+    }

+  }

+  else {

+    if (*(longlong *)(param_1 + 0x200) == 0) goto LAB_0;

+    local_28 = 0;

+    KeWaitForSingleObject(*(longlong *)(param_1 + 0x200) + 0x200,0,0,0);

+    if ((*(uint *)(param_1 + 0xc4) >> 0x17 & 1) != 0) {

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

+      if (*(longlong **)(*(longlong *)(param_1 + 0x200) + 0x238) == plVar1) {

+        uVar6 = ClfsLsnContainer(*(longlong *)(param_1 + 0x200) + 0x288);

+        unaff_RBX = (undefined8 *)(ulonglong)uVar6;

+        uVar7 = ClfsLsnContainer(param_1 + 0xf8);

+        bVar5 = false;

+        if (uVar6 < uVar7) {

+          bVar5 = true;

+        }

+      }

+      lVar2 = *plVar1;

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

+         (plVar3 = *(longlong **)(param_1 + 0x1f0), (longlong *)*plVar3 != plVar1))

+      goto LAB_1;

+      *plVar3 = lVar2;

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

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

+      LOCK();

+      *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) & 0xff7fffff;

+      UNLOCK();

+    }

+  }

+  KeReleaseMutex(*(longlong *)(param_1 + 0x200) + 0x200,0);

 LAB_0:

-  if (in_stack_00000048 != unaff_R14D) {

-    KeReleaseMutex(*(longlong *)(unaff_RSI + 0x58) + unaff_R15,0);

+  puVar11 = auStack_48;

+  if (((*(uint *)(param_1 + 0xc4) >> 8 & 1) != 0) &&

+     (puVar11 = auStack_48, (*(uint *)(param_1 + 0xc4) >> 10 & 1) != 0)) {

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

+    puVar9 = (undefined8 *)*puVar12;

+    while (unaff_RBX = puVar9, puVar11 = puVar10, puVar9 != puVar12) {

+LAB_2:

+      puVar9 = (undefined8 *)*unaff_RBX;

+      if (unaff_RBX[0x36] != 0) {

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

+        ZwClose();

+        unaff_RBX[0x36] = 0;

+      }

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

+      ObfDereferenceObject(unaff_RBX + -0x20);

+    }

   }

-  ObfDereferenceObject();

-  if (in_stack_00000180 != (undefined4 *)0x0) {

-    *in_stack_00000180 = in_stack_00000030;

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

+  if (lVar2 != 0) {

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

   }

-  return unaff_RDI & 0xffffffff;

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

+  if ((bVar5) && (lVar2 != 0)) {

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

+    TmpQueueCheckpointTm(lVar2);

+  }

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

+  ObfDereferenceObject(param_1);

+  return 0;

 }
```

## `TmpAcquireTransactionMutex`  (modified)

```diff
--- TmpAcquireTransactionMutex
+++ TmpAcquireTransactionMutex
@@ -1,50 +1,53 @@
 

-undefined4 TmpAcquireTransactionMutex(longlong param_1)

+void TmpAcquireTransactionMutex(longlong param_1)

 

 {

   longlong lVar1;

-  longlong unaff_RSI;

-  undefined4 unaff_EDI;

-  undefined4 *unaff_R13;

-  int unaff_R14D;

-  longlong unaff_R15;

-  bool in_OF;

-  undefined4 unaff_XMM6_Da;

-  undefined4 unaff_XMM6_Db;

-  undefined4 unaff_XMM6_Dc;

-  undefined4 unaff_XMM6_Dd;

-  undefined4 unaff_XMM7_Da;

-  undefined4 unaff_XMM7_Db;

-  undefined4 unaff_XMM7_Dc;

-  undefined4 unaff_XMM7_Dd;

-  undefined4 uStack0000000000000030;

-  int in_stack_00000048;

-  undefined4 *in_stack_00000180;

+  longlong lVar2;

+  ulonglong uVar3;

+  longlong lVar4;

   

-  if (in_OF) {

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

-    unaff_XMM7_Da = *(undefined4 *)(lVar1 + 0x88);

-    unaff_XMM7_Db = *(undefined4 *)(lVar1 + 0x8c);

-    unaff_XMM7_Dc = *(undefined4 *)(lVar1 + 0x90);

-    unaff_XMM7_Dd = *(undefined4 *)(lVar1 + 0x94);

-    KeReleaseMutex(param_1 + 0x40,0);

+  uVar3 = Feature_2864344377__private_IsEnabledDeviceUsageNoInline();

+  lVar4 = param_1;

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

+    ObfReferenceObject(param_1);

   }

-  *unaff_R13 = unaff_XMM6_Da;

-  unaff_R13[1] = unaff_XMM6_Db;

-  unaff_R13[2] = unaff_XMM6_Dc;

-  unaff_R13[3] = unaff_XMM6_Dd;

-  unaff_R13[4] = unaff_XMM7_Da;

-  unaff_R13[5] = unaff_XMM7_Db;

-  unaff_R13[6] = unaff_XMM7_Dc;

-  unaff_R13[7] = unaff_XMM7_Dd;

-  uStack0000000000000030 = (undefined4)unaff_R15;

-  if (in_stack_00000048 != unaff_R14D) {

-    KeReleaseMutex(*(longlong *)(unaff_RSI + 0x58) + unaff_R15,0);

-  }

-  ObfDereferenceObject();

-  if (in_stack_00000180 != (undefined4 *)0x0) {

-    *in_stack_00000180 = uStack0000000000000030;

-  }

-  return unaff_EDI;

+  do {

+    uVar3 = Feature_2864344377__private_IsEnabledDeviceUsageNoInline();

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

+      KeWaitForSingleObject(lVar4 + 0x20,0,0,0,0);

+    }

+    lVar1 = *(longlong *)(lVar4 + 0x58);

+    uVar3 = Feature_2864344377__private_IsEnabledDeviceUsageNoInline();

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

+      ObfReferenceObject(lVar1);

+      KeReleaseMutex(lVar4 + 0x20);

+      ObfDereferenceObject(lVar4);

+    }

+    lVar4 = lVar1 + 0x20;

+    KeWaitForSingleObject(lVar4);

+    if (*(longlong *)(lVar1 + 0x58) == lVar1) {

+      uVar3 = Feature_2864344377__private_IsEnabledDeviceUsageNoInline();

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

+        return;

+      }

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

+      if (lVar2 == lVar1) {

+LAB_0:

+        ObfDereferenceObject(lVar1);

+        return;

+      }

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

+      ObfReferenceObject(lVar1);

+      KeReleaseMutex(lVar4);

+      KeWaitForSingleObject(param_1 + 0x20);

+      ObDereferenceObjectDeferDelete(lVar2);

+      KeReleaseMutex(param_1 + 0x20);

+      KeWaitForSingleObject(lVar4);

+      if (*(longlong *)(lVar1 + 0x58) == lVar1) goto LAB_0;

+    }

+    KeReleaseMutex(lVar4);

+    lVar4 = lVar1;

+  } while( true );

 }
```

## `NtQueryInformationTransaction`  (modified)

```diff
--- NtQueryInformationTransaction
+++ NtQueryInformationTransaction
@@ -1,10 +1,235 @@
 

 ulonglong NtQueryInformationTransaction

                     (undefined8 param_1,uint param_2,uint *param_3,uint param_4,uint *param_5)

 

 {

-  ulonglong in_stack_00000030;

+  longlong lVar1;

+  undefined8 *puVar2;

+  char cVar3;

+  undefined8 uVar4;

+  undefined8 uVar5;

+  undefined8 uVar6;

+  undefined8 uVar7;

+  longlong lVar8;

+  int iVar9;

+  uint uVar10;

+  undefined8 *puVar11;

+  uint *puVar12;

+  ulonglong unaff_RDI;

+  undefined8 uVar13;

+  uint local_res10;

+  uint uVar14;

+  longlong lVar15;

+  uint uVar16;

+  undefined8 *puVar17;

+  longlong local_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  ulonglong local_e8;

+  ulonglong uStack_e0;

+  undefined8 *local_d8;

+  longlong local_d0;

+  uint *local_c8;

+  undefined8 *local_c0;

+  undefined8 uStack_b8;

+  undefined8 local_b0;

+  undefined8 uStack_a8;

+  undefined8 local_a0;

+  undefined8 uStack_98;

+  undefined8 local_90;

+  undefined8 uStack_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  ulonglong local_70;

+  undefined8 uStack_68;

   

-  return in_stack_00000030;

+                    /* 0x19cb0  25  NtQueryInformationTransaction */

+  local_c0 = (undefined8 *)0x0;

+  uStack_b8 = 0;

+  local_f8 = 0;

+  uStack_f0 = 0;

+  local_e8 = 0;

+  uStack_e0 = 0;

+  local_b0 = 0;

+  uStack_a8 = 0;

+  local_a0 = 0;

+  uStack_98 = 0;

+  local_90 = 0;

+  uStack_88 = 0;

+  local_80 = 0;

+  uStack_78 = 0;

+  uVar13 = 0;

+  uVar14 = 0;

+  uVar16 = 0;

+  if ((3 < param_2) && (param_2 != 5)) {

+    return unaff_RDI;

+  }

+  if (param_2 == 0) {

+    if (param_4 != 0x18) {

+      return unaff_RDI;

+    }

+  }

+  else if ((param_2 != 1) && (param_2 != 2)) {

+    if (param_2 == 3) {

+      if (param_4 != 0x20) {

+        return unaff_RDI;

+      }

+      uVar13 = 4;

+    }

+    else if (param_2 == 5) {

+      uVar13 = 1;

+    }

+    goto LAB_0;

+  }

+  uVar13 = 4;

+LAB_0:

+  cVar3 = *(char *)((longlong)SystemReserved1[0xf] + 0x232);

+  if ((cVar3 != '\0') && (ProbeForWrite(param_3,(ulonglong)param_4,uVar13), param_5 != (uint *)0x0))

+  {

+    puVar12 = param_5;

+    if (*(uint **)MmUserProbeAddress_exref <= param_5) {

+      puVar12 = *(uint **)MmUserProbeAddress_exref;

+    }

+    *puVar12 = *puVar12;

+  }

+  local_100 = 0;

+  uVar13 = 0;

+  iVar9 = ObReferenceObjectByHandle(param_1,1,TmTransactionObjectType,cVar3,&local_100,0);

+  lVar8 = local_100;

+  if (-1 < iVar9) {

+    lVar15 = local_100;

+    if (param_2 != 5) {

+      TmpAcquireTransactionMutex(local_100);

+    }

+    local_res10 = (uint)(param_2 != 5);

+    if (param_2 == 0) {

+      local_c0 = *(undefined8 **)(lVar8 + 0xb0);

+      uStack_b8 = *(undefined8 *)(lVar8 + 0xb8);

+      uVar16 = *(uint *)(lVar8 + 0x1f8);

+      *(undefined8 **)param_3 = local_c0;

+      *(undefined8 *)(param_3 + 2) = uStack_b8;

+      param_3[4] = 1;

+      param_3[5] = uVar16;

+      uVar14 = 0x18;

+    }

+    else if (param_2 == 1) {

+      if (0x1f < param_4) {

+        local_f8 = *(undefined8 *)(lVar8 + 0x120);

+        uStack_f0 = *(undefined8 *)(lVar8 + 0x128);

+        local_e8 = (ulonglong)

+                   CONCAT24(*(undefined2 *)(lVar8 + 0x130),*(undefined4 *)(lVar8 + 0x1f8));

+        uStack_e0 = uStack_e0 & 0xffffffffffff0000;

+        *(undefined8 *)param_3 = local_f8;

+        *(undefined8 *)(param_3 + 2) = uStack_f0;

+        *(ulonglong *)(param_3 + 4) = local_e8;

+        *(ulonglong *)(param_3 + 6) = uStack_e0;

+        uVar16 = *(ushort *)(lVar8 + 0x130) + 0x18;

+        uVar14 = uVar16;

+        if (uVar16 < 0x20) {

+          uVar14 = 0x20;

+        }

+        uVar10 = param_4 - 0x18;

+        if (uVar16 <= param_4) {

+          uVar10 = (uint)*(ushort *)(lVar8 + 0x130);

+        }

+        memmove(param_3 + 6,*(void **)(lVar8 + 0x138),(ulonglong)uVar10);

+      }

+    }

+    else if (param_2 == 2) {

+      if (0x23 < param_4) {

+        uStack_68 = 0;

+        uVar14 = *(uint *)(lVar8 + 0xd8) - 1;

+        if (*(longlong *)(lVar8 + 0xf0) == 0) {

+          uVar14 = *(uint *)(lVar8 + 0xd8);

+        }

+        local_70 = (ulonglong)uVar14;

+        *param_3 = uVar14;

+        param_3[1] = 0;

+        param_3[2] = 0;

+        param_3[3] = 0;

+        param_3[4] = 0;

+        param_3[5] = 0;

+        param_3[6] = 0;

+        param_3[7] = 0;

+        param_3[8] = 0;

+        if (uVar14 == 0) {

+          uVar14 = 0x24;

+        }

+        else {

+          uVar14 = uVar14 * 0x20 + 4;

+        }

+        local_c8 = param_3 + 1;

+        local_d8 = *(undefined8 **)(lVar8 + 200);

+        puVar2 = local_d8;

+        puVar12 = local_c8;

+        while (puVar11 = puVar2, puVar11 != (undefined8 *)(lVar8 + 200)) {

+          puVar17 = puVar11 + -0xf;

+          local_d8 = (undefined8 *)*puVar11;

+          puVar2 = local_d8;

+          local_c0 = local_d8;

+          if (puVar17 != *(undefined8 **)(lVar8 + 0xf0)) {

+            local_d0 = (ulonglong)uVar16 * 0x20;

+            if ((ulonglong)param_4 <

+                (ulonglong)((longlong)puVar12 + (local_d0 - (longlong)param_3) + 0x20)) break;

+            KeWaitForSingleObject(puVar11 + -7,0,0,0,0,uVar13,uVar14,lVar15);

+            uVar4 = puVar17[6];

+            uVar5 = puVar17[7];

+            uVar6 = *(undefined8 *)(puVar17[0x13] + 0x88);

+            uVar7 = *(undefined8 *)(puVar17[0x13] + 0x90);

+            local_90 = uVar4;

+            uStack_88 = uVar5;

+            local_80 = uVar6;

+            uStack_78 = uVar7;

+            KeReleaseMutex(puVar11 + -7,0);

+            uVar16 = uVar16 + 1;

+            *(undefined8 *)(local_d0 + (longlong)local_c8) = uVar4;

+            ((undefined8 *)(local_d0 + (longlong)local_c8))[1] = uVar5;

+            puVar2 = (undefined8 *)(local_d0 + 0x10 + (longlong)local_c8);

+            *puVar2 = uVar6;

+            puVar2[1] = uVar7;

+            puVar2 = local_c0;

+            puVar12 = local_c8;

+          }

+        }

+      }

+    }

+    else if (param_2 == 3) {

+      if (*(longlong *)(lVar8 + 0xf0) != 0) {

+        KeWaitForSingleObject(*(longlong *)(lVar8 + 0xf0) + 0x40,0,0,0,0,uVar13,uVar14,lVar15);

+        lVar15 = *(longlong *)(lVar8 + 0xf0);

+        uVar13 = *(undefined8 *)(lVar15 + 0x30);

+        uVar4 = *(undefined8 *)(lVar15 + 0x38);

+        uVar5 = *(undefined8 *)(*(longlong *)(lVar15 + 0x98) + 0x88);

+        uVar6 = *(undefined8 *)(*(longlong *)(lVar15 + 0x98) + 0x90);

+        local_b0 = uVar13;

+        uStack_a8 = uVar4;

+        local_a0 = uVar5;

+        uStack_98 = uVar6;

+        KeReleaseMutex(lVar15 + 0x40,0);

+        *(undefined8 *)param_3 = uVar13;

+        *(undefined8 *)(param_3 + 2) = uVar4;

+        *(undefined8 *)(param_3 + 4) = uVar5;

+        *(undefined8 *)(param_3 + 6) = uVar6;

+        uVar14 = 0x20;

+      }

+    }

+    else if (param_2 == 5) {

+      lVar1 = lVar8 + 0x278;

+      KeWaitForSingleObject(lVar1,0,0,0,0,uVar13,uVar14,lVar15,uVar16,0,lVar1);

+      if (*(uint *)(lVar8 + 0x270) <= param_4) {

+        memmove(param_3,*(void **)(lVar8 + 0x268),(ulonglong)*(uint *)(lVar8 + 0x270));

+      }

+      uVar14 = *(uint *)(lVar8 + 0x270);

+      KeReleaseMutex(lVar1,0);

+    }

+    if (local_res10 != 0) {

+      KeReleaseMutex(*(longlong *)(lVar8 + 0x58) + 0x20,0);

+    }

+    ObfDereferenceObject(lVar8);

+    if (param_5 != (uint *)0x0) {

+      *param_5 = uVar14;

+    }

+  }

+  return unaff_RDI;

 }
```

## `TmpGetNotificationResourceManagerAsync`  (modified)

```diff
--- TmpGetNotificationResourceManagerAsync
+++ TmpGetNotificationResourceManagerAsync
@@ -1,12 +1,99 @@
-

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

 

 int TmpGetNotificationResourceManagerAsync

               (longlong param_1,undefined1 param_2,longlong param_3,void *param_4,uint param_5,

               uint *param_6)

 

 {

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

-  halt_baddata();

+  longlong lVar1;

+  byte bVar2;

+  longlong lVar3;

+  code *pcVar4;

+  int iVar5;

+  longlong lVar6;

+  longlong lVar7;

+  longlong *plVar8;

+  ulonglong uVar9;

+  undefined8 uVar10;

+  undefined1 *puVar11;

+  longlong *plVar12;

+  undefined8 local_res8;

+  undefined1 auStackY_58 [8];

+  undefined1 auStackY_50 [24];

+  

+  puVar11 = auStackY_58;

+  lVar7 = param_1 + 0x28;

+  KeWaitForSingleObject(lVar7,0,0,0);

+  lVar1 = param_1 + 0xd8;

+  KeWaitForSingleObject(lVar1,0,0,0);

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

+     (lVar6 = PsGetCurrentProcess(), lVar6 == *(longlong *)(param_1 + 0x248))) {

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

+    ObfReferenceObject(lVar6);

+    lVar3 = *(longlong *)(param_1 + 0x240);

+    uVar10 = 0;

+    KeReleaseMutex(lVar7,0);

+    iVar5 = KeReadStateQueue(param_1 + 0x98);

+    if (iVar5 == 0) {

+      plVar8 = (longlong *)ExAllocatePoolWithQuotaTag(0x208,0xb8,0x524e6d54);

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

+        plVar8[0x14] = param_3;

+        bVar2 = *(byte *)((longlong)SystemReserved1[0xf] + 0x24a);

+        plVar8[0x16] = 0;

+        *(uint *)(plVar8 + 0x13) = (uint)bVar2;

+        *(uint *)(plVar8 + 3) = param_5;

+        plVar8[2] = (longlong)param_4;

+        plVar8[0x15] = lVar3;

+        uVar9 = Feature_4165365051__private_IsEnabledDeviceUsageNoInline();

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

+          *(undefined4 *)(plVar8 + 4) = 0;

+        }

+        ObfReferenceObject(SystemReserved1[0xf]);

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

+        plVar8[6] = (longlong)SystemReserved1[0xf];

+        plVar8[7] = lVar6;

+        lVar7 = *plVar12;

+        if (*(longlong **)(lVar7 + 8) != plVar12) {

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

+          lVar7 = (*pcVar4)(3);

+          puVar11 = auStackY_50;

+        }

+        *plVar8 = lVar7;

+        plVar8[1] = (longlong)plVar12;

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

+        *plVar12 = (longlong)plVar8;

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

+        KeReleaseMutex(lVar1,0);

+        return 0x103;

+      }

+      iVar5 = -0x3fffff66;

+    }

+    else {

+      local_res8 = 0;

+      uVar10 = CONCAT71((int7)((ulonglong)uVar10 >> 8),param_2);

+      lVar7 = KeRemoveQueue(param_1 + 0x98,uVar10,&local_res8);

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

+        KeResetEvent(param_1);

+      }

+      if (((lVar7 == 0x102) || (lVar7 == 0xc0)) || (lVar7 == 0x80)) {

+        iVar5 = (int)lVar7;

+      }

+      else {

+        iVar5 = TmpCaptureOrRequeueNotification(param_1,uVar10,lVar7,param_4,param_5,param_6);

+        if (-1 < iVar5) {

+          if (*(longlong *)(lVar7 + 0x10) != 0) {

+            ObfDereferenceObject();

+            *(undefined8 *)(lVar7 + 0x10) = 0;

+          }

+          ExFreePoolWithTag(lVar7,0);

+        }

+      }

+    }

+    KeReleaseMutex(lVar1,0);

+    ObfDereferenceObject(lVar6);

+    return iVar5;

+  }

+  KeReleaseMutex(lVar1,0);

+  KeReleaseMutex(lVar7,0);

+  return -0x3ffffe7c;

 }
```

## `TmpInsertTransactionLsnList`  (modified)

```diff
--- TmpInsertTransactionLsnList
+++ TmpInsertTransactionLsnList
@@ -1,500 +1,70 @@
 

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

-

-int TmpInsertTransactionLsnList(longlong param_1,longlong *param_2)

+void TmpInsertTransactionLsnList(longlong param_1,longlong *param_2)

 

 {

-  ulonglong uVar1;

-  ushort uVar2;

-  undefined8 uVar3;

-  longlong lVar4;

-  int iVar5;

-  undefined4 uVar6;

-  int *in_RAX;

-  ulonglong uVar7;

-  longlong lVar8;

-  undefined8 *puVar9;

-  uint uVar10;

-  uint uVar11;

-  uint uVar12;

-  uint unaff_EBX;

-  longlong unaff_RSI;

-  longlong unaff_RDI;

-  ulonglong in_R8;

-  longlong *plVar13;

-  char cVar14;

-  int in_R10D;

-  int iVar15;

-  ulonglong uVar16;

-  longlong *plVar17;

-  undefined8 *puVar18;

-  longlong unaff_R15;

-  undefined8 *in_stack_00000030;

-  char in_stack_00000054;

-  int iStack0000000000000058;

-  int iStack000000000000005c;

-  uint uStack0000000000000060;

-  uint uStack0000000000000064;

-  uint in_stack_00000068;

-  uint uStack000000000000006c;

-  uint uStack0000000000000074;

-  uint uStack0000000000000078;

-  uint uStack0000000000000080;

-  int in_stack_00000088;

-  longlong *in_stack_00000090;

-  int in_stack_000000b8;

-  uint uStack00000000000000bc;

-  longlong *in_stack_000000c0;

-  longlong in_stack_000000d0;

-  undefined8 *in_stack_000000d8;

-  int in_stack_000000e0;

-  undefined8 *in_stack_000000e8;

-  ulonglong in_stack_000000f0;

-  ulonglong in_stack_000000f8;

-  longlong in_stack_00000100;

-  undefined8 *in_stack_00000108;

-  undefined8 *in_stack_00000110;

-  ulonglong in_stack_00000118;

-  uint in_stack_00000120;

-  ulonglong in_stack_00000128;

-  undefined4 in_stack_00000140;

-  undefined8 in_stack_00000148;

-  undefined8 in_stack_00000150;

-  uint in_stack_00000160;

-  undefined4 uStack0000000000000164;

-  undefined4 uStack0000000000000168;

-  uint in_stack_0000016c;

-  undefined4 in_stack_00000170;

-  undefined4 in_stack_00000174;

-  int iStack0000000000000178;

-  undefined4 uStack000000000000017c;

-  int in_stack_00000180;

+  longlong lVar1;

+  longlong *plVar2;

+  code *pcVar3;

+  char cVar4;

+  ulonglong uVar5;

+  longlong lVar6;

+  undefined1 *puVar7;

+  undefined1 *puVar8;

+  longlong *plVar9;

+  undefined1 auStack_38 [8];

+  undefined1 auStack_30 [24];

+  undefined8 local_18;

   

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

-  *(char *)(param_1 + 0x3b) = *(char *)(param_1 + 0x3b) + (char)param_1;

-  if (((-1 < (int)param_2) &&

-      (uVar16 = unaff_RSI * 0x70, in_stack_00000128 = uVar16, uVar16 < in_R8 || uVar16 - in_R8 == 0)

-      ) && (uVar1 = unaff_RSI * 8, in_stack_000000f8 = uVar1, uVar1 < in_R8 || uVar1 - in_R8 == 0))

-  {

-    in_stack_000000f0 = unaff_RSI * 2;

-    if (((in_R8 < in_stack_000000f0) ||

-        (uVar10 = (uint)in_stack_000000f0 + 1, uVar10 < (uint)in_stack_000000f0)) ||

-       (uVar7 = (ulonglong)uVar10 << 4, iVar5 = in_R10D, in_R8 < uVar7)) {

-      uVar7 = in_R8 & 0xffffffff;

-      iVar5 = -0x3fffff6b;

+  puVar7 = auStack_38;

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

+  local_18 = 0;

+  KeWaitForSingleObject(lVar1 + 0x200,0,0,0);

+  uVar5 = Feature_1546284347__private_IsEnabledDeviceUsageNoInline();

+  if (((int)uVar5 != 0) && (puVar8 = auStack_38, (*(uint *)(param_1 + 0xc4) >> 0x1c & 1) != 0))

+  goto LAB_0;

+  if ((*(uint *)(param_1 + 0xc4) >> 0x17 & 1) == 0) {

+LAB_1:

+    plVar9 = (longlong *)(lVar1 + 0x238);

+    *(longlong *)(param_1 + 0xf8) = *param_2;

+    param_2 = plVar9;

+    if ((longlong *)*plVar9 != plVar9) {

+      param_2 = *(longlong **)(lVar1 + 0x240);

+      do {

+        cVar4 = ClfsLsnGreater(param_2 + -0x1e,(longlong *)(param_1 + 0xf8));

+        if (cVar4 == '\0') break;

+        param_2 = (longlong *)param_2[1];

+      } while (param_2 != plVar9);

     }

-    if (-1 < iVar5) {

-      uVar10 = (uint)unaff_RSI;

-      if (uVar10 < 4) {

-        in_stack_00000054 = '\x01';

-        in_stack_00000090 = (longlong *)ExAllocateFromPagedLookasideList(&TmpLogWriteLookasideList);

-      }

-      else {

-        in_stack_00000054 = (char)in_R10D;

-        uVar11 = unaff_EBX + (int)uVar16;

-        if (((uVar11 < unaff_EBX) || (uVar12 = (int)uVar1 + uVar11, uVar12 < uVar11)) ||

-           (uVar11 = uVar12 + (int)uVar7, uVar11 < uVar12)) goto LAB_0;

-        in_stack_00000120 = uVar11;

-        in_stack_00000090 = (longlong *)ExAllocatePoolWithTag(1,uVar11,0x6f4c6d54);

-      }

-      in_R10D = 0;

-      uVar11 = in_stack_00000068;

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

-        iVar5 = -0x3fffff66;

-        goto LAB_1;

-      }

-      uVar7 = (ulonglong)unaff_EBX;

-      in_stack_000000f0 = uVar7 + (longlong)in_stack_00000090;

-      lVar8 = uVar7 + (uVar16 & 0xffffffff) + (longlong)in_stack_00000090;

-      in_stack_000000c0 =

-           (longlong *)

-           ((uVar1 & 0xffffffff) + uVar7 + (uVar16 & 0xffffffff) + (longlong)in_stack_00000090);

-      in_stack_00000148 = *(undefined8 *)(unaff_RDI + 0xb0);

-      in_stack_00000150 = *(undefined8 *)(unaff_RDI + 0xb8);

-      _uStack0000000000000164 = CONCAT44(uStack0000000000000168,0x48);

-      in_stack_00000140 = 0x104;

-      in_stack_00000170 = *(undefined4 *)(unaff_RDI + 0xc4);

-      _iStack0000000000000178 =

-           CONCAT44(uStack000000000000017c,(uint)*(ushort *)(unaff_RDI + 0x130));

-      in_stack_00000174 = 0x10000001;

-      in_stack_00000180 = 0;

-      *in_stack_00000090 = (longlong)&stack0x00000140;

-      *(undefined4 *)(in_stack_00000090 + 1) = 0x48;

-      uStack0000000000000080 = 1;

-      in_stack_00000100 = lVar8;

-      in_stack_00000118 = in_stack_000000f0;

-      in_stack_00000160 = uVar10;

-      if (in_stack_000000b8 == 4) {

-        plVar13 = in_stack_00000090;

-        if ((*(uint *)(unaff_RDI + 0xc4) >> 0x18 & 1) != 0) {

-          in_stack_000000d0 = -*(longlong *)(unaff_RDI + 0x208);

-          in_stack_00000030 = &stack0x000000d0;

-          plVar13 = (longlong *)0x0;

-          iVar5 = ClfsReserveAndAppendLog(*(undefined8 *)(unaff_R15 + 0xa0),0,0,0,0);

-          in_R10D = 0;

-          if (iVar5 < 0) goto LAB_1;

-          LOCK();

-          *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfeffffff;

-          UNLOCK();

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

-        }

-        _uStack0000000000000164 = 0;

-        in_stack_0000016c = 0;

-        _iStack0000000000000178 = 0;

-        uStack00000000000000bc = 1;

-        uStack0000000000000078 = *(uint *)(unaff_RDI + 0xc4) >> 0x19 & 1;

-        iStack0000000000000058 = 0;

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

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

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

-          WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),10,plVar13,unaff_R15);

-        }

-      }

-      else {

-        uVar12 = uVar10 * 0x78 + 0x48;

-        iVar5 = ObGetObjectSecurity();

-        in_R10D = 0;

-        if (iVar5 < 0) goto LAB_1;

-        if (*in_stack_000000c0 == 0) {

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

-        }

-        else {

-          uVar6 = RtlLengthSecurityDescriptor();

-          *(undefined4 *)(in_stack_000000c0 + 1) = uVar6;

-        }

-        in_R10D = 0;

-        in_stack_00000068 = 1;

-        _uStack0000000000000164 = CONCAT44((int)in_stack_000000c0[1],uStack0000000000000164);

-        lVar4 = in_stack_000000c0[1];

-        uVar11 = (int)lVar4 + 7U & 0xfffffff8;

-        uStack0000000000000064 = uVar11 + uVar12;

-        in_stack_0000016c = uVar12;

-        if (uStack0000000000000064 < uVar12) goto LAB_0;

-        in_stack_00000090[(ulonglong)(uVar10 + 2) * 2] = *in_stack_000000c0;

-        *(int *)(in_stack_00000090 + (ulonglong)(uVar10 + 2) * 2 + 1) = (int)lVar4;

-        iStack000000000000005c = uVar11 + 0x48;

-        uStack0000000000000060 = uVar10 + 3;

-        uVar16 = 1;

-        uStack000000000000006c = 1;

-        if (iStack0000000000000178 == 0) {

-          _iStack0000000000000178 = _iStack0000000000000178 & 0xffffffff;

-        }

-        else {

-          _iStack0000000000000178 = CONCAT44(uStack0000000000000064,iStack0000000000000178);

-          uVar2 = *(ushort *)(unaff_RDI + 0x130);

-          uVar11 = uVar2 + 7 & 0xfffffff8;

-          uVar12 = uVar11 + uStack0000000000000064;

-          if (uVar12 < uStack0000000000000064) {

-            in_R10D = 0;

-            goto LAB_0;

-          }

-          in_stack_00000090[(ulonglong)uStack0000000000000060 * 2] =

-               *(longlong *)(unaff_RDI + 0x138);

-          *(uint *)(in_stack_00000090 + (ulonglong)uStack0000000000000060 * 2 + 1) = (uint)uVar2;

-          iStack000000000000005c = iStack000000000000005c + uVar11;

-          uStack0000000000000060 = uVar10 + 4;

-          uStack0000000000000064 = uVar12;

-        }

-        uStack0000000000000074 = 0;

-        puVar9 = *(undefined8 **)(unaff_RDI + 200);

-        while( true ) {

-          uStack00000000000000bc = uStack0000000000000060;

-          in_R10D = 0;

-          uVar11 = in_stack_00000068;

-          in_stack_00000108 = puVar9;

-          if (puVar9 == (undefined8 *)(unaff_RDI + 200)) break;

-          in_stack_000000e8 = puVar9 + -0xf;

-          if (((*(uint *)((longlong)puVar9 + 0x34) & 4) == 0) &&

-             ((*(uint *)((longlong)puVar9 + 0x34) & 2) != 0)) {

-            if ((*(uint *)((longlong)puVar9 + 0x34) >> 8 & 1) == 0) {

-              iVar5 = -0x3fe6ff9e;

-            }

-            else {

-              plVar13 = in_stack_000000c0 + (ulonglong)uStack000000000000006c * 2;

-              iVar5 = ObGetObjectSecurity(in_stack_000000e8,plVar13,(longlong)plVar13 + 0xc);

-              in_R10D = 0;

-              if (-1 < iVar5) {

-                if (*plVar13 == 0) {

-                  *(undefined4 *)(in_stack_000000c0 + uVar16 * 2 + 1) = 0;

-                }

-                else {

-                  uVar6 = RtlLengthSecurityDescriptor(in_stack_000000c0[uVar16 * 2]);

-                  *(undefined4 *)(in_stack_000000c0 + uVar16 * 2 + 1) = uVar6;

-                }

-                plVar17 = in_stack_000000c0 + (ulonglong)(uStack000000000000006c + 1) * 2;

-                iVar5 = ObGetObjectSecurity(puVar9[4],plVar17,(longlong)plVar17 + 0xc);

-                uVar11 = in_stack_00000068 + 1;

-                in_R10D = 0;

-                if (-1 < iVar5) {

-                  uVar16 = (ulonglong)(uStack000000000000006c + 1);

-                  if (*plVar17 == 0) {

-                    *(undefined4 *)(in_stack_000000c0 + uVar16 * 2 + 1) = 0;

-                  }

-                  else {

-                    uVar6 = RtlLengthSecurityDescriptor(in_stack_000000c0[uVar16 * 2]);

-                    *(undefined4 *)(in_stack_000000c0 + uVar16 * 2 + 1) = uVar6;

-                  }

-                  uStack000000000000006c = uStack000000000000006c + 2;

-                  in_stack_00000068 = in_stack_00000068 + 2;

-                  KeWaitForSingleObject(puVar9 + -7,0,0,0,0);

-                  in_stack_000000f8 = (ulonglong)uStack0000000000000074;

-                  puVar18 = (undefined8 *)(in_stack_000000f8 * 0x70 + in_stack_00000118);

-                  uVar3 = puVar9[-8];

-                  *puVar18 = puVar9[-9];

-                  puVar18[1] = uVar3;

-                  uVar3 = *(undefined8 *)(puVar9[4] + 0x90);

-                  puVar18[2] = *(undefined8 *)(puVar9[4] + 0x88);

-                  puVar18[3] = uVar3;

-                  if ((*(uint *)((longlong)puVar9 + 0x34) & 0x20) == 0) {

-                    uVar16 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

-                    if ((int)uVar16 != 0) {

-                      puVar18[4] = 0xffffffffffffffff;

-                      puVar18[5] = 0xffffffffffffffff;

-                      puVar18[8] = 0xffffffffffffffff;

-                      puVar18[9] = 0xffffffffffffffff;

-                      puVar18[6] = 0xffffffffffffffff;

-                      puVar18[7] = 0xffffffffffffffff;

-                    }

-                  }

-                  else {

-                    uVar3 = in_stack_000000e8[0x22];

-                    puVar18[4] = in_stack_000000e8[0x21];

-                    puVar18[5] = uVar3;

-                    uVar3 = in_stack_000000e8[0x24];

-                    puVar18[8] = in_stack_000000e8[0x23];

-                    puVar18[9] = uVar3;

-                    uVar3 = in_stack_000000e8[0x26];

-                    puVar18[6] = in_stack_000000e8[0x25];

-                    puVar18[7] = uVar3;

-                  }

-                  *(undefined4 *)(puVar18 + 10) = *(undefined4 *)((longlong)puVar9 + 0x34);

-                  uVar16 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

-                  if ((int)uVar16 != 0) {

-                    *(undefined4 *)((longlong)puVar18 + 0x54) = 0xffffffff;

-                  }

-                  *(undefined4 *)(puVar18 + 0xb) = *(undefined4 *)(in_stack_000000e8 + 0x1a);

-                  *(int *)(puVar18 + 0xc) = (int)plVar13[1];

-                  *(int *)(puVar18 + 0xd) = (int)plVar17[1];

-                  *(uint *)(lVar8 + in_stack_000000f8 * 8) = (uint)*(ushort *)(puVar9[4] + 0x170);

-                  in_stack_00000090[(ulonglong)uStack0000000000000080 * 2] = (longlong)puVar18;

-                  *(undefined4 *)(in_stack_00000090 + (ulonglong)uStack0000000000000080 * 2 + 1) =

-                       0x70;

-                  iStack000000000000005c = iStack000000000000005c + 0x70;

-                  uStack0000000000000080 = uStack0000000000000080 + 1;

-                  if (*(int *)(puVar18 + 0xb) == 0) {

-                    *(undefined4 *)

-                     ((ulonglong)uStack0000000000000074 * 0x70 + 0x5c + in_stack_000000f0) = 0;

-LAB_2:

-                    *(uint *)((longlong)puVar18 + 100) = uStack0000000000000064;

-                    lVar4 = plVar13[1];

-                    uVar11 = (int)lVar4 + 7U & 0xfffffff8;

-                    uVar10 = uVar11 + uStack0000000000000064;

-                    if (uStack0000000000000064 <= uVar10) {

-                      in_stack_00000090[(ulonglong)uStack0000000000000060 * 2] = *plVar13;

-                      *(int *)(in_stack_00000090 + (ulonglong)uStack0000000000000060 * 2 + 1) =

-                           (int)lVar4;

-                      *(uint *)((longlong)puVar18 + 0x6c) = uVar10;

-                      lVar4 = plVar17[1];

-                      uVar12 = (int)lVar4 + 7U & 0xfffffff8;

-                      uStack0000000000000064 = uVar12 + uVar10;

-                      if (uVar10 <= uStack0000000000000064) {

-                        in_stack_00000090[(ulonglong)(uStack0000000000000060 + 1) * 2] = *plVar17;

-                        *(int *)(in_stack_00000090 + (ulonglong)(uStack0000000000000060 + 1) * 2 + 1

-                                ) = (int)lVar4;

-                        iStack000000000000005c = iStack000000000000005c + uVar11 + uVar12;

-                        uVar10 = uStack0000000000000060 + 2;

-                        if (*(int *)(lVar8 + in_stack_000000f8 * 8) == 0) {

-                          *(undefined4 *)

-                           (in_stack_00000100 + 4 + (ulonglong)uStack0000000000000074 * 8) = 0;

-                        }

-                        else {

-                          *(uint *)(in_stack_00000100 + 4 + (ulonglong)uStack0000000000000074 * 8) =

-                               uStack0000000000000064;

-                          uVar2 = *(ushort *)(puVar9[4] + 0x170);

-                          uVar11 = uVar2 + 7 & 0xfffffff8;

-                          uVar12 = uVar11 + uStack0000000000000064;

-                          if (uVar12 < uStack0000000000000064) goto LAB_3;

-                          in_stack_00000090[(ulonglong)uVar10 * 2] =

-                               *(longlong *)(puVar9[4] + 0x178);

-                          *(uint *)(in_stack_00000090 + (ulonglong)uVar10 * 2 + 1) = (uint)uVar2;

-                          iStack000000000000005c = iStack000000000000005c + uVar11;

-                          uVar10 = uStack0000000000000060 + 3;

-                          uStack0000000000000064 = uVar12;

-                        }

-                        KeReleaseMutex(puVar9 + -7,0);

-                        uStack0000000000000074 = uStack0000000000000074 + 1;

-                        uStack0000000000000060 = uVar10;

-                        goto LAB_4;

-                      }

-                    }

-                  }

-                  else {

-                    *(uint *)((ulonglong)uStack0000000000000074 * 0x70 + 0x5c + in_stack_000000f0) =

-                         uStack0000000000000064;

-                    iVar5 = *(int *)(in_stack_000000e8 + 0x1a);

-                    uVar11 = iVar5 + 7U & 0xfffffff8;

-                    uVar10 = uVar11 + uStack0000000000000064;

-                    if (uStack0000000000000064 <= uVar10) {

-                      in_stack_00000090[(ulonglong)uStack0000000000000060 * 2] =

-                           in_stack_000000e8[0x19];

-                      *(int *)(in_stack_00000090 + (ulonglong)uStack0000000000000060 * 2 + 1) =

-                           iVar5;

-                      iStack000000000000005c = iStack000000000000005c + uVar11;

-                      uStack0000000000000060 = uStack0000000000000060 + 1;

-                      uStack0000000000000064 = uVar10;

-                      goto LAB_2;

-                    }

-                  }

-LAB_3:

-                  iVar5 = -0x3fffff6b;

-                  KeReleaseMutex(puVar9 + -7,0);

-                  uVar11 = in_stack_00000068;

-                  in_R10D = 0;

-                }

-              }

-            }

-            goto LAB_1;

-          }

-LAB_4:

-          puVar9 = (undefined8 *)*in_stack_00000108;

-          uVar16 = (ulonglong)uStack000000000000006c;

-        }

-        uVar16 = (ulonglong)uStack0000000000000080;

-        in_stack_00000090[uVar16 * 2] = lVar8;

-        *(uint *)(in_stack_00000090 + uVar16 * 2 + 1) = uStack0000000000000074 * 8;

-        uVar10 = iStack000000000000005c + uStack0000000000000074 * 8;

-        puVar9 = (undefined8 *)(ulonglong)uVar10;

-        in_stack_00000180 = (int)in_stack_00000128 + 0x48;

-        if (in_stack_000000b8 == 3) {

-          if ((*(uint *)(unaff_RDI + 0xc4) >> 0x18 & 1) == 0) {

-            uStack0000000000000078 = 0;

-            iStack0000000000000058 = 0;

-            in_stack_00000088 = iStack0000000000000058;

-            if ((*(uint *)(unaff_RDI + 0xc4) >> 0x19 & 1) == 0) {

-              iStack0000000000000058 = 1;

-              in_stack_000000d0 = 0x48;

-              in_stack_00000088 = iStack0000000000000058;

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

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

-                in_stack_00000030 = (undefined8 *)0x48;

-                WPP_SF_qq_guid_i(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar16 * 2,0x48,

-                                 unaff_R15,unaff_RDI,unaff_RDI + 0xb0);

-              }

-            }

-          }

-          else {

-            puVar18 = (undefined8 *)(ulonglong)uVar10;

-            puVar9 = *(undefined8 **)(unaff_RDI + 0x208);

-            if (puVar9 != puVar18) {

-              in_stack_000000d0 = -(longlong)puVar9;

-              in_stack_000000d8 = puVar18;

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

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

-                WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xb,puVar9,unaff_R15,

-                                  unaff_RDI,unaff_RDI + 0xb0);

-              }

-              in_stack_00000030 = &stack0x000000d0;

-              puVar9 = (undefined8 *)0x0;

-              iVar5 = ClfsReserveAndAppendLog(*(undefined8 *)(unaff_R15 + 0xa0),0,0,0,0);

-              in_R10D = 0;

-              if (iVar5 < 0) goto LAB_1;

-              *(undefined8 **)(unaff_RDI + 0x208) = puVar18;

-            }

-            uStack0000000000000078 = 1;

-            iStack0000000000000058 = 0;

-            in_stack_00000088 = iStack0000000000000058;

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

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

-              WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xc,puVar9,unaff_R15);

-            }

-          }

-        }

-        else {

-          uStack0000000000000078 = 0;

-          iStack0000000000000058 = 2;

-          in_stack_000000d0 = 0x48;

-          in_stack_000000d8 = puVar9;

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

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

-            WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xe,0x48,unaff_R15,

-                              unaff_RDI,unaff_RDI + 0xb0);

-            in_stack_00000030 = puVar9;

-          }

-          in_stack_00000088 = 1;

-          in_stack_00000110 = puVar9;

-        }

-      }

-      puVar9 = &stack0x000000d0;

-      if (iStack0000000000000058 == 0) {

-        puVar9 = (undefined8 *)0x0;

-      }

-      iVar5 = TmpWriteLog(unaff_RDI,in_stack_00000090,uStack00000000000000bc,

-                          (undefined8 *)&stack0x00000158,in_stack_000000e0,uStack0000000000000078,

-                          in_stack_00000030,iStack0000000000000058,(ulonglong)puVar9,

-                          (longlong *)&stack0x00000130);

-      iVar15 = 0;

-      uVar11 = in_stack_00000068;

-      in_R10D = 0;

-      if (-1 < iVar5) {

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

-          *(undefined8 **)(unaff_RDI + 0x208) = in_stack_00000110;

-          LOCK();

-          *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) | 0x1000000;

-          UNLOCK();

-        }

-        if (in_stack_00000088 != 0) {

-          LOCK();

-          *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) | 0x2000000;

-          UNLOCK();

-        }

-        if (uStack0000000000000078 != 0) {

-          in_R10D = iVar15;

-          if (in_stack_000000b8 == 3) {

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

-            LOCK();

-            *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfeffffff;

-            UNLOCK();

-          }

-          else if (in_stack_000000b8 == 4) {

-            LOCK();

-            *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfdffffff;

-            UNLOCK();

-          }

-        }

-      }

+    lVar6 = *param_2;

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

+    if (*(longlong **)(lVar6 + 8) != param_2) goto LAB_2;

+  }

+  else {

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

+    lVar6 = *plVar9;

+    if ((*(longlong **)(lVar6 + 8) == plVar9) &&

+       (plVar2 = *(longlong **)(param_1 + 0x1f0), (longlong *)*plVar2 == plVar9)) {

+      *plVar2 = lVar6;

+      *(longlong **)(lVar6 + 8) = plVar2;

       goto LAB_1;

     }

+LAB_2:

+    lVar6 = 3;

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

+    plVar9 = (longlong *)(*pcVar3)();

+    puVar7 = auStack_30;

   }

+  *plVar9 = lVar6;

+  plVar9[1] = (longlong)param_2;

+  *(longlong **)(lVar6 + 8) = plVar9;

+  *param_2 = (longlong)plVar9;

+  LOCK();

+  *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) | 0x800000;

+  UNLOCK();

+  puVar8 = puVar7;

 LAB_0:

-  iVar5 = -0x3fffff6b;

-  uVar11 = in_stack_00000068;

-LAB_1:

-  in_stack_00000068 = uVar11;

-  cVar14 = (char)in_R10D;

-  if (in_stack_00000068 != 0) {

-    uVar16 = (ulonglong)in_stack_00000068;

-    do {

-      if (*in_stack_000000c0 != 0) {

-        ObReleaseObjectSecurity

-                  (*in_stack_000000c0,*(undefined1 *)((longlong)in_stack_000000c0 + 0xc));

-        in_R10D = 0;

-      }

-      cVar14 = (char)in_R10D;

-      in_stack_000000c0 = in_stack_000000c0 + 2;

-      uVar16 = uVar16 - 1;

-    } while (uVar16 != 0);

-  }

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

-    if (in_stack_00000054 == cVar14) {

-      ExFreePoolWithTag(in_stack_00000090,0);

-    }

-    else {

-      ExFreeToPagedLookasideList(&TmpLogWriteLookasideList,in_stack_00000090);

-    }

-  }

-  if (iVar5 == -0x3fffffdd) {

-    iVar5 = -0x3fe6ffa8;

-  }

-  return iVar5;

+  *(undefined8 *)(puVar8 + -8) = 0x14001d989;

+  KeReleaseMutex(lVar1 + 0x200,0);

+  return;

 }
```

## `TmpLogTransaction`  (modified)

```diff
--- TmpLogTransaction
+++ TmpLogTransaction
@@ -1,453 +1,493 @@
 

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

 

 int TmpLogTransaction(longlong param_1,int param_2,int param_3)

 

 {

   ushort uVar1;

-  code *pcVar2;

-  undefined8 uVar3;

-  longlong *plVar4;

-  char cVar5;

-  int iVar6;

-  undefined4 uVar7;

-  ulonglong in_RAX;

-  char *pcVar8;

-  int *piVar9;

+  int iVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  bool bVar5;

+  longlong lVar6;

+  int iVar7;

+  undefined4 uVar8;

+  ulonglong uVar9;

   undefined8 *puVar10;

-  ulonglong uVar11;

-  char cVar12;

+  uint uVar11;

+  uint uVar12;

+  longlong *plVar13;

   uint uVar14;

-  undefined4 in_register_00000014;

-  longlong lVar15;

-  uint uVar16;

-  longlong unaff_RBX;

-  int unaff_ESI;

+  ulonglong uVar15;

+  ulonglong uVar16;

   ulonglong uVar17;

-  longlong unaff_RDI;

-  longlong *plVar18;

-  undefined4 in_register_00000084;

-  uint in_R10D;

-  uint uVar19;

-  uint unaff_R12D;

-  longlong *plVar20;

-  uint uVar21;

-  undefined8 *puVar22;

-  int unaff_R14D;

-  longlong unaff_R15;

-  char in_stack_0000005c;

-  int iStack0000000000000060;

-  uint uStack0000000000000064;

-  uint uStack0000000000000068;

-  uint uStack000000000000006c;

-  uint in_stack_00000070;

-  uint uStack0000000000000074;

-  uint uStack000000000000007c;

-  uint uStack0000000000000080;

-  uint uStack0000000000000088;

-  int in_stack_00000090;

-  longlong in_stack_00000098;

-  longlong *plStack00000000000000a0;

-  longlong in_stack_000000b0;

-  int in_stack_000000c0;

-  longlong *plStack00000000000000c8;

-  longlong *plStack00000000000000d0;

-  longlong in_stack_000000f8;

-  longlong *plStack0000000000000108;

-  ulonglong in_stack_00000118;

-  longlong in_stack_00000120;

-  int in_stack_00000130;

-  undefined4 uStack0000000000000148;

-  undefined8 uStack0000000000000150;

-  undefined8 uStack0000000000000158;

-  undefined4 uStack000000000000016c;

-  undefined4 uStack0000000000000170;

-  uint in_stack_00000174;

-  undefined4 uStack0000000000000178;

-  undefined4 uStack000000000000017c;

-  int iStack0000000000000180;

-  undefined4 uStack0000000000000184;

-  uint uStack0000000000000188;

-  longlong lVar13;

+  ulonglong uVar18;

+  ulonglong uVar19;

+  undefined8 *puVar20;

+  longlong *plVar21;

+  undefined1 auStackY_1c8 [32];

+  longlong *in_stack_fffffffffffffe68;

+  int local_170;

+  int local_16c;

+  uint local_168;

+  uint local_164;

+  uint local_160;

+  uint local_15c;

+  uint local_154;

+  uint local_150;

+  uint local_148;

+  longlong *local_138;

+  uint local_10c;

+  longlong *local_108;

+  longlong local_f8;

+  longlong *local_f0;

+  int local_e8;

+  undefined8 *local_e0;

+  ulonglong local_d8;

+  ulonglong local_d0;

+  ulonglong local_c8;

+  undefined8 *local_c0;

+  longlong *local_b8;

+  ulonglong local_b0;

+  uint local_a8;

+  ulonglong local_a0;

+  longlong local_98 [2];

+  undefined4 local_88;

+  int local_84;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  uint local_68;

+  undefined8 local_64;

+  uint local_5c;

+  undefined4 local_58;

+  undefined4 local_54;

+  undefined8 local_50;

+  int local_48;

+  ulonglong local_38;

   

-  plVar18 = (longlong *)CONCAT44(in_register_00000084,param_3);

-  lVar15 = CONCAT44(in_register_00000014,param_2);

-  pcVar8 = (char *)(unaff_RBX + -0x7c + param_1 * 4);

-  cVar12 = (char)param_1;

-  *pcVar8 = *pcVar8 + cVar12;

-  pcVar8 = (char *)(in_RAX & 0xffffffffffffff90);

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

-  pcVar8 = (char *)(param_1 * 5 + -0x7c);

-  *pcVar8 = *pcVar8 + cVar12;

-  piVar9 = (int *)(in_RAX & 0xffffffffffffff80);

-  cVar5 = (char)piVar9;

-  *(char *)piVar9 = (char)*piVar9 + cVar5;

-  *(char *)(unaff_RBX + 0x48d4ad3) = *(char *)(unaff_RBX + 0x48d4ad3) + cVar12;

-  cVar12 = cVar12 + *(char *)((longlong)piVar9 + -0x77);

-  lVar13 = CONCAT71((int7)((ulonglong)param_1 >> 8),cVar12);

-  *(char *)piVar9 = (char)*piVar9 + cVar5;

-  *(char *)((longlong)piVar9 + -0x77) = *(char *)((longlong)piVar9 + -0x77) + cVar12;

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

-  *(char *)(lVar13 + -0x75) = *(char *)(lVar13 + -0x75) + cVar5;

-  pcVar2 = (code *)swi(0x48);

-  uStack0000000000000188 = in_R10D;

-  (*pcVar2)();

-  plStack00000000000000a0 =

-       (longlong *)((ulonglong)(uint)((int)lVar15 + (int)lVar13) + (longlong)plVar18);

-  plVar20 = (longlong *)((ulonglong)unaff_R12D + lVar15 + lVar13 + (longlong)plVar18);

-  uStack0000000000000150 = *(undefined8 *)(unaff_RDI + 0xb0);

-  uStack0000000000000158 = *(undefined8 *)(unaff_RDI + 0xb8);

-  _uStack000000000000016c = CONCAT44(uStack0000000000000170,0x48);

-  uStack0000000000000148 = 0x104;

-  uStack0000000000000178 = *(undefined4 *)(unaff_RDI + 0xc4);

-  _iStack0000000000000180 = CONCAT44(uStack0000000000000184,(uint)*(ushort *)(unaff_RDI + 0x130));

-  uStack000000000000017c = 0x10000001;

-  *plVar18 = (longlong)&stack0x00000148;

-  *(undefined4 *)(plVar18 + 1) = 0x48;

-  uStack0000000000000064 = 0x48;

-  uStack0000000000000088 = 1;

-  uVar14 = in_stack_00000070;

-  plStack00000000000000c8 = plVar20;

-  plStack00000000000000d0 = plStack00000000000000a0;

-  plStack0000000000000108 = plStack00000000000000a0;

-  if (in_stack_000000c0 == 4) {

-    uVar21 = uStack0000000000000188;

-    if ((*(uint *)(unaff_RDI + 0xc4) >> 0x18 & 1) != 0) {

-      plVar18 = (longlong *)0x0;

-      iVar6 = ClfsReserveAndAppendLog(*(undefined8 *)(unaff_R15 + 0xa0),0,0,0);

-      if (iVar6 < 0) goto LAB_0;

-      LOCK();

-      *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfeffffff;

-      UNLOCK();

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

-      uVar21 = 0;

+  local_38 = __security_cookie ^ (ulonglong)auStackY_1c8;

+  local_e8 = param_3;

+  memset(&local_88,0,0x48);

+  uVar16 = 0;

+  local_108 = (longlong *)0x0;

+  local_138 = (longlong *)0x0;

+  bVar5 = false;

+  local_160 = 0;

+  local_98[0] = *(longlong *)CLFS_LSN_NULL_exref;

+  local_b8 = (longlong *)0x0;

+  iVar2 = 0;

+  lVar3 = *(longlong *)(param_1 + 0x200);

+  if ((lVar3 == 0) || ((*(uint *)(lVar3 + 0x80) & 1) != 0)) {

+    return 0;

+  }

+  if (*(int *)(lVar3 + 0x40) == 4) {

+    return -0x3fe6fffc;

+  }

+  if (((*(longlong *)(lVar3 + 0x98) == 0) || (*(longlong *)(lVar3 + 0xa0) == 0)) ||

+     (*(int *)(lVar3 + 0x40) != 3)) {

+    return -0x3fe6ffae;

+  }

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

+    return 0;

+  }

+  uVar19 = uVar16;

+  if (param_2 != 4) {

+    uVar19 = (ulonglong)*(uint *)(param_1 + 0xdc);

+  }

+  uVar18 = uVar19 * 5;

+  if ((uVar18 < 0x100000000) && (uVar11 = (uint)uVar18, uVar11 <= uVar11 + 4)) {

+    if ((uVar11 + 4 < uVar11) ||

+       (uVar17 = (ulonglong)(uVar11 + 4) << 4, uVar15 = uVar16, local_c8 = uVar17,

+       0xffffffff < uVar17)) {

+      uVar17 = 0xffffffff;

+      uVar15 = 0xc0000095;

     }

-    in_stack_00000174 = uVar21;

-    _uStack000000000000016c = 0;

-    _iStack0000000000000180 = 0;

-    uStack0000000000000080 = *(uint *)(unaff_RDI + 0xc4) >> 0x19 & 1;

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

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

-      WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),10,plVar18,unaff_R15);

-    }

-  }

-  else {

-    uVar21 = unaff_ESI * 0x78 + 0x48;

-    iVar6 = ObGetObjectSecurity();

-    if (iVar6 < 0) goto LAB_0;

-    if (*plVar20 == 0) {

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

-    }

-    else {

-      uVar7 = RtlLengthSecurityDescriptor();

-      *(undefined4 *)(plVar20 + 1) = uVar7;

-    }

-    in_stack_00000070 = 1;

-    _uStack000000000000016c = CONCAT44((int)plVar20[1],uStack000000000000016c);

-    lVar13 = plVar20[1];

-    uVar16 = (int)lVar13 + 7U & 0xfffffff8;

-    uStack000000000000006c = uVar16 + uVar21;

-    iVar6 = unaff_R14D;

-    uVar14 = in_stack_00000070;

-    in_stack_00000174 = uVar21;

-    if (uStack000000000000006c < uVar21) goto LAB_0;

-    *(longlong *)(in_stack_00000098 + (ulonglong)(unaff_ESI + 2) * 0x10) = *plVar20;

-    *(int *)(in_stack_00000098 + 8 + (ulonglong)(unaff_ESI + 2) * 0x10) = (int)lVar13;

-    uVar16 = uVar16 + 0x48;

-    uStack0000000000000068 = unaff_ESI + 3;

-    uVar17 = 1;

-    uStack0000000000000074 = 1;

-    if (iStack0000000000000180 == 0) {

-      _iStack0000000000000180 = _iStack0000000000000180 & 0xffffffff;

-    }

-    else {

-      _iStack0000000000000180 = CONCAT44(uStack000000000000006c,iStack0000000000000180);

-      uVar1 = *(ushort *)(unaff_RDI + 0x130);

-      uVar21 = uVar1 + 7 & 0xfffffff8;

-      uVar19 = uVar21 + uStack000000000000006c;

-      uStack0000000000000064 = uVar16;

-      if (uVar19 < uStack000000000000006c) goto LAB_0;

-      *(undefined8 *)(in_stack_00000098 + (ulonglong)uStack0000000000000068 * 0x10) =

-           *(undefined8 *)(unaff_RDI + 0x138);

-      *(uint *)(in_stack_00000098 + 8 + (ulonglong)uStack0000000000000068 * 0x10) = (uint)uVar1;

-      uVar16 = uVar16 + uVar21;

-      uStack0000000000000068 = unaff_ESI + 4;

-      uStack000000000000006c = uVar19;

-    }

-    uStack000000000000007c = 0;

-    uStack0000000000000064 = uVar16;

-    for (puVar10 = *(undefined8 **)(unaff_RDI + 200); uVar14 = in_stack_00000070,

-        puVar10 != (undefined8 *)(unaff_RDI + 200); puVar10 = (undefined8 *)*puVar10) {

-      if (((*(uint *)((longlong)puVar10 + 0x34) & 4) == 0) &&

-         ((*(uint *)((longlong)puVar10 + 0x34) & 2) != 0)) {

-        if ((*(uint *)((longlong)puVar10 + 0x34) >> 8 & 1) == 0) {

-          iVar6 = -0x3fe6ff9e;

+    local_b0 = uVar18;

+    if (((-1 < (int)uVar15) && (uVar18 = uVar19 * 0x70, local_a0 = uVar18, uVar18 < 0x100000000)) &&

+       (uVar15 = uVar19 * 8, local_d0 = uVar15, uVar15 < 0x100000000)) {

+      local_d8 = uVar19 * 2;

+      if (((0xffffffff < local_d8) || (uVar11 = (uint)local_d8 + 1, uVar11 < (uint)local_d8)) ||

+         (uVar9 = (ulonglong)uVar11 << 4, 0xffffffff < uVar9)) {

+        uVar9 = 0xffffffff;

+        uVar16 = 0xc0000095;

+      }

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

+        uVar11 = (uint)uVar19;

+        if (uVar11 < 4) {

+          bVar5 = true;

+          local_138 = (longlong *)ExAllocateFromPagedLookasideList(&TmpLogWriteLookasideList);

         }

         else {

-          plStack00000000000000a0 = plStack00000000000000c8 + (ulonglong)uStack0000000000000074 * 2;

-          iVar6 = ObGetObjectSecurity(puVar10 + -0xf,plStack00000000000000a0,

-                                      (longlong)plStack00000000000000a0 + 0xc);

-          if (-1 < iVar6) {

-            if (*plStack00000000000000a0 == 0) {

-              *(undefined4 *)(plVar20 + uVar17 * 2 + 1) = 0;

-            }

-            else {

-              uVar7 = RtlLengthSecurityDescriptor(plVar20[uVar17 * 2]);

-              *(undefined4 *)(plVar20 + uVar17 * 2 + 1) = uVar7;

-            }

-            plVar18 = plStack00000000000000c8 + (ulonglong)(uStack0000000000000074 + 1) * 2;

-            iVar6 = ObGetObjectSecurity(puVar10[4],plVar18,(longlong)plVar18 + 0xc);

-            uVar14 = in_stack_00000070 + 1;

-            if (-1 < iVar6) {

-              uVar17 = (ulonglong)(uStack0000000000000074 + 1);

-              if (*plVar18 == 0) {

-                *(undefined4 *)(plVar20 + uVar17 * 2 + 1) = 0;

+          bVar5 = false;

+          uVar12 = (uint)uVar17 + (int)uVar18;

+          if (((uVar12 < (uint)uVar17) || (uVar14 = (int)uVar15 + uVar12, uVar14 < uVar12)) ||

+             (uVar12 = uVar14 + (int)uVar9, uVar12 < uVar14)) goto LAB_0;

+          local_a8 = uVar12;

+          local_138 = (longlong *)ExAllocatePoolWithTag(1,uVar12,0x6f4c6d54);

+        }

+        uVar12 = local_160;

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

+          iVar7 = -0x3fffff66;

+          goto LAB_1;

+        }

+        uVar17 = uVar17 & 0xffffffff;

+        local_d8 = uVar17 + (longlong)local_138;

+        uVar16 = uVar17 + (uVar18 & 0xffffffff) + (longlong)local_138;

+        local_108 = (longlong *)

+                    ((uVar15 & 0xffffffff) + uVar17 + (uVar18 & 0xffffffff) + (longlong)local_138);

+        local_80 = *(undefined8 *)(param_1 + 0xb0);

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

+        local_64 = CONCAT44(local_64._4_4_,0x48);

+        local_88 = 0x104;

+        local_58 = *(undefined4 *)(param_1 + 0xc4);

+        local_50 = CONCAT44(local_50._4_4_,(uint)*(ushort *)(param_1 + 0x130));

+        local_54 = 0x10000001;

+        local_48 = 0;

+        *local_138 = (longlong)&local_88;

+        *(undefined4 *)(local_138 + 1) = 0x48;

+        local_148 = 1;

+        local_c8 = uVar16;

+        local_b0 = local_d8;

+        local_84 = param_2;

+        local_68 = uVar11;

+        if (param_2 == 4) {

+          plVar13 = local_138;

+          if ((*(uint *)(param_1 + 0xc4) >> 0x18 & 1) != 0) {

+            local_f8 = -*(longlong *)(param_1 + 0x208);

+            in_stack_fffffffffffffe68 = &local_f8;

+            plVar13 = (longlong *)0x0;

+            iVar7 = ClfsReserveAndAppendLog(*(undefined8 *)(lVar3 + 0xa0),0,0,0);

+            if (iVar7 < 0) goto LAB_1;

+            LOCK();

+            *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) & 0xfeffffff;

+            UNLOCK();

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

+          }

+          local_64 = 0;

+          local_5c = 0;

+          local_50 = 0;

+          local_10c = 1;

+          local_150 = *(uint *)(param_1 + 0xc4) >> 0x19 & 1;

+          local_170 = 0;

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

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

+            WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),10,plVar13,lVar3);

+          }

+        }

+        else {

+          uVar14 = uVar11 * 0x78 + 0x48;

+          iVar7 = ObGetObjectSecurity(param_1,local_108,(longlong)local_108 + 0xc);

+          if (iVar7 < 0) goto LAB_1;

+          if (*local_108 == 0) {

+            *(undefined4 *)(local_108 + 1) = 0;

+          }

+          else {

+            uVar8 = RtlLengthSecurityDescriptor();

+            *(undefined4 *)(local_108 + 1) = uVar8;

+          }

+          local_160 = 1;

+          local_64 = CONCAT44((int)local_108[1],(undefined4)local_64);

+          lVar6 = local_108[1];

+          uVar12 = (int)lVar6 + 7U & 0xfffffff8;

+          local_164 = uVar12 + uVar14;

+          local_5c = uVar14;

+          if (local_164 < uVar14) goto LAB_0;

+          local_138[(ulonglong)(uVar11 + 2) * 2] = *local_108;

+          *(int *)(local_138 + (ulonglong)(uVar11 + 2) * 2 + 1) = (int)lVar6;

+          local_16c = uVar12 + 0x48;

+          local_168 = uVar11 + 3;

+          uVar19 = 1;

+          local_15c = 1;

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

+            local_50 = local_50 & 0xffffffff;

+          }

+          else {

+            local_50 = CONCAT44(local_164,(int)local_50);

+            uVar1 = *(ushort *)(param_1 + 0x130);

+            uVar12 = uVar1 + 7 & 0xfffffff8;

+            uVar14 = uVar12 + local_164;

+            if (uVar14 < local_164) goto LAB_0;

+            local_138[(ulonglong)local_168 * 2] = *(longlong *)(param_1 + 0x138);

+            *(uint *)(local_138 + (ulonglong)local_168 * 2 + 1) = (uint)uVar1;

+            local_16c = local_16c + uVar12;

+            local_168 = uVar11 + 4;

+            local_164 = uVar14;

+          }

+          local_154 = 0;

+          puVar10 = *(undefined8 **)(param_1 + 200);

+          while (local_10c = local_168, uVar12 = local_160, local_c0 = puVar10,

+                puVar10 != (undefined8 *)(param_1 + 200)) {

+            local_e0 = puVar10 + -0xf;

+            if (((*(uint *)((longlong)puVar10 + 0x34) & 4) == 0) &&

+               ((*(uint *)((longlong)puVar10 + 0x34) & 2) != 0)) {

+              if ((*(uint *)((longlong)puVar10 + 0x34) >> 8 & 1) == 0) {

+                iVar7 = -0x3fe6ff9e;

               }

               else {

-                uVar7 = RtlLengthSecurityDescriptor(plVar20[uVar17 * 2]);

-                *(undefined4 *)(plVar20 + uVar17 * 2 + 1) = uVar7;

-              }

-              uStack0000000000000074 = uStack0000000000000074 + 2;

-              in_stack_00000070 = in_stack_00000070 + 2;

-              KeWaitForSingleObject(puVar10 + -7,0,0,0);

-              uVar17 = (ulonglong)uStack000000000000007c;

-              puVar22 = (undefined8 *)(uVar17 * 0x70 + in_stack_00000120);

-              uVar3 = puVar10[-8];

-              *puVar22 = puVar10[-9];

-              puVar22[1] = uVar3;

-              uVar3 = *(undefined8 *)(puVar10[4] + 0x90);

-              puVar22[2] = *(undefined8 *)(puVar10[4] + 0x88);

-              puVar22[3] = uVar3;

-              if ((*(uint *)((longlong)puVar10 + 0x34) & 0x20) == 0) {

-                uVar11 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

-                if ((int)uVar11 != 0) {

-                  puVar22[4] = 0xffffffffffffffff;

-                  puVar22[5] = 0xffffffffffffffff;

-                  puVar22[8] = 0xffffffffffffffff;

-                  puVar22[9] = 0xffffffffffffffff;

-                  puVar22[6] = 0xffffffffffffffff;

-                  puVar22[7] = 0xffffffffffffffff;

-                }

-              }

-              else {

-                uVar3 = puVar10[0x13];

-                puVar22[4] = puVar10[0x12];

-                puVar22[5] = uVar3;

-                uVar3 = puVar10[0x15];

-                puVar22[8] = puVar10[0x14];

-                puVar22[9] = uVar3;

-                uVar3 = puVar10[0x17];

-                puVar22[6] = puVar10[0x16];

-                puVar22[7] = uVar3;

-              }

-              *(undefined4 *)(puVar22 + 10) = *(undefined4 *)((longlong)puVar10 + 0x34);

-              uVar11 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

-              plVar4 = plStack00000000000000a0;

-              if ((int)uVar11 != 0) {

-                *(undefined4 *)((longlong)puVar22 + 0x54) = 0xffffffff;

-              }

-              *(undefined4 *)(puVar22 + 0xb) = *(undefined4 *)(puVar10 + 0xb);

-              *(int *)(puVar22 + 0xc) = (int)plStack00000000000000a0[1];

-              *(int *)(puVar22 + 0xd) = (int)plVar18[1];

-              plStack00000000000000a0 = plStack00000000000000d0;

-              *(uint *)(plStack00000000000000d0 + uVar17) = (uint)*(ushort *)(puVar10[4] + 0x170);

-              *(undefined8 **)(in_stack_000000b0 + (ulonglong)uStack0000000000000088 * 0x10) =

-                   puVar22;

-              *(undefined4 *)(in_stack_000000b0 + ((ulonglong)uStack0000000000000088 * 2 + 1) * 8) =

-                   0x70;

-              uStack0000000000000064 = uStack0000000000000064 + 0x70;

-              uStack0000000000000088 = uStack0000000000000088 + 1;

-              if (*(int *)(puVar22 + 0xb) == 0) {

-                *(undefined4 *)((ulonglong)uStack000000000000007c * 0x70 + 0x5c + in_stack_000000f8)

-                     = 0;

-LAB_1:

-                *(uint *)((longlong)puVar22 + 100) = uStack000000000000006c;

-                iVar6 = (int)plVar4[1];

-                uVar21 = iVar6 + 7U & 0xfffffff8;

-                uVar14 = uVar21 + uStack000000000000006c;

-                if (uStack000000000000006c <= uVar14) {

-                  *(longlong *)(in_stack_000000b0 + (ulonglong)uStack0000000000000068 * 0x10) =

-                       *plVar4;

-                  *(int *)(in_stack_000000b0 + ((ulonglong)uStack0000000000000068 * 2 + 1) * 8) =

-                       iVar6;

-                  uStack0000000000000064 = uStack0000000000000064 + uVar21;

-                  *(uint *)((longlong)puVar22 + 0x6c) = uVar14;

-                  lVar13 = plVar18[1];

-                  uVar16 = (int)lVar13 + 7U & 0xfffffff8;

-                  uStack000000000000006c = uVar16 + uVar14;

-                  if (uVar14 <= uStack000000000000006c) {

-                    *(longlong *)

-                     (in_stack_000000b0 + (ulonglong)(uStack0000000000000068 + 1) * 0x10) = *plVar18

-                    ;

-                    *(int *)(in_stack_000000b0 +

-                            ((ulonglong)(uStack0000000000000068 + 1) * 2 + 1) * 8) = (int)lVar13;

-                    uVar16 = uStack0000000000000064 + uVar16;

-                    uVar14 = uStack0000000000000068 + 2;

-                    if ((int)plStack00000000000000d0[uVar17] == 0) {

-                      *(undefined4 *)

-                       ((longlong)plStack0000000000000108 +

-                       (ulonglong)uStack000000000000007c * 8 + 4) = 0;

+                plVar13 = local_108 + (ulonglong)local_15c * 2;

+                iVar7 = ObGetObjectSecurity(local_e0,plVar13,(longlong)plVar13 + 0xc);

+                if (-1 < iVar7) {

+                  if (*plVar13 == 0) {

+                    *(undefined4 *)(local_108 + uVar19 * 2 + 1) = 0;

+                  }

+                  else {

+                    uVar8 = RtlLengthSecurityDescriptor(local_108[uVar19 * 2]);

+                    *(undefined4 *)(local_108 + uVar19 * 2 + 1) = uVar8;

+                  }

+                  plVar21 = local_108 + (ulonglong)(local_15c + 1) * 2;

+                  iVar7 = ObGetObjectSecurity(puVar10[4],plVar21,(longlong)plVar21 + 0xc);

+                  uVar12 = local_160 + 1;

+                  if (-1 < iVar7) {

+                    uVar19 = (ulonglong)(local_15c + 1);

+                    if (*plVar21 == 0) {

+                      *(undefined4 *)(local_108 + uVar19 * 2 + 1) = 0;

                     }

                     else {

-                      *(uint *)((longlong)plStack0000000000000108 +

-                               (ulonglong)uStack000000000000007c * 8 + 4) = uStack000000000000006c;

-                      uVar1 = *(ushort *)(puVar10[4] + 0x170);

-                      uVar21 = uVar1 + 7 & 0xfffffff8;

-                      uVar19 = uVar21 + uStack000000000000006c;

-                      uStack0000000000000064 = uVar16;

-                      if (uVar19 < uStack000000000000006c) goto LAB_2;

-                      *(undefined8 *)(in_stack_000000b0 + (ulonglong)uVar14 * 0x10) =

-                           *(undefined8 *)(puVar10[4] + 0x178);

-                      *(uint *)(in_stack_000000b0 + ((ulonglong)uVar14 * 2 + 1) * 8) = (uint)uVar1;

-                      uVar16 = uVar16 + uVar21;

-                      uVar14 = uStack0000000000000068 + 3;

-                      uStack000000000000006c = uVar19;

-                    }

-                    uStack0000000000000064 = uVar16;

+                      uVar8 = RtlLengthSecurityDescriptor(local_108[uVar19 * 2]);

+                      *(undefined4 *)(local_108 + uVar19 * 2 + 1) = uVar8;

+                    }

+                    local_15c = local_15c + 2;

+                    local_160 = local_160 + 2;

+                    KeWaitForSingleObject(puVar10 + -7,0,0,0);

+                    local_d0 = (ulonglong)local_154;

+                    puVar20 = (undefined8 *)(local_d0 * 0x70 + local_b0);

+                    uVar4 = puVar10[-8];

+                    *puVar20 = puVar10[-9];

+                    puVar20[1] = uVar4;

+                    uVar4 = *(undefined8 *)(puVar10[4] + 0x90);

+                    puVar20[2] = *(undefined8 *)(puVar10[4] + 0x88);

+                    puVar20[3] = uVar4;

+                    if ((*(uint *)((longlong)puVar10 + 0x34) & 0x20) == 0) {

+                      uVar19 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

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

+                        puVar20[4] = 0xffffffffffffffff;

+                        puVar20[5] = 0xffffffffffffffff;

+                        puVar20[8] = 0xffffffffffffffff;

+                        puVar20[9] = 0xffffffffffffffff;

+                        puVar20[6] = 0xffffffffffffffff;

+                        puVar20[7] = 0xffffffffffffffff;

+                      }

+                    }

+                    else {

+                      uVar4 = local_e0[0x22];

+                      puVar20[4] = local_e0[0x21];

+                      puVar20[5] = uVar4;

+                      uVar4 = local_e0[0x24];

+                      puVar20[8] = local_e0[0x23];

+                      puVar20[9] = uVar4;

+                      uVar4 = local_e0[0x26];

+                      puVar20[6] = local_e0[0x25];

+                      puVar20[7] = uVar4;

+                    }

+                    *(undefined4 *)(puVar20 + 10) = *(undefined4 *)((longlong)puVar10 + 0x34);

+                    uVar19 = Feature_586833209__private_IsEnabledDeviceUsageNoInline();

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

+                      *(undefined4 *)((longlong)puVar20 + 0x54) = 0xffffffff;

+                    }

+                    *(undefined4 *)(puVar20 + 0xb) = *(undefined4 *)(local_e0 + 0x1a);

+                    *(int *)(puVar20 + 0xc) = (int)plVar13[1];

+                    *(int *)(puVar20 + 0xd) = (int)plVar21[1];

+                    *(uint *)(uVar16 + local_d0 * 8) = (uint)*(ushort *)(puVar10[4] + 0x170);

+                    local_138[(ulonglong)local_148 * 2] = (longlong)puVar20;

+                    *(undefined4 *)(local_138 + (ulonglong)local_148 * 2 + 1) = 0x70;

+                    local_16c = local_16c + 0x70;

+                    local_148 = local_148 + 1;

+                    if (*(int *)(puVar20 + 0xb) == 0) {

+                      *(undefined4 *)((ulonglong)local_154 * 0x70 + 0x5c + local_d8) = 0;

+LAB_2:

+                      *(uint *)((longlong)puVar20 + 100) = local_164;

+                      lVar6 = plVar13[1];

+                      uVar12 = (int)lVar6 + 7U & 0xfffffff8;

+                      uVar11 = uVar12 + local_164;

+                      if (local_164 <= uVar11) {

+                        local_138[(ulonglong)local_168 * 2] = *plVar13;

+                        *(int *)(local_138 + (ulonglong)local_168 * 2 + 1) = (int)lVar6;

+                        *(uint *)((longlong)puVar20 + 0x6c) = uVar11;

+                        lVar6 = plVar21[1];

+                        uVar14 = (int)lVar6 + 7U & 0xfffffff8;

+                        local_164 = uVar14 + uVar11;

+                        if (uVar11 <= local_164) {

+                          local_138[(ulonglong)(local_168 + 1) * 2] = *plVar21;

+                          *(int *)(local_138 + (ulonglong)(local_168 + 1) * 2 + 1) = (int)lVar6;

+                          local_16c = local_16c + uVar12 + uVar14;

+                          uVar11 = local_168 + 2;

+                          if (*(int *)(uVar16 + local_d0 * 8) == 0) {

+                            *(undefined4 *)(local_c8 + 4 + (ulonglong)local_154 * 8) = 0;

+                          }

+                          else {

+                            *(uint *)(local_c8 + 4 + (ulonglong)local_154 * 8) = local_164;

+                            uVar1 = *(ushort *)(puVar10[4] + 0x170);

+                            uVar12 = uVar1 + 7 & 0xfffffff8;

+                            uVar14 = uVar12 + local_164;

+                            if (uVar14 < local_164) goto LAB_3;

+                            local_138[(ulonglong)uVar11 * 2] = *(longlong *)(puVar10[4] + 0x178);

+                            *(uint *)(local_138 + (ulonglong)uVar11 * 2 + 1) = (uint)uVar1;

+                            local_16c = local_16c + uVar12;

+                            uVar11 = local_168 + 3;

+                            local_164 = uVar14;

+                          }

+                          KeReleaseMutex(puVar10 + -7,0);

+                          local_154 = local_154 + 1;

+                          local_168 = uVar11;

+                          goto LAB_4;

+                        }

+                      }

+                    }

+                    else {

+                      *(uint *)((ulonglong)local_154 * 0x70 + 0x5c + local_d8) = local_164;

+                      iVar2 = *(int *)(local_e0 + 0x1a);

+                      uVar12 = iVar2 + 7U & 0xfffffff8;

+                      uVar11 = uVar12 + local_164;

+                      if (local_164 <= uVar11) {

+                        local_138[(ulonglong)local_168 * 2] = local_e0[0x19];

+                        *(int *)(local_138 + (ulonglong)local_168 * 2 + 1) = iVar2;

+                        local_16c = local_16c + uVar12;

+                        local_168 = local_168 + 1;

+                        local_164 = uVar11;

+                        goto LAB_2;

+                      }

+                    }

+LAB_3:

+                    iVar7 = -0x3fffff6b;

                     KeReleaseMutex(puVar10 + -7,0);

-                    uStack000000000000007c = uStack000000000000007c + 1;

-                    uStack0000000000000068 = uVar14;

-                    goto LAB_3;

+                    uVar12 = local_160;

                   }

                 }

               }

-              else {

-                *(uint *)((ulonglong)uStack000000000000007c * 0x70 + 0x5c + in_stack_000000f8) =

-                     uStack000000000000006c;

-                iVar6 = *(int *)(puVar10 + 0xb);

-                uVar21 = iVar6 + 7U & 0xfffffff8;

-                uVar14 = uVar21 + uStack000000000000006c;

-                if (uStack000000000000006c <= uVar14) {

-                  *(undefined8 *)(in_stack_000000b0 + (ulonglong)uStack0000000000000068 * 0x10) =

-                       puVar10[10];

-                  *(int *)(in_stack_000000b0 + ((ulonglong)uStack0000000000000068 * 2 + 1) * 8) =

-                       iVar6;

-                  uStack0000000000000064 = uStack0000000000000064 + uVar21;

-                  uStack0000000000000068 = uStack0000000000000068 + 1;

-                  uStack000000000000006c = uVar14;

-                  goto LAB_1;

+              goto LAB_1;

+            }

+LAB_4:

+            uVar19 = (ulonglong)local_15c;

+            puVar10 = (undefined8 *)*local_c0;

+          }

+          uVar19 = (ulonglong)local_148;

+          local_138[uVar19 * 2] = uVar16;

+          *(uint *)(local_138 + uVar19 * 2 + 1) = local_154 * 8;

+          uVar11 = local_16c + local_154 * 8;

+          plVar13 = (longlong *)(ulonglong)uVar11;

+          local_48 = (int)local_a0 + 0x48;

+          if (param_2 == 3) {

+            if ((*(uint *)(param_1 + 0xc4) >> 0x18 & 1) == 0) {

+              local_150 = 0;

+              local_170 = 0;

+              iVar2 = local_170;

+              if ((*(uint *)(param_1 + 0xc4) >> 0x19 & 1) == 0) {

+                local_170 = 1;

+                local_f8 = 0x48;

+                iVar2 = local_170;

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

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

+                  in_stack_fffffffffffffe68 = (longlong *)0x48;

+                  WPP_SF_qq_guid_i(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar19 * 2,0x48,lVar3,

+                                   param_1,param_1 + 0xb0);

                 }

               }

-LAB_2:

-              KeReleaseMutex(puVar10 + -7,0);

-              iVar6 = unaff_R14D;

-              uVar14 = in_stack_00000070;

-            }

-          }

-        }

-        goto LAB_0;

-      }

-      plStack00000000000000a0 = plStack00000000000000d0;

-      uVar16 = uStack0000000000000064;

-LAB_3:

-      uVar17 = (ulonglong)uStack0000000000000074;

-    }

-    uVar17 = (ulonglong)uStack0000000000000088;

-    *(longlong **)(in_stack_000000b0 + uVar17 * 0x10) = plStack00000000000000a0;

-    *(uint *)(in_stack_000000b0 + (uVar17 * 2 + 1) * 8) = uStack000000000000007c * 8;

-    uStack0000000000000064 = uVar16 + uStack000000000000007c * 8;

-    uVar11 = (ulonglong)uStack0000000000000064;

-    uStack0000000000000088 = uStack0000000000000088 + 1;

-    uStack0000000000000188 = in_stack_00000130 + 0x48;

-    if (in_stack_000000c0 == 3) {

-      if ((*(uint *)(unaff_RDI + 0xc4) >> 0x18 & 1) == 0) {

-        uStack0000000000000080 = 0;

-        iStack0000000000000060 = 0;

-        in_stack_00000090 = iStack0000000000000060;

-        if ((((*(uint *)(unaff_RDI + 0xc4) >> 0x19 & 1) == 0) &&

-            (iStack0000000000000060 = 1, in_stack_00000090 = iStack0000000000000060,

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

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

-          WPP_SF_qq_guid_i(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar17 * 2,0x48,unaff_R15,

-                           unaff_RDI,unaff_RDI + 0xb0);

-        }

-      }

-      else {

-        uVar11 = (ulonglong)uStack0000000000000064;

-        uVar17 = *(ulonglong *)(unaff_RDI + 0x208);

-        if (uVar17 != uVar11) {

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

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

-            WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xb,uVar17,unaff_R15,

-                              unaff_RDI,unaff_RDI + 0xb0);

-          }

-          uVar17 = 0;

-          iVar6 = ClfsReserveAndAppendLog(*(undefined8 *)(unaff_R15 + 0xa0),0,0,0);

-          if (iVar6 < 0) goto LAB_0;

-          *(ulonglong *)(unaff_RDI + 0x208) = uVar11;

-        }

-        uStack0000000000000080 = 1;

-        iStack0000000000000060 = 0;

-        in_stack_00000090 = iStack0000000000000060;

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

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

-          WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xc,uVar17,unaff_R15);

-        }

+            }

+            else {

+              plVar21 = (longlong *)(ulonglong)uVar11;

+              plVar13 = *(longlong **)(param_1 + 0x208);

+              if (plVar13 != plVar21) {

+                local_f8 = -(longlong)plVar13;

+                local_f0 = plVar21;

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

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

+                  WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xb,plVar13,lVar3,

+                                    param_1,param_1 + 0xb0);

+                }

+                in_stack_fffffffffffffe68 = &local_f8;

+                plVar13 = (longlong *)0x0;

+                iVar7 = ClfsReserveAndAppendLog(*(undefined8 *)(lVar3 + 0xa0),0,0,0);

+                if (iVar7 < 0) goto LAB_1;

+                *(longlong **)(param_1 + 0x208) = plVar21;

+              }

+              local_150 = 1;

+              local_170 = 0;

+              iVar2 = local_170;

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

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

+                WPP_SF_qq(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xc,plVar13,lVar3);

+              }

+            }

+          }

+          else {

+            local_150 = 0;

+            local_170 = 2;

+            local_f8 = 0x48;

+            local_f0 = plVar13;

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

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

+              in_stack_fffffffffffffe68 = plVar13;

+              WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xe,0x48,lVar3,param_1,

+                                param_1 + 0xb0);

+            }

+            local_b8 = plVar13;

+            iVar2 = 1;

+          }

+        }

+        plVar13 = &local_f8;

+        if (local_170 == 0) {

+          plVar13 = (longlong *)0x0;

+        }

+        iVar7 = TmpWriteLog(param_1,local_138,local_10c,&local_70,local_e8,local_150,

+                            in_stack_fffffffffffffe68,local_170,(ulonglong)plVar13,local_98);

+        uVar12 = local_160;

+        if (-1 < iVar7) {

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

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

+            LOCK();

+            *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) | 0x1000000;

+            UNLOCK();

+          }

+          if (iVar2 != 0) {

+            LOCK();

+            *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) | 0x2000000;

+            UNLOCK();

+          }

+          if (local_150 != 0) {

+            if (param_2 == 3) {

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

+              LOCK();

+              *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) & 0xfeffffff;

+              UNLOCK();

+            }

+            else if (param_2 == 4) {

+              LOCK();

+              *(uint *)(param_1 + 0xc4) = *(uint *)(param_1 + 0xc4) & 0xfdffffff;

+              UNLOCK();

+            }

+          }

+        }

+        goto LAB_1;

       }

     }

-    else {

-      uStack0000000000000080 = 0;

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

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

-        WPP_SF_qq_guid_ii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xe,0x48,unaff_R15,unaff_RDI,

-                          unaff_RDI + 0xb0);

+  }

+LAB_0:

+  iVar7 = -0x3fffff6b;

+  uVar12 = local_160;

+LAB_1:

+  local_160 = uVar12;

+  if (local_160 != 0) {

+    uVar16 = (ulonglong)local_160;

+    do {

+      if (*local_108 != 0) {

+        ObReleaseObjectSecurity(*local_108,*(undefined1 *)((longlong)local_108 + 0xc));

       }

-      in_stack_00000090 = 1;

-      in_stack_00000118 = uVar11;

-    }

-  }

-  iVar6 = func_0x00014001e908();

-  uVar14 = in_stack_00000070;

-  if (-1 < iVar6) {

-    if (in_stack_00000118 != 0) {

-      *(ulonglong *)(unaff_RDI + 0x208) = in_stack_00000118;

-      LOCK();

-      *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) | 0x1000000;

-      UNLOCK();

-    }

-    if (in_stack_00000090 != 0) {

-      LOCK();

-      *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) | 0x2000000;

-      UNLOCK();

-    }

-    if (uStack0000000000000080 != 0) {

-      if (in_stack_000000c0 == 3) {

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

-        LOCK();

-        *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfeffffff;

-        UNLOCK();

-      }

-      else if (in_stack_000000c0 == 4) {

-        LOCK();

-        *(uint *)(unaff_RDI + 0xc4) = *(uint *)(unaff_RDI + 0xc4) & 0xfdffffff;

-        UNLOCK();

-      }

-    }

-  }

-LAB_0:

-  in_stack_00000070 = uVar14;

-  if (in_stack_00000070 != 0) {

-    uVar17 = (ulonglong)in_stack_00000070;

-    plVar18 = plStack00000000000000c8;

-    do {

-      if (*plVar18 != 0) {

-        ObReleaseObjectSecurity(*plVar18,*(undefined1 *)((longlong)plVar18 + 0xc));

-      }

-      plVar18 = plVar18 + 2;

-      uVar17 = uVar17 - 1;

-    } while (uVar17 != 0);

-  }

-  if (in_stack_00000098 != 0) {

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

-      ExFreePoolWithTag(in_stack_00000098,0);

+      local_108 = local_108 + 2;

+      uVar16 = uVar16 - 1;

+    } while (uVar16 != 0);

+  }

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

+    if (bVar5) {

+      ExFreeToPagedLookasideList(&TmpLogWriteLookasideList,local_138);

     }

     else {

-      ExFreeToPagedLookasideList(&TmpLogWriteLookasideList,in_stack_00000098);

+      ExFreePoolWithTag(local_138,0);

     }

   }

-  if (iVar6 == -0x3fffffdd) {

-    iVar6 = -0x3fe6ffa8;

-  }

-  return iVar6;

+  if (iVar7 == -0x3fffffdd) {

+    iVar7 = -0x3fe6ffa8;

+  }

+  return iVar7;

 }
```

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

```diff
--- NTOSKRNL.EXE::ObfReferenceObject calling
+++ NTOSKRNL.EXE::ObfReferenceObject calling
@@ -7,0 +8 @@
+TmpAcquireTransactionMutex
```

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

```diff
--- NTOSKRNL.EXE::ObDereferenceObjectDeferDelete calling
+++ NTOSKRNL.EXE::ObDereferenceObjectDeferDelete calling
@@ -0,0 +1 @@
+TmpAcquireTransactionMutex
```

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

```diff
--- NTOSKRNL.EXE::KeWaitForSingleObject calling
+++ NTOSKRNL.EXE::ObDereferenceObjectDeferDelete calling
@@ -1,47 +1 @@
-NtQueryInformationEnlistment
-NtQueryInformationResourceManager
-NtQueryInformationTransaction
-NtQueryInformationTransactionManager
-NtSetInformationEnlistment
-NtSetInformationResourceManager
-NtSetInformationTransaction
-TmCommitEnlistment
-TmDereferenceEnlistmentKey
-TmEnableCallbacks
-TmEndPropagationRequest
-TmFreezeTransactions
-TmInitializeResourceManager
-TmPropagationFailed
-TmRecoverEnlistment
-TmRecoverResourceManager
-TmReferenceEnlistmentKey
-TmRegisterProtocolAddressInformation
-TmRequestOutcomeEnlistment
-TmRollbackEnlistment
-TmSinglePhaseReject
-TmThawTransactions
-TmpAcquireTransactionMutex
-TmpAcquireTxTableTransactionManager
-TmpAllocateAndDispatchPropagateRequest
-TmpAllocatePropagateRequest
-TmpAreAllSubordinatesAvailableTransaction
-TmpBindResourceManagerCompletionPort
-TmpCheckpoint
-TmpCloseResourceManager
-TmpCloseTransactionManager
-TmpDelayedPropWorkItem
-TmpDelegateDisconnect
-TmpDeletePropagateRequest
-TmpDeleteResourceManager
-TmpDereferencePropagateRequest
-TmpDispatchPropagateRequest
-TmpFilterTransactionManagerOnlineAndLock
-TmpFinalizeEnlistment
-TmpFinalizeTransaction
-TmpFinalizeTransactionForcefully
-TmpFindPropagationRequest
-TmpFreezeThawTransactionManager
-TmpGetNotificationResourceManager
-TmpGetNotificationResourceManagerAsync
-TmpInitializeEnlistment
-TmpInsertTransactionLsnList
+TmpCompleteNotificationRequestPacket
@@ -49,28 +2,0 @@
-TmpIsClusteredTransactionManager
-TmpIsLogWritableTransactionManager
-TmpLogTransaction
-TmpMigrateEnlistments
-TmpNamespaceActivate
-TmpNamespaceEnumerate
-TmpNamespaceEnumerateObject
-TmpNamespaceExpire
-TmpNamespaceForEach
-TmpNamespaceInsert
-TmpNamespaceLookup
-TmpNamespaceRemove
-TmpNamespaceRename
-TmpNamespaceReplace
-TmpNotifyAllCRM
-TmpNotifyAllEnlistmentsTransaction
-TmpNotifyEnlistment
-TmpNotifyResourceManagerTmOnline
-TmpOpenResourceManager
-TmpProcessNotificationResponse
-TmpPropagationComplete
-TmpRecover
-TmpRundownResourceManagerNotificationRequests
-TmpSetNotificationResourceManager
-TmpTmOffline
-TmpTxActionDoCommit
-TmpTxActionDoPrePrepareComplete
-TmpWaitForTransactionOutcome
```

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

```diff
--- NTOSKRNL.EXE::ObfDereferenceObject calling
+++ NTOSKRNL.EXE::ObfDereferenceObject calling
@@ -54,0 +55 @@
+TmpAcquireTransactionMutex
@@ -84,0 +86 @@
+TmpInternalCrmNotification
```

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

```diff
--- NTOSKRNL.EXE::RtlQueryFeatureConfiguration calling
+++ NTOSKRNL.EXE::RtlQueryFeatureConfiguration calling
@@ -0,0 +1 @@
+wil_RtlStagingConfig_QueryFeatureState
```
