# CVE-2026-112766 — exfat.sys patch diff

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

## `FppCheckDirtyBit`  (modified)

```diff
--- FppCheckDirtyBit
+++ FppCheckDirtyBit
@@ -1,14 +1,46 @@
-

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

 

 void FppCheckDirtyBit(longlong param_1,longlong param_2)

 

 {

-  byte *pbVar1;

-  longlong in_RAX;

+  char cVar1;

+  char *local_res10;

+  longlong local_res18 [2];

+  undefined2 local_18;

+  undefined2 local_16;

+  undefined4 local_14;

+  longlong local_10;

   

-  pbVar1 = (byte *)(in_RAX + -0x75);

-  *pbVar1 = *pbVar1 >> 5 | *pbVar1 << 3;

+  local_res10 = (char *)0x0;

+  local_res18[0] = 0;

+  local_14 = 0;

+  local_18 = *(undefined2 *)(*(longlong *)(param_2 + 0xc0) + 6);

+  local_16 = 0x40;

+  local_10 = *(longlong *)(param_2 + 0xc0) + 0x20;

+  FppReadVolumeFile(param_1,param_2,0,0x200,local_res18,&local_res10);

+  cVar1 = FppIsBootSectorFatPlusPlus(local_res10,0);

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

+    if ((local_res10[0x6a] & 2U) == 0) {

+      if ((*(uint *)(param_2 + 200) & 0x10) == 0) {

+        FsRtlBalanceReads(*(undefined8 *)(param_2 + 0x88));

+      }

+      else {

+        DbgPrintEx(0x8d,2,"EXFAT: Volume %wZ has been cleaned.\n",&local_18);

+        LOCK();

+        *(uint *)(param_2 + 200) = *(uint *)(param_2 + 200) & 0xffffffef;

+        UNLOCK();

+      }

+    }

+    else if (((*(char *)(param_1 + 0x40) != '\r') || (*(char *)(param_1 + 0x41) != '\x02')) ||

+            ((*(uint *)(param_2 + 200) >> 0xb & 1) == 0)) {

+      DbgPrintEx(0x8d,1,"EXFAT: WARNING! Mounting Dirty Volume %wZ\n",&local_18);

+      LOCK();

+      *(uint *)(param_2 + 200) = *(uint *)(param_2 + 200) | 0x10;

+      UNLOCK();

+    }

+  }

+  if (local_res18[0] != 0) {

+    CcUnpinData();

+  }

   return;

 }
```

## `FppMarkVolume`  (modified)

