/* ============================================================
 * DXE Core Dispatcher - Decompiled from DxeCore.efi
 * Original Source: MdeModulePkg/Core/Dxe/Dispatcher/Dispatcher.c
 * ============================================================ */

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



/* ============================================================
 * Function: PeCoffAllocatePoolWrapper
 * Address:  0x151b4
 * Source:   BasePeCoff.c
 * Desc:     Wrapper to call AllocatePool for PE/COFF library
 * ============================================================ */

__int64 __fastcall PeCoffAllocatePoolWrapper(__int64 a1, char *a2, char *a3, __int64 a4)
{
  return Assert_14(a1, a2, a3, a4, 0);
}


/* ============================================================
 * Function: PeCoffFreePoolWrapper
 * Address:  0x151c8
 * Source:   BasePeCoff.c
 * Desc:     Wrapper to call FreePool for PE/COFF library
 * ============================================================ */

__int64 __fastcall PeCoffFreePoolWrapper(__int64 a1, _BYTE *a2, _BYTE *a3, __int64 a4)
{
  return Assert_95(a1, a2, a3, a4);
}


/* ============================================================
 * Function: PeCoffAllocateZeroPoolWrapper
 * Address:  0x151dc
 * Source:   BasePeCoff.c
 * Desc:     Wrapper to allocate and zero pool memory
 * ============================================================ */

__int64 __fastcall PeCoffAllocateZeroPoolWrapper(unsigned __int64 a1, _QWORD *a2, __int64 a3, double a4)
{
  __int64 result; // rax
  char *v6; // [rsp+40h] [rbp+18h] BYREF

  v6 = 0;
  result = Assert_100(a1, &v6, a3, a4);
  if ( result >= 0 )
  {
    if ( a2 )
    {
      *a2 = v6;
      return 0;
    }
    else
    {
      return 0x8000000000000002uLL;
    }
  }
  return result;
}


/* ============================================================
 * Function: DxeHuffmanDecode
 * Address:  0x15aec
 * Source:   Dispatcher.c
 * Desc:     Huffman code tree decompression for FV
 * ============================================================ */

char __fastcall DxeHuffmanDecode(__int64 buf, __int64 a2, __int64 i, double a4)
{
  __int16 v5; // bx
  unsigned int v6; // eax
  __int64 v7; // rdx
  unsigned __int16 n0x1FE_1; // bp
  unsigned __int16 n0x1FE; // bx
  unsigned int n0x80000; // ecx
  __int16 v11; // bp
  unsigned __int16 n0x1F; // si
  unsigned int n0x800000; // ecx
  __int64 v14; // r8
  int n0x1F_1; // r14d
  int v16; // ebx
  __int64 v17; // rcx
  __int64 v18; // rdx

  while ( 1 )
  {
    while ( 1 )
    {
      if ( *(_WORD *)(buf + 36) )
        goto LABEL_6;
      v5 = *(_WORD *)(buf + 30);
      Assert_97(buf, 0x10u, i, a4);
      *(_WORD *)(buf + 36) = v5;
      LOWORD(v6) = CoreConnectController(buf, 0x13u, 5, 3);
      *(_WORD *)(buf + 48) = v6;
      if ( (_WORD)v6 )
      {
        n0x1FE_1 = 0;
        goto LABEL_13;
      }
      CoreDisconnectController(buf, v7, i, a4);
      LOWORD(v6) = CoreConnectController(buf, 0x1Fu, *(unsigned __int8 *)(buf + 13372), 0xFFFF);
      *(_WORD *)(buf + 48) = v6;
      if ( !(_WORD)v6 )
      {
LABEL_6:
        --*(_WORD *)(buf + 36);
        n0x1FE = *(_WORD *)(buf + 2 * ((unsigned __int64)*(unsigned int *)(buf + 28) >> 20) + 4668);
        if ( n0x1FE >= 0x1FEu )
        {
          n0x80000 = 0x80000;
          do
          {
            if ( (*(_DWORD *)(buf + 28) & n0x80000) != 0 )
              n0x1FE = *(_WORD *)(buf + 2LL * n0x1FE + 2088);
            else
              n0x1FE = *(_WORD *)(buf + 2LL * n0x1FE + 50);
            n0x80000 >>= 1;
          }
          while ( n0x1FE >= 0x1FEu );
        }
        LOBYTE(v6) = Assert_97(buf, *(unsigned __int8 *)(n0x1FE + buf + 4126), i, a4);
        n0x1FE_1 = n0x1FE;
      }
      else
      {
        n0x1FE_1 = 0;
      }
LABEL_13:
      if ( *(_WORD *)(buf + 48) )
        return v6;
      if ( n0x1FE_1 < 0x100u )
        break;
      v11 = n0x1FE_1 - 253;
      n0x1F = *(_WORD *)(buf + 2 * ((unsigned __int64)*(unsigned int *)(buf + 28) >> 24) + 12860);
      if ( n0x1F >= 0x1Fu )
      {
        n0x800000 = 0x800000;
        do
        {
          if ( (*(_DWORD *)(buf + 28) & n0x800000) != 0 )
            n0x1F = *(_WORD *)(buf + 2LL * n0x1F + 2088);
          else
            n0x1F = *(_WORD *)(buf + 2LL * n0x1F + 50);
          n0x800000 >>= 1;
        }
        while ( n0x1F >= 0x1Fu );
      }
      LOBYTE(v6) = Assert_97(buf, *(unsigned __int8 *)(n0x1F + buf + 4636), i, a4);
      n0x1F_1 = n0x1F;
      if ( n0x1F > 1u )
      {
        v16 = *(_DWORD *)(buf + 28) >> (32 - (n0x1F - 1));
        LOBYTE(v6) = Assert_97(buf, n0x1F - 1, v14, a4);
        n0x1F_1 = v16 + (1 << (n0x1F - 1));
      }
      for ( i = (unsigned int)(*(_DWORD *)(buf + 16) - n0x1F_1 - 1); --v11 >= 0; i = (unsigned int)(i + 1) )
      {
        v17 = *(unsigned int *)(buf + 16);
        if ( (unsigned int)v17 >= *(_DWORD *)(buf + 44) )
          return v6;
        if ( (unsigned int)i >= *(_DWORD *)(buf + 44) )
        {
          *(_WORD *)(buf + 48) = -1;
          return v6;
        }
        v18 = *(_QWORD *)(buf + 8);
        LOBYTE(v6) = *(_BYTE *)(i + v18);
        *(_BYTE *)(v17 + v18) = v6;
        ++*(_DWORD *)(buf + 16);
      }
      v6 = *(_DWORD *)(buf + 44);
      if ( *(_DWORD *)(buf + 16) >= v6 )
        return v6;
    }
    v6 = *(_DWORD *)(buf + 16);
    if ( v6 >= *(_DWORD *)(buf + 44) )
      return v6;
    *(_BYTE *)(v6 + *(_QWORD *)(buf + 8)) = n0x1FE_1;
    ++*(_DWORD *)(buf + 16);
  }
}


