/* ============================================================
 * DXE Core Firmware Volume - Decompiled from DxeCore.efi
 * Original Sources: MdeModulePkg/Core/Dxe/FwVol/, SectionExtraction/
 * ============================================================ */

#include "../uefi_headers/Uefi.h"



/* ============================================================
 * Function: CoreScheduleFfs
 * Address:  0xc000
 * Source:   Dispatcher.c
 * Desc:     Schedule an FFS driver for dispatch
 * ============================================================ */

unsigned __int64 __fastcall CoreScheduleFfs(void *a1, __int64 a2, double a3, double a4)
{
  __int64 v4; // r8
  __int64 *i; // rdi
  __int64 *i_1; // rbx
  __int64 v9; // rdx
  __int64 v10; // rdx
  __int64 v11; // r8

  for ( i = (__int64 *)n; i != &n; i = (__int64 *)*i )
  {
    i_1 = i - 1;
    if ( *(i - 1) != 1920365156 )
    {
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\Dispatcher\\\\Dispatcher.c",
        330,
        (__int64)"CR has Bad Signature",
        a4);
      i_1 = i;
    }
    if ( (void *)i_1[5] == a1 && *((_BYTE *)i_1 + 117) && Assert_103(a2, (__int64)(i_1 + 6), v4, a4) )
    {
      DxeGetInfo_8((__int64)&unk_26100, v9, v4, a4);
      *((_WORD *)i_1 + 58) = 1;
      DxeGetInfo_10((__int64)&unk_26100, v10, v11, a4);
      DebugPrint(128, "Schedule FFS(%g) - EFI_SUCCESS\
", a3);
      return 0;
    }
  }
  DebugPrint(128, "Schedule FFS(%g) - EFI_NOT_FOUND\
", a3);
  return 0x800000000000000EuLL;
}


/* ============================================================
 * Function: CoreUnscheduleFfs
 * Address:  0xc0ec
 * Source:   Dispatcher.c
 * Desc:     Remove an FFS driver from the scheduled queue
 * ============================================================ */

unsigned __int64 __fastcall CoreUnscheduleFfs(void *a1, __int64 a2, __int64 a3, double a4)
{
  __int64 *i; // rdi
  __int64 *i_1; // rbx
  __int64 v8; // rdx
  __int64 v9; // r8
  __int64 v10; // rdx
  __int64 v11; // r8

  for ( i = (__int64 *)n; i != &n; i = (__int64 *)*i )
  {
    i_1 = i - 1;
    if ( *(i - 1) != 1920365156 )
    {
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\Dispatcher\\\\Dispatcher.c",
        381,
        (__int64)"CR has Bad Signature",
        a4);
      i_1 = i;
    }
    if ( (void *)i_1[5] == a1 && *((_BYTE *)i_1 + 119) && Assert_103(a2, (__int64)(i_1 + 6), a3, a4) )
    {
      DxeGetInfo_8((__int64)&unk_26100, v8, a3, a4);
      *((_WORD *)i_1 + 59) = 1;
      Assert_53(&off_26118, i_1 + 3, v9, a4);
      DxeGetInfo_10((__int64)&unk_26100, v10, v11, a4);
      return 0;
    }
  }
  return 0x800000000000000EuLL;
}


/* ============================================================
 * Function: FwVolGetVolumeInfo
 * Address:  0xd6d0
 * Source:   FwVol.c
 * Desc:     Query Firmware Volume information
 * ============================================================ */

__int64 __fastcall FwVolGetVolumeInfo(char *dst, __int64 n232, _QWORD *a3, double a4)
{
  signed __int64 inited; // rbx
  __int64 p; // r8
  char *ProtocolEntry; // rax
  __int64 v11; // rdx
  __int64 v12; // r8
  __int64 v13; // rax
  __int64 *v14; // rax
  __int64 v15[2]; // [rsp+20h] [rbp-28h] BYREF
  _UNKNOWN **v16; // [rsp+30h] [rbp-18h]
  char *ProtocolEntry_1; // [rsp+38h] [rbp-10h]

  if ( a3 && dst )
  {
    *a3 = 0;
    v15[0] = (__int64)dst;
    v16 = &off_25AD8;
    v15[1] = n232;
    inited = DxeInit_2((__int64)&unk_25AC0, n232, (__int64)a3, a4);
    if ( inited < 0 )
      return 0x800000000000000EuLL;
    ++qword_26470;
    if ( n232 )
    {
      v13 = DxeNotify_1((__int64)v15, a3, p, a4);
    }
    else
    {
      ProtocolEntry = CoreFindProtocolEntry(dst, 0, p, a4);
      ProtocolEntry_1 = ProtocolEntry;
      if ( !ProtocolEntry )
        goto LABEL_7;
      v16 = (_UNKNOWN **)(ProtocolEntry + 40);
      v13 = DxeConfig_55((__int64)v15, a3, v12, a4);
    }
    if ( v13 )
    {
      if ( n232 )
      {
        v14 = *(__int64 **)(n232 + 40);
        v11 = *v14;
        *(_QWORD *)(n232 + 40) = *v14;
      }
      goto LABEL_13;
    }
LABEL_7:
    inited = 0x800000000000000EuLL;
LABEL_13:
    DxeGetInfo_10((__int64)&unk_25AC0, v11, v12, a4);
    return inited;
  }
  return 0x8000000000000002uLL;
}


/* ============================================================
 * Function: FwVolUnsupportedStub
 * Address:  0xdbf0
 * Source:   FwVol.c
 * Desc:     Stub function returning EFI_UNSUPPORTED
 * ============================================================ */

