# CVE-2026-119832 — fvevol.sys patch diff

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

## `FveVerifyIceCrypto`  (modified)

```diff
--- FveVerifyIceCrypto
+++ FveVerifyIceCrypto
@@ -1,52 +1,1105 @@
 

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

+/* WARNING: Type propagation algorithm not settling */

 

-byte FveVerifyIceCrypto(longlong *param_1,char param_2,undefined2 param_3,uint param_4,uint param_5,

-                       uint param_6,ulonglong ******param_7,ulonglong ******param_8,uint *param_9)

+byte FveVerifyIceCrypto(longlong *param_1,char param_2,undefined2 param_3,uint param_4,int param_5,

+                       int param_6,ulonglong *******param_7,ulonglong *******param_8,uint *param_9)

 

 {

-  byte in_AL;

-  char cVar1;

-  undefined8 uVar2;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  uint unaff_ESI;

-  ulonglong *unaff_RDI;

-  undefined4 unaff_R13D;

-  undefined8 unaff_R14;

+  longlong *plVar1;

+  uint uVar2;

+  undefined8 uVar3;

+  code *pcVar4;

+  char cVar5;

+  uint uVar6;

+  uint uVar7;

+  uint uVar8;

+  uint extraout_EAX;

+  uint uVar9;

+  uint extraout_EAX_00;

+  uint extraout_EAX_01;

+  uint extraout_EAX_02;

+  int *piVar10;

+  longlong *plVar11;

+  undefined8 *puVar12;

+  longlong lVar13;

+  longlong lVar14;

+  ulonglong ************ppppppppppppuVar15;

+  ulonglong uVar16;

+  short sVar17;

+  undefined8 uVar18;

+  ulonglong uVar19;

+  undefined2 uVar20;

+  ulonglong ***********pppppppppppuVar21;

+  undefined1 *puVar22;

+  undefined1 *puVar23;

+  undefined1 *puVar24;

+  undefined1 *puVar25;

+  byte bVar26;

+  ushort uVar27;

+  int iVar28;

+  ulonglong ************ppppppppppppuVar29;

+  byte bVar30;

+  ulonglong ************ppppppppppppuVar31;

+  void *_Dst;

+  ulonglong ************ppppppppppppuVar32;

+  ulonglong ************ppppppppppppuVar33;

+  longlong lVar34;

+  longlong *plVar35;

+  longlong *plVar36;

+  ulonglong *******pppppppuVar37;

+  undefined1 auStack_2c8 [8];

+  undefined1 auStack_2c0 [88];

+  byte local_268;

+  ushort local_260 [8];

+  ulonglong ************local_250;

+  uint local_248;

+  undefined4 uStack_244;

+  uint local_240;

+  uint local_23c;

+  longlong *local_238;

+  undefined8 local_230;

+  ulonglong ************local_228;

+  longlong local_220;

+  longlong local_218;

+  longlong local_210;

+  longlong *local_208;

+  longlong local_200;

+  ulonglong ************local_1f8;

+  ulonglong ***********local_1f0;

+  ulonglong ***********local_1e8;

+  ulonglong ************local_1e0;

+  longlong local_1d8;

+  ulonglong local_1d0;

+  ulonglong ***********local_1c8;

+  BCRYPT_ALG_HANDLE local_1c0;

+  longlong local_1b8;

+  uint *local_1b0;

+  longlong local_1a8;

+  undefined *local_1a0;

+  undefined8 uStack_198;

+  undefined8 local_190;

+  undefined1 local_188 [32];

+  undefined4 *local_168;

+  undefined8 local_160;

+  uint *local_158;

+  undefined8 local_150;

+  ulonglong ************local_148;

+  undefined8 local_140;

+  uint *local_138;

+  undefined8 local_130;

+  undefined1 *local_128;

+  undefined8 local_120;

+  undefined8 local_118;

+  undefined8 local_110;

+  uint *local_108;

+  undefined8 local_100;

+  undefined1 *local_f8;

+  undefined8 local_f0;

+  ulonglong *************local_e8;

+  undefined8 local_e0;

+  longlong *local_d8;

+  undefined8 local_d0;

+  UCHAR local_88 [64];

+  ulonglong local_48;

   

-  if (unaff_ESI < DAT_0) {

-    cVar1 = _tlgKeywordOn(0x14003b040,0x400000000000);

-    in_AL = 0;

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

-      *(undefined8 *)(unaff_RBP + -0x19) = 0xe;

-      *(char **)(unaff_RBP + -0x21) = "IceKeyCreated";

-      if (*(longlong *)(unaff_RBX + 0x11d8) == 0) {

-        if (*(longlong *)(unaff_RBX + 0x11e0) != 0) {

-          unaff_R13D = *(undefined4 *)(*(longlong *)(unaff_RBX + 0x11e0) + 0x10);

-        }

+  puVar22 = auStack_2c8;

+  puVar25 = auStack_2c8;

+  puVar23 = auStack_2c8;

+  puVar24 = auStack_2c8;

+  local_48 = __security_cookie ^ (ulonglong)auStack_2c8;

+  plVar11 = (longlong *)0x0;

+  uVar7 = 0;

+  local_248 = CONCAT22(local_248._2_2_,param_3);

+  local_1b0 = param_9;

+  local_268 = 0;

+  local_23c = param_4;

+  local_238 = param_1;

+  memset(local_88,0,0x40);

+  uVar2 = *(uint *)((longlong)param_1 + 0x49c);

+  pppppppuVar37 = (ulonglong *******)(ulonglong)uVar2;

+  local_1f8 = (ulonglong ************)0x0;

+  plVar35 = (longlong *)0x0;

+  local_1f0 = (ulonglong ***********)0x0;

+  local_250 = (ulonglong ************)0x0;

+  local_1e8 = (ulonglong ***********)0x0;

+  local_1b8 = param_1[0x23b];

+  local_1a8 = param_1[0x23c];

+  local_1c8 = (ulonglong ***********)0x0;

+  local_220 = 0;

+  local_1c0 = (BCRYPT_ALG_HANDLE)0x0;

+  uVar6 = *(uint *)(param_1[1] + 0x2510);

+  local_230._0_4_ = (uint)local_230._2_2_ << 0x10;

+  local_240 = uVar6 & 2;

+  uStack_244 = (uint)uStack_244._2_2_ << 0x10;

+  local_260[0] = 0;

+  local_208 = (longlong *)0x0;

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

+    local_230._4_4_ = CONCAT31(local_230._5_3_,(byte)uVar6 >> 5);

+    bVar26 = (byte)uVar6 >> 6;

+  }

+  else {

+    local_230._4_4_ = uVar6 >> 9;

+    bVar26 = (byte)(uVar6 >> 10);

+  }

+  local_230._4_4_ = local_230._4_4_ & 0xffffff01;

+  ppppppppppppuVar33 = (ulonglong ************)0x100;

+  memset(local_188,0,0x100);

+  local_118 = (undefined4 *)CONCAT44(uVar2,(undefined4)local_118);

+  local_1a0 = (undefined *)0x0;

+  uStack_198 = 0;

+  local_190 = 0;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    ppppppppppppuVar33 = (ulonglong ************)&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids;

+    WPP_SF_(WPP_GLOBAL_Control[3],0xf3,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+  }

+  bVar30 = 0;

+  if ((uVar6 & 0x1000) != 0) {

+    bVar30 = 1;

+    puVar24 = auStack_2c8;

+    plVar35 = plVar11;

+    plVar36 = local_238;

+    goto LAB_0;

+  }

+  uVar6 = FveIceAlgorithmBitSizeToKeySize(param_5,param_6);

+  uVar7 = RtlULongToUShort(uVar6,local_260);

+  plVar36 = local_238;

+  uVar27 = local_260[0];

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

+    uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+    plVar36 = local_238;

+    ppppppppppppuVar33 = (ulonglong ************)(ulonglong)local_260[0];

+    uVar6 = 0;

+    uStack_244 = CONCAT22(uStack_244._2_2_,local_260[0]);

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

+      if ((((local_1a8 == 0) || (local_1b0 == (uint *)0x0)) ||

+          ((0xfff < (ushort)((short)local_248 + 0x8000U) ||

+           ((uVar2 == 0 || ((uVar2 & uVar2 - 1) != 0)))))) ||

+         ((0x10000 < uVar2 ||

+          (((int)(0x10000U % (ulonglong)uVar2) != 0 ||

+           ((ushort)((short)(0x10000U % (ulonglong)uVar2) + 0x40U) < local_260[0])))))) {

+        uVar7 = 0xc000000d;

+        ppppppppppppuVar32 = local_250;

+        goto LAB_1;

+      }

+      if (*(uint *)(local_1a8 + 0xc) != 0) {

+        ppppppppppppuVar33 = (ulonglong ************)(ulonglong)local_23c;

+        piVar10 = (int *)(local_1a8 + 0x24);

+        do {

+          if (((piVar10[-1] == local_23c) && (*piVar10 == param_5)) && (piVar10[1] == param_6))

+          goto LAB_2;

+          uVar6 = uVar6 + 1;

+          piVar10 = piVar10 + 8;

+        } while (uVar6 < *(uint *)(local_1a8 + 0xc));

+      }

+    }

+    else {

+      if (((((local_1b8 == 0) || (local_1b0 == (uint *)0x0)) ||

+           ((0xfff < (ushort)((short)local_248 + 0x8000U) ||

+            ((uVar2 == 0 || ((uVar2 & uVar2 - 1) != 0)))))) || (0x10000 < uVar2)) ||

+         (((int)(0x10000U % (ulonglong)pppppppuVar37) != 0 ||

+          ((ushort)((short)(0x10000U % (ulonglong)pppppppuVar37) + 0x40U) < local_260[0])))) {

+        uVar7 = 0xc000000d;

+        bVar30 = 0;

+        goto LAB_0;

+      }

+      if (*(uint *)(local_1b8 + 0xc) != 0) {

+        ppppppppppppuVar33 = (ulonglong ************)(ulonglong)*(uint *)(local_1b8 + 0x14);

+        do {

+          lVar13 = (ulonglong)(*(uint *)(local_1b8 + 0x14) * uVar6 + *(int *)(local_1b8 + 0x10)) +

+                   local_1b8;

+          if (((*(uint *)(lVar13 + 8) == local_23c) && (*(int *)(lVar13 + 0xc) == param_5)) &&

+             (*(int *)(lVar13 + 0x10) == param_6)) goto LAB_2;

+          uVar6 = uVar6 + 1;

+        } while (uVar6 < *(uint *)(local_1b8 + 0xc));

+      }

+    }

+    uVar7 = 0xc0000225;

+    bVar30 = 0;

+    puVar24 = auStack_2c8;

+    goto LAB_0;

+  }

+LAB_3:

+  *(undefined8 *)(puVar25 + -8) = 0x140052cae;

+  uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+  if (((int)uVar16 != 0) && (local_1c8 != (ulonglong ************)0x0)) {

+    *(undefined8 *)(puVar25 + -8) = 0x140052cc3;

+    FveDatumFree((ulonglong *)local_1c8);

+    local_1c8 = (ulonglong ***********)0x0;

+  }

+  if (local_220 != 0) {

+    *(undefined8 *)(puVar25 + -8) = 0x140052cdf;

+    ExFreePoolWithTag(local_220,0x656e6f4e);

+    local_220 = 0;

+  }

+  if (local_1c0 != (BCRYPT_ALG_HANDLE)0x0) {

+    *(undefined8 *)(puVar25 + -8) = 0x140052cfd;

+    BCryptCloseAlgorithmProvider(local_1c0,0);

+    local_1c0 = (BCRYPT_ALG_HANDLE)0x0;

+  }

+  if ((int)uVar7 < 0) {

+    bVar30 = 0;

+  }

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

+    *(byte *)((longlong)plVar11 + 0x22) = bVar30;

+    *(uint *)((longlong)plVar11 + 0x24) = uVar7;

+  }

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

+    *local_1b0 = uVar7;

+  }

+  if (bVar30 == 0) {

+    lVar13 = *plVar36;

+    local_190 = 0;

+    local_1a0 = &FVE_ICE_HW_CRYPTO_VERIFY_FAILED;

+    uVar18 = 0;

+    uStack_198 = CONCAT44(uVar7,(undefined4)uStack_198);

+    *(undefined8 *)(puVar25 + -8) = 0x140052dea;

+    FveLogEventEx(lVar13,(longlong *)&local_1a0,'\0','\x01');

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

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

+       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      uVar6 = local_248 & 0xffff;

+      uVar3 = WPP_GLOBAL_Control[3];

+      *(uint *)(puVar25 + 0x48) = uVar7;

+      *(uint *)(puVar25 + 0x40) = uVar2;

+      *(uint *)(puVar25 + 0x38) = local_248 & 0xffff;

+      *(uint *)(puVar25 + 0x30) = (uint)uVar27;

+      *(int *)(puVar25 + 0x28) = param_6;

+      *(int *)(puVar25 + 0x20) = param_5;

+      *(undefined8 *)(puVar25 + -8) = 0x140052e49;

+      WPP_SF_LLLLDLd(uVar3,(ulonglong)uVar27,uVar18,local_23c);

+      goto LAB_4;

+    }

+  }

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

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

+          (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    uVar6 = local_248 & 0xffff;

+    *(uint *)(puVar25 + 0x40) = uVar2;

+    *(uint *)(puVar25 + 0x38) = local_248 & 0xffff;

+    *(uint *)(puVar25 + 0x30) = (uint)uVar27;

+    uVar18 = WPP_GLOBAL_Control[3];

+    *(int *)(puVar25 + 0x28) = param_6;

+    *(int *)(puVar25 + 0x20) = param_5;

+    *(undefined8 *)(puVar25 + -8) = 0x140052d9b;

+    WPP_SF_LLLLDL(uVar18,WPP_GLOBAL_Control,ppppppppppppuVar33,local_23c);

+    goto LAB_4;

+  }

+  uVar6 = local_248 & 0xffff;

+LAB_4:

+  if (4 < DAT_5) {

+    *(undefined8 *)(puVar25 + -8) = 0x140052e81;

+    cVar5 = _tlgKeywordOn(0x14003b040,0x400000000000);

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

+      local_230._4_4_ = (uint)bVar30;

+      local_168 = (undefined4 *)((longlong)&local_230 + 4);

+      local_158 = &local_240;

+      local_160 = 4;

+      local_150 = 4;

+      if (local_1b8 == 0) {

+        local_230._0_4_ = *(uint *)(local_1a8 + 0x10);

       }

       else {

-        unaff_R13D = *(undefined4 *)(*(longlong *)(unaff_RBX + 0x11d8) + 0x18);

+        local_230._0_4_ = *(uint *)(local_1b8 + 0x18);

       }

-      *(undefined4 *)(unaff_RBP + -0x61) = unaff_R13D;

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

-      *(longlong *)(unaff_RBP + -0x11) = unaff_RBP + -0x61;

-      in_AL = _tlgWriteTransfer_EtwWriteTransfer

-                        (0x14003b040,&DAT_1,0,0,(int)unaff_R14,

-                         (undefined8 *)(unaff_RBP + -0x41));

-    }

-  }

-  if (unaff_RDI != (ulonglong *)0x0) {

-    uVar2 = FveDatumFree(unaff_RDI);

-    in_AL = (byte)uVar2;

+      local_148 = (ulonglong ************)&local_230;

+      local_140 = 4;

+      local_138 = &local_23c;

+      local_130 = 4;

+      local_128 = puVar25 + 0x68;

+      local_118 = &uStack_244;

+      local_248 = (uint)uVar27;

+      local_108 = &local_248;

+      *(uint *)(puVar25 + 0x70) = uVar6;

+      local_f8 = puVar25 + 0x70;

+      local_e8 = &local_228;

+      local_d8 = &local_218;

+      *(undefined1 **)(puVar25 + 0x28) = local_188;

+      *(undefined4 *)(puVar25 + 0x20) = 0xc;

+      *(int *)(puVar25 + 0x68) = param_5;

+      local_120 = 4;

+      uStack_244 = param_6;

+      local_110 = 4;

+      local_100 = 4;

+      local_f0 = 4;

+      local_228 = (ulonglong ************)CONCAT44(local_228._4_4_,uVar2);

+      local_e0 = 4;

+      local_218 = 0x1000000;

+      local_d0 = 8;

+      *(undefined8 *)(puVar25 + -8) = 0x140052fd0;

+      local_240 = uVar7;

+      _tlgWriteTransfer_EtwWriteTransfer

+                (0x14003b040,&DAT_6,0,0,*(undefined4 *)(puVar25 + 0x20),

+                 *(undefined8 **)(puVar25 + 0x28));

+    }

   }

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

-      (in_AL = (byte)*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c),

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

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    in_AL = WPP_SF_(WPP_GLOBAL_Control[3],0xda,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

-  }

-  return in_AL;

+    uVar18 = WPP_GLOBAL_Control[3];

+    *(uint *)(puVar25 + 0x20) = uVar7;

+    *(undefined8 *)(puVar25 + -8) = 0x14005300e;

+    WPP_SF_Ld(uVar18,0xf9,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,(uint)bVar30);

+  }

+  *(undefined8 *)(puVar25 + -8) = 0x140053020;

+  return bVar30;

+LAB_2:

+  ppppppppppppuVar33 = (ulonglong ************)(ulonglong)local_23c;

+  plVar1 = local_238 + 0x240;

+  plVar35 = (longlong *)*plVar1;

+  if (plVar35 != plVar1) {

+    do {

+      if (((*(uint *)((longlong)plVar35 + 0x14) == uVar2) && ((short)plVar35[4] == (short)local_248)

+          ) && (((int)plVar35[3] == param_5 &&

+                ((*(uint *)(plVar35 + 2) == local_23c &&

+                 (local_208 = plVar35, *(int *)((longlong)plVar35 + 0x1c) == param_6)))))) break;

+      plVar35 = (longlong *)*plVar35;

+      local_208 = (longlong *)0x0;

+    } while (plVar35 != plVar1);

+    plVar11 = local_208;

+    if ((local_208 != (longlong *)0x0) && (-1 < *(int *)((longlong)local_208 + 0x24))) {

+      puVar24 = auStack_2c8;

+      plVar35 = local_208;

+      bVar30 = *(byte *)((longlong)local_208 + 0x22);

+      goto LAB_0;

+    }

+  }

+  ppppppppppppuVar32 = (ulonglong ************)0x10000;

+  plVar35 = plVar11;

+  if ((param_8 == (ulonglong *******)0x0) || ((local_230._4_1_ == '\0' && ((bVar26 & 1) == 0)))) {

+    bVar30 = 1;

+    puVar24 = auStack_2c8;

+  }

+  else if ((param_8 < pppppppuVar37) ||

+          ((param_8 < (ulonglong *******)0x10000 &&

+           (ppppppppppppuVar32 = (ulonglong ************)((ulonglong)param_8 & 0xffffffff),

+           (int)(((ulonglong)param_8 & 0xffffffff) % (ulonglong)uVar2) != 0)))) {

+    uVar7 = 0xc000000d;

+    puVar24 = auStack_2c8;

+    bVar30 = local_268;

+  }

+  else {

+    puVar23 = auStack_2c8;

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

+      ppppppppppppuVar33 = (ulonglong ************)0x30455646;

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

+      local_208 = plVar11;

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

+        uVar7 = 0xc000009a;

+        bVar30 = 0;

+        puVar24 = auStack_2c8;

+        plVar35 = plVar11;

+        goto LAB_0;

+      }

+      *plVar11 = 0;

+      plVar11[1] = 0;

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

+      *(undefined2 *)((longlong)plVar11 + 0x26) = 0;

+      *(short *)(plVar11 + 4) = (short)local_248;

+      *(int *)(plVar11 + 3) = param_5;

+      *(int *)((longlong)plVar11 + 0x1c) = param_6;

+      *(uint *)((longlong)plVar11 + 0x14) = uVar2;

+      *(uint *)(plVar11 + 2) = local_23c;

+      puVar12 = (undefined8 *)plVar36[0x241];

+      if ((longlong *)*puVar12 != plVar1) {

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

+        puVar12 = (undefined8 *)(*pcVar4)(3);

+        puVar22 = auStack_2c0;

+      }

+      *plVar11 = (longlong)plVar1;

+      plVar11[1] = (longlong)puVar12;

+      *puVar12 = plVar11;

+      plVar36[0x241] = (longlong)plVar11;

+      puVar23 = puVar22;

+    }

+    uVar6 = (uint)ppppppppppppuVar32;

+    *(undefined8 *)(puVar23 + -8) = 0x140051f87;

+    local_1e0 = ppppppppppppuVar32;

+    uVar16 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

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

+      *(undefined8 *)(puVar23 + -8) = 0x140051fd7;

+      local_228 = (ulonglong ************)ExAllocatePool2(0x40,ppppppppppppuVar32,0x30455646);

+      *(undefined8 *)(puVar23 + -8) = 0x140051ff3;

+      lVar13 = ExAllocatePool2(0x40,ppppppppppppuVar32,0x30455646);

+      uVar18 = 0x40;

+    }

+    else {

+      *(undefined8 *)(puVar23 + -8) = 0x140051fa1;

+      local_228 = (ulonglong ************)ExAllocatePool2(0x48,ppppppppppppuVar32,0x30455646);

+      *(undefined8 *)(puVar23 + -8) = 0x140051fbb;

+      lVar13 = ExAllocatePool2(0x48,ppppppppppppuVar32,0x30455646);

+      uVar18 = 0x48;

+    }

+    *(longlong *)(puVar23 + 0x70) = lVar13;

+    *(undefined8 *)(puVar23 + -8) = 0x140052015;

+    local_200 = ExAllocatePool2(uVar18,ppppppppppppuVar32);

+    ppppppppppppuVar31 = local_228;

+    cVar5 = *(char *)(plVar36[0xd] + 0x4c);

+    *(undefined8 *)(puVar23 + -8) = 0x140052039;

+    lVar14 = IoAllocateIrpEx(0xffffffffffffffff,cVar5 + '\x01');

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

+    *(undefined8 *)(puVar23 + -8) = 0x14005205b;

+    local_210 = IoAllocateMdl(ppppppppppppuVar31,ppppppppppppuVar32);

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

+    *(undefined8 *)(puVar23 + -8) = 0x14005207e;

+    uVar18 = IoAllocateMdl(lVar13,ppppppppppppuVar32);

+    *(undefined8 *)(puVar23 + 0x68) = uVar18;

+    ppppppppppppuVar33 = (ulonglong ************)0x0;

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

+    *(undefined8 *)(puVar23 + -8) = 0x1400520a6;

+    local_1d8 = IoAllocateMdl(0,uVar6 + 0x1000);

+    lVar34 = local_210;

+    if ((((((ppppppppppppuVar31 == (ulonglong ************)0x0) || (lVar13 == 0)) ||

+          (local_200 == 0)) || ((lVar14 == 0 || (local_210 == 0)))) ||

+        (lVar13 = *(longlong *)(puVar23 + 0x68), lVar13 == 0)) || (local_1d8 == 0)) {

+      uVar7 = 0xc000009a;

+      lVar13 = *(longlong *)(puVar23 + 0x70);

+      lVar34 = *(longlong *)(puVar23 + 0x68);

+      puVar23[0x60] = 0;

+      uVar8 = 0xc000009a;

+      local_228 = ppppppppppppuVar31;

+      local_208 = plVar11;

+      if (ppppppppppppuVar31 != (ulonglong ************)0x0) goto LAB_7;

+      ppppppppppppuVar32 = *(ulonglong *************)(puVar23 + 0x78);

+    }

+    else {

+      *(undefined8 *)(puVar23 + -8) = 0x140052106;

+      MmBuildMdlForNonPagedPool(local_210);

+      *(undefined8 *)(puVar23 + -8) = 0x140052115;

+      MmBuildMdlForNonPagedPool(lVar13);

+      *(undefined8 *)(puVar23 + -8) = 0x14005212b;

+      MmMdlPageContentsState(lVar34,1);

+      *(undefined8 *)(puVar23 + -8) = 0x14005213c;

+      MmMdlPageContentsState(lVar13,1);

+      ppppppppppppuVar33 = (ulonglong ************)0x0;

+      *(undefined8 *)(puVar23 + -8) = 0x140052159;

+      uVar8 = BCryptOpenAlgorithmProvider(&local_1c0,L"RNG",(LPCWSTR)0x0,1);

+      if ((int)uVar8 < 0) {

+LAB_8:

+        lVar13 = *(longlong *)(puVar23 + 0x70);

+LAB_9:

+        lVar34 = *(longlong *)(puVar23 + 0x68);

+LAB_7:

+        uVar7 = uVar8;

+        ppppppppppppuVar32 = *(ulonglong *************)(puVar23 + 0x78);

+      }

+      else {

+        ppppppppppppuVar33 = (ulonglong ************)0x40;

+        *(undefined8 *)(puVar23 + -8) = 0x140052181;

+        uVar8 = BCryptGenRandom(local_1c0,local_88,0x40,0);

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

+        *(undefined8 *)(puVar23 + -8) = 0x140052195;

+        uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+        sVar17 = (short)local_248;

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

+          *(undefined8 *)(puVar23 + -8) = 0x1400521a6;

+          uVar18 = FveMapHwWrappedToNonHwWrappedKeyType((short)local_248,(undefined2 *)&local_230);

+          sVar17 = (short)local_230;

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

+            sVar17 = (short)local_248;

+          }

+        }

+        ppppppppppppuVar33 = (ulonglong ************)(ulonglong)(ushort)uStack_244;

+        *(undefined8 *)(puVar23 + -8) = 0x1400521c6;

+        uVar8 = FveDatumKeyCreate(sVar17,local_88,(ushort)uStack_244,&local_1f0);

+        if ((int)uVar8 < 0) {

+          local_1f8 = (ulonglong ************)local_1f0;

+          goto LAB_8;

+        }

+        *(undefined8 *)(puVar23 + -8) = 0x1400521d5;

+        uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+        ppppppppppppuVar33 = &local_1e8;

+        local_1f8 = (ulonglong ************)local_1f0;

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

+          *(undefined8 *)(puVar23 + -8) = 0x1400521f0;

+          uVar16 = FveFvekDataFromFvekDatum(uVar2,(ulonglong *)local_1f0,ppppppppppppuVar33);

+          uVar7 = (uint)uVar16;

+        }

+        else {

+          *(undefined8 *)(puVar23 + -8) = 0x1400521f7;

+          uVar16 = FveFvekDataFromFvekDatum2(uVar2,(ulonglong *)local_1f0,ppppppppppppuVar33);

+          uVar7 = (uint)uVar16;

+        }

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

+          *(ulonglong ************)(puVar23 + 0x78) = local_1e8;

+          local_148 = (ulonglong ************)local_1e8;

+          *(undefined8 *)(puVar23 + -8) = 0x140052216;

+          uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+          pppppppppppuVar21 = (ulonglong ***********)(ulonglong ************)0x0;

+          plVar11 = local_238;

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

+            *(undefined8 *)(puVar23 + -8) = 0x140052226;

+            cVar5 = FveIsHwWrappedKeyType((short)local_248);

+            plVar11 = local_238;

+            pppppppppppuVar21 = (ulonglong ***********)local_1f8;

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

+              *(undefined8 *)(puVar23 + -8) = 0x140052240;

+              ppppppppppppuVar33 = local_1f8;

+              uVar8 = FveIceHwWrapFvek(local_238,1,(ushort *)local_1f8,&local_1c8);

+              pppppppppppuVar21 = local_1c8;

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

+            }

+          }

+          *(undefined8 *)(puVar23 + -8) = 0x140052262;

+          uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+          ppppppppppppuVar33 = (ulonglong ************)(ulonglong)local_23c;

+          *(longlong **)(puVar23 + 0x28) = &local_220;

+          *(int *)(puVar23 + 0x20) = param_6;

+          ppppppppppppuVar31 = local_1f8;

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

+            ppppppppppppuVar31 = (ulonglong ************)pppppppppppuVar21;

+          }

+          *(undefined8 *)(puVar23 + -8) = 0x140052293;

+          uVar8 = FveCreateIceKey((longlong)plVar11,(ulonglong *)ppppppppppppuVar31,

+                                  ppppppppppppuVar33,param_5,*(int *)(puVar23 + 0x20),

+                                  *(undefined8 **)(puVar23 + 0x28));

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

+          uVar7 = uVar2;

+          ppppppppppppuVar31 = local_1e0;

+          if (local_230._4_1_ == '\0') {

+            if ((bVar26 & 1) != 0) goto LAB_10;

+LAB_11:

+            puVar23[0x60] = 1;

+            goto LAB_8;

+          }

+          for (; lVar34 = local_210, local_230._0_4_ = uVar7, local_210 = lVar34,

+              (uint)local_230 <= uVar6; uVar7 = uVar7 + uVar2) {

+            local_1e8 = (ulonglong ***********)0x0;

+            ppppppppppppuVar29 = ppppppppppppuVar31;

+            uVar7 = (uint)local_230;

+            for (; ppppppppppppuVar31 <= param_8;

+                ppppppppppppuVar31 =

+                     (ulonglong ************)((longlong)local_1e8 + (longlong)ppppppppppppuVar31)) {

+              uVar16 = 0;

+              ppppppppppppuVar29 = (ulonglong ************)((longlong)param_7 + (longlong)local_1e8)

+              ;

+              local_230._0_4_ = uVar7;

+              if (ppppppppppppuVar29 < local_1e8) {

+LAB_12:

+                uVar8 = 0xc0000095;

+                goto LAB_8;

+              }

+              if (uVar6 != 0) {

+                do {

+                  ppppppppppppuVar31 =

+                       (ulonglong ************)(uVar16 + (longlong)ppppppppppppuVar29);

+                  ppppppppppppuVar33 = local_228;

+                  if (ppppppppppppuVar31 < ppppppppppppuVar29) goto LAB_12;

+                  puVar12 = (undefined8 *)(uVar16 + (longlong)local_228);

+                  uVar8 = (int)uVar16 + uVar2;

+                  uVar16 = (ulonglong)uVar8;

+                  for (uVar19 = (ulonglong)(uVar2 >> 3); uVar19 != 0; uVar19 = uVar19 - 1) {

+                    *puVar12 = ppppppppppppuVar31;

+                    puVar12 = puVar12 + 1;

+                  }

+                  plVar11 = local_238;

+                } while (uVar8 < uVar6);

+              }

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

+              *(longlong *)(puVar23 + 0x30) = local_200;

+              *(ulonglong *************)(puVar23 + 0x28) = local_228;

+              *(uint *)(puVar23 + 0x20) = uVar6;

+              *(undefined8 *)(puVar23 + -8) = 0x140052349;

+              uVar8 = FveFilteredEncrypt(3,(longlong)local_188,ppppppppppppuVar29,-1,

+                                         *(int *)(puVar23 + 0x20),*(longlong *)(puVar23 + 0x28),

+                                         *(longlong *)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38)

+                                        );

+              ppppppppppppuVar33 = (ulonglong ************)0x0;

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

+              uVar8 = 0;

+              if (uVar6 != 0) {

+                do {

+                  ppppppppppppuVar33 = (ulonglong ************)0x0;

+                  local_230._4_4_ = uVar8 + uVar7;

+                  if (uVar6 < local_230._4_4_) {

+                    uVar7 = uVar6 - uVar8;

+                  }

+                  local_1d0 = (ulonglong)uVar8;

+                  ppppppppppppuVar31 =

+                       (ulonglong ************)(local_1d0 + (longlong)ppppppppppppuVar29);

+                  if (ppppppppppppuVar31 < ppppppppppppuVar29) goto LAB_12;

+                  ppppppppppppuVar33 = local_228;

+                  lVar13 = local_210;

+                  if (local_240 != 0) {

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

+                    *(ulonglong *)(puVar23 + 0x30) = *(longlong *)(puVar23 + 0x70) + local_1d0;

+                    *(undefined **)(puVar23 + 0x28) = (undefined *)(local_1d0 + (longlong)local_228)

+                    ;

+                    *(uint *)(puVar23 + 0x20) = uVar7;

+                    *(undefined8 *)(puVar23 + -8) = 0x1400523c1;

+                    ppppppppppppuVar33 = ppppppppppppuVar31;

+                    uVar8 = FveFilteredEncrypt(3,(longlong)local_188,ppppppppppppuVar31,-1,

+                                               *(int *)(puVar23 + 0x20),

+                                               *(longlong *)(puVar23 + 0x28),

+                                               *(longlong *)(puVar23 + 0x30),

+                                               *(longlong *)(puVar23 + 0x38));

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

+                    ppppppppppppuVar33 = *(ulonglong *************)(puVar23 + 0x70);

+                    lVar13 = *(longlong *)(puVar23 + 0x68);

+                  }

+                  lVar34 = local_1d8;

+                  *(undefined8 *)(puVar23 + -8) = 0x1400523fb;

+                  IoBuildPartialMdl(lVar13,local_1d8,

+                                    (undefined *)(local_1d0 + (longlong)ppppppppppppuVar33),uVar7);

+                  plVar11 = local_238;

+                  puVar23[0x50] = 0;

+                  *(undefined4 *)(puVar23 + 0x48) = 0;

+                  *(undefined4 *)(puVar23 + 0x40) = 0;

+                  *(longlong *)(puVar23 + 0x38) = lVar14;

+                  *(undefined8 *)(puVar23 + 0x30) = 0;

+                  ppppppppppppuVar33 = (ulonglong ************)0x2;

+                  *(longlong *)(puVar23 + 0x28) = lVar34;

+                  *(uint *)(puVar23 + 0x20) = uVar7;

+                  *(undefined8 *)(puVar23 + -8) = 0x140052438;

+                  ppppppppppppuVar31 =

+                       (ulonglong ************)

+                       FveInitPreallocatedIrp

+                                 ((longlong)local_238,4,2,(ulonglong)ppppppppppppuVar31,

+                                  *(undefined4 *)(puVar23 + 0x20),*(undefined8 *)(puVar23 + 0x28),

+                                  *(void **)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38),

+                                  *(undefined4 *)(puVar23 + 0x40),*(int *)(puVar23 + 0x48),

+                                  puVar23[0x50]);

+                  uVar8 = extraout_EAX;

+                  if ((int)extraout_EAX < 0) goto LAB_8;

+                  if (local_240 == 0) {

+                    *(undefined8 *)(puVar23 + -8) = 0x14005244e;

+                    uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline

+                                       ();

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

+                      ppppppppppppuVar31 =

+                           (ulonglong ************)

+                           ((ulonglong)ppppppppppppuVar31 /

+                           (ulonglong)*(uint *)((longlong)plVar11 + 0x49c));

+                      *(undefined8 *)(puVar23 + -8) = 0x140052470;

+                      uVar8 = FveIceSetIrpExtension(lVar14,local_220,ppppppppppppuVar31);

+                    }

+                    else {

+                      *(undefined8 *)(puVar23 + -8) = 0x140052484;

+                      uVar18 = FveIceSetIrpExtensionSteelix

+                                         (lVar14,local_220,(ulonglong)ppppppppppppuVar31,

+                                          (longlong)plVar11);

+                      uVar8 = (uint)uVar18;

+                    }

+                    ppppppppppppuVar33 = ppppppppppppuVar31;

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

+                  }

+                  *(char *)(lVar14 + 0x43) = *(char *)(lVar14 + 0x43) + -1;

+                  *(longlong *)(lVar14 + 0xb8) = *(longlong *)(lVar14 + 0xb8) + -0x48;

+                  lVar13 = plVar11[0xd];

+                  *(undefined8 *)(puVar23 + -8) = 0x1400524ab;

+                  IoForwardIrpSynchronously(lVar13);

+                  uVar8 = *(uint *)(lVar14 + 0x30);

+                  ppppppppppppuVar33 = (ulonglong ************)0x0;

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

+                  uVar7 = (uint)local_230;

+                  uVar8 = local_230._4_4_;

+                } while (local_230._4_4_ < uVar6);

+              }

+              if (local_240 == 0) {

+                *(undefined8 *)(puVar23 + -8) = 0x1400524f1;

+                uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline

+                                   ();

+                ppppppppppppuVar33 = (ulonglong ************)0x0;

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

+                  *(undefined8 *)(puVar23 + -8) = 0x140052502;

+                  uVar8 = FveIceSetIrpExtension(lVar14,0,0);

+                }

+                else {

+                  *(undefined8 *)(puVar23 + -8) = 0x14005250c;

+                  uVar18 = FveIceSetIrpExtensionSteelix(lVar14,0,0,(longlong)plVar11);

+                  uVar8 = (uint)uVar18;

+                }

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

+                _Dst = *(void **)(puVar23 + 0x70);

+              }

+              else {

+                _Dst = *(void **)(puVar23 + 0x70);

+                *(undefined8 *)(puVar23 + -8) = 0x1400524e8;

+                memset(_Dst,0,(size_t)local_1e0);

+              }

+              *(undefined4 *)(puVar23 + 0x40) = 0;

+              *(longlong *)(puVar23 + 0x38) = lVar14;

+              *(undefined8 *)(puVar23 + 0x28) = *(undefined8 *)(puVar23 + 0x68);

+              ppppppppppppuVar33 = (ulonglong ************)0x2;

+              *(uint *)(puVar23 + 0x20) = uVar6;

+              *(undefined8 *)(puVar23 + -8) = 0x14005254a;

+              uVar8 = FveSendPreallocatedIrpEx

+                                ((longlong)local_238,3,2,(ulonglong)ppppppppppppuVar29,

+                                 *(uint *)(puVar23 + 0x20),*(undefined8 *)(puVar23 + 0x28),

+                                 *(undefined8 *)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38),

+                                 *(int *)(puVar23 + 0x40));

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

+              *(undefined8 *)(puVar23 + -8) = 0x140052566;

+              ppppppppppppuVar33 = local_1e0;

+              ppppppppppppuVar31 = (ulonglong ************)RtlCompareMemory(_Dst,local_200);

+              if (ppppppppppppuVar31 != local_1e0) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  uVar20 = 0xf4;

+                  *(undefined **)(puVar23 + 0x38) =

+                       (undefined *)((longlong)ppppppppppppuVar31 + (longlong)ppppppppppppuVar29);

+                  *(ulonglong *************)(puVar23 + 0x30) = ppppppppppppuVar31;

+                  *(uint *)(puVar23 + 0x28) = uVar7;

+LAB_13:

+                  uVar18 = WPP_GLOBAL_Control[3];

+                  *(uint *)(puVar23 + 0x20) = uVar2;

+                  *(undefined8 *)(puVar23 + -8) = 0x1400527eb;

+                  WPP_SF_iDDii(uVar18,uVar20,ppppppppppppuVar33,ppppppppppppuVar29);

+                }

+                goto LAB_8;

+              }

+              uVar9 = 0;

+              if (uVar6 != 0) {

+                do {

+                  lVar13 = local_1d8;

+                  local_230._4_4_ = uVar9 + uVar7;

+                  if (uVar6 < local_230._4_4_) {

+                    uVar7 = uVar6 - uVar9;

+                  }

+                  ppppppppppppuVar31 =

+                       (ulonglong ************)((ulonglong)uVar9 + (longlong)ppppppppppppuVar29);

+                  if (ppppppppppppuVar31 < ppppppppppppuVar29) goto LAB_12;

+                  local_218 = *(longlong *)(puVar23 + 0x70) + (ulonglong)uVar9;

+                  *(undefined8 *)(puVar23 + -8) = 0x1400525cb;

+                  IoBuildPartialMdl(*(undefined8 *)(puVar23 + 0x68),local_1d8,local_218,uVar7);

+                  puVar23[0x50] = 0;

+                  *(undefined4 *)(puVar23 + 0x48) = 0;

+                  *(undefined4 *)(puVar23 + 0x40) = 0;

+                  *(longlong *)(puVar23 + 0x38) = lVar14;

+                  *(undefined8 *)(puVar23 + 0x30) = 0;

+                  ppppppppppppuVar33 = (ulonglong ************)0x2;

+                  *(longlong *)(puVar23 + 0x28) = lVar13;

+                  *(uint *)(puVar23 + 0x20) = uVar7;

+                  *(undefined8 *)(puVar23 + -8) = 0x140052605;

+                  ppppppppppppuVar31 =

+                       (ulonglong ************)

+                       FveInitPreallocatedIrp

+                                 ((longlong)local_238,3,2,(ulonglong)ppppppppppppuVar31,

+                                  *(undefined4 *)(puVar23 + 0x20),*(undefined8 *)(puVar23 + 0x28),

+                                  *(void **)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38),

+                                  *(undefined4 *)(puVar23 + 0x40),*(int *)(puVar23 + 0x48),

+                                  puVar23[0x50]);

+                  uVar8 = extraout_EAX_00;

+                  if ((int)extraout_EAX_00 < 0) goto LAB_8;

+                  if (local_240 == 0) {

+                    *(undefined8 *)(puVar23 + -8) = 0x14005261b;

+                    uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline

+                                       ();

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

+                      ppppppppppppuVar33 =

+                           (ulonglong ************)

+                           ((ulonglong)ppppppppppppuVar31 /

+                           (ulonglong)*(uint *)((longlong)local_238 + 0x49c));

+                      *(undefined8 *)(puVar23 + -8) = 0x140052640;

+                      uVar8 = FveIceSetIrpExtension(lVar14,local_220,ppppppppppppuVar33);

+                    }

+                    else {

+                      *(undefined8 *)(puVar23 + -8) = 0x140052655;

+                      ppppppppppppuVar33 = ppppppppppppuVar31;

+                      uVar18 = FveIceSetIrpExtensionSteelix

+                                         (lVar14,local_220,(ulonglong)ppppppppppppuVar31,

+                                          (longlong)local_238);

+                      uVar8 = (uint)uVar18;

+                    }

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

+                  }

+                  *(char *)(lVar14 + 0x43) = *(char *)(lVar14 + 0x43) + -1;

+                  *(longlong *)(lVar14 + 0xb8) = *(longlong *)(lVar14 + 0xb8) + -0x48;

+                  lVar13 = local_238[0xd];

+                  *(undefined8 *)(puVar23 + -8) = 0x14005267d;

+                  IoForwardIrpSynchronously(lVar13,lVar14);

+                  uVar8 = *(uint *)(lVar14 + 0x30);

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

+                  if (local_240 != 0) {

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

+                    *(longlong *)(puVar23 + 0x30) = local_218;

+                    *(longlong *)(puVar23 + 0x28) = local_218;

+                    *(uint *)(puVar23 + 0x20) = uVar7;

+                    *(undefined8 *)(puVar23 + -8) = 0x1400526c1;

+                    uVar8 = FveFilteredDecrypt(3,(longlong)local_188,ppppppppppppuVar31,

+                                               0xffffffffffffffff,*(ULONG *)(puVar23 + 0x20),

+                                               *(PUCHAR *)(puVar23 + 0x28),

+                                               *(PUCHAR *)(puVar23 + 0x30),

+                                               *(longlong *)(puVar23 + 0x38));

+                    ppppppppppppuVar33 = ppppppppppppuVar31;

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

+                  }

+                  uVar7 = (uint)local_230;

+                  uVar9 = local_230._4_4_;

+                } while (local_230._4_4_ < uVar6);

+              }

+              ppppppppppppuVar31 = local_1e0;

+              *(undefined8 *)(puVar23 + -8) = 0x1400526f2;

+              ppppppppppppuVar33 = local_1e0;

+              ppppppppppppuVar15 =

+                   (ulonglong ************)RtlCompareMemory(*(undefined8 *)(puVar23 + 0x70));

+              if (ppppppppppppuVar15 != ppppppppppppuVar31) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  uVar20 = 0xf5;

+                  *(undefined **)(puVar23 + 0x38) =

+                       (undefined *)((longlong)ppppppppppppuVar15 + (longlong)ppppppppppppuVar29);

+                  *(ulonglong *************)(puVar23 + 0x30) = ppppppppppppuVar15;

+                  *(uint *)(puVar23 + 0x28) = (uint)local_230;

+                  goto LAB_13;

+                }

+                goto LAB_8;

+              }

+              local_1e8 = (ulonglong ***********)

+                          ((longlong)local_1e8 + (longlong)ppppppppppppuVar31);

+              ppppppppppppuVar29 = local_1e0;

+              plVar11 = local_238;

+              uVar7 = (uint)local_230;

+            }

+            ppppppppppppuVar31 = ppppppppppppuVar29;

+          }

+LAB_10:

+          if (local_240 == 0) {

+            *(undefined8 *)(puVar23 + -8) = 0x140052754;

+            uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+            ppppppppppppuVar33 = (ulonglong ************)0x0;

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

+              *(undefined8 *)(puVar23 + -8) = 0x140052769;

+              uVar8 = FveIceSetIrpExtension(lVar14,0,0);

+            }

+            else {

+              *(undefined8 *)(puVar23 + -8) = 0x14005284e;

+              uVar18 = FveIceSetIrpExtensionSteelix(lVar14,0,0,(longlong)plVar11);

+              uVar8 = (uint)uVar18;

+            }

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

+          }

+          *(undefined4 *)(puVar23 + 0x40) = 0;

+          *(longlong *)(puVar23 + 0x38) = lVar14;

+          *(longlong *)(puVar23 + 0x28) = lVar34;

+          ppppppppppppuVar33 = (ulonglong ************)0x2;

+          *(uint *)(puVar23 + 0x20) = uVar6;

+          *(undefined8 *)(puVar23 + -8) = 0x14005288a;

+          uVar8 = FveSendPreallocatedIrpEx

+                            ((longlong)plVar11,3,2,(ulonglong)param_7,*(uint *)(puVar23 + 0x20),

+                             *(undefined8 *)(puVar23 + 0x28),*(undefined8 *)(puVar23 + 0x30),

+                             *(longlong *)(puVar23 + 0x38),*(int *)(puVar23 + 0x40));

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

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

+          *(ulonglong *************)(puVar23 + 0x30) = local_228;

+          *(ulonglong *************)(puVar23 + 0x28) = local_228;

+          *(uint *)(puVar23 + 0x20) = uVar6;

+          *(undefined8 *)(puVar23 + -8) = 0x1400528c3;

+          ppppppppppppuVar33 = (ulonglong ************)param_7;

+          uVar8 = FveFilteredDecrypt(3,(longlong)local_188,param_7,0xffffffffffffffff,

+                                     *(ULONG *)(puVar23 + 0x20),*(PUCHAR *)(puVar23 + 0x28),

+                                     *(PUCHAR *)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38));

+          lVar34 = local_1d8;

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

+          lVar13 = *(longlong *)(puVar23 + 0x70);

+          *(undefined8 *)(puVar23 + -8) = 0x1400528eb;

+          IoBuildPartialMdl(*(undefined8 *)(puVar23 + 0x68),local_1d8,lVar13,uVar2);

+          puVar23[0x50] = 0;

+          *(undefined4 *)(puVar23 + 0x48) = 0;

+          *(undefined4 *)(puVar23 + 0x40) = 0;

+          *(longlong *)(puVar23 + 0x38) = lVar14;

+          *(undefined8 *)(puVar23 + 0x30) = 0;

+          ppppppppppppuVar33 = (ulonglong ************)0x2;

+          *(longlong *)(puVar23 + 0x28) = lVar34;

+          *(uint *)(puVar23 + 0x20) = uVar2;

+          *(undefined8 *)(puVar23 + -8) = 0x140052924;

+          uVar16 = FveInitPreallocatedIrp

+                             ((longlong)plVar11,3,2,(ulonglong)param_7,

+                              *(undefined4 *)(puVar23 + 0x20),*(undefined8 *)(puVar23 + 0x28),

+                              *(void **)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38),

+                              *(undefined4 *)(puVar23 + 0x40),*(int *)(puVar23 + 0x48),puVar23[0x50]

+                             );

+          uVar8 = extraout_EAX_01;

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

+            if (local_240 == 0) {

+              *(undefined8 *)(puVar23 + -8) = 0x14005293a;

+              uVar19 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline()

+              ;

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

+                ppppppppppppuVar33 =

+                     (ulonglong ************)

+                     ((ulonglong)param_7 / (ulonglong)*(uint *)(uVar16 + 0x49c));

+                *(undefined8 *)(puVar23 + -8) = 0x14005295b;

+                uVar8 = FveIceSetIrpExtension(lVar14,local_220,ppppppppppppuVar33);

+              }

+              else {

+                *(undefined8 *)(puVar23 + -8) = 0x14005296f;

+                ppppppppppppuVar33 = (ulonglong ************)param_7;

+                uVar18 = FveIceSetIrpExtensionSteelix(lVar14,local_220,(ulonglong)param_7,uVar16);

+                uVar8 = (uint)uVar18;

+              }

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

+            }

+            *(char *)(lVar14 + 0x43) = *(char *)(lVar14 + 0x43) + -1;

+            *(longlong *)(lVar14 + 0xb8) = *(longlong *)(lVar14 + 0xb8) + -0x48;

+            uVar18 = *(undefined8 *)(uVar16 + 0x68);

+            *(undefined8 *)(puVar23 + -8) = 0x140052993;

+            IoForwardIrpSynchronously(uVar18,lVar14);

+            uVar8 = *(uint *)(lVar14 + 0x30);

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

+              if (local_240 != 0) {

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

+                *(longlong *)(puVar23 + 0x30) = lVar13;

+                *(longlong *)(puVar23 + 0x28) = lVar13;

+                *(uint *)(puVar23 + 0x20) = uVar2;

+                *(undefined8 *)(puVar23 + -8) = 0x1400529d2;

+                ppppppppppppuVar33 = (ulonglong ************)param_7;

+                uVar8 = FveFilteredDecrypt(3,(longlong)local_188,param_7,0xffffffffffffffff,

+                                           *(ULONG *)(puVar23 + 0x20),*(PUCHAR *)(puVar23 + 0x28),

+                                           *(PUCHAR *)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38)

+                                          );

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

+              }

+              lVar34 = local_1d8;

+              if (uVar6 <= uVar2) goto LAB_14;

+              iVar28 = uVar6 - uVar2;

+              if ((ulonglong *******)((longlong)pppppppuVar37 + (longlong)param_7) < param_7) {

+                uVar8 = 0xc0000095;

+              }

+              else {

+                *(undefined8 *)(puVar23 + -8) = 0x140052a19;

+                IoBuildPartialMdl(*(undefined8 *)(puVar23 + 0x68),local_1d8,

+                                  (longlong)pppppppuVar37 + lVar13,iVar28);

+                puVar23[0x50] = 0;

+                *(undefined4 *)(puVar23 + 0x48) = 0;

+                *(undefined4 *)(puVar23 + 0x40) = 0;

+                *(longlong *)(puVar23 + 0x38) = lVar14;

+                *(undefined8 *)(puVar23 + 0x30) = 0;

+                ppppppppppppuVar33 = (ulonglong ************)0x2;

+                *(longlong *)(puVar23 + 0x28) = lVar34;

+                *(int *)(puVar23 + 0x20) = iVar28;

+                *(undefined8 *)(puVar23 + -8) = 0x140052a52;

+                ppppppppppppuVar31 =

+                     (ulonglong ************)

+                     FveInitPreallocatedIrp

+                               ((longlong)local_238,3,2,

+                                (ulonglong)((longlong)pppppppuVar37 + (longlong)param_7),

+                                *(undefined4 *)(puVar23 + 0x20),*(undefined8 *)(puVar23 + 0x28),

+                                *(void **)(puVar23 + 0x30),*(longlong *)(puVar23 + 0x38),

+                                *(undefined4 *)(puVar23 + 0x40),*(int *)(puVar23 + 0x48),

+                                puVar23[0x50]);

+                uVar8 = extraout_EAX_02;

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

+                  if (local_240 == 0) {

+                    *(undefined8 *)(puVar23 + -8) = 0x140052a68;

+                    uVar16 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline

+                                       ();

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

+                      ppppppppppppuVar33 =

+                           (ulonglong ************)

+                           ((ulonglong)ppppppppppppuVar31 /

+                           (ulonglong)*(uint *)((longlong)local_238 + 0x49c));

+                      *(undefined8 *)(puVar23 + -8) = 0x140052a8d;

+                      uVar8 = FveIceSetIrpExtension(lVar14,local_220,ppppppppppppuVar33);

+                    }

+                    else {

+                      *(undefined8 *)(puVar23 + -8) = 0x140052aa2;

+                      ppppppppppppuVar33 = ppppppppppppuVar31;

+                      uVar18 = FveIceSetIrpExtensionSteelix

+                                         (lVar14,local_220,(ulonglong)ppppppppppppuVar31,

+                                          (longlong)local_238);

+                      uVar8 = (uint)uVar18;

+                    }

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

+                  }

+                  *(char *)(lVar14 + 0x43) = *(char *)(lVar14 + 0x43) + -1;

+                  *(longlong *)(lVar14 + 0xb8) = *(longlong *)(lVar14 + 0xb8) + -0x48;

+                  lVar34 = local_238[0xd];

+                  *(undefined8 *)(puVar23 + -8) = 0x140052aca;

+                  IoForwardIrpSynchronously(lVar34);

+                  uVar8 = *(uint *)(lVar14 + 0x30);

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

+                    if (local_240 != 0) {

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

+                      *(longlong *)(puVar23 + 0x30) = (longlong)pppppppuVar37 + lVar13;

+                      *(longlong *)(puVar23 + 0x28) = (longlong)pppppppuVar37 + lVar13;

+                      *(int *)(puVar23 + 0x20) = iVar28;

+                      *(undefined8 *)(puVar23 + -8) = 0x140052b11;

+                      uVar8 = FveFilteredDecrypt(3,(longlong)local_188,ppppppppppppuVar31,

+                                                 0xffffffffffffffff,*(ULONG *)(puVar23 + 0x20),

+                                                 *(PUCHAR *)(puVar23 + 0x28),

+                                                 *(PUCHAR *)(puVar23 + 0x30),

+                                                 *(longlong *)(puVar23 + 0x38));

+                      ppppppppppppuVar33 = ppppppppppppuVar31;

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

+                    }

+LAB_14:

+                    *(undefined8 *)(puVar23 + -8) = 0x140052b2f;

+                    ppppppppppppuVar33 = ppppppppppppuVar32;

+                    ppppppppppppuVar31 = (ulonglong ************)RtlCompareMemory(lVar13,local_228);

+                    if (ppppppppppppuVar31 == ppppppppppppuVar32) goto LAB_11;

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

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

+                       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                      uVar18 = WPP_GLOBAL_Control[3];

+                      *(undefined **)(puVar23 + 0x30) =

+                           (undefined *)((longlong)ppppppppppppuVar31 + (longlong)param_7);

+                      *(ulonglong *************)(puVar23 + 0x28) = ppppppppppppuVar31;

+                      *(uint *)(puVar23 + 0x20) = uVar2;

+                      *(undefined8 *)(puVar23 + -8) = 0x140052b83;

+                      WPP_SF_iDii(uVar18,WPP_GLOBAL_Control,ppppppppppppuVar33,param_7);

+                    }

+                  }

+                }

+              }

+            }

+          }

+          goto LAB_9;

+        }

+        lVar13 = *(longlong *)(puVar23 + 0x70);

+        lVar34 = *(longlong *)(puVar23 + 0x68);

+        ppppppppppppuVar32 = (ulonglong ************)local_1e8;

+      }

+      *(undefined8 *)(puVar23 + -8) = 0x140052792;

+      ExFreePoolWithTag(local_228,0x30455646);

+    }

+    plVar11 = local_208;

+    if (lVar13 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c04;

+      ExFreePoolWithTag(lVar13,0x30455646);

+    }

+    if (local_200 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c21;

+      ExFreePoolWithTag(local_200,0x30455646);

+    }

+    if (lVar14 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c35;

+      IoFreeIrp(lVar14);

+    }

+    if (local_210 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c4d;

+      IoFreeMdl(local_210);

+    }

+    if (lVar34 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c61;

+      IoFreeMdl(lVar34);

+    }

+    if (local_1d8 != 0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c79;

+      IoFreeMdl(local_1d8);

+    }

+LAB_1:

+    if (local_1f8 != (ulonglong ************)0x0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c8f;

+      FveDatumFree((ulonglong *)local_1f8);

+    }

+    if (ppppppppppppuVar32 != (ulonglong ************)0x0) {

+      *(undefined8 *)(puVar23 + -8) = 0x140052c9c;

+      DeleteKey((longlong)ppppppppppppuVar32);

+    }

+    bVar30 = puVar23[0x60];

+    puVar24 = puVar23;

+    plVar35 = plVar11;

+    plVar36 = local_238;

+  }

+LAB_0:

+  puVar25 = puVar24;

+  plVar11 = plVar35;

+  uVar27 = (ushort)uStack_244;

+  goto LAB_3;

 }
```

## `FveEowFinalSweepComplete`  (modified)

```diff
--- FveEowFinalSweepComplete
+++ FveEowFinalSweepComplete
@@ -1,278 +1,465 @@
 

-/* WARNING: Instruction at (ram,0x00014005f371) overlaps instruction at (ram,0x00014005f370)

-    */

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

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

+/* WARNING: Type propagation algorithm not settling */

 

-int FveEowFinalSweepComplete(longlong *param_1)

+void FveEowFinalSweepComplete(ulonglong *param_1)

 

 {

   ulonglong *puVar1;

-  undefined4 uVar2;

-  longlong lVar3;

-  longlong *plVar4;

-  undefined4 *puVar5;

-  code *pcVar6;

-  undefined1 uVar7;

+  uint uVar2;

+  bool bVar3;

+  char cVar4;

+  int iVar5;

+  uint uVar6;

+  uint uVar7;

   int iVar8;

-  void *pvVar9;

-  uint *in_RAX;

-  undefined8 uVar10;

-  undefined8 *puVar11;

-  longlong lVar12;

-  ulonglong uVar13;

-  undefined8 *puVar14;

-  undefined8 *puVar15;

-  undefined8 *unaff_RBP;

-  undefined8 *unaff_RSI;

-  longlong unaff_RDI;

+  short *psVar9;

+  ulonglong uVar10;

+  short *psVar11;

+  ulonglong uVar12;

+  short *psVar13;

+  longlong *plVar14;

+  undefined8 uVar15;

   uint uVar16;

-  ulonglong unaff_R12;

-  size_t unaff_R13;

-  longlong *unaff_R14;

-  undefined8 *unaff_R15;

-  char in_ZF;

-  undefined1 local_res8 [24];

-  char in_stack_00000060;

-  longlong in_stack_00000068;

-  uint in_stack_00000078;

+  short *psVar17;

+  ulonglong uVar18;

+  ulonglong uVar19;

+  longlong lVar20;

+  ulonglong uVar21;

+  undefined8 *puVar22;

+  byte bVar23;

+  uint uVar24;

+  short *psVar25;

+  undefined1 auStackY_288 [32];

+  short *local_240;

+  undefined4 local_238;

+  uint local_234;

+  short *local_230;

+  uint local_228;

+  undefined4 local_224;

+  uint local_220;

+  undefined8 local_218;

+  ulonglong local_210;

+  undefined1 *local_208;

+  longlong local_200;

+  ulonglong local_1f8;

+  ulonglong local_1f0 [2];

+  undefined *local_1e0;

+  undefined8 uStack_1d8;

+  undefined8 local_1d0;

+  longlong local_1c8 [18];

+  undefined8 local_138;

+  undefined8 uStack_130;

+  undefined8 local_128 [4];

+  uint *local_108;

+  undefined8 local_100;

+  undefined4 *local_f8;

+  undefined8 local_f0;

+  short **local_e8;

+  undefined8 local_e0;

+  undefined4 *local_d8;

+  undefined8 local_d0;

+  undefined8 *local_c8;

+  undefined8 local_c0;

+  undefined8 *local_b8;

+  undefined8 local_b0;

+  undefined8 local_a8 [4];

+  longlong *local_88;

+  undefined8 local_80;

+  ulonglong *local_78;

+  undefined8 local_70;

+  ulonglong *local_68;

+  undefined8 local_60;

+  undefined8 *local_58;

+  undefined8 local_50;

+  ulonglong *local_48;

+  undefined8 local_40;

+  ulonglong local_38;

   

-  if (param_1 != (longlong *)0x1 && in_ZF == '\0') {

-    uVar13 = (ulonglong)*in_RAX;

-    goto code_r0x00014005f3a2;

-  }

-  uVar13 = (ulonglong)*(uint *)((longlong)param_1 + 0x27);

-  while( true ) {

-    uVar10 = IoAllocateMdl(uVar13);

-    *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x20) = uVar10;

-    uVar13 = *(ulonglong *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x20);

-    if (uVar13 == 0) break;

-code_r0x00014005f3a2:

-    MmBuildMdlForNonPagedPool(uVar13);

-    MmMdlPageContentsState(*(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x20),1);

-    uVar10 = IoAllocateIrpEx(0xffffffffffffffff,*(char *)(unaff_R15[0xd] + 0x4c) + '\x01',0);

-    *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x18) = uVar10;

-    lVar3 = *(longlong *)(unaff_R14[4] + unaff_R12 * 8);

-    if (*(longlong *)(lVar3 + 0x18) == 0) break;

-    puVar15 = unaff_R15 + 0x22a;

-    *(longlong **)(lVar3 + 0x40) = unaff_R14;

-    uVar7 = KeAcquireSpinLockRaiseToDpc(puVar15);

-    plVar4 = *(longlong **)(unaff_R14[4] + unaff_R12 * 8);

-    puVar11 = unaff_R15 + 0x228;

-    puVar14 = (undefined8 *)unaff_R15[0x229];

-    if ((undefined8 *)*puVar14 != puVar11) {

+  local_38 = __security_cookie ^ (ulonglong)auStackY_288;

+  memset(local_1c8,0,0x90);

+  psVar11 = (short *)0x0;

+  local_208 = (undefined1 *)0x0;

+  psVar17 = (short *)0x0;

+  local_210 = 0;

+  local_234 = 0;

+  iVar8 = -0x3fffffff;

+  bVar23 = 1;

+  local_1d0 = 0;

+  local_1e0 = (undefined *)0x0;

+  uStack_1d8 = 0;

+  local_138 = 0;

+  uStack_130 = 0;

+  local_230 = (short *)0x0;

+  bVar3 = false;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],300,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

+  }

+  FvepAcquireDevFveLock((longlong *)param_1,local_1c8,'\x01');

+  FveEowFinalSweepEnable((longlong)param_1,0);

+  psVar9 = (short *)param_1[0x7b];

+  if (((psVar9 != (short *)0x0) && (*psVar9 != 0)) &&

+     ((0xf < (ushort)psVar9[1] && ((*(uint *)(psVar9 + 4) >> 8 & 1) != 0)))) {

+    bVar23 = 0;

+  }

+  local_220 = FveNvcWriteBackDisable((longlong *)param_1,0,'\0');

+  local_220 = local_220 >> 0x1f;

+  iVar5 = FvePrepareForFveInfoCopyUpdate((longlong)param_1,*(int *)((longlong)param_1 + 0x7cc),1);

+  psVar9 = psVar11;

+  psVar25 = psVar11;

+  if (((-1 < iVar5) &&

+      (bVar3 = true, psVar9 = (short *)0x0, psVar25 = (short *)0x0, param_1[0x76] != 0)) &&

+     (psVar9 = (short *)ExAllocatePool2(0x40), psVar9 != (short *)0x0)) {

+    memmove(psVar9,(void *)param_1[0x76],0x10000);

+    uVar10 = FveFindExtendedInfoInDataset((uint *)(psVar9 + 0x20),(longlong *)&local_230);

+    psVar25 = local_230;

+    if ((int)uVar10 < 0) {

+      psVar25 = psVar11;

+      local_230 = psVar11;

+    }

+  }

+  FveRundownAllReadsAndWrites((longlong)param_1);

+  uVar10 = param_1[0x75];

+  psVar13 = psVar11;

+  if ((((uVar10 == 0) || (psVar13 = psVar17, (param_1[99] & 0x100) == 0)) ||

+      ((longlong *)param_1[0x5b] == (longlong *)0x0)) || (*(longlong *)param_1[0x5b] == 0)) {

 LAB_0:

-      puVar14 = (undefined8 *)0x3;

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

-      puVar11 = (undefined8 *)(*pcVar6)();

-      register0x00000020 = (BADSPACEBASE *)local_res8;

-      in_stack_00000060 = (char)unaff_R12;

+    iVar8 = -0x3fffffff;

+    uVar6 = 0xc0000001;

+    psVar17 = psVar13;

+  }

+  else {

+    if ((*(short *)(uVar10 + 10) != 1) &&

+       (psVar11 = (short *)(ulonglong)*(uint *)(uVar10 + 0x1c), *(uint *)(uVar10 + 0x1c) == 0)) {

+      psVar11 = (short *)0x1;

+    }

+    uVar10 = (ulonglong)*(uint *)((longlong)param_1 + 0x49c) * (longlong)psVar11;

+    if (uVar10 < 0x100000000) {

+      uVar12 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                         ();

+      uVar24 = (uint)uVar10;

+      uVar15 = 0x40;

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

+        uVar15 = 0x48;

+      }

+      psVar13 = (short *)ExAllocatePool2(uVar15);

+      local_240 = psVar13;

+      if (psVar13 == (short *)0x0) {

+        uVar6 = 0xc000009a;

+      }

+      else {

+        uVar12 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,0,(byte *)0x0,0,uVar24,

+                                     (longlong)psVar13);

+        uVar6 = (uint)uVar12;

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

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

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_D(WPP_GLOBAL_Control[3],0x12d,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,

+                     uVar24);

+          }

+          puVar22 = &WPP_GLOBAL_Control;

+          plVar14 = FveEowFindGuidRecognition((longlong)psVar13,uVar24);

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

+          if (((WPP_GLOBAL_Control != puVar22) &&

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_i(WPP_GLOBAL_Control[3],0x12e,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,

+                     (longlong)plVar14 - (longlong)psVar13);

+            puVar22 = &WPP_GLOBAL_Control;

+          }

+          plVar14[5] = 0;

+          plVar14[6] = 0;

+          *plVar14 = 0x4ad82e294967d63b;

+          plVar14[1] = 0x1d0e339a3f69983;

+          uVar19 = (ulonglong)(uint)param_1[0x95];

+          uVar12 = (longlong)plVar14 - (longlong)psVar13;

+          if (((uVar19 - 1 & uVar19) == 0) && (uVar19 != 0)) {

+            uVar18 = ~(uVar19 - 1) & uVar12;

+          }

+          else {

+            uVar18 = uVar12 - uVar12 % uVar19;

+          }

+          uVar21 = 0xffffffff;

+          if (uVar18 < 0x100000000) {

+            uVar15 = FveLibULongLongAlignUp(uVar12 + 0x28,uVar19,&local_210);

+            uVar6 = (uint)uVar15;

+            psVar13 = local_240;

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

+              if (uVar21 < local_210) goto LAB_1;

+              uVar16 = (uint)uVar18;

+              if ((uint)local_210 <= uVar24) {

+                uVar10 = local_210;

+              }

+              uVar6 = RtlULongSub((uint)uVar10,uVar16,(int *)&local_234);

+              uVar24 = local_234;

+              psVar13 = local_240;

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

+                if (local_234 != 0) {

+                  uVar2 = *(uint *)((longlong)param_1 + 0x49c);

+                  uVar6 = uVar2 - 1;

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

+                    uVar7 = uVar6 & local_234;

+                  }

+                  else {

+                    uVar7 = local_234 % uVar2;

+                  }

+                  if (uVar7 == 0) {

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

+                      uVar6 = uVar16 & uVar6;

+                    }

+                    else {

+                      uVar6 = (uint)((uVar18 & 0xffffffff) % (ulonglong)uVar2);

+                    }

+                    if (uVar6 == 0) {

+                      if (((WPP_GLOBAL_Control != puVar22) &&

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

+                         (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                        WPP_SF_LLL(WPP_GLOBAL_Control[3],0x12f,

+                                   &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,uVar16);

+                      }

+                      psVar13 = local_240;

+                      uVar10 = 0;

+                      uVar16 = 0;

+                      uVar12 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,0,(byte *)0x0,

+                                                   uVar18 & 0xffffffff,uVar24,

+                                                   (uVar18 & 0xffffffff) + (longlong)local_240);

+                      uVar6 = (uint)uVar12;

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

+                        uVar12 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,0,(byte *)0x0,

+                                                     0,0,0);

+                        uVar6 = (uint)uVar12;

+                        if (((uVar6 == 0xc0000002) || (uVar6 == 0xc0000010)) ||

+                           ((uVar6 == 0xc00000bb || (uVar16 = uVar6, -1 < (int)uVar6)))) {

+                          uVar6 = uVar16;

+                          uVar12 = uVar10;

+                          if (bVar23 != 0) {

+                            uVar12 = param_1[0x7e];

+                          }

+                          param_1[0x7d] = uVar12;

+                          SetFveStateEx((longlong *)param_1,(bVar23 ^ 1) + 1,

+                                        -(ulonglong)(bVar23 != 0) & uVar12,0,'\x01',0x3b);

+                          if (bVar23 != 0) {

+                            local_138 = *(undefined8 *)(psVar9 + 0x28);

+                            uStack_130 = *(undefined8 *)(psVar9 + 0x2c);

+                            lVar20 = *(longlong *)(psVar9 + 8);

+                            if (((lVar20 != *(longlong *)(param_1[0x75] + 0x10)) &&

+                                (4 < DAT_2)) &&

+                               (cVar4 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar4 != '\0')) {

+                              local_88 = &local_200;

+                              local_1f8 = param_1[0x7e];

+                              local_78 = &local_1f8;

+                              local_80 = 8;

+                              local_70 = 8;

+                              if (param_1[0x5b] != 0) {

+                                uVar10 = *(ulonglong *)(param_1[0x5b] + 0x28);

+                              }

+                              local_68 = local_1f0;

+                              local_60 = 8;

+                              local_58 = &local_138;

+                              local_50 = 0x10;

+                              local_48 = local_1f0 + 1;

+                              local_1f0[1] = 0x1000000;

+                              local_40 = 8;

+                              local_200 = lVar20;

+                              local_1f0[0] = uVar10;

+                              _tlgWriteTransfer_EtwWriteTransfer

+                                        (0x14003b040,&DAT_3,0,0,7,local_a8);

+                            }

+                          }

+                          puVar22 = (undefined8 *)param_1[0x75];

+                          uVar15 = puVar22[1];

+                          *(undefined8 *)psVar9 = *puVar22;

+                          *(undefined8 *)(psVar9 + 4) = uVar15;

+                          uVar15 = puVar22[3];

+                          *(undefined8 *)(psVar9 + 8) = puVar22[2];

+                          *(undefined8 *)(psVar9 + 0xc) = uVar15;

+                          uVar15 = puVar22[5];

+                          *(undefined8 *)(psVar9 + 0x10) = puVar22[4];

+                          *(undefined8 *)(psVar9 + 0x14) = uVar15;

+                          uVar15 = puVar22[7];

+                          *(undefined8 *)(psVar9 + 0x18) = puVar22[6];

+                          *(undefined8 *)(psVar9 + 0x1c) = uVar15;

+                          if (bVar23 == 0) {

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

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

+                               (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                              WPP_SF_(WPP_GLOBAL_Control[3],0x131,

+                                      &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

+                            }

+                          }

+                          else {

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

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

+                               (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                              WPP_SF_(WPP_GLOBAL_Control[3],0x130,

+                                      &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

+                            }

+                            if ((4 < DAT_2) &&

+                               (cVar4 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar4 != '\0')) {

+                              local_108 = &local_228;

+                              local_224 = (undefined4)param_1[2];

+                              local_f8 = &local_224;

+                              local_100 = 4;

+                              local_240 = (short *)CONCAT44(local_240._4_4_,

+                                                            *(undefined4 *)

+                                                             ((longlong)param_1 + 0x14));

+                              local_e8 = &local_240;

+                              local_238 = *(undefined4 *)((longlong)param_1 + 0x344);

+                              local_d8 = &local_238;

+                              local_f0 = 4;

+                              local_e0 = 4;

+                              local_d0 = 4;

+                              local_218 = *(undefined8 *)(param_1[0x7b] + 8);

+                              local_c8 = &local_218;

+                              local_b8 = &local_138;

+                              local_c0 = 8;

+                              local_b0 = 0x10;

+                              local_228 = uVar6;

+                              _tlgWriteTransfer_EtwWriteTransfer

+                                        (0x14003b040,&DAT_4,0,0,8,local_128);

+                            }

+                            LOCK();

+                            puVar1 = param_1 + 0x5c;

+                            uVar10 = *puVar1;

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

+                            UNLOCK();

+                            psVar25 = local_230;

+                            if ((int)uVar10 == 1) {

+                              local_208 = (undefined1 *)param_1[0x5b];

+                              param_1[0x5b] = 0;

+                            }

+                          }

+                          if ((((bVar3) && (psVar25 != (short *)0x0)) && (*psVar25 != 0)) &&

+                             (0xf < (ushort)psVar25[1])) {

+                            *(ulonglong *)(psVar25 + 4) =

+                                 *(ulonglong *)(psVar25 + 4) & 0xfffffffffffffe1f;

+                            uVar10 = FveWriteInformation((longlong *)param_1,'\0',psVar9,

+                                                         (longlong *)(param_1 + 0x7f),

+                                                         (ulonglong *)param_1[0x7a],'\x01');

+                            iVar8 = (int)uVar10;

+                            psVar17 = psVar13;

+                            if (-1 < iVar8) {

+                              uVar15 = *(undefined8 *)(psVar9 + 4);

+                              puVar22 = (undefined8 *)param_1[0x75];

+                              *puVar22 = *(undefined8 *)psVar9;

+                              puVar22[1] = uVar15;

+                              uVar15 = *(undefined8 *)(psVar9 + 0xc);

+                              puVar22[2] = *(undefined8 *)(psVar9 + 8);

+                              puVar22[3] = uVar15;

+                              uVar15 = *(undefined8 *)(psVar9 + 0x14);

+                              puVar22[4] = *(undefined8 *)(psVar9 + 0x10);

+                              puVar22[5] = uVar15;

+                              uVar15 = *(undefined8 *)(psVar9 + 0x1c);

+                              puVar22[6] = *(undefined8 *)(psVar9 + 0x18);

+                              puVar22[7] = uVar15;

+                            }

+                            goto LAB_5;

+                          }

+                        }

+                      }

+                      goto LAB_6;

+                    }

+                  }

+                }

+                iVar8 = -0x3fffffff;

+                uVar6 = 0xc0000001;

+                psVar17 = local_240;

+                goto LAB_5;

+              }

+            }

+          }

+          else {

 LAB_1:

-      puVar5 = (undefined4 *)unaff_RBP[-9];

-      in_stack_00000068 = *(longlong *)((longlong)register0x00000020 + 0x68);

-      *unaff_RSI = puVar11;

-      unaff_RSI[1] = puVar14;

-      *puVar14 = unaff_RSI;

-      puVar11[1] = unaff_RSI;

-      puVar5[1] = *(undefined4 *)((longlong)register0x00000020 + 0x74);

-      puVar5[2] = *(undefined4 *)(unaff_RSI[0x29] + 0x5c);

-      *puVar5 = *(undefined4 *)(unaff_RSI + 0x28);

-      *(undefined4 *)(unaff_RSI[0x29] + 4) = *(undefined4 *)(unaff_RSI + 0x28);

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

-      *(undefined8 *)((longlong)register0x00000020 + 0x38) = unaff_RSI[8];

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

-      *(char *)((longlong)register0x00000020 + 0x28) = (char)puVar15;

-      *(char *)((longlong)register0x00000020 + 0x20) = (char)puVar15;

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

-      KeWaitForMultipleObjects(uVar2,in_stack_00000068,0,0);

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

-      uVar10 = KeQueryPerformanceCounter(unaff_RBP + -0xb);

-      puVar1 = unaff_RSI + 5;

-      *(undefined8 *)(unaff_RSI[0x29] + 0x28) = uVar10;

-      *(undefined8 *)(unaff_RSI[0x29] + 0x38) = 0xffffffffffffffff;

-      *(undefined8 *)(unaff_RSI[0x29] + 0x40) = unaff_RBP[-0xb];

-      lVar3 = _DAT_2;

-      if (*(int *)(unaff_RDI + 0x28) == (int)puVar15) {

-        *puVar1 = 0x7fffffffffffffff;

-      }

-      else {

-        iVar8 = -*(int *)(unaff_RDI + 0x28);

-        if (-*(int *)(unaff_RDI + 0x28) < 0) {

-          iVar8 = *(int *)(unaff_RDI + 0x28);

+            uVar6 = 0xc0000095;

+            psVar13 = local_240;

+          }

         }

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

-        RtlLongLongMult((longlong)iVar8,10000000,(longlong *)puVar1);

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

-        uVar16 = KeQueryTimeIncrement();

-        uVar13 = *puVar1;

-        *puVar1 = (longlong)uVar13 / (longlong)(ulonglong)uVar16;

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

-        RtlLongLongAdd((longlong)uVar13 / (longlong)(ulonglong)uVar16,lVar3,puVar1);

-      }

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

-      uVar10 = unaff_RBP[-8];

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

-      iVar8 = ZwQuerySystemInformation(8,uVar10,uVar2);

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

-      KeSetEvent(unaff_RSI + 0x19,0,0);

-      unaff_RSI = (undefined8 *)0x0;

-      goto LAB_3;

-    }

-    *plVar4 = (longlong)puVar11;

-    plVar4[1] = (longlong)puVar14;

-    *puVar14 = plVar4;

-    unaff_R15[0x229] = plVar4;

-    KeReleaseSpinLock(puVar15,CONCAT71((int7)((ulonglong)puVar11 >> 8),uVar7));

-    uVar16 = (int)unaff_R12 + 1;

-    unaff_R12 = (ulonglong)uVar16;

-    if (*(uint *)(unaff_RDI + 0x30) <= uVar16) {

-      uVar16 = *(uint *)(unaff_RBP + -0xf);

-      do {

-        unaff_RBP[-4] = 0;

-        unaff_RBP[-3] = 0;

-        *(undefined4 *)(unaff_RBP + -5) = 0x30;

-        *(undefined4 *)(unaff_RBP + -2) = 0x200;

-        unaff_RBP[-1] = 0;

-        *unaff_RBP = 0;

-        iVar8 = PsCreateSystemThread(unaff_RBP + -0x10,0,unaff_RBP + -5,0,0);

-        if (iVar8 < 0) goto LAB_3;

-        puVar15 = (undefined8 *)0x0;

-        unaff_R12 = 0;

-        in_stack_00000060 = '\0';

-        unaff_RBP[-0xf] = 0;

-        ObReferenceObjectByHandle(unaff_RBP[-0x10],0x1fffff,0,0,unaff_RBP + -0xf);

-        unaff_R14[3] = unaff_RBP[-0xf];

-        ZwClose(unaff_RBP[-0x10]);

-        lVar3 = unaff_RSI[7];

-        lVar12 = unaff_R14[3];

-        uVar13 = (ulonglong)uVar16;

-        uVar16 = uVar16 + 1;

-        *(uint *)(unaff_RBP + -0xf) = uVar16;

-        *(longlong *)(lVar3 + uVar13 * 8) = lVar12;

-        if (*(uint *)(unaff_RDI + 0x2c) <= uVar16) {

-          puVar11 = unaff_R15 + 0x226;

-          puVar14 = (undefined8 *)unaff_R15[0x227];

-          in_stack_00000060 = '\0';

-          if ((undefined8 *)*puVar14 == puVar11) goto LAB_1;

-          goto LAB_0;

-        }

-        puVar15 = unaff_RSI + 2;

-        unaff_RBP[-0x10] = 0;

-        unaff_RBP[-1] = 0;

-        unaff_RBP[-5] = 0;

-        unaff_RBP[-4] = 0;

-        *(undefined4 *)unaff_RBP = 0;

-        unaff_RBP[-3] = 0;

-        unaff_RBP[-2] = 0;

-        unaff_R14 = (longlong *)ExAllocatePool2(0x40,0x48,0x30455646);

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

-LAB_4:

-          iVar8 = -0x3fffff66;

-          in_stack_00000060 = '\0';

-          goto LAB_3;

-        }

-        memset(unaff_R14,0,0x48);

-        plVar4 = (longlong *)unaff_RSI[3];

-        if ((undefined8 *)*plVar4 != puVar15) goto LAB_0;

-        *unaff_R14 = (longlong)puVar15;

-        unaff_R14[1] = (longlong)plVar4;

-        *plVar4 = (longlong)unaff_R14;

-        unaff_RSI[3] = unaff_R14;

-        unaff_R14[2] = (longlong)unaff_RSI;

-        pvVar9 = (void *)ExAllocatePool2(0x40,(ulonglong)*(uint *)(unaff_RDI + 0x30) << 3,0x30455646

-                                        );

-        unaff_R14[4] = (longlong)pvVar9;

-        if (pvVar9 == (void *)0x0) goto LAB_4;

-        memset(pvVar9,0,(ulonglong)*(uint *)(unaff_RDI + 0x30) << 3);

-        pvVar9 = (void *)ExAllocatePool2(0x40,(ulonglong)*(uint *)(unaff_RDI + 0x30) << 3,0x30455646

-                                        );

-        unaff_R14[6] = (longlong)pvVar9;

-        if (pvVar9 == (void *)0x0) goto LAB_4;

-        memset(pvVar9,0,(ulonglong)*(uint *)(unaff_RDI + 0x30) << 3);

-        pvVar9 = (void *)ExAllocatePool2(0x40,(ulonglong)*(uint *)(unaff_RDI + 0x30) * 0x30,

-                                         0x30455646);

-        unaff_R14[7] = (longlong)pvVar9;

-        if (pvVar9 == (void *)0x0) goto LAB_4;

-        memset(pvVar9,0,(ulonglong)*(uint *)(unaff_RDI + 0x30) * 0x30);

-        unaff_R12 = 0;

-        *(uint *)(unaff_R14 + 8) = uVar16;

-        unaff_R14[5] = *(longlong *)(in_stack_00000068 + (ulonglong)uVar16 * 8);

-      } while (*(int *)(unaff_RDI + 0x30) == 0);

-      unaff_R13 = (size_t)in_stack_00000078;

-    }

-    uVar10 = ExAllocatePool2(0x40,0x18,0x30455646);

-    *(undefined8 *)(unaff_R14[6] + unaff_R12 * 8) = uVar10;

-    lVar3 = *(longlong *)(unaff_R14[6] + unaff_R12 * 8);

-    if (lVar3 == 0) break;

-    KeInitializeEvent(lVar3,0,0);

-    uVar10 = ExAllocatePool2(0x40,0x80,0x30455646);

-    *(undefined8 *)(unaff_R14[4] + unaff_R12 * 8) = uVar10;

-    pvVar9 = *(void **)(unaff_R14[4] + unaff_R12 * 8);

-    if (pvVar9 == (void *)0x0) break;

-    memset(pvVar9,0,0x80);

-    lVar3 = *(longlong *)(unaff_R14[4] + unaff_R12 * 8);

-    lVar12 = lVar3 + 0x60;

-    *(longlong *)(lVar3 + 0x68) = lVar12;

-    *(longlong *)lVar12 = lVar12;

-    KeInitializeSpinLock(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x70);

-    *(int *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x54) = (int)unaff_R12;

-    *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x10) = 0xffffffffffffffff;

-    uVar10 = IoAllocateWorkItem(*unaff_R15);

-    *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x48) = uVar10;

-    if (*(longlong *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x48) == 0) break;

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

-      uVar10 = ExAllocatePool2(0x40,unaff_R13,0x30455646);

-      *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x38) = uVar10;

-      pvVar9 = *(void **)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x38);

-      if (pvVar9 == (void *)0x0) break;

-      memset(pvVar9,0,unaff_R13);

-      uVar10 = ExAllocatePool2(0x40,unaff_R13,0x30455646);

-      *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x30) = uVar10;

-      pvVar9 = *(void **)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x30);

-      if (pvVar9 == (void *)0x0) break;

-      memset(pvVar9,0,unaff_R13);

-      unaff_R13 = (size_t)in_stack_00000078;

-    }

-    uVar10 = ExAllocatePool2(0x40,unaff_R13 & 0xffffffff,0x30455646);

-    *(undefined8 *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x28) = uVar10;

-    pvVar9 = *(void **)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x28);

-    if (pvVar9 == (void *)0x0) break;

-    memset(pvVar9,0,unaff_R13 & 0xffffffff);

-    uVar13 = *(ulonglong *)(*(longlong *)(unaff_R14[4] + unaff_R12 * 8) + 0x28);

-  }

-  iVar8 = -0x3fffff66;

-LAB_3:

-  uVar2 = *(undefined4 *)((longlong)register0x00000020 + 100);

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

-  FvepLockReleaseLock(unaff_RBP + 0x14);

-  if ((iVar8 < 0) || (*(int *)(unaff_RDI + 0x40) - 7U < 2)) {

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

-    func_0x00014005f6f0(unaff_RSI,uVar2);

-  }

-  if (in_stack_00000068 != 0) {

-    uVar13 = 0;

-    if (*(int *)(unaff_RDI + 0x2c) != 0) {

-      do {

-        lVar3 = *(longlong *)(in_stack_00000068 + uVar13 * 8);

-        if (lVar3 != 0) {

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

-          ExFreePoolWithTag(lVar3,0x30455646);

-          *(undefined8 *)(in_stack_00000068 + uVar13 * 8) = 0;

-        }

-        uVar16 = (int)uVar13 + 1;

-        uVar13 = (ulonglong)uVar16;

-      } while (uVar16 < *(uint *)(unaff_RDI + 0x2c));

-    }

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

-    ExFreePoolWithTag(in_stack_00000068,0x30455646);

-  }

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

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

-    FvepReleaseRemoveLock(unaff_R15 + 7);

-  }

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

-  FveVolumeCleanupInfo(unaff_RBP + 2);

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

-  return iVar8;

+      }

+LAB_6:

+      iVar8 = -0x3fffffff;

+      psVar17 = psVar13;

+    }

+    else {

+      uVar6 = 0xc0000095;

+    }

+  }

+LAB_5:

+  FveResumeAllReadsAndWrites((longlong *)param_1);

+  if ((int)uVar6 < 0) {

+LAB_7:

+    if (!bVar3) goto LAB_8;

+  }

+  else {

+    if (((!bVar3) || (psVar25 == (short *)0x0)) || (iVar8 < 0)) {

+      psVar11 = (short *)param_1[0x7b];

+      if (((psVar11 != (short *)0x0) && (*psVar11 != 0)) && (0xf < (ushort)psVar11[1])) {

+        *(ulonglong *)(psVar11 + 4) = *(ulonglong *)(psVar11 + 4) & 0xfffffffffffffe1f;

+      }

+      goto LAB_7;

+    }

+    memmove((void *)param_1[0x76],psVar9,0x10000);

+    param_1[0x7b] = 0;

+    FveFindExtendedInfoInDataset((uint *)(param_1[0x76] + 0x40),(longlong *)(param_1 + 0x7b));

+  }

+  FveCompleteFveInfoCopyUpdate((longlong)param_1);

+LAB_8:

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

+    FveNvcWriteBackReset((longlong *)param_1,0);

+  }

+  uVar10 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

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

+    UpdateDynamicContext((longlong)param_1,(ulonglong *)0x0,0);

+  }

+  FvepReleaseDevFveLock(local_1c8);

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

+    local_1e0 = &FVE_EOW_SWEEP_COMPLETE;

+    uStack_1d8 = 0;

+    local_1d0 = 0;

+    FveLogEventEx(*param_1,(longlong *)&local_1e0,'\0','\x01');

+    if (bVar23 != 0) {

+      FvepAcquireDevFveLock((longlong *)param_1,local_1c8,'\x01');

+      uVar15 = 1;

+      FveNvcWriteBackReset((longlong *)param_1,1);

+      if (param_1[0x99] != 0) {

+        PoUnregisterPowerSettingCallback();

+        param_1[0x99] = 0;

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

+      }

+      FvepReleaseDevFveLock(local_1c8);

+      FveFsEnforceDefaultMount(param_1);

+      if ((*(uint *)(param_1[0xe] + 0x30) & 0x400100) != 0) {

+        local_218 = FveGetSystemTime();

+        FveSetStatsValue(L"OsvEncryptComplete",uVar15,(longlong)&local_218);

+      }

+    }

+    FveRaiseStatusChangedEvent(param_1,0xc);

+    FveRaiseStatusChangedEvent(param_1,0xd);

+    if (bVar23 == 0) {

+      FveQueueAutoWorkItem(param_1,WindDownFveVolume,(longlong)param_1);

+    }

+    FvePdcActivatorDeactivate((longlong)param_1);

+  }

+  uVar10 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

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

+    UpdateDynamicContext((longlong)param_1,(ulonglong *)0x0,0);

+  }

+  if (psVar9 != (short *)0x0) {

+    ExFreePoolWithTag(psVar9,0x30455646);

+  }

+  if (psVar17 != (short *)0x0) {

+    ExFreePoolWithTag(psVar17,0x65455646);

+  }

+  if (local_208 != (undefined1 *)0x0) {

+    FveEowControlFree(local_208);

+  }

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x132,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,uVar6);

+  }

+  return;

 }
```

## `FveEowPrepareForDecryption`  (modified)

```diff
--- FveEowPrepareForDecryption
+++ FveEowPrepareForDecryption
@@ -1,208 +1,326 @@
 

 uint FveEowPrepareForDecryption(longlong *param_1,ushort *param_2)

 

 {

-  longlong *plVar1;

-  longlong lVar2;

-  int iVar3;

-  uint uVar4;

-  ulonglong uVar5;

-  longlong *plVar6;

-  ulonglong uVar7;

-  uint uVar8;

+  uint uVar1;

+  uint *puVar2;

+  bool bVar3;

+  short *psVar4;

+  longlong lVar5;

+  uint uVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  undefined8 *_Dst;

   ulonglong uVar9;

-  ulonglong uVar10;

-  char cVar11;

-  longlong unaff_RBP;

-  uint unaff_ESI;

-  ulonglong unaff_RDI;

-  char *pcVar12;

-  uint uVar13;

-  ulonglong uVar14;

-  longlong in_R10;

-  ulonglong uVar15;

-  char *in_R11;

-  longlong *unaff_R12;

-  ulonglong unaff_R13;

-  ulonglong unaff_R14;

-  ulonglong uVar16;

-  char *unaff_R15;

-  ulonglong in_stack_00000028;

+  longlong lVar10;

+  undefined8 *puVar11;

+  longlong *plVar12;

+  undefined8 uVar13;

+  int iVar14;

+  uint uVar15;

+  longlong lVar16;

+  uint uVar17;

+  longlong lVar18;

+  ulonglong uVar19;

+  ulonglong uVar20;

+  ulonglong uVar21;

+  undefined8 *puVar22;

+  uint local_res18 [2];

+  longlong *local_res20;

+  longlong local_e8;

+  short *local_e0;

+  ulonglong local_d8 [2];

+  longlong local_c8 [18];

   

-  do {

-    uVar8 = *(uint *)(in_R10 + 0x49c);

-    uVar4 = uVar8 - 1;

-    uVar13 = uVar4 & uVar8;

-    if ((uVar13 != 0) || (uVar8 == 0)) {

-      uVar4 = (uint)(((ulonglong)unaff_R15 & 0xffffffff) % (ulonglong)uVar8);

+  memset(local_c8,0,0x90);

+  _Dst = (undefined8 *)0x0;

+  lVar10 = 0;

+  local_e0 = (short *)0x0;

+  local_res20 = (longlong *)0x0;

+  local_d8[0] = 0;

+  local_res18[0] = 0;

+  local_e8 = 0;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0xa2,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

+  }

+  FvepAcquireDevFveLock(param_1,local_c8,'\x01');

+  if ((((*(uint *)(param_1 + 99) & 0x17f) == 0) || ((*(uint *)(param_1 + 99) & 0x40) != 0)) ||

+     ((lVar18 = param_1[0x75], lVar18 == 0 || (*(ushort *)(lVar18 + 10) < 2)))) {

+    uVar6 = 0xc0000001;

+  }

+  else if (*(int *)((longlong)param_1 + 0x33c) < 1) {

+    puVar2 = *(uint **)(lVar18 + 0x38);

+    uVar6 = *(uint *)(lVar18 + 0x1c);

+    if (uVar6 == 0) {

+      uVar6 = 1;

     }

-    pcVar12 = (char *)(unaff_R14 - unaff_RDI);

-    if ((char *)(ulonglong)~uVar4 <= pcVar12) {

-      if ((uVar13 == 0) && (uVar8 != 0)) {

-        uVar8 = -uVar8;

+    uVar7 = *(uint *)((longlong)param_1 + 0x49c);

+    FvepReleaseDevFveLock(local_c8);

+    uVar6 = FveEowInitialize(param_1,param_2,puVar2,(uint *)((ulonglong)uVar6 * (ulonglong)uVar7),

+                             &local_res20);

+    if ((int)uVar6 < 0) {

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

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

+         (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+        WPP_SF_D(WPP_GLOBAL_Control[3],0xa3,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,uVar6);

+      }

+      goto LAB_0;

+    }

+    *(byte *)(*local_res20 + 0x30) = *(byte *)(*local_res20 + 0x30) | 0x20;

+    uVar8 = FveEowInitializeReservedRegions

+                      ((longlong)param_1,(longlong)local_res20,(longlong)(param_1 + 0x7f));

+    uVar6 = (uint)uVar8;

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

+    FvepAcquireDevFveLock(param_1,local_c8,'\x01');

+    uVar6 = FveNvcWriteBackDisable(param_1,1,'\0');

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

+    bVar3 = true;

+    uVar6 = FveNvcWriteBackDisable(param_1,0,'\0');

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

+      lVar18 = 2;

+      if (*(short *)(param_1[0x75] + 10) == 2) {

+        iVar14 = 0x10000;

       }

       else {

-        uVar8 = ~(uint)(((ulonglong)unaff_R15 & 0xffffffff) % (ulonglong)uVar8);

+        iVar14 = 0;

+        if (*(short *)(param_1[0x75] + 10) == 1) {

+          iVar14 = 0x4000;

+        }

       }

-      pcVar12 = (char *)(ulonglong)uVar8;

-    }

-    if (unaff_R15 < pcVar12) {

-LAB_0:

-      iVar3 = -0x3fffff6b;

-      goto LAB_1;

-    }

-    iVar3 = 0;

-    uVar5 = ((ulonglong)pcVar12 & 0xffffffff) + unaff_RDI;

-    *(ulonglong *)(unaff_RBP + 7) = uVar5;

-    if (unaff_RDI < uVar5) {

-      do {

-        pcVar12 = in_R11;

-        if (unaff_R15 < (char *)(uVar5 - unaff_RDI)) goto LAB_0;

-        uVar16 = uVar5 - unaff_RDI & 0xffffffff;

-        uVar5 = uVar16;

-        plVar6 = FveEowOverlappedRegionsAcquire

-                           (*(longlong *)(in_R10 + 0x2d8),unaff_R13,(ulonglong)pcVar12,unaff_RDI,

-                            uVar16,in_stack_00000028,(longlong *)(unaff_RBP + -0x49),

-                            (undefined1 *)(unaff_RBP + 0x6f),(undefined1 *)(unaff_RBP + -0x69));

-        iVar3 = (int)plVar6;

-        uVar7 = (ulonglong)plVar6 & 0xffffffff;

-        if (iVar3 < 0) goto LAB_1;

-        plVar6 = *(longlong **)(unaff_RBP + -0x49);

-        if (plVar6 == (longlong *)(unaff_RBP + -0x49)) {

-          FveEowOverlappedRegionsRelease

-                    ((longlong *)(unaff_RBP + -0x49),*(undefined1 *)(unaff_RBP + 0x6f));

+      uVar6 = FvePrepareForFveInfoCopyUpdate((longlong)param_1,iVar14,1);

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

+        _Dst = (undefined8 *)ExAllocatePool2(0x40,0x10000,0x30455646);

+        if (_Dst == (undefined8 *)0x0) {

+          uVar6 = 0xc000009a;

         }

         else {

-          uVar16 = 0;

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

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

-          while( true ) {

-            iVar3 = (int)uVar7;

-            plVar1 = (longlong *)plVar6[0x11];

-            if ((unaff_R12 != (longlong *)0x0) && (unaff_R12 != plVar1)) break;

-            uVar9 = *(longlong *)((longlong)plVar1 + 0x54) + *(longlong *)((longlong)plVar1 + 0x5c);

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

-            *(ulonglong *)(unaff_RBP + -1) = uVar9;

-            while( true ) {

-              iVar3 = (int)uVar7;

-              *(uint *)(unaff_RBP + -0x65) = uVar4;

-              if (*(uint *)((longlong)plVar6 + 0x2c) <= uVar4) break;

-              uVar15 = (ulonglong)uVar4 * *(longlong *)(unaff_RBP + -0x21) +

-                       *(longlong *)((longlong)plVar1 + 0x54);

-              uVar7 = *(longlong *)(unaff_RBP + -0x21) + uVar15;

-              if (uVar7 < uVar9) {

-                uVar9 = uVar7;

+          memmove(_Dst,(void *)param_1[0x76],0x10000);

+          uVar8 = FveFindExtendedInfoInDataset((uint *)(_Dst + 8),(longlong *)&local_e0);

+          psVar4 = local_e0;

+          uVar6 = (uint)uVar8;

+          if ((int)uVar6 < 0) {

+            bVar3 = true;

+          }

+          else {

+            if (((local_e0 == (short *)0x0) || (*local_e0 == 0)) || ((ushort)local_e0[1] < 0x10)) {

+              uVar6 = 0xc0000001;

+            }

+            else {

+              uVar8 = ExtractFvek((longlong)(_Dst + 8),(ulonglong *)param_1[0x7a],

+                                  (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                  &local_e8);

+              uVar6 = (uint)uVar8;

+              if (-1 < (int)(uint)uVar8) {

+                plVar12 = param_1;

+                FveRundownAllReadsAndWrites((longlong)param_1);

+                lVar5 = lVar10;

+                if ((((*(uint *)(param_1 + 99) & 0x17f) == 0) ||

+                    ((*(uint *)(param_1 + 99) & 0x40) != 0)) || (uVar8 = 0, param_1[0x75] == 0)) {

+LAB_2:

+                  lVar10 = lVar5;

+                  uVar7 = 0xc0000001;

+                }

+                else {

+                  if (0 < *(int *)((longlong)param_1 + 0x33c)) {

+                    uVar7 = 0x80000011;

+                    goto LAB_3;

+                  }

+                  FveEowSetKey(plVar12,local_res20,&local_e8);

+                  lVar5 = 0;

+                  if (local_e8 != 0) goto LAB_2;

+                  if ((*(short *)(param_1[0x75] + 10) != 1) &&

+                     (uVar6 = *(uint *)(param_1[0x75] + 0x1c), uVar8 = (ulonglong)uVar6, uVar6 == 0)

+                     ) {

+                    uVar8 = 1;

+                  }

+                  uVar8 = *(uint *)((longlong)param_1 + 0x49c) * uVar8;

+                  if (0xffffffff < uVar8) goto LAB_4;

+                  uVar9 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                                    ();

+                  uVar6 = (uint)uVar8;

+                  uVar13 = 0x40;

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

+                    uVar13 = 0x48;

+                  }

+                  lVar10 = ExAllocatePool2(uVar13,uVar8 & 0xffffffff,0x65455646);

+                  if (lVar10 == 0) {

+                    uVar7 = 0xc000009a;

+                  }

+                  else {

+                    uVar9 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,0,(byte *)0x0,0,

+                                                uVar6,lVar10);

+                    uVar7 = (uint)uVar9;

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

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

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

+                         (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                        WPP_SF_D(WPP_GLOBAL_Control[3],0xa4,

+                                 &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,uVar6);

+                      }

+                      puVar11 = (undefined8 *)FveFindGuidRecognition(lVar10,uVar6);

+                      lVar5 = lVar10;

+                      if (puVar11 == (undefined8 *)0x0) goto LAB_2;

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

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

+                         (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                        WPP_SF_i(WPP_GLOBAL_Control[3],0xa5,

+                                 &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,

+                                 (longlong)puVar11 - lVar10);

+                      }

+                      puVar22 = &WPP_GLOBAL_Control;

+                      lVar16 = 0xa8;

+                      *puVar11 = 0x4d0edd8092a84d3b;

+                      puVar11[1] = 0xd8ae4e28e3b14e9e;

+                      do {

+                        *(undefined8 *)((longlong)puVar11 + lVar16 + -0x80) =

+                             *(undefined8 *)(lVar16 + (longlong)local_res20);

+                        lVar16 = lVar16 + 8;

+                        lVar18 = lVar18 + -1;

+                      } while (lVar18 != 0);

+                      uVar20 = (ulonglong)*(uint *)(param_1 + 0x95);

+                      uVar9 = (longlong)puVar11 - lVar10;

+                      if (((uVar20 & uVar20 - 1) == 0) && (uVar20 != 0)) {

+                        uVar19 = ~(uVar20 - 1) & uVar9;

+                      }

+                      else {

+                        uVar19 = uVar9 - uVar9 % uVar20;

+                      }

+                      uVar21 = 0xffffffff;

+                      if (uVar19 < 0x100000000) {

+                        uVar13 = FveLibULongLongAlignUp(uVar9 + 0x38,uVar20,local_d8);

+                        uVar7 = (uint)uVar13;

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

+                          if (uVar21 < local_d8[0]) goto LAB_4;

+                          uVar17 = (uint)uVar19;

+                          if ((uint)local_d8[0] <= uVar6) {

+                            uVar8 = local_d8[0];

+                          }

+                          uVar7 = RtlULongSub((uint)uVar8,uVar17,(int *)local_res18);

+                          uVar6 = local_res18[0];

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

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

+                              uVar1 = *(uint *)((longlong)param_1 + 0x49c);

+                              uVar7 = uVar1 - 1;

+                              if (((uVar7 & uVar1) == 0) && (uVar1 != 0)) {

+                                uVar15 = local_res18[0] & uVar7;

+                              }

+                              else {

+                                uVar15 = local_res18[0] % uVar1;

+                              }

+                              if (uVar15 == 0) {

+                                if (((uVar7 & uVar1) == 0) && (uVar1 != 0)) {

+                                  uVar7 = uVar17 & uVar7;

+                                }

+                                else {

+                                  uVar7 = (uint)((uVar19 & 0xffffffff) % (ulonglong)uVar1);

+                                }

+                                if (uVar7 == 0) {

+                                  if (((WPP_GLOBAL_Control != puVar22) &&

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

+                                      )) && (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                                    WPP_SF_LLL(WPP_GLOBAL_Control[3],0xa6,

+                                               &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,

+                                               uVar17);

+                                  }

+                                  uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,0,

+                                                              (byte *)0x0,uVar19 & 0xffffffff,uVar6,

+                                                              (uVar19 & 0xffffffff) + lVar10);

+                                  uVar7 = (uint)uVar8;

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

+                                    uVar6 = 0;

+                                    uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,0,

+                                                                (byte *)0x0,0,0,0);

+                                    uVar7 = (uint)uVar8;

+                                    if (((uVar7 == 0xc0000002) || (uVar7 == 0xc0000010)) ||

+                                       ((uVar7 == 0xc00000bb || (uVar6 = uVar7, -1 < (int)uVar7))))

+                                    {

+                                      param_1[0x5b] = (longlong)local_res20;

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

+                                      local_res20 = (longlong *)0x0;

+                                      bVar3 = false;

+                                      *(ulonglong *)(psVar4 + 4) = *(ulonglong *)(psVar4 + 4) | 0xc2

+                                      ;

+                                      SetFveStateEx(param_1,0x108,param_1[0x7d],0,'\x01',0x3d);

+                                      FveWriteInformation(param_1,'\0',_Dst,param_1 + 0x7f,

+                                                          (ulonglong *)param_1[0x7a],'\x01');

+                                      uVar13 = _Dst[1];

+                                      puVar11 = (undefined8 *)param_1[0x75];

+                                      *puVar11 = *_Dst;

+                                      puVar11[1] = uVar13;

+                                      uVar13 = _Dst[3];

+                                      puVar11[2] = _Dst[2];

+                                      puVar11[3] = uVar13;

+                                      uVar13 = _Dst[5];

+                                      puVar11[4] = _Dst[4];

+                                      puVar11[5] = uVar13;

+                                      uVar13 = _Dst[7];

+                                      puVar11[6] = _Dst[6];

+                                      puVar11[7] = uVar13;

+                                      FveResumeAllReadsAndWrites(param_1);

+                                      memmove((void *)param_1[0x76],_Dst,0x10000);

+                                      param_1[0x7b] = 0;

+                                      FveFindExtendedInfoInDataset

+                                                ((uint *)(param_1[0x76] + 0x40),param_1 + 0x7b);

+                                      goto LAB_5;

+                                    }

+                                  }

+                                  goto LAB_3;

+                                }

+                              }

+                            }

+                            goto LAB_2;

+                          }

+                        }

+                      }

+                      else {

+LAB_4:

+                        uVar7 = 0xc0000095;

+                      }

+                    }

+                  }

+                }

+LAB_3:

+                FveResumeAllReadsAndWrites(param_1);

+                uVar6 = uVar7;

               }

-              *(ulonglong *)(unaff_RBP + -9) = uVar9;

-              uVar10 = uVar9 - uVar15;

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

-              if (0xffffffff < uVar10) goto LAB_0;

-              uVar14 = plVar6[3];

-              uVar7 = plVar6[2];

-              if ((ulonglong)plVar6[2] < uVar15) {

-                uVar7 = uVar15;

-              }

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

-              if (uVar9 < uVar14) {

-                uVar14 = uVar9;

-              }

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

-              uVar14 = uVar14 - uVar7;

-              *(ulonglong *)(unaff_RBP + -0x31) = uVar14;

-              if (0xffffffff < uVar14) goto LAB_0;

-              uVar8 = (int)uVar14 + (uint)uVar16;

-              *(uint *)(unaff_RBP + -0x5d) = uVar8;

-              if (uVar8 < (uint)uVar16) goto LAB_0;

-              uVar7 = 0;

-              iVar3 = 0;

-              pcVar12 = (char *)&WPP_GLOBAL_Control;

-              uVar13 = uVar4;

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

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

-                 (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-                pcVar12 = "Partial";

-                if ((int)uVar14 == (int)uVar10) {

-                  pcVar12 = "Full";

-                }

-                uVar5 = *(longlong *)((longlong)plVar1 + 0x5c) +

-                        *(longlong *)((longlong)plVar1 + 0x54);

-                WPP_SF_iiiiDiiDLs(WPP_GLOBAL_Control[3],0x13b,pcVar12,

-                                  *(longlong *)((longlong)plVar1 + 0x54));

-                uVar8 = *(uint *)(unaff_RBP + -0x5d);

-                uVar13 = *(uint *)(unaff_RBP + -0x65);

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

-                uVar14 = *(ulonglong *)(unaff_RBP + -0x31);

-                in_stack_00000028 = uVar15;

-              }

-              if ((int)uVar14 != (int)uVar10) {

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

-                uVar16 = (ulonglong)uVar8;

-                cVar11 = '\x01';

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

-                  cVar11 = '\0';

-                }

-                goto LAB_2;

-              }

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

-                *(uint *)(unaff_RBP + -0x61) = uVar13;

-                unaff_R12 = plVar1;

-              }

-              uVar9 = *(ulonglong *)(unaff_RBP + -1);

-              uVar4 = uVar13 + 1;

-              uVar16 = (ulonglong)uVar8;

-              unaff_ESI = uVar13;

             }

-            plVar6 = (longlong *)*plVar6;

-            if (plVar6 == (longlong *)(unaff_RBP + -0x49)) goto LAB_3;

+            bVar3 = true;

           }

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

-LAB_3:

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

-LAB_2:

-          FveEowOverlappedRegionsRelease

-                    ((longlong *)(unaff_RBP + -0x49),*(undefined1 *)(unaff_RBP + 0x6f));

-          lVar2 = *(longlong *)(unaff_RBP + -0x59);

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

-            uVar4 = (unaff_ESI - *(int *)(unaff_RBP + -0x61)) + 1;

-            uVar5 = CONCAT44((int)(uVar5 >> 0x20),uVar4);

-            FveEowSetSpecialRangesEncrypted

-                      (lVar2,unaff_R12,pcVar12,*(uint *)(unaff_RBP + -0x61),uVar4);

-            unaff_R12 = (longlong *)0x0;

-            *(undefined4 *)(unaff_RBP + -0x61) = 0xffffffff;

-            unaff_ESI = 0xffffffff;

-          }

-          if (*(char *)(unaff_RBP + 0x7f) != '\0') {

-            pcVar12 = (char *)(ulonglong)*(uint *)(unaff_RBP + -0x65);

-            FveEowProcessChunksSynchronously

-                      (lVar2,plVar1,*(uint *)(unaff_RBP + -0x65),1,uVar5,in_stack_00000028,2);

-          }

-          unaff_R13 = *(ulonglong *)(unaff_RBP + -0x29);

         }

-        in_R10 = *(longlong *)(unaff_RBP + -0x59);

-        unaff_R15 = (char *)0xffffffff;

-        unaff_RDI = unaff_RDI + uVar16;

-        uVar5 = *(ulonglong *)(unaff_RBP + 7);

-        in_R11 = *(char **)(unaff_RBP + -0x51);

-      } while (unaff_RDI < uVar5);

-      unaff_R14 = *(ulonglong *)(unaff_RBP + 0x77);

+LAB_5:

+        FveCompleteFveInfoCopyUpdate((longlong)param_1);

+      }

+      FveNvcWriteBackReset(param_1,0);

+      if (!bVar3) goto LAB_1;

     }

-    if (unaff_R14 <= unaff_RDI) {

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

-        FveEowSetSpecialRangesEncrypted

-                  (in_R10,unaff_R12,pcVar12,*(uint *)(unaff_RBP + -0x61),

-                   (unaff_ESI - *(int *)(unaff_RBP + -0x61)) + 1);

-      }

+    FveNvcWriteBackReset(param_1,1);

+  }

+  else {

+    uVar6 = 0x80000011;

+  }

 LAB_1:

-      uVar4 = 0x4003b000;

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

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

-         (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-        uVar4 = WPP_SF_D(WPP_GLOBAL_Control[3],0x13c,

-                         &WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,iVar3);

-      }

-      return uVar4;

-    }

-    in_R11 = *(char **)(unaff_RBP + -0x51);

-  } while( true );

+  FvepReleaseDevFveLock(local_c8);

+  if (_Dst != (undefined8 *)0x0) {

+    ExFreePoolWithTag(_Dst,0x30455646);

+  }

+  if (lVar10 != 0) {

+    ExFreePoolWithTag(lVar10,0x65455646);

+  }

+LAB_0:

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

+    FveEowControlFree((undefined1 *)local_res20);

+    local_res20 = (longlong *)0x0;

+  }

+  if (local_e8 != 0) {

+    DeleteKey(local_e8);

+  }

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0xa7,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids,uVar6);

+  }

+  return uVar6;

 }
```

## `FveLoadWipeInfo`  (modified)

```diff
--- FveLoadWipeInfo
+++ FveLoadWipeInfo
@@ -1,12 +1,273 @@
+

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

 

 ulonglong FveLoadWipeInfo(longlong *param_1,ushort *param_2,longlong *param_3,longlong *param_4)

 

 {

-  uint unaff_EBX;

+  char *pcVar1;

+  byte bVar2;

+  longlong lVar3;

+  longlong *plVar4;

+  ushort uVar5;

+  int iVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  ulonglong uVar9;

+  ushort *puVar10;

+  undefined8 uVar11;

+  undefined2 uVar12;

+  ushort uVar13;

+  ulonglong *puVar14;

+  longlong lVar15;

+  uint uVar16;

+  ushort *puVar17;

+  ulonglong uVar18;

+  longlong lVar19;

+  undefined1 auStackY_1e8 [32];

+  uint local_198;

+  ushort local_194;

+  uint local_190;

+  uint local_180;

+  longlong local_170 [6];

+  ulonglong local_140;

+  ulonglong uStack_138;

+  ushort *local_130;

+  longlong *local_128;

+  longlong *local_120;

+  undefined *local_118;

+  undefined8 uStack_110;

+  undefined8 local_108;

+  ushort local_f8 [72];

+  undefined8 local_68;

+  ulonglong uStack_60;

+  undefined8 local_58;

+  ulonglong local_50;

   

-  if (4 < *(byte *)((longlong)param_1 + 0x29)) {

-    WPP_SF_D(param_1[3],0x32,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,unaff_EBX);

-  }

-  return (ulonglong)unaff_EBX;

+  local_50 = __security_cookie ^ (ulonglong)auStackY_1e8;

+  uVar8 = 0;

+  local_58 = 0;

+  local_170[5] = 0;

+  local_140 = 0;

+  uStack_138 = 0;

+  local_68 = 0;

+  uStack_60 = 0;

+  local_130 = param_2;

+  local_128 = param_3;

+  local_120 = param_4;

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],99,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids);

+  }

+  local_198 = 0;

+  local_108 = 0;

+  local_118 = (undefined *)0x0;

+  uStack_110 = 0;

+  memset(local_f8,0,0x90);

+  uVar16 = *(uint *)((longlong)param_1 + 0x49c);

+  local_170[2] = 0;

+  local_170[3] = 0;

+  local_170[0] = 0;

+  local_170[1] = 0;

+  if (((uVar16 & uVar16 - 1) == 0) && (uVar16 != 0)) {

+    local_180 = uVar16 + 0x1ff & ~(uVar16 - 1);

+  }

+  else {

+    local_180 = 0x200;

+    iVar6 = (int)(0x200 % (ulonglong)uVar16);

+    if (iVar6 != 0) {

+      local_180 = (uVar16 - iVar6) + 0x200;

+    }

+  }

+  local_194 = 0;

+  *param_3 = 0;

+  puVar17 = local_f8;

+  if (param_2 != (ushort *)0x0) {

+    puVar17 = param_2;

+  }

+  local_190 = 0xffffffff;

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

+    *param_4 = 0;

+    param_4[1] = 0;

+  }

+  lVar19 = 2;

+  if (puVar17 == local_f8) {

+    uVar7 = FveVolumeInitInfo((longlong)param_1,puVar17);

+    uVar18 = uVar7 & 0xffffffff;

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

+  }

+  uVar18 = 0xc0210002;

+  uVar7 = uVar8;

+  do {

+    local_170[5] = 0;

+    uVar16 = (uint)uVar8;

+    uVar8 = FveWipeInfoFileCreate((longlong)param_1,puVar17,uVar16,'\0',local_170 + uVar8);

+    if ((int)uVar8 < 0) {

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

+          ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+         (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+        WPP_SF_Ld(WPP_GLOBAL_Control[3],100,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,uVar16)

+        ;

+      }

+    }

+    else {

+      lVar15 = *(undefined8 *)((longlong)local_170 + uVar7);

+      puVar14 = &local_140;

+      local_170[4] = lVar15;

+      iVar6 = ZwQueryInformationFile(lVar15,puVar14,&local_68,0x18);

+      if (iVar6 < 0) {

+LAB_1:

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

+            ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_Ld(WPP_GLOBAL_Control[3],0x65,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,

+                    uVar16);

+        }

+      }

+      else {

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

+        if (uStack_60 < 0x100000000) {

+          if ((uint)uStack_60 < local_180) {

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

+                ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+               (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_lDd(WPP_GLOBAL_Control[3],0x67,local_140 & 0xffffffff,uVar16);

+            }

+          }

+          else {

+            uVar8 = uStack_60;

+            if (0xfe00 < (uint)uStack_60) {

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

+                  ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                 (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_lDD(WPP_GLOBAL_Control[3],puVar14,local_140 & 0xffffffff,uVar16);

+              }

+              uVar8 = 0xfe00;

+            }

+            uVar9 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                              ();

+            uVar11 = 0x108;

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

+              uVar11 = 0x100;

+            }

+            puVar10 = (ushort *)ExAllocatePool2(uVar11,uVar8 & 0xffffffff,0x30455646);

+            *(ushort **)((longlong)local_170 + uVar7 + 0x10) = puVar10;

+            if (puVar10 == (ushort *)0x0) {

+              uVar18 = 0xc000009a;

+              goto LAB_0;

+            }

+            iVar6 = ZwReadFile(local_170[4],0,0,0);

+            if (((iVar6 < 0) || ((int)local_140 < 0)) || (uStack_138 != (uVar8 & 0xffffffff))) {

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

+                  ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                 (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                uVar11 = WPP_GLOBAL_Control[3];

+                uVar12 = 0x69;

+LAB_2:

+                WPP_SF_Ld(uVar11,uVar12,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,uVar16);

+              }

+            }

+            else {

+              iVar6 = FveValidateWipeInfo((uint)uVar8,puVar10,*(uint *)(local_130 + 0x34));

+              if (-1 < iVar6) {

+                bVar2 = *(byte *)((longlong)puVar10 + 3);

+                local_198 = local_198 + 1;

+                if (local_190 == 0xffffffff) {

+LAB_3:

+                  local_194 = (ushort)bVar2;

+                  local_190 = uVar16;

+                }

+                else {

+                  uVar13 = bVar2 - local_194;

+                  uVar5 = local_194 - bVar2;

+                  if (local_194 < bVar2) {

+                    if (uVar13 < (ushort)(uVar5 + 0xff)) goto LAB_3;

+                  }

+                  else if ((ushort)(uVar13 + 0xff) < uVar5) goto LAB_3;

+                }

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

+                    ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                   (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  WPP_SF_lL(WPP_GLOBAL_Control[3],0x6b,WPP_GLOBAL_Control,uVar16);

+                }

+                goto LAB_4;

+              }

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

+                  ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                 (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                uVar11 = WPP_GLOBAL_Control[3];

+                uVar12 = 0x6a;

+                goto LAB_2;

+              }

+            }

+            ExFreePoolWithTag(puVar10,0x30455646);

+            *(undefined8 *)((longlong)local_170 + uVar7 + 0x10) = 0;

+            lVar15 = local_170[4];

+          }

+        }

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

+                 ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_lid(WPP_GLOBAL_Control[3],0x66,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,

+                     uVar16);

+        }

+      }

+      ZwClose(lVar15);

+      *(undefined8 *)((longlong)local_170 + uVar7) = 0;

+    }

+LAB_4:

+    uVar8 = (ulonglong)(uVar16 + 1);

+    uVar7 = uVar7 + 8;

+  } while (uVar16 + 1 < 2);

+  if ((local_198 == 0) || (1 < local_190)) {

+    local_118 = &FVE_METADATA_CORRUPT_ERROR;

+    uStack_110 = CONCAT44(0xc0210002,(undefined4)uStack_110);

+    FveLogEvent(*param_1,(longlong *)&local_118);

+  }

+  else {

+    uVar18 = (ulonglong)(-(uint)(local_198 < 2) & 0x80210001);

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

+        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+       (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      WPP_SF_lL(WPP_GLOBAL_Control[3],0x6c,WPP_GLOBAL_Control,local_190);

+    }

+    plVar4 = local_128;

+    lVar15 = local_170[(ulonglong)local_190 + 2];

+    local_170[(ulonglong)local_190 + 2] = 0;

+    pcVar1 = (char *)(lVar15 + 3);

+    *pcVar1 = *pcVar1 + '\x01';

+    *plVar4 = lVar15;

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

+      *local_120 = local_170[0];

+      local_120[1] = local_170[1];

+      local_170[0] = 0;

+      local_170[1] = 0;

+    }

+  }

+LAB_0:

+  lVar15 = 0;

+  do {

+    lVar3 = *(longlong *)((longlong)local_170 + lVar15 + 0x10);

+    if (lVar3 != 0) {

+      ExFreePoolWithTag(lVar3,0x30455646);

+      *(undefined8 *)((longlong)local_170 + lVar15 + 0x10) = 0;

+    }

+    if (*(longlong *)((longlong)local_170 + lVar15) != 0) {

+      ZwClose();

+      *(undefined8 *)((longlong)local_170 + lVar15) = 0;

+    }

+    lVar15 = lVar15 + 8;

+    lVar19 = lVar19 + -1;

+  } while (lVar19 != 0);

+  if (puVar17 == local_f8) {

+    FveVolumeCleanupInfo(puVar17);

+  }

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x6d,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,(int)uVar18

+            );

+  }

+  return uVar18;

 }
```

## `FvepWriteInformation`  (modified)

```diff
--- FvepWriteInformation
+++ FvepWriteInformation
@@ -1,32 +1,385 @@
+

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

 

 ulonglong FvepWriteInformation

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

                     ulonglong *param_6,char param_7,int param_8,char param_9)

 

 {

-  uint uVar1;

-  longlong unaff_RBP;

-  undefined1 unaff_SIL;

-  longlong unaff_RDI;

-  undefined1 unaff_R12B;

-  byte unaff_R13B;

-  char unaff_R14B;

-  undefined8 *unaff_R15;

+  bool bVar1;

+  bool bVar2;

+  char cVar3;

+  char cVar4;

+  uint uVar5;

+  undefined8 *puVar6;

+  ulonglong uVar7;

+  char *pcVar8;

+  longlong *plVar9;

+  longlong *plVar10;

+  undefined8 uVar11;

+  undefined2 uVar12;

+  ulonglong uVar13;

+  byte *_Dst;

+  uint uVar14;

+  undefined4 uVar15;

+  uint uVar16;

+  undefined1 auStackY_148 [32];

+  uint local_104;

+  char local_100;

+  uint local_fc;

+  byte *local_f8;

+  undefined8 *local_f0;

+  undefined *local_e8;

+  undefined8 uStack_e0;

+  undefined8 local_d8;

+  longlong *local_d0;

+  undefined1 *local_c8;

+  undefined8 local_c0;

+  undefined8 uStack_b8;

+  undefined8 local_a8 [4];

+  uint *local_88;

+  undefined4 local_80;

+  undefined4 local_7c;

+  byte **local_78;

+  undefined4 local_70;

+  undefined4 local_6c;

+  undefined8 *local_68;

+  undefined4 local_60;

+  undefined4 local_5c;

+  ulonglong local_58;

   

-  *unaff_R15 = param_3;

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

-    FveFindExtendedInfoInDataset((uint *)(unaff_RBP + 0x40),(longlong *)&stack0x00000090);

-  }

-  func_0x000140081e8c();

+  local_58 = __security_cookie ^ (ulonglong)auStackY_148;

+  local_100 = param_2;

+  local_d0 = param_4;

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

-      ((unaff_R13B & (byte)*(undefined4 *)((longlong)WPP_GLOBAL_Control + 0x2c)) != 0)) &&

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_(WPP_GLOBAL_Control[3],0x6c,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

-  }

-  uVar1 = *(uint *)(unaff_RDI + 0x318);

-  if (((uVar1 & 0x17f) == 0) || ((uVar1 & 0x40) != 0)) {

-    unaff_SIL = unaff_R12B;

-  }

-  return (ulonglong)CONCAT31((int3)(uVar1 >> 8),unaff_SIL);

+    WPP_SF_(WPP_GLOBAL_Control[3],0x53,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+  }

+  local_fc = 0;

+  local_d8 = 0;

+  local_104 = 0;

+  puVar6 = &local_c0;

+  bVar1 = false;

+  bVar2 = false;

+  local_e8 = (undefined *)0x0;

+  uStack_e0 = 0;

+  local_c0 = 0;

+  uStack_b8 = 0;

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

+    puVar6 = (undefined8 *)((longlong)param_3 + 0x50);

+  }

+  local_c0 = *puVar6;

+  uStack_b8 = puVar6[1];

+  if ((int)param_1[2] == 2) {

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

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

+       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      WPP_SF_(WPP_GLOBAL_Control[3],0x54,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+    }

+    uVar13 = 0xc0210034;

+    goto LAB_0;

+  }

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

+    if (param_5 == 0) {

+      if (*(short *)((longlong)param_3 + 10) == 2) {

+        uVar13 = (ulonglong)*(ushort *)((longlong)param_3 + 8) << 4;

+      }

+      else if (*(short *)((longlong)param_3 + 10) == 1) {

+        uVar13 = (ulonglong)*(ushort *)((longlong)param_3 + 8);

+      }

+      else {

+        uVar13 = 0;

+      }

+      uVar7 = FveInformationIsValid((longlong)param_3,uVar13,'\0');

+      uVar13 = uVar7 & 0xffffffff;

+      if ((int)uVar7 < 0) {

+        if ((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) {

+          return uVar13;

+        }

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

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_D(WPP_GLOBAL_Control[3],0x55,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                   (int)uVar7);

+        }

+        goto LAB_0;

+      }

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

+        if (param_6 == (ulonglong *)0x0) goto LAB_1;

+        uVar7 = FveDatumMustBe(param_6,1);

+        uVar13 = uVar7 & 0xffffffff;

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

+      }

+      uVar14 = 0;

+      pcVar8 = (char *)((longlong)param_4 + 0xc);

+      do {

+        if (*pcVar8 != '\0') {

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

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

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_D(WPP_GLOBAL_Control[3],0x56,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                     uVar14);

+          }

+          uVar13 = 0xc0210002;

+          goto LAB_0;

+        }

+        uVar14 = uVar14 + 1;

+        pcVar8 = pcVar8 + 0x18;

+      } while (uVar14 < 3);

+    }

+    else if ((param_5 - 1 & 0xfffffffd) == 0) {

+      uVar14 = 0;

+      pcVar8 = (char *)((longlong)param_4 + 0xd);

+      do {

+        if (*pcVar8 != '\0') goto LAB_2;

+        uVar14 = uVar14 + 1;

+        pcVar8 = pcVar8 + 0x18;

+      } while (uVar14 < 3);

+      if (uVar14 == 3) {

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

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

+           (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_(WPP_GLOBAL_Control[3],0x57,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+        }

+        uVar13 = 0;

+        goto LAB_0;

+      }

+    }

+LAB_2:

+    uVar13 = 0;

+    plVar10 = param_4 + 1;

+    do {

+      if ((int)*plVar10 != 0) {

+        uVar14 = *(uint *)(param_4 + uVar13 * 3 + 1);

+        uVar13 = (ulonglong)uVar14;

+        if (uVar14 != 0) {

+          if ((param_5 == 1) && (uVar14 != *(uint *)((longlong)param_1 + 0x7cc))) {

+            if (((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

+               (((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 4) == 0 ||

+                (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)))) goto LAB_1;

+            uVar12 = 0x59;

+            goto LAB_3;

+          }

+          uVar7 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                            ();

+          uVar11 = 0x48;

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

+            uVar11 = 0x40;

+          }

+          local_f0 = (undefined8 *)ExAllocatePool2(uVar11);

+          if (local_f0 == (undefined8 *)0x0) {

+            uVar13 = 0xc000009a;

+            goto LAB_0;

+          }

+          local_c8 = (undefined1 *)((longlong)local_f0 + uVar13);

+          if (param_5 < 2) {

+            _Dst = local_c8 + uVar13;

+            local_f8 = _Dst;

+            memset(_Dst,0,uVar13);

+            if (param_5 == 0) {

+              uVar7 = FveBuildInformationBuffer

+                                (param_3,uVar14,local_100,param_6,(ulonglong *)(param_1 + 0x77),

+                                 uVar13,_Dst);

+              uVar13 = uVar7 & 0xffffffff;

+              if ((int)uVar7 < 0) goto LAB_4;

+            }

+            else {

+              memmove(_Dst,(void *)param_1[0xfa],uVar13);

+            }

+          }

+          else {

+            _Dst = (byte *)0x0;

+            local_f8 = (byte *)0x0;

+          }

+          uVar16 = 0;

+          pcVar8 = (char *)((longlong)local_d0 + 0xd);

+          goto LAB_5;

+        }

+        break;

+      }

+      uVar14 = (int)uVar13 + 1;

+      uVar13 = (ulonglong)uVar14;

+      plVar10 = plVar10 + 3;

+    } while (uVar14 < 3);

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

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

+       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      uVar12 = 0x58;

+LAB_3:

+      WPP_SF_(WPP_GLOBAL_Control[3],uVar12,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+    }

+  }

+LAB_1:

+  uVar13 = 0xc000000d;

+LAB_0:

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x5e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,(int)uVar13

+            );

+  }

+  return uVar13;

+LAB_5:

+  do {

+    plVar10 = local_d0;

+    if (pcVar8[-1] == '\0') {

+      if (((param_5 - 1 & 0xfffffffd) == 0) && (*pcVar8 == '\0')) {

+        plVar9 = (longlong *)&WPP_GLOBAL_Control;

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

+           ((plVar9 = (longlong *)(ulonglong)*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c),

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

+            (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+          uVar12 = 0x5b;

+          goto LAB_6;

+        }

+      }

+      else {

+        if (param_5 == 0) {

+          FvePerfTraceDevMetadata

+                    ((longlong)param_1,&FVE_PERF_METADATA_WRITE_START,uVar16,

+                     *(undefined8 *)(pcVar8 + -0xd));

+        }

+        if ((!bVar1) && (param_9 != '\0')) {

+          uVar5 = FveNvcWriteBackDisable(param_1,0,'\0');

+          uVar13 = (ulonglong)uVar5;

+          if ((int)uVar5 < 0) goto LAB_4;

+          bVar1 = true;

+        }

+        uVar13 = FvepWriteInformationContent

+                           (param_1,*(ulonglong *)(pcVar8 + -0xd),(undefined8 *)_Dst,local_f0,

+                            (longlong)local_c8,uVar14,param_8);

+        if (param_5 == 0) {

+          FvePerfTraceDevMetadata

+                    ((longlong)param_1,&FVE_PERF_METADATA_WRITE_STOP,uVar16,

+                     *(undefined8 *)(pcVar8 + -0xd));

+        }

+        uVar5 = (uint)uVar13;

+        if ((int)uVar5 < 0) {

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

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

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_Ld(WPP_GLOBAL_Control[3],0x5d,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                      uVar16);

+          }

+          local_104 = local_104 & 0xff;

+          pcVar8[-1] = uVar5 != 0x80000016;

+          plVar9 = param_1 + 0x7f;

+          *pcVar8 = '\x01';

+          if (plVar10 == plVar9) {

+            local_104 = 1;

+          }

+          _Dst = local_f8;

+          local_fc = uVar5;

+          if ((!bVar2) && (param_5 == 0)) goto LAB_7;

+        }

+        else {

+          *pcVar8 = '\0';

+          plVar9 = (longlong *)&WPP_GLOBAL_Control;

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

+              (plVar9 = (longlong *)(ulonglong)*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c),

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            plVar9 = (longlong *)

+                     WPP_SF_D(WPP_GLOBAL_Control[3],0x5c,

+                              &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar16);

+          }

+          _Dst = local_f8;

+          if (param_5 == 0) {

+            bVar2 = true;

+            plVar9 = (longlong *)FveInitiateFveInfoCopyUpdate((longlong)param_1,local_f8);

+          }

+        }

+      }

+    }

+    else {

+      plVar9 = (longlong *)&WPP_GLOBAL_Control;

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

+          (plVar9 = (longlong *)(ulonglong)*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c),

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

+         (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+        uVar12 = 0x5a;

+LAB_6:

+        plVar9 = (longlong *)

+                 WPP_SF_D(WPP_GLOBAL_Control[3],uVar12,

+                          &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar16);

+      }

+    }

+    uVar16 = uVar16 + 1;

+    pcVar8 = pcVar8 + 0x18;

+  } while (uVar16 < 3);

+  cVar4 = (char)local_104;

+  if ((int)local_fc < 0) {

+    local_104 = (uint)CONCAT71((int7)((ulonglong)plVar9 >> 8),cVar4);

+    if (bVar2) {

+      local_d8 = 0;

+      uVar13 = 0x80210001;

+      local_e8 = &FVE_METADATA_PARTIAL_COMMIT;

+      uStack_e0 = CONCAT44(0x80210001,(undefined4)uStack_e0);

+      FveLogEventEx(*param_1,(longlong *)&local_e8,'\0','\x01');

+      uVar15 = 4;

+      if ((4 < DAT_8) && (cVar3 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar3 != '\0'))

+      {

+        local_7c = 0;

+        local_88 = &local_fc;

+        local_6c = 0;

+        local_5c = 0;

+        local_104 = param_5;

+        local_78 = (byte **)&local_104;

+        local_68 = &local_c0;

+        local_fc = 0x80210001;

+        local_60 = 0x10;

+        local_80 = uVar15;

+        local_70 = uVar15;

+        _tlgWriteTransfer_EtwWriteTransfer(0x14003b040,&DAT_9,0,0,5,local_a8);

+      }

+    }

+    else {

+LAB_7:

+      uVar16 = local_fc;

+      if ((4 < DAT_8) && (cVar4 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar4 != '\0'))

+      {

+        local_7c = 0;

+        local_88 = &local_fc;

+        local_6c = 0;

+        local_5c = 0;

+        local_78 = &local_f8;

+        local_68 = &local_c0;

+        local_80 = 4;

+        local_f8 = (byte *)CONCAT44(local_f8._4_4_,param_5);

+        local_70 = 4;

+        local_60 = 0x10;

+        local_fc = uVar16;

+        _tlgWriteTransfer_EtwWriteTransfer(0x14003b040,&DAT_10,0,0,5,local_a8);

+      }

+      local_d8 = 0;

+      local_e8 = &FVE_METADATA_FAILED_COMMIT;

+      uStack_e0 = CONCAT44(uVar16,(undefined4)uStack_e0);

+      uVar13 = (ulonglong)uVar16;

+      FveLogEventEx(*param_1,(longlong *)&local_e8,'\0','\x01');

+      cVar4 = (char)local_104;

+    }

+  }

+  else {

+    uVar13 = 0;

+LAB_4:

+    cVar4 = (char)local_104;

+  }

+  puVar6 = local_f0;

+  for (uVar7 = (ulonglong)(uVar14 * 3); uVar7 != 0; uVar7 = uVar7 - 1) {

+    *(undefined1 *)puVar6 = 0;

+    puVar6 = (undefined8 *)((longlong)puVar6 + 1);

+  }

+  ExFreePoolWithTag(local_f0);

+  if (bVar1) {

+    FveNvcWriteBackReset(param_1,0);

+  }

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

+    *(uint *)(param_1 + 0x73) = *(uint *)(param_1 + 0x73) | 1;

+    FveTestDevStateChange(param_1,9,'\x01');

+    if (param_1[0x92] == 0) {

+      FveQueueAutoWorkItem(param_1,FveControlFilesManage,(longlong)param_1);

+    }

+  }

+  goto LAB_0;

 }
```

## `FveInitialDataReadPhase1`  (modified)

```diff
--- FveInitialDataReadPhase1
+++ FveInitialDataReadPhase1
@@ -1,98 +1,724 @@
 

-/* WARNING: Removing unreachable block (ram,0x000140077c72) */

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

 

-ulonglong FveInitialDataReadPhase1(longlong *param_1,int *param_2,uint *param_3)

+uint FveInitialDataReadPhase1(longlong *param_1,int *param_2,uint *param_3)

 

 {

-  char cVar1;

-  ulonglong uVar2;

-  undefined2 uVar3;

-  undefined8 *unaff_RBX;

-  longlong unaff_RBP;

-  undefined4 unaff_EDI;

-  int iVar4;

-  longlong unaff_R12;

-  byte unaff_R14B;

-  longlong unaff_R15;

-  undefined8 uStack0000000000000050;

-  longlong lStack0000000000000058;

-  longlong in_stack_00000068;

+  undefined8 *puVar1;

+  ushort uVar2;

+  undefined1 uVar3;

+  uint uVar4;

+  int iVar5;

+  uint extraout_EAX;

+  void *pvVar6;

+  ulonglong uVar7;

+  longlong lVar8;

+  wchar_t *pwVar9;

+  longlong lVar10;

+  undefined7 extraout_var;

+  byte bVar11;

+  byte bVar12;

+  undefined2 uVar13;

+  undefined8 uVar14;

+  uint uVar16;

+  byte bVar17;

+  uint uVar18;

+  undefined4 uVar19;

+  uint uVar20;

+  undefined1 auStackY_298 [32];

+  undefined8 in_stack_fffffffffffffd88;

+  byte local_238;

+  char local_237;

+  char local_236;

+  char local_235 [5];

+  void *local_230;

+  ushort local_228 [4];

+  int *local_220;

+  int local_218;

+  ulonglong local_210 [2];

+  undefined4 local_200 [2];

+  void *local_1f8;

+  undefined8 uStack_1f0;

+  undefined8 local_1e8;

+  undefined *local_1e0;

+  undefined8 uStack_1d8;

+  undefined8 local_1d0;

+  longlong local_1c8 [2];

+  uint local_1b8 [6];

+  undefined4 local_1a0;

+  char local_198;

+  char cStack_197;

+  undefined6 uStack_196;

+  longlong local_190;

+  undefined8 local_170;

+  undefined8 uStack_168;

+  undefined8 local_160;

+  undefined8 uStack_158;

+  undefined8 local_150;

+  undefined8 uStack_148;

+  undefined8 local_140;

+  undefined8 uStack_138;

+  undefined8 local_130;

+  uint *local_128;

+  longlong local_120;

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined8 local_108;

+  undefined8 uStack_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  undefined8 local_c8;

+  undefined8 uStack_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined4 local_88;

+  undefined4 uStack_84;

+  undefined4 local_80;

+  uint local_78;

+  uint uStack_74;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  uint local_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  ulonglong local_40;

+  longlong *plVar15;

   

-  if (((WPP_GLOBAL_Control != unaff_R15) &&

-      ((unaff_R14B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0)) &&

-     (2 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x41,

-             &WPP_8fa8ffb166c932bc85b25c05668723f4_Traceguids,unaff_EDI);

+  uVar19 = (undefined4)((ulonglong)in_stack_fffffffffffffd88 >> 0x20);

+  local_40 = __security_cookie ^ (ulonglong)auStackY_298;

+  local_48 = 0;

+  local_88 = 0;

+  uStack_84 = 0;

+  lVar10 = 0;

+  local_80 = 0;

+  local_1c8[0] = 0;

+  local_68 = 0;

+  local_60 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  local_1b8[1] = 0;

+  local_78 = 0;

+  uStack_74 = 0;

+  uStack_70 = 0;

+  local_220 = param_2;

+  local_128 = param_3;

+  memset(local_1b8,0,0x8c);

+  uVar18 = 0;

+  local_200[0] = 0;

+  local_1e8 = 0;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x100,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

   }

-  uStack0000000000000050 = 0;

-  lStack0000000000000058 = 0;

-  iVar4 = (int)unaff_R12;

-  func_0x0001400783e0(0,unaff_RBP + -0x60,1);

-  if ((lStack0000000000000058 == unaff_R12) && ((*(uint *)(unaff_RBX[1] + 0x250c) & 0x8000000) == 0)

-     ) {

-    *(byte *)(unaff_RBX + 0x213) = *(byte *)(unaff_RBX + 0x213) & 0xf7;

-    if (((WPP_GLOBAL_Control != unaff_R15) &&

-        ((unaff_R14B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0)) &&

-       (3 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-      uVar3 = 0x44;

-LAB_0:

-      WPP_SF_(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar3,

-              &WPP_8fa8ffb166c932bc85b25c05668723f4_Traceguids);

+  local_218 = 0;

+  local_1d0 = 0;

+  local_120 = param_1[0x7e];

+  *param_2 = 0;

+  local_230 = (void *)0x0;

+  local_1f8 = (void *)0x0;

+  uVar20 = 0x40;

+  local_228[0] = 0;

+  local_1e0 = (undefined *)0x0;

+  uStack_1d8 = 0;

+  bVar11 = 0;

+  local_237 = '\0';

+  local_236 = '\0';

+  local_235[0] = '\0';

+  local_238 = 0;

+  if ((short)param_1[0x21d] == 0) {

+    uVar4 = FveGetPdoName((longlong)param_1,&local_1f8,local_228);

+    uVar2 = local_228[0];

+    pvVar6 = local_1f8;

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

+      uVar7 = (ulonglong)local_228[0];

+      pvVar6 = (void *)ExAllocatePool2(0x40);

+      param_1[0x21e] = (longlong)pvVar6;

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

+        memset(pvVar6,0,uVar7 + 2);

+        local_230 = local_1f8;

+        memmove((void *)param_1[0x21e],local_1f8,uVar7);

+        *(ushort *)(param_1 + 0x21d) = uVar2;

+        *(ushort *)((longlong)param_1 + 0x10ea) = uVar2 + 2;

+        goto LAB_0;

+      }

+      uVar4 = 0xc000009a;

+      pvVar6 = local_1f8;

+      goto LAB_1;

+    }

+LAB_2:

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

+      if ((1 < *param_2 - 2U) && ((*(uint *)((longlong)param_1 + 0x344) & 0x200) == 0)) {

+        SetFveStateEx(param_1,0x8000,0,0,'\x01',3);

+      }

+      goto LAB_3;

     }

   }

   else {

-    *(byte *)(unaff_RBX + 0x213) = *(byte *)(unaff_RBX + 0x213) | unaff_R14B;

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

-    if ((WPP_GLOBAL_Control != unaff_R15) &&

-       (((unaff_R14B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0 &&

-        (3 < *(byte *)(WPP_GLOBAL_Control + 0x29))))) {

-      uVar3 = 0x43;

-      goto LAB_0;

+LAB_0:

+    iVar5 = FveDeviceControlSynchronousEx(param_1[0xd],0x70024,2,(void *)0x0,0,0,0,local_210);

+    if ((iVar5 < 0) && (iVar5 == -0x3fffff5e)) {

+      uVar4 = *(uint *)((longlong)param_1 + 0x344) | 0x100;

+    }

+    else {

+      uVar4 = *(uint *)((longlong)param_1 + 0x344) & 0xfffffeff;

+    }

+    *(uint *)((longlong)param_1 + 0x344) = uVar4;

+    uVar7 = FveResolveIsRoamable((longlong)param_1);

+    uVar4 = (uint)uVar7;

+    pvVar6 = local_230;

+    if ((((int)uVar4 < 0) ||

+        (((*(uint *)(param_1[0xe] + 0x34) & 1) != 0 &&

+         (uVar4 = FveDeviceControlSynchronousEx(param_1[0xd],0x2d4800,2,(void *)0x0,0,0,0,local_210)

+         , pvVar6 = local_230, (int)uVar4 < 0)))) ||

+       (uVar4 = FveDeviceControlSynchronousEx

+                          (param_1[0xd],0x7405c,2,(void *)0x0,0,(longlong)local_1c8,8,local_210),

+       pvVar6 = local_230, (int)uVar4 < 0)) goto LAB_2;

+    if (local_1c8[0] < 0) {

+      param_1[0x7e] = -1;

+      uVar4 = 0xc0000095;

+      goto LAB_1;

+    }

+    param_1[0x7e] = local_1c8[0];

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

+LAB_4:

+      uVar7 = *(ulonglong *)(param_1[1] + 0x2740);

+      if ((uVar7 & 3) == 0) {

+        uVar19 = 0;

+        uVar4 = FveFeatWcosCheck(param_1[1],&local_238,(undefined4 *)0x0,(undefined4 *)0x0,

+                                 (undefined4 *)0x0,(undefined4 *)0x0,(undefined4 *)0x0,

+                                 (undefined4 *)0x0,(undefined4 *)0x0,(undefined4 *)0x0,

+                                 (undefined4 *)0x0,(undefined4 *)0x0);

+        uVar16 = uVar4;

+        bVar17 = local_238;

+        if ((((int)uVar4 < 0) &&

+            (uVar16 = uVar18, (undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

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

+            (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+          WPP_SF_D(WPP_GLOBAL_Control[3],0x10b,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                   uVar4);

+          bVar17 = local_238;

+        }

+      }

+      else {

+        uVar16 = uVar18;

+        bVar17 = (byte)uVar7 >> 1 & 1;

+      }

+      if ((*(byte *)(param_1 + 0x213) & 0x20) != 0) goto LAB_5;

+      if (param_1[0x220] != 0) {

+        if (*(ushort *)((longlong)param_1 + 0x10fa) < 0x4a) {

+          ExFreePoolWithTag(param_1[0x220],0x30455646);

+          param_1[0x220] = 0;

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

+          goto LAB_6;

+        }

+LAB_7:

+        uVar14 = 0x70048;

+        uVar4 = FveDeviceControlSynchronousEx

+                          (param_1[0xd],0x70048,2,(void *)0x0,0,(longlong)local_1b8,0x90,local_210);

+        if ((int)uVar4 < 0) {

+          uVar16 = uVar18;

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

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

+             (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_D(WPP_GLOBAL_Control[3],0x10c,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                     uVar4);

+          }

+        }

+        else {

+          uVar7 = CONCAT71((int7)((ulonglong)uVar14 >> 8),(char)param_1[0x213]) & 0xffffffffffffff7f

+          ;

+          uVar7 = CONCAT71((int7)(uVar7 >> 8),(byte)uVar7 | ~-(local_1b8[0] != 0) & 0x80U) &

+                  0xffffffffffffffbf;

+          bVar12 = (byte)uVar7 | (local_1b8[0] == 1) << 6;

+          plVar15 = (longlong *)CONCAT71((int7)(uVar7 >> 8),bVar12);

+          *(byte *)(param_1 + 0x213) = bVar12;

+          *(undefined4 *)(param_1 + 0x221) = local_1a0;

+          if (local_1b8[0] == 1) {

+            if (((CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x11d2f81fc12a7328) &&

+                (local_190 == 0x3bc93ec9a0004bba)) ||

+               ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)) {

+              bVar11 = 1;

+            }

+            bVar12 = *(byte *)((longlong)param_1 + 0x1099);

+            *(byte *)((longlong)param_1 + 0x1099) = bVar12 & 0xfe | bVar11;

+            iVar5 = memcmp(&local_198,&PARTITION_MSFT_RECOVERY_GUID,0x10);

+            plVar15 = param_1 + 0x21f;

+            *(undefined2 *)plVar15 = 0;

+            *(byte *)((longlong)param_1 + 0x1099) = bVar12 & 0xfc | bVar11 | ~-(iVar5 != 0) & 2U;

+            memset((void *)param_1[0x220],0,(ulonglong)*(ushort *)((longlong)param_1 + 0x10fa));

+            puVar1 = (undefined8 *)param_1[0x220];

+            local_210[0] = 0;

+            *puVar1 = local_170;

+            puVar1[1] = uStack_168;

+            puVar1[2] = local_160;

+            puVar1[3] = uStack_158;

+            puVar1[4] = local_150;

+            puVar1[5] = uStack_148;

+            puVar1[6] = local_140;

+            puVar1[7] = uStack_138;

+            puVar1[8] = local_130;

+            uVar4 = RtlStringCbLengthW((short *)param_1[0x220],

+                                       (ulonglong)*(ushort *)((longlong)param_1 + 0x10fa),

+                                       (longlong *)local_210);

+            pvVar6 = local_230;

+            param_2 = local_220;

+            if (((int)uVar4 < 0) ||

+               (uVar4 = RtlUIntPtrToUShort(local_210[0],(undefined2 *)plVar15), pvVar6 = local_230,

+               param_2 = local_220, (int)uVar4 < 0)) goto LAB_2;

+          }

+          bVar11 = 0;

+          if ((char)param_1[0x213] < '\0') {

+            if (((cStack_197 != '\0') && ((*(uint *)((longlong)param_1 + 0x344) & 0x10) == 0)) ||

+               ((local_198 == -0x11 || ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)))) {

+              bVar11 = 1;

+            }

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

+            plVar15 = (longlong *)0x0;

+            *(byte *)((longlong)param_1 + 0x1099) =

+                 *(byte *)((longlong)param_1 + 0x1099) & 0xfc | bVar11 |

+                 (local_198 != '\'') - 1U & 2;

+            memset((void *)param_1[0x220],0,(ulonglong)*(ushort *)((longlong)param_1 + 0x10fa));

+          }

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

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            pwVar9 = (wchar_t *)param_1[0x220];

+            if ((pwVar9 == (wchar_t *)0x0) || ((short)param_1[0x21f] == 0)) {

+              pwVar9 = L"<NULL>";

+            }

+            WPP_SF_LLS(WPP_GLOBAL_Control[3],plVar15,(ulonglong)local_1b8[0],local_1a0,

+                       CONCAT44(uVar19,local_1b8[0]),pwVar9);

+          }

+          *(byte *)(param_1 + 0x213) = *(byte *)(param_1 + 0x213) | 0x20;

+          *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 3;

+          *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) & 0xe0;

+          uVar16 = uVar4;

+          if (bVar17 != 0) {

+            local_210[0] = 0;

+            local_210[1] = 0;

+            local_1f8 = (void *)0x0;

+            uStack_1f0 = 0;

+            local_98 = 0;

+            uStack_90 = 0;

+            local_e8 = 0;

+            uStack_e0 = 0;

+            local_118 = 0;

+            uStack_110 = 0;

+            local_108 = 0;

+            uStack_100 = 0;

+            local_f8 = 0;

+            uStack_f0 = 0;

+            local_a8 = 0;

+            uStack_a0 = 0;

+            local_d8 = 0;

+            uStack_d0 = 0;

+            local_c8 = 0;

+            uStack_c0 = 0;

+            local_b8 = 0;

+            uStack_b0 = 0;

+            RtlInitUnicodeString(local_210,L"OSDATA");

+            RtlInitUnicodeString(&local_1f8,L"PREINSTALLED");

+            RtlInitUnicodeString(&local_98,L"DATA");

+            RtlInitUnicodeString(&local_e8,L"MAINOS");

+            RtlInitUnicodeString(&local_118,L"BSP");

+            RtlInitUnicodeString(&local_108,L"DPP");

+            RtlInitUnicodeString(&local_f8,L"WSP");

+            RtlInitUnicodeString(&local_a8,L"EFIESP");

+            RtlInitUnicodeString(&local_d8,L"SERVICING_METADATA");

+            RtlInitUnicodeString(&local_c8,L"SERVICING_FILES");

+            RtlInitUnicodeString(&local_b8,L"RESERVE");

+            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xfb;

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x44d523f257434f53)) &&

+                (local_190 == -0x6f659254498cf58)) ||

+               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == ')')) ||

+                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,local_210), iVar5 == 0)))) {

+              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 4;

+            }

+            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xf7;

+            if ((((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                  (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x41967fe057434f53)) &&

+                 (local_190 == -0x7bcb9bae84bdbd65)) ||

+                (((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '*')))) ||

+               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_1f8), iVar5 == 0)) {

+              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 8;

+            }

+            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xdf;

+            if ((((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                  (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x45b94df957434f53)) &&

+                 (local_190 == 0x7c4506f070239e8e)) ||

+                (((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '+')))) ||

+               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_118), iVar5 == 0)) {

+              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x20;

+            }

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

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x43f094cb57434f53)) &&

+                (local_190 == 0x7da5cf103cd733a5)) ||

+               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == ',')) ||

+                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_108), iVar5 == 0)))) {

+              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 2;

+            }

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

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x4631e3e357434f53)) &&

+                (local_190 == -0x558cc7db2dd93a5b)) ||

+               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '-')) ||

+                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_f8), iVar5 == 0)))) {

+              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 1;

+            }

+            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xbf;

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x405e8f4557434f53)) &&

+                (local_190 == -0x2ccfbc7592e7dc76)) ||

+               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '(')) ||

+                ((iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_e8), iVar5 == 0 ||

+                 ((*(uint *)(param_1[0xe] + 0x30) & 0x100) != 0)))))) {

+              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x40;

+            }

+            bVar11 = *(byte *)((longlong)param_1 + 0x109a) & 0xfb;

+            *(byte *)((longlong)param_1 + 0x109a) = bVar11;

+            if ((((*(byte *)(param_1 + 0x213) & 0x40) == 0) ||

+                (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) != 0x4a05c69157434f53)) ||

+               (local_190 != -0x31d62d50c28fb145)) {

+              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_d8);

+              if (iVar5 == 0) {

+                bVar11 = *(byte *)((longlong)param_1 + 0x109a);

+                goto LAB_8;

+              }

+            }

+            else {

+LAB_8:

+              *(byte *)((longlong)param_1 + 0x109a) = bVar11 | 4;

+            }

+            bVar11 = *(byte *)((longlong)param_1 + 0x109a) & 0xf7;

+            *(byte *)((longlong)param_1 + 0x109a) = bVar11;

+            if ((((*(byte *)(param_1 + 0x213) & 0x40) == 0) ||

+                (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) != 0x4014432e57434f53)) ||

+               (local_190 != 0x6a00c0a9ea8d4cae)) {

+              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_c8);

+              if (iVar5 == 0) {

+                bVar11 = *(byte *)((longlong)param_1 + 0x109a);

+                goto LAB_9;

+              }

+            }

+            else {

+LAB_9:

+              *(byte *)((longlong)param_1 + 0x109a) = bVar11 | 8;

+            }

+            *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) & 0xef;

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x460b4b8157434f53)) &&

+                (local_190 == 0x146d13feb6ff19a3)) ||

+               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_b8), iVar5 == 0)) {

+              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 0x10;

+            }

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

+            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

+                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x11d2f81fc12a7328)) &&

+                (local_190 == 0x3bc93ec9a0004bba)) ||

+               (((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == -0x11)) ||

+                 (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_a8), iVar5 == 0)) ||

+                ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)))) {

+              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x80;

+            }

+            bVar11 = *(byte *)((longlong)param_1 + 0x1099);

+            *(byte *)((longlong)param_1 + 0x1099) = bVar11 & 0xef;

+            if (((((bVar11 & 0x2c) == 0) && ((*(byte *)((longlong)param_1 + 0x109a) & 3) == 0)) &&

+                (((bVar11 & 0x40) == 0 &&

+                 ((-1 < (char)(bVar11 & 0xef) &&

+                  ((*(byte *)((longlong)param_1 + 0x109a) & 0x1c) == 0)))))) &&

+               ((*(uint *)((longlong)param_1 + 0x344) & 0x10) == 0)) {

+              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_98);

+              if ((iVar5 == 0) ||

+                 ((((((short)param_1[0x21f] == 0 && ((*(byte *)(param_1 + 0x213) & 0x40) != 0)) &&

+                    (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x4433b9e5ebd0a0a2)) &&

+                   (local_190 == -0x3866d94849973f79)) ||

+                  (((char)param_1[0x213] < '\0' && (local_198 == '\a')))))) {

+                *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x10

+                ;

+              }

+            }

+          }

+        }

+LAB_5:

+        uVar4 = uVar16;

+        uVar19 = 0;

+        if ((int)param_1[2] == 0) {

+          *local_220 = 0;

+          pvVar6 = local_230;

+          param_2 = local_220;

+          goto LAB_2;

+        }

+        iVar5 = FveGetBandProperties(param_1,&local_237,&local_236,local_235);

+        if (iVar5 < 0) {

+          if (local_237 == '\0') goto LAB_10;

+        }

+        else {

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

+            *(uint *)((longlong)param_1 + 0x344) = *(uint *)((longlong)param_1 + 0x344) | 0x200;

+            *(char *)((longlong)param_1 + 0x7c9) = local_236;

+            if (local_235[0] == '\0') {

+              uVar20 = 0x8000;

+            }

+            else {

+              uVar19 = 0xc0210000;

+            }

+            SetFveStateEx(param_1,uVar20,0,0,'\x01',3);

+            *(undefined4 *)((longlong)param_1 + 0x31c) = uVar19;

+            pvVar6 = local_230;

+            param_2 = local_220;

+            goto LAB_2;

+          }

+LAB_10:

+          *(uint *)((longlong)param_1 + 0x344) = *(uint *)((longlong)param_1 + 0x344) & 0xfffffdff;

+        }

+        if ((ulonglong)param_1[0x7e] < 0x2000) goto LAB_11;

+        uVar7 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                          ();

+        uVar14 = 0x48;

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

+          uVar14 = 0x40;

+        }

+        lVar10 = ExAllocatePool2(uVar14,0x2000);

+        if (lVar10 == 0) goto LAB_12;

+        uVar7 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,2,(byte *)0x0,0,0x2000,lVar10);

+        uVar4 = (uint)uVar7;

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

+          uVar3 = FveCheckVolumeTypeEx(lVar10,0x2000,local_128);

+          local_218 = (int)CONCAT71(extraout_var,uVar3);

+          if (local_218 - 2U < 2) {

+            uVar7 = FveWorkerInit((longlong)param_1);

+            uVar4 = (uint)uVar7;

+            if ((int)uVar4 < 0) goto LAB_13;

+          }

+LAB_11:

+          *local_220 = local_218;

+          pvVar6 = local_230;

+          param_2 = local_220;

+          if (lVar10 == 0) goto LAB_2;

+        }

+LAB_13:

+        param_2 = local_220;

+        ExFreePoolWithTag(lVar10,0x30455646);

+        pvVar6 = local_230;

+        goto LAB_2;

+      }

+LAB_6:

+      lVar8 = ExAllocatePool2(0x100,0x4a);

+      param_1[0x220] = lVar8;

+      if (lVar8 != 0) {

+        *(undefined4 *)(param_1 + 0x21f) = 0x4a0000;

+        goto LAB_7;

+      }

+LAB_12:

+      uVar4 = 0xc000009a;

+      pvVar6 = local_230;

+    }

+    else {

+      uVar4 = FveDeviceControlSynchronousEx

+                        (param_1[0xd],0x70000,2,(void *)0x0,0,(longlong)&local_58,0x18,local_210);

+      pvVar6 = local_230;

+      param_2 = local_220;

+      if ((int)uVar4 < 0) goto LAB_2;

+      *(uint *)((longlong)param_1 + 0x49c) = local_48._4_4_;

+      *(uint *)(param_1 + 0x95) = local_48._4_4_;

+      uStack_84 = 0;

+      local_80 = 0;

+      local_88 = 6;

+      uStack_70 = 0;

+      local_68 = 0;

+      local_60 = 0;

+      local_78 = 2;

+      uStack_74 = 1;

+      iVar5 = FveDeviceControlSynchronousEx

+                        (param_1[0xd],0x2d1400,2,&local_88,0xc,(longlong)&local_78,0x1c,local_210);

+      if (iVar5 < 0) {

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

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

+           (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_D(WPP_GLOBAL_Control[3],0x101,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                   iVar5);

+        }

+      }

+      else {

+        if ((((0x1b < local_78) && (0x1b < uStack_74)) && ((uint)local_68 != 0)) &&

+           ((((uint)local_68 == local_48._4_4_ && ((uint)local_68 <= local_68._4_4_)) &&

+            (((local_68._4_4_ & local_68._4_4_ - 1) == 0 && (local_68._4_4_ != 0)))))) {

+          uVar4 = (uint)local_68 - 1;

+          if ((uVar4 & (uint)local_68) == 0) {

+            if ((local_68._4_4_ & uVar4) == 0) {

+              uVar4 = local_60 & uVar4;

+LAB_14:

+              if (uVar4 == 0) {

+                *(uint *)(param_1 + 0x95) = local_68._4_4_;

+                *(uint *)((longlong)param_1 + 0x4a4) = local_68._4_4_;

+                goto LAB_15;

+              }

+            }

+          }

+          else if (local_68._4_4_ % (uint)local_68 == 0) {

+            uVar4 = local_60 % (uint)local_68;

+            goto LAB_14;

+          }

+        }

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

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

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_(WPP_GLOBAL_Control[3],0x102,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+        }

+      }

+LAB_15:

+      iVar5 = FsRtlGetVirtualDiskNestingLevel

+                        (param_1[0xd],(undefined4 *)((longlong)param_1 + 0x4ac));

+      if (iVar5 == -0x3fffff66) {

+        uVar4 = 0xc000009a;

+        pvVar6 = local_230;

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

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

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          uVar13 = 0x103;

+          uVar4 = 0xc000009a;

+LAB_16:

+          WPP_SF_D(WPP_GLOBAL_Control[3],uVar13,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                   uVar4);

+          pvVar6 = local_230;

+        }

+      }

+      else {

+        if (iVar5 < 0) {

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

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

+             (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_D(WPP_GLOBAL_Control[3],0x104,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                     iVar5);

+          }

+          *(undefined4 *)((longlong)param_1 + 0x4ac) = 0;

+        }

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

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

+           (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_LLLL(WPP_GLOBAL_Control[3],0x105,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                      *(undefined4 *)((longlong)param_1 + 0x49c));

+        }

+        if ((*(uint *)((longlong)param_1 + 0x344) & 0x200000) == 0) {

+          local_228[0] = local_228[0] & 0xff00;

+          local_1f8 = (void *)0x0;

+          local_210[0] = 0;

+          FveResolveTpVolume((longlong)param_1,(byte *)local_228,(ulonglong *)&local_1f8,local_210);

+          param_1[0x9b] = (longlong)local_1f8;

+          param_1[0x9c] = local_210[0];

+          if ((char)local_228[0] == '\0') {

+            uVar4 = *(uint *)((longlong)param_1 + 0x344) & 0xffffefff | 0x200000;

+          }

+          else {

+            uVar4 = *(uint *)((longlong)param_1 + 0x344) | 0x201000;

+          }

+          *(uint *)((longlong)param_1 + 0x344) = uVar4;

+        }

+        uVar4 = FveCheckStorageLogicalCopies((longlong)param_1);

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

+          FveCheckIceSupport((longlong)param_1);

+          pvVar6 = local_230;

+          param_2 = local_220;

+          uVar4 = extraout_EAX;

+          if ((int)extraout_EAX < 0) goto LAB_2;

+          local_200[0] = 1;

+          iVar5 = FveDeviceControlSynchronousEx

+                            (param_1[0xd],0x2d19f4,2,local_200,4,(longlong)&local_1e8,8,local_210);

+          if (iVar5 < 0) {

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

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

+               (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_D(WPP_GLOBAL_Control[3],0x107,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                       iVar5);

+            }

+          }

+          else if ((int)local_1e8 == 1) {

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

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

+               (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_D(WPP_GLOBAL_Control[3],0x109,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                       local_1e8._4_4_ & 1);

+            }

+            *(byte *)((longlong)param_1 + 0x109c) =

+                 local_1e8._4_1_ & 1 | *(byte *)((longlong)param_1 + 0x109c) & 0xfe;

+          }

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

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

+                  (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_D(WPP_GLOBAL_Control[3],0x108,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                     (int)local_1e8);

+          }

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

+            uVar4 = FveUpdateIsOnRdvPolicyExclusionList(param_1);

+            if ((int)uVar4 < 0) {

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

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

+                 (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_D(WPP_GLOBAL_Control[3],0x10a,

+                         &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar4);

+              }

+              local_1e0 = &FVE_CHECK_RDV_EXCLUSION_LIST_ERROR;

+              uStack_1d8 = CONCAT44(uVar4,(undefined4)uStack_1d8);

+              local_1d0 = 0;

+              FveLogEventEx(*param_1,(longlong *)&local_1e0,'\0','\x01');

+              local_1e0 = (undefined *)0x0;

+              uStack_1d8 = 0;

+              local_1d0 = 0;

+            }

+            *(byte *)((longlong)param_1 + 0x109b) = *(byte *)((longlong)param_1 + 0x109b) | 2;

+          }

+          goto LAB_4;

+        }

+        pvVar6 = local_230;

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

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

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          uVar13 = 0x106;

+          goto LAB_16;

+        }

+      }

     }

   }

-  *(byte *)(unaff_RBX + 0x213) = *(byte *)(unaff_RBX + 0x213) | 4;

-  if ((*(byte *)(unaff_RBX + 0x213) & unaff_R14B) == 0) {

-    if (unaff_RBX[0x219] != 0) {

-      ExUnsubscribeWnfStateChange();

-      unaff_RBX[0x219] = unaff_R12;

-    }

-    if ((*(byte *)(unaff_RBX + 0x213) & unaff_R14B) == 0) goto LAB_1;

+LAB_1:

+  *(uint *)(param_1 + 100) = uVar4;

+  *(uint *)((longlong)param_1 + 0x31c) = uVar4;

+  if (uVar4 == 0xc0000013) {

+    SetFveStateEx(param_1,0x8000,0,0,'\x01',3);

+    param_1[0x7e] = 0;

   }

-  if ((((*(uint *)(unaff_RBX + 99) & 0x40) == 0 && (*(uint *)(unaff_RBX + 99) & 0x17f) != 0) ||

-      ((*(uint *)((longlong)unaff_RBX + 0x344) & 0x200) != 0)) &&

-     ((*(uint *)((longlong)unaff_RBX + 0x344) & 0x4000000) == 0)) {

-    cVar1 = XboxCryptoSupported();

-    FveQueueDelayedAutoWorkItem

-              (unaff_RBX,FveWimHashCheck,(longlong)unaff_RBX,0,unaff_R12,unaff_R12,

-               (longlong *)(ulonglong)(~-(uint)(cVar1 != '\0') & 600000000));

+  else if (((uVar4 != 0xc000000e) && (uVar4 != 0xc000009d)) &&

+          ((uVar4 != 0x80000010 && (uVar4 != 0xc0000185)))) {

+    local_1e0 = &FVE_INIT_FAILED_ERROR;

+    uStack_1d8 = CONCAT44(uVar4,(undefined4)uStack_1d8);

+    local_1d0 = 0;

+    FveLogEventEx(*param_1,(longlong *)&local_1e0,'\0','\x01');

   }

-LAB_1:

-  if (((iVar4 < 0) && (WPP_GLOBAL_Control != unaff_R15)) &&

-     (((unaff_R14B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0 &&

-      (1 < *(byte *)(WPP_GLOBAL_Control + 0x29))))) {

-    WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x45,

-             &WPP_8fa8ffb166c932bc85b25c05668723f4_Traceguids,iVar4);

+  *(uint *)((longlong)param_1 + 0x334) = 6 - (uint)(uVar4 != 0x80000010);

+LAB_3:

+  if ((local_120 == 0) && (param_1[0x7e] != 0)) {

+    FveReInit(param_1,'\x01',3);

   }

-  uVar2 = (ulonglong)*(uint *)(unaff_RBX + 0x214);

-  if ((-1 < (int)*(uint *)(unaff_RBX + 0x214)) || (-1 < iVar4)) {

-    *(int *)(unaff_RBX + 0x214) = iVar4;

+  FveTestDevStateChange(param_1,3,'\x01');

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

+    ExFreePoolWithTag(pvVar6,0);

   }

-  cVar1 = (char)unaff_R12;

-  if (*(char *)(unaff_RBP + 0x28) != cVar1) {

-    uVar2 = func_0x000140078230(unaff_RBP + -0x60);

-    *(char *)(unaff_RBP + 0x28) = cVar1;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x10e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar4);

   }

-  if (*(char *)(unaff_RBP + 0x29) != cVar1) {

-    uVar2 = func_0x000140078230(unaff_RBP + -0x20);

-    *(char *)(unaff_RBP + 0x29) = cVar1;

-  }

-  if (*(longlong *)(unaff_RBP + 0x90) != 0) {

-    uVar2 = ZwClose();

-    *(longlong *)(unaff_RBP + 0x90) = unaff_R12;

-  }

-  if (in_stack_00000068 != 0) {

-    uVar2 = ExFreePoolWithTag(in_stack_00000068,0x30455646);

-  }

-  return CONCAT71((int7)(uVar2 >> 8),*(undefined1 *)(unaff_RBP + 0x80));

+  return uVar4;

 }
```

## `FveBackupBootSectors`  (modified)

```diff
--- FveBackupBootSectors
+++ FveBackupBootSectors
@@ -1,76 +1,198 @@
+

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

 

 int FveBackupBootSectors(longlong *param_1,ulonglong param_2,ulonglong param_3)

 

 {

-  longlong *plVar1;

+  int iVar1;

   ulonglong uVar2;

-  char *pcVar3;

-  int iVar4;

-  int in_EAX;

-  ulonglong uVar5;

-  longlong unaff_RBP;

-  uint unaff_EDI;

-  int unaff_R12D;

-  longlong unaff_R13;

-  longlong *unaff_R14;

+  longlong lVar3;

+  longlong lVar4;

+  undefined8 uVar5;

+  longlong lVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  undefined1 auStackY_1c8 [32];

+  longlong lVar9;

+  undefined *local_188;

+  undefined8 uStack_180;

+  undefined8 local_178;

+  ulonglong local_170;

+  ulonglong local_168;

+  longlong local_160;

+  ulonglong local_158;

+  ulonglong local_150;

+  ulonglong local_148 [2];

+  ulonglong local_138;

+  code *local_f0;

+  longlong local_e8;

+  longlong local_e0;

+  uint local_d8;

+  ulonglong local_48;

   

-  if ((((int)param_1 != in_EAX) && ((*(uint *)((longlong)param_1 + 0x2c) & 2) != 0)) &&

-     (4 < *(byte *)((longlong)param_1 + 0x29))) {

-    WPP_SF_(param_1[3],0x84,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids);

+  local_48 = __security_cookie ^ (ulonglong)auStackY_1c8;

+  local_170 = param_2;

+  local_158 = param_3;

+  memset(local_148,0,0x100);

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x5f,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

   }

-  *(char *)(unaff_R13 + 0x1b0) = (char)unaff_R12D;

-  FveConvResumeRangeIo(unaff_R14,unaff_R13,(char)unaff_R12D);

-  uVar2 = *(ulonglong *)(unaff_RBP + -9);

-  pcVar3 = *(char **)(unaff_RBP + 0x77);

-  if (*(int *)(unaff_RBP + -0x59) == 0) {

-    if (unaff_EDI != 0) {

+  local_168 = 0;

+  lVar6 = 0;

+  local_160 = 0;

+  local_178 = 0;

+  uVar8 = 0x100000;

+  if (param_3 < 0x100000) {

+    uVar8 = param_3 & 0xffffffff;

+  }

+  local_188 = (undefined *)0x0;

+  uStack_180 = 0;

+  local_150 = uVar8;

+  uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+  uVar5 = 0x40;

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

+    uVar5 = 0x48;

+  }

+  lVar3 = ExAllocatePool2(uVar5,uVar8,0x30455646);

+  if (lVar3 == 0) {

+    iVar1 = -0x3fffff66;

+  }

+  else {

+    uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar5 = 0x40;

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

+      uVar5 = 0x48;

+    }

+    lVar4 = ExAllocatePool2(uVar5,uVar8,0x30455646);

+    if (lVar4 == 0) {

+      iVar1 = -0x3fffff66;

+    }

+    else {

+      while (iVar1 = 0, param_3 != 0) {

+        uVar8 = local_150;

+        if (local_158 < (local_150 & 0xffffffff)) {

+          uVar8 = local_158;

+        }

+        uVar2 = uVar8 & 0xffffffff;

+        uVar7 = (uint)uVar8;

+        uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,0,(byte *)0x0,local_168,uVar7,

+                                    lVar3);

+        iVar1 = (int)uVar8;

+        if (iVar1 < 0) goto LAB_0;

+        if (param_1[0x75] == 0) goto LAB_1;

+        InitializeFilterData((longlong)param_1,local_148,'\x01',0,(longlong *)0x0,0);

+        local_138 = local_168;

+        local_f0 = FveFilteredRead;

+        local_e8 = lVar3;

+        local_e0 = lVar3;

+        local_d8 = uVar7;

+        iVar1 = FveParseBlockAndFilter(local_148);

+        DeInitializeFilterData((longlong)param_1,local_148);

+        if (iVar1 < 0) goto LAB_0;

+        if (param_1[0x75] != 0) {

+          uVar8 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

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

+            lVar9 = 0;

+          }

+          else {

+            lVar9 = lVar6;

+            if (((param_1[0x23d] != 0) && (*(int *)(param_1[0x23d] + 0x58) != 0)) && (lVar6 == 0)) {

+              if (param_1[0x79] != 0) {

+                    /* WARNING: Subroutine does not return */

+                KeBugCheckEx(0x120,0xc,0);

+              }

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

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

+                 (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_(WPP_GLOBAL_Control[3],0x60,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids)

+                ;

+              }

+              uVar8 = ExtractFvek(param_1[0x75] + 0x40,(ulonglong *)param_1[0x7a],

+                                  (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                  &local_160);

+              iVar1 = (int)uVar8;

+              lVar6 = local_160;

+              lVar9 = local_160;

+              if (iVar1 < 0) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  WPP_SF_D(WPP_GLOBAL_Control[3],0x61,

+                           &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,iVar1);

+                  lVar6 = local_160;

+                }

+                break;

+              }

+            }

+          }

+          InitializeFilterData((longlong)param_1,local_148,'\x01',0,(longlong *)0x0,lVar9);

+          local_138 = local_170;

+          local_f0 = FveFilteredWrite;

+          local_e8 = lVar3;

+          local_e0 = lVar3;

+          local_d8 = uVar7;

+          iVar1 = FveParseBlockAndFilter(local_148);

+          DeInitializeFilterData((longlong)param_1,local_148);

+          if (-1 < iVar1) goto LAB_1;

+LAB_2:

+          local_188 = &FVE_METADATA_FAILED_COMMIT;

+LAB_3:

+          local_178 = 0;

+          uStack_180 = CONCAT44(iVar1,0xffffffff);

+          FveLogEventEx(*param_1,(longlong *)&local_188,'\0','\x01');

+          break;

+        }

+LAB_1:

+        uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,0,(byte *)0x0,local_170,uVar7,

+                                    lVar3);

+        iVar1 = (int)uVar8;

+        if (iVar1 < 0) goto LAB_2;

+        uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,0,(byte *)0x0,0,0,0);

+        iVar1 = (int)uVar8;

+        if (((iVar1 != -0x3ffffffe) && (iVar1 != -0x3ffffff0)) &&

+           ((iVar1 != -0x3fffff45 && (iVar1 < 0)))) {

+          local_188 = &FVE_METADATA_DISK_FAILED_FLUSH_ERROR;

+          goto LAB_3;

+        }

+        uVar8 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,0,(byte *)0x0,local_170,uVar7,

+                                    lVar4);

+        iVar1 = (int)uVar8;

+        if (iVar1 < 0) {

 LAB_0:

-                    /* WARNING: Subroutine does not return */

-      KeBugCheckEx(0x120,0xc,0,0,0);

+          local_188 = &FVE_METADATA_DISK_FAILED_READBACK_ERROR;

+          goto LAB_3;

+        }

+        uVar8 = RtlCompareMemory(lVar3,lVar4);

+        if (uVar8 != uVar2) {

+          iVar1 = -0x3fffffff;

+          goto LAB_0;

+        }

+        uVar8 = local_170 + uVar2;

+        if ((uVar8 < local_170) || (local_170 = uVar8, uVar2 + local_168 < local_168)) {

+          iVar1 = -0x3fffff6b;

+          break;

+        }

+        local_158 = local_158 - uVar2;

+        local_168 = uVar2 + local_168;

+        param_3 = local_158;

+      }

+    }

+    ExFreePoolWithTag(lVar3,0x30455646);

+    if (lVar4 != 0) {

+      ExFreePoolWithTag(lVar4,0x30455646);

     }

   }

-  else if (unaff_EDI == 0) goto LAB_0;

-  *(int *)(unaff_R14 + 0xa9) = *(int *)(unaff_RBP + -0x59);

-  if (unaff_R12D == 0) {

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

-      unaff_R14[0x7d] = uVar2;

-      UpdateDynamicContext((longlong)unaff_R14,(ulonglong *)0x0,0);

-    }

-    else {

-      UpdateDynamicContext((longlong)unaff_R14,(ulonglong *)0x0,0);

-      uVar5 = unaff_EDI + uVar2;

-      if (uVar5 < uVar2) {

-        iVar4 = -0x3fffff6b;

-        uVar5 = 0xffffffffffffffff;

-      }

-      else {

-        iVar4 = 0;

-      }

-      unaff_R14[0x7d] = uVar5;

-      if (iVar4 < 0) {

-                    /* WARNING: Subroutine does not return */

-        KeBugCheckEx(0x120,0xc,0,0,(longlong)iVar4);

-      }

-    }

-    *(ulonglong *)(*(longlong *)(unaff_R13 + 0x130) + 0x60) = uVar2;

-    *(uint *)(*(longlong *)(unaff_R13 + 0x130) + 0x5c) = unaff_EDI;

+  uVar8 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+  if (((int)uVar8 != 0) && (lVar6 != 0)) {

+    DeleteKey(lVar6);

   }

-  plVar1 = (longlong *)(unaff_R13 + 0x188);

-  FveMoveTailList((longlong *)(unaff_R13 + 0x198),plVar1);

-  *(longlong **)(unaff_R13 + 400) = plVar1;

-  *plVar1 = (longlong)plVar1;

-  FveConvUpdatePriority(unaff_R13,4,1,0,'\0','\x01');

-  FveResumeAllReadsAndWrites(unaff_R14);

-  if (*pcVar3 == '\0') {

-    FvepReleaseDevFveLock(*(longlong **)(unaff_RBP + 0x7f));

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x62,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,iVar1);

   }

-  FveDequeueAndDispatchToSelf(*unaff_R14,(longlong *)(unaff_R13 + 0x198),unaff_R13 + 0x1a8);

-  FveConvUpdatePriority(unaff_R13,4,1,0,'\x01','\0');

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

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

-     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_(WPP_GLOBAL_Control[3],0x85,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids);

-  }

-  return unaff_R12D;

+  return iVar1;

 }
```

## `FveInitialDataReadPhase1`  (modified)

```diff
--- FveInitialDataReadPhase1
+++ FvepReadInformationAndValidation
@@ -1,724 +1,267 @@
 

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

-

-uint FveInitialDataReadPhase1(longlong *param_1,int *param_2,uint *param_3)

+ulonglong FvepReadInformationAndValidation

+                    (longlong *param_1,ulonglong param_2,int param_3,ulonglong *param_4,

+                    undefined8 param_5,undefined8 param_6,undefined8 *param_7,undefined8 *param_8)

 

 {

-  undefined8 *puVar1;

-  ushort uVar2;

-  undefined1 uVar3;

-  uint uVar4;

-  int iVar5;

-  uint extraout_EAX;

-  void *pvVar6;

-  ulonglong uVar7;

-  longlong lVar8;

-  wchar_t *pwVar9;

-  longlong lVar10;

-  undefined7 extraout_var;

-  byte bVar11;

-  byte bVar12;

-  undefined2 uVar13;

-  undefined8 uVar14;

-  uint uVar16;

-  byte bVar17;

-  uint uVar18;

-  undefined4 uVar19;

-  uint uVar20;

-  undefined1 auStackY_298 [32];

-  undefined8 in_stack_fffffffffffffd88;

-  byte local_238;

-  char local_237;

-  char local_236;

-  char local_235 [5];

-  void *local_230;

-  ushort local_228 [4];

-  int *local_220;

-  int local_218;

-  ulonglong local_210 [2];

-  undefined4 local_200 [2];

-  void *local_1f8;

-  undefined8 uStack_1f0;

-  undefined8 local_1e8;

-  undefined *local_1e0;

-  undefined8 uStack_1d8;

-  undefined8 local_1d0;

-  longlong local_1c8 [2];

-  uint local_1b8 [6];

-  undefined4 local_1a0;

-  char local_198;

-  char cStack_197;

-  undefined6 uStack_196;

-  longlong local_190;

-  undefined8 local_170;

-  undefined8 uStack_168;

-  undefined8 local_160;

-  undefined8 uStack_158;

-  undefined8 local_150;

-  undefined8 uStack_148;

-  undefined8 local_140;

-  undefined8 uStack_138;

-  undefined8 local_130;

-  uint *local_128;

-  longlong local_120;

-  undefined8 local_118;

-  undefined8 uStack_110;

-  undefined8 local_108;

-  undefined8 uStack_100;

-  undefined8 local_f8;

-  undefined8 uStack_f0;

-  undefined8 local_e8;

-  undefined8 uStack_e0;

-  undefined8 local_d8;

-  undefined8 uStack_d0;

-  undefined8 local_c8;

-  undefined8 uStack_c0;

-  undefined8 local_b8;

-  undefined8 uStack_b0;

-  undefined8 local_a8;

-  undefined8 uStack_a0;

-  undefined8 local_98;

-  undefined8 uStack_90;

-  undefined4 local_88;

-  undefined4 uStack_84;

-  undefined4 local_80;

-  uint local_78;

-  uint uStack_74;

-  undefined8 uStack_70;

-  undefined8 local_68;

-  uint local_60;

-  undefined8 local_58;

-  undefined8 uStack_50;

-  undefined8 local_48;

-  ulonglong local_40;

-  longlong *plVar15;

+  ulonglong uVar1;

+  undefined2 uVar2;

+  ulonglong uVar3;

+  ulonglong uVar4;

+  byte *pbVar5;

+  undefined8 uVar6;

+  uint uVar7;

+  uint uVar8;

+  byte *pbVar9;

+  uint uVar10;

+  uint uVar11;

+  uint uVar12;

+  ulonglong uVar13;

+  byte *pbVar14;

+  ushort *puVar15;

+  undefined8 in_stack_ffffffffffffff58;

+  byte *local_68;

+  ushort *local_60;

+  ulonglong local_58;

+  ulonglong local_50;

+  ulonglong local_48;

   

-  uVar19 = (undefined4)((ulonglong)in_stack_fffffffffffffd88 >> 0x20);

-  local_40 = __security_cookie ^ (ulonglong)auStackY_298;

-  local_48 = 0;

-  local_88 = 0;

-  uStack_84 = 0;

-  lVar10 = 0;

-  local_80 = 0;

-  local_1c8[0] = 0;

-  local_68 = 0;

-  local_60 = 0;

-  local_58 = 0;

-  uStack_50 = 0;

-  local_1b8[1] = 0;

-  local_78 = 0;

-  uStack_74 = 0;

-  uStack_70 = 0;

-  local_220 = param_2;

-  local_128 = param_3;

-  memset(local_1b8,0,0x8c);

-  uVar18 = 0;

-  local_200[0] = 0;

-  local_1e8 = 0;

+  uVar4 = param_2;

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

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_(WPP_GLOBAL_Control[3],0x100,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

-  }

-  local_218 = 0;

-  local_1d0 = 0;

-  local_120 = param_1[0x7e];

-  *param_2 = 0;

-  local_230 = (void *)0x0;

-  local_1f8 = (void *)0x0;

-  uVar20 = 0x40;

-  local_228[0] = 0;

-  local_1e0 = (undefined *)0x0;

-  uStack_1d8 = 0;

-  bVar11 = 0;

-  local_237 = '\0';

-  local_236 = '\0';

-  local_235[0] = '\0';

-  local_238 = 0;

-  if ((short)param_1[0x21d] == 0) {

-    uVar4 = FveGetPdoName((longlong)param_1,&local_1f8,local_228);

-    uVar2 = local_228[0];

-    pvVar6 = local_1f8;

-    if (-1 < (int)uVar4) {

-      uVar7 = (ulonglong)local_228[0];

-      pvVar6 = (void *)ExAllocatePool2(0x40);

-      param_1[0x21e] = (longlong)pvVar6;

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

-        memset(pvVar6,0,uVar7 + 2);

-        local_230 = local_1f8;

-        memmove((void *)param_1[0x21e],local_1f8,uVar7);

-        *(ushort *)(param_1 + 0x21d) = uVar2;

-        *(ushort *)((longlong)param_1 + 0x10ea) = uVar2 + 2;

-        goto LAB_0;

-      }

-      uVar4 = 0xc000009a;

-      pvVar6 = local_1f8;

-      goto LAB_1;

-    }

+    uVar4 = 0x3c;

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x3c,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,param_3);

+  }

+  uVar1 = *param_4;

+  uVar12 = (uint)param_4[1];

+  uVar8 = *(uint *)((longlong)param_1 + 0x49c);

+  uVar3 = (ulonglong)uVar8;

+  *param_7 = 0;

+  local_68 = (byte *)0x0;

+  local_60 = (ushort *)0x0;

+  if (uVar12 == 0) {

+    uVar12 = 0x10000;

+  }

+  else if (((uVar8 & uVar8 - 1) == 0) && (uVar8 != 0)) {

+    uVar12 = (uVar12 - 1) + uVar8 & ~(uVar8 - 1);

+  }

+  else {

+    uVar4 = (ulonglong)uVar12 % uVar3;

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

+      uVar12 = (uVar12 - (int)uVar4) + uVar8;

+    }

+  }

+  local_48 = (ulonglong)uVar12;

+  local_58 = local_48 + uVar1;

+  if (local_58 < uVar1) {

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

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

+       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      WPP_SF_iDLd(WPP_GLOBAL_Control[3],uVar4,&WPP_GLOBAL_Control,uVar1);

+    }

+    uVar4 = 0xc021001f;

+    pbVar9 = (byte *)0xa96;

+    pbVar5 = (byte *)0x0;

+    goto LAB_0;

+  }

+  pbVar5 = (byte *)0x0;

+  if ((uVar1 != 0) && (local_58 <= param_2)) {

+    uVar4 = uVar3 - 1;

+    uVar13 = uVar4 & uVar3;

+    local_50 = uVar3;

+    if ((uVar13 == 0) && (uVar3 != 0)) {

+      if ((uVar1 & uVar4) == 0) {

+LAB_1:

+        uVar4 = local_58 & uVar4;

 LAB_2:

-    if (-1 < (int)uVar4) {

-      if ((1 < *param_2 - 2U) && ((*(uint *)((longlong)param_1 + 0x344) & 0x200) == 0)) {

-        SetFveStateEx(param_1,0x8000,0,0,'\x01',3);

-      }

-      goto LAB_3;

-    }

-  }

-  else {

-LAB_0:

-    iVar5 = FveDeviceControlSynchronousEx(param_1[0xd],0x70024,2,(void *)0x0,0,0,0,local_210);

-    if ((iVar5 < 0) && (iVar5 == -0x3fffff5e)) {

-      uVar4 = *(uint *)((longlong)param_1 + 0x344) | 0x100;

-    }

-    else {

-      uVar4 = *(uint *)((longlong)param_1 + 0x344) & 0xfffffeff;

-    }

-    *(uint *)((longlong)param_1 + 0x344) = uVar4;

-    uVar7 = FveResolveIsRoamable((longlong)param_1);

-    uVar4 = (uint)uVar7;

-    pvVar6 = local_230;

-    if ((((int)uVar4 < 0) ||

-        (((*(uint *)(param_1[0xe] + 0x34) & 1) != 0 &&

-         (uVar4 = FveDeviceControlSynchronousEx(param_1[0xd],0x2d4800,2,(void *)0x0,0,0,0,local_210)

-         , pvVar6 = local_230, (int)uVar4 < 0)))) ||

-       (uVar4 = FveDeviceControlSynchronousEx

-                          (param_1[0xd],0x7405c,2,(void *)0x0,0,(longlong)local_1c8,8,local_210),

-       pvVar6 = local_230, (int)uVar4 < 0)) goto LAB_2;

-    if (local_1c8[0] < 0) {

-      param_1[0x7e] = -1;

-      uVar4 = 0xc0000095;

-      goto LAB_1;

-    }

-    param_1[0x7e] = local_1c8[0];

-    if (local_1c8[0] == 0) {

-LAB_4:

-      uVar7 = *(ulonglong *)(param_1[1] + 0x2740);

-      if ((uVar7 & 3) == 0) {

-        uVar19 = 0;

-        uVar4 = FveFeatWcosCheck(param_1[1],&local_238,(undefined4 *)0x0,(undefined4 *)0x0,

-                                 (undefined4 *)0x0,(undefined4 *)0x0,(undefined4 *)0x0,

-                                 (undefined4 *)0x0,(undefined4 *)0x0,(undefined4 *)0x0,

-                                 (undefined4 *)0x0,(undefined4 *)0x0);

-        uVar16 = uVar4;

-        bVar17 = local_238;

-        if ((((int)uVar4 < 0) &&

-            (uVar16 = uVar18, (undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

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

-            (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

-          WPP_SF_D(WPP_GLOBAL_Control[3],0x10b,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                   uVar4);

-          bVar17 = local_238;

+        if (uVar4 == 0) {

+          if (*(uint *)(param_1 + 0x9d) < 2) {

+LAB_3:

+            uVar4 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                              ();

+            uVar6 = 0x48;

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

+              uVar6 = 0x40;

+            }

+            pbVar5 = (byte *)ExAllocatePool2(uVar6,uVar12,0x30455646);

+            if (pbVar5 == (byte *)0x0) {

+              uVar4 = 0xc000009a;

+              pbVar9 = (byte *)0xb19;

+              goto LAB_0;

+            }

+            uVar6 = 2;

+            uVar3 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,2,(byte *)0x0,uVar1,uVar12,

+                                        (longlong)pbVar5);

+            uVar4 = uVar3 & 0xffffffff;

+            if ((int)uVar3 < 0) {

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

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

+                 (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_iiLd(WPP_GLOBAL_Control[3],0x42,

+                            &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

+              }

+              pbVar9 = (byte *)0xb30;

+              goto LAB_0;

+            }

+            uVar6 = FveInformationAndValidationFromBuffer

+                              (pbVar5,(ulonglong)uVar12,local_50,uVar6,&local_68,&local_60);

+            uVar4 = 0;

+            if ((int)uVar6 < 0) {

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

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

+                 (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_iiLd(WPP_GLOBAL_Control[3],0x43,

+                            &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

+              }

+              uVar6 = FveInformationIsValid((longlong)pbVar5,(ulonglong)uVar12,'\x01');

+              if ((int)uVar6 < 0) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  WPP_SF_iiLd(WPP_GLOBAL_Control[3],0x44,

+                              &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

+                }

+                uVar4 = 0xc0210002;

+                pbVar9 = (byte *)0xb5f;

+                goto LAB_0;

+              }

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

+              if (*(short *)(pbVar5 + 10) == 2) {

+                uVar2 = 4;

+              }

+              else if (*(short *)(pbVar5 + 10) == 1) {

+                uVar2 = 0x40;

+              }

+              else {

+                uVar2 = 0;

+              }

+              *(undefined2 *)(pbVar5 + 8) = uVar2;

+              uVar4 = 0x80210001;

+              pbVar14 = pbVar5;

+              puVar15 = (ushort *)0x0;

+            }

+            else {

+              uVar12 = 0;

+              if (*(short *)(local_68 + 10) == 2) {

+                uVar12 = (uint)*(ushort *)(local_68 + 8) << 4;

+              }

+              else if (*(short *)(local_68 + 10) == 1) {

+                uVar12 = (uint)*(ushort *)(local_68 + 8);

+              }

+              uVar7 = *local_60 + uVar12;

+              uVar8 = 0xffffffff;

+              if (uVar7 >= uVar12) {

+                uVar8 = uVar7;

+              }

+              uVar11 = -(uint)(uVar7 < uVar12) & 0xc0000095;

+              *(uint *)(param_4 + 1) = uVar8;

+              pbVar14 = local_68;

+              puVar15 = local_60;

+              if (uVar7 < uVar12) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  WPP_SF_D(WPP_GLOBAL_Control[3],0x45,

+                           &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar11);

+                }

+                pbVar9 = (byte *)0xb85;

+                uVar4 = (ulonglong)uVar11;

+                goto LAB_0;

+              }

+            }

+          }

+          else {

+            uVar3 = FvepReadBestInformationAndValidationFromLogicalCopies

+                              (param_1,uVar1,uVar12,uVar13,in_stack_ffffffffffffff58,

+                               (ulonglong *)&local_68,(ulonglong *)&local_60);

+            uVar4 = uVar3 & 0xffffffff;

+            if ((int)uVar3 < 0) {

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

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

+                 (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_iLLd(WPP_GLOBAL_Control[3],0x40,

+                            &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

+              }

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

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

+              }

+              else {

+                if (local_68 == (byte *)0x0) goto LAB_3;

+                ExFreePoolWithTag(local_68,0x30455646);

+                local_68 = (byte *)0x0;

+                local_60 = (ushort *)0x0;

+              }

+            }

+            else {

+              if (*(short *)(local_68 + 10) == 2) {

+                uVar8 = (uint)*(ushort *)(local_68 + 8) << 4;

+              }

+              else if (*(short *)(local_68 + 10) == 1) {

+                uVar8 = (uint)*(ushort *)(local_68 + 8);

+              }

+              else {

+                uVar8 = 0;

+              }

+              uVar11 = *local_60 + uVar8;

+              uVar7 = 0xffffffff;

+              if (uVar11 >= uVar8) {

+                uVar7 = uVar11;

+              }

+              uVar10 = -(uint)(uVar11 < uVar8) & 0xc0000095;

+              uVar4 = (ulonglong)uVar10;

+              *(uint *)(param_4 + 1) = uVar7;

+              if (uVar11 < uVar8) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  WPP_SF_D(WPP_GLOBAL_Control[3],0x41,

+                           &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar10);

+                }

+                pbVar9 = (byte *)0xb08;

+                goto LAB_0;

+              }

+            }

+            pbVar14 = local_68;

+            puVar15 = local_60;

+            if (local_68 == (byte *)0x0) goto LAB_3;

+          }

+          pbVar9 = (byte *)0x0;

+          *param_7 = pbVar14;

+          *param_8 = puVar15;

+          pbVar5 = pbVar9;

+          goto LAB_0;

         }

       }

-      else {

-        uVar16 = uVar18;

-        bVar17 = (byte)uVar7 >> 1 & 1;

-      }

-      if ((*(byte *)(param_1 + 0x213) & 0x20) != 0) goto LAB_5;

-      if (param_1[0x220] != 0) {

-        if (*(ushort *)((longlong)param_1 + 0x10fa) < 0x4a) {

-          ExFreePoolWithTag(param_1[0x220],0x30455646);

-          param_1[0x220] = 0;

-          *(undefined4 *)(param_1 + 0x21f) = 0;

-          goto LAB_6;

-        }

-LAB_7:

-        uVar14 = 0x70048;

-        uVar4 = FveDeviceControlSynchronousEx

-                          (param_1[0xd],0x70048,2,(void *)0x0,0,(longlong)local_1b8,0x90,local_210);

-        if ((int)uVar4 < 0) {

-          uVar16 = uVar18;

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

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

-             (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-            WPP_SF_D(WPP_GLOBAL_Control[3],0x10c,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                     uVar4);

-          }

-        }

-        else {

-          uVar7 = CONCAT71((int7)((ulonglong)uVar14 >> 8),(char)param_1[0x213]) & 0xffffffffffffff7f

-          ;

-          uVar7 = CONCAT71((int7)(uVar7 >> 8),(byte)uVar7 | ~-(local_1b8[0] != 0) & 0x80U) &

-                  0xffffffffffffffbf;

-          bVar12 = (byte)uVar7 | (local_1b8[0] == 1) << 6;

-          plVar15 = (longlong *)CONCAT71((int7)(uVar7 >> 8),bVar12);

-          *(byte *)(param_1 + 0x213) = bVar12;

-          *(undefined4 *)(param_1 + 0x221) = local_1a0;

-          if (local_1b8[0] == 1) {

-            if (((CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x11d2f81fc12a7328) &&

-                (local_190 == 0x3bc93ec9a0004bba)) ||

-               ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)) {

-              bVar11 = 1;

-            }

-            bVar12 = *(byte *)((longlong)param_1 + 0x1099);

-            *(byte *)((longlong)param_1 + 0x1099) = bVar12 & 0xfe | bVar11;

-            iVar5 = memcmp(&local_198,&PARTITION_MSFT_RECOVERY_GUID,0x10);

-            plVar15 = param_1 + 0x21f;

-            *(undefined2 *)plVar15 = 0;

-            *(byte *)((longlong)param_1 + 0x1099) = bVar12 & 0xfc | bVar11 | ~-(iVar5 != 0) & 2U;

-            memset((void *)param_1[0x220],0,(ulonglong)*(ushort *)((longlong)param_1 + 0x10fa));

-            puVar1 = (undefined8 *)param_1[0x220];

-            local_210[0] = 0;

-            *puVar1 = local_170;

-            puVar1[1] = uStack_168;

-            puVar1[2] = local_160;

-            puVar1[3] = uStack_158;

-            puVar1[4] = local_150;

-            puVar1[5] = uStack_148;

-            puVar1[6] = local_140;

-            puVar1[7] = uStack_138;

-            puVar1[8] = local_130;

-            uVar4 = RtlStringCbLengthW((short *)param_1[0x220],

-                                       (ulonglong)*(ushort *)((longlong)param_1 + 0x10fa),

-                                       (longlong *)local_210);

-            pvVar6 = local_230;

-            param_2 = local_220;

-            if (((int)uVar4 < 0) ||

-               (uVar4 = RtlUIntPtrToUShort(local_210[0],(undefined2 *)plVar15), pvVar6 = local_230,

-               param_2 = local_220, (int)uVar4 < 0)) goto LAB_2;

-          }

-          bVar11 = 0;

-          if ((char)param_1[0x213] < '\0') {

-            if (((cStack_197 != '\0') && ((*(uint *)((longlong)param_1 + 0x344) & 0x10) == 0)) ||

-               ((local_198 == -0x11 || ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)))) {

-              bVar11 = 1;

-            }

-            *(undefined2 *)(param_1 + 0x21f) = 0;

-            plVar15 = (longlong *)0x0;

-            *(byte *)((longlong)param_1 + 0x1099) =

-                 *(byte *)((longlong)param_1 + 0x1099) & 0xfc | bVar11 |

-                 (local_198 != '\'') - 1U & 2;

-            memset((void *)param_1[0x220],0,(ulonglong)*(ushort *)((longlong)param_1 + 0x10fa));

-          }

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

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

-             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-            pwVar9 = (wchar_t *)param_1[0x220];

-            if ((pwVar9 == (wchar_t *)0x0) || ((short)param_1[0x21f] == 0)) {

-              pwVar9 = L"<NULL>";

-            }

-            WPP_SF_LLS(WPP_GLOBAL_Control[3],plVar15,(ulonglong)local_1b8[0],local_1a0,

-                       CONCAT44(uVar19,local_1b8[0]),pwVar9);

-          }

-          *(byte *)(param_1 + 0x213) = *(byte *)(param_1 + 0x213) | 0x20;

-          *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 3;

-          *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) & 0xe0;

-          uVar16 = uVar4;

-          if (bVar17 != 0) {

-            local_210[0] = 0;

-            local_210[1] = 0;

-            local_1f8 = (void *)0x0;

-            uStack_1f0 = 0;

-            local_98 = 0;

-            uStack_90 = 0;

-            local_e8 = 0;

-            uStack_e0 = 0;

-            local_118 = 0;

-            uStack_110 = 0;

-            local_108 = 0;

-            uStack_100 = 0;

-            local_f8 = 0;

-            uStack_f0 = 0;

-            local_a8 = 0;

-            uStack_a0 = 0;

-            local_d8 = 0;

-            uStack_d0 = 0;

-            local_c8 = 0;

-            uStack_c0 = 0;

-            local_b8 = 0;

-            uStack_b0 = 0;

-            RtlInitUnicodeString(local_210,L"OSDATA");

-            RtlInitUnicodeString(&local_1f8,L"PREINSTALLED");

-            RtlInitUnicodeString(&local_98,L"DATA");

-            RtlInitUnicodeString(&local_e8,L"MAINOS");

-            RtlInitUnicodeString(&local_118,L"BSP");

-            RtlInitUnicodeString(&local_108,L"DPP");

-            RtlInitUnicodeString(&local_f8,L"WSP");

-            RtlInitUnicodeString(&local_a8,L"EFIESP");

-            RtlInitUnicodeString(&local_d8,L"SERVICING_METADATA");

-            RtlInitUnicodeString(&local_c8,L"SERVICING_FILES");

-            RtlInitUnicodeString(&local_b8,L"RESERVE");

-            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xfb;

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x44d523f257434f53)) &&

-                (local_190 == -0x6f659254498cf58)) ||

-               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == ')')) ||

-                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,local_210), iVar5 == 0)))) {

-              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 4;

-            }

-            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xf7;

-            if ((((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                  (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x41967fe057434f53)) &&

-                 (local_190 == -0x7bcb9bae84bdbd65)) ||

-                (((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '*')))) ||

-               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_1f8), iVar5 == 0)) {

-              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 8;

-            }

-            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xdf;

-            if ((((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                  (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x45b94df957434f53)) &&

-                 (local_190 == 0x7c4506f070239e8e)) ||

-                (((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '+')))) ||

-               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_118), iVar5 == 0)) {

-              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x20;

-            }

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

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x43f094cb57434f53)) &&

-                (local_190 == 0x7da5cf103cd733a5)) ||

-               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == ',')) ||

-                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_108), iVar5 == 0)))) {

-              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 2;

-            }

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

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x4631e3e357434f53)) &&

-                (local_190 == -0x558cc7db2dd93a5b)) ||

-               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '-')) ||

-                (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_f8), iVar5 == 0)))) {

-              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 1;

-            }

-            *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) & 0xbf;

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x405e8f4557434f53)) &&

-                (local_190 == -0x2ccfbc7592e7dc76)) ||

-               ((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == '(')) ||

-                ((iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_e8), iVar5 == 0 ||

-                 ((*(uint *)(param_1[0xe] + 0x30) & 0x100) != 0)))))) {

-              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x40;

-            }

-            bVar11 = *(byte *)((longlong)param_1 + 0x109a) & 0xfb;

-            *(byte *)((longlong)param_1 + 0x109a) = bVar11;

-            if ((((*(byte *)(param_1 + 0x213) & 0x40) == 0) ||

-                (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) != 0x4a05c69157434f53)) ||

-               (local_190 != -0x31d62d50c28fb145)) {

-              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_d8);

-              if (iVar5 == 0) {

-                bVar11 = *(byte *)((longlong)param_1 + 0x109a);

-                goto LAB_8;

-              }

-            }

-            else {

-LAB_8:

-              *(byte *)((longlong)param_1 + 0x109a) = bVar11 | 4;

-            }

-            bVar11 = *(byte *)((longlong)param_1 + 0x109a) & 0xf7;

-            *(byte *)((longlong)param_1 + 0x109a) = bVar11;

-            if ((((*(byte *)(param_1 + 0x213) & 0x40) == 0) ||

-                (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) != 0x4014432e57434f53)) ||

-               (local_190 != 0x6a00c0a9ea8d4cae)) {

-              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_c8);

-              if (iVar5 == 0) {

-                bVar11 = *(byte *)((longlong)param_1 + 0x109a);

-                goto LAB_9;

-              }

-            }

-            else {

-LAB_9:

-              *(byte *)((longlong)param_1 + 0x109a) = bVar11 | 8;

-            }

-            *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) & 0xef;

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x460b4b8157434f53)) &&

-                (local_190 == 0x146d13feb6ff19a3)) ||

-               (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_b8), iVar5 == 0)) {

-              *(byte *)((longlong)param_1 + 0x109a) = *(byte *)((longlong)param_1 + 0x109a) | 0x10;

-            }

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

-            if (((((*(byte *)(param_1 + 0x213) & 0x40) != 0) &&

-                 (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x11d2f81fc12a7328)) &&

-                (local_190 == 0x3bc93ec9a0004bba)) ||

-               (((((char)*(byte *)(param_1 + 0x213) < '\0' && (local_198 == -0x11)) ||

-                 (iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_a8), iVar5 == 0)) ||

-                ((*(uint *)(param_1[0xe] + 0x30) & 0x200000) != 0)))) {

-              *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x80;

-            }

-            bVar11 = *(byte *)((longlong)param_1 + 0x1099);

-            *(byte *)((longlong)param_1 + 0x1099) = bVar11 & 0xef;

-            if (((((bVar11 & 0x2c) == 0) && ((*(byte *)((longlong)param_1 + 0x109a) & 3) == 0)) &&

-                (((bVar11 & 0x40) == 0 &&

-                 ((-1 < (char)(bVar11 & 0xef) &&

-                  ((*(byte *)((longlong)param_1 + 0x109a) & 0x1c) == 0)))))) &&

-               ((*(uint *)((longlong)param_1 + 0x344) & 0x10) == 0)) {

-              iVar5 = RtlCompareUnicodeString(param_1 + 0x21f,&local_98);

-              if ((iVar5 == 0) ||

-                 ((((((short)param_1[0x21f] == 0 && ((*(byte *)(param_1 + 0x213) & 0x40) != 0)) &&

-                    (CONCAT62(uStack_196,CONCAT11(cStack_197,local_198)) == 0x4433b9e5ebd0a0a2)) &&

-                   (local_190 == -0x3866d94849973f79)) ||

-                  (((char)param_1[0x213] < '\0' && (local_198 == '\a')))))) {

-                *(byte *)((longlong)param_1 + 0x1099) = *(byte *)((longlong)param_1 + 0x1099) | 0x10

-                ;

-              }

-            }

-          }

-        }

-LAB_5:

-        uVar4 = uVar16;

-        uVar19 = 0;

-        if ((int)param_1[2] == 0) {

-          *local_220 = 0;

-          pvVar6 = local_230;

-          param_2 = local_220;

-          goto LAB_2;

-        }

-        iVar5 = FveGetBandProperties(param_1,&local_237,&local_236,local_235);

-        if (iVar5 < 0) {

-          if (local_237 == '\0') goto LAB_10;

-        }

-        else {

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

-            *(uint *)((longlong)param_1 + 0x344) = *(uint *)((longlong)param_1 + 0x344) | 0x200;

-            *(char *)((longlong)param_1 + 0x7c9) = local_236;

-            if (local_235[0] == '\0') {

-              uVar20 = 0x8000;

-            }

-            else {

-              uVar19 = 0xc0210000;

-            }

-            SetFveStateEx(param_1,uVar20,0,0,'\x01',3);

-            *(undefined4 *)((longlong)param_1 + 0x31c) = uVar19;

-            pvVar6 = local_230;

-            param_2 = local_220;

-            goto LAB_2;

-          }

-LAB_10:

-          *(uint *)((longlong)param_1 + 0x344) = *(uint *)((longlong)param_1 + 0x344) & 0xfffffdff;

-        }

-        if ((ulonglong)param_1[0x7e] < 0x2000) goto LAB_11;

-        uVar7 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

-                          ();

-        uVar14 = 0x48;

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

-          uVar14 = 0x40;

-        }

-        lVar10 = ExAllocatePool2(uVar14,0x2000);

-        if (lVar10 == 0) goto LAB_12;

-        uVar7 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,2,(byte *)0x0,0,0x2000,lVar10);

-        uVar4 = (uint)uVar7;

-        if (-1 < (int)uVar4) {

-          uVar3 = FveCheckVolumeTypeEx(lVar10,0x2000,local_128);

-          local_218 = (int)CONCAT71(extraout_var,uVar3);

-          if (local_218 - 2U < 2) {

-            uVar7 = FveWorkerInit((longlong)param_1);

-            uVar4 = (uint)uVar7;

-            if ((int)uVar4 < 0) goto LAB_13;

-          }

-LAB_11:

-          *local_220 = local_218;

-          pvVar6 = local_230;

-          param_2 = local_220;

-          if (lVar10 == 0) goto LAB_2;

-        }

-LAB_13:

-        param_2 = local_220;

-        ExFreePoolWithTag(lVar10,0x30455646);

-        pvVar6 = local_230;

-        goto LAB_2;

-      }

-LAB_6:

-      lVar8 = ExAllocatePool2(0x100,0x4a);

-      param_1[0x220] = lVar8;

-      if (lVar8 != 0) {

-        *(undefined4 *)(param_1 + 0x21f) = 0x4a0000;

-        goto LAB_7;

-      }

-LAB_12:

-      uVar4 = 0xc000009a;

-      pvVar6 = local_230;

-    }

-    else {

-      uVar4 = FveDeviceControlSynchronousEx

-                        (param_1[0xd],0x70000,2,(void *)0x0,0,(longlong)&local_58,0x18,local_210);

-      pvVar6 = local_230;

-      param_2 = local_220;

-      if ((int)uVar4 < 0) goto LAB_2;

-      *(uint *)((longlong)param_1 + 0x49c) = local_48._4_4_;

-      *(uint *)(param_1 + 0x95) = local_48._4_4_;

-      uStack_84 = 0;

-      local_80 = 0;

-      local_88 = 6;

-      uStack_70 = 0;

-      local_68 = 0;

-      local_60 = 0;

-      local_78 = 2;

-      uStack_74 = 1;

-      iVar5 = FveDeviceControlSynchronousEx

-                        (param_1[0xd],0x2d1400,2,&local_88,0xc,(longlong)&local_78,0x1c,local_210);

-      if (iVar5 < 0) {

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

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

-           (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          WPP_SF_D(WPP_GLOBAL_Control[3],0x101,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                   iVar5);

-        }

-      }

-      else {

-        if ((((0x1b < local_78) && (0x1b < uStack_74)) && ((uint)local_68 != 0)) &&

-           ((((uint)local_68 == local_48._4_4_ && ((uint)local_68 <= local_68._4_4_)) &&

-            (((local_68._4_4_ & local_68._4_4_ - 1) == 0 && (local_68._4_4_ != 0)))))) {

-          uVar4 = (uint)local_68 - 1;

-          if ((uVar4 & (uint)local_68) == 0) {

-            if ((local_68._4_4_ & uVar4) == 0) {

-              uVar4 = local_60 & uVar4;

-LAB_14:

-              if (uVar4 == 0) {

-                *(uint *)(param_1 + 0x95) = local_68._4_4_;

-                *(uint *)((longlong)param_1 + 0x4a4) = local_68._4_4_;

-                goto LAB_15;

-              }

-            }

-          }

-          else if (local_68._4_4_ % (uint)local_68 == 0) {

-            uVar4 = local_60 % (uint)local_68;

-            goto LAB_14;

-          }

-        }

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

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

-           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          WPP_SF_(WPP_GLOBAL_Control[3],0x102,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

-        }

-      }

-LAB_15:

-      iVar5 = FsRtlGetVirtualDiskNestingLevel

-                        (param_1[0xd],(undefined4 *)((longlong)param_1 + 0x4ac));

-      if (iVar5 == -0x3fffff66) {

-        uVar4 = 0xc000009a;

-        pvVar6 = local_230;

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

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

-           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          uVar13 = 0x103;

-          uVar4 = 0xc000009a;

-LAB_16:

-          WPP_SF_D(WPP_GLOBAL_Control[3],uVar13,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                   uVar4);

-          pvVar6 = local_230;

-        }

-      }

-      else {

-        if (iVar5 < 0) {

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

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

-             (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-            WPP_SF_D(WPP_GLOBAL_Control[3],0x104,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                     iVar5);

-          }

-          *(undefined4 *)((longlong)param_1 + 0x4ac) = 0;

-        }

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

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

-           (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          WPP_SF_LLLL(WPP_GLOBAL_Control[3],0x105,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                      *(undefined4 *)((longlong)param_1 + 0x49c));

-        }

-        if ((*(uint *)((longlong)param_1 + 0x344) & 0x200000) == 0) {

-          local_228[0] = local_228[0] & 0xff00;

-          local_1f8 = (void *)0x0;

-          local_210[0] = 0;

-          FveResolveTpVolume((longlong)param_1,(byte *)local_228,(ulonglong *)&local_1f8,local_210);

-          param_1[0x9b] = (longlong)local_1f8;

-          param_1[0x9c] = local_210[0];

-          if ((char)local_228[0] == '\0') {

-            uVar4 = *(uint *)((longlong)param_1 + 0x344) & 0xffffefff | 0x200000;

-          }

-          else {

-            uVar4 = *(uint *)((longlong)param_1 + 0x344) | 0x201000;

-          }

-          *(uint *)((longlong)param_1 + 0x344) = uVar4;

-        }

-        uVar4 = FveCheckStorageLogicalCopies((longlong)param_1);

-        if (-1 < (int)uVar4) {

-          FveCheckIceSupport((longlong)param_1);

-          pvVar6 = local_230;

-          param_2 = local_220;

-          uVar4 = extraout_EAX;

-          if ((int)extraout_EAX < 0) goto LAB_2;

-          local_200[0] = 1;

-          iVar5 = FveDeviceControlSynchronousEx

-                            (param_1[0xd],0x2d19f4,2,local_200,4,(longlong)&local_1e8,8,local_210);

-          if (iVar5 < 0) {

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

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

-               (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-              WPP_SF_D(WPP_GLOBAL_Control[3],0x107,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                       iVar5);

-            }

-          }

-          else if ((int)local_1e8 == 1) {

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

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

-               (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-              WPP_SF_D(WPP_GLOBAL_Control[3],0x109,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                       local_1e8._4_4_ & 1);

-            }

-            *(byte *)((longlong)param_1 + 0x109c) =

-                 local_1e8._4_1_ & 1 | *(byte *)((longlong)param_1 + 0x109c) & 0xfe;

-          }

-          else if ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control) &&

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

-                  (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-            WPP_SF_D(WPP_GLOBAL_Control[3],0x108,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                     (int)local_1e8);

-          }

-          if ((*(byte *)((longlong)param_1 + 0x109b) & 2) == 0) {

-            uVar4 = FveUpdateIsOnRdvPolicyExclusionList(param_1);

-            if ((int)uVar4 < 0) {

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

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

-                 (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-                WPP_SF_D(WPP_GLOBAL_Control[3],0x10a,

-                         &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar4);

-              }

-              local_1e0 = &FVE_CHECK_RDV_EXCLUSION_LIST_ERROR;

-              uStack_1d8 = CONCAT44(uVar4,(undefined4)uStack_1d8);

-              local_1d0 = 0;

-              FveLogEventEx(*param_1,(longlong *)&local_1e0,'\0','\x01');

-              local_1e0 = (undefined *)0x0;

-              uStack_1d8 = 0;

-              local_1d0 = 0;

-            }

-            *(byte *)((longlong)param_1 + 0x109b) = *(byte *)((longlong)param_1 + 0x109b) | 2;

-          }

-          goto LAB_4;

-        }

-        pvVar6 = local_230;

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

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

-           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          uVar13 = 0x106;

-          goto LAB_16;

-        }

-      }

-    }

-  }

-LAB_1:

-  *(uint *)(param_1 + 100) = uVar4;

-  *(uint *)((longlong)param_1 + 0x31c) = uVar4;

-  if (uVar4 == 0xc0000013) {

-    SetFveStateEx(param_1,0x8000,0,0,'\x01',3);

-    param_1[0x7e] = 0;

-  }

-  else if (((uVar4 != 0xc000000e) && (uVar4 != 0xc000009d)) &&

-          ((uVar4 != 0x80000010 && (uVar4 != 0xc0000185)))) {

-    local_1e0 = &FVE_INIT_FAILED_ERROR;

-    uStack_1d8 = CONCAT44(uVar4,(undefined4)uStack_1d8);

-    local_1d0 = 0;

-    FveLogEventEx(*param_1,(longlong *)&local_1e0,'\0','\x01');

-  }

-  *(uint *)((longlong)param_1 + 0x334) = 6 - (uint)(uVar4 != 0x80000010);

-LAB_3:

-  if ((local_120 == 0) && (param_1[0x7e] != 0)) {

-    FveReInit(param_1,'\x01',3);

-  }

-  FveTestDevStateChange(param_1,3,'\x01');

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

-    ExFreePoolWithTag(pvVar6,0);

+    }

+    else if (uVar1 % uVar3 == 0) {

+      if ((uVar13 == 0) && (uVar3 != 0)) goto LAB_1;

+      uVar4 = local_58 % uVar3;

+      goto LAB_2;

+    }

+  }

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

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

+     (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_iiLd(WPP_GLOBAL_Control[3],0x3e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

+  }

+  pbVar9 = (byte *)0xaaa;

+  uVar4 = 0xc021001f;

+LAB_0:

+  if (1 < *(uint *)(param_1 + 0x9d)) {

+    FveLogEventWithMetadataInfo

+              (*param_1,(ushort *)&FVE_METADATA_LOGICAL_COPY_READ,(int)uVar4,uVar1,local_48,

+               (ulonglong)(param_3 + 1),(ulonglong)*(uint *)(param_1 + 0x9d),param_1[0x9b],pbVar9,

+               '\x01','\x01');

+  }

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

+    ExFreePoolWithTag(pbVar5,0x30455646);

   }

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

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(WPP_GLOBAL_Control[3],0x10e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar4);

+    WPP_SF_Ld(WPP_GLOBAL_Control[3],0x46,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,param_3);

   }

   return uVar4;

 }
```

## `FvepWriteBootSectors`  (modified)

```diff
--- FvepWriteBootSectors
+++ FvepWriteBootSectors
@@ -1,47 +1,314 @@
 

-/* WARNING: Variable defined which should be unmapped: param_5 */

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

 

 ulonglong FvepWriteBootSectors

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

                     int param_5)

 

 {

-  uint uVar1;

-  undefined8 in_RAX;

-  uint unaff_EBP;

-  undefined1 *unaff_RSI;

-  longlong unaff_RDI;

-  longlong *unaff_R12;

-  longlong unaff_R14;

-  undefined *in_stack_00000040;

-  uint in_stack_0000004c;

+  longlong lVar1;

+  int iVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  undefined8 *puVar5;

+  ulonglong uVar6;

+  undefined8 *puVar7;

+  longlong *plVar8;

+  ulonglong uVar9;

+  undefined4 uVar10;

+  undefined8 uVar11;

+  undefined8 uVar12;

+  longlong lVar13;

+  ulonglong uVar14;

+  longlong lVar15;

+  ulonglong uVar16;

+  undefined1 auStackY_1e8 [32];

+  undefined *local_1a8;

+  undefined8 uStack_1a0;

+  undefined8 local_198;

+  uint local_190;

+  undefined8 *local_188;

+  longlong local_180;

+  uint local_178;

+  longlong local_170;

+  uint local_168;

+  ulonglong local_158 [2];

+  longlong local_148;

+  code *local_100;

+  undefined8 *local_f8;

+  undefined8 *local_f0;

+  uint local_e8;

+  longlong local_58 [4];

   

-  uVar1 = FveDeviceControlSynchronousEx

-                    ((longlong)param_1,unaff_EBP,0,unaff_RSI,(uint)unaff_R14,unaff_RDI,

-                     (uint)unaff_RDI,

-                     (undefined8 *)

-                     (CONCAT71((int7)((ulonglong)in_RAX >> 8),uRam8b491c7e89000000) &

-                     0xffffffffffffff68));

-  if ((int)uVar1 < 0) {

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

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

-       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-      WPP_SF_D(WPP_GLOBAL_Control[3],0x138,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

-    }

-    in_stack_00000040 = &FVE_METADATA_FAILED_COMMIT;

-    in_stack_0000004c = uVar1;

-    FveLogEventEx(*unaff_R12,(longlong *)&stack0x00000040,'\0','\x01');

-  }

-  for (; unaff_R14 != 0; unaff_R14 = unaff_R14 + -1) {

-    *unaff_RSI = 0;

-    unaff_RSI = unaff_RSI + 1;

-  }

-  ExFreePoolWithTag();

+  local_58[3] = __security_cookie ^ (ulonglong)auStackY_1e8;

+  local_188 = param_3;

+  memset(local_158,0,0x100);

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

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(WPP_GLOBAL_Control[3],0x139,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar1);

-  }

-  return (ulonglong)uVar1;

+    WPP_SF_(WPP_GLOBAL_Control[3],0x65,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+  }

+  local_170 = 0;

+  local_180 = 0;

+  local_198 = 0;

+  local_1a8 = (undefined *)0x0;

+  uStack_1a0 = 0;

+  if ((param_4 & 0xfffffffc) == 0) {

+    if (param_4 == 1) goto LAB_0;

+    uVar4 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar10 = 0x40;

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

+      uVar10 = 0x48;

+    }

+    puVar5 = (undefined8 *)ExAllocatePool2(uVar10,0x2000,0x30455646);

+    if (puVar5 != (undefined8 *)0x0) {

+      lVar15 = 3;

+      lVar13 = param_1[0xd];

+      uVar6 = FveRawIoSynchronous((longlong)param_1,lVar13,3,param_5,(byte *)0x0,0,0x2000,

+                                  (longlong)puVar5);

+      uVar4 = uVar6 & 0xffffffff;

+      if ((int)uVar6 < 0) {

+LAB_1:

+        local_1a8 = &FVE_METADATA_DISK_FAILED_READBACK_ERROR;

+LAB_2:

+        local_198 = 0;

+        uStack_1a0 = CONCAT44((int)uVar4,0xffffffff);

+        FveLogEventEx(*param_1,(longlong *)&local_1a8,'\0','\x01');

+      }

+      else if (param_4 == 2) {

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

+          plVar8 = local_58;

+          do {

+            lVar1 = *param_2;

+            param_2 = param_2 + 3;

+            *plVar8 = lVar1;

+            plVar8 = plVar8 + 1;

+            lVar15 = lVar15 + -1;

+          } while (lVar15 != 0);

+          FveBuildBootSector((longlong)puVar5,lVar13,local_58);

+          goto LAB_3;

+        }

+LAB_4:

+        uVar4 = 0xc000000d;

+      }

+      else {

+        if (param_4 == 3) {

+          if ((param_2 == (longlong *)0x0) || (local_188 == (undefined8 *)0x0)) goto LAB_4;

+          plVar8 = local_58;

+          do {

+            lVar1 = *param_2;

+            param_2 = param_2 + 3;

+            *plVar8 = lVar1;

+            plVar8 = plVar8 + 1;

+            lVar15 = lVar15 + -1;

+          } while (lVar15 != 0);

+          FveEowBuildBootSector((longlong)puVar5,lVar13,local_58,local_188);

+        }

+        else {

+          *puVar5 = 0;

+          *(undefined2 *)(puVar5 + 1) = 0;

+          *(undefined1 *)((longlong)puVar5 + 10) = 0;

+          puVar7 = (undefined8 *)FveFindGuidRecognition((longlong)puVar5,0x2000);

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

+            *puVar7 = 0;

+            puVar7[1] = 0;

+            puVar7[2] = 0;

+            puVar7[3] = 0;

+            puVar7[4] = 0;

+          }

+          plVar8 = FveEowFindGuidRecognition((longlong)puVar5,0x2000);

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

+            *plVar8 = 0;

+            plVar8[1] = 0;

+            plVar8[2] = 0;

+            plVar8[3] = 0;

+            plVar8[4] = 0;

+            plVar8[5] = 0;

+            plVar8[6] = 0;

+          }

+        }

+LAB_3:

+        uVar6 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,param_5,(byte *)0x0,0,0x2000,

+                                    (longlong)puVar5);

+        uVar4 = uVar6 & 0xffffffff;

+        if ((int)uVar6 < 0) {

+          local_1a8 = &FVE_METADATA_FAILED_COMMIT;

+          goto LAB_2;

+        }

+        uVar4 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,param_5,(byte *)0x0,0,0,0);

+        iVar2 = (int)uVar4;

+        uVar4 = uVar4 & 0xffffffff;

+        if (((iVar2 != -0x3ffffffe) && (iVar2 != -0x3ffffff0)) && (iVar2 != -0x3fffff45)) {

+          if (-1 < iVar2) goto LAB_5;

+          local_198 = 0;

+          local_1a8 = &FVE_METADATA_DISK_FAILED_FLUSH_ERROR;

+          uStack_1a0 = CONCAT44(iVar2,0xffffffff);

+          FveLogEventEx(*param_1,(longlong *)&local_1a8,'\0','\x01');

+        }

+        uVar4 = 0;

+      }

+      goto LAB_5;

+    }

+  }

+  else {

+    if (param_4 != 1) {

+      uVar4 = 0xc000000d;

+      goto LAB_6;

+    }

+LAB_0:

+    if (*(short *)(param_1[0x75] + 10) == 1) {

+      uVar6 = 0;

+    }

+    else {

+      uVar3 = *(uint *)(param_1[0x75] + 0x1c);

+      uVar6 = (ulonglong)uVar3;

+      if (uVar3 == 0) {

+        uVar6 = 1;

+      }

+    }

+    uVar6 = *(uint *)((longlong)param_1 + 0x49c) * uVar6;

+    uVar3 = (uint)uVar6;

+    if (0x100000 < uVar6) {

+      uVar3 = 0x100000;

+    }

+    local_168 = uVar3;

+    uVar4 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar12 = 0x40;

+    uVar11 = uVar12;

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

+      uVar11 = 0x48;

+    }

+    puVar5 = (undefined8 *)ExAllocatePool2(uVar11,uVar3,0x30455646);

+    if (puVar5 != (undefined8 *)0x0) {

+      uVar4 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline()

+      ;

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

+        uVar12 = 0x48;

+      }

+      local_170 = ExAllocatePool2(uVar12,uVar3,0x30455646);

+      if (local_170 == 0) {

+        uVar4 = 0xc000009a;

+      }

+      else {

+        uVar4 = 0;

+        local_188 = (undefined8 *)0x2000;

+        uVar16 = 0x2000;

+        if (uVar6 < 0x2000) {

+          uVar16 = uVar6;

+        }

+        uVar16 = uVar6 - uVar16;

+        uVar9 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+        if ((((int)uVar9 != 0) && ((*(uint *)(param_1 + 99) & 2) == 0)) &&

+           ((param_1[0x23d] != 0 && (uVar4 = 0, *(int *)(param_1[0x23d] + 0x58) != 0)))) {

+          if (param_1[0x79] != 0) {

+                    /* WARNING: Subroutine does not return */

+            KeBugCheckEx(0x120,0xc,0);

+          }

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

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_(WPP_GLOBAL_Control[3],0x66,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+          }

+          uVar9 = ExtractFvek(param_1[0x75] + 0x40,(ulonglong *)param_1[0x7a],

+                              (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                              &local_180);

+          uVar4 = uVar9 & 0xffffffff;

+          if ((int)uVar9 < 0) {

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

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

+               (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_D(WPP_GLOBAL_Control[3],0x67,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                       (int)uVar9);

+            }

+            goto LAB_5;

+          }

+        }

+        puVar7 = (undefined8 *)0x2000;

+        local_178 = 0;

+        do {

+          for (; uVar16 != 0; uVar16 = uVar16 - uVar14) {

+            local_190 = (uint)uVar16;

+            if (local_168 < uVar16) {

+              local_190 = local_168;

+            }

+            uVar9 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,param_5,(byte *)0x0,

+                                        *(longlong *)(param_1[0x75] + 0x38) + (longlong)puVar7,

+                                        local_190,(longlong)puVar5);

+            uVar4 = uVar9 & 0xffffffff;

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

+            uVar4 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+            lVar13 = local_180;

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

+              lVar13 = 0;

+            }

+            InitializeFilterData((longlong)param_1,local_158,'\x01',0,(longlong *)0x0,lVar13);

+            local_148 = (longlong)local_188 + *(longlong *)(param_1[0x75] + 0x38);

+            local_e8 = local_190;

+            local_100 = FveFilteredRead;

+            local_f8 = puVar5;

+            local_f0 = puVar5;

+            uVar3 = FveParseBlockAndFilter(local_158);

+            uVar4 = (ulonglong)uVar3;

+            DeInitializeFilterData((longlong)param_1,local_158);

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

+            uVar9 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,param_5,(byte *)0x0,

+                                        (ulonglong)local_188,local_190,(longlong)puVar5);

+            uVar4 = uVar9 & 0xffffffff;

+            if ((int)uVar9 < 0) {

+              local_1a8 = &FVE_METADATA_FAILED_COMMIT;

+              goto LAB_2;

+            }

+            uVar4 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,param_5,(byte *)0x0,0,0,0);

+            iVar2 = (int)uVar4;

+            uVar4 = uVar4 & 0xffffffff;

+            if (((iVar2 != -0x3ffffffe) && (iVar2 != -0x3ffffff0)) &&

+               ((iVar2 != -0x3fffff45 && (iVar2 < 0)))) {

+              local_1a8 = &FVE_METADATA_DISK_FAILED_FLUSH_ERROR;

+              goto LAB_2;

+            }

+            uVar9 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,param_5,(byte *)0x0,

+                                        (ulonglong)local_188,local_190,local_170);

+            uVar4 = uVar9 & 0xffffffff;

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

+            uVar9 = RtlCompareMemory(puVar5,local_170);

+            uVar14 = (ulonglong)local_190;

+            if (uVar9 != uVar14) {

+              uVar4 = 0xc0000001;

+              goto LAB_1;

+            }

+            puVar7 = (undefined8 *)((longlong)local_188 + uVar14);

+            local_188 = puVar7;

+          }

+          puVar7 = (undefined8 *)0x0;

+          local_188 = (undefined8 *)0x0;

+          uVar16 = 0x2000;

+          if (uVar6 < 0x2000) {

+            uVar16 = uVar6;

+          }

+          local_178 = local_178 + 1;

+        } while (local_178 < 2);

+      }

+LAB_5:

+      ExFreePoolWithTag(puVar5,0x30455646);

+      if (local_170 != 0) {

+        ExFreePoolWithTag(local_170,0x30455646);

+      }

+      goto LAB_6;

+    }

+  }

+  uVar4 = 0xc000009a;

+LAB_6:

+  lVar13 = local_180;

+  uVar6 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+  if (((int)uVar6 != 0) && (lVar13 != 0)) {

+    DeleteKey(lVar13);

+  }

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x68,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,(int)uVar4)

+    ;

+  }

+  return uVar4;

 }
```

## `ActionIsFveSupported`  (modified)

```diff
--- ActionIsFveSupported
+++ ActionIsFveSupported
@@ -1,105 +1,60 @@
-

-/* WARNING: Instruction at (ram,0x0001400c9979) overlaps instruction at (ram,0x0001400c9978)

-    */

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

 

 ulonglong ActionIsFveSupported(longlong *param_1,undefined8 param_2,short *param_3)

 

 {

-  char *pcVar1;

-  undefined8 *puVar2;

-  undefined8 uVar3;

-  undefined8 uVar4;

-  uint uVar5;

-  char *in_RAX;

+  int iVar1;

+  ulonglong uVar2;

+  longlong lVar3;

+  longlong lVar4;

+  undefined8 uVar5;

   ulonglong uVar6;

-  longlong lVar7;

-  ulonglong *unaff_RBX;

-  longlong unaff_RBP;

-  ulonglong *unaff_RSI;

-  ulonglong uVar8;

-  ulonglong uVar9;

-  undefined8 *unaff_R12;

-  longlong unaff_R13;

-  longlong unaff_R14;

-  uint unaff_R15D;

-  undefined4 in_XMM0_Da;

-  undefined4 in_XMM0_Db;

-  undefined4 in_XMM0_Dc;

-  undefined4 in_XMM0_Dd;

-  uint *puVar10;

-  uint in_stack_00000040;

-  ulonglong *in_stack_00000048;

+  longlong local_98 [18];

   

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

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

-  pcVar1 = in_RAX + -0x77;

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

-  if (*pcVar1 != '\0') {

-    *(undefined4 *)(unaff_RBP + -9) = in_XMM0_Da;

-    *(undefined4 *)(unaff_RBP + -5) = in_XMM0_Db;

-    *(undefined4 *)(unaff_RBP + -1) = in_XMM0_Dc;

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

-    FvepLockAcquireLock((longlong)param_1,(longlong *)(unaff_RBP + -0x59),(char)param_3);

-    unaff_R13 = unaff_R13 + 0x40;

-    uVar5 = func_0x0001400c9a70();

-    uVar8 = (ulonglong)uVar5;

-    unaff_RSI = in_stack_00000048;

-    if ((-1 < (int)uVar5) && (in_stack_00000048 == (ulonglong *)0x0)) {

-      uVar5 = FvepRegGetAutoUnlockKey

-                        (unaff_RBP + -9,*(ulonglong **)(unaff_R14 + 0x70),

-                         (ulonglong *)(unaff_RBP + -0x19),&stack0x00000048);

-      uVar8 = (ulonglong)uVar5;

-      unaff_RSI = in_stack_00000048;

+  memset(local_98,0,0x90);

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x17,&WPP_8b811256f49c336aa340c0b739490f4a_Traceguids);

+  }

+  if (*param_3 == 8) {

+    FvepAcquireDevFveLock(param_1,local_98,'\0');

+    if ((*(uint *)(param_1 + 99) & 0x17f) == 0) {

+      FvepReleaseDevFveLock(local_98);

+      uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline()

+      ;

+      uVar5 = 0x108;

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

+        uVar5 = 0x100;

+      }

+      lVar3 = ExAllocatePool2(uVar5,0x2000,0x30455646);

+      if (lVar3 == 0) {

+        uVar6 = 0xc000009a;

+      }

+      else {

+        lVar4 = IoGetAttachedDevice(*param_1);

+        uVar2 = FveRawIoSynchronous((longlong)param_1,lVar4,3,0,(byte *)0x0,0,0x2000,lVar3);

+        uVar6 = uVar2 & 0xffffffff;

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

+          iVar1 = FveCheckVolumeType(lVar3,0x2000);

+          uVar6 = (ulonglong)(-(uint)(2 < iVar1 - 1U) & 0xc0210004);

+        }

+        ExFreePoolWithTag(lVar3,0x30455646);

+      }

     }

-    FvepLockReleaseLock((longlong *)(unaff_RBP + -0x59));

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

-    *(ulonglong **)(unaff_RBP + -0x71) = unaff_RSI;

+    else {

+      uVar6 = 0;

+      FvepReleaseDevFveLock(local_98);

+    }

   }

-  while( true ) {

-    puVar10 = &stack0x00000040;

-    uVar9 = (ulonglong)unaff_R15D;

-    uVar6 = FveDatasetGetNext(unaff_R13,2,8,unaff_R15D,puVar10);

-    unaff_R15D = in_stack_00000040;

-    uVar8 = uVar6 & 0xffffffff;

-    if ((int)uVar6 < 0) break;

-    uVar5 = FveDatasetGetDatum(unaff_R13,in_stack_00000040,(undefined8 *)(unaff_RBP + -0x79),uVar9);

-    unaff_RBX = *(ulonglong **)(unaff_RBP + -0x79);

-    uVar8 = (ulonglong)uVar5;

-    if ((int)uVar5 < 0) break;

-    lVar7 = unaff_RBX[1] - *(longlong *)(unaff_RBP + -0x19);

-    if (lVar7 == 0) {

-      lVar7 = unaff_RBX[2] - *(longlong *)(unaff_RBP + -0x11);

-    }

-    if (lVar7 == 0) {

-      uVar6 = FveDatumGetVmk(unaff_RBX,(undefined8 *)(unaff_RBP + -0x71),1,uVar9,puVar10,

-                             (undefined8 *)(unaff_RBP + -0x69));

-      uVar8 = uVar6 & 0xffffffff;

-      if (-1 < (int)uVar6) {

-        uVar4 = *(undefined8 *)(unaff_RBP + -0x11);

-        puVar2 = *(undefined8 **)(unaff_RBP + -0x61);

-        uVar3 = *(undefined8 *)(unaff_RBP + -0x69);

-        *unaff_R12 = *(undefined8 *)(unaff_RBP + -0x19);

-        unaff_R12[1] = uVar4;

-        *puVar2 = uVar3;

-        goto LAB_1;

-      }

-      break;

-    }

-    FveDatumFree(unaff_RBX);

-    unaff_RBX = (ulonglong *)0x0;

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

+  else {

+    uVar6 = 0xc000000d;

   }

-LAB_0:

-  *unaff_R12 = 0;

-  unaff_R12[1] = 0;

-LAB_1:

-  if (unaff_RBX != (ulonglong *)0x0) {

-    FveDatumFree(unaff_RBX);

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x18,&WPP_8b811256f49c336aa340c0b739490f4a_Traceguids,(int)uVar6)

+    ;

   }

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

-    FveDatumFree(unaff_RSI);

-  }

-  return uVar8;

+  return uVar6;

 }
```

## `FveInitialDataReadPhase2`  (modified)

```diff
--- FveInitialDataReadPhase2
+++ FveInitialDataReadPhase2
@@ -1,102 +1,961 @@
 

-ulonglong FveInitialDataReadPhase2

-                    (ulonglong *param_1,ulonglong *param_2,longlong *param_3,int param_4)

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

+/* WARNING: Type propagation algorithm not settling */

+

+void FveInitialDataReadPhase2(ulonglong *param_1,ulonglong *param_2,longlong *param_3,int param_4)

 

 {

-  char *pcVar1;

-  wchar_t *pwVar2;

-  wchar_t *_Str1;

-  uint uVar3;

-  int iVar4;

-  int iVar5;

-  int *in_RAX;

-  undefined1 *puVar6;

-  ulonglong uVar7;

-  longlong lVar8;

-  longlong unaff_RBX;

-  longlong unaff_RBP;

-  char *unaff_RSI;

-  longlong unaff_RDI;

-  undefined4 in_register_0000008c;

-  undefined4 unaff_R12D;

-  char *unaff_R14;

-  longlong lVar9;

+  uint *puVar1;

+  byte bVar2;

+  short sVar3;

+  bool bVar4;

+  char cVar5;

+  bool bVar6;

+  uint uVar7;

+  int iVar8;

+  undefined4 uVar9;

+  void *pvVar10;

+  ulonglong uVar11;

+  ulonglong uVar12;

+  undefined8 uVar13;

+  longlong *plVar14;

+  undefined2 uVar15;

+  uint uVar16;

+  undefined8 *puVar17;

+  PUCHAR pUVar18;

+  ulonglong *puVar19;

+  ushort *puVar20;

+  longlong lVar21;

+  ulonglong *puVar22;

+  longlong **pplVar23;

+  int iVar24;

+  ulonglong uVar25;

+  PUCHAR pUVar26;

+  ulonglong *puVar27;

+  bool bVar28;

+  undefined1 auStackY_298 [32];

+  undefined8 *in_stack_fffffffffffffd90;

+  uint local_234;

+  char local_22f;

+  char local_22e [6];

+  ulonglong local_228;

+  ulonglong *local_220;

+  longlong *local_218;

+  longlong local_210;

+  longlong local_208;

+  uint local_200;

+  uint local_1fc;

+  ulonglong *local_1f8;

+  ulonglong *local_1f0;

+  undefined2 local_1e8 [2];

+  undefined2 local_1e4 [2];

+  int local_1e0 [2];

+  PUCHAR local_1d8;

+  longlong *local_1d0;

+  ushort *local_1c8;

+  ushort *local_1c0;

+  undefined4 local_1b8 [2];

+  ulonglong *******local_1b0;

+  ulonglong *******local_1a8;

+  ulonglong local_1a0;

+  ulonglong local_198 [2];

+  undefined *local_188;

+  undefined8 uStack_180;

+  undefined8 local_178;

+  undefined8 local_170;

+  undefined8 local_168;

+  ulonglong local_160 [3];

+  undefined8 uStack_148;

+  undefined8 local_140;

+  undefined8 local_138 [4];

+  undefined2 *local_118;

+  int local_110;

+  undefined4 local_10c;

+  undefined2 *local_108;

+  int local_100;

+  undefined4 local_fc;

+  undefined8 *local_f8;

+  undefined4 local_f0;

+  undefined4 local_ec;

+  undefined4 *local_e8;

+  int local_e0;

+  undefined4 local_dc;

+  PUCHAR local_d8;

+  undefined4 local_d0;

+  undefined4 local_cc;

+  undefined8 *local_c8;

+  undefined4 local_c0;

+  undefined4 local_bc;

+  undefined8 local_b8 [4];

+  longlong **local_98;

+  undefined4 local_90;

+  undefined4 local_8c;

+  ulonglong *local_88;

+  undefined4 local_80;

+  undefined4 local_7c;

+  PUCHAR local_78;

+  int local_70;

+  undefined4 local_6c;

+  int *local_68;

+  int local_60;

+  undefined4 local_5c;

+  ulonglong *local_58;

+  undefined4 local_50;

+  undefined4 local_4c;

+  ulonglong local_48;

   

-  uVar3 = (int)in_RAX + *in_RAX;

-  pcVar1 = (char *)(unaff_RBP + -0x73 + (longlong)param_1 * 4);

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

-  *(undefined1 *)(ulonglong)uVar3 = *(undefined1 *)(ulonglong)uVar3;

-  pcVar1 = (char *)((longlong)param_1 * 5 + -0x5b);

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

-  puVar6 = (undefined1 *)((ulonglong)(uint3)(uVar3 >> 8) << 8);

-  *puVar6 = *puVar6;

-  *(undefined4 *)(unaff_RBP + 0xc0) = unaff_R12D;

-  uVar7 = FveGroupPolicyGetMultiSzValue

-                    (L"System\\CurrentControlSet\\Control\\CrashControl",L"DumpFilters",

-                     (undefined8 *)(unaff_RBP + 0xb0),(uint *)CONCAT44(in_register_0000008c,param_4)

-                    );

-  pwVar2 = *(wchar_t **)(unaff_RBP + 0xb0);

-  iVar4 = (int)uVar7;

-  _Str1 = pwVar2;

-  if (iVar4 < 0) {

+  local_48 = __security_cookie ^ (ulonglong)auStackY_298;

+  local_140 = 0;

+  local_160[2] = 0;

+  uStack_148 = 0;

+  local_22e[0] = '\0';

+  local_22f = '\0';

+  local_220 = param_2;

+  local_1e0[0] = param_4;

+  local_1d0 = param_3;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x115,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+  }

+  local_234 = 0;

+  local_200 = 0;

+  pUVar26 = (PUCHAR)0x0;

+  local_1fc = 0;

+  local_198[1] = 0;

+  uVar25 = 0;

+  local_198[0] = 0;

+  local_218 = (longlong *)0x0;

+  local_1a0 = 0;

+  local_1c8 = (ushort *)0x0;

+  local_1a8 = (ulonglong *******)0x0;

+  local_1b0 = (ulonglong *******)0x0;

+  local_1c0 = (ushort *)0x0;

+  uVar12 = param_3[1];

+  local_1f0 = (ulonglong *)0x0;

+  local_1f8 = (ulonglong *)0x0;

+  bVar6 = false;

+  bVar4 = false;

+  local_178 = 0;

+  local_1d8 = (PUCHAR)0x0;

+  local_228 = 0;

+  local_208 = 0;

+  local_210 = 0;

+  local_188 = (undefined *)0x0;

+  uStack_180 = 0;

+  *(int *)(param_1 + 0x94) = (int)*param_3;

+  if (param_1[0x75] != 0) {

+LAB_0:

+    if (param_1[0x76] == 0) {

+      uVar11 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                         ();

+      uVar13 = 0x100;

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

+        uVar13 = 0x108;

+      }

+      pvVar10 = (void *)ExAllocatePool2(uVar13);

+      param_1[0x76] = (ulonglong)pvVar10;

+      if (pvVar10 == (void *)0x0) goto LAB_1;

+      memset(pvVar10,0,0x10000);

+      param_3 = local_1d0;

+    }

+    uVar16 = 3;

+    puVar19 = local_220;

+    if (param_4 != 3) {

+LAB_2:

+      do {

+        bVar4 = false;

+        bVar28 = false;

+        if (pUVar26 != (PUCHAR)0x0) {

+          ExFreePoolWithTag(pUVar26,0x30455646);

+          local_1d8 = (PUCHAR)0x0;

+        }

+        uVar11 = FvepLoadInformation((longlong *)param_1,param_1[0x7e],uVar12,&local_200,

+                                     local_160 + 2,in_stack_fffffffffffffd90,(longlong *)&local_1d8,

+                                     &local_1c0);

+        uVar7 = (uint)uVar11;

+        if ((int)uVar7 < 0) {

+          in_stack_fffffffffffffd90 = (undefined8 *)(ulonglong)local_200;

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

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

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_iLd(WPP_GLOBAL_Control[3],0x116,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                       uVar12);

+          }

+          FveLogEventWithMetadataInfo

+                    (*param_1,(ushort *)&FVE_METADATA_READ_FAIL,uVar7,uVar12,0,

+                     in_stack_fffffffffffffd90,(ulonglong)(uint)param_1[0x9d],param_1[0x9b],0x2f4c,

+                     '\x01','\0');

+          local_1fc = local_1fc + 1;

+          pUVar26 = local_1d8;

+          if (5 < uVar16 + 1) goto code_r0x000140083a03;

+        }

+        else {

+          if (local_1f0 != (ulonglong *)0x0) {

+            FveDatumFree(local_1f0);

+            if (uVar25 != 0) {

+              DeleteKey(uVar25);

+              uVar25 = 0;

+              local_228 = 0;

+            }

+            if (local_208 != 0) {

+              DeleteKey(local_208);

+              local_208 = 0;

+              local_210 = 0;

+            }

+            puVar19 = (ulonglong *)0x0;

+            local_1f0 = (ulonglong *)0x0;

+            local_220 = (ulonglong *)0x0;

+            local_1f8 = (ulonglong *)0x0;

+          }

+          pUVar26 = local_1d8;

+          puVar27 = local_1f0;

+          if (param_1[0x7a] != 0) {

+            if ((*(longlong *)(param_1[0x75] + 0x50) != *(longlong *)(local_1d8 + 0x50)) ||

+               (*(longlong *)(param_1[0x75] + 0x58) != *(longlong *)(local_1d8 + 0x58))) {

+              bVar6 = true;

+              goto LAB_3;

+            }

+            Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+            *(uint *)((longlong)param_1 + 0x334) = (param_1[0x5b] != 0) + 3;

+LAB_4:

+            bVar28 = false;

+            goto LAB_5;

+          }

+LAB_3:

+          FveCleanup((longlong *)param_1,'\x01','\0',4);

+          if (bVar6) {

+            FveReInit((longlong *)param_1,'\x01',4);

+          }

+          puVar22 = local_160 + 2;

+          FvepCheckInformationStatus

+                    ((longlong *)param_1,param_1[0x7e],(longlong)pUVar26,(longlong *)puVar22,

+                     (longlong *)(param_1 + 0x7f));

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

+            uVar12 = FveEowInitializeReservedRegions

+                               ((longlong)param_1,(longlong)local_218,(longlong)(param_1 + 0x7f));

+            uVar7 = (uint)uVar12;

+            if ((int)uVar7 < 0) goto LAB_4;

+          }

+          if (puVar19 == (ulonglong *)0x0) {

+            uVar12 = TryObtainKey((longlong *)param_1,(longlong)pUVar26,&local_1f8,puVar22);

+            local_1f0 = local_1f8;

+            local_220 = local_1f8;

+            local_234 = (uint)uVar12;

+            puVar19 = local_1f8;

+            puVar27 = local_1f8;

+          }

+          uVar12 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+          puVar22 = local_220;

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

+            if ((int)local_234 < 0) goto LAB_6;

+            uVar12 = ExtractFvek((longlong)(pUVar26 + 0x40),local_220,

+                                 (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                 &local_228);

+            local_234 = (uint)uVar12;

+            uVar25 = local_228;

+            if ((int)local_234 < 0) {

+LAB_7:

+              puVar19 = local_220;

+              if ((int)local_234 < 0) goto LAB_6;

+            }

+            else {

+              puVar19 = local_220;

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

+                uVar12 = ExtractFvek((longlong)(pUVar26 + 0x40),puVar22,

+                                     (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                     &local_210);

+                local_234 = (uint)uVar12;

+                uVar25 = local_228;

+                goto LAB_8;

+              }

+            }

+          }

+          else {

+            if ((int)local_234 < 0) goto LAB_6;

+            if (*(short *)(pUVar26 + 0xc) == 2) {

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

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

+                 (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_(WPP_GLOBAL_Control[3],0x117,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids

+                       );

+              }

+              uVar12 = ExtractFvek((longlong)(pUVar26 + 0x40),puVar19,

+                                   (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                   &local_228);

+              local_234 = (uint)uVar12;

+              uVar25 = local_228;

+            }

+            if ((int)local_234 < 0) goto LAB_6;

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

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

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

+                 (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                WPP_SF_(WPP_GLOBAL_Control[3],0x118,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids

+                       );

+              }

+              uVar12 = ExtractFvek((longlong)(pUVar26 + 0x40),puVar19,

+                                   (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                   &local_210);

+              local_234 = (uint)uVar12;

+LAB_8:

+              local_208 = local_210;

+              goto LAB_7;

+            }

+          }

+          Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+          puVar22 = puVar19;

+          uVar12 = FveValidateInformationEx(pUVar26,(longlong)local_1c0,puVar19,&local_22f);

+          uVar7 = (uint)uVar12;

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

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

+              uVar13 = 4;

+              if ((4 < DAT_9) &&

+                 (cVar5 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar5 != '\0')) {

+                local_1e8[0] = *(undefined2 *)(pUVar26 + 0xc);

+                local_e0 = (int)uVar13;

+                local_110 = local_e0 + -2;

+                local_10c = 0;

+                puVar22 = (ulonglong *)0x0;

+                local_118 = local_1e8;

+                local_1e4[0] = *(undefined2 *)(pUVar26 + 0xe);

+                local_fc = 0;

+                local_108 = local_1e4;

+                local_170 = *(undefined8 *)(pUVar26 + 0x10);

+                local_ec = 0;

+                local_f8 = &local_170;

+                local_f0 = 8;

+                local_1b8[0] = *(undefined4 *)(pUVar26 + 0x18);

+                local_dc = 0;

+                local_cc = 0;

+                local_bc = 0;

+                local_e8 = local_1b8;

+                local_d8 = pUVar26 + 0x50;

+                local_c8 = &local_168;

+                in_stack_fffffffffffffd90 = local_138;

+                local_d0 = 0x10;

+                local_168 = 0x1000000;

+                local_c0 = 8;

+                local_100 = local_110;

+                _tlgWriteTransfer_EtwWriteTransfer

+                          (0x14003b040,&DAT_10,0,0,8,in_stack_fffffffffffffd90);

+                uVar13 = 4;

+              }

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

+              puVar17 = WPP_GLOBAL_Control;

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

+                  ((byte)((byte)uVar13 & (byte)*(undefined4 *)((longlong)WPP_GLOBAL_Control + 0x2c))

+                   != 0)) && (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                uVar9 = (undefined4)((ulonglong)*(undefined8 *)(pUVar26 + 0x10) >> 0x20);

+                WPP_SF_DDIL(WPP_GLOBAL_Control[3],WPP_GLOBAL_Control,puVar22,

+                            (uint)*(ushort *)(pUVar26 + 0xc));

+              }

+              in_stack_fffffffffffffd90 =

+                   (undefined8 *)CONCAT44(uVar9,*(undefined4 *)(pUVar26 + 0x18));

+              FveLogEventWithMetadataValidation

+                        (*param_1,puVar17,*(undefined2 *)(pUVar26 + 0xc),

+                         *(undefined2 *)(pUVar26 + 0xe));

+              if ((1 < *(ushort *)(pUVar26 + 0xc)) &&

+                 ((*(int *)(pUVar26 + 0x18) != 0 || (*(longlong *)(pUVar26 + 0x10) != 0)))) {

+                if ((local_218 == (longlong *)0x0) ||

+                   ((*local_218 == 0 || (*(longlong *)(*local_218 + 0x48) != 0)))) {

+                  uVar7 = 0xc000000d;

+                  goto LAB_11;

+                }

+                if ((*(uint *)((longlong)param_1 + 0x344) & 0x100) == 0) {

+                  uVar7 = FveNvcWriteBackDisable((longlong *)param_1,1,'\0');

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

+                    uVar7 = FvePrepareForFveInfoCopyUpdate

+                                      ((longlong)param_1,*(int *)((longlong)param_1 + 0x7cc),0);

+                    bVar28 = true;

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

+                      pUVar26[0xc] = '\x01';

+                      pUVar26[0xd] = '\0';

+                      pUVar26[0xe] = '\x01';

+                      pUVar26[0xf] = '\0';

+                      pUVar26[0x18] = '\0';

+                      pUVar26[0x19] = '\0';

+                      pUVar26[0x1a] = '\0';

+                      pUVar26[0x1b] = '\0';

+                      pUVar26[0x10] = '\0';

+                      pUVar26[0x11] = '\0';

+                      pUVar26[0x12] = '\0';

+                      pUVar26[0x13] = '\0';

+                      pUVar26[0x14] = '\0';

+                      pUVar26[0x15] = '\0';

+                      pUVar26[0x16] = '\0';

+                      pUVar26[0x17] = '\0';

+                      uVar12 = FvepWriteInformation

+                                         ((longlong *)param_1,'\0',pUVar26,

+                                          (longlong *)(param_1 + 0x7f),0,puVar19,'\x01',2,'\x01');

+                      uVar7 = (uint)uVar12;

+                      FveCompleteFveInfoCopyUpdate((longlong)param_1);

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

+                        FveNvcWriteBackReset((longlong *)param_1,1);

+                        if (puVar27 != (ulonglong *)0x0) {

+                          local_234 = 0xc0210000;

+                          FveDatumFree(puVar27);

+                          if (uVar25 != 0) {

+                            DeleteKey(uVar25);

+                            uVar25 = 0;

+                            local_228 = 0;

+                          }

+                          if (local_208 != 0) {

+                            DeleteKey(local_208);

+                            local_208 = 0;

+                            local_210 = 0;

+                          }

+                          local_220 = (ulonglong *)0x0;

+                          local_1f0 = (ulonglong *)0x0;

+                          local_1f8 = (ulonglong *)0x0;

+                        }

+                        goto LAB_12;

+                      }

+                    }

+                    goto LAB_13;

+                  }

+                }

+                else {

+                  uVar7 = 0xc0210028;

+                }

+                bVar28 = false;

+                goto LAB_13;

+              }

+              if (puVar27 != (ulonglong *)0x0) {

+                local_234 = 0xc0210000;

+                FveDatumFree(puVar27);

+                if (uVar25 != 0) {

+                  DeleteKey(uVar25);

+                  uVar25 = 0;

+                  local_228 = 0;

+                }

+                if (local_208 != 0) {

+                  DeleteKey(local_208);

+                  local_208 = 0;

+                  local_210 = 0;

+                }

+                local_220 = (ulonglong *)0x0;

+                local_1f0 = (ulonglong *)0x0;

+                local_1f8 = (ulonglong *)0x0;

+              }

+            }

+LAB_12:

+            bVar6 = false;

+            bVar28 = false;

+            if ((int)local_234 < 0) goto LAB_6;

+            Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+            puVar20 = local_1c0;

+            if ((*(uint *)((longlong)param_1 + 0x344) & 0x100) != 0) goto LAB_14;

+            uVar16 = 0;

+            plVar14 = local_1d0;

+            goto LAB_15;

+          }

+LAB_11:

+          local_188 = &FVE_METADATA_CORRUPT_ERROR;

+          uStack_180 = CONCAT44(uVar7,(undefined4)uStack_180);

+          FveLogEventEx(*param_1,(longlong *)&local_188,'\0','\x01');

+          local_200 = local_200 + 1;

+          if (local_200 < uVar16) {

+            uVar12 = *(ulonglong *)(pUVar26 + (ulonglong)(local_200 % 3) * 8 + 0x20);

+            goto LAB_2;

+          }

+          local_1fc = local_1fc + 1;

+          if (5 < uVar16 + 1) {

+            uVar7 = 0xc0210002;

+            goto LAB_13;

+          }

+        }

+        uVar16 = uVar16 + 1;

+        uVar12 = local_1d0[(ulonglong)local_1fc + 1];

+        puVar19 = local_220;

+        local_200 = local_1fc;

+      } while( true );

+    }

+    uVar11 = FveEowLoad((longlong *)param_1,(longlong)(param_3 + 4),&local_218);

+    uVar7 = (uint)uVar11;

+    puVar19 = local_220;

+    if (-1 < (int)uVar7) goto LAB_2;

+    bVar28 = false;

+    pUVar26 = (PUCHAR)0x0;

+    goto LAB_13;

+  }

+  pvVar10 = (void *)ExAllocatePool2(0x40);

+  param_1[0x75] = (ulonglong)pvVar10;

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

+    memset(pvVar10,0,0x70);

+    goto LAB_0;

+  }

+LAB_1:

+  bVar28 = false;

+  uVar7 = 0xc000009a;

+  goto LAB_5;

+code_r0x000140083a03:

+  bVar28 = false;

+  goto LAB_13;

+  while (uVar16 = uVar16 + 1, uVar16 < 3) {

+LAB_15:

+    plVar14 = plVar14 + 1;

+    if (*plVar14 != *(longlong *)(pUVar26 + (0x18 - (longlong)local_1d0) + (longlong)plVar14)) {

+      *(uint *)((longlong)param_1 + 0x39c) = *(uint *)((longlong)param_1 + 0x39c) | 0x10;

+      break;

+    }

+  }

+LAB_14:

+  uVar13 = FveDatumMustBe((ulonglong *)(local_1c0 + 4),5);

+  if ((int)uVar13 < 0) {

+    uVar7 = 0xc0210002;

+    bVar28 = bVar6;

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

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

        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-      uVar3 = *(uint *)(*(longlong *)(unaff_RBX + 0x70) + 0x30);

-      if (((uVar3 >> 8 & 1) == 0) && (unaff_RSI = "critical", (uVar3 >> 0x16 & 1) == 0)) {

-        unaff_RSI = unaff_R14;

+      WPP_SF_(WPP_GLOBAL_Control[3],0x11a,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+    }

+  }

+  else {

+    puVar1 = (uint *)(pUVar26 + 0x40);

+    param_1[0x77] = *(ulonglong *)(puVar20 + 8);

+    *(undefined4 *)(param_1 + 0x78) = *(undefined4 *)(puVar20 + 0xc);

+    uVar12 = FveFindExtendedInfoInDataset(puVar1,(longlong *)&local_1c8);

+    puVar20 = local_1c8;

+    if (((((-1 < (int)uVar12) && (local_1c8 != (ushort *)0x0)) && (2 < *local_1c8)) &&

+        ((0x23 < local_1c8[1] && (*(int *)(local_1c8 + 0x10) != 0)))) &&

+       ((int)param_1[0x95] != *(int *)(local_1c8 + 0x10))) {

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

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

+         (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+        WPP_SF_Ld(WPP_GLOBAL_Control[3],0x11b,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                  (int)param_1[0x95]);

       }

-      WPP_SF_ds(WPP_GLOBAL_Control[3],299,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,iVar4,

-                unaff_RSI);

+      *(undefined4 *)(param_1 + 0x95) = *(undefined4 *)(puVar20 + 0x10);

     }

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

+LAB_16:

+      if (((puVar20 != (ushort *)0x0) && (4 < *puVar20)) && (0x4b < puVar20[1])) {

+        local_1a8 = *(ulonglong ********)(puVar20 + 0x1e);

+        local_1b0 = *(ulonglong ********)(puVar20 + 0x22);

+      }

+    }

+    else if (puVar20 != (ushort *)0x0) {

+      if (((*puVar20 != 0) && (0xf < puVar20[1])) && ((puVar20[4] & 1) != 0)) {

+        *(byte *)(*local_218 + 0x30) = *(byte *)(*local_218 + 0x30) | 0x20;

+      }

+      goto LAB_16;

+    }

+    local_1c8 = (ushort *)0x0;

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

+LAB_17:

+      if (*(short *)(pUVar26 + 0xc) == 2) {

+        Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+        if ((int)param_1[2] == 2) {

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

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

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_(WPP_GLOBAL_Control[3],0x11c,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+          }

+          uVar7 = 0xc0210034;

+        }

+        else {

+          uStack_180 = uStack_180 & 0xffffffff;

+          local_188 = &FVE_CONV_RECOVERING;

+          FveLogEventEx(*param_1,(longlong *)&local_188,'\0','\x01');

+          if ((*(uint *)((longlong)param_1 + 0x344) & 0x100) == 0) {

+            uVar7 = FveNvcWriteBackDisable((longlong *)param_1,1,'\0');

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

+              bVar4 = true;

+              uVar7 = FveConvRecoverDataAndWatermark(param_1,(longlong)pUVar26,uVar25,local_198);

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

+                 (uVar7 = FvePrepareForFveInfoCopyUpdate

+                                    ((longlong)param_1,*(int *)((longlong)param_1 + 0x7cc),0),

+                 -1 < (int)uVar7)) {

+                uVar13 = *(undefined8 *)(pUVar26 + 0x10);

+                uVar9 = *(undefined4 *)(pUVar26 + 0x18);

+                *(ulonglong *)(pUVar26 + 0x10) = local_198[0];

+                pUVar26[0x18] = '\0';

+                pUVar26[0x19] = '\0';

+                pUVar26[0x1a] = '\0';

+                pUVar26[0x1b] = '\0';

+                pUVar26[0xc] = '\x05';

+                pUVar26[0xd] = '\0';

+                uVar12 = FvepWriteInformation

+                                   ((longlong *)param_1,'\0',pUVar26,(longlong *)(param_1 + 0x7f),0,

+                                    local_220,'\x01',2,'\x01');

+                uVar7 = (uint)uVar12;

+                FveCompleteFveInfoCopyUpdate((longlong)param_1);

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

+                  FveNvcWriteBackReset((longlong *)param_1,1);

+                  goto LAB_18;

+                }

+                *(undefined8 *)(pUVar26 + 0x10) = uVar13;

+                *(undefined4 *)(pUVar26 + 0x18) = uVar9;

+                pUVar26[0xc] = '\x02';

+                pUVar26[0xd] = '\0';

+              }

+            }

+          }

+          else {

+            uVar7 = 0xc0210028;

+          }

+        }

+      }

+      else {

+LAB_18:

+        bVar4 = false;

+        if ((((local_1e0[0] == 2) && (local_218 == (longlong *)0x0)) &&

+            (*(short *)(pUVar26 + 0xc) == 4)) &&

+           (((*(int *)(pUVar26 + 0x18) == 0 && (*(ulonglong *)(pUVar26 + 0x10) < param_1[0x7e])) &&

+            ((*(uint *)((longlong)param_1 + 0x344) & 0x100) == 0)))) {

+          iVar8 = FveNvcWriteBackDisable((longlong *)param_1,1,'\0');

+          bVar6 = false;

+          if (-1 < iVar8) {

+            bVar4 = true;

+            iVar8 = FvePrepareForFveInfoCopyUpdate

+                              ((longlong)param_1,*(int *)((longlong)param_1 + 0x7cc),0);

+            bVar6 = true;

+            if (-1 < iVar8) {

+              pUVar26[0xc] = '\x05';

+              pUVar26[0xd] = '\0';

+              uVar12 = FvepWriteInformation

+                                 ((longlong *)param_1,'\0',pUVar26,(longlong *)(param_1 + 0x7f),0,

+                                  local_220,'\x01',2,'\x01');

+              iVar8 = (int)uVar12;

+              FveCompleteFveInfoCopyUpdate((longlong)param_1);

+              bVar6 = true;

+              if (iVar8 < 0) {

+                pUVar26[0xc] = '\x04';

+                pUVar26[0xd] = '\0';

+              }

+            }

+          }

+          iVar24 = 4;

+          if ((4 < DAT_9) &&

+             (cVar5 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar5 != '\0')) {

+            local_1d0 = *(longlong **)(pUVar26 + 0x10);

+            local_8c = 0;

+            local_7c = 0;

+            local_6c = 0;

+            local_5c = 0;

+            local_4c = 0;

+            local_98 = &local_1d0;

+            local_160[0] = param_1[0x7e];

+            local_88 = local_160;

+            local_78 = pUVar26 + 0x50;

+            local_70 = iVar24 + 0xc;

+            local_68 = local_1e0;

+            local_58 = local_160 + 1;

+            local_90 = 8;

+            local_80 = 8;

+            local_160[1] = 0x1000000;

+            local_50 = 8;

+            local_1e0[0] = iVar8;

+            local_60 = iVar24;

+            _tlgWriteTransfer_EtwWriteTransfer(0x14003b040,&DAT_19,0,0,7,local_b8);

+          }

+          if (bVar6) {

+            FveNvcWriteBackReset((longlong *)param_1,1);

+            bVar4 = false;

+          }

+        }

+        iVar8 = FveDatasetHasClearKey((longlong)puVar1,local_22e);

+        puVar19 = local_220;

+        if ((-1 < iVar8) && (local_22e[0] != '\0')) {

+          *(uint *)((longlong)param_1 + 0x344) = *(uint *)((longlong)param_1 + 0x344) | 2;

+        }

+        uVar12 = FveDatumDuplicate(local_220,param_1 + 0x7a);

+        uVar7 = (uint)uVar12;

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

+          uVar12 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

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

+            param_1[0x79] = uVar25;

+            uVar25 = 0;

+            local_228 = 0;

+            FveResolveIceCryptoInfo

+                      ((longlong *)param_1,(longlong)puVar1,puVar19,local_1a8,local_1b0);

+          }

+          else {

+            iVar8 = FveResolveIceCryptoInfoV2

+                              ((longlong *)param_1,(longlong)puVar1,puVar19,local_1a8,local_1b0);

+            if ((((iVar8 < 0) &&

+                 (puVar19 = local_220, (undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

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

+               (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_D(WPP_GLOBAL_Control[3],0x11d,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                       iVar8);

+              puVar19 = local_220;

+            }

+            if ((uVar25 == 0) && ((param_1[0x23d] == 0 || (*(int *)(param_1[0x23d] + 0x58) == 0))))

+            {

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

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

+                  (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+                WPP_SF_(WPP_GLOBAL_Control[3],0x11e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids

+                       );

+              }

+              uVar12 = ExtractFvek((longlong)puVar1,puVar19,

+                                   (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                   &local_228);

+              local_234 = (uint)uVar12;

+              uVar25 = local_228;

+              if (-1 < (int)local_234) goto LAB_20;

+            }

+            else {

+LAB_20:

+              if ((uVar25 != 0) && ((param_1[0x23d] == 0 || (*(int *)(param_1[0x23d] + 0x58) == 0)))

+                 ) {

+                if (param_1[0x79] != 0) goto LAB_21;

+                param_1[0x79] = uVar25;

+                local_228 = 0;

+                uVar25 = 0;

+              }

+            }

+            if (((((*(uint *)(param_1[1] + 0x2510) & 0x10) != 0) && (param_1[0x23d] != 0)) &&

+                (*(int *)(param_1[0x23d] + 0x58) != 0)) &&

+               ((((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control &&

+                 ((char)*(undefined4 *)((longlong)WPP_GLOBAL_Control + 0x2c) < '\0')) &&

+                (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+              WPP_SF_(WPP_GLOBAL_Control[3],0x11f,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+            }

+          }

+          if ((param_1[0x23d] == 0) || ((*(uint *)(param_1[1] + 0x2510) & 2) == 0)) {

+LAB_6:

+            sVar3 = *(short *)(pUVar26 + 10);

+            if (sVar3 == 2) {

+              uVar16 = (uint)uStack_148 >> 4;

+            }

+            else {

+              uVar16 = 0;

+              if (sVar3 == 1) {

+                uVar16 = (uint)uStack_148;

+              }

+            }

+            *(short *)(pUVar26 + 8) = (short)uVar16;

+            if (sVar3 == 2) {

+              uVar16 = (uVar16 & 0xffff) << 4;

+            }

+            else if (sVar3 == 1) {

+              uVar16 = uVar16 & 0xffff;

+            }

+            else {

+              uVar16 = 0;

+            }

+            pplVar23 = &local_218;

+            *(uint *)(pUVar26 + 0x40) = uVar16 - 0x40;

+            *(uint *)(pUVar26 + 0x44) = *(uint *)(pUVar26 + 0x44) | 0x80000000;

+            puVar20 = local_1c0;

+            for (uVar12 = (ulonglong)*local_1c0; uVar12 != 0; uVar12 = uVar12 - 1) {

+              *(undefined1 *)puVar20 = 0;

+              puVar20 = (ushort *)((longlong)puVar20 + 1);

+            }

+            pUVar18 = pUVar26;

+            uVar9 = SetInitialFveState((longlong *)param_1,(longlong)pUVar26,(longlong *)pplVar23);

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

+              uVar12 = FveReadWriteDeviceInit((longlong)param_1);

+              uVar7 = (uint)uVar12;

+              if ((int)uVar7 < 0) goto LAB_13;

+              if ((int)param_1[2] != 2) {

+                uVar12 = FveRegisterPnpNotifications((longlong *)param_1,pUVar18,pplVar23);

+                uVar7 = (uint)uVar12;

+                if ((int)uVar7 < 0) goto LAB_13;

+              }

+              UpdateDynamicContext((longlong)param_1,local_220,(longlong)(pUVar26 + 0x40));

+              FveConvDetermineInitialStatus((longlong)param_1);

+              if ((int)param_1[2] != 2) {

+                FveScheduleFsMount(param_1);

+              }

+              if (((bVar28) && ((longlong *)param_1[0x5b] != (longlong *)0x0)) &&

+                 ((lVar21 = *(longlong *)param_1[0x5b], lVar21 != 0 &&

+                  (bVar2 = *(byte *)(lVar21 + 0x30), (bVar2 & 1) != 0)))) {

+                bVar28 = (bVar2 & 2) != 0;

+              }

+            }

+            uVar12 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+            if ((((int)uVar12 != 0) && ((*(uint *)((longlong)param_1 + 0x344) & 0x8040) == 0)) &&

+               ((*(uint *)((longlong)param_1 + 0x344) & 0x19) != 0)) {

+              if ((param_1[0x79] == 0) && (param_1[0x23d] == 0)) {

+LAB_21:

+                    /* WARNING: Subroutine does not return */

+                KeBugCheckEx(0x120,0xc,0);

+              }

+              if ((param_1[0x23d] == 0) || (*(int *)(param_1[0x23d] + 0x58) == 0)) {

+                bVar6 = false;

+              }

+              else {

+                bVar6 = true;

+              }

+              if ((param_1[0x79] != 0) == bVar6) goto LAB_21;

+            }

+          }

+          else {

+            uVar12 = Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

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

+              uVar12 = FveIceSimAlloc(param_1,(undefined8 *)0x0);

+              uVar7 = (uint)uVar12;

+              if (-1 < (int)uVar7) goto LAB_6;

+            }

+            else {

+              uVar12 = ExtractFvek((longlong)puVar1,puVar19,

+                                   (undefined *)(ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                   local_198 + 1);

+              uVar7 = (uint)uVar12;

+              if ((int)uVar7 < 0) {

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  uVar15 = 0x120;

+LAB_22:

+                  WPP_SF_D(WPP_GLOBAL_Control[3],uVar15,

+                           &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar7);

+                }

+              }

+              else {

+                uVar12 = FveIceSimAlloc(param_1,local_198 + 1);

+                uVar7 = (uint)uVar12;

+                if (-1 < (int)uVar7) goto LAB_6;

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

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

+                   (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                  uVar15 = 0x121;

+                  goto LAB_22;

+                }

+              }

+            }

+          }

+        }

+      }

+    }

+    else {

+      plVar14 = local_218;

+      Feature_SteelixInlineNvmeCryptoEngine__private_IsEnabledDeviceUsageNoInline();

+      FveEowSetKey(plVar14,local_218,&local_210);

+      local_208 = local_210;

+      if (local_210 == 0) {

+        uVar12 = FveConvCreateUsedBitmap

+                           ((ulonglong)*(uint *)((longlong)local_218 + 0x94),

+                            *(ulonglong *)(*local_218 + 0x38),&local_1a0);

+        uVar7 = (uint)uVar12;

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

+          LOCK();

+          puVar17 = (undefined8 *)param_1[0xaa];

+          param_1[0xaa] = local_1a0;

+          UNLOCK();

+          if (puVar17 != (undefined8 *)0x0) {

+            FveConvReleaseUsedBitmap(puVar17);

+          }

+          pUVar26 = local_1d8;

+          if (*(short *)(local_1d8 + 0xc) != 4) {

+LAB_23:

+            local_1f0 = local_1f8;

+            local_208 = local_210;

+            uVar25 = local_228;

+            goto LAB_17;

+          }

+          uVar7 = FveNvcWriteBackDisable((longlong *)param_1,1,'\0');

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

+            bVar28 = true;

+            uVar12 = FveFindExtendedInfoInDataset(puVar1,(longlong *)&local_1c8);

+            puVar20 = local_1c8;

+            uVar7 = (uint)uVar12;

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

+              if (((local_1c8 == (ushort *)0x0) || (*local_1c8 == 0)) || (local_1c8[1] < 0x10)) {

+                local_1f0 = local_1f8;

+                uVar7 = 0xc000000d;

+                bVar28 = true;

+                local_208 = local_210;

+                uVar25 = local_228;

+                goto LAB_13;

+              }

+              uVar12 = FveEowRecover((longlong *)param_1,local_218,

+                                     ~(byte)((uint)*(undefined4 *)(local_1c8 + 4) >> 8) & 1);

+              uVar7 = (uint)uVar12;

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

+                if ((*(uint *)(puVar20 + 4) >> 8 & 1) != 0) {

+                  FveNvcWriteBackReset((longlong *)param_1,1);

+                  bVar28 = false;

+                }

+                goto LAB_23;

+              }

+            }

+          }

+          local_1f0 = local_1f8;

+          local_208 = local_210;

+          uVar25 = local_228;

+        }

+      }

+      else {

+        uVar7 = 0xc0000001;

+      }

+    }

+  }

+LAB_13:

+  if (((pUVar26 != (PUCHAR)0x0) &&

+      (uVar12 = FvepCacheFveInformationAndUpgradeExtInfo((longlong)param_1,(undefined8 *)pUVar26),

+      -1 < (int)uVar7)) && ((int)(uint)uVar12 < 0)) {

+    uVar7 = (uint)uVar12;

+  }

+LAB_5:

+  lVar21 = local_208;

+  puVar19 = local_1f0;

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

+    LOCK();

+    uVar12 = param_1[0xaa];

+    param_1[0xaa] = 0;

+    UNLOCK();

+    FveEowControlFree((undefined1 *)local_218);

+    local_218 = (longlong *)0x0;

+    LOCK();

+    param_1[0xaa] = uVar12;

+    UNLOCK();

+    lVar21 = local_210;

+    uVar25 = local_228;

+    pUVar26 = local_1d8;

+    puVar19 = local_1f8;

+  }

+  if ((int)uVar7 < 0) {

+    SetFveStateEx((longlong *)param_1,0x40,0,0,'\x01',4);

+  }

+  if (bVar28) {

+    FveNvcWriteBackReset((longlong *)param_1,1);

+  }

+  if (bVar4) {

+    FveNvcWriteBackReset((longlong *)param_1,1);

+  }

+  *(uint *)(param_1 + 0xa4) = local_234;

+  uVar16 = uVar7;

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

+    uVar16 = local_234;

+  }

+  uVar9 = 0xc0210024;

+  *(uint *)((longlong)param_1 + 0x31c) = uVar16;

+  if (uVar16 == 0xc0210024) {

+    *(undefined4 *)((longlong)param_1 + 0x334) = 8;

   }

   else {

-    for (; _Str1 != (wchar_t *)0x0; _Str1 = _Str1 + lVar9 + 2) {

-      iVar5 = _wcsicmp(_Str1,L"dumpfve.sys");

-      if (iVar5 == 0) {

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

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

-           (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          uVar3 = *(uint *)(*(longlong *)(unaff_RBX + 0x70) + 0x30);

-          if (((uVar3 >> 8 & 1) == 0) && (unaff_RSI = "critical", (uVar3 >> 0x16 & 1) == 0)) {

-            unaff_RSI = "unknown";

-          }

-          WPP_SF_s(WPP_GLOBAL_Control[3],300,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                   unaff_RSI);

-        }

-        ExFreePoolWithTag(pwVar2,0x30455646);

-        FvepReleaseDevFveLock((longlong *)(unaff_RBP + -0x20));

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

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

-           (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-          WPP_SF_D(WPP_GLOBAL_Control[3],0x12e,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                   iVar4);

-        }

-        return uVar7 & 0xffffffff;

-      }

-      lVar8 = -1;

-      do {

-        lVar9 = lVar8;

-        lVar8 = lVar9 + 1;

-      } while (_Str1[lVar8] != L'\0');

-    }

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

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

-       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-      uVar3 = *(uint *)(*(longlong *)(unaff_RBX + 0x70) + 0x30);

-      if (((uVar3 >> 8 & 1) == 0) && (unaff_RSI = "critical", (uVar3 >> 0x16 & 1) == 0)) {

-        unaff_RSI = "unknown";

-      }

-      WPP_SF_s((undefined8 *)WPP_GLOBAL_Control[3],0x12d,

-               &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,unaff_RSI);

-    }

-  }

-  uVar3 = *(uint *)(*(undefined1 **)(unaff_RDI + 0x280) + 8);

-  if (uVar3 < 0x4000) {

-    uVar3 = 0x4000;

-  }

-  FveSecureZeroAndFlush(*(undefined1 **)(unaff_RDI + 0x280),uVar3);

-                    /* WARNING: Subroutine does not return */

-  KeBugCheckEx(0x120,0x12);

+    uVar9 = 0xc0210034;

+    if (uVar16 != 0xc0210034) goto LAB_24;

+    *(undefined4 *)((longlong)param_1 + 0x334) = 5;

+  }

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

+LAB_24:

+  if (puVar19 != (ulonglong *)0x0) {

+    FveDatumFree(puVar19);

+  }

+  if (uVar25 != 0) {

+    DeleteKey(uVar25);

+  }

+  if (lVar21 != 0) {

+    DeleteKey(lVar21);

+  }

+  if (pUVar26 != (PUCHAR)0x0) {

+    ExFreePoolWithTag(pUVar26,0x30455646);

+  }

+  if ((-1 < (int)uVar7) && (1 < (uint)param_1[0x9d])) {

+    FveRegisterMetadataCheckWorker((longlong *)param_1);

+  }

+  FveTestDevStateChange((longlong *)param_1,4,'\x01');

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_Ld(WPP_GLOBAL_Control[3],0x122,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar7);

+  }

+  return;

 }
```

## `FveWriteWipeInfo`  (modified)

```diff
--- FveWriteWipeInfo
+++ FveWriteWipeInfo
@@ -1,10 +1,222 @@
 

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

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

 

 int FveWriteWipeInfo(longlong *param_1,ushort *param_2,longlong param_3,char param_4)

 

 {

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

-  halt_baddata();

+  longlong *plVar1;

+  bool bVar2;

+  uint uVar3;

+  int iVar4;

+  ulonglong uVar5;

+  ushort *_Dst;

+  void *_Dst_00;

+  undefined8 uVar6;

+  void *pvVar7;

+  byte bVar8;

+  uint uVar9;

+  uint uVar10;

+  ulonglong uVar11;

+  ulonglong _Size;

+  undefined8 local_110;

+  ulonglong uStack_108;

+  undefined *local_100;

+  undefined8 uStack_f8;

+  undefined8 local_f0;

+  undefined8 local_e8 [2];

+  longlong local_d8 [19];

+  

+  local_110 = 0;

+  uStack_108 = 0;

+  memset(local_d8,0,0x90);

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x5e,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids);

+  }

+  local_e8[0] = 0;

+  bVar2 = false;

+  uVar9 = 0x200;

+  if (0x1ff < *param_2) {

+    uVar9 = (uint)*param_2;

+  }

+  uVar10 = *(uint *)((longlong)param_1 + 0x49c);

+  if (((uVar10 & uVar10 - 1) == 0) && (uVar10 != 0)) {

+    uVar9 = (uVar9 - 1) + uVar10 & ~(uVar10 - 1);

+  }

+  else if (uVar9 % uVar10 != 0) {

+    uVar9 = (uVar9 - uVar9 % uVar10) + uVar10;

+  }

+  local_f0 = 0;

+  uVar11 = 0;

+  local_100 = (undefined *)0x0;

+  uStack_f8 = 0;

+  bVar8 = *(char *)((longlong)param_2 + 3) - 1;

+  do {

+    if (*(longlong *)(param_3 + (ulonglong)(bVar8 & 1) * 8) != 0) {

+      *(char *)((longlong)param_2 + 3) = *(char *)((longlong)param_2 + 3) + (char)uVar11;

+      uVar10 = bVar8 & 1;

+      uVar11 = (ulonglong)uVar10;

+      uVar5 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline()

+      ;

+      _Size = (ulonglong)uVar9;

+      uVar6 = 0x100;

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

+        uVar6 = 0x108;

+      }

+      _Dst = (ushort *)ExAllocatePool2(uVar6,uVar9,0x30455646);

+      if (_Dst == (ushort *)0x0) {

+        iVar4 = -0x3fffff66;

+      }

+      else {

+        memset(_Dst,0,_Size);

+        uVar5 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                          ();

+        uVar6 = 0x100;

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

+          uVar6 = 0x108;

+        }

+        _Dst_00 = (void *)ExAllocatePool2(uVar6,_Size,0x30455646);

+        if (_Dst_00 == (void *)0x0) {

+          iVar4 = -0x3fffff66;

+        }

+        else {

+          pvVar7 = _Dst_00;

+          memset(_Dst_00,0,_Size);

+          *(undefined8 *)(param_2 + 0x10) = _DAT_0;

+          uVar6 = *(undefined8 *)(param_2 + 4);

+          *(undefined8 *)_Dst = *(undefined8 *)param_2;

+          *(undefined8 *)(_Dst + 4) = uVar6;

+          uVar6 = *(undefined8 *)(param_2 + 0xc);

+          *(undefined8 *)(_Dst + 8) = *(undefined8 *)(param_2 + 8);

+          *(undefined8 *)(_Dst + 0xc) = uVar6;

+          *(undefined8 *)(_Dst + 0x10) = *(undefined8 *)(param_2 + 0x10);

+          _Dst[2] = 0;

+          _Dst[3] = 0;

+          uVar3 = ComputeCrc32(pvVar7,(byte *)_Dst,0x28);

+          *(uint *)(_Dst + 2) = uVar3;

+          iVar4 = FveValidateWipeInfo(uVar9,_Dst,*(uint *)((longlong)param_1 + 0x49c));

+          if (-1 < iVar4) {

+            plVar1 = (longlong *)(param_3 + uVar11 * 8);

+            iVar4 = ZwWriteFile(*plVar1,0,0,0,&local_110,_Dst,uVar9,local_e8,0);

+            if ((iVar4 < 0) || (iVar4 = (int)local_110, (int)local_110 < 0)) {

+LAB_1:

+              if (iVar4 == -0x3ffffd92) {

+                ZwClose(*plVar1);

+                *plVar1 = 0;

+                uVar5 = FveWipeInfoFileCreate((longlong)param_1,(ushort *)0x0,uVar10,'\0',plVar1);

+                iVar4 = (int)uVar5;

+                if (iVar4 < 0) {

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

+                      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+                     (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                    WPP_SF_Ld(WPP_GLOBAL_Control[3],0x61,

+                              &WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,uVar10);

+                  }

+                }

+                else {

+                  iVar4 = ZwWriteFile(*plVar1,0,0,0,&local_110,_Dst,uVar9,local_e8,0);

+                  if (-1 < iVar4) {

+                    if ((-1 < (int)local_110) && (uStack_108 == _Size)) goto LAB_2;

+                    iVar4 = (int)local_110;

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

+                      iVar4 = -0x3fffffff;

+                    }

+                  }

+                }

+              }

+            }

+            else {

+              if (uStack_108 == _Size) {

+LAB_2:

+                iVar4 = ZwFlushBuffersFile(*plVar1,&local_110);

+                if ((iVar4 < 0) || (iVar4 = (int)local_110, (int)local_110 < 0)) {

+                  local_100 = &FVE_METADATA_DISK_FAILED_FLUSH_ERROR;

+                  bVar2 = true;

+                  uStack_f8 = CONCAT44(iVar4,(undefined4)uStack_f8);

+                  FveLogEvent(*param_1,(longlong *)&local_100);

+                  goto LAB_3;

+                }

+                iVar4 = ZwReadFile(*plVar1,0,0,0,&local_110,_Dst_00,uVar9,local_e8,0);

+                if (iVar4 < 0) {

+LAB_4:

+                  local_100 = &FVE_METADATA_DISK_FAILED_READBACK_ERROR;

+                }

+                else {

+                  if (((int)local_110 < 0) || (uStack_108 != _Size)) {

+                    iVar4 = (int)local_110;

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

+                      iVar4 = -0x3fffffff;

+                    }

+                    goto LAB_4;

+                  }

+                  uVar5 = RtlCompareMemory(_Dst,_Dst_00,_Size);

+                  if (uVar5 == _Size) {

+                    *(char *)((longlong)param_2 + 3) = *(char *)((longlong)param_2 + 3) + '\x01';

+                    goto LAB_3;

+                  }

+                  iVar4 = -0x3fdefffe;

+                  local_100 = &FVE_METADATA_DISK_FAILED_VERIFY_ERROR;

+                }

+                bVar2 = true;

+                uStack_f8 = CONCAT44(iVar4,(undefined4)uStack_f8);

+                FveLogEvent(*param_1,(longlong *)&local_100);

+                goto LAB_3;

+              }

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

+              iVar4 = -0x3fffffff;

+            }

+            local_100 = &FVE_METADATA_FAILED_COMMIT;

+            bVar2 = true;

+            uStack_f8 = CONCAT44(iVar4,(undefined4)uStack_f8);

+            FveLogEvent(*param_1,(longlong *)&local_100);

+          }

+        }

+LAB_3:

+        ExFreePoolWithTag(_Dst,0x30455646);

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

+          ExFreePoolWithTag(_Dst_00,0x30455646);

+        }

+      }

+      if (bVar2) goto LAB_5;

+      goto LAB_6;

+    }

+    bVar2 = true;

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

+        ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+       (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      WPP_SF_(WPP_GLOBAL_Control[3],0x5f,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids);

+    }

+    uVar10 = (int)uVar11 + 1;

+    uVar11 = (ulonglong)uVar10;

+    bVar8 = bVar8 + 1;

+  } while (uVar10 < 2);

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x60,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids);

+  }

+  iVar4 = -0x3fdefffe;

+LAB_5:

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

+    if (((uint)uVar11 < 2) && (*(longlong *)(param_3 + uVar11 * 8) != 0)) {

+      ZwClose();

+      *(undefined8 *)(param_3 + uVar11 * 8) = 0;

+    }

+    FvepAcquireDevFveLock(param_1,local_d8,'\x01');

+    *(uint *)(param_1 + 0x73) = *(uint *)(param_1 + 0x73) | 4;

+    FveTestDevStateChange(param_1,10,'\x01');

+    FvepReleaseDevFveLock(local_d8);

+    if (param_1[0x92] == 0) {

+      FveQueueAutoWorkItem(param_1,FveControlFilesManage,(longlong)param_1);

+    }

+  }

+LAB_6:

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x62,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,iVar4);

+  }

+  return iVar4;

 }
```

## `AcquireRequestResources`  (modified)

```diff
--- AcquireRequestResources
+++ AcquireRequestResources
@@ -1,134 +1,474 @@
-

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

 

 longlong *

 AcquireRequestResources

           (undefined8 *param_1,longlong param_2,char param_3,ulonglong param_4,uint param_5)

 

 {

-  uint uVar1;

-  longlong lVar2;

-  longlong lVar3;

-  longlong lVar4;

-  undefined8 *puVar5;

-  undefined1 uVar6;

-  longlong *plVar7;

-  ulonglong uVar8;

-  byte bVar9;

-  longlong unaff_RBX;

-  byte unaff_BPL;

-  longlong unaff_RSI;

-  ulonglong unaff_RDI;

-  longlong unaff_R13;

-  undefined1 unaff_R15B;

-  undefined2 in_stack_00000090;

+  longlong *plVar1;

+  byte bVar2;

+  undefined2 uVar3;

+  int iVar4;

+  uint uVar5;

+  longlong lVar6;

+  undefined8 uVar7;

+  undefined1 uVar8;

+  char cVar9;

+  int iVar10;

+  uint uVar11;

+  longlong *plVar12;

+  ulonglong uVar13;

+  longlong lVar14;

+  longlong lVar15;

+  void *pvVar16;

+  undefined8 *puVar17;

+  byte bVar18;

+  uint uVar19;

+  longlong *plVar20;

+  ulonglong uVar21;

+  uint uVar22;

+  longlong lVar23;

+  uint uVar24;

+  longlong local_78;

+  longlong local_70;

+  ulonglong local_68;

+  longlong *local_58;

   

-  uVar8 = (ulonglong)*(uint *)(param_1 + 3);

-  do {

-    MmUnmapLockedPages(uVar8,param_2);

+  lVar15 = param_1[1];

+  uVar13 = 0;

+  local_68 = 0;

+  plVar12 = (longlong *)ExAllocateFromNPagedLookasideList(*(undefined8 *)(lVar15 + 0x2270));

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

+    uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+      plVar12 = (longlong *)param_1[0xdc];

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

+    }

+    KeReleaseSpinLock(param_1 + 0xdb,uVar8);

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

+      return (longlong *)0x0;

+    }

+  }

+  else {

+    plVar20 = plVar12 + 0x39;

+    lVar23 = 0x20;

     do {

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

-      puVar5 = *(undefined8 **)(unaff_R13 + 8);

-      *puVar5 = 0;

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

-           ((short)((ulonglong)((uint)unaff_RDI & 0xfff) + 0xfff + (ulonglong)uVar1 >> 0xc) + 6) * 8

-      ;

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

-      puVar5[4] = unaff_RDI & 0xfffffffffffff000;

-      *(uint *)((longlong)puVar5 + 0x2c) = (uint)unaff_RDI & 0xfff;

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

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

-      MmMdlPageContentsState(*(undefined8 *)(unaff_R13 + 8),1);

-      *(undefined2 *)(*(longlong *)(unaff_R13 + 8) + 8) = in_stack_00000090;

-      do {

-        lVar2 = *(longlong *)(unaff_R13 + 0xb8);

-        *(undefined4 *)(lVar2 + -0x40) = *(undefined4 *)(unaff_RSI + 0x7c);

-        *(undefined8 *)(lVar2 + -0x30) = *(undefined8 *)(unaff_RSI + 8);

-        lVar2 = *(longlong *)(unaff_R13 + 0xb8);

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

-        *(longlong *)(lVar2 + -8) = unaff_RSI;

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

-        LOCK();

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

-        UNLOCK();

-        KeReleaseSpinLock(unaff_RBX + 0x68,unaff_R15B);

-        lVar2 = *(longlong *)(unaff_RSI + 0x10);

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

-        lVar4 = *(longlong *)(lVar2 + 0x30);

-        *(undefined8 *)(unaff_RSI + 0x48) = _DAT_0;

-        *(undefined4 *)(unaff_RSI + 0x5c) = *(undefined4 *)(unaff_RSI + 0x7c);

-        FvePerfTraceDevPtr(lVar4,&FVE_PERF_READ_SUBREQUEST_START,lVar3);

-        LOCK();

-        *(longlong *)(lVar4 + 0x820) = *(longlong *)(lVar4 + 0x820) + 1;

-        UNLOCK();

-        if (*(char *)(unaff_RSI + 0x88) < '\0') {

-          LOCK();

-          *(longlong *)(lVar4 + 0x8f8) = *(longlong *)(lVar4 + 0x8f8) + 1;

-          UNLOCK();

-        }

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

-        uVar6 = KeAcquireSpinLockRaiseToDpc(unaff_RSI + 0x98);

-        uVar8 = (ulonglong)*(byte *)((ulonglong)*(byte *)(unaff_RSI + 0xaf) + 0xa0 + unaff_RSI);

-        if (*(char *)(uVar8 * 0x1d + 0x5bc + lVar4) == '\0') {

+      *plVar20 = 0;

+      plVar20[1] = 0;

+      KeInitializeSpinLock(plVar20 + -1);

+      plVar20 = plVar20 + 0x16;

+      lVar23 = lVar23 + -1;

+    } while (lVar23 != 0);

+  }

+  iVar10 = FvepAcquireRemoveLockEx(param_1 + 7,'\x01');

+  if (iVar10 < 0) {

                     /* WARNING: Subroutine does not return */

-          KeBugCheckEx(0x120,0xb,unaff_RSI,uVar8,0xc);

-        }

-        bVar9 = *(byte *)(unaff_RSI + 0xaf) + 1;

-        *(byte *)(unaff_RSI + 0xaf) = bVar9;

-        if (0xe < bVar9) {

-          *(undefined1 *)(unaff_RSI + 0xaf) = 0;

-          bVar9 = 0;

-        }

-        *(undefined1 *)((ulonglong)bVar9 + 0xa0 + unaff_RSI) = 0xc;

-        KeReleaseSpinLock(unaff_RSI + 0x98,uVar6);

-        if (((*(byte *)(unaff_RSI + 0x90) & 1) != 0) && ((*(uint *)(lVar3 + 0x10) & 2) == 0)) {

-          *(uint *)(lVar3 + 0x10) = *(uint *)(lVar3 + 0x10) | 2;

-          *(byte *)(unaff_RSI + 0x90) = *(byte *)(unaff_RSI + 0x90) | 2;

-        }

-        if (*(longlong *)(lVar2 + 0xc0) == 0) {

-          IofCallDriver(*(undefined8 *)(*(longlong *)(lVar2 + 0x30) + 0x68),lVar3);

+    KeBugCheckEx(0x120,10,(longlong)iVar10,param_1,0);

+  }

+  *(undefined1 *)((longlong)plVar12 + 0x5c) = 0;

+  plVar20 = plVar12 + 0x12;

+  plVar12[0x17] = 0;

+  *(undefined4 *)((longlong)plVar12 + 100) = 1;

+  *(undefined4 *)(plVar12 + 0x14) = 0;

+  *plVar12 = 0;

+  plVar12[0x22] = 0;

+  plVar12[0x13] = (longlong)plVar20;

+  *plVar20 = (longlong)plVar20;

+  plVar20 = plVar12 + 0x15;

+  plVar12[0x16] = (longlong)plVar20;

+  *plVar20 = (longlong)plVar20;

+  if ((*(uint *)(param_1 + 99) & 0x40) == 0 && (*(uint *)(param_1 + 99) & 0x17f) != 0) {

+    if ((*(short *)(param_1[0x75] + 10) != 1) &&

+       (uVar19 = *(uint *)(param_1[0x75] + 0x1c), uVar13 = (ulonglong)uVar19, uVar19 == 0)) {

+      uVar13 = 1;

+    }

+    local_68 = *(uint *)((longlong)param_1 + 0x49c) * uVar13;

+  }

+  local_78 = 0;

+  plVar20 = plVar12 + 0x24;

+  local_70 = 0;

+  plVar1 = plVar12 + 0x23;

+  iVar10 = IoGetFsTrackOffsetState(param_2,&local_78,&local_70);

+  if (((iVar10 < 0) || (local_78 == 0)) || ((*(byte *)(local_78 + 2) & 1) == 0)) {

+LAB_0:

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

+      *plVar1 = -1;

+      *plVar1 = -1;

+    }

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

+      *plVar20 = 0;

+    }

+    *(undefined1 *)((longlong)plVar12 + 0x114) = 0;

+  }

+  else {

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

+      *plVar1 = local_70;

+    }

+    if ((local_70 == -1) || (*(longlong *)(local_78 + 0x10) == 0)) goto LAB_0;

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

+      *plVar20 = *(longlong *)(local_78 + 0x10);

+    }

+    *(undefined1 *)((longlong)plVar12 + 0x114) = 1;

+    lVar23 = 0x900;

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

+      lVar23 = 0x908;

+    }

+    LOCK();

+    *(longlong *)(lVar23 + (longlong)param_1) = *(longlong *)(lVar23 + (longlong)param_1) + 1;

+    UNLOCK();

+  }

+  uVar13 = (ulonglong)*(uint *)(lVar15 + 0x344);

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

+    iVar4 = *(int *)((longlong)param_1 + uVar13 * 4 + 0x5bc);

+    uVar19 = iVar4 * 6;

+    iVar10 = iVar4 * 4;

+    uVar22 = ((uint)(iVar4 * 2) < param_5) + 1;

+    do {

+      if (param_5 <= uVar19) break;

+      uVar22 = uVar22 + 1;

+      iVar10 = iVar10 + *(int *)((longlong)param_1 + uVar13 * 4 + 0x5bc) * 2;

+      uVar19 = uVar19 + iVar10;

+    } while (uVar22 < 0x20);

+    uVar21 = (ulonglong)param_5 / (ulonglong)uVar22;

+    uVar13 = (ulonglong)param_5 % (ulonglong)uVar22;

+    uVar19 = (uint)uVar21;

+    if (uVar19 < (uint)(iVar4 * 0x21)) {

+      uVar5 = *(uint *)((longlong)param_1 + 0x49c);

+      if (((uVar5 & uVar5 - 1) == 0) && (uVar5 != 0)) {

+        uVar21 = (ulonglong)((uVar19 - 1) + uVar5 & ~(uVar5 - 1));

+      }

+      else {

+        uVar13 = uVar21 % (ulonglong)uVar5;

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

+          uVar21 = (ulonglong)(uVar19 + (uVar5 - (int)uVar13));

+        }

+      }

+    }

+    else {

+      uVar21 = (ulonglong)(uint)(iVar4 * 0x21);

+    }

+    uVar19 = (uint)uVar21;

+    if (((1 < uVar22) && (uVar19 < 0x100000)) && (((uVar19 & uVar19 - 1) != 0 || (uVar19 == 0)))) {

+      cVar9 = RtlFindMostSignificantBit(uVar21);

+      uVar19 = 1 << (cVar9 + 1U & 0x1f);

+      uVar22 = param_5 / uVar19;

+      uVar13 = (ulonglong)param_5 % (ulonglong)uVar19;

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

+        uVar22 = uVar22 + 1;

+      }

+    }

+    *(uint *)(plVar12 + 0xc) = uVar19;

+  }

+  else {

+    uVar19 = *(uint *)((longlong)param_1 + uVar13 * 4 + 0x5b0);

+    *(uint *)(plVar12 + 0xc) = uVar19;

+    uVar5 = *(uint *)((longlong)param_1 + (ulonglong)*(uint *)(lVar15 + 0x344) * 4 + 0x5b0);

+    uVar11 = (param_5 - 1) + uVar5;

+    uVar22 = uVar11 / uVar5;

+    uVar13 = (ulonglong)uVar11 % (ulonglong)uVar5;

+  }

+  if (uVar19 != 0) {

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

+      uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0x54,uVar13);

+      if (uVar19 < *(uint *)(param_1 + 0x4e)) {

+        *(uint *)(param_1 + 0x4e) = uVar19;

+      }

+      if (*(uint *)((longlong)param_1 + 0x274) < uVar19) {

+        *(uint *)((longlong)param_1 + 0x274) = uVar19;

+      }

+      puVar17 = param_1 + 0x54;

+    }

+    else {

+      uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0x55,uVar13);

+      if (uVar19 < *(uint *)(param_1 + 0x4f)) {

+        *(uint *)(param_1 + 0x4f) = uVar19;

+      }

+      if (*(uint *)((longlong)param_1 + 0x27c) < uVar19) {

+        *(uint *)((longlong)param_1 + 0x27c) = uVar19;

+      }

+      puVar17 = param_1 + 0x55;

+    }

+    KeReleaseSpinLock(puVar17,uVar8);

+  }

+  FvePerfUpdateMinMaxTtl((longlong)param_1);

+  if ((param_4 == 0) && (*(uint *)((longlong)param_1 + 0x49c) < param_5)) {

+    uVar22 = uVar22 + 1;

+  }

+  if (uVar22 == 0) {

+    uVar22 = 1;

+  }

+  else if (0x20 < uVar22) {

+    uVar22 = 0x20;

+  }

+  iVar10 = MmAreMdlPagesCached(*(undefined8 *)(param_2 + 8));

+  *(bool *)(plVar12 + 0x22) = iVar10 != 0;

+  while (bVar2 = *(byte *)((longlong)plVar12 + 0x5c), bVar2 < uVar22) {

+    uVar19 = *(uint *)(plVar12 + 0xc);

+    local_58 = plVar12 + (ulonglong)bVar2 * 0x16 + 0x25;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x27] = (longlong)plVar12;

+    pvVar16 = (void *)ExAllocateFromNPagedLookasideList(*(undefined8 *)(param_1[1] + 0x150));

+    if (pvVar16 == (void *)0x0) {

+      uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+        pvVar16 = (void *)param_1[0xe0];

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

+      }

+      KeReleaseSpinLock(param_1 + 0xdb,uVar8);

+    }

+    if (pvVar16 == (void *)0x0) break;

+    uVar5 = *(uint *)(lVar15 + 0x344);

+    lVar23 = IoAllocateIrpEx(0xffffffffffffffff);

+    if (lVar23 == 0) {

+LAB_1:

+      uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+        lVar23 = param_1[0xde];

+        uVar24 = *(int *)((longlong)param_1 + (ulonglong)uVar5 * 4 + 0x5bc) * 0x21;

+        uVar5 = *(uint *)((longlong)param_1 + (ulonglong)uVar5 * 4 + 0x5b0);

+        uVar11 = uVar24;

+        if (uVar24 <= uVar5) {

+          uVar11 = uVar5;

+        }

+        if ((uVar11 < uVar19) && (uVar19 = uVar24, uVar24 <= uVar5)) {

+          uVar19 = uVar5;

+        }

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

+      }

+      KeReleaseSpinLock(param_1 + 0xdb,uVar8);

+      if (lVar23 != 0) goto LAB_2;

+      if (pvVar16 == (void *)param_1[0xe0]) {

+        uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+        KeReleaseSpinLock(param_1 + 0xdb,uVar8);

+      }

+      else {

+LAB_3:

+        ExFreeToNPagedLookasideList(*(undefined8 *)(param_1[1] + 0x150),pvVar16);

+      }

+      break;

+    }

+    if ((param_1[0x23d] != 0) &&

+       ((uVar11 = FveSimulateResourceStress(param_1[1]), (char)uVar11 != '\0' ||

+        (iVar10 = FveIceAllocateIrpExtension(lVar23,0), iVar10 < 0)))) {

+LAB_4:

+      IoFreeIrp(lVar23);

+      lVar23 = 0;

+      goto LAB_1;

+    }

+    lVar14 = IoAllocateMdl(0,uVar19 + 0x1000,0,0,0);

+    *(longlong *)(lVar23 + 8) = lVar14;

+    if (lVar14 == 0) goto LAB_4;

+LAB_2:

+    if (((param_3 != '\0') ||

+        (*(int *)((longlong)param_1 + (ulonglong)*(uint *)(lVar15 + 0x344) * 4 + 0x61c) != 0)) ||

+       ((char)plVar12[0x22] == '\0')) goto LAB_5;

+    iVar10 = MmMdlPageContentsState(*(undefined8 *)(param_2 + 8));

+    if (iVar10 == 0) {

+      uVar5 = *(uint *)((longlong)param_1 + 0x49c);

+      uVar11 = *(uint *)(*(longlong *)(param_2 + 8) + 0x2c);

+      if (((uVar5 & uVar5 - 1) != 0) || (uVar5 == 0)) {

+        if (uVar11 % uVar5 != 0) goto LAB_5;

+        goto LAB_6;

+      }

+      if ((uVar11 & uVar5 - 1) == 0) goto LAB_6;

+LAB_5:

+      uVar13 = AcquireShadowBuffer((longlong)param_1,uVar19,

+                                   (uint *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1a4));

+      plVar12[(ulonglong)bVar2 * 0x16 + 0x31] = uVar13;

+      if (uVar13 == 0) {

+        lVar14 = *(longlong *)(lVar23 + 8);

+        if (lVar23 == param_1[0xde]) {

+          uVar3 = *(undefined2 *)(lVar14 + 8);

+          if ((*(ushort *)(lVar14 + 10) >> 4 & 1) != 0 && (*(ushort *)(lVar14 + 10) >> 5 & 1) != 0)

+          {

+            MmUnmapLockedPages(*(undefined8 *)(lVar14 + 0x18),lVar14);

+          }

+          puVar17 = *(undefined8 **)(lVar23 + 8);

+          *puVar17 = 0;

+          *(undefined4 *)(puVar17 + 1) = 0x30;

+          puVar17[4] = 0;

+          puVar17[5] = 0;

+          *(undefined2 *)(*(longlong *)(lVar23 + 8) + 8) = uVar3;

+          uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+                    /* WARNING: Subroutine does not return */

+            KeBugCheckEx(0x120,0xc,0,0,0);

+          }

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

+          KeReleaseSpinLock(param_1 + 0xdb,uVar8);

         }

         else {

-          FveTestRwStorageRequest(*(longlong *)(lVar2 + 0xc0));

-        }

-        unaff_BPL = unaff_BPL + 1;

-        if (*(byte *)(unaff_RBX + 0x5c) <= unaff_BPL) {

-LAB_1:

-          plVar7 = (longlong *)func_0x00014006b070();

-          return plVar7;

-        }

-        unaff_R15B = KeAcquireSpinLockRaiseToDpc(unaff_RBX + 0x68);

-        if (*(int *)(unaff_RBX + 0x78) == 0) {

-          KeReleaseSpinLock(unaff_RBX + 0x68,unaff_R15B);

-          goto LAB_1;

-        }

-        unaff_RSI = (ulonglong)unaff_BPL * 0xb0 + 0x128 + unaff_RBX;

-        *(byte *)(unaff_RSI + 0x88) =

-             (*(byte *)(unaff_RSI + 0x88) ^ unaff_BPL) & 0x3f ^ *(byte *)(unaff_RSI + 0x88);

-        lVar2 = *(longlong *)(*(longlong *)(unaff_RBX + 0x30) + 8);

-        KeAcquireSpinLockAtDpcLevel(unaff_RSI + 0x98);

-        uVar8 = (ulonglong)*(byte *)((ulonglong)*(byte *)(unaff_RSI + 0xaf) + 0xa0 + unaff_RSI);

-        if (*(char *)(uVar8 * 0x1d + 0x5b2 + lVar2) == '\0') {

+          IoFreeMdl();

+          *(undefined8 *)(lVar23 + 8) = 0;

+          IoFreeIrp(lVar23);

+        }

+        if (pvVar16 != (void *)param_1[0xe0]) goto LAB_3;

+        uVar8 = KeAcquireSpinLockRaiseToDpc(param_1 + 0xdb);

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

+        KeReleaseSpinLock(param_1 + 0xdb,uVar8);

+        break;

+      }

+    }

+    else {

+LAB_6:

+      *(uint *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1a4) = uVar19;

+      plVar12[(ulonglong)bVar2 * 0x16 + 0x31] = 0;

+    }

+    lVar14 = param_1[1];

+    KeAcquireSpinLockRaiseToDpc(plVar12 + (ulonglong)bVar2 * 0x16 + 0x38);

+    bVar18 = *(byte *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1d7);

+    uVar13 = (ulonglong)

+             *(byte *)((longlong)plVar12 + (ulonglong)bVar18 + 0x1c8 + (ulonglong)bVar2 * 0xb0);

+    if (*(char *)(uVar13 * 0x1d + 0x5b1 + lVar14) == '\0') {

                     /* WARNING: Subroutine does not return */

-          KeBugCheckEx(0x120,0xb,unaff_RSI,uVar8,2);

-        }

-        bVar9 = *(byte *)(unaff_RSI + 0xaf) + 1;

-        *(byte *)(unaff_RSI + 0xaf) = bVar9;

-        if (0xe < bVar9) {

-          *(undefined1 *)(unaff_RSI + 0xaf) = 0;

-          bVar9 = 0;

-        }

-        *(undefined1 *)((ulonglong)bVar9 + 0xa0 + unaff_RSI) = 2;

-        KeReleaseSpinLockFromDpcLevel(unaff_RSI + 0x98);

-        func_0x00014006b460();

-        *(byte *)(unaff_RSI + 0x89) = *(byte *)(unaff_RSI + 0x89) | 1;

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

-      } while (((*(byte *)(unaff_RSI + 0x88) & 0x40) == 0) ||

-              (unaff_RDI = *(ulonglong *)(unaff_RSI + 0x60) & 0xfffffffffffffffc, unaff_RDI == 0));

-      param_2 = *(longlong *)(unaff_R13 + 8);

-      in_stack_00000090 = *(undefined2 *)(param_2 + 8);

-    } while ((*(byte *)(param_2 + 10) & 0x20) == 0);

-    uVar8 = *(ulonglong *)(param_2 + 0x18);

-  } while( true );

+      KeBugCheckEx(0x120,0xb,local_58,uVar13,1);

+    }

+    bVar18 = bVar18 + 1;

+    *(byte *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1d7) = bVar18;

+    if (0xe < bVar18) {

+      *(undefined1 *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1d7) = 0;

+      bVar18 = 0;

+    }

+    *(undefined1 *)((longlong)plVar12 + (ulonglong)bVar18 + 0x1c8 + (ulonglong)bVar2 * 0xb0) = 1;

+    KeReleaseSpinLock(plVar12 + (ulonglong)bVar2 * 0x16 + 0x38);

+    *(undefined4 *)(plVar12 + (ulonglong)bVar2 * 0x16 + 0x34) =

+         *(undefined4 *)((longlong)plVar12 + (ulonglong)bVar2 * 0xb0 + 0x1a4);

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x29] = (longlong)pvVar16;

+    lVar6 = param_1[1];

+    uVar19 = *(uint *)((longlong)param_1 + 0x4ac);

+    uVar7 = *param_1;

+    iVar10 = IoSizeofWorkItem();

+    memset(pvVar16,0,(ulonglong)(iVar10 + 0xb8));

+    *(longlong *)((longlong)pvVar16 + 0x28) = lVar6 + 0x1e8;

+    KeInitializeSpinLock((longlong)pvVar16 + 0x38);

+    lVar14 = (longlong)pvVar16 + 0xa8;

+    *(void **)((longlong)pvVar16 + 8) = pvVar16;

+    *(void **)pvVar16 = pvVar16;

+    *(longlong *)((longlong)pvVar16 + 0xb0) = lVar14;

+    *(longlong *)lVar14 = lVar14;

+    *(undefined4 *)((longlong)pvVar16 + 100) = 7;

+    iVar10 = FveWorkerQueueTypeToPriority(7);

+    *(int *)((longlong)pvVar16 + 0x68) = iVar10;

+    *(code **)((longlong)pvVar16 + 0x40) = ControlAddRef;

+    *(code **)((longlong)pvVar16 + 0x48) = ControlDeRef;

+    *(longlong **)((longlong)pvVar16 + 0x50) = plVar12;

+    *(undefined8 *)((longlong)pvVar16 + 0x58) = 0xffffffffffffffff;

+    *(undefined1 *)((longlong)pvVar16 + 0x60) = 0;

+    *(undefined4 *)((longlong)pvVar16 + 0x8c) = 7;

+    *(undefined1 *)((longlong)pvVar16 + 0x90) = 0;

+    if ((uVar19 != 0) && (*(uint *)(lVar6 + 0xf8) <= uVar19)) {

+      uVar19 = 0;

+    }

+    *(uint *)((longlong)pvVar16 + 0xa4) = uVar19;

+    IoInitializeWorkItem(uVar7,(longlong)pvVar16 + 0xb8);

+    *(longlong **)(plVar12[(ulonglong)bVar2 * 0x16 + 0x29] + 0x18) =

+         plVar12 + (ulonglong)bVar2 * 0x16 + 0x25;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2a] = lVar23;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2b] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2c] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2d] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2e] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x2f] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x33] = 0;

+    plVar12[(ulonglong)bVar2 * 0x16 + 0x32] = 0;

+    *(char *)((longlong)plVar12 + 0x5c) = *(char *)((longlong)plVar12 + 0x5c) + '\x01';

+  }

+  bVar2 = *(byte *)((longlong)plVar12 + 0x5c);

+  if (bVar2 == 0) {

+    ReleaseControl((longlong)param_1,plVar12);

+    return (longlong *)0x0;

+  }

+  if ((1 < bVar2) && (param_1[0x23d] == 0)) {

+    uVar13 = (ulonglong)*(uint *)(lVar15 + 0x344);

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

+      if ((*(int *)((longlong)param_1 + uVar13 * 4 + 0x5d4) == 0) ||

+         ((uVar22 <= bVar2 &&

+          (*(uint *)((longlong)param_1 + uVar13 * 4 + 0x5e0) <= *(uint *)(plVar12 + 0xc)))))

+      goto LAB_7;

+    }

+    else if (*(int *)((longlong)param_1 + uVar13 * 4 + 0x5f8) == 0) goto LAB_7;

+    uVar13 = (ulonglong)param_5;

+    if ((local_68 <= param_4) || (uVar13 + param_4 <= local_68)) {

+      lVar15 = param_1[0x75];

+      if (lVar15 != 0) {

+        if (((*(uint *)(param_1 + 99) & 0x40) == 0 && (*(uint *)(param_1 + 99) & 0x17f) != 0) &&

+           ((((param_4 < (ulonglong)*(uint *)(param_1 + 0x80) + param_1[0x7f] &&

+              ((ulonglong)param_1[0x7f] < uVar13 + param_4)) ||

+             ((param_4 < (ulonglong)*(uint *)(param_1 + 0x83) + param_1[0x82] &&

+              ((ulonglong)param_1[0x82] < param_4 + uVar13)))) ||

+            ((param_4 < (ulonglong)*(uint *)(param_1 + 0x86) + param_1[0x85] &&

+             ((ulonglong)param_1[0x85] < param_4 + uVar13)))))) goto LAB_7;

+        if (*(short *)(lVar15 + 10) == 1) {

+          uVar19 = 0;

+        }

+        else {

+          uVar19 = *(uint *)(lVar15 + 0x1c);

+          if (uVar19 == 0) {

+            uVar19 = 1;

+          }

+        }

+        if (((param_4 < (ulonglong)*(uint *)((longlong)param_1 + 0x49c) * (ulonglong)uVar19 +

+                        *(ulonglong *)(lVar15 + 0x38)) &&

+            (*(ulonglong *)(lVar15 + 0x38) < param_4 + uVar13)) ||

+           ((*(short *)(lVar15 + 0xc) == 2 &&

+            (((*(uint *)(lVar15 + 0x18) != 0 &&

+              (param_4 < (ulonglong)*(uint *)(lVar15 + 0x18) + *(ulonglong *)(lVar15 + 0x10))) &&

+             (*(ulonglong *)(lVar15 + 0x10) < param_4 + uVar13)))))) goto LAB_7;

+      }

+      lVar15 = 0x874;

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

+        lVar15 = 0x880;

+      }

+      LOCK();

+      *(int *)(lVar15 + (longlong)param_1) = *(int *)(lVar15 + (longlong)param_1) + 1;

+      UNLOCK();

+      pvVar16 = (void *)ExAllocateFromNPagedLookasideList(*(undefined8 *)(param_1[1] + 0x150));

+      plVar12[0x17] = (longlong)pvVar16;

+      if (pvVar16 == (void *)0x0) {

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

+            ((char)*(undefined4 *)((longlong)WPP_GLOBAL_Control + 0x2c) < '\0')) &&

+           (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_i(WPP_GLOBAL_Control[3],0x3e,&WPP_cba9a8ed819d352f8054346eb611e741_Traceguids,

+                   param_1);

+        }

+      }

+      else {

+        uVar19 = *(uint *)((longlong)param_1 + 0x4ac);

+        uVar7 = *param_1;

+        lVar23 = param_1[1];

+        iVar10 = IoSizeofWorkItem();

+        memset(pvVar16,0,(ulonglong)(iVar10 + 0xb8));

+        *(longlong *)((longlong)pvVar16 + 0x28) = lVar23 + 0x1a0;

+        KeInitializeSpinLock((longlong)pvVar16 + 0x38);

+        lVar15 = (longlong)pvVar16 + 0xa8;

+        *(void **)((longlong)pvVar16 + 8) = pvVar16;

+        *(void **)pvVar16 = pvVar16;

+        *(longlong *)((longlong)pvVar16 + 0xb0) = lVar15;

+        *(longlong *)lVar15 = lVar15;

+        *(undefined4 *)((longlong)pvVar16 + 100) = 7;

+        iVar10 = FveWorkerQueueTypeToPriority(7);

+        *(int *)((longlong)pvVar16 + 0x68) = iVar10;

+        *(code **)((longlong)pvVar16 + 0x40) = ControlAddRef;

+        *(code **)((longlong)pvVar16 + 0x48) = ControlDeRef;

+        *(longlong **)((longlong)pvVar16 + 0x50) = plVar12;

+        *(undefined8 *)((longlong)pvVar16 + 0x58) = 0xffffffffffffffff;

+        *(undefined1 *)((longlong)pvVar16 + 0x60) = 0;

+        *(undefined4 *)((longlong)pvVar16 + 0x8c) = 7;

+        *(undefined1 *)((longlong)pvVar16 + 0x90) = 0;

+        if ((uVar19 != 0) && (*(uint *)(lVar23 + 0xf8) <= uVar19)) {

+          uVar19 = 0;

+        }

+        *(uint *)((longlong)pvVar16 + 0xa4) = uVar19;

+        IoInitializeWorkItem(uVar7,(longlong)pvVar16 + 0xb8);

+        KeInitializeSemaphore(plVar12 + 0x19,0,0x7fffffff);

+      }

+    }

+  }

+LAB_7:

+  *(undefined2 *)(plVar12 + 0x21) = 0;

+  plVar12[0x1d] = -1;

+  plVar12[0x1e] = -1;

+  plVar12[0x1f] = -1;

+  plVar12[0x20] = -1;

+  return plVar12;

 }
```

## `FveFileFillZeros`  (modified)

```diff
--- FveFileFillZeros
+++ FveFileFillZeros
@@ -1,42 +1,68 @@
 

-int FveFileFillZeros(undefined8 param_1,ulonglong param_2,ulonglong param_3)

+ulonglong FveFileFillZeros(undefined8 param_1,ulonglong param_2,ulonglong param_3)

 

 {

-  longlong *in_RAX;

-  int iVar1;

-  int unaff_EBX;

-  longlong unaff_RSI;

-  void *unaff_RDI;

-  char in_stack_00000090;

+  uint uVar1;

+  ulonglong uVar2;

+  void *_Dst;

+  ulonglong uVar3;

+  undefined8 uVar4;

+  uint uVar5;

+  size_t _Size;

+  ulonglong uVar6;

+  ulonglong local_res10;

+  ulonglong local_28 [2];

   

-  if ((char)in_RAX == '\0') {

-    if (*(uint *)((longlong)unaff_RDI + 0x18) <= *(uint *)(in_RAX + 1)) {

-      if ((*in_RAX <= *(longlong *)((longlong)unaff_RDI + 0x20)) &&

-         (*(longlong *)((longlong)unaff_RDI + 0x20) - *in_RAX < 0x100000000)) {

-        *(uint *)((longlong)unaff_RDI + 0x38) = *(uint *)(in_RAX + 1);

-        iVar1 = *(int *)((longlong)unaff_RDI + 0x20) - (int)*in_RAX;

-        *(int *)((longlong)unaff_RDI + 0x10) = iVar1;

-        *(uint *)((longlong)unaff_RDI + 0x14) = iVar1 + *(uint *)((longlong)unaff_RDI + 0x18);

-        goto LAB_0;

+  local_res10 = param_2;

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

+      ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0)) &&

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x1a,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids);

+  }

+  uVar3 = 0;

+  _Size = 0x100000;

+  if (param_3 < 0x100000) {

+    _Size = param_3 & 0xffffffff;

+  }

+  uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+  uVar4 = 0x100;

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

+    uVar4 = 0x108;

+  }

+  _Dst = (void *)ExAllocatePool2(uVar4,_Size,0x30455646);

+  if (_Dst == (void *)0x0) {

+    uVar3 = 0xc000009a;

+  }

+  else {

+    memset(_Dst,0,_Size);

+    local_res10 = 0;

+    local_28[0] = 0;

+    local_28[1] = 0;

+    if (param_3 != 0) {

+      while( true ) {

+        uVar5 = 0x100000;

+        if ((uint)param_3 < 0x100000) {

+          uVar5 = (uint)param_3;

+        }

+        uVar1 = ZwWriteFile(param_1,0,0,0,local_28,_Dst,uVar5,&local_res10,0);

+        uVar3 = (ulonglong)uVar1;

+        if ((int)uVar1 < 0) break;

+        uVar3 = local_28[0] & 0xffffffff;

+        if ((int)local_28[0] < 0) break;

+        uVar6 = (ulonglong)uVar5;

+        uVar2 = RtlLongLongAdd(local_res10,(ulonglong)uVar5,&local_res10);

+        uVar3 = uVar2 & 0xffffffff;

+        if (((int)uVar2 < 0) || (param_3 = param_3 - uVar6, param_3 == 0)) break;

       }

     }

+    ExFreePoolWithTag(_Dst,0x30455646);

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

+       (((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 0x20) != 0 &&

+        (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+      WPP_SF_D(WPP_GLOBAL_Control[3],0x1b,&WPP_6d730e60472e3435a9acb6bfa5905f30_Traceguids,

+               (int)uVar3);

+    }

   }

-  unaff_EBX = -0x3fffffff;

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

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

-     (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(WPP_GLOBAL_Control[3],0x33,&WPP_cbdc3e5efa9e3c1f40ce0b54c00226e6_Traceguids,0xc0000001)

-    ;

-  }

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

-    FveFsReleaseRangeBitMapControl(unaff_RSI,unaff_RDI);

-  }

-LAB_0:

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

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

-     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(WPP_GLOBAL_Control[3],0x34,&WPP_cbdc3e5efa9e3c1f40ce0b54c00226e6_Traceguids,unaff_EBX);

-  }

-  return unaff_EBX;

+  return uVar3;

 }
```

## `FveConvRecoverDataAndWatermark`  (modified)

```diff
--- FveConvRecoverDataAndWatermark
+++ FveConvRecoverDataAndWatermark
@@ -1,33 +1,228 @@
+

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

 

 uint FveConvRecoverDataAndWatermark

                (ulonglong *param_1,longlong param_2,undefined8 param_3,ulonglong *param_4)

 

 {

-  byte bVar1;

-  byte bVar2;

-  byte *in_RAX;

-  uint unaff_EBX;

-  byte unaff_BPL;

-  longlong unaff_RSI;

-  longlong unaff_R12;

-  undefined8 unaff_R13;

-  byte unaff_R15B;

+  uint uVar1;

+  void *pvVar2;

+  longlong lVar3;

+  char cVar4;

+  uint uVar5;

+  uint uVar6;

+  uint uVar7;

+  undefined8 *puVar8;

+  ulonglong uVar9;

+  ulonglong uVar10;

+  ulonglong uVar11;

+  void *_Dst;

+  ulonglong *puVar12;

+  undefined8 uVar13;

+  void *pvVar14;

+  void *_Dst_00;

+  undefined1 auStackY_138 [32];

+  undefined4 local_f8;

+  void *local_f0;

+  uint local_e8 [2];

+  longlong local_e0;

+  ulonglong local_d8 [4];

+  ulonglong *local_b8;

+  undefined8 local_b0;

+  undefined8 uStack_a8;

+  undefined8 local_98 [4];

+  undefined8 *local_78;

+  undefined8 local_70;

+  uint *local_68;

+  undefined8 local_60;

+  ulonglong local_58;

   

-  bVar1 = *in_RAX;

-  bVar2 = (byte)in_RAX;

-  *in_RAX = *in_RAX + bVar2;

-  *in_RAX = *in_RAX + bVar2 + CARRY1(bVar1,bVar2);

-  FvepTestCrashSystemWhileConverting(unaff_RSI,(uint)param_2);

-  if (((WPP_GLOBAL_Control != unaff_R12) &&

-      ((unaff_R15B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0)) &&

-     (unaff_BPL <= *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_qii(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x93,unaff_R13,unaff_RSI);

-  }

-  if (((WPP_GLOBAL_Control != unaff_R12) &&

-      ((unaff_R15B & (byte)*(undefined4 *)(WPP_GLOBAL_Control + 0x2c)) != 0)) &&

-     (4 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0x94,unaff_R13,unaff_EBX);

-  }

-  return unaff_EBX;

+  local_58 = __security_cookie ^ (ulonglong)auStackY_138;

+  local_d8[0] = (ulonglong)(uint)local_d8[0];

+  local_d8[3] = param_3;

+  local_b8 = param_4;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],0x66,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids);

+  }

+  pvVar14 = (void *)0x0;

+  puVar8 = &local_b0;

+  local_d8[2] = 0;

+  local_e0 = 0;

+  local_f0 = (void *)0x0;

+  _Dst_00 = (void *)0x0;

+  local_f8 = (uint)local_f8._2_2_ << 0x10;

+  _Dst = (void *)0x0;

+  local_d8[0] = 0;

+  local_d8[1] = 0;

+  local_b0 = 0;

+  uStack_a8 = 0;

+  if (param_2 != 0) {

+    puVar8 = (undefined8 *)(param_2 + 0x50);

+  }

+  local_b0 = *puVar8;

+  uStack_a8 = puVar8[1];

+  puVar12 = local_d8 + 2;

+  uVar5 = FveConvLoadConvLog((longlong)param_1,param_2,&local_e0,puVar12,&local_f0);

+  lVar3 = local_e0;

+  pvVar2 = local_f0;

+  if ((int)uVar5 < 0) {

+    uVar5 = 0xc0210028;

+    _Dst = pvVar14;

+    _Dst_00 = pvVar14;

+  }

+  else if (local_f0 == (void *)0x0) {

+    uVar10 = *(ulonglong *)(local_e0 + 0x2a);

+    _Dst = pvVar14;

+    _Dst_00 = pvVar14;

+LAB_0:

+    *param_4 = uVar10;

+    if (-1 < (int)uVar5) goto LAB_1;

+  }

+  else {

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

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

+       (2 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      puVar12 = param_1;

+      WPP_SF_qii(WPP_GLOBAL_Control[3],0x67,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids,param_1

+                );

+    }

+    uVar10 = (ulonglong)*(uint *)((longlong)pvVar2 + 0x14) * (ulonglong)*(uint *)(lVar3 + 0x22);

+    if (uVar10 < 0x100000000) {

+      if (*(ulonglong *)((longlong)pvVar2 + 0xc) + (uVar10 & 0xffffffff) <

+          *(ulonglong *)((longlong)pvVar2 + 0xc)) {

+        uVar5 = 0xc000000d;

+      }

+      else {

+        uVar9 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline

+                          ();

+        uVar13 = 0x40;

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

+          uVar13 = 0x48;

+        }

+        _Dst_00 = (void *)ExAllocatePool2(uVar13);

+        if (_Dst_00 == (void *)0x0) {

+          uVar5 = 0xc000009a;

+        }

+        else {

+          memset(_Dst_00,0,uVar10 & 0xffffffff);

+          uVar6 = (uint)uVar10;

+          uVar9 = FveRawIoSynchronousSkipBadSector

+                            ((longlong)param_1,param_1[0xd],3,puVar12,

+                             *(uint *)((longlong)param_1 + 0x49c),

+                             *(ulonglong *)((longlong)pvVar2 + 0xc),uVar6,(longlong)_Dst_00);

+          uVar5 = (uint)uVar9;

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

+            uVar9 = (uVar10 & 0xffffffff) / (ulonglong)*(uint *)((longlong)param_1 + 0x49c);

+            local_e8[0] = (uint)uVar9;

+            uVar5 = local_e8[0] + 7;

+            _Dst = (void *)ExAllocatePool2(0x40);

+            local_f0 = _Dst;

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

+              memset(_Dst,0,(ulonglong)(uVar5 >> 3));

+              RtlInitializeBitMap(local_d8,_Dst,uVar9);

+              uVar7 = 0;

+              if (uVar6 != 0) {

+                do {

+                  uVar9 = (ulonglong)*(uint *)(local_e0 + 0x1e);

+                  uVar5 = FveConvLogRecoverBlock

+                                    (local_e0,local_d8[3],*(uint *)(local_e0 + 0x1e),

+                                     (longlong)pvVar2,uVar7 / *(uint *)((longlong)param_1 + 0x49c),

+                                     *(uint *)((longlong)param_1 + 0x49c),

+                                     (ulonglong)uVar7 + (longlong)_Dst_00,(undefined2 *)&local_f8);

+                  uVar1 = local_f8;

+                  _Dst = local_f0;

+                  if ((int)uVar5 < 0) goto LAB_2;

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

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

+                     (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                    WPP_SF_qid(WPP_GLOBAL_Control[3],0x68,uVar9,param_1);

+                  }

+                  if ((uVar1 & 1) == 0) {

+                    if (((((uVar1 & 2) != 0) &&

+                         ((undefined8 **)WPP_GLOBAL_Control != &WPP_GLOBAL_Control)) &&

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

+                       (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+                      WPP_SF_qi(WPP_GLOBAL_Control[3],0x69,WPP_GLOBAL_Control,param_1);

+                    }

+                  }

+                  else {

+                    RtlSetBit(local_d8);

+                  }

+                  uVar5 = *(int *)((longlong)param_1 + 0x49c) + uVar7;

+                  if (uVar5 < uVar7) {

+                    uVar5 = 0xc0000095;

+                    _Dst = local_f0;

+                    goto LAB_2;

+                  }

+                  uVar7 = uVar5;

+                } while (uVar5 < uVar6);

+              }

+              uVar6 = 0;

+              while (uVar7 = RtlFindSetBits(local_d8,1,uVar6), uVar7 != 0xffffffff) {

+                uVar6 = RtlFindClearBits(local_d8,1,uVar7);

+                if ((uVar6 == 0xffffffff) || (uVar6 < uVar7)) {

+                  uVar6 = local_e8[0];

+                }

+                uVar5 = *(uint *)((longlong)param_1 + 0x49c);

+                local_f8 = uVar6 - uVar7;

+                uVar9 = FveRawIoSynchronousSkipBadSector

+                                  ((longlong)param_1,param_1[0xd],4,(ulonglong)(local_f8 * uVar5),

+                                   uVar5,(ulonglong)(uVar5 * uVar7) +

+                                         *(longlong *)((longlong)pvVar2 + 0xc),local_f8 * uVar5,

+                                   (ulonglong)(uVar5 * uVar7) + (longlong)_Dst_00);

+                uVar5 = (uint)uVar9;

+                _Dst = local_f0;

+                if ((int)uVar5 < 0) goto LAB_2;

+                RtlClearBits(local_d8,uVar7,local_f8);

+              }

+              FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,2,(byte *)0x0,0,0,0);

+              uVar9 = *(ulonglong *)((longlong)pvVar2 + 0xc);

+              uVar11 = (uVar10 & 0xffffffff) + uVar9;

+              uVar10 = 0xffffffffffffffff;

+              if (uVar11 >= uVar9) {

+                uVar10 = uVar11;

+              }

+              uVar5 = -(uint)(uVar11 < uVar9) & 0xc0000095;

+              _Dst = local_f0;

+              param_4 = local_b8;

+              goto LAB_0;

+            }

+            uVar5 = 0xc000009a;

+          }

+        }

+      }

+    }

+    else {

+      uVar5 = 0xc0000095;

+    }

+  }

+LAB_2:

+  uVar13 = 4;

+  if ((4 < DAT_3) && (cVar4 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar4 != '\0')) {

+    local_78 = &local_b0;

+    local_68 = local_e8;

+    local_70 = 0x10;

+    local_e8[0] = uVar5;

+    local_60 = uVar13;

+    _tlgWriteTransfer_EtwWriteTransfer(0x14003b040,&DAT_4,0,0,(int)uVar13,local_98);

+  }

+LAB_1:

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

+    ExFreePoolWithTag(_Dst,0x76455646);

+  }

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

+    ExFreePoolWithTag(_Dst_00,0x76455646);

+  }

+  if (local_d8[2] != 0) {

+    ExFreePoolWithTag(local_d8[2],0x76455646);

+  }

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x6a,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids,uVar5);

+  }

+  return uVar5;

 }
```

## `FvePrepareForFveInfoCopyUpdate`  (modified)

```diff
--- FvePrepareForFveInfoCopyUpdate
+++ FvePrepareForFveInfoCopyUpdate
@@ -1,20 +1,59 @@
 

 undefined4 FvePrepareForFveInfoCopyUpdate(longlong param_1,int param_2,byte param_3)

 

 {

-  byte *pbVar1;

-  char cVar2;

-  longlong in_RAX;

-  ulonglong *unaff_RSI;

-  undefined4 unaff_EDI;

+  ulonglong uVar1;

+  longlong lVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  undefined4 uVar5;

   

-  *(char *)param_1 = *(char *)param_1 + (char)((ulonglong)in_RAX >> 8);

-  cVar2 = *(char *)param_1;

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

-  *pbVar1 = *pbVar1 >> 6 | *pbVar1 << 2;

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

-    FveDatumFree(unaff_RSI);

+  uVar5 = 0;

+  lVar2 = 0;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x146,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+             (uint)param_3);

   }

-  return unaff_EDI;

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

+  if (param_3 != 0) {

+    uVar1 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar4 = 0x40;

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

+      uVar4 = 0x48;

+    }

+    lVar2 = ExAllocatePool2(uVar4,param_2,0x30455646);

+    if (lVar2 == 0) {

+      uVar5 = 0xc000009a;

+      goto LAB_0;

+    }

+  }

+  lVar3 = *(longlong *)(param_1 + 2000);

+  if ((lVar3 == 0) || (*(int *)(param_1 + 0x7cc) != param_2)) {

+    uVar1 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar4 = 0x108;

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

+      uVar4 = 0x100;

+    }

+    lVar3 = ExAllocatePool2(uVar4,param_2,0x30455646);

+    if (lVar3 == 0) {

+      uVar5 = 0xc000009a;

+      if (lVar2 != 0) {

+        ExFreePoolWithTag(lVar2,0x30455646);

+      }

+      goto LAB_0;

+    }

+  }

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

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

+  *(int *)(param_1 + 0x7e8) = param_2;

+LAB_0:

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x147,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,uVar5);

+  }

+  return uVar5;

 }
```

## `FveBufferProvisionEx`  (modified)

```diff
--- FveBufferProvisionEx
+++ FveBufferProvisionEx
@@ -1,230 +1,62 @@
 

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

-

-ulonglong FveBufferProvisionEx(uint param_1,undefined8 param_2,undefined8 *param_3)

+undefined8 FveBufferProvisionEx(uint param_1,undefined8 param_2,undefined8 *param_3)

 

 {

   uint uVar1;

-  undefined8 uVar2;

-  undefined8 uVar3;

+  undefined1 *puVar2;

+  ulonglong uVar3;

+  void *_Dst;

   undefined8 uVar4;

-  char cVar5;

-  uint uVar6;

-  undefined8 in_RAX;

-  ulonglong uVar7;

-  void *_Dst;

-  wchar_t *pwVar8;

-  undefined *puVar9;

-  longlong unaff_RBX;

-  undefined8 *unaff_RBP;

-  ushort *unaff_RSI;

-  uint unaff_EDI;

-  longlong in_R9;

-  undefined8 in_R10;

-  wchar_t *pwVar10;

-  undefined4 unaff_R12D;

-  void *unaff_R13;

-  ushort *unaff_R14;

-  void *unaff_R15;

+  ulonglong uVar5;

+  undefined8 uVar6;

+  undefined1 *puVar7;

   

-  unaff_RBP[0x2a] = in_RAX;

-  unaff_RBP[0x2c] = unaff_RBX + 100;

-  unaff_RBP[0x25] = 2;

-  unaff_RBP[0x2e] = unaff_RBP[-1] + 8;

-  *(uint *)(unaff_RBP + 0x2f) = (uint)(ushort)param_2;

-  unaff_RBP[0x27] = 2;

-  unaff_RBP[0x30] = unaff_RBP[-8] + 8;

-  *(uint *)(unaff_RBP + 0x31) = param_1 & 0xffff;

-  unaff_RBP[0x29] = 2;

-  unaff_RBP[0x2b] = 4;

-  unaff_RBP[0x2d] = 4;

-  *(undefined4 *)((longlong)unaff_RBP + 0x17c) = unaff_R12D;

-  *(undefined4 *)((longlong)unaff_RBP + 0x18c) = unaff_R12D;

-  if (unaff_R14 == (ushort *)0x0) {

-LAB_0:

-    if (unaff_RSI == (ushort *)0x0) {

-      puVar9 = (undefined *)unaff_RBP[-7];

+  uVar6 = 0;

+  uVar5 = (ulonglong)param_1;

+  if ((param_1 == 0) || ((*(uint *)((longlong)param_3 + 0x14) & 1) == 0)) {

+    uVar6 = 0xc000000d;

+  }

+  else if (*(uint *)(param_3 + 1) < param_1) {

+    uVar3 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

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

+      uVar4 = 0x102;

+      if (*(int *)(param_3 + 2) != 1) {

+        uVar4 = 0x42;

+      }

     }

     else {

-      uVar7 = FveDatumUnicodeGetLength(unaff_RSI);

-      uVar1 = ((uint)uVar7 & 0xffff) * 2;

-      uVar6 = uVar1 + 2;

-      if (uVar6 < uVar1) {

-        uVar7 = 0xc0000095;

-        goto LAB_1;

-      }

-      _Dst = (void *)ExAllocatePool2(in_R10);

-      unaff_RBP[-0xd] = _Dst;

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

-        in_R9 = unaff_RBP[-0xf];

-        uVar7 = 0xc0000017;

-        unaff_R12D = 0;

-        unaff_R15 = (void *)0x0;

-        goto LAB_2;

-      }

-      memset(_Dst,0,(ulonglong)uVar6);

-      unaff_R15 = (void *)unaff_RBP[-0xd];

-      memmove(unaff_R15,unaff_RSI + 4,(ulonglong)uVar1);

-      uVar7 = (ulonglong)unaff_EDI;

-      unaff_EDI = unaff_EDI + 1;

-      *(uint *)(unaff_RBP + uVar7 * 2 + 7) = uVar6;

-      unaff_R12D = 0;

-      unaff_RBP[uVar7 * 2 + 6] = unaff_R15;

-      *(undefined4 *)((longlong)unaff_RBP + uVar7 * 0x10 + 0x3c) = 0;

-      if (unaff_R14 == (ushort *)0x0) {

-        puVar9 = &FVE_KEYRING_MISMATCHED_BINDING_OBSERVED_LABEL;

-      }

-      else {

-        puVar9 = &FVE_KEYRING_MISMATCHED_BINDING_EXPECTED_OBSERVED_LABELS;

+      uVar4 = 0x10a;

+      if (*(int *)(param_3 + 2) != 1) {

+        uVar4 = 0x4a;

       }

     }

-    unaff_RBP[(ulonglong)unaff_EDI * 2 + 6] = unaff_RBP + -0x10;

-    unaff_RBP[(ulonglong)unaff_EDI * 2 + 7] = 2;

-    uVar6 = unaff_EDI + 1;

-    if (unaff_EDI <= uVar6) {

-      uVar7 = (ulonglong)uVar6;

-      unaff_RBP[uVar7 * 2 + 6] = unaff_RBP[-0xf] + 8;

-      *(uint *)(unaff_RBP + uVar7 * 2 + 7) = (uint)*(ushort *)(unaff_RBP + -0x10);

-      *(undefined4 *)((longlong)unaff_RBP + uVar7 * 0x10 + 0x3c) = unaff_R12D;

-      if (uVar6 <= unaff_EDI + 2) {

-        uVar6 = EtwWrite(*(undefined8 *)(unaff_RBP[-2] + 0x58),puVar9,0,unaff_EDI + 2,unaff_RBP + 6)

-        ;

-        uVar7 = (ulonglong)uVar6;

-        goto LAB_3;

+    _Dst = (void *)ExAllocatePool2(uVar4,uVar5,*(undefined4 *)((longlong)param_3 + 0xc));

+    if (_Dst == (void *)0x0) {

+      uVar6 = 0xc000009a;

+    }

+    else {

+      uVar1 = *(uint *)((longlong)param_3 + 0x14);

+      puVar2 = (undefined1 *)*param_3;

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

+        memset(_Dst,0,uVar5);

       }

-    }

-    uVar7 = 0xc0000095;

-  }

-  else {

-    uVar7 = FveDatumUnicodeGetLength(unaff_R14);

-    uVar1 = ((uint)uVar7 & 0xffff) * 2;

-    uVar6 = uVar1 + 2;

-    if (uVar6 < uVar1) {

-      uVar7 = 0xc0000095;

-      goto LAB_2;

-    }

-    unaff_R13 = (void *)ExAllocatePool2(in_R10);

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

-      memset(unaff_R13,0,(ulonglong)uVar6);

-      memmove(unaff_R13,unaff_R14 + 4,(ulonglong)uVar1);

-      unaff_EDI = 0x17;

-      *(uint *)(unaff_RBP + 0x33) = uVar6;

-      unaff_R15 = (void *)unaff_RBP[-0xd];

-      unaff_RBP[0x32] = unaff_R13;

-      *(undefined4 *)((longlong)unaff_RBP + 0x19c) = unaff_R12D;

-      in_R10 = 0x40;

-      unaff_RBP[-7] = &FVE_KEYRING_MISMATCHED_BINDING_EXPECTED_LABEL;

-      goto LAB_0;

-    }

-    uVar7 = 0xc0000017;

-LAB_1:

-    unaff_R15 = (void *)unaff_RBP[-0xd];

-  }

-LAB_3:

-  in_R9 = unaff_RBP[-0xf];

-LAB_2:

-  uVar6 = DAT_4;

-  pwVar10 = L"";

-  if (unaff_RBX != 0) {

-    uVar2 = *(undefined8 *)(unaff_RBX + 0x16);

-    uVar3 = *(undefined8 *)(unaff_RBX + 0x1e);

-    uVar4 = *(undefined8 *)(unaff_RBX + 0x26);

-    unaff_RBP[2] = *(undefined8 *)(unaff_RBX + 0xe);

-    unaff_RBP[3] = uVar2;

-    unaff_RBP[4] = uVar3;

-    unaff_RBP[5] = uVar4;

-    if ((4 < uVar6) && (cVar5 = _tlgKeywordOn(0x14003b040,0x400000000000), cVar5 != '\0')) {

-      *(undefined2 *)(unaff_RBP + -0xc) = *(undefined2 *)(unaff_RBX + 8);

-      unaff_RBP[0x40] = unaff_RBP + -0xc;

-      *(undefined4 *)(unaff_RBP + -4) = *(undefined4 *)(unaff_RBX + 10);

-      unaff_RBP[0x42] = unaff_RBP + -4;

-      unaff_RBP[0x44] = unaff_RBP + 2;

-      unaff_RBP[0x46] = unaff_RBP + 4;

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

-      unaff_RBP[0x48] = (longlong)unaff_RBP + -0x1c;

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

-      unaff_RBP[0x4a] = unaff_RBP;

-      unaff_RBP[1] = *(undefined8 *)(unaff_RBX + 0x3a);

-      unaff_RBP[0x4c] = unaff_RBP + 1;

-      *(undefined4 *)(unaff_RBP + -3) = *(undefined4 *)(unaff_RBX + 0x42);

-      unaff_RBP[0x4e] = unaff_RBP + -3;

-      *(undefined4 *)(unaff_RBP + -2) = *(undefined4 *)(unaff_RBX + 0x46);

-      unaff_RBP[0x50] = unaff_RBP + -2;

-      *(undefined4 *)(unaff_RBP + -7) = *(undefined4 *)(unaff_RBX + 0x4a);

-      unaff_RBP[0x52] = unaff_RBP + -7;

-      *(undefined4 *)(unaff_RBP + -6) = *(undefined4 *)(unaff_RBX + 0x4e);

-      unaff_RBP[0x54] = unaff_RBP + -6;

-      *(undefined4 *)(unaff_RBP + -5) = *(undefined4 *)(unaff_RBX + 0x52);

-      unaff_RBP[0x56] = unaff_RBP + -5;

-      *(undefined2 *)((longlong)unaff_RBP + -0x5c) = *(undefined2 *)(unaff_RBX + 0x56);

-      unaff_RBP[0x58] = (longlong)unaff_RBP + -0x5c;

-      *(undefined2 *)(unaff_RBP + -0xb) = *(undefined2 *)(unaff_RBX + 0x58);

-      unaff_RBP[0x5a] = unaff_RBP + -0xb;

-      *(undefined2 *)((longlong)unaff_RBP + -0x54) = *(undefined2 *)(unaff_RBX + 0x5a);

-      unaff_RBP[0x5c] = (longlong)unaff_RBP + -0x54;

-      *(undefined2 *)(unaff_RBP + -10) = *(undefined2 *)(unaff_RBX + 0x5c);

-      unaff_RBP[0x5e] = unaff_RBP + -10;

-      *(undefined2 *)((longlong)unaff_RBP + -0x4c) = *(undefined2 *)(unaff_RBX + 0x5e);

-      unaff_RBP[0x60] = (longlong)unaff_RBP + -0x4c;

-      unaff_RBP[0x41] = 2;

-      unaff_RBP[0x43] = 4;

-      unaff_RBP[0x45] = 0x10;

-      unaff_RBP[0x47] = 0x10;

-      unaff_RBP[0x49] = 4;

-      unaff_RBP[0x4b] = 8;

-      unaff_RBP[0x4d] = 8;

-      unaff_RBP[0x4f] = 4;

-      unaff_RBP[0x51] = 4;

-      unaff_RBP[0x53] = 4;

-      unaff_RBP[0x55] = 4;

-      unaff_RBP[0x57] = 4;

-      unaff_RBP[0x59] = 2;

-      unaff_RBP[0x5b] = 2;

-      unaff_RBP[0x5d] = 2;

-      unaff_RBP[0x5f] = 2;

-      unaff_RBP[0x61] = 2;

-      *(undefined4 *)(unaff_RBP + -0xd) = *(undefined4 *)(unaff_RBX + 0x60);

-      unaff_RBP[0x62] = unaff_RBP + -0xd;

-      *(undefined4 *)(unaff_RBP + -0xf) = *(undefined4 *)(unaff_RBX + 100);

-      unaff_RBP[100] = unaff_RBP + -0xf;

-      unaff_RBP[0x66] = unaff_RBP + 0x69;

-      unaff_RBP[99] = 4;

-      unaff_RBP[0x68] = unaff_RBP[-1] + 8;

-      *(uint *)(unaff_RBP + 0x69) = (uint)*(ushort *)(unaff_RBP + -0xe);

-      unaff_RBP[0x6a] = unaff_RBP + 0x6d;

-      unaff_RBP[0x65] = 4;

-      unaff_RBP[0x6c] = unaff_RBP[-8] + 8;

-      *(uint *)(unaff_RBP + 0x6d) = (uint)*(ushort *)((longlong)unaff_RBP + -0x6c);

-      unaff_RBP[0x67] = 2;

-      *(undefined4 *)((longlong)unaff_RBP + 0x34c) = unaff_R12D;

-      unaff_RBP[0x6b] = 2;

-      *(undefined4 *)((longlong)unaff_RBP + 0x36c) = unaff_R12D;

-      pwVar8 = (wchar_t *)(unaff_R14 + 4);

-      if (unaff_R14 == (ushort *)0x0) {

-        pwVar8 = pwVar10;

+      if (puVar2 != (undefined1 *)0x0) {

+        if ((uVar1 & 4) != 0) {

+          puVar7 = puVar2;

+          for (uVar5 = (ulonglong)*(uint *)(param_3 + 1); uVar5 != 0; uVar5 = uVar5 - 1) {

+            *puVar7 = 0;

+            puVar7 = puVar7 + 1;

+          }

+        }

+        ExFreePoolWithTag(puVar2,*(undefined4 *)((longlong)param_3 + 0xc));

       }

-      _tlgCreate1Sz_wchar_t(unaff_RBP + 0x6e,pwVar8);

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

-        pwVar10 = (wchar_t *)(unaff_RSI + 4);

-      }

-      _tlgCreate1Sz_wchar_t(unaff_RBP + 0x70,pwVar10);

-      unaff_RBP[0x73] = 2;

-      unaff_RBP[0x74] = in_R9 + 8;

-      *(uint *)(unaff_RBP + 0x75) = (uint)*(ushort *)(unaff_RBP + -0x10);

-      unaff_RBP[0x72] = unaff_RBP + 0x75;

-      unaff_RBP[0x76] = unaff_RBP + -8;

-      *(undefined4 *)((longlong)unaff_RBP + 0x3ac) = unaff_R12D;

-      unaff_RBP[-8] = 0x1000000;

-      unaff_RBP[0x77] = 8;

-      _tlgWriteTransfer_EtwWriteTransfer(0x14003b040,&DAT_5,0,0,0x1e,unaff_RBP + 0x3c);

+      *param_3 = _Dst;

+      *(uint *)(param_3 + 1) = param_1;

     }

   }

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

-    ExFreePoolWithTag(unaff_R13,0x30455646);

+  else if ((*(uint *)((longlong)param_3 + 0x14) & 2) != 0) {

+    memset((void *)*param_3,0,uVar5);

   }

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

-    ExFreePoolWithTag(unaff_R15,0x30455646);

-  }

-  return uVar7;

+  return uVar6;

 }
```

## `FvepReadInformationAndValidationFromLogicalCopy`  (modified)

```diff
--- FvepReadInformationAndValidationFromLogicalCopy
+++ FvepReadInformationAndValidationFromLogicalCopy
@@ -1,52 +1,147 @@
-

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

 

 ulonglong FvepReadInformationAndValidationFromLogicalCopy

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

                     undefined8 param_5,undefined8 param_6,undefined8 *param_7,ulonglong *param_8)

 

 {

-  ulonglong in_RAX;

-  undefined8 *puVar1;

-  longlong unaff_RBP;

-  ushort unaff_SI;

-  byte unaff_DIL;

-  undefined4 in_register_00000084;

-  undefined4 in_register_0000008c;

-  ushort unaff_R13W;

-  undefined4 unaff_R14D;

-  undefined4 unaff_R15D;

-  uint uStack0000000000000070;

+  uint uVar1;

+  ulonglong uVar2;

+  byte *pbVar3;

+  undefined8 uVar4;

+  undefined4 uVar5;

+  ulonglong uVar6;

+  ulonglong uVar7;

+  ulonglong uVar8;

+  undefined8 uVar9;

+  ulonglong uVar10;

+  ulonglong uVar11;

+  uint local_res20 [2];

+  byte *local_48;

+  ulonglong local_40;

   

-  *(char *)(in_RAX - 0x73) = *(char *)(in_RAX - 0x73) + (char)param_1;

-  *(ulonglong *)(unaff_RBP + 0xa0) = in_RAX & 0xffffffffffffff68;

-  *(longlong *)(unaff_RBP + 0xb0) = unaff_RBP + -0x7c;

-  *(uint *)(unaff_RBP + -0x80) = (uint)unaff_SI;

-  *(longlong *)(unaff_RBP + 0xc0) = unaff_RBP + -0x80;

-  uStack0000000000000070 = (uint)unaff_R13W;

-  *(uint **)(unaff_RBP + 0xd0) = &stack0x00000070;

-  *(longlong *)(unaff_RBP + 0xe0) = unaff_RBP + -0x60;

-  *(longlong *)(unaff_RBP + 0xf0) = unaff_RBP + -0x50;

-  *(undefined8 *)(unaff_RBP + 0xa8) = 4;

-  *(undefined4 *)(unaff_RBP + -0x7c) = unaff_R14D;

-  *(undefined8 *)(unaff_RBP + 0xb8) = 4;

-  *(undefined8 *)(unaff_RBP + 200) = 4;

-  *(undefined8 *)(unaff_RBP + 0xd8) = 4;

-  *(undefined4 *)(unaff_RBP + -0x60) = unaff_R15D;

-  *(undefined8 *)(unaff_RBP + 0xe8) = 4;

-  *(undefined8 *)(unaff_RBP + -0x50) = 0x1000000;

-  *(undefined8 *)(unaff_RBP + 0xf8) = 8;

-  _tlgWriteTransfer_EtwWriteTransfer

-            ((longlong)param_1,(byte *)param_2,CONCAT44(in_register_00000084,param_3),

-             CONCAT44(in_register_0000008c,param_4),0xc,(undefined8 *)(unaff_RBP + 0x40));

-  puVar1 = &WPP_GLOBAL_Control;

+  uVar11 = (ulonglong)param_3;

+  local_res20[0] = param_4;

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

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

      (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    puVar1 = (undefined8 *)

-             WPP_SF_Ld(WPP_GLOBAL_Control[3],0xf9,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                       (uint)unaff_DIL);

+    WPP_SF_(WPP_GLOBAL_Control[3],0x31,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

   }

-  return CONCAT71((int7)((ulonglong)puVar1 >> 8),unaff_DIL);

+  uVar6 = 0;

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

+  local_48 = (byte *)0x0;

+  local_40 = 0;

+  *param_7 = 0;

+  *param_8 = 0;

+  if ((uVar1 < 2) || (uVar1 <= param_4)) {

+    uVar7 = 0xc000000d;

+    uVar6 = 0x97e;

+    uVar2 = 0x97e;

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

+       ((uVar2 = uVar6, (*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 4) != 0 &&

+        (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))))) {

+      WPP_SF_LLL(WPP_GLOBAL_Control[3],0x32,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,param_4

+                );

+    }

+  }

+  else {

+    uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+    uVar5 = 0x40;

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

+      uVar5 = 0x48;

+    }

+    pbVar3 = (byte *)ExAllocatePool2(uVar5,uVar11,0x30455646);

+    if (pbVar3 == (byte *)0x0) {

+      uVar7 = 0xc000009a;

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

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

+         (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+        WPP_SF_D(WPP_GLOBAL_Control[3],0x33,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

+                 0xc000009a);

+      }

+      uVar2 = 0x994;

+    }

+    else {

+      uVar10 = 2;

+      uVar4 = 3;

+      uVar2 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,2,(byte *)local_res20,param_2,

+                                  param_3,(longlong)pbVar3);

+      uVar7 = uVar2 & 0xffffffff;

+      if ((int)uVar2 < 0) {

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

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

+           (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          WPP_SF_DiDd(WPP_GLOBAL_Control[3],0x34,uVar4,param_4);

+        }

+        uVar2 = 0x9a9;

+LAB_0:

+        ExFreePoolWithTag(pbVar3,0x30455646);

+      }

+      else {

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

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

+           (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+          uVar10 = (ulonglong)param_4;

+          WPP_SF_DiD(WPP_GLOBAL_Control[3],0x36,uVar4,param_4);

+        }

+        uVar8 = (ulonglong)*(uint *)((longlong)param_1 + 0x49c);

+        uVar4 = FveInformationAndValidationFromBuffer

+                          (pbVar3,uVar11,uVar8,uVar10,&local_48,&local_40);

+        if ((int)uVar4 < 0) {

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

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

+             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_DiDd(WPP_GLOBAL_Control[3],0x37,uVar8,param_4);

+          }

+          uVar9 = CONCAT71((int7)(uVar8 >> 8),1);

+          uVar4 = FveInformationIsValid((longlong)pbVar3,uVar11,'\x01');

+          if ((int)uVar4 < 0) {

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

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

+               (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+              WPP_SF_DiDd(WPP_GLOBAL_Control[3],0x38,uVar9,param_4);

+            }

+            uVar7 = 0xc0210002;

+            uVar2 = 0x9ef;

+            goto LAB_0;

+          }

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

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_DiD(WPP_GLOBAL_Control[3],0x39,uVar9,param_4);

+          }

+          uVar2 = 0x9fe;

+          uVar7 = 0x80210001;

+        }

+        else {

+          uVar2 = uVar6;

+          pbVar3 = local_48;

+          uVar7 = uVar6;

+          uVar6 = local_40;

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

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

+             (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+            WPP_SF_DiD(WPP_GLOBAL_Control[3],0x3a,uVar8,param_4);

+            pbVar3 = local_48;

+            uVar6 = local_40;

+          }

+        }

+        *param_7 = pbVar3;

+        *param_8 = uVar6;

+        if (-1 < (int)uVar7) goto LAB_1;

+      }

+    }

+  }

+  FveLogEventWithMetadataInfo

+            (*param_1,(ushort *)&FVE_METADATA_LOGICAL_COPY_READ_FAIL,(int)uVar7,param_2,uVar11,

+             (ulonglong)(param_4 + 1),(ulonglong)*(uint *)(param_1 + 0x9d),param_1[0x9b],uVar2,

+             '\x01','\0');

+LAB_1:

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x3b,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,(int)uVar7)

+    ;

+  }

+  return uVar7;

 }
```

## `FveConvLoadConvLog`  (modified)

```diff
--- FveConvLoadConvLog
+++ FveConvLoadConvLog
@@ -1,11 +1,123 @@
-

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

 

 uint FveConvLoadConvLog(longlong param_1,longlong param_2,undefined8 *param_3,undefined8 *param_4,

                        undefined8 *param_5)

 

 {

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

-  halt_baddata();

+  uint uVar1;

+  bool bVar2;

+  uint uVar3;

+  ulonglong uVar4;

+  byte *_Dst;

+  ulonglong uVar5;

+  undefined8 uVar6;

+  uint uVar7;

+  ulonglong uVar8;

+  byte *pbVar9;

+  ulonglong uVar10;

+  byte *pbVar11;

+  uint local_48 [2];

+  byte *local_40;

+  

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],99,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids);

+  }

+  uVar5 = *(ulonglong *)(param_2 + 0x10);

+  local_40 = (byte *)0x0;

+  uVar7 = *(uint *)(param_2 + 0x18);

+  uVar8 = (ulonglong)uVar7;

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

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

+     (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_qiD(WPP_GLOBAL_Control[3],100,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids,param_1);

+  }

+  if ((param_4 == (undefined8 *)0x0) || (uVar7 < 0x32)) {

+    uVar3 = 0xc000000d;

+    goto LAB_0;

+  }

+  uVar10 = *(ulonglong *)(param_1 + 0x3f0);

+  uVar3 = FveConvLogVerifyConvOffsets(uVar5,uVar8,*(uint *)(param_1 + 0x49c),uVar10);

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

+  uVar4 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+  uVar6 = 0x40;

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

+    uVar6 = 0x48;

+  }

+  _Dst = (byte *)ExAllocatePool2(uVar6,uVar8,0x76455646);

+  if (_Dst == (byte *)0x0) {

+    uVar3 = 0xc000009a;

+    goto LAB_0;

+  }

+  memset(_Dst,0,uVar8);

+  uVar5 = FveRawIoSynchronousSkipBadSector

+                    (param_1,*(longlong *)(param_1 + 0x68),3,uVar10,*(uint *)(param_1 + 0x49c),uVar5

+                     ,uVar7,(longlong)_Dst);

+  uVar3 = (uint)uVar5;

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

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

+    uVar6 = FveConvLogVerifyLogHeader((longlong *)_Dst,uVar7,uVar1);

+    uVar3 = (uint)uVar6;

+    pbVar9 = _Dst;

+    if ((int)uVar3 < 0) {

+      pbVar9 = _Dst + (uVar8 - uVar1);

+      uVar6 = FveConvLogVerifyLogHeader((longlong *)pbVar9,uVar7,uVar1);

+      uVar3 = (uint)uVar6;

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

+    }

+    if (*(short *)(pbVar9 + 0xc) == 3) {

+LAB_2:

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

+        *param_3 = pbVar9;

+      }

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

+        *param_5 = local_40;

+      }

+      *param_4 = _Dst;

+      goto LAB_0;

+    }

+    if (*(short *)(pbVar9 + 0xc) == 2) {

+      uVar5 = 0;

+      local_48[0] = uVar1;

+      local_48[1] = *(int *)(pbVar9 + 0x1e) + uVar1;

+      if (*(int *)(pbVar9 + 0x26) != 0) {

+        bVar2 = false;

+        uVar8 = 0;

+        do {

+          pbVar11 = _Dst + local_48[uVar5];

+          uVar3 = FveConvLogVerifyRecord(pbVar9,*(uint *)(pbVar9 + 0x1e),pbVar11);

+          if ((int)uVar3 < 0) {

+            uVar3 = 0;

+            uVar4 = uVar8;

+          }

+          else {

+            uVar10 = *(ulonglong *)(pbVar11 + 4);

+            bVar2 = true;

+            uVar4 = uVar10;

+            if (uVar10 < uVar8) {

+              uVar4 = uVar8;

+            }

+            if (uVar4 == uVar10) {

+              local_40 = pbVar11;

+            }

+          }

+          uVar7 = (int)uVar5 + 1;

+          uVar5 = (ulonglong)uVar7;

+          uVar8 = uVar4;

+        } while (uVar7 < *(uint *)(pbVar9 + 0x26));

+        if (bVar2) goto LAB_2;

+      }

+    }

+    uVar3 = 0xc000000d;

+  }

+LAB_1:

+  ExFreePoolWithTag(_Dst,0x76455646);

+LAB_0:

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],0x65,&WPP_7d60d18d6f8936f72c7f3f2fe194948f_Traceguids,uVar3);

+  }

+  return uVar3;

 }
```

## `FvepWriteBootSectorsLegacy`  (modified)

```diff
--- FvepWriteBootSectorsLegacy
+++ FvepWriteBootSectorsLegacy
@@ -1,198 +1,106 @@
-

-/* WARNING: Instruction at (ram,0x000140053b1a) overlaps instruction at (ram,0x000140053b18)

-    */

 

 ulonglong FvepWriteBootSectorsLegacy(longlong *param_1,ulonglong param_2,uint param_3,int param_4)

 

 {

-  longlong lVar1;

-  longlong *plVar2;

-  ulonglong uVar3;

-  ulonglong uVar4;

-  ulonglong uVar5;

-  uint unaff_EBX;

-  ulonglong unaff_RBP;

-  uint unaff_ESI;

-  ulonglong unaff_RDI;

+  int iVar1;

+  ulonglong uVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  char *pcVar5;

   ulonglong uVar6;

-  undefined8 uVar7;

-  undefined4 in_register_00000084;

-  ulonglong in_R10;

-  char unaff_R12B;

-  uint *unaff_R13;

-  uint *puVar8;

-  ulonglong unaff_R14;

-  ulonglong unaff_R15;

-  char in_CF;

-  ulonglong uVar9;

-  char in_stack_00000060;

-  uint in_stack_00000064;

-  longlong in_stack_00000068;

-  ulonglong in_stack_00000070;

-  ulonglong in_stack_00000078;

-  longlong in_stack_00000080;

-  longlong *in_stack_000000d0;

-  uint *in_stack_000000e0;

+  undefined *local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

   

-  uVar7 = CONCAT44(in_register_00000084,param_3);

-code_r0x000140053b18:

-  *(char *)(in_R10 + 0x1a3) = (*(char *)(in_R10 + 0x1a3) - (char)unaff_RDI) - in_CF;

-  WPP_SF_iDDd(param_1,(short)param_2,uVar7,unaff_RBP);

-LAB_0:

-  *(undefined4 *)(*(longlong *)(unaff_R13 + 2) + unaff_RDI * 4) = 0;

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

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

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_(WPP_GLOBAL_Control[3],99,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids);

+  }

+  local_38 = 0;

+  local_48 = (undefined *)0x0;

+  uStack_40 = 0;

+  if (*(short *)(param_1[0x75] + 10) == 1) {

+    uVar6 = *(ulonglong *)(param_1[0x75] + 0x38);

+  }

+  else {

+    uVar6 = 0;

+  }

+  if (2 < param_3) {

+    uVar6 = 0xc000000d;

+    goto LAB_0;

+  }

+  uVar2 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline();

+  uVar4 = 0x48;

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

+    uVar4 = 0x40;

+  }

+  lVar3 = ExAllocatePool2(uVar4,*(undefined4 *)((longlong)param_1 + 0x49c),0x30455646);

+  if (lVar3 == 0) {

+    uVar6 = 0xc000009a;

+    goto LAB_0;

+  }

+  uVar2 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],3,param_4,(byte *)0x0,0,

+                              *(uint *)((longlong)param_1 + 0x49c),lVar3);

+  if ((int)uVar2 < 0) {

+    local_48 = &FVE_METADATA_DISK_FAILED_READBACK_ERROR;

 LAB_1:

-  if (-1 < (int)unaff_ESI) {

-    unaff_ESI = (uint)unaff_R14;

+    local_38 = 0;

+    uVar6 = uVar2 & 0xffffffff;

+    uStack_40 = CONCAT44((int)uVar2,0xffffffff);

+    FveLogEventEx(*param_1,(longlong *)&local_48,'\0','\x01');

   }

+  else {

+    if (param_3 == 0) {

+      pcVar5 = "";

 LAB_2:

-  plVar2 = in_stack_000000d0;

-  unaff_RDI = (ulonglong)((int)unaff_RDI + 1);

-  uVar4 = (ulonglong)unaff_EBX;

-  FveLogEventWithMetadataInfo

-            (*in_stack_000000d0,(ushort *)&FVE_METADATA_LOGICAL_COPY_MATCH_FAIL,(int)unaff_R14,

-             unaff_RBP,uVar4,unaff_RDI,(ulonglong)*(uint *)(in_stack_000000d0 + 0x9d),

-             in_stack_000000d0[0x9b],unaff_R15 & 0xffffffff,'\0','\0');

-  uVar9 = unaff_RDI;

-  do {

-    lVar1 = in_stack_00000068;

-    if (*(uint *)(plVar2 + 0x9d) <= (uint)unaff_RDI) {

-      puVar8 = unaff_R13;

-      if ((in_stack_00000060 != '\0') && (unaff_R12B != '\0')) {

-        *in_stack_000000e0 = *in_stack_000000e0 | 0x10000;

+      FveUpdateBootSector(lVar3,(undefined8 *)pcVar5,uVar6);

+    }

+    else {

+      if (param_3 == 1) {

+        pcVar5 = "NTFS    ";

+        goto LAB_2;

       }

-      do {

-        while( true ) {

-          while( true ) {

-            uVar3 = (ulonglong)in_stack_00000064;

-            unaff_R13 = puVar8 + 6;

-            in_stack_00000080 = in_stack_00000080 + -1;

-            if (in_stack_00000080 == 0) {

-              if (lVar1 != 0) {

-                ExFreePoolWithTag(lVar1,0x30455646);

-              }

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

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

-                 (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-                WPP_SF_D(WPP_GLOBAL_Control[3],0x1a4,

-                         &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,unaff_ESI);

-              }

-              return (ulonglong)unaff_ESI;

-            }

-            unaff_EBX = *unaff_R13;

-            unaff_RBP = *(ulonglong *)(puVar8 + 4);

-            if (unaff_EBX == 0) {

-              unaff_EBX = 0x10000;

-            }

-            else if (((in_stack_00000064 & in_stack_00000064 - 1) == 0) && (in_stack_00000064 != 0))

-            {

-              unaff_EBX = (unaff_EBX - 1) + in_stack_00000064 & ~(in_stack_00000064 - 1);

-            }

-            else if (unaff_EBX % in_stack_00000064 != 0) {

-              unaff_EBX = (unaff_EBX - unaff_EBX % in_stack_00000064) + in_stack_00000064;

-            }

-            uVar5 = (ulonglong)unaff_EBX;

-            uVar6 = uVar5 + unaff_RBP;

-            puVar8 = unaff_R13;

-            if (unaff_RBP <= uVar6) break;

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

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

-               (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-              uVar9 = 0xc0000095;

-              WPP_SF_qiD(WPP_GLOBAL_Control[3],0x19e,

-                         &WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,unaff_RBP);

-              uVar4 = uVar5;

-            }

-            if (-1 < (int)unaff_ESI) {

-              unaff_ESI = 0xc021001f;

-            }

-          }

-          if ((unaff_RBP != 0) && (uVar6 <= in_stack_00000070)) break;

-LAB_3:

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

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

-             (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-            uVar9 = 0;

-            WPP_SF_qiD(WPP_GLOBAL_Control[3],0x19f,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,

-                       unaff_RBP);

-            uVar4 = uVar6;

-          }

-          if (-1 < (int)unaff_ESI) {

-            unaff_ESI = 0xc021001f;

-          }

-        }

-        in_R10 = uVar3 - 1;

-        if (((in_R10 & uVar3) == 0) && (uVar3 != 0)) {

-          uVar5 = unaff_RBP & in_R10;

-        }

-        else {

-          uVar5 = unaff_RBP % uVar3;

-        }

-        if (uVar5 != 0) goto LAB_3;

-        if (((in_R10 & uVar3) == 0) && (uVar3 != 0)) {

-          uVar3 = uVar6 & in_R10;

-        }

-        else {

-          uVar3 = uVar6 % uVar3;

-        }

-        if (uVar3 != 0) goto LAB_3;

-        unaff_R12B = '\0';

-        unaff_RDI = 0;

-        in_stack_00000060 = '\0';

-      } while ((int)plVar2[0x9d] == 0);

+      if (param_3 == 2) {

+        uVar6 = param_2 / *(uint *)(param_1 + 0x94);

+        pcVar5 = "-FVE-FS-";

+        goto LAB_2;

+      }

     }

-    if (lVar1 != 0) {

-      ExFreePoolWithTag(lVar1,0x30455646);

-      in_stack_00000068 = 0;

-      in_stack_00000078 = 0;

-    }

-    uVar3 = FvepReadInformationAndValidationFromLogicalCopy

-                      (plVar2,unaff_RBP,unaff_EBX,(uint)unaff_RDI,uVar4,uVar9,&stack0x00000068,

-                       &stack0x00000078);

-    unaff_R14 = uVar3 & 0xffffffff;

-    if ((int)uVar3 < 0) {

-      uVar7 = 0xc0210002;

-      if ((int)uVar3 != -0x3fdefffe) {

-        unaff_R15 = 0x48c4;

-        if ((((undefined8 **)WPP_GLOBAL_Control == &WPP_GLOBAL_Control) ||

-            ((*(uint *)((longlong)WPP_GLOBAL_Control + 0x2c) & 4) == 0)) ||

-           (*(byte *)((longlong)WPP_GLOBAL_Control + 0x29) < 2)) goto LAB_0;

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

-        param_2 = 0x1a3;

-        in_CF = '\0';

-        goto code_r0x000140053b18;

-      }

-      unaff_R15 = 0x48b5;

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

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

-         (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-        WPP_SF_iDDd(WPP_GLOBAL_Control[3],0x1a2,0xc0210002,unaff_RBP);

-      }

-      unaff_R12B = '\x01';

-      *(undefined4 *)(*(longlong *)(unaff_R13 + 2) + unaff_RDI * 4) = 2;

+    uVar6 = 0;

+    uVar2 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,param_4,(byte *)0x0,0,

+                                *(uint *)((longlong)param_1 + 0x49c),lVar3);

+    if ((int)uVar2 < 0) {

+      local_48 = &FVE_METADATA_FAILED_COMMIT;

       goto LAB_1;

     }

-    uVar6 = (ulonglong)*unaff_R13;

-    uVar3 = RtlCompareMemory(in_stack_00000068);

-    if (uVar3 != *unaff_R13) break;

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

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

-       (3 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-      uVar4 = CONCAT44((int)(uVar4 >> 0x20),unaff_EBX);

-      WPP_SF_iDD(WPP_GLOBAL_Control[3],0x1a0,uVar6,unaff_RBP);

-      uVar9 = unaff_RDI;

+    uVar2 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],9,param_4,(byte *)0x0,0,0,0);

+    iVar1 = (int)uVar2;

+    if (((iVar1 != -0x3ffffffe) && (iVar1 != -0x3ffffff0)) &&

+       ((iVar1 != -0x3fffff45 && (iVar1 < 0)))) {

+      local_48 = &FVE_METADATA_DISK_FAILED_FLUSH_ERROR;

+      uStack_40 = CONCAT44(iVar1,0xffffffff);

+      local_38 = 0;

+      FveLogEventEx(*param_1,(longlong *)&local_48,'\0','\x01');

     }

-    *(undefined4 *)(*(longlong *)(unaff_R13 + 2) + unaff_RDI * 4) = 1;

-    in_stack_00000060 = '\x01';

-    unaff_RDI = (ulonglong)((uint)unaff_RDI + 1);

-  } while( true );

-  unaff_R15 = 0x48a3;

+    uVar2 = FveRawIoSynchronous((longlong)param_1,param_1[0xd],4,param_4,(byte *)0x0,

+                                param_1[0x7e] - (ulonglong)*(uint *)((longlong)param_1 + 0x49c),

+                                *(uint *)((longlong)param_1 + 0x49c),lVar3);

+    if ((int)uVar2 < 0) {

+      local_48 = &FVE_METADATA_PARTIAL_COMMIT;

+      uStack_40 = CONCAT44((int)uVar2,0xffffffff);

+      local_38 = 0;

+      FveLogEventEx(*param_1,(longlong *)&local_48,'\0','\x01');

+      uVar6 = 0x80210001;

+    }

+  }

+  ExFreePoolWithTag(lVar3,0x30455646);

+LAB_0:

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

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

-     (1 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_iDD(WPP_GLOBAL_Control[3],0x1a1,uVar6,unaff_RBP);

+     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+    WPP_SF_D(WPP_GLOBAL_Control[3],100,&WPP_9da3d64de5083b6681d483e337ed2ff7_Traceguids,(int)uVar6);

   }

-  unaff_R12B = '\x01';

-  *(undefined4 *)(*(longlong *)(unaff_R13 + 2) + unaff_RDI * 4) = 2;

-  goto LAB_2;

+  return uVar6;

 }
```

## `FveValidateCryptoThrottleConfig`  (modified)

```diff
--- FveValidateCryptoThrottleConfig
+++ FveValidateCryptoThrottleConfig
@@ -1,94 +1,169 @@
 

-ulonglong FveValidateCryptoThrottleConfig(ulonglong param_1,longlong param_2,int *param_3)

+void FveValidateCryptoThrottleConfig(ulonglong param_1,longlong param_2,int *param_3)

 

 {

-  uint extraout_EAX;

-  char *in_RAX;

-  undefined2 uVar1;

-  longlong unaff_RBX;

-  ulonglong unaff_RSI;

-  int iVar2;

-  int *unaff_RDI;

-  undefined8 unaff_R12;

-  longlong unaff_R15;

-  longlong in_stack_00000040;

-  ushort *in_stack_00000048;

-  longlong lVar3;

+  int *piVar1;

+  bool bVar2;

+  char cVar3;

+  int iVar4;

+  ulonglong uVar5;

+  int *piVar6;

+  longlong lVar7;

+  char *pcVar8;

+  uint uVar9;

+  ulonglong local_res8;

   

-  *unaff_RDI = *unaff_RDI + -1;

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

-  if (*(longlong *)(unaff_RBX + 0xc) == 0x3f05139760008fb0) {

-    iVar2 = GetIceKeyManagementInterface

-                      (*(longlong *)(unaff_RBX + 0x28),&stack0x00000048,&stack0x00000040);

-    lVar3 = CONCAT44((int)((ulonglong)unaff_RDI >> 0x20),iVar2);

-    unaff_RSI = (ulonglong)extraout_EAX;

-    if ((int)extraout_EAX < 0) {

-      if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x40) != 0)

-          ) && (2 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-        uVar1 = 0xf4;

+  local_res8 = param_1 & 0xffffffffffffff00;

+  iVar4 = ZwPowerInformation(0x42,0,0,&local_res8,1);

+  uVar9 = 0;

+  if ((iVar4 < 0) || (bVar2 = true, (char)local_res8 == '\0')) {

+    bVar2 = false;

+  }

+  piVar1 = param_3 + 3;

+  local_res8 = (longlong)param_3 - param_2;

+  pcVar8 = (char *)((longlong)param_3 + 0x36);

+  lVar7 = param_2 - (longlong)param_3;

+  piVar6 = piVar1;

+  do {

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

+        ((char)*(undefined4 *)((longlong)WPP_GLOBAL_Control + 0x2c) < '\0')) &&

+       (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

+      WPP_SF_D(WPP_GLOBAL_Control[3],0x31,&WPP_cba9a8ed819d352f8054346eb611e741_Traceguids,uVar9);

+    }

+    pcVar8[7] = '\0';

+    if (pcVar8[-3] == '\0') {

 LAB_0:

-        WPP_SF_(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),uVar1,unaff_R12);

+      if ((param_2 == 0) || (pcVar8[lVar7 + 0x5a] == '\0')) {

+        if (*(char *)((longlong)param_3 + 0x33) == '\0') {

+          uVar5 = Feature_BitLocker_Old_SoC_Throttle_Removal__private_IsEnabledDeviceUsageNoInline()

+          ;

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

+            *piVar6 = 1;

+          }

+          else {

+            *piVar6 = -1;

+          }

+          goto LAB_1;

+        }

+        iVar4 = *piVar1;

+      }

+      else {

+        iVar4 = *(int *)(lVar7 + -0xc + (longlong)piVar6);

+      }

+      *piVar6 = iVar4;

+    }

+    else if (*piVar6 == 0) {

+      pcVar8[-3] = '\0';

+      goto LAB_0;

+    }

+LAB_1:

+    cVar3 = '\0';

+    if ((pcVar8[7] != '\0') || (*piVar1 != *piVar6)) {

+      cVar3 = '\x01';

+    }

+    pcVar8[7] = cVar3;

+    if (pcVar8[-6] == '\0') {

+LAB_2:

+      if (((param_2 == 0) || (pcVar8[lVar7 + 0x5a] == '\0')) || (pcVar8[lVar7 + 0x6f] == '\0')) {

+        if ((char)param_3[0xc] == '\0') {

+          uVar5 = Feature_BitLocker_Old_SoC_Throttle_Removal__private_IsEnabledDeviceUsageNoInline()

+          ;

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

+            iVar4 = (-(uint)bVar2 & 3) - 1;

+            goto LAB_3;

+          }

+          piVar6[-3] = -1;

+        }

+        else {

+          piVar6[-3] = *param_3;

+        }

+      }

+      else {

+        iVar4 = *(int *)(lVar7 + -0xc + (longlong)piVar6) + 1 +

+                *(int *)(lVar7 + 0x48 + (longlong)piVar6);

+LAB_3:

+        piVar6[-3] = iVar4;

       }

     }

-    else if (in_stack_00000048[1] == 0) {

-      if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x40) != 0)

-          ) && (2 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-        uVar1 = 0xf5;

-        goto LAB_0;

+    else if (piVar6[-3] == 0) {

+      pcVar8[-6] = '\0';

+      goto LAB_2;

+    }

+    cVar3 = '\0';

+    if ((pcVar8[7] != '\0') || (*param_3 != piVar6[-3])) {

+      cVar3 = '\x01';

+    }

+    pcVar8[7] = cVar3;

+    if (*pcVar8 == '\0') {

+LAB_4:

+      if (((param_2 == 0) || (pcVar8[lVar7 + 0x5a] == '\0')) || (pcVar8[lVar7 + 0x6f] == '\0')) {

+        if (*(char *)((longlong)param_3 + 0x36) == '\0') {

+          iVar4 = piVar6[-3];

+        }

+        else {

+          iVar4 = param_3[6];

+        }

+      }

+      else {

+        iVar4 = *(int *)(lVar7 + 0x48 + (longlong)piVar6) + 1 +

+                *(int *)(lVar7 + -0xc + (longlong)piVar6);

+      }

+      *(int *)((longlong)piVar6 + local_res8 + lVar7 + 0xc) = iVar4;

+      if ((iVar4 + 1U & 0xfffffffe) == 0) {

+        Feature_BitLocker_Old_SoC_Throttle_Removal__private_IsEnabledDeviceUsageNoInline();

+        piVar6[3] = -1;

       }

     }

-    else if (*in_stack_00000048 < 0x38) {

-      if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x40) != 0)

-          ) && (2 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-        uVar1 = 0xf6;

-        goto LAB_0;

+    else if ((piVar6[3] + 1U & 0xfffffffe) == 0) {

+      *pcVar8 = '\0';

+      goto LAB_4;

+    }

+    cVar3 = '\0';

+    if ((pcVar8[7] != '\0') || (param_3[6] != piVar6[3])) {

+      cVar3 = '\x01';

+    }

+    pcVar8[7] = cVar3;

+    if (pcVar8[3] == '\0') {

+LAB_5:

+      if ((param_2 == 0) || (pcVar8[lVar7 + 0x5a] == '\0')) {

+        if (pcVar8[-3] == '\0') {

+          if (*(char *)((longlong)param_3 + 0x39) == '\0') {

+            uVar5 = Feature_BitLocker_Old_SoC_Throttle_Removal__private_IsEnabledDeviceUsageNoInline

+                              ();

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

+              piVar6[6] = (-(uint)bVar2 & 2) - 1;

+            }

+            else {

+              piVar6[6] = -1;

+            }

+            goto LAB_6;

+          }

+          iVar4 = param_3[9];

+        }

+        else {

+          iVar4 = *piVar6;

+        }

       }

+      else {

+        iVar4 = *(int *)(lVar7 + -0xc + (longlong)piVar6);

+      }

+      piVar6[6] = iVar4;

     }

-    else {

-      if (((*(longlong *)(in_stack_00000048 + 0x10) != 0) &&

-          (*(longlong *)(in_stack_00000048 + 0x14) != 0)) &&

-         (*(longlong *)(in_stack_00000048 + 0x18) != 0)) {

-        if (*(longlong *)(lVar3 + 0x2770) != 0) {

-          ExFreePoolWithTag(*(longlong *)(lVar3 + 0x2770),0x30455646);

-        }

-        *(ushort **)(lVar3 + 0x2770) = in_stack_00000048;

-        if (*(longlong *)(lVar3 + 0x2780) != 0) {

-          ObfDereferenceObject();

-        }

-        *(longlong *)(lVar3 + 0x2780) = in_stack_00000040;

-        goto LAB_1;

-      }

-      if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x40) != 0)

-          ) && (2 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-        uVar1 = 0xf7;

-        goto LAB_0;

-      }

+    else if (piVar6[6] == 0) {

+      pcVar8[3] = '\0';

+      goto LAB_5;

     }

-    if (in_stack_00000040 != 0) {

-      ObfDereferenceObject();

+LAB_6:

+    if ((pcVar8[7] != '\0') || (cVar3 = '\0', param_3[9] != piVar6[6])) {

+      cVar3 = '\x01';

     }

-  }

-  else if ((*(longlong *)(unaff_RBX + 4) == 0x11d046f0cb3a4005) &&

-          (*(longlong *)(unaff_RBX + 0xc) == 0x3f05139760008fb0)) {

-    if (*(longlong *)(unaff_RDI + 0x9dc) != 0) {

-      ExFreePoolWithTag(*(longlong *)(unaff_RDI + 0x9dc),0x30455646);

-      *(ulonglong *)(unaff_RDI + 0x9dc) = *(ulonglong *)(unaff_RDI + 0x9dc) & unaff_RSI;

+    pcVar8[7] = cVar3;

+    uVar9 = uVar9 + 1;

+    pcVar8 = pcVar8 + 1;

+    piVar6 = piVar6 + 1;

+    if (2 < uVar9) {

+      return;

     }

-  }

-  else {

-    if (WPP_GLOBAL_Control == unaff_R15) goto LAB_2;

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

-       (3 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-      uVar1 = 0xf8;

-      goto LAB_0;

-    }

-  }

-LAB_1:

-  if (((WPP_GLOBAL_Control != unaff_R15) && ((*(uint *)(WPP_GLOBAL_Control + 0x2c) & 0x40) != 0)) &&

-     (4 < *(byte *)(WPP_GLOBAL_Control + 0x29))) {

-    WPP_SF_D(*(undefined8 *)(WPP_GLOBAL_Control + 0x18),0xf9,unaff_R12,(int)unaff_RSI);

-  }

-LAB_2:

-  return unaff_RSI & 0xffffffff;

+  } while( true );

 }
```

## `FveIceHwWrapFvek`  (modified)

```diff
--- FveIceHwWrapFvek
+++ Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline
@@ -1,44 +1,17 @@
 

-uint FveIceHwWrapFvek(longlong *param_1,int param_2,ushort *param_3,undefined8 *param_4)

+ulonglong Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledDeviceUsageNoInline(void)

 

 {

-  int *piVar1;

-  undefined8 uVar2;

-  ulonglong in_RAX;

-  longlong lVar3;

-  uint uVar4;

-  ulonglong uVar5;

-  longlong *unaff_RBX;

-  longlong *unaff_RBP;

-  undefined8 *unaff_RDI;

+  ulonglong uVar1;

+  undefined8 local_res8;

   

-  piVar1 = (int *)((in_RAX | 0x67) - 0x73);

-  *piVar1 = *piVar1 + -1;

-  if (((param_1 != unaff_RBP) && ((*(uint *)((longlong)param_1 + 0x2c) & 0x100) != 0)) &&

-     (4 < *(byte *)((longlong)param_1 + 0x29))) {

-    WPP_SF_(param_1[3],0x3c,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

+  local_res8 = (ulonglong)Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_featureState;

+  if ((Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_featureState & 0x10) == 0) {

+    uVar1 = Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_IsEnabledFallback(local_res8,3);

   }

-  uVar5 = 0;

-  if ((int)unaff_RBX[0x14] != 0) {

-    uVar2 = *unaff_RDI;

-    do {

-      lVar3 = uVar5 * 8;

-      uVar4 = (int)uVar5 + 1;

-      uVar5 = (ulonglong)uVar4;

-      *(undefined8 *)(*(longlong *)(**(longlong **)(unaff_RBX[2] + lVar3) + 0x128) + 200) = uVar2;

-    } while (uVar4 < *(uint *)(unaff_RBX + 0x14));

+  else {

+    uVar1 = (ulonglong)(Feature_SteelixInlineNvmeCryptoEngineForQC8480__private_featureState & 1);

   }

-  uVar2 = *unaff_RDI;

-  lVar3 = *unaff_RBX;

-  *unaff_RDI = 0;

-  *(undefined8 *)(lVar3 + 0x10) = uVar2;

-  lVar3 = *unaff_RBX;

-  *(byte *)(lVar3 + 0x30) = *(byte *)(lVar3 + 0x30) | 4;

-  if (((WPP_GLOBAL_Control != unaff_RBP) &&

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

-     (4 < *(byte *)((longlong)WPP_GLOBAL_Control + 0x29))) {

-    lVar3 = WPP_SF_(WPP_GLOBAL_Control[3],0x3d,&WPP_6be8a2f4833733c2fd8762605e461eaa_Traceguids);

-  }

-  return (uint)lVar3;

+  return uVar1;

 }
```

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

```diff
--- NTOSKRNL.EXE::ExAllocatePool2 calling
+++ NTOSKRNL.EXE::ExAllocatePool2 calling
@@ -1 +1 @@
-AcquireRequestResources
+AcquireShadowBuffer
```