/* ============================================================
 * Function: PeCoffGetEntryPointEx
 * Address:  0x160c4
 * Source:   BasePeCoff.c
 * Desc:     Get PE/COFF entry point from image context
 * ============================================================ */

__int64 __fastcall PeCoffGetEntryPointEx(__int64 *p___ImageBase, __int64 a2)
{
  __int64 v3; // rcx
  bool v4; // zf
  unsigned int v5; // eax
  __int64 v6; // r9
  __int64 v7; // rcx
  __int64 v8; // rcx
  __int16 v9; // ax
  unsigned __int64 v10; // rdx
  __int64 v12; // rcx
  __int64 v13; // rax
  int v14; // r8d
  unsigned int v15; // r8d
  unsigned int v16; // r10d
  unsigned int v17; // edx
  unsigned int v18; // edx
  int v19; // edx
  int v20; // ecx
  unsigned int n0x10; // r8d
  int v22; // r9d
  unsigned int v23; // r8d
  unsigned int v24; // r10d
  unsigned int v25; // edx
  unsigned int v26; // edx
  __int16 n3772; // cx
  unsigned __int64 v28; // r15
  unsigned int n40; // esi
  unsigned int v30; // r14d
  __int64 v31; // rcx
  unsigned int v32; // edx
  int v33; // ecx
  unsigned __int64 v34; // rax
  _BYTE v35[12]; // [rsp+20h] [rbp-49h] BYREF
  unsigned int v36; // [rsp+2Ch] [rbp-3Dh]
  unsigned int v37; // [rsp+30h] [rbp-39h]
  unsigned int v38; // [rsp+34h] [rbp-35h]
  _WORD v39[30]; // [rsp+50h] [rbp-19h] BYREF
  unsigned int v40; // [rsp+8Ch] [rbp+23h]
  char v41; // [rsp+D0h] [rbp+67h] BYREF
  __int64 v42; // [rsp+D8h] [rbp+6Fh]
  __int64 n64; // [rsp+E0h] [rbp+77h] BYREF

  v42 = a2;
  n64 = 64;
  v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, _WORD *))p___ImageBase[4])(p___ImageBase[5], 0, &n64, v39);
  if ( v3 < 0 )
  {
    v4 = n64 == 64;
    goto LABEL_80;
  }
  v4 = n64 == 64;
  if ( n64 == 64 )
  {
    *((_DWORD *)p___ImageBase + 15) = 0;
    v5 = *((_DWORD *)p___ImageBase + 15);
    v6 = v42;
    if ( v39[0] == 23117 )
      v5 = v40;
    v7 = p___ImageBase[5];
    *((_DWORD *)p___ImageBase + 15) = v5;
    n64 = 264;
    v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, __int64))p___ImageBase[4])(v7, v5, &n64, v6);
    if ( v3 < 0 )
    {
      v4 = n64 == 264;
      goto LABEL_80;
    }
    v4 = n64 == 264;
    if ( n64 == 264 )
    {
      v8 = v42;
      if ( *(_WORD *)v42 == 23126 )
      {
        *((_BYTE *)p___ImageBase + 125) = 1;
        *((_WORD *)p___ImageBase + 60) = *(_WORD *)(v8 + 2);
        v9 = *(unsigned __int8 *)(v8 + 5);
        p___ImageBase[1] = 0;
        *((_DWORD *)p___ImageBase + 14) = 0;
        *((_WORD *)p___ImageBase + 61) = v9;
        v10 = *(unsigned int *)(v8 + 12) - (unsigned __int64)*(unsigned __int16 *)(v8 + 6) + 40;
        p___ImageBase[11] = v10;
        if ( *(_WORD *)(v8 + 6) > 0x28u && *(_DWORD *)(v8 + 12) > (unsigned int)*(unsigned __int16 *)(v8 + 6) )
        {
          v12 = p___ImageBase[5];
          n64 = 1;
          v3 = ((__int64 (__fastcall *)(__int64, unsigned __int64, __int64 *, char *))p___ImageBase[4])(
                 v12,
                 v10 - 1,
                 &n64,
                 &v41);
          if ( v3 >= 0 )
          {
            v4 = n64 == 1;
            if ( n64 != 1 )
              goto LABEL_80;
            v13 = v42;
            if ( *(_DWORD *)(v42 + 28) && !*(_DWORD *)(v42 + 24) || *(_DWORD *)(v42 + 36) && !*(_DWORD *)(v42 + 32) )
              goto LABEL_9;
            goto LABEL_55;
          }
LABEL_19:
          v4 = n64 == 1;
          goto LABEL_80;
        }
LABEL_9:
        *((_DWORD *)p___ImageBase + 26) = 11;
        return 0x8000000000000003uLL;
      }
      if ( *(_DWORD *)v42 == 17744 )
      {
        *((_BYTE *)p___ImageBase + 125) = 0;
        *((_WORD *)p___ImageBase + 60) = *(_WORD *)(v8 + 4);
        if ( *(_WORD *)(v8 + 4) == 512 && *(_WORD *)(v8 + 24) == 267 )
          goto LABEL_38;
        if ( *(_WORD *)(v8 + 24) == 267 )
        {
          if ( *(_DWORD *)(v8 + 116) > 0x10u )
            goto LABEL_9;
          v14 = *(unsigned __int16 *)(v8 + 20);
          if ( v14 - 96 != 8LL * *(unsigned int *)(v8 + 116) )
            goto LABEL_9;
          v15 = v14 + *((_DWORD *)p___ImageBase + 15) + 24;
          if ( *(_DWORD *)(v8 + 80) <= v15 )
            goto LABEL_9;
          v16 = *(unsigned __int16 *)(v8 + 6);
          if ( (*(_DWORD *)(v8 + 80) - v15) / 0x28 <= v16 )
            goto LABEL_9;
          v17 = *(_DWORD *)(v8 + 84);
          if ( v17 <= v15 || v17 >= *(_DWORD *)(v8 + 80) || (v17 - v15) / 0x28 < v16 )
            goto LABEL_9;
          n64 = 1;
          v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, char *))p___ImageBase[4])(
                 p___ImageBase[5],
                 (unsigned int)(*(_DWORD *)(v8 + 84) - 1),
                 &n64,
                 &v41);
          if ( v3 < 0 )
            goto LABEL_19;
          v4 = n64 == 1;
          if ( n64 != 1 )
            goto LABEL_80;
          v13 = v42;
          if ( *(_DWORD *)(v42 + 116) > 4u )
          {
            v18 = *(_DWORD *)(v42 + 156);
            if ( v18 )
            {
              if ( ~*(_DWORD *)(v42 + 152) < v18 )
                goto LABEL_9;
              n64 = 1;
              v19 = *(_DWORD *)(v42 + 156);
              v20 = *(_DWORD *)(v42 + 152);
              goto LABEL_51;
            }
          }
          goto LABEL_54;
        }
        if ( *(_WORD *)(v8 + 24) == 523 )
        {
LABEL_38:
          n0x10 = *(_DWORD *)(v8 + 132);
          if ( n0x10 > 0x10 )
            goto LABEL_9;
          v22 = *(unsigned __int16 *)(v8 + 20);
          if ( v22 - 112 != 8LL * n0x10 )
            goto LABEL_9;
          v23 = v22 + *((_DWORD *)p___ImageBase + 15) + 24;
          if ( *(_DWORD *)(v8 + 80) <= v23 )
            goto LABEL_9;
          v24 = *(unsigned __int16 *)(v8 + 6);
          if ( (*(_DWORD *)(v8 + 80) - v23) / 0x28 <= v24 )
            goto LABEL_9;
          v25 = *(_DWORD *)(v8 + 84);
          if ( v25 <= v23 || v25 >= *(_DWORD *)(v8 + 80) || (v25 - v23) / 0x28 < v24 )
            goto LABEL_9;
          n64 = 1;
          v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, char *))p___ImageBase[4])(
                 p___ImageBase[5],
                 (unsigned int)(*(_DWORD *)(v8 + 84) - 1),
                 &n64,
                 &v41);
          if ( v3 < 0 )
            goto LABEL_19;
          v4 = n64 == 1;
          if ( n64 != 1 )
            goto LABEL_80;
          v13 = v42;
          if ( *(_DWORD *)(v42 + 132) > 4u )
          {
            v26 = *(_DWORD *)(v42 + 172);
            if ( v26 )
            {
              if ( ~*(_DWORD *)(v42 + 168) < v26 )
                goto LABEL_9;
              n64 = 1;
              v19 = *(_DWORD *)(v42 + 172);
              v20 = *(_DWORD *)(v42 + 168);
LABEL_51:
              v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, char *))p___ImageBase[4])(
                     p___ImageBase[5],
                     (unsigned int)(v20 - 1 + v19),
                     &n64,
                     &v41);
              if ( v3 < 0 )
                goto LABEL_19;
              v4 = n64 == 1;
              if ( n64 != 1 )
                goto LABEL_80;
              v13 = v42;
            }
          }