unsigned __int64 FwVolUnsupportedStub()
{
  return 0x8000000000000003uLL;
}


/* ============================================================
 * Function: FwVolReadFile
 * Address:  0xddf8
 * Source:   FwVolRead.c
 * Desc:     Read a file from Firmware Volume
 * ============================================================ */

__int64 __fastcall FwVolReadFile(unsigned __int64 __ImageBase, int a2, __int64 n3, int a4, _QWORD *a5)
{
  double v5; // xmm3_8
  int v11; // eax
  unsigned int n8; // ebx
  char *__FVB_; // rax
  unsigned __int64 v14; // rdx
  unsigned __int64 v15; // r8
  unsigned __int64 __FVB__1; // rdi
  int v17; // eax
  __int64 v18; // rbp
  unsigned __int64 n0x40; // rcx
  unsigned __int64 n0x40_1; // rax
  __int64 v21; // rbx
  unsigned int *v22; // r14
  _DWORD *v23; // rax
  unsigned __int64 v24; // rcx
  unsigned __int64 v25; // rcx
  char *v26; // rax
  int v27; // eax
  __int64 v28; // r10
  __int64 v29; // r9
  __int64 v30; // rcx
  char *v31; // rax
  __int64 v32; // rdx
  __int64 v33; // r8
  char *v34; // rax
  unsigned __int64 __ImageBase_1; // rcx
  _QWORD v36[4]; // [rsp+30h] [rbp-58h] BYREF
  int n2; // [rsp+50h] [rbp-38h]

  if ( *(_DWORD *)(__ImageBase + 40) != 1213613663 )
    return 0x800000000000000AuLL;
  v11 = *(_DWORD *)(__ImageBase + 44);
  if ( v11 >= 0 )
  {
    n8 = 1 << (BYTE2(v11) & 0x1F);
    if ( n8 < 8 )
      n8 = 8;
    if ( __ImageBase % n8 && (DxeConfig_36((__int16 *)__ImageBase, (__int64)v36, n3, v5) < 0 || n2 != 2) )
    {
      DebugPrint(
        0x80000000,
        "Unaligned FvImage found at 0x%lx:0x%lx, the required alignment is 0x%x\
",
        __ImageBase,
        a2,
        n8);
      return 0x800000000000000AuLL;
    }
  }
  __FVB_ = DxeConfig_56(
             4u,
             0x80u,
             aFvb, // "_FVB"
             v5); // "_FVB"
  __FVB__1 = (unsigned __int64)__FVB_;
  if ( !__FVB_ )
    return 0x8000000000000009uLL;
  *((_QWORD *)__FVB_ + 14) = __ImageBase;
  v17 = *(_DWORD *)(__ImageBase + 44);
  *(_DWORD *)(__FVB__1 + 120) = a4;
  v18 = 0;
  *(_DWORD *)(__FVB__1 + 104) = v17;
  *(_QWORD *)(__FVB__1 + 80) = n3;
  *(_QWORD *)(__FVB__1 + 88) = 0;
  n0x40 = *(unsigned __int16 *)(__ImageBase + 48);
  n0x40_1 = *(_QWORD *)(__ImageBase + 32);
  if ( n0x40 > n0x40_1 || (unsigned int)n0x40 < 0x40 )
  {
    v21 = 0x800000000000000AuLL;
    goto LABEL_47;
  }
  if ( __ImageBase + n0x40_1 - 1 < __ImageBase )
  {
    v21 = 0x8000000000000009uLL;
    goto LABEL_48;
  }
  v22 = (unsigned int *)(__ImageBase + 56);
  v14 = n0x40 + __ImageBase;
  v23 = (_DWORD *)(__ImageBase + 56);
  if ( __ImageBase + 56 >= n0x40 + __ImageBase )
    goto LABEL_23;
  do
  {
    if ( !*v23 )
      break;
    v24 = *(_QWORD *)(__FVB__1 + 88) + (unsigned int)*v23;
    if ( *(_QWORD *)(__FVB__1 + 88) > v24 )
      goto LABEL_23;
    v23 += 2;
    *(_QWORD *)(__FVB__1 + 88) = v24;
  }
  while ( (unsigned __int64)v23 < v14 );
  if ( (unsigned __int64)v23 >= v14 )
  {
LABEL_23:
    v21 = 0x800000000000000AuLL;
    goto LABEL_48;
  }
  v25 = *(_QWORD *)(__FVB__1 + 88);
  if ( v25 >= 0xFFFFFFFFFFFFFFFLL || (v26 = Assert_112(16 * v25, v14, v15, v5), (*(_QWORD *)(__FVB__1 + 96) = v26) == 0) )
  {
    Assert_55(__FVB__1, v14, v15, v5);
    return 0x8000000000000009uLL;
  }
  v27 = *v22;
  v28 = 0;
  v15 = 0;
  v21 = 0x800000000000000AuLL;
  if ( *v22 )
  {
    do
    {
      v29 = 0;
      if ( v27 )
      {
        v14 = 16 * v28;
        while ( 1 )
        {
          *(_QWORD *)(v14 + *(_QWORD *)(__FVB__1 + 96)) = v15;
          *(_QWORD *)(v14 + *(_QWORD *)(__FVB__1 + 96) + 8) = v22[1];
          if ( v15 > v15 + v22[1] )
            break;
          v15 += v22[1];
          ++v28;
          v14 += 16LL;
          if ( ++v29 >= (unsigned __int64)*v22 )
            goto LABEL_32;
        }
        v18 = 0x800000000000000AuLL;
      }
LABEL_32:
      v22 += 2;
      v27 = *v22;
    }
    while ( *v22 );
    if ( v18 < 0 )
      goto LABEL_48;
  }
  v30 = *(_QWORD *)(__ImageBase + 32);
  if ( v15 != v30 )
    goto LABEL_48;
  v14 = *(unsigned __int16 *)(__ImageBase + 52);
  if ( !(_WORD)v14 )
  {
    v31 = DxeConfig_56(4u, 0x1Cu, &src_, v5);
    *(_QWORD *)(__FVB__1 + 16) = v31;
    if ( v31 )
    {
      *((_QWORD *)v31 + 1) = __ImageBase;
      *(_QWORD *)(*(_QWORD *)(__FVB__1 + 16) + 16LL) = *(_QWORD *)(__ImageBase + 32) + __ImageBase - 1;
      goto LABEL_44;
    }
    goto LABEL_40;
  }
  if ( (unsigned __int16)v14 < *(_WORD *)(__ImageBase + 48) || (unsigned __int16)v14 > (unsigned __int64)(v30 - 20) )
  {
LABEL_48:
    __ImageBase_1 = *(_QWORD *)(__FVB__1 + 96);
    if ( __ImageBase_1 )
      AssertCpuDeadLoop_10(__ImageBase_1, v14, v15, v5);
    AssertCpuDeadLoop_10(__FVB__1, v14, v15, v5);
    return v21;
  }
  v34 = DxeConfig_56(4u, 0x18u, &src__0, v5);
  *(_QWORD *)(__FVB__1 + 16) = v34;
  if ( !v34 )
  {
LABEL_40:
    AssertCpuDeadLoop_10(__FVB__1, v32, v33, v5);
    return 0x8000000000000009uLL;
  }
  Assert_108(v34 + 4, __ImageBase + *(unsigned __int16 *)(__ImageBase + 52), v33, v5);
LABEL_44:
  v21 = Assert_89((char **)(__FVB__1 + 8), (__int64)&dst__2, __FVB__1 + 24, &qword_22550, *(_QWORD *)(__FVB__1 + 16), 0);
  if ( a5 )
    *a5 = *(_QWORD *)(__FVB__1 + 8);
LABEL_47:
  if ( v21 < 0 )
    goto LABEL_48;
  return v21;
}