```diff
--- FppMarkVolume
+++ FppMarkVolume
@@ -1,110 +1,107 @@
-

-/* WARNING: Instruction at (ram,0x00014000cdeb) overlaps instruction at (ram,0x00014000cde8)

-    */

 

 void FppMarkVolume(undefined8 param_1,longlong param_2,int param_3)

 

 {

-  longlong lVar1;

-  short *psVar2;

-  short *psVar3;

-  short *in_RAX;

-  undefined1 *puVar4;

-  undefined8 *unaff_RBX;

-  char unaff_R12B;

-  undefined8 *unaff_R14;

-  undefined8 *unaff_R15;

-  undefined1 in_ZF;

-  char local_res20;

-  short *in_stack_00000068;

-  undefined8 in_stack_00000070;

-  undefined8 *in_stack_00000128;

-  undefined8 *in_stack_00000130;

-  undefined8 *in_stack_00000138;

+  byte *pbVar1;

+  longlong lVar2;

+  undefined8 *puVar3;

+  char cVar4;

+  ushort uVar5;

+  int iVar6;

+  longlong lVar7;

+  uint uVar8;

+  char *pcVar9;

+  char *local_res8;

+  longlong local_res10;

+  undefined8 local_30;

+  undefined8 uStack_28;

+  undefined8 local_20;

   

-  do {

-    *(undefined4 *)unaff_RBX = 0xc0854800;

-    if ((bool)in_ZF) {

-      ExReleaseResourceLite(unaff_RBX + 0x3a);

+  local_res10 = 0;

+  local_30 = 0;

+  uStack_28 = 0;

+  local_20 = 0;

+  local_res8 = (char *)0x0;

+  if ((*(uint *)(param_2 + 200) >> 0xe & 1) != 0) {

+    return;

+  }

+  lVar7 = *(longlong *)(param_2 + 0x2a0);

+  if (lVar7 == 0) {

+    return;

+  }

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

+    return;

+  }

+  if (*(longlong *)(*(longlong *)(lVar7 + 0x28) + 8) == 0) {

+    return;

+  }

+  uVar8 = 1 << (*(byte *)(param_2 + 0x144) & 0x1f);

+  if (uVar8 < 0x200) {

+    uVar8 = 0x200;

+  }

+  CcPinRead(lVar7,&FppLargeZero,uVar8,1,&local_res10,&local_res8);

+  cVar4 = FppIsBootSectorFatPlusPlus(local_res8,0);

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

+    lVar7 = 0;

+    goto LAB_0;

+  }

+  if (param_3 == 0) {

+    uVar5 = *(ushort *)(local_res8 + 0x6a) & 0xfffd;

+    pcVar9 = "exFAT: Marking Volume 0x%p Clean\n";

+LAB_1:

+    *(ushort *)(local_res8 + 0x6a) = uVar5;

+    DbgPrintEx(0x8d,2,pcVar9,param_2);

+  }

+  else {

+    if (param_3 == 1) {

+      uVar5 = *(ushort *)(local_res8 + 0x6a) | 2;

+      pcVar9 = "exFAT: Marking Volume 0x%p Dirty\n";

+      goto LAB_1;

+    }

+    if (param_3 != 2) {

+                    /* WARNING: Subroutine does not return */

+      KeBugCheckEx(300,0x1e051e,param_2,(longlong)param_3,0);

+    }

+    *(ushort *)(local_res8 + 0x6a) = *(ushort *)(local_res8 + 0x6a) | 2;

+    *(ushort *)(local_res8 + 0x6a) = *(ushort *)(local_res8 + 0x6a) | 4;

+    DbgPrintEx(0x8d,2,"exFAT: Marking Volume 0x%p Dirty With Surface Scan\n",param_2);

+  }

+  *(ushort *)(local_res8 + 0x6a) = *(ushort *)(local_res8 + 0x6a) & 0xfff7;

+  local_res8[0x70] =

+       (char)(((ulonglong)(*(uint *)(param_2 + 0x138) - *(int *)(param_2 + 0x13c)) * 100) /

+             (ulonglong)*(uint *)(param_2 + 0x138));

+  KeInitializeEvent(&local_30,0,0);

+  lVar7 = IoBuildAsynchronousFsdRequest

+                    (4,*(undefined8 *)(param_2 + 0x88),local_res8,uVar8,&FppLargeZero,0);

+  if (lVar7 != 0) {

+    pbVar1 = (byte *)(*(longlong *)(lVar7 + 0xb8) + -0x46);

+    *pbVar1 = *pbVar1 | 4;

+    lVar2 = *(longlong *)(lVar7 + 0xb8);

+    *(code **)(lVar2 + -0x10) = FppCallSelfCompletionRoutine;

+    *(undefined8 **)(lVar2 + -8) = &local_30;

+    *(undefined1 *)(lVar2 + -0x45) = 0;

+    *(undefined1 *)(lVar2 + -0x45) = 0x40;

+    *(undefined1 *)(lVar2 + -0x45) = 0xc0;

+    *(undefined1 *)(lVar2 + -0x45) = 0xe0;

+    iVar6 = IofCallDriver(*(undefined8 *)(param_2 + 0x88),lVar7);

+    if (iVar6 == 0x103) {

+      KeWaitForSingleObject(&local_30,0,0,0,0);

+    }

+  }

 LAB_0:

-      do {

-        ExReleaseResourceLite(unaff_RBX + 0x3a);

-        unaff_R14 = (undefined8 *)*unaff_R14;

-        in_stack_00000128 = unaff_R14;

-        if (unaff_R14 == &DAT_1) {

-          ExReleaseResourceLite(&DAT_2);

-          return;

-        }

-        unaff_RBX = unaff_R14 + -0xf;

-        in_stack_00000130 = unaff_RBX;

-        FppAcquireExclusiveVcb_Real((longlong)&stack0x00000040,(longlong)unaff_RBX,'\0');

-      } while ((((*(uint *)(unaff_R14 + 10) & 0x40) != 0) ||

-               ((*(uint *)(unaff_R14 + 10) >> 0x10 & 1) != 0)) ||

-              ((*(uint *)(unaff_R14 + 10) & 4) == 0));

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

-        if ((*(uint *)(unaff_R14 + 10) >> 0xc & 1) != 0) goto LAB_0;

-      }

-      else if ((*(uint *)(unaff_R14 + 10) >> 0x16 & 1) == 0) goto LAB_0;

-      if ((*(int *)((longlong)unaff_R14 + 0x54) != 1) || (unaff_R14[9] == 0)) goto LAB_0;

-      puVar4 = &stack0x00000040;

-      FppAcquireExclusiveVcb_Real((longlong)puVar4,(longlong)unaff_RBX,'\0');

-      unaff_R15 = unaff_R14 + 0xb;

-      psVar2 = (short *)0x0;

-      in_stack_00000138 = unaff_R15;

-      while (psVar2 = FppGetNextFcbBottomUp(puVar4,psVar2,(short *)*unaff_R15),

-            psVar2 != (short *)0x0) {

-        puVar4 = &stack0x00000040;

-        FppAcquireExclusiveFcb((longlong)puVar4,(longlong)psVar2);

-      }

-      in_stack_00000070 = *(undefined8 *)(unaff_R14[9] + 0x10);

-      psVar2 = (short *)CONCAT71((int7)((ulonglong)in_stack_00000070 >> 8),

-                                 *(char *)(unaff_R14[2] + 0x4c) + '\x01');

-      psVar3 = (short *)IoAllocateIrp();

-      if (psVar3 != (short *)0x0) {

-        *(char *)((longlong)psVar3 + 0x43) = *(char *)((longlong)psVar3 + 0x43) + -1;

-        lVar1 = *(longlong *)(psVar3 + 0x5c);

-        puVar4 = (undefined1 *)(lVar1 + -0x48);

-        *(undefined1 **)(psVar3 + 0x5c) = puVar4;

-        *puVar4 = 0x10;

-        *(undefined8 *)(lVar1 + -0x20) = DAT_3;

-        in_stack_00000068 = psVar3;

-        local_res20 = FppIsIrpTopLevel(psVar3);

-        FppVerifyVcb((longlong)&stack0x00000040,(longlong)unaff_RBX);

-        psVar2 = (short *)&stack0x00000040;

-        FppFlushVolume(psVar2,(longlong)unaff_RBX,1);

-        if ((*(uint *)(unaff_R14 + 10) & 4) != 0) {

-          KeCancelTimer(unaff_R14 + 0x61);

-          psVar2 = (short *)(unaff_R14 + 0x59);

-          KeRemoveQueueDpc();

-          if ((*(uint *)(unaff_R14 + 10) & 0x10) == 0) {

-            func_0x00014000cf98();

-            LOCK();

-            *(uint *)(unaff_R14 + 10) = *(uint *)(unaff_R14 + 10) & 0xfffffffb;

-            UNLOCK();

-          }

-          if (((*(uint *)(unaff_R14 + 10) & 2) != 0) &&

-             ((*(uint *)(unaff_R14 + 10) >> 0xb & 1) == 0)) {

-            FppToggleMediaEjectDisable(psVar2,(longlong)unaff_RBX,0);

-          }

-        }

-      }

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

-        psVar2 = (short *)0x0;

-        IoSetTopLevelIrp();

-      }

-      if (psVar3 != (short *)0x0) {

-        IoFreeIrp();

-        in_stack_00000068 = (short *)0x0;

-        psVar2 = psVar3;

-      }

-      in_RAX = (short *)0x0;

+  if (lVar7 != 0) {

+    puVar3 = *(undefined8 **)(lVar7 + 8);

+    while (puVar3 != (undefined8 *)0x0) {

+      puVar3 = (undefined8 *)*puVar3;

+      MmUnlockPages();

+      IoFreeMdl(*(undefined8 *)(lVar7 + 8));

+      *(undefined8 **)(lVar7 + 8) = puVar3;

     }

-    else {

-      psVar2 = *(short **)(in_RAX + 4);

-      ExReleaseResourceLite();

-    }

-    in_RAX = FppGetNextFcbBottomUp(psVar2,in_RAX,(short *)*unaff_R15);

-    in_ZF = in_RAX == (short *)0x0;

-  } while( true );

+    IoFreeIrp(lVar7);

+  }

+  if (local_res10 != 0) {

+    CcUnpinData();

+  }

+  return;

 }
```

## `EfsPostCreateCallback$fin$0`  (modified)

```diff
--- EfsPostCreateCallback$fin$0
+++ EfsPostCreateCallback$fin$0
@@ -1,13 +1,9 @@
-

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

 

 void EfsPostCreateCallback_fin_0(undefined8 param_1,longlong param_2)

 

 {

-  char *unaff_RDI;

-  

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

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

-  halt_baddata();

+  ExReleaseResourceLite(*(undefined8 *)(*(longlong *)(param_2 + 0x68) + 8));

+  KeLeaveCriticalRegion();

+  return;

 }
```

## `FppIsBootSectorFatPlusPlus`  (modified)