LABEL_54:
          *((_WORD *)p___ImageBase + 61) = *(_WORD *)(v13 + 92);
          p___ImageBase[1] = *(unsigned int *)(v13 + 80);
          *((_DWORD *)p___ImageBase + 14) = *(_DWORD *)(v13 + 56);
          p___ImageBase[11] = *(unsigned int *)(v13 + 84);
LABEL_55:
          n3772 = *((_WORD *)p___ImageBase + 60);
          if ( n3772 != -31132 && n3772 != 3772 && n3772 != 332 && n3772 != -21916 )
            return 0x8000000000000003uLL;
          if ( *((_BYTE *)p___ImageBase + 125) )
          {
            v28 = *(unsigned __int8 *)(v13 + 4);
            n40 = 40;
          }
          else
          {
            v28 = *(unsigned __int16 *)(v13 + 6);
            n40 = *(unsigned __int16 *)(v13 + 20) + *((_DWORD *)p___ImageBase + 15) + 24;
          }
          v30 = 0;
          if ( !v28 )
            return 0;
          while ( 1 )
          {
            v31 = p___ImageBase[5];
            n64 = 40;
            v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, _BYTE *))p___ImageBase[4])(v31, n40, &n64, v35);
            if ( v3 < 0 )
              break;
            v4 = n64 == 40;
            if ( n64 != 40 )
              goto LABEL_80;
            v32 = v38;
            if ( *((_BYTE *)p___ImageBase + 125) )
            {
              v33 = *(unsigned __int16 *)(v42 + 6) - 40;
              v34 = v36 - v33;
              v32 = v38 - v33;
              v36 -= v33;
              v38 -= v33;
            }
            else
            {
              v34 = v36;
            }
            if ( v37 )
            {
              if ( v34 < p___ImageBase[11] || v32 < (unsigned __int64)p___ImageBase[11] || -1 - v32 < v37 )
                goto LABEL_9;
              n64 = 1;
              v3 = ((__int64 (__fastcall *)(__int64, _QWORD, __int64 *, char *))p___ImageBase[4])(
                     p___ImageBase[5],
                     v37 - 1 + v32,
                     &n64,
                     &v41);
              if ( v3 < 0 )
                goto LABEL_19;
              v4 = n64 == 1;
              if ( n64 != 1 )
                goto LABEL_80;
            }
            ++v30;
            n40 += 40;
            if ( v30 >= v28 )
              return 0;
          }
          v4 = n64 == 40;
          goto LABEL_80;
        }
      }
      *((_DWORD *)p___ImageBase + 26) = 3;
      return 0x8000000000000003uLL;
    }
  }