/* ============================================================
 * Function: FwVolGetBlockSize
 * Address:  0xe6a8
 * Source:   FwVolRead.c
 * Desc:     Calculate block size for FV read
 * ============================================================ */

signed __int64 __fastcall FwVolGetBlockSize(unsigned int n4, unsigned __int64 n232, char **a3, double a4)
{
  __int64 v5; // rdx
  signed __int64 v6; // rbx
  __int64 v7; // r8
  __int64 v8; // rcx

  v6 = CoreCloseEvent(n4, n232, a3, a4);
  if ( v6 >= 0 )
  {
    if ( byte_264B0 )
    {
      v8 = n4 - 5;
      if ( (unsigned int)v8 <= 1 )
        CoreBuildMemoryAttributesTable(v8, v5, v7, a4);
    }
  }
  return v6;
}


/* ============================================================
 * Function: FwVolSearchSection
 * Address:  0xee98
 * Source:   SectionExtraction.c
 * Desc:     Search for a section within FFS file
 * ============================================================ */

__int64 __fastcall FwVolSearchSection(unsigned __int64 count, char *i, __int64 a3, int a4, _QWORD *a5)
{
  double v5; // xmm3_8
  char v8; // bp
  char *__ImageBase_1; // rax
  __int64 v11; // rdx
  __int64 v12; // r8
  unsigned __int64 __ImageBase; // rdi
  char *dst; // rax
  __int64 v16; // rdx
  __int64 v17; // r8
  __int64 v18; // rdx
  __int64 v19; // r8
  unsigned __int64 n0x10; // rbx
  __int64 v21; // r8
  __int64 v22; // rdx
  __int64 v23; // r8

  v8 = a3;
  __ImageBase_1 = Assert_112(0x48u, (__int64)i, a3, v5);
  __ImageBase = (unsigned __int64)__ImageBase_1;
  if ( !__ImageBase_1 )
    return 0x8000000000000009uLL;
  if ( v8 )
  {
    if ( count )
    {
      dst = Assert_112(count, v11, v12, v5);
      *(_QWORD *)(__ImageBase + 32) = dst;
      if ( !dst )
      {
        Assert_55(__ImageBase, v16, v17, v5);
        return 0x8000000000000009uLL;
      }
      CopyMemWrapper(dst, i, count, v5);
    }
    else
    {
      *((_QWORD *)__ImageBase_1 + 4) = 0;
    }
  }
  else
  {
    *((_QWORD *)__ImageBase_1 + 4) = i;
  }
  *(_DWORD *)__ImageBase = 1397971027;
  *(_QWORD *)(__ImageBase + 24) = __ImageBase;
  *(_QWORD *)(__ImageBase + 40) = count;
  Assert_74((_QWORD *)(__ImageBase + 48), v11, v12, v5);
  *(_DWORD *)(__ImageBase + 64) = a4;
  n0x10 = DxeConfig_58(0x10u, v18, v19, v5);
  Assert_53(&off_26278, (_QWORD *)(__ImageBase + 8), v21, v5);
  DxeNotify(n0x10, v22, v23, v5);
  *a5 = *(_QWORD *)(__ImageBase + 24);
  return 0;
}


/* ============================================================
 * Function: FwVolExtractSectionInfo
 * Address:  0xef88
 * Source:   SectionExtraction.c
 * Desc:     Extract section metadata information
 * ============================================================ */