```diff
--- FppIsBootSectorFatPlusPlus
+++ FppIsBootSectorFatPlusPlus
@@ -1,84 +1,92 @@
 

-undefined8 FppIsBootSectorFatPlusPlus(char *param_1,longlong param_2)

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

+

+undefined1 FppIsBootSectorFatPlusPlus(char *param_1,longlong param_2)

 

 {

-  undefined4 *_Dst;

-  longlong lVar1;

-  char cVar2;

-  char *in_RAX;

-  short *psVar3;

-  short *psVar4;

-  longlong unaff_RBP;

-  undefined8 *unaff_RSI;

-  undefined8 *unaff_RDI;

-  short *psVar5;

-  ushort unaff_R13W;

-  undefined8 *unaff_R14;

-  undefined8 *puVar6;

-  longlong unaff_R15;

+  byte bVar1;

+  uint uVar2;

+  int iVar3;

+  ulonglong uVar4;

+  byte bVar5;

+  ulonglong uVar6;

+  undefined1 uVar7;

+  undefined1 auStack_68 [32];

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  undefined8 uStack_30;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  undefined4 local_18;

+  undefined1 local_14;

+  ulonglong local_10;

   

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

-  do {

-    if ((*(byte *)(*(longlong *)(unaff_R15 + 0x38) + 4) & 1) != 0) {

-      _Dst = (undefined4 *)unaff_RDI[0x86];

-      unaff_RDI[0x86] = 0;

-      LOCK();

-      *(uint *)(unaff_RDI + 0x19) = *(uint *)(unaff_RDI + 0x19) | 0x40000;

-      UNLOCK();

-      memset(_Dst,0,0x60);

-      *_Dst = 0x60000a;

-      *(longlong *)(_Dst + 4) = unaff_R15;

-      *(ushort *)(_Dst + 1) = *(ushort *)(*(longlong *)(unaff_R15 + 0x38) + 4) & unaff_R13W;

-      *(undefined4 **)(unaff_R15 + 0x38) = _Dst;

+  local_10 = __security_cookie ^ (ulonglong)auStack_68;

+  uVar7 = 0;

+  local_18 = 0;

+  local_14 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_38 = 0;

+  uStack_30 = 0;

+  local_28 = 0;

+  uStack_20 = 0;

+  if (*param_1 != -0x15) {

+    return 0;

+  }

+  if (param_1[1] != 'v') {

+    return 0;

+  }

+  if (param_1[2] != -0x70) {

+    return 0;

+  }

+  if (*(longlong *)(param_1 + 3) == 0x2020205441465845) {

+    iVar3 = memcmp(param_1 + 0xb,&local_48,0x35);

+    if (iVar3 != 0) {

+      return 0;

     }

-    IoReleaseVpbSpinLock(*(undefined1 *)(unaff_RBP + 0x6f));

-    do {

-      *(undefined4 *)((longlong)unaff_RDI + 0xcc) = 3;

-      if (unaff_RDI[0x1a] == 0) {

-LAB_0:

-        ExReleaseResourceLite(unaff_RDI + 0x3a);

+    bVar5 = param_1[0x6c];

+    if ((byte)(bVar5 - 7) < 6) {

+      if (0x10 < (byte)param_1[0x6d]) {

+        return 0;

       }

-      else {

-        psVar4 = (short *)&stack0x00000030;

-        FppAcquireExclusiveVcb_Real((longlong)psVar4,(longlong)unaff_RDI,'\0');

-        psVar3 = (short *)0x0;

-        while( true ) {

-          psVar5 = (short *)unaff_RDI[0x1a];

-          psVar3 = FppGetNextFcbBottomUp(psVar4,psVar3,psVar5);

-          if (psVar3 == (short *)0x0) break;

-          psVar4 = (short *)&stack0x00000030;

-          FppAcquireExclusiveFcb((longlong)psVar4,(longlong)psVar3);

+      if (param_2 != 0) {

+        uVar4 = Feature_3447085371__private_IsEnabledDeviceUsageNoInline();

+        bVar5 = param_1[0x6c];

+        uVar6 = *(longlong *)(param_2 + 0x10) >> (bVar5 & 0x3f);

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

+          if ((char)uVar6 != param_1[0x48]) {

+            return 0;

+          }

         }

-        FppMarkFcbCondition(psVar4,psVar5,2,'\x01');

-        psVar3 = (short *)0x0;

-        while( true ) {

-          psVar3 = FppGetNextFcbBottomUp(psVar4,psVar3,(short *)unaff_RDI[0x1a]);

-          if (psVar3 == (short *)0x0) break;

-          psVar4 = *(short **)(psVar3 + 4);

-          ExReleaseResourceLite();

-        }

-        ExReleaseResourceLite(unaff_RDI + 0x3a);

-        *(int *)(unaff_RDI + 0x22) = *(int *)(unaff_RDI + 0x22) + 1;

-        FppPurgeReferencedFileObjects((longlong)&stack0x00000030,(short *)unaff_RDI[0x1a],0);

-        *(int *)(unaff_RDI + 0x22) = *(int *)(unaff_RDI + 0x22) + -1;

-        cVar2 = FppCheckForDismount((longlong)&stack0x00000030,unaff_RDI,'\0');

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

-      }

-      do {

-        puVar6 = unaff_R14;

-        if (puVar6 == unaff_RSI) {

-          lVar1 = *(longlong *)(unaff_RBP + 0x67);

-          ExReleaseResourceLite();

-          FppCompleteRequest_Real(0,lVar1,0);

+        else if (uVar6 < *(ulonglong *)(param_1 + 0x48)) {

           return 0;

         }

-        unaff_RDI = puVar6 + -0xf;

-        unaff_R14 = (undefined8 *)*puVar6;

-      } while (*(longlong *)(puVar6[9] + 0x10) != unaff_R15);

-      FppAcquireExclusiveVcb_Real((longlong)&stack0x00000030,(longlong)unaff_RDI,'\0');

-    } while (puVar6[9] != *(longlong *)(unaff_R15 + 0x38));

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

-    IoAcquireVpbSpinLock(unaff_RBP + 0x6f);

-  } while( true );

+      }

+      if (0x17 < *(uint *)(param_1 + 0x50)) {

+        bVar1 = param_1[0x6e];

+        if (bVar1 == 1 || bVar1 == 2) {

+          if ((ulonglong)bVar1 * (ulonglong)*(uint *)(param_1 + 0x54) +

+              (ulonglong)*(uint *)(param_1 + 0x50) <= (ulonglong)*(uint *)(param_1 + 0x58)) {

+            uVar2 = *(uint *)(param_1 + 0x5c);

+            if ((((uVar2 != 0) &&

+                 ((longlong)(ulonglong)uVar2 <=

+                  (longlong)((((ulonglong)*(uint *)(param_1 + 0x54) << (bVar5 & 0x3f)) >> 2) - 2)))

+                && (((ulonglong)uVar2 << (param_1[0x6d] & 0x3fU)) +

+                    (ulonglong)*(uint *)(param_1 + 0x58) <= *(ulonglong *)(param_1 + 0x48))) &&

+               (((1 < *(uint *)(param_1 + 0x60) && (*(uint *)(param_1 + 0x60) - 2 < uVar2)) &&

+                (((byte)param_1[0x69] < 2 && (uVar7 = 0, *(short *)(param_1 + 0x1fe) == -0x55ab)))))

+               ) {

+              uVar7 = 1;

+            }

+          }

+        }

+      }

+      return uVar7;

+    }

+    return 0;

+  }

+  return 0;

 }
```