LABEL_80:
  *((_DWORD *)p___ImageBase + 26) = 1;
  if ( !v4 )
    return 0x8000000000000003uLL;
  return v3;
}


/* ============================================================
 * Function: PeCoffGetImageInfoEx
 * Address:  0x16608
 * Source:   BasePeCoff.c
 * Desc:     Get PE/COFF image information
 * ============================================================ */

__int64 __fastcall PeCoffGetImageInfoEx(__int64 *p___ImageBase)
{
  __int64 result; // rax
  char v3; // r9
  int n523_2; // edx
  __int16 n523; // r8
  char v6; // cl
  __int16 v7; // r10
  unsigned int v8; // esi
  __int64 v9; // rax
  unsigned int n6; // eax
  char *v11; // r15
  unsigned __int64 v12; // rdi
  unsigned __int64 v13; // r12
  __int64 v14; // rsi
  bool i; // cf
  __int64 v16; // rcx
  bool v17; // zf
  unsigned __int64 v18; // r14
  unsigned __int64 v19; // rsi
  __int64 v20; // rcx
  unsigned __int64 v21; // r12
  __int64 n40; // r14
  unsigned __int64 v23; // r15
  unsigned __int64 v24; // rdi
  __int64 v25; // rcx
  unsigned __int64 v26; // r8
  unsigned __int64 v27; // rax
  unsigned __int64 v28; // rsi
  __int64 v29; // rcx
  _BYTE v30[12]; // [rsp+20h] [rbp-E0h] BYREF
  int n2; // [rsp+2Ch] [rbp-D4h]
  unsigned int v32; // [rsp+30h] [rbp-D0h]
  int v33; // [rsp+34h] [rbp-CCh]
  int v34; // [rsp+38h] [rbp-C8h]
  _BYTE v35[8]; // [rsp+40h] [rbp-C0h] BYREF
  int v36; // [rsp+48h] [rbp-B8h]
  unsigned int v37; // [rsp+4Ch] [rbp-B4h]
  unsigned int v38; // [rsp+54h] [rbp-ACh]
  __int64 v39; // [rsp+70h] [rbp-90h] BYREF
  __int64 v40; // [rsp+80h] [rbp-80h]
  int n523_1; // [rsp+88h] [rbp-78h]
  int v42; // [rsp+8Ch] [rbp-74h]
  unsigned int v43; // [rsp+90h] [rbp-70h]
  unsigned int v44; // [rsp+94h] [rbp-6Ch]
  __int64 v45; // [rsp+A0h] [rbp-60h]
  unsigned int n6_1; // [rsp+E4h] [rbp-1Ch]
  unsigned int n6_2; // [rsp+F4h] [rbp-Ch]
  char v48; // [rsp+118h] [rbp+18h] BYREF
  char v49; // [rsp+128h] [rbp+28h] BYREF
  __int64 n40_1; // [rsp+1B0h] [rbp+B0h] BYREF

  *((_DWORD *)p___ImageBase + 26) = 0;
  result = PeCoffGetEntryPointEx(p___ImageBase, (__int64)&v39);
  if ( result < 0 )
    return result;
  v3 = BYTE4(v39);
  n523_2 = n523_1;
  if ( WORD2(v39) == 512 && (_WORD)n523_1 == 267 )
    n523 = 523;
  else
    n523 = n523_1;
  v6 = *((_BYTE *)p___ImageBase + 125);
  v7 = HIWORD(v39);
  if ( v6 )
  {
    v8 = HIWORD(v39) - 40;
    v9 = v40 + v8;
  }
  else
  {
    v8 = 0;
    if ( n523 == 267 )
      v9 = HIDWORD(v45);
    else
      v9 = v45;
  }
  *p___ImageBase = v9;
  p___ImageBase[2] = 0;
  *((_DWORD *)p___ImageBase + 16) = 0;
  p___ImageBase[9] = 0;
  p___ImageBase[10] = 0;
  if ( v6 )
  {
    if ( v42 || n523_2 )
      goto LABEL_17;
  }
  else if ( (v40 & 0x1000000000000LL) == 0 )
  {
LABEL_17:
    *((_BYTE *)p___ImageBase + 124) = 0;
    goto LABEL_18;
  }
  *((_BYTE *)p___ImageBase + 124) = 1;
LABEL_18:
  if ( v6 )
  {
    v21 = v43;
    n40 = 40;
    v23 = 0;
    v24 = 0;
    if ( v3 )
    {
      do
      {
        v25 = p___ImageBase[5];
        n40_1 = 40;
        result = ((__int64 (__fastcall *)(__int64, __int64, __int64 *, _BYTE *))p___ImageBase[4])(v25, n40, &n40_1, v35);
        if ( result < 0 )
        {
LABEL_41:
          v17 = n40_1 == 40;
LABEL_42:
          *((_DWORD *)p___ImageBase + 26) = 1;
          if ( !v17 )
            return 0x8000000000000003uLL;
          return result;
        }
        v17 = n40_1 == 40;
        if ( n40_1 != 40 )
          goto LABEL_42;
        if ( v21 < v37
          || v21 >= v36 + v37
          || (v26 = BYTE4(v39), v23 = v21 + v38 - (unsigned __int64)v8 - v37, v24 >= (unsigned __int64)BYTE4(v39) - 1) )
        {
          ++v24;
          v26 = BYTE4(v39);
          if ( v24 == BYTE4(v39) )
            p___ImageBase[1] = v37 + v36 - v8;
          n40 += 40;
        }
        else
        {
          v27 = BYTE4(v39) - 1 - v24;
          v24 = BYTE4(v39) - 1;
          n40 += 40 * v27;
        }
      }
      while ( v24 < v26 );
      if ( v23 )
      {
        v28 = 0;
        if ( v44 )
        {
          while ( 1 )
          {
            v29 = p___ImageBase[5];
            n40_1 = 28;
            result = ((__int64 (__fastcall *)(__int64, unsigned __int64, __int64 *, _BYTE *))p___ImageBase[4])(
                       v29,
                       v28 + v23,
                       &n40_1,
                       v30);
            if ( result < 0 )
            {
LABEL_40:
              v17 = n40_1 == 28;
              goto LABEL_42;
            }
            v17 = n40_1 == 28;
            if ( n40_1 != 28 )
              goto LABEL_42;
            if ( n2 == 2 )
              break;
            v28 += 28LL;
            if ( v28 >= v44 )
              return 0;
          }
          *((_DWORD *)p___ImageBase + 16) = v21 + v28;
        }
      }
    }
  }
  else
  {
    if ( n523 == 267 )
    {
      n6 = n6_1;
      v11 = &v48;
    }
    else
    {
      n6 = n6_2;
      v11 = &v49;
    }
    if ( n6 > 6 )
    {
      v12 = 0;
      v13 = *(unsigned int *)v11;
      v14 = *((unsigned int *)p___ImageBase + 15) + WORD2(v40) + 24LL;
      for ( i = v7 != 0; i; i = v12 < HIWORD(v39) )
      {
        v16 = p___ImageBase[5];
        n40_1 = 40;
        result = ((__int64 (__fastcall *)(__int64, __int64, __int64 *, _BYTE *))p___ImageBase[4])(v16, v14, &n40_1, v35);
        if ( result < 0 )
          goto LABEL_41;
        v17 = n40_1 == 40;
        if ( n40_1 != 40 )
          goto LABEL_42;
        if ( v13 >= v37 && v13 < v37 + v36 )
        {
          v18 = v13 + v38 - (unsigned __int64)v37;
          if ( !v18 )
            return 0;
          v19 = 0;
          if ( !*((_DWORD *)v11 + 1) )
            return 0;
          while ( 1 )
          {
            v20 = p___ImageBase[5];
            n40_1 = 28;
            result = ((__int64 (__fastcall *)(__int64, unsigned __int64, __int64 *, _BYTE *))p___ImageBase[4])(
                       v20,
                       v19 + v18,
                       &n40_1,
                       v30);
            if ( result < 0 )
              goto LABEL_40;
            v17 = n40_1 == 28;
            if ( n40_1 != 28 )
              goto LABEL_42;
            if ( n2 == 2 )
            {
              *((_DWORD *)p___ImageBase + 16) = v13 + v19;
              if ( !v33 )
              {
                if ( v34 )
                  p___ImageBase[1] += v32;
              }
              return 0;
            }
            v19 += 28LL;
            if ( v19 >= *((unsigned int *)v11 + 1) )
              return 0;
          }
        }
        v14 += 40;
        ++v12;
      }
    }
  }
  return 0;
}