char __fastcall FwVolExtractSectionInfo(char *dst, _QWORD *a2, __int64 a3, double a4)
{
  __int64 v6; // r8
  __int64 v8; // [rsp+40h] [rbp+18h] BYREF
  __int64 v9; // [rsp+48h] [rbp+20h] BYREF

  v8 = 0;
  if ( Assert_23((__int64)dst, &v9, a3, a4)
    || !Assert_103(v9, (__int64)dst, v6, a4)
    || FwVolGetVolumeInfo(dst, 0, &v8, a4) < 0
    || !v8 )
  {
    return 0;
  }
  *a2 = v8;
  return 1;
}


/* ============================================================
 * Function: FwVolSectionReadEx
 * Address:  0xeff0
 * Source:   SectionExtraction.c
 * Desc:     Read section data via FV protocol (extended)
 * ============================================================ */

char __fastcall FwVolSectionReadEx(__int64 a1, _QWORD *__ImageBase, __int64 a3, double a4)
{
  __int64 v6; // rdi
  char result; // al
  __int64 v8; // rax
  __int64 v9; // rax
  int v10; // r9d
  __int64 v11; // rax
  __int64 v12; // rdx
  __int64 v13; // r8
  _QWORD *v14; // [rsp+20h] [rbp-38h]
  unsigned __int64 v15[5]; // [rsp+30h] [rbp-28h] BYREF
  int v16; // [rsp+68h] [rbp+10h] BYREF
  __int64 (__fastcall **v17)(_QWORD, __int64, char **, unsigned __int64 *, int *); // [rsp+70h] [rbp+18h] BYREF
  char *i; // [rsp+78h] [rbp+20h] BYREF

  v6 = *(_QWORD *)(__ImageBase[1] + 32LL) + *(unsigned int *)(*__ImageBase + 32LL);
  if ( *(_BYTE *)(v6 + 3) != 2 )
    DebugAssert(
      (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
      568,
      (__int64)"GuidedHeader->CommonHeader.Type == 0x02",
      a4);
  result = FwVolExtractSectionInfo(*(_QWORD *)(*__ImageBase + 48LL), &v17, a3, a4);
  if ( result )
  {
    v8 = (*v17)(v17, v6, &i, v15, &v16);
    if ( v8 < 0 )
    {
      DebugPrint(0x80000000, "\
ASSERT_EFI_ERROR (Status = %r)\
", v8);
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
        581,
        (__int64)"!EFI_ERROR (Status)",
        a4);
    }
    v9 = __ImageBase[1];
    if ( (*(_BYTE *)(v6 + 22) & 2) != 0 )
      v10 = *(_DWORD *)(v9 + 64) & 0xF | v16;
    else
      v10 = *(_DWORD *)(v9 + 64);
    v14 = (_QWORD *)(*__ImageBase + 40LL);
    v16 = v10;
    v11 = FwVolSearchSection(v15[0], i, 0, v10, v14);
    if ( v11 < 0 )
    {
      DebugPrint(0x80000000, "\
ASSERT_EFI_ERROR (Status = %r)\
", v11);
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
        607,
        (__int64)"!EFI_ERROR (Status)",
        a4);
    }
    (*((void (__fastcall **)(__int64))buf_0 + 14))(a1);
    *(_QWORD *)(*__ImageBase + 56LL) = 0;
    return AssertCpuDeadLoop_10((unsigned __int64)__ImageBase, v12, v13, a4);
  }
  return result;
}


/* ============================================================
 * Function: FwVolParseSections
 * Address:  0xf13c
 * Source:   SectionExtraction.c
 * Desc:     Parse FFS sections for extraction
 * ============================================================ */