## `FppMountVolume`  (modified)

```diff
--- FppMountVolume
+++ FppMountVolume
@@ -1,2 +1,633 @@
-Failed to decompile exfat.sys - .ProgramDB FppMountVolume : Error: Decompile error: 
-Low-level Error: DuplicateFunctionError, but could not recover original symbol+

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

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

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

+

+ulonglong FppMountVolume(longlong param_1,undefined8 *param_2,undefined8 **param_3)

+

+{

+  void *_Buf2;

+  undefined8 **ppuVar1;

+  undefined8 **ppuVar2;

+  undefined4 uVar3;

+  undefined4 uVar4;

+  undefined8 ***pppuVar5;

+  bool bVar6;

+  char cVar7;

+  bool bVar8;

+  undefined4 uVar9;

+  int iVar10;

+  uint uVar11;

+  ulonglong uVar12;

+  ulonglong uVar13;

+  char *pcVar14;

+  undefined8 *puVar15;

+  undefined8 uVar16;

+  undefined8 **ppuVar17;

+  int *piVar18;

+  undefined *puVar19;

+  char *pcVar20;

+  longlong lVar21;

+  void **ppvVar22;

+  ulonglong unaff_RSI;

+  void *pvVar23;

+  ulonglong uVar24;

+  uint uVar25;

+  longlong lVar26;

+  undefined8 ***pppuVar27;

+  uint uVar28;

+  void *pvVar29;

+  void *pvVar30;

+  void *pvVar31;

+  bool bVar32;

+  undefined1 auStackY_2b8 [32];

+  undefined8 in_stack_fffffffffffffd80;

+  undefined8 in_stack_fffffffffffffd88;

+  uint local_250;

+  uint local_24c;

+  undefined4 local_248 [2];

+  undefined8 ***local_240;

+  longlong local_238;

+  undefined8 ***local_230;

+  uint local_228 [4];

+  longlong local_218;

+  undefined8 **local_210;

+  void *local_208;

+  char *local_200;

+  longlong local_1f8;

+  longlong local_1f0;

+  longlong local_1e8;

+  longlong local_1e0;

+  longlong local_1d8;

+  undefined8 **local_1d0;

+  byte *local_1c8;

+  longlong local_1c0;

+  uint local_1b8;

+  ulonglong local_1b0;

+  void *local_1a8;

+  byte *local_1a0;

+  void *local_198;

+  longlong local_190;

+  longlong local_188;

+  undefined8 local_180;

+  uint local_178 [2];

+  longlong lStack_170;

+  undefined4 local_168;

+  undefined4 local_164;

+  undefined4 uStack_160;

+  ulonglong local_158;

+  longlong lStack_150;

+  undefined8 local_148;

+  uint local_140;

+  uint local_13c;

+  int local_138;

+  undefined8 **local_130;

+  int local_128 [4];

+  ulonglong local_118;

+  char local_108;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStackY_2b8;

+  lVar21 = *(longlong *)(*(longlong *)(param_1 + 0x28) + 0xb8);

+  pvVar31 = (void *)0x0;

+  local_1a8 = (void *)0x0;

+  local_200 = (char *)0x0;

+  local_1c0 = 0;

+  local_228[1] = 0;

+  bVar32 = false;

+  local_240 = (undefined8 ***)0x0;

+  local_210 = (undefined8 **)0x0;

+  pvVar29 = (void *)0x0;

+  local_198 = (void *)0x0;

+  local_178[0] = 0;

+  local_178[1] = 0;

+  lStack_170 = 0;

+  local_248[0] = 0;

+  local_98 = 0;

+  uStack_90 = 0;

+  local_88 = 0;

+  local_128[1] = 0;

+  piVar18 = local_128;

+  local_230 = (undefined8 ***)param_3;

+  local_1d0 = param_3;

+  local_190 = param_1;

+  memset(piVar18,0,0x8c);

+  local_1b0 = 0;

+  local_1d8 = 0;

+  local_1f0 = 0;

+  local_218 = 0;

+  local_1c8 = (byte *)0x0;

+  local_158 = 0;

+  lStack_150 = 0;

+  local_148 = 0;

+  local_188 = 0;

+  local_1e8 = 0;

+  local_228[0] = 0;

+  uStack_160 = 0;

+  local_168 = 0;

+  local_164 = 0;

+  local_1e0 = 0;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  lVar26 = 4;

+  if ((*(uint *)((longlong)param_2 + 0x34) & 1) != 0) {

+    uVar12 = FppPerformDevIoCtrl(piVar18,0x74800,param_2,0,0,local_248,4,in_stack_fffffffffffffd80,

+                                 in_stack_fffffffffffffd88,local_178);

+    if ((int)uVar12 < 0) {

+      if ((*(byte *)(lVar21 + 2) & 1) != 0) {

+        return unaff_RSI;

+      }

+      if (*(int *)(param_3[2] + 9) != 7) {

+        return unaff_RSI;

+      }

+      *(int *)(param_1 + 0x48) = (int)uVar12;

+      uVar9 = FsRtlNormalizeNtstatus(uVar12 & 0xffffffff,0xc00000e9);

+                    /* WARNING: Subroutine does not return */

+      ExRaiseStatus(uVar9);

+    }

+  }

+  if (lStack_170 != 4) {

+    local_248[0] = 0;

+  }

+  uVar12 = FppPerformDevIoCtrl(piVar18,0x70048,param_2,0,0,local_128,0x90,in_stack_fffffffffffffd80,

+                               in_stack_fffffffffffffd88,local_178);

+  *(uint *)(param_1 + 0x44) = *(uint *)(param_1 + 0x44) | 2;

+  local_250 = (uint)uVar12;

+  FppScanForDismountedVcb(param_1);

+  local_238 = 0;

+  local_1f8 = 0;

+  bVar8 = false;

+  puVar19 = &DAT_0;

+  ExAcquireResourceExclusiveLite

+            (&DAT_0,

+             CONCAT31((uint3)(*(uint *)(param_1 + 0x44) >> 9),(char)(*(uint *)(param_1 + 0x44) >> 1)

+                     ) & 0xffffff01);

+  uVar13 = FppPerformDevIoCtrl(puVar19,0x70000,param_2,0,0,&local_98,0x18,in_stack_fffffffffffffd80,

+                               in_stack_fffffffffffffd88,(uint *)0x0);

+  pvVar23 = pvVar31;

+  pvVar30 = pvVar31;

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

+    if ((int)(uint)uVar12 < 0) {

+      uVar12 = FppPerformDevIoCtrl(puVar19,0x7405c,param_2,0,0,&local_1b0,8,

+                                   in_stack_fffffffffffffd80,in_stack_fffffffffffffd88,local_178);

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

+    }

+    else {

+      local_1b0 = local_118;

+    }

+    local_140 = local_88._4_2_ + 0xfff & 0xfffff000;

+    uVar11 = (uint)local_88._4_2_;

+    local_13c = uVar11;

+    pcVar14 = (char *)ExAllocatePoolWithTag(0x610,local_140,0x74627046);

+    local_200 = pcVar14;

+    bVar6 = FppReadBootSector(param_2,uVar11,pcVar14);

+    pvVar30 = pvVar29;

+    if (bVar6) {

+      piVar18 = local_128;

+      if ((int)local_250 < 0) {

+        piVar18 = (int *)0x0;

+      }

+      cVar7 = FppIsBootSectorFatPlusPlus(pcVar14,(longlong)piVar18);

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

+        uVar12 = Feature_3447085371__private_IsEnabledDeviceUsageNoInline();

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

+          pvVar23 = (void *)0x0;

+          if ((1 << (pcVar14[0x6c] & 0x1fU) != local_88._4_4_) ||

+             (local_1b0 >> (pcVar14[0x6c] & 0x3fU) < *(ulonglong *)(pcVar14 + 0x48)))

+          goto LAB_1;

+        }

+        local_138 = IoCreateDevice(DAT_2,0x570,0,8);

+        pvVar23 = pvVar31;

+        if (-1 < local_138) {

+          if (uRam0000000000000098 < *(uint *)(param_2 + 0x13)) {

+            uRam0000000000000098 = *(uint *)(param_2 + 0x13);

+          }

+          uRam0000000000000154 = 0;

+          uRam0000000000000160 = 0x158;

+          uRam0000000000000158 = 0x158;

+          uRam0000000000000150 = 0;

+          KeInitializeSpinLock(0x168);

+          cRam000000000000004c = *(char *)((longlong)param_2 + 0x4c) + '\x01';

+          uRam0000000000000130 = (undefined2)((ulonglong)local_88 >> 0x20);

+          uRam0000000000000030 = uRam0000000000000030 & 0xffffff7f;

+          local_230[1] = (undefined8 **)0x0;

+          local_210 = local_230[2];

+          bVar32 = (*(uint *)(local_210 + 6) & 2) != 0;

+          if (bVar32) {

+            *(uint *)(local_210 + 6) = *(uint *)(local_210 + 6) & 0xfffffffd;

+          }

+          FppInitializeVcb(param_1,(short *)0x1a0,param_2,(longlong)local_230);

+          pvVar23 = (void *)0x1a0;

+          local_208 = pvVar23;

+          iVar10 = IoVolumeDeviceToGuid(puRam0000000000000228,&local_68);

+          if (-1 < iVar10) {

+            uRam000000000000066c = (undefined4)local_68;

+            uRam0000000000000670 = local_68._4_4_;

+            uRam0000000000000674 = (undefined4)uStack_60;

+            uRam0000000000000678 = uStack_60._4_4_;

+            uRam0000000000000230 = local_68;

+            uRam0000000000000238 = uStack_60;

+          }

+          iVar10 = FsRtlVolumeDeviceToCorrelationId(puRam0000000000000228,&local_58);

+          if (-1 < iVar10) {

+            uRam0000000000000250 = (undefined4)local_58;

+            uRam0000000000000254 = local_58._4_4_;

+            uRam0000000000000258 = (undefined4)uStack_50;

+            uRam000000000000025c = uStack_50._4_4_;

+          }

+          if (lRam0000000000000248 != 0) {

+            ExFreePoolWithTag(lRam0000000000000248,0);

+            lRam0000000000000248 = 0;

+            uRam0000000000000240 = 0;

+          }

+          IoVolumeDeviceToGuidPath(puRam0000000000000228,0x240);

+          puVar15 = puRam00000000000002c0;

+          pcVar20 = pcVar14;

+          do {

+            uVar16 = *(undefined8 *)(pcVar20 + 8);

+            *puVar15 = *(undefined8 *)pcVar20;

+            puVar15[1] = uVar16;

+            uVar16 = *(undefined8 *)(pcVar20 + 0x18);

+            puVar15[2] = *(undefined8 *)(pcVar20 + 0x10);

+            puVar15[3] = uVar16;

+            uVar16 = *(undefined8 *)(pcVar20 + 0x28);

+            puVar15[4] = *(undefined8 *)(pcVar20 + 0x20);

+            puVar15[5] = uVar16;

+            uVar16 = *(undefined8 *)(pcVar20 + 0x38);

+            puVar15[6] = *(undefined8 *)(pcVar20 + 0x30);

+            puVar15[7] = uVar16;

+            uVar16 = *(undefined8 *)(pcVar20 + 0x48);

+            puVar15[8] = *(undefined8 *)(pcVar20 + 0x40);

+            puVar15[9] = uVar16;

+            uVar16 = *(undefined8 *)(pcVar20 + 0x58);

+            puVar15[10] = *(undefined8 *)(pcVar20 + 0x50);

+            puVar15[0xb] = uVar16;

+            uVar9 = *(undefined4 *)(pcVar20 + 100);

+            uVar3 = *(undefined4 *)(pcVar20 + 0x68);

+            uVar4 = *(undefined4 *)(pcVar20 + 0x6c);

+            *(undefined4 *)(puVar15 + 0xc) = *(undefined4 *)(pcVar20 + 0x60);

+            *(undefined4 *)((longlong)puVar15 + 100) = uVar9;

+            *(undefined4 *)(puVar15 + 0xd) = uVar3;

+            *(undefined4 *)((longlong)puVar15 + 0x6c) = uVar4;

+            uVar9 = *(undefined4 *)(pcVar20 + 0x74);

+            uVar3 = *(undefined4 *)(pcVar20 + 0x78);

+            uVar4 = *(undefined4 *)(pcVar20 + 0x7c);

+            *(undefined4 *)(puVar15 + 0xe) = *(undefined4 *)(pcVar20 + 0x70);

+            *(undefined4 *)((longlong)puVar15 + 0x74) = uVar9;

+            *(undefined4 *)(puVar15 + 0xf) = uVar3;

+            *(undefined4 *)((longlong)puVar15 + 0x7c) = uVar4;

+            pcVar20 = pcVar20 + 0x80;

+            lVar26 = lVar26 + -1;

+            puVar15 = puVar15 + 0x10;

+          } while (lVar26 != 0);

+          if (((((int)local_250 < 0) || (local_128[0] != 0)) || (local_108 != '\n')) ||

+             (0x7e < puRam00000000000002c0[9] - 1)) {

+            ExFreePoolWithTag(pcVar14,0x74627046);

+            uVar24 = 0;

+            local_200 = (char *)0x0;

+            FppReadVolumeFile(param_1,0x1a0,0,local_88._4_4_ * 0x18,&local_238,&local_1a8);

+            pvVar29 = local_1a8;

+            local_1b8 = 0;

+            uVar12 = uVar24;

+            uVar13 = uVar24;

+            while( true ) {

+              uVar11 = (uint)uVar12;

+              uVar28 = (uint)uVar13;

+              if (local_88._4_4_ * 0xb <= uVar11) break;

+              if ((1 < uVar11 - 0x6a) && (uVar11 != 0x70)) {

+                local_1b8 = (uVar28 >> 1) +

+                            (uint)*(byte *)(uVar12 + (longlong)local_1a8) + uVar28 * -0x80000000;

+                uVar13 = (ulonglong)local_1b8;

+              }

+              uVar12 = (ulonglong)(uVar11 + 1);

+            }

+            local_24c = 0;

+            while ((uint)uVar24 < local_88._4_4_ >> 2) {

+              uVar11 = *(uint *)((longlong)local_1a8 +

+                                uVar24 * 4 + (ulonglong)(local_88._4_4_ * 0xb));

+              if (uVar11 != uVar28) {

+                DbgPrintEx(0x8d,0,

+                           "ExFAT: Invalid boot sector checksum.  Was 0x%x, should be 0x%x.\n",

+                           uVar11);

+                pvVar30 = pvVar31;

+                goto LAB_1;

+              }

+              local_24c = (uint)uVar24 + 1;

+              uVar24 = (ulonglong)local_24c;

+            }

+            uVar11 = local_88._4_4_ * 0xc;

+            _Buf2 = (void *)((ulonglong)uVar11 + (longlong)local_1a8);

+            iVar10 = memcmp(local_1a8,_Buf2,0x6a);

+            if (((iVar10 == 0) &&

+                (*(int *)((longlong)pvVar29 + 0x6c) == *(int *)((longlong)_Buf2 + 0x6c))) &&

+               (iVar10 = memcmp((void *)((longlong)pvVar29 + 0x71),(void *)((longlong)_Buf2 + 0x71),

+                                (ulonglong)uVar11 - 0x71), pvVar30 = pvVar31, iVar10 == 0)) {

+              if (local_238 != 0) {

+                CcUnpinData();

+                local_238 = 0;

+              }

+              local_1a8 = (void *)0x0;

+              FppSetupAllocationSupport(param_1,0x1a0);

+              LOCK();

+              uRam0000000000000268 = uRam0000000000000268 & 0xff7fffff;

+              UNLOCK();

+              if ((DAT_3 & 0x20) != 0) {

+                LOCK();

+                uRam0000000000000268 = uRam0000000000000268 | 0x800000;

+                UNLOCK();

+              }

+              FppCreateRootDcb(param_1,0x1a0);

+              bVar6 = FppUnrecognizedPrimaryTypes(param_1,0x1a0);

+              pvVar30 = local_198;

+              if (((!bVar6) &&

+                  (FppLocateBitmap(param_1,0x1a0,&local_188,&local_1e8,local_228),

+                  pvVar30 = local_198, local_188 != 0)) &&

+                 ((lVar21 = *(longlong *)(local_188 + 0x18),

+                  (longlong)(ulonglong)(*(int *)((longlong)puRam00000000000002c0 + 0x5c) + 7U >> 3)

+                  <= lVar21 && (lVar21 < 0x20000001)))) {

+                lVar26 = param_1;

+                FppCreateBitmapFcb(param_1,0x1a0,local_228[0],*(undefined4 *)(local_188 + 0x14),

+                                   (uint)lVar21);

+                lRam0000000000000460 = FppOpenBitmapFile(lVar26,psRam0000000000000468);

+                lVar21 = param_1;

+                FppEvaluateBitmap(param_1,0x1a0);

+                uVar11 = FppSelectBestWindow(lVar21,0x1a0);

+                FppSwitchWindow(param_1,0x1a0,uVar11,&local_168,&local_1e0);

+                iVar10 = RtlFindClearBits(&local_168,1);

+                iRam0000000000000470 = iVar10 + 2;

+                if (iVar10 == -1) {

+                  iRam0000000000000470 = 2;

+                }

+                FppLocateVolumeLabel(param_1,0x1a0,&local_1c0,&local_1f8,local_228 + 1);

+                ppuVar17 = local_1d0;

+                if ((local_1c0 == 0) || (0xf < *(byte *)(local_1c0 + 1))) {

+                  *(undefined2 *)((longlong)local_230 + 6) = 0;

+                }

+                else {

+                  *(ushort *)((longlong)local_230 + 6) = (ushort)*(byte *)(local_1c0 + 1) * 2;

+                  memmove(local_1d0 + 4,(void *)(local_1c0 + 2),

+                          (ulonglong)*(byte *)(local_1c0 + 1) * 2);

+                  memset((void *)((longlong)ppuVar17 +

+                                 ((ulonglong)*(byte *)(local_1c0 + 1) + 0x10) * 2),0,

+                         (0x20 - (ulonglong)*(byte *)(local_1c0 + 1)) * 2);

+                }

+                *(undefined4 *)(ppuVar17 + 3) =

+                     *(undefined4 *)((longlong)puRam00000000000002c0 + 100);

+                FppLocateUpcaseTable(param_1,0x1a0,&local_1d8,&local_1f0,local_228 + 1);

+                if ((((local_1d8 != 0) && (0 < (longlong)*(ulonglong *)(local_1d8 + 0x18))) &&

+                    (*(ulonglong *)(local_1d8 + 0x18) < 0x20001)) &&

+                   ((uVar11 = *(uint *)(local_1d8 + 0x14), 1 < uVar11 &&

+                    (uVar11 < iRam00000000000002d8 + 2U)))) {

+                  local_228[2] = 0;

+                  local_1a0 = (byte *)0x0;

+                  local_250 = uVar11;

+                  local_218 = ExAllocatePoolWithTag(0x411,0x20000,0x55707046);

+                  uVar28 = local_88._4_4_ + -1 + *(int *)(local_1d8 + 0x18) & ~(local_88._4_4_ - 1);

+                  local_1a0 = (byte *)ExAllocatePoolWithTag(0x614,uVar28,0x75707046);

+                  local_1c8 = local_1a0;

+                  for (; local_228[2] = uVar28, uVar28 != 0; uVar28 = uVar28 - uVar25) {

+                    uVar25 = 1 << (bRam00000000000002e5 & 0x1f);

+                    if (uVar28 <= uVar25) {

+                      uVar25 = uVar28;

+                    }

+                    uVar16 = FppPerformVerifyDiskRead

+                                       (param_1,0x1a0,local_1a0,

+                                        ((ulonglong)(uVar11 - 2) << (bRam00000000000002e5 & 0x3f)) +

+                                        lRam00000000000002d0,uVar25,'\x01');

+                    if ((char)uVar16 == '\0') break;

+                    FppLookupFatEntry(param_1,0x1a0,uVar11,&local_250,&local_158);

+                    if (uVar25 == uVar28) {

+                      if (local_250 != 0xffffffff) break;

+                    }

+                    else if ((local_250 < 2) || (iRam00000000000002d8 + 2U <= local_250)) break;

+                    local_1a0 = local_1a0 + uVar25;

+                    uVar11 = local_250;

+                  }

+                  lVar21 = local_218;

+                  if ((uVar28 == 0) &&

+                     (uVar12 = FppDecompressUpcaseTable

+                                         (local_1c8,*(uint *)(local_1d8 + 0x18),

+                                          *(uint *)(local_1d8 + 4),local_218), (char)uVar12 != '\0')

+                     ) {

+                    lRam0000000000000630 = lVar21;

+                    local_218 = 0;

+                  }

+                }

+                uRam00000000000005c8 = local_248[0];

+                for (pppuVar27 = (undefined8 ***)DAT_4; local_230 = pppuVar27,

+                    pppuVar27 != &DAT_4; pppuVar27 = (undefined8 ***)*pppuVar27) {

+                  local_240 = pppuVar27 + -0xf;

+                  ppuVar1 = pppuVar27[9];

+                  local_130 = ppuVar1;

+                  if (((((ppuVar1 != ppuVar17) && (*(int *)(ppuVar1 + 3) == *(int *)(ppuVar17 + 3)))

+                       && (*(int *)((longlong)pppuVar27 + 0x54) == 2)) &&

+                      ((((((undefined8 **)ppuVar1[2] == local_210 &&

+                          (*(ushort *)((longlong)ppuVar1 + 6) == *(ushort *)((longlong)ppuVar17 + 6)

+                          )) && ((iVar10 = memcmp(ppuVar1 + 4,ppuVar17 + 4,

+                                                  (ulonglong)*(ushort *)((longlong)ppuVar17 + 6)),

+                                 pppuVar5 = local_240, iVar10 == 0 &&

+                                 ((ppuVar2 = pppuVar27[0x15],

+                                  (undefined8 *)puRam00000000000002c0[8] == ppuVar2[8] &&

+                                  ((undefined8 *)puRam00000000000002c0[9] == ppuVar2[9])))))) &&

+                        (*(int *)(puRam00000000000002c0 + 10) == *(int *)(ppuVar2 + 10))) &&

+                       (((((*(int *)((longlong)puRam00000000000002c0 + 0x54) ==

+                            *(int *)((longlong)ppuVar2 + 0x54) &&

+                           (*(int *)(puRam00000000000002c0 + 0xb) == *(int *)(ppuVar2 + 0xb))) &&

+                          (*(int *)((longlong)puRam00000000000002c0 + 0x5c) ==

+                           *(int *)((longlong)ppuVar2 + 0x5c))) &&

+                         ((*(int *)(puRam00000000000002c0 + 0xc) == *(int *)(ppuVar2 + 0xc) &&

+                          (*(int *)((longlong)puRam00000000000002c0 + 100) ==

+                           *(int *)((longlong)ppuVar2 + 100))))) &&

+                        ((*(short *)(puRam00000000000002c0 + 0xd) == *(short *)(ppuVar2 + 0xd) &&

+                         ((*(char *)((longlong)puRam00000000000002c0 + 0x6c) ==

+                           *(char *)((longlong)ppuVar2 + 0x6c) &&

+                          (*(char *)((longlong)puRam00000000000002c0 + 0x6d) ==

+                           *(char *)((longlong)ppuVar2 + 0x6d))))))))))) &&

+                     (*(char *)((longlong)puRam00000000000002c0 + 0x6e) ==

+                      *(char *)((longlong)ppuVar2 + 0x6e))) {

+                    puRam0000000000000228 = pppuVar27[2];

+                    pppuVar27[2] = (undefined8 **)param_2;

+                    *(undefined4 *)((longlong)pppuVar27 + 0x54) = 1;

+                    ppuVar1[2] = ppuVar17[2];

+                    LOCK();

+                    *(uint *)(pppuVar27 + 10) = *(uint *)(pppuVar27 + 10) & 0xfffdffff;

+                    UNLOCK();

+                    ppuVar1[2][7] = local_130;

+                    *(undefined4 *)(local_240 + 0x85) = uRam00000000000005c8;

+                    lVar21 = *(longlong *)(*(longlong *)(param_1 + 0x28) + 0xb8);

+                    if (*(undefined8 ***)(lVar21 + 8) == local_1d0) {

+                      *(undefined8 ***)(lVar21 + 8) = local_130;

+                    }

+                    LOCK();

+                    uRam0000000000000268 = uRam0000000000000268 | 0x40000;

+                    UNLOCK();

+                    uRam000000000000026c = 3;

+                    uStack_78 = 0x41000;

+                    local_80 = 0x41000;

+                    local_70 = 0x7fffffffffffffff;

+                    ppuVar17 = local_240[0x54];

+                    CcInitializeCacheMap(ppuVar17,&local_80,1,&DAT_5);

+                    if (FppDiskAccountingEnabled != 0) {

+                      CcSetAdditionalCacheAttributesEx(ppuVar17,0x10);

+                    }

+                    lVar21 = param_1;

+                    FppSetupAllocationSupport(param_1,(longlong)pppuVar5);

+                    if (pppuVar5[0x58] == (undefined8 **)0x0) {

+                      ppuVar17 = (undefined8 **)FppOpenBitmapFile(lVar21,(short *)pppuVar5[0x59]);

+                      pppuVar5[0x58] = ppuVar17;

+                    }

+                    lVar21 = param_1;

+                    FppCheckDirtyBit(param_1,(longlong)pppuVar5);

+                    bVar6 = FppIsMediaWriteProtected(lVar21,param_2);

+                    if (bVar6) {

+                      LOCK();

+                      *(uint *)(pppuVar27 + 10) = *(uint *)(pppuVar27 + 10) | 0x100000;

+                      UNLOCK();

+                    }

+                    else {

+                      LOCK();

+                      *(uint *)(pppuVar27 + 10) = *(uint *)(pppuVar27 + 10) & 0xffefffff;

+                      UNLOCK();

+                    }

+                    pvVar30 = local_198;

+                    if (((*(uint *)(local_240 + 0x19) >> 0x14 & 1) == 0) &&

+                       (local_240[0x92] != (undefined8 **)0x0)) {

+                      LOCK();

+                      *(uint *)(local_240 + 0x19) = *(uint *)(local_240 + 0x19) & 0xffffbfff;

+                      UNLOCK();

+                    }

+                    else {

+                      LOCK();

+                      *(uint *)(local_240 + 0x19) = *(uint *)(local_240 + 0x19) | 0x4000;

+                      UNLOCK();

+                    }

+                    goto LAB_1;

+                  }

+                }

+                FppCheckDirtyBit(param_1,0x1a0);

+                uVar12 = (ulonglong)(uRam0000000000000268 >> 4) & 0xffffffffffffff01;

+                uRam0000000000000650 = (undefined1)uVar12;

+                bVar8 = FppIsMediaWriteProtected(uVar12,param_2);

+                if (bVar8) {

+                  LOCK();

+                  *(uint *)((longlong)local_208 + 200) =

+                       *(uint *)((longlong)local_208 + 200) | 0x100000;

+                  UNLOCK();

+                }

+                else {

+                  LOCK();

+                  *(uint *)((longlong)local_208 + 200) =

+                       *(uint *)((longlong)local_208 + 200) & 0xffefffff;

+                  UNLOCK();

+                }

+                if (((uRam0000000000000268 >> 0x14 & 1) == 0) && (lRam0000000000000630 != 0)) {

+                  LOCK();

+                  uRam0000000000000268 = uRam0000000000000268 & 0xffffbfff;

+                  UNLOCK();

+                }

+                else {

+                  LOCK();

+                  uRam0000000000000268 = uRam0000000000000268 | 0x4000;

+                  UNLOCK();

+                }

+                uVar12 = (ulonglong)(uRam0000000000000268 >> 0xe) & 0xffffffffffffff01;

+                uRam0000000000000651 = (undefined1)uVar12;

+                if (((ulonglong)local_210[6] & 0x100) != 0) {

+                  LOCK();

+                  uVar11 = uRam0000000000000268 | 0x800;

+                  UNLOCK();

+                  uVar12 = (ulonglong)uVar11;

+                  uVar28 = uRam0000000000000268 & 2;

+                  uRam0000000000000268 = uVar11;

+                  if (uVar28 != 0) {

+                    FppToggleMediaEjectDisable(uVar12,0x1a0,1);

+                  }

+                }

+                FppSqmVolumeInfo(uVar12,0x1a0);

+                uRam0000000000000638 = _DAT_6;

+                if (5 < DAT_7) {

+                  local_180 = 0;

+                  local_208 = (void *)0x0;

+                  ppvVar22 = &local_208;

+                  IoGetStackLimits(ppvVar22,&local_180);

+                  if ((ulonglong)((longlong)&local_180 - (longlong)local_208) < 0x800) {

+                    LOCK();

+                    _DAT_8 = _DAT_8 + 1;

+                    UNLOCK();

+                  }

+                  else {

+                    FppTelemetryMount(ppvVar22,0x1a0);

+                  }

+                }

+                bVar8 = true;

+                pvVar30 = *(void **)(lRam0000000000000270 + 0x1b8);

+                ObfReferenceObject(pvVar30);

+                ObfDereferenceObject(param_2);

+              }

+            }

+          }

+        }

+      }

+    }

+  }

+LAB_1:

+  if (local_200 != (char *)0x0) {

+    ExFreePoolWithTag(local_200,0x74627046);

+  }

+  if (local_238 != 0) {

+    CcUnpinData();

+    local_238 = 0;

+  }

+  if (local_1f8 != 0) {

+    CcUnpinData();

+    local_1f8 = 0;

+  }

+  if (lStack_150 != 0) {

+    CcUnpinData();

+    lStack_150 = 0;

+  }

+  if (local_1f0 != 0) {

+    CcUnpinData();

+    local_1f0 = 0;

+  }

+  if (local_1e8 != 0) {

+    CcUnpinData();

+    local_1e8 = 0;

+  }

+  if (local_1e0 != 0) {

+    CcUnpinData();

+    local_1e0 = 0;

+  }

+  if (local_218 != 0) {

+    ExFreePoolWithTag(local_218,0);

+  }

+  if (local_1c8 != (byte *)0x0) {

+    ExFreePoolWithTag(local_1c8,0);

+  }

+  if ((!bVar8) && (pvVar23 != (void *)0x0)) {

+    FppCheckForDismount(param_1,pvVar23,'\x01');

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

+  }

+  if (bVar32) {

+    *(uint *)(local_210 + 6) = *(uint *)(local_210 + 6) | 2;

+  }

+  ExReleaseResourceLite(&DAT_0);

+  if (pvVar30 != (void *)0x0) {

+    FsRtlNotifyVolumeEvent(pvVar30,6);

+    ObfDereferenceObject(pvVar30);

+  }

+  return unaff_RSI;

+}

+
```

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