/* ============================================================
 * Function: PeCoffLoadImageEx
 * Address:  0x16c9c
 * Source:   BasePeCoff.c
 * Desc:     Load PE/COFF image into memory
 * ============================================================ */

__int64 __fastcall PeCoffLoadImageEx(__int64 *p___ImageBase, __int64 __ImageBase, __int64 n4095, double a4)
{
  __int64 v4; // rsi
  __int64 result; // rax
  __int64 v7; // rcx
  __int64 *v8; // r8
  __int64 v9; // rax
  __int64 v10; // rdx
  unsigned int v11; // r11d
  __int64 __ImageBase_2; // r8
  __int64 v13; // r9
  __int64 __ImageBase_1; // rbx
  unsigned __int64 v15; // rax
  unsigned int *v16; // r13
  __int64 v17; // rax
  __int64 v18; // r12
  __int64 v19; // r10
  unsigned __int64 v20; // rdx
  __int64 v21; // r9
  unsigned __int64 v22; // r14
  __int64 v23; // r14
  unsigned __int64 v24; // r8
  __int64 v25; // r8
  unsigned __int64 v26; // rax
  unsigned __int64 v27; // rax
  __int16 n523; // r8
  unsigned __int64 v29; // rdx
  unsigned __int64 v30; // rcx
  __int64 v31; // rax
  unsigned int v32; // r10d
  unsigned __int64 v33; // rcx
  __int64 v34; // rcx
  unsigned int n5; // eax
  __int64 n164; // rcx
  unsigned __int64 v37; // rax
  unsigned __int64 v38; // r14
  _DWO... [11159 chars total]


/* ============================================================
 * Function: DxeDepexEvaluate
 * Address:  0x17338
 * Source:   Depex.c
 * Desc:     Evaluate DXE dependency expression
 * ============================================================ */

unsigned __int64 __fastcall DxeDepexEvaluate(char a1, char *i, unsigned __int64 *__ImageBase, _DWORD *a4)
{
  double v4; // xmm3_8
  char *ia_1; // rax
  char *ia_2; // r14
  __int64 v10; // rdx
  __int64 __ImageBase_1; // r8
  __int64 v12; // rdi
  __int64 v13; // r8
  __int64 v14; // rdx
  unsigned __int64 __ImageBase_3; // r8
  __int64 v16; // rdx
  __int64 v17; // rdi
  __int64 __ImageBase_2; // r8
  char *ia_3; // rsi
  char *ia_4; // rax
  __int64 v21; // rbx
  __int64 v22; // rdx
  __int64 v23; // r8
  unsigned __int64 __ImageBase_4; // rbx
  char *__ImageBase_5; // rax
  __int64 v26; // rax
  char *__ImageBasea_1; // rax
  __int64 v28; // rax
  char *__ImageBasea_2; // rax
  char *ia; // [rsp+40h] [rbp-29h] BYREF
  unsigned __int64 n232_1; // [rsp+48h] [rbp-21h] BYREF
  unsigned __int64 __ImageBasea; // [rsp+50h] [rbp-19h] BYREF
  __int64 v34; // [rsp+58h] [rbp-11h] BYREF
  __int64 v35; // [rsp+60h] [rbp-9h] BYREF
  unsigned __int64 n232; // [rsp+68h] [rbp-1h] BYREF
  __int64 v37; // [rsp+70h] [rbp+7h] BYREF
  __int64 (__fastcall **v38)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD); // [rsp+78h] [rbp+Fh] BYREF
  __int64 (__fastcall **v39)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD); // [rsp+80h] [rbp+17h] BYREF
  char v40[8]; // [rsp+88h] [rbp+1Fh] BYREF
  __int64 v41; // [rsp+90h] [rbp+27h] BYREF
  char v42; // [rsp+E0h] [rbp+77h] BYREF

  if ( __ImageBase )
  {
    if ( a4 )
    {
      v34 = 0;
      __ImageBasea = 0;
      n232_1 = 0;
      *a4 = 0;
      ia_1 = sub_14284(i, (__int64)i, (__int64)__ImageBase, v4);
      ia_2 = ia_1;
      if ( ia_1 )
      {
        ia = ia_1;
        if ( (*((__int64 (__fastcall **)(unsigned int *, char **, __int64 *))buf_0 + 23))(dst_2, &ia, &v35) >= 0 )
        {
          v12 = Assert_56((__int64)ia, v10, __ImageBase_1, v4);
          if ( v12 )
          {
            if ( (*((__int64 (__fastcall **)(__int64, unsigned int *, __int64 *))buf_0 + 19))(v35, dst_2, &v37) >= 0 )
            {
              __ImageBasea = 0;
              LOBYTE(v13) = 16;
              if ( (*(__int64 (__fastcall **)(__int64, __int64, __int64, _QWORD, unsigned __int64 *, unsigned __int64 *, _DWORD *))(v37 + 24))(
                     v37,
                     v12,
                     v13,
                     0,
                     &__ImageBasea,
                     &n232_1,
                     a4) >= 0 )
                goto LABEL_54;
              if ( __ImageBasea )
              {
                AssertCpuDeadLoop_10(__ImageBasea, v14, __ImageBase_3, v4);
                *a4 = 0;
              }
              __ImageBasea = 0;
              if ( (*(__int64 (__fastcall **)(__int64, __int64, unsigned __int64 *, unsigned __int64 *, char *, char *, _DWORD *))(v37 + 16))(
                     v37,
                     v12,
                     &__ImageBasea,
                     &n232_1,
                     &v42,
                     v40,
                     a4) >= 0 )
                goto LABEL_54;
            }
          }
        }
        ia = ia_2;
        if ( (*((__int64 (__fastcall **)(__int64 *, char **, __int64 *))buf_0 + 23))(&qword_22620, &ia, &v35) < 0 )
          goto LABEL_41;
        if ( (*((__int64 (__fastcall **)(__int64, __int64 *, __int64 *))buf_0 + 19))(v35, &qword_22620, &v41) < 0 )
          goto LABEL_41;
        v17 = (*(__int64 (__fastcall **)(__int64, __int64 *))(v41 + 8))(v41, &v34);
        if ( v17 < 0 )
          goto LABEL_41;
        ia_3 = sub_14284(ia, v16, __ImageBase_2, v4);
        if ( !ia_3 )
        {
          (*(void (__fastcall **)(__int64))(v34 + 16))(v34);
          v17 = 0x8000000000000009uLL;
        }
        ia_4 = ia_3;
        ia = ia_3;
        if ( v17 >= 0 )
        {
          while ( !Assert_51((__int64)ia_4, v14, __ImageBase_3, v4) )
          {
            if ( Assert_83((__int64)ia, v14, __ImageBase_3, v4) != 4
              || Assert_81((__int64)ia, v14, __ImageBase_3, v4) != 4 )
            {
              v17 = 0x8000000000000003uLL;
              break;
            }
            v21 = v34;
            v34 = 0;
            v17 = (*(__int64 (__fastcall **)(__int64, __int64 *, char *, __int64, _QWORD))(v21 + 8))(
                    v21,
                    &v34,
                    ia + 4,
                    1,
                    0);
            (*(void (__fastcall **)(__int64))(v21 + 16))(v21);
            ia_4 = (char *)Assert_73((__int64)ia, v22, v23, v4);
            ia = ia_4;
            if ( v17 < 0 )
              break;
          }
          if ( v17 >= 0 )
          {
            n232 = 0;
            __ImageBase_4 = 0;
            v17 = (*(__int64 (__fastcall **)(__int64, void *, unsigned __int64 *, _QWORD))(v34 + 64))(
                    v34,
                    &unk_22530,
                    &n232,
                    0);
            if ( v17 == 0x8000000000000005uLL )
            {
              __ImageBase_5 = Assert_112(n232, v14, __ImageBase_3, v4);
              __ImageBase_4 = (unsigned __int64)__ImageBase_5;
              if ( !__ImageBase_5 )
              {
                v17 = 0x8000000000000009uLL;
                goto LABEL_36;
              }
              v17 = (*(__int64 (__fastcall **)(__int64, void *, unsigned __int64 *, char *))(v34 + 64))(
                      v34,
                      &unk_22530,
                      &n232,
                      __ImageBase_5);
            }
            if ( v17 >= 0 )
            {
              if ( !__ImageBase_4 )
                goto LABEL_36;
              if ( (*(_BYTE *)(__ImageBase_4 + 72) & 0x10) == 0 )
              {
                __ImageBasea = (unsigned __int64)Assert_112(*(_QWORD *)(__ImageBase_4 + 8), v14, __ImageBase_3, v4);
                __ImageBase_3 = __ImageBasea;
                if ( __ImageBasea )
                {
                  n232_1 = *(_QWORD *)(__ImageBase_4 + 8);
                  v17 = (*(__int64 (__fastcall **)(__int64, unsigned __int64 *, unsigned __int64))(v34 + 32))(
                          v34,
                          &n232_1,
                          __ImageBasea);
                }
                else
                {
                  v17 = 0x8000000000000009uLL;
                }
              }
            }
            if ( __ImageBase_4 )
              AssertCpuDeadLoop_10(__ImageBase_4, v14, __ImageBase_3, v4);
          }
        }
LABEL_36:
        if ( v34 )
          (*(void (__fastcall **)(__int64))(v34 + 16))(v34);
        if ( ia_3 )
          AssertCpuDeadLoop_10((unsigned __int64)ia_3, v14, __ImageBase_3, v4);
        if ( v17 >= 0 )
          goto LABEL_54;
LABEL_41:
        if ( !a1 )
        {
          ia = ia_2;
          if ( (*((__int64 (__fastcall **)(__int64 *, char **, __int64 *))buf_0 + 23))(&qword_227A0, &ia, &v35) >= 0
            && (*((__int64 (__fastcall **)(__int64, __int64 *, __int64 (__fastcall ***)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD)))buf_0
                + 19))(
                 v35,
                 &qword_227A0,
                 &v38) >= 0 )
          {
            n232_1 = 0;
            __ImageBasea = 0;
            v26 = (*v38)(v38, ia, 0, &n232_1, 0);
            if ( v26 == 0x8000000000000005uLL )
            {
              __ImageBasea_1 = Assert_112(n232_1, v14, __ImageBase_3, v4);
              __ImageBasea = (unsigned __int64)__ImageBasea_1;
              if ( !__ImageBasea_1 )
                goto LABEL_48;
              v26 = (*v38)(v38, ia, 0, &n232_1, __ImageBasea_1);
            }
            if ( v26 >= 0 )
            {
LABEL_54:
              *__ImageBase = n232_1;
LABEL_58:
              AssertCpuDeadLoop_10((unsigned __int64)ia_2, v14, __ImageBase_3, v4);
              return __ImageBasea;
            }
          }
        }
LABEL_48:
        ia = ia_2;
        if ( (*((__int64 (__fastcall **)(__int64 *, char **, __int64 *))buf_0 + 23))(&qword_22500, &ia, &v35) >= 0
          && (*((__int64 (__fastcall **)(__int64, __int64 *, __int64 (__fastcall ***)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD)))buf_0
              + 19))(
               v35,
               &qword_22500,
               &v39) >= 0 )
        {
          LOBYTE(__ImageBase_3) = a1;
          n232_1 = 0;
          __ImageBasea = 0;
          v28 = (*v39)(v39, ia, __ImageBase_3, &n232_1, 0);
          if ( v28 == 0x8000000000000005uLL )
          {
            __ImageBasea_2 = Assert_112(n232_1, v14, __ImageBase_3, v4);
            __ImageBasea = (unsigned __int64)__ImageBasea_2;
            if ( !__ImageBasea_2 )
            {
LABEL_57:
              *__ImageBase = 0;
              goto LABEL_58;
            }
            LOBYTE(__ImageBase_3) = a1;
            v28 = (*v39)(v39, ia, __ImageBase_3, &n232_1, __ImageBasea_2);
          }
          if ( v28 >= 0 )
            goto LABEL_54;
        }
        if ( __ImageBasea )
        {
          AssertCpuDeadLoop_10(__ImageBasea, v14, __ImageBase_3, v4);
          __ImageBasea = 0;
        }
        goto LABEL_57;
      }
    }
  }
  return 0;
}