unsigned __int64 __fastcall FwVolParseSections(
        unsigned __int64 p___ImageBase,
        unsigned int a2,
        unsigned __int64 *p_i,
        double a4)
{
  __int64 v5; // rbx
  char *Info_19; // rax
  __int64 v9; // rdx
  __int64 v10; // r8
  unsigned __int64 Info; // rdi
  int n0xFFFFFF; // eax
  int v14; // ecx
  int v15; // ecx
  __int16 v16; // si
  __int64 v17; // rdx
  __int64 v18; // r8
  __int64 v19; // rdx
  __int64 v20; // r8
  int v21; // r9d
  __int64 v22; // rdx
  __int64 v23; // rbx
  unsigned __int64 Info_2; // rcx
  char *v25; // rbx
  int v26; // r9d
  int n0xFFFFFF_2; // ecx
  __int64 v28; // rcx
  char *i_3; // rdx
  unsigned __int64 count_3; // rcx
  __int64 v31; // rax
  __int64 n9; // rcx
  int n0xFFFFFF_1; // eax
  unsigned int count_1; // eax
  unsigned int v35; // r15d
  char v36; // si
  char *src; // r13
  __int64 count_2; // r12
  char *i_1; // rax
  char *i_2; // rcx
  __int64 Info_9; // rax
  __int64 Info_1; // rbx
  __int64 v43; // rsi
  __int64 v44; // rdx
  __int64 v45; // r8
  char *__ImageBase; // rbx
  __int64 v47; // rsi
  __int64 v48; // rdx
  __int64 v49; // r8
  __int64 v50; // rdx
  __int64 v51; // r8
  __int64 v52; // rax
  _QWORD v53[3]; // [rsp+40h] [rbp-18h] BYREF
  unsigned __int64 n232; // [rsp+A0h] [rbp+48h] BYREF
  int v55; // [rsp+A8h] [rbp+50h] BYREF
  unsigned __int64 count; // [rsp+B0h] [rbp+58h] BYREF
  char *i; // [rsp+B8h] [rbp+60h] BYREF

  v5 = *(_QWORD *)(p___ImageBase + 32) + a2;
  Info_19 = CoreSetTimer(4u, 0x40u, (__int64)p_i, a4);
  *p_i = (unsigned __int64)Info_19;
  Info = (unsigned __int64)Info_19;
  if ( !Info_19 )
    return 0x8000000000000009uLL;
  *(_DWORD *)Info_19 = 1396922451;
  *((_DWORD *)Info_19 + 6) = *(unsigned __int8 *)(v5 + 3);
  n0xFFFFFF = *(_DWORD *)v5 & 0xFFFFFF;
  if ( n0xFFFFFF == 0xFFFFFF )
    n0xFFFFFF = *(_DWORD *)(v5 + 4);
  *(_QWORD *)(Info + 48) = 0;
  *(_QWORD *)(Info + 40) = 0;
  v14 = *(_DWORD *)(Info + 24);
  *(_DWORD *)(Info + 28) = n0xFFFFFF;
  *(_DWORD *)(Info + 32) = a2;
  v15 = v14 - 1;
  if ( !v15 )
  {
    n9 = 9;
    if ( *(_DWORD *)(Info + 28) < 9u )
    {
      v23 = 0x800000000000000EuLL;
      goto LABEL_38;
    }
    n0xFFFFFF_1 = *(_DWORD *)v5 & 0xFFFFFF;
    if ( n0xFFFFFF_1 == 0xFFFFFF )
    {
      n9 = 13;
      count_1 = *(_DWORD *)(v5 + 8);
      v35 = *(_DWORD *)(v5 + 4) - 13;
      v36 = *(_BYTE *)(v5 + 12);
    }
    else
    {
      v36 = *(_BYTE *)(v5 + 8);
      v35 = n0xFFFFFF_1 - 9;
      count_1 = *(_DWORD *)(v5 + 4);
    }
    src = (char *)(n9 + v5);
    if ( !count_1 )
    {
      i_1 = 0;
      count = 0;
      i = 0;
      goto LABEL_60;
    }
    count_2 = count_1;
    count = count_1;
    i_1 = Assert_112(count_1, v9, v10, a4);
    i = i_1;
    if ( !i_1 )
    {
      v23 = 0x8000000000000009uLL;
      goto LABEL_38;
    }
    if ( v36 )
    {
      if ( v36 != 1 )
        goto LABEL_60;
      Info_9 = FwVolGetVolumeInfo(dst_4, 0, v53, a4);
      Info_1 = Info_9;
      if ( Info_9 < 0 )
      {
        DebugPrint(0x80000000, "\
ASSERT_EFI_ERROR (Status = %r)\
", Info_9);
        DebugAssert(
          (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
          774,
          (__int64)"!EFI_ERROR (Status)",
          a4);
      }
      v43 = v53[0];
      if ( !v53[0] )
        DebugAssert(
          (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
          775,
          (__int64)"Decompress != ((void *) 0)",
          a4);
      if ( Info_1 < 0 )
      {
        v23 = 0x8000000000000018uLL;
        goto LABEL_62;
      }
      v23 = (*(__int64 (__fastcall **)(__int64, char *, _QWORD, unsigned __int64 *, unsigned __int64 *))v43)(
              v43,
              src,
              v35,
              &count,
              &n232);
      if ( v23 < 0 || count != count_2 )
      {
        Assert_55(Info, v44, v45, a4);
        Assert_55((unsigned __int64)i, v50, v51, a4);
        if ( v23 >= 0 )
          return 0x8000000000000004uLL;
        return v23;
      }
      __ImageBase = Assert_112((unsigned int)n232, v44, v45, a4);
      if ( !__ImageBase )
      {
        v23 = 0x8000000000000009uLL;
        goto LABEL_62;
      }
      v47 = (*(__int64 (__fastcall **)(__int64, char *, _QWORD, char *, _DWORD, char *, _DWORD))(v43 + 8))(
              v43,
              src,
              v35,
              i,
              count,
              __ImageBase,
              n232);
      Assert_55((unsigned __int64)__ImageBase, v48, v49, a4);
      if ( v47 < 0 )
      {
        v23 = v47;
        goto LABEL_62;
      }
    }
    else
    {
      CopyMemWrapper(i_1, src, count, a4);
    }
    i_1 = i;
LABEL_60:
    v52 = FwVolSearchSection(count, i_1, 0, *(_DWORD *)(p___ImageBase + 64), (_QWORD *)(Info + 40));
    if ( v52 >= 0 )
      goto LABEL_22;
    v23 = v52;
LABEL_62:
    Info_2 = Info;
    goto LABEL_63;
  }
  if ( v15 != 1 )
    goto LABEL_22;
  if ( (*(_DWORD *)v5 & 0xFFFFFF) == 0xFFFFFF )
  {
    *(_QWORD *)(Info + 48) = v5 + 8;
    v16 = *(_WORD *)(v5 + 26);
  }
  else
  {
    *(_QWORD *)(Info + 48) = v5 + 4;
    v16 = *(_WORD *)(v5 + 22);
  }
  if ( FwVolExtractSectionInfo(*(_QWORD *)(Info + 48), v53, v10, a4) )
  {
    if ( (*(__int64 (__fastcall **)(_QWORD, __int64, char **, unsigned __int64 *, int *))v53[0])(
           v53[0],
           v5,
           &i,
           &count,
           &v55) < 0 )
    {
      Assert_55(*p_i, v19, v20, a4);
      return 0x8000000000000018uLL;
    }
    if ( (v16 & 2) != 0 )
      v21 = *(_DWORD *)(p___ImageBase + 64) & 0xF | v55;
    else
      v21 = *(_DWORD *)(p___ImageBase + 64);
    v55 = v21;
    v23 = FwVolSearchSection(count, i, 0, v21, (_QWORD *)(Info + 40));
    if ( v23 < 0 )
    {
      Info_2 = *p_i;
LABEL_63:
      Assert_55(Info_2, v22, v10, a4);
      i_2 = i;
      goto LABEL_39;
    }
LABEL_22:
    Assert_53((_QWORD *)(p___ImageBase + 48), (_QWORD *)(Info + 8), v10, a4);
    return 0;
  }
  if ( (v16 & 1) != 0 )
  {
    v25 = Assert_112(0x18u, v17, v18, a4);
    if ( !v25 )
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
        636,
        (__int64)"Context != ((void *) 0)",
        a4);
    *(_QWORD *)v25 = Info;
    *((_QWORD *)v25 + 1) = p___ImageBase;
    *(_QWORD *)(*(_QWORD *)v25 + 56LL) = Assert_0(
                                           *(unsigned int **)(Info + 48),
                                           16,
                                           (__int64)FwVolSectionReadEx,
                                           (__int64)v25,
                                           (__int64)(v25 + 16));
    goto LABEL_22;
  }
  v26 = *(_DWORD *)(p___ImageBase + 64);
  v55 = v26;
  if ( (v16 & 2) != 0 )
  {
    v26 |= 6u;
    v55 = v26;
  }
  LOBYTE(v18) = 1;
  n0xFFFFFF_2 = *(_DWORD *)v5 & 0xFFFFFF;
  if ( n0xFFFFFF_2 == 0xFFFFFF )
  {
    v28 = *(unsigned __int16 *)(v5 + 24);
    i_3 = (char *)(v5 + v28);
    count_3 = (unsigned int)(*(_DWORD *)(v5 + 4) - v28);
  }
  else
  {
    v31 = *(unsigned __int16 *)(v5 + 20);
    count_3 = (unsigned int)(n0xFFFFFF_2 - v31);
    i_3 = (char *)(v5 + v31);
  }
  v23 = FwVolSearchSection(count_3, i_3, v18, v26, (_QWORD *)(Info + 40));
  if ( v23 >= 0 )
    goto LABEL_22;
LABEL_38:
  i_2 = (char *)Info;
LABEL_39:
  Assert_55((unsigned __int64)i_2, v9, v10, a4);
  return v23;
}


/* ============================================================
 * Function: FwVolDecompressSection
 * Address:  0xf55c
 * Source:   SectionExtraction.c
 * Desc:     Decompress a compressed FFS section
 * ============================================================ */

signed __int64 __fastcall FwVolDecompressSection(
        unsigned __int64 p___ImageBase,
        __int64 n2,
        _QWORD *a3,
        __int64 a4,
        __int64 *a5,
        __int64 *a6,
        _DWORD *p_p___ImageBase)
{
  double v7; // xmm3_8
  _QWORD *v8; // rbx
  __int64 v10; // rdi
  __int64 v11; // rdx
  __int64 v12; // r8
  signed __int64 result; // rax
  __int64 v14; // rdx
  __int64 v15; // r8
  __int64 v16; // rdx
  __int64 v17; // r8
  __int64 p_i_1; // rax
  __int64 n2_1; // rdx
  __int64 v20; // r8
  __int64 v21; // rax
  __int64 p_i_2; // rbx
  _DWORD *v23; // rcx
  __int64 v24; // rcx
  bool v25; // al
  _QWORD *v26; // rax
  _DWORD *p_p___ImageBase_1; // rcx
  unsigned __int64 p___ImageBase_1; // rcx
  __int64 v30; // r8
  __int64 v31; // r8
  __int64 v32; // r8
  __int64 v33; // [rsp+40h] [rbp-28h]
  __int64 v34; // [rsp+48h] [rbp-20h] BYREF
  __int64 v35[3]; // [rsp+50h] [rbp-18h] BYREF
  __int64 p_i; // [rsp+90h] [rbp+28h] BYREF
  unsigned __int8 n2a; // [rsp+98h] [rbp+30h]
  _QWORD *v38; // [rsp+A0h] [rbp+38h]
  __int64 v39; // [rsp+A8h] [rbp+40h]

  v39 = a4;
  v38 = a3;
  n2a = n2;
  p_i = 0;
  v8 = (_QWORD *)(p___ImageBase + 48);
  v10 = 0x800000000000000EuLL;
  if ( !Assert_75((_QWORD *)(p___ImageBase + 48), n2, (__int64)a3, v7)
    || *(_QWORD *)(p___ImageBase + 40) < 4u
    || (result = FwVolParseSections(p___ImageBase, 0, (unsigned __int64 *)&p_i, v7), result >= 0) )
  {
    if ( *(_DWORD *)(Assert_77(v8, v11, v12, v7) - 8) == 1396922451 )
    {
      v21 = Assert_77(v8, v14, v15, v7);
      goto LABEL_7;
    }
    DebugAssert(
      (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
      1034,
      (__int64)"CR has Bad Signature",
      v7);
    p_i_1 = Assert_77(v8, v16, v17, v7);
LABEL_38:
    p_i_2 = p_i_1;
    for ( p_i = p_i_1; ; p_i_2 = p_i )
    {
      while ( 1 )
      {
        if ( !p_i_2 )
          DebugAssert(
            (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
            1037,
            (__int64)"CurrentChildNode != ((void *) 0)",
            v7);
        LOBYTE(n2_1) = n2a;
        if ( !n2a
          || *(_DWORD *)(p_i_2 + 24) == n2a
          && (n2a != 2 || (v20 = v39) == 0
            ? (v25 = 1)
            : ((v23 = (_DWORD *)(*(_QWORD *)(p___ImageBase + 32) + *(unsigned int *)(p_i_2 + 32)),
                (*v23 & 0xFFFFFF) != 0xFFFFFF)
             ? (v24 = (__int64)(v23 + 1))
             : (v24 = (__int64)(v23 + 2)),
               v25 = Assert_103(v24, v39, v39, v7),
               LOBYTE(n2_1) = n2a),
              v25) )
        {
          v26 = v38;
          if ( (*v38)-- == 1 )
          {
            p_p___ImageBase_1 = p_p___ImageBase;
            *a5 = p_i_2;
            *a6 = p___ImageBase;
            *p_p___ImageBase_1 = *(_DWORD *)(p___ImageBase + 64);
            return 0;
          }
        }
        else
        {
          v26 = v38;
        }
        p___ImageBase_1 = *(_QWORD *)(p_i_2 + 40);
        if ( p___ImageBase_1 )
        {
          if ( *(_QWORD *)(p___ImageBase_1 + 40) )
            v10 = FwVolDecompressSection(p___ImageBase_1, n2_1, v26, v39, &v34, v35, p_p___ImageBase);
          else
            v10 = 0x800000000000000EuLL;
          v20 = (__int64)v38;
          if ( !*v38 )
          {
            if ( v10 < 0 )
            {
              DebugPrint(0x80000000, "\
ASSERT_EFI_ERROR (Status = %r)\
", v10);
              DebugAssert(
                (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
                1072,
                (__int64)"!EFI_ERROR (Status)",
                v7);
            }
            *a5 = v34;
            *a6 = v35[0];
            return 0;
          }
        }
        else if ( *(_DWORD *)(p_i_2 + 24) == 2 && (_BYTE)n2_1 != 2 )
        {
          v10 = 0x8000000000000018uLL;
        }
        v33 = p_i_2 + 8;
        if ( Assert_33((_QWORD *)(p___ImageBase + 48), p_i_2 + 8, v20, v7) )
          break;
        if ( *(_DWORD *)(Assert_78((_QWORD *)(p___ImageBase + 48), v33, v30, v7) - 8) != 1396922451 )
        {
          DebugAssert(
            (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
            1094,
            (__int64)"CR has Bad Signature",
            v7);
          p_i_1 = Assert_78((_QWORD *)(p___ImageBase + 48), v33, v32, v7);
          goto LABEL_38;
        }
        v21 = Assert_78((_QWORD *)(p___ImageBase + 48), v33, v31, v7);
LABEL_7:
        p_i_2 = v21 - 8;
        p_i = v21 - 8;
      }
      if ( ((*(_DWORD *)(p_i_2 + 32) + 3 + *(_DWORD *)(p_i_2 + 28)) & 0xFFFFFFFC) > (unsigned __int64)(*(_QWORD *)(p___ImageBase + 40) - 4LL) )
        break;
      result = FwVolParseSections(
                 p___ImageBase,
                 (*(_DWORD *)(p_i_2 + 32) + 3 + *(_DWORD *)(p_i_2 + 28)) & 0xFFFFFFFC,
                 (unsigned __int64 *)&p_i,
                 v7);
      if ( result < 0 )
        return result;
    }
    if ( v10 >= 0 )
      DebugAssert(
        (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
        1116,
        (__int64)"(((INTN)(RETURN_STATUS)(ErrorStatus)) < 0)",
        v7);
    return v10;
  }
  return result;
}


/* ============================================================
 * Function: FwVolProtocolRegister
 * Address:  0xf918
 * Source:   FwVolBlock.c
 * Desc:     Register Firmware Volume Block protocol
 * ============================================================ */

signed __int64 __fastcall FwVolProtocolRegister(
        __int64 a1,
        unsigned __int8 *p_n2,
        __int64 p___ImageBase,
        __int64 a4,
        __int64 *p_dst,
        unsigned __int64 *a6,
        _DWORD *a7,
        char a8)
{
  double v8; // xmm3_8
  unsigned __int64 n0x10; // r13
  __int64 n2; // rdx
  __int64 n4; // rdi
  __int64 v14; // r8
  unsigned __int64 n232; // rbx
  char *src; // r15
  _DWORD *v17; // rsi
  char **p_dst_1; // rsi
  unsigned __int64 n232_1; // r12
  unsigned __int64 *v20; // r14
  char *v22; // rax
  __int64 v23; // [rsp+40h] [rbp-10h] BYREF
  __int64 v24; // [rsp+48h] [rbp-8h] BYREF
  __int64 p___ImageBasea; // [rsp+A0h] [rbp+50h] BYREF
  __int64 v26; // [rsp+A8h] [rbp+58h] BYREF

  p___ImageBasea = p___ImageBase;
  v26 = 0;
  v23 = a4 + 1;
  n0x10 = DxeConfig_58(0x10u, (__int64)p_n2, p___ImageBase, v8);
  n4 = DxeConfig_45(a1, &p___ImageBasea, v23, v8);
  if ( n4 < 0 )
  {
    n4 = 0x8000000000000002uLL;
    goto LABEL_20;
  }
  if ( p_n2 )
  {
    if ( *(_QWORD *)(p___ImageBasea + 40) )
    {
      LOBYTE(n2) = *p_n2;
      n4 = FwVolDecompressSection(p___ImageBasea, n2, &v23, 0, &v24, &v26, &p___ImageBasea);
      if ( n4 < 0 )
        goto LABEL_20;
      v17 = (_DWORD *)(*(_QWORD *)(v26 + 32) + *(unsigned int *)(v24 + 32));
      if ( (*v17 & 0xFFFFFF) == 0xFFFFFF )
      {
        if ( v17[1] <= 0xFFFFFFu )
          DebugAssert(
            (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
            1289,
            (__int64)"(((EFI_COMMON_SECTION_HEADER2 *) (UINTN) Section)->ExtendedSize) > 0x00FFFFFF",
            v8);
        if ( !a8 )
        {
          DebugPrint(0x80000000, "It is a FFS3 formatted section in a non-FFS3 formatted FV.\
");
          goto LABEL_12;
        }
        n2 = 8;
        n232 = (unsigned int)v17[1] - 8LL;
      }
      else
      {
        n2 = 4;
        n232 = (*v17 & 0xFFFFFF) - 4LL;
      }
      src = (char *)&v17[(unsigned __int64)n2 / 4];
      *a7 = p___ImageBasea;
      goto LABEL_16;
    }
LABEL_12:
    n4 = 0x800000000000000EuLL;
    goto LABEL_20;
  }
  n232 = *(_QWORD *)(p___ImageBasea + 40);
  src = *(char **)(p___ImageBasea + 32);
  *a7 = *(_DWORD *)(p___ImageBasea + 64);
LABEL_16:
  p_dst_1 = (char **)p_dst;
  n232_1 = n232;
  v20 = a6;
  if ( *p_dst )
  {
    if ( *a6 < n232 )
    {
      n232 = *a6;
      n4 = 4;
    }
  }
  else
  {
    v22 = Assert_112(n232, n2, v14, v8);
    *p_dst_1 = v22;
    if ( !v22 )
    {
      n4 = 0x8000000000000009uLL;
      goto LABEL_20;
    }
  }
  CopyMemWrapper(*p_dst_1, src, n232, v8);
  *v20 = n232_1;
LABEL_20:
  DxeNotify(n0x10, n2, v14, v8);
  return n4;
}


/* ============================================================
 * Function: CoreExtractSection
 * Address:  0xfad0
 * Source:   SectionExtraction.c
 * Desc:     Core section extraction handler
 * ============================================================ */

unsigned __int64 __fastcall CoreExtractSection(__int64 a1, __int64 a2, __int64 a3, double a4)
{
  unsigned __int64 n0x10; // rdi
  __int64 v6; // r8
  __int64 v7; // rax
  __int64 v8; // rdx
  __int64 v9; // r8
  unsigned __int64 v10; // rbx
  unsigned __int64 p___ImageBase_1; // rsi
  __int64 v12; // rdx
  __int64 v13; // r8
  __int64 v14; // rdx
  __int64 v15; // r8
  __int64 __ImageBase_1; // rax
  __int64 v17; // rdx
  __int64 v18; // r8
  unsigned __int64 __ImageBase; // rdi
  __int64 v20; // rdx
  __int64 v21; // r8
  __int64 v22; // rcx
  __int64 v23; // rdx
  __int64 v24; // r8
  char v26; // [rsp+48h] [rbp+10h]
  __int64 p___ImageBase; // [rsp+50h] [rbp+18h] BYREF
  unsigned __int64 n0x10_1; // [rsp+58h] [rbp+20h]

  v26 = a2;
  n0x10_1 = DxeConfig_58(0x10u, a2, a3, a4);
  n0x10 = n0x10_1;
  v7 = DxeConfig_45(a1, &p___ImageBase, v6, a4);
  v10 = 0;
  if ( v7 < 0 )
  {
    v10 = 0x8000000000000002uLL;
  }
  else
  {
    p___ImageBase_1 = p___ImageBase;
    Assert_58((_QWORD *)(p___ImageBase + 8), v8, v9, a4);
    if ( !Assert_75((_QWORD *)(p___ImageBase_1 + 48), v12, v13, a4) )
    {
      do
      {
        __ImageBase_1 = Assert_77((_QWORD *)(p___ImageBase_1 + 48), v14, v15, a4);
        __ImageBase = __ImageBase_1;
        if ( *(_DWORD *)(__ImageBase_1 - 8) == 1396922451 )
          __ImageBase = __ImageBase_1 - 8;
        else
          DebugAssert(
            (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
            1408,
            (__int64)"CR has Bad Signature",
            a4);
        if ( *(_DWORD *)__ImageBase != 1396922451 )
          DebugAssert(
            (__int64)"e:\\\\hs\\\\MdeModulePkg\\\\Core\\\\Dxe\\\\SectionExtraction\\\\CoreSectionExtraction.c",
            1344,
            (__int64)"ChildNode->Signature == ((('S') | ('X' << 8)) | ((('C') | ('S' << 8)) << 16))",
            a4);
        Assert_58((_QWORD *)(__ImageBase + 8), v17, v18, a4);
        v22 = *(_QWORD *)(__ImageBase + 40);
        if ( v22 )
        {
          LOBYTE(v20) = 1;
          CoreExtractSection(v22, v20, v21, a4);
        }
        if ( *(_QWORD *)(__ImageBase + 56) )
          (*((void (**)(void))buf_0 + 14))();
        Assert_55(__ImageBase, v20, v21, a4);
      }
      while ( !Assert_75((_QWORD *)(p___ImageBase_1 + 48), v23, v24, a4) );
      n0x10 = n0x10_1;
    }
    if ( v26 )
      Assert_55(*(_QWORD *)(p___ImageBase_1 + 32), v14, v15, a4);
    Assert_55(p___ImageBase_1, v14, v15, a4);
  }
  DxeNotify(n0x10, v8, v9, a4);
  return v10;
}