```diff
--- NTOSKRNL.EXE::KeEnterCriticalRegion calling
+++ NTOSKRNL.EXE::KeEnterCriticalRegion calling
@@ -0,0 +1 @@
+EfsPostCreateCallback
```

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

```diff
--- NTOSKRNL.EXE::ExReleaseResourceLite calling
+++ NTOSKRNL.EXE::ExReleaseResourceLite calling
@@ -0,0 +1,2 @@
+EfsPostCreateCallback
+EfsPostCreateCallback$fin$0
```

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

```diff
--- NTOSKRNL.EXE::ExAcquireResourceSharedLite calling
+++ NTOSKRNL.EXE::KeEnterCriticalRegion calling
@@ -1,14 +1,2 @@
-FppAcquireFcbForLazyWrite
-FppAcquireFcbForReadAhead
-FppAcquireForCcFlush
-FppAcquireForMappedWrite
-FppAcquireSharedFcb
-FppAcquireSharedVcb
-FppAdjustAllCleanVolumeTimers
-FppAllocateDiskSpace
-FppCommonCreate
-FppCommonRead
-FppCommonWrite
-FppDeallocateDiskSpace
-FppDeferredCleanVolume
-FppDeferredFlush
+FppCloseWorker
+FppCoalescingCallback
@@ -21,4 +9,21 @@
-FppFlushAndCleanAllVolumes
-FppPostStackOverflowRead
-FppSearchRemainderOfDirectoryForCollisions
-FppSetRenameInfo
+FppFastUnlockSingle
+FppFsdCleanup
+FppFsdClose
+FppFsdCreate
+FppFsdDeviceControl
+FppFsdDirectoryControl
+FppFsdFileSystemControl
+FppFsdFlushBuffers
+FppFsdLockControl
+FppFsdPnp
+FppFsdQueryInformation
+FppFsdQueryVolumeInformation
+FppFsdRead
+FppFsdSetInformation
+FppFsdSetVolumeInformation
+FppFsdShutdown
+FppFsdWrite
+FppFspDispatch
+FppPostProcessEfsCreate
+FppPostProcessEfsCreate$fin$0
+NtOfsRegisterCallBacks
```