/* ============================================================
 * Function: ProcessFirmwarePerformanceEntry
 * Address:  0x182e8
 * Source:   Performance.c
 * Desc:     Process firmware performance data entries
 * ============================================================ */

void __fastcall ProcessFirmwarePerformanceEntry(__int64 n2, __int64 n3772)
{
  int n2_1; // ebx
  __int64 v3; // rsi
  __int64 v4; // rdi
  int v5; // ebx
  int v6; // ebx
  __int64 n8; // [rsp+48h] [rbp+10h] BYREF

  n2_1 = n2;
  n8 = 8;
  if ( (qword_26538 && (v3 = *(_QWORD *)(qword_26538 + 16)) != 0 && (v4 = *(_QWORD *)(qword_26538 + 8)) != 0
     || (*(__int64 (__fastcall **)(const __int16 *, void *, _QWORD, __int64 *, __int64 *))(qword_26540 + 72))(
          L"FPDT_Volatile",
          &unk_22780,
          0,
          &n8,
          &qword_26538) >= 0
     && (v3 = *(_QWORD *)(qword_26538 + 16)) != 0
     && (v4 = *(_QWORD *)(qword_26538 + 8)) != 0)
    && *(_DWORD *)v4 == 1414545990
    && *(_WORD *)(v4 + 8) == 2 )
  {
    if ( n2_1 )
    {
      v5 = n2_1 - 1;
      if ( v5 )
      {
        v6 = v5 - 1;
        if ( v6 )
        {
          if ( v6 == 1 )
            *(_QWORD *)(v4 + 48) = v3 * sub_1A5A0(n2, n3772) / 0xF4240uLL;
        }
        else
        {
          *(_QWORD *)(v4 + 40) = v3 * sub_1A5A0(n2, n3772) / 0xF4240uLL;
        }
      }
      else
      {
        *(_QWORD *)(v4 + 32) = v3 * sub_1A5A0(n2, n3772) / 0xF4240uLL;
      }
    }
    else
    {
      *(_QWORD *)(v4 + 24) = v3 * sub_1A5A0(n2, n3772) / 0xF4240uLL;
    }
  }
}


/* ============================================================
 * Function: ReportFirmwarePerformanceEvent
 * Address:  0x182b8
 * Source:   Performance.c
 * Desc:     Report firmware performance event via status code
 * ============================================================ */

unsigned __int64 __fastcall ReportFirmwarePerformanceEvent(__int64 a1, __int64 a2, __int64 a3)
{
  ReportStatusCode(0x40000002u, 0x3111000u, a3, (__int64)&unk_22760, 0);
  return 0xA000000000000002uLL;
}