// === 0xffde398e ===
char __cdecl MemMgrInit(_DWORD *a1, int n0x10000)
{
  char result; // al

  if ( a1 ) /*0xffde3996*/
  {
    a1[2] = 0; /*0xffde39d2*/
    *a1 = a1 + 5; /*0xffde39d9*/
    a1[4] = a1 + 5; /*0xffde39db*/
    a1[1] = n0x10000 - 20; /*0xffde39e1*/
    a1[3] = (char *)a1 + n0x10000 - 8; /*0xffde39e6*/
    if ( DebugEnabled() && DebugLevelEnabled(64) ) /*0xffde39f6*/
      DebugPrint(64, "\n===>\nMem Mgr Init:\nHeap Start= %08X(sz %X)\n", *a1, a1[1] - 8); /*0xffde3a0f*/
    if ( DebugEnabled() && DebugLevelEnabled(64) ) /*0xffde3a21*/
      DebugPrint(64, "Heap End  = %08X\n", a1[3]); /*0xffde3a34*/
    result = DebugEnabled(); /*0xffde3a3c*/
    if ( result ) /*0xffde3a43*/
    {
      result = DebugLevelEnabled(64); /*0xffde3a46*/
      if ( result ) /*0xffde3a4e*/
        return DebugPrint(64, "Desc Start= %08X(sz %X)\n<===\n", a1[3], 8); /*0xffde3a5b*/
    }
  }
  else
  {
    result = DebugEnabled(); /*0xffde3998*/
    if ( result ) /*0xffde399f*/
    {
      result = DebugLevelEnabled(64); /*0xffde39a9*/
      if ( result ) /*0xffde39b1*/
        return DebugPrint(64, "\n===>\n!!! Heap Addr %X !!!\n<===\n", 0); /*0xffde39be*/
    }
  }
  return result; /*0xffde3a63*/
}

// === 0xffde3004 ===
void *__cdecl SetMem(void *buf, unsigned int count, char value)
{
  memset(buf, value, count); /*0xffde3011*/
  return buf; /*0xffde3017*/
}

// === 0xffde3024 ===
void *__cdecl SetMemZero(void *buf, unsigned int n80)
{
  memset(buf, 0, n80); /*0xffde303b*/
  return buf; /*0xffde3042*/
}

// === 0xffde3064 ===
void *__cdecl SetMem32(void *buf, unsigned int count, int value)
{
  memset32(buf, value, count); /*0xffde3071*/
  return buf; /*0xffde3077*/
}

// === 0xffde3044 ===
int __cdecl SetMem32Loop(int a1, int a2, int a3, int a4)
{
  do /*0xffde305d*/
  {
    *(_DWORD *)(a1 + 8 * a2 - 8) = a3; /*0xffde3055*/
    *(_DWORD *)(a1 + 8 * a2-- - 4) = a4; /*0xffde3059*/
  }
  while ( a2 ); /*0xffde305d*/
  return a1; /*0xffde3061*/
}

// === 0xffde3585 ===
int __cdecl CompareMem(int ZeroPool, int ZeroPool_1, int n32)
{
  int DebugPeiServicesPtr; // eax
  int v4; // eax
  int v5; // eax
  int v6; // eax

  if ( !n32 || ZeroPool == ZeroPool_1 ) /*0xffde359e*/
    return 0; /*0xffde3637*/
  if ( !ZeroPool ) /*0xffde35ac*/
  {
    DebugPeiServicesPtr = GetDebugPeiServicesPtr(); /*0xffde35ae*/
    if ( DebugPeiServicesPtr ) /*0xffde35b5*/
      (*(void (__cdecl **)(const char *, int, const char *))(DebugPeiServicesPtr + 4))( /*0xffde35bf*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
        60,
        "DestinationBuffer != ((void *) 0)");
  }
  if ( !ZeroPool_1 ) /*0xffde35c7*/
  {
    v4 = GetDebugPeiServicesPtr(); /*0xffde35c9*/
    if ( v4 ) /*0xffde35d0*/
      (*(void (__cdecl **)(const char *, int, const char *))(v4 + 4))( /*0xffde35da*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
        61,
        "SourceBuffer != ((void *) 0)");
  }
  if ( n32 - 1 > (unsigned int)~ZeroPool ) /*0xffde35e9*/
  {
    v5 = GetDebugPeiServicesPtr(); /*0xffde35eb*/
    if ( v5 ) /*0xffde35f2*/
      (*(void (__cdecl **)(const char *, int, const char *))(v5 + 4))( /*0xffde3600*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
        62,
        "(Length - 1) <= (0xFFFFFFFF - (UINTN)DestinationBuffer)");
  }
  if ( n32 - 1 > (unsigned int)~ZeroPool_1 ) /*0xffde360d*/
  {
    v6 = GetDebugPeiServicesPtr(); /*0xffde360f*/
    if ( v6 ) /*0xffde3616*/
      (*(void (__cdecl **)(const char *, int, const char *))(v6 + 4))( /*0xffde3624*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
        63,
        "(Length - 1) <= (0xFFFFFFFF - (UINTN)SourceBuffer)");
  }
  return InternalCompareMem((_BYTE *)ZeroPool, (_BYTE *)ZeroPool_1, n32); /*0xffde3639*/
}

// === 0xffde3699 ===
char *__cdecl CopyMem(int dst, int src, unsigned int n64)
{
  int DebugPeiServicesPtr; // eax
  int v5; // eax

  if ( !n64 ) /*0xffde36a0*/
    return (char *)dst; /*0xffde36a2*/
  if ( n64 - 1 > ~dst ) /*0xffde36bd*/
  {
    DebugPeiServicesPtr = GetDebugPeiServicesPtr(); /*0xffde36bf*/
    if ( DebugPeiServicesPtr ) /*0xffde36c6*/
      (*(void (__cdecl **)(const char *, int, const char *))(DebugPeiServicesPtr + 4))( /*0xffde36d0*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
        56,
        "(Length - 1) <= (0xFFFFFFFF - (UINTN)DestinationBuffer)");
  }
  if ( n64 - 1 > ~src ) /*0xffde36de*/
  {
    v5 = GetDebugPeiServicesPtr(); /*0xffde36e0*/
    if ( v5 ) /*0xffde36e7*/
      (*(void (__cdecl **)(const char *, int, const char *))(v5 + 4))( /*0xffde36f1*/
        "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
        57,
        "(Length - 1) <= (0xFFFFFFFF - (UINTN)SourceBuffer)");
  }
  if ( dst == src ) /*0xffde36fb*/
    return (char *)dst; /*0xffde36fd*/
  else
    return InternalCopyMem((char *)dst, (char *)src, n64); /*0xffde3707*/
}

// === 0xffde2fa4 ===
int __cdecl InternalCompareMem(_BYTE *ZeroPool, _BYTE *a2, int n32)
{
  bool v6; // zf

  do /*0xffde2fb2*/
  {
    if ( !n32 ) /*0xffde2fb2*/
      break; /*0xffde2fb2*/
    v6 = *ZeroPool++ == *a2++; /*0xffde2fb2*/
    --n32; /*0xffde2fb2*/
  }
  while ( v6 ); /*0xffde2fb2*/
  return (unsigned __int8)*(ZeroPool - 1) - (unsigned __int8)*(a2 - 1); /*0xffde2fbe*/
}

// === 0xffde2fc4 ===
char *__cdecl InternalCopyMem(char *dst, char *src, unsigned int n64)
{
  unsigned int n64_1; // edx
  char *dst_1; // edi
  char *src_1; // esi

  n64_1 = n64; /*0xffde2fce*/
  if ( src < dst && &src[n64 - 1] >= dst ) /*0xffde2fdc*/
  {
    src_1 = &src[n64 - 1]; /*0xffde2ff0*/
    dst_1 = &dst[n64 - 1]; /*0xffde2ff2*/
  }
  else
  {
    n64_1 = n64 & 3; /*0xffde2fe0*/
    qmemcpy(dst, src, 4 * (n64 >> 2)); /*0xffde2fe9*/
    src_1 = &src[4 * (n64 >> 2)]; /*0xffde2fe9*/
    dst_1 = &dst[4 * (n64 >> 2)]; /*0xffde2fe9*/
  }
  qmemcpy(dst_1, src_1, n64_1); /*0xffde2ff9*/
  return dst; /*0xffde3000*/
}

// === 0xffde3a66 ===
int __cdecl Sha256Transform(int a1, int a2)
{
  unsigned __int8 *v2; // edx
  int i; // esi
  int v4; // eax
  int v5; // ecx
  unsigned int *v6; // edi
  int n48; // ebp
  unsigned int v8; // ecx
  unsigned int v9; // edx
  int v10; // edi
  int n256; // ecx
  _DWORD *v12; // ebp
  int v13; // ebx
  int v14; // esi
  int v15; // edx
  int v16; // eax
  int n8; // ebx
  int v19; // [esp+10h] [ebp-130h]
  int n256_1; // [esp+14h] [ebp-12Ch]
  _DWORD dst[8]; // [esp+18h] [ebp-128h] BYREF
  _DWORD *v22; // [esp+38h] [ebp-108h]
  int n8_1; // [esp+3Ch] [ebp-104h]
  _DWORD v24[14]; // [esp+40h] [ebp-100h]
  char v25; // [esp+78h] [ebp-C8h] BYREF

  n8_1 = 0; /*0xffde3a83*/
  v22 = (_DWORD *)(a1 + 8); /*0xffde3a8c*/
  v2 = (unsigned __int8 *)(a2 + 2); /*0xffde3a94*/
  qmemcpy(dst, (const void *)(a1 + 8), sizeof(dst)); /*0xffde3a97*/
  for ( i = 0; i < 16; ++i ) /*0xffde3a99*/
  {
    v4 = *v2; /*0xffde3aa8*/
    v5 = (*(v2 - 1) | (*(v2 - 2) << 8)) << 8; /*0xffde3aab*/
    v2 += 4; /*0xffde3aae*/
    v24[i] = *(v2 - 3) | ((v4 | v5) << 8); /*0xffde3abc*/
  }
  v6 = (unsigned int *)&v25; /*0xffde3ac8*/
  n48 = 48; /*0xffde3acc*/
  do /*0xffde3b05*/
  {
    v8 = *(v6 - 13); /*0xffde3acd*/
    v9 = *v6++; /*0xffde3ad2*/
    v6[1] = *(v6 - 6) /*0xffde3aff*/
          + *(v6 - 15)
          + ((v9 >> 10) ^ __ROL4__(v9, 13) ^ __ROL4__(v9, 15))
          + ((v8 >> 3) ^ __ROR4__(v8, 7) ^ __ROL4__(v8, 14));
    --n48; /*0xffde3b02*/
  }
  while ( n48 ); /*0xffde3b05*/
  v10 = dst[0]; /*0xffde3b07*/
  n256 = 0; /*0xffde3b0b*/
  v12 = v22; /*0xffde3b11*/
  v19 = dst[3]; /*0xffde3b15*/
  v13 = dst[4]; /*0xffde3b19*/
  n256_1 = 0; /*0xffde3b1d*/
  do /*0xffde3bc0*/
  {
    v14 = dst[7] /*0xffde3b52*/
        + *(_DWORD *)((char *)v24 + n256)
        + *(int *)((char *)&dword_FFDE3F74 + n256)
        + (dst[6] ^ v13 & (dst[6] ^ dst[5]))
        + (__ROR4__(v13, 6) ^ __ROL4__(v13, 7) ^ __ROR4__(v13, 11));
    v15 = v14 + (__ROR4__(v10, 2) ^ __ROL4__(v10, 10) ^ __ROR4__(v10, 13)) + (v10 & dst[1] | dst[2] & (v10 | dst[1])); /*0xffde3b7f*/
    dst[7] = dst[6]; /*0xffde3b81*/
    dst[6] = dst[5]; /*0xffde3b8d*/
    n256 = n256_1 + 4; /*0xffde3b91*/
    dst[5] = v13; /*0xffde3b98*/
    v13 = v14 + v19; /*0xffde3b9c*/
    v19 = dst[2]; /*0xffde3ba0*/
    dst[3] = dst[2]; /*0xffde3ba4*/
    v16 = dst[1]; /*0xffde3ba8*/
    dst[1] = v10; /*0xffde3bac*/
    v10 = v15; /*0xffde3bb0*/
    dst[2] = v16; /*0xffde3bb2*/
    n256_1 = n256; /*0xffde3bb6*/
  }
  while ( n256 < 256 ); /*0xffde3bc0*/
  dst[4] = v13; /*0xffde3bc6*/
  n8 = n8_1; /*0xffde3bca*/
  dst[0] = v15; /*0xffde3bce*/
  do /*0xffde3be0*/
    *v12++ += dst[n8++]; /*0xffde3bd6*/
  while ( n8 < 8 ); /*0xffde3be0*/
  return 0; /*0xffde3be2*/
}

// === 0xffde3ce3 ===
_DWORD *__cdecl Sha256Init(_DWORD *a1)
{
  a1[10] = 0; /*0xffde3ce9*/
  *a1 = 0; /*0xffde3cec*/
  a1[1] = 0; /*0xffde3cee*/
  a1[2] = 1779033703; /*0xffde3cf1*/
  a1[3] = -1150833019; /*0xffde3cf8*/
  a1[4] = 1013904242; /*0xffde3cff*/
  a1[5] = -1521486534; /*0xffde3d06*/
  a1[6] = 1359893119; /*0xffde3d0d*/
  a1[7] = -1694144372; /*0xffde3d14*/
  a1[8] = 528734635; /*0xffde3d1b*/
  a1[9] = 1541459225; /*0xffde3d22*/
  return a1; /*0xffde3d29*/
}

// === 0xffde3d2a ===
int __cdecl Sha256Update(int a1, int src, unsigned int n0x40)
{
  unsigned int n0x40_1; // ebx
  unsigned int n0x40_2; // esi

  if ( *(_DWORD *)(a1 + 40) >= 0x40u ) /*0xffde3d33*/
    return -1; /*0xffde3d39*/
  n0x40_1 = n0x40; /*0xffde3d3b*/
  if ( !n0x40 ) /*0xffde3d43*/
    return 0; /*0xffde3ddb*/
  while ( !*(_DWORD *)(a1 + 40) && n0x40_1 >= 0x40 ) /*0xffde3d56*/
  {
    CopyMem(a1 + 44, src, 0x40u); /*0xffde3d5f*/
    if ( Sha256Transform(a1, a1 + 44) < 0 ) /*0xffde3d70*/
      return -1; /*0xffde3d70*/
    *(_QWORD *)a1 += 512LL; /*0xffde3d72*/
    src += 64; /*0xffde3d7c*/
    n0x40_1 -= 64; /*0xffde3d7f*/
LABEL_13:
    if ( !n0x40_1 ) /*0xffde3dcf*/
      return 0; /*0xffde3dcf*/
  }
  n0x40_2 = 64 - *(_DWORD *)(a1 + 40); /*0xffde3d8a*/
  if ( n0x40_1 < n0x40_2 ) /*0xffde3d8f*/
    n0x40_2 = n0x40_1; /*0xffde3d8f*/
  CopyMem(a1 + *(_DWORD *)(a1 + 40) + 44, src, n0x40_2); /*0xffde3d9a*/
  *(_DWORD *)(a1 + 40) += n0x40_2; /*0xffde3d9f*/
  src += n0x40_2; /*0xffde3da5*/
  n0x40_1 -= n0x40_2; /*0xffde3da7*/
  if ( *(_DWORD *)(a1 + 40) != 64 ) /*0xffde3dad*/
    goto LABEL_13; /*0xffde3dad*/
  if ( Sha256Transform(a1, a1 + 44) >= 0 ) /*0xffde3dbd*/
  {
    *(_QWORD *)a1 += 512LL; /*0xffde3dbf*/
    *(_DWORD *)(a1 + 40) = 0; /*0xffde3dc9*/
    goto LABEL_13; /*0xffde3dc9*/
  }
  return -1; /*0xffde3d38*/
}

// === 0xffde3bef ===
int __cdecl Sha256Final(int *a1, int a2)
{
  unsigned int n0x40; // ecx
  bool v4; // cf
  unsigned int n0x40_1; // eax
  int v6; // edx
  int v7; // ebx
  int v8; // ecx
  _BYTE *v9; // edx
  int *v10; // esi
  int n8; // edi
  int v12; // ecx
  unsigned int v13; // eax

  n0x40 = a1[10]; /*0xffde3bf4*/
  if ( n0x40 >= 0x40 ) /*0xffde3bfa*/
    return -1; /*0xffde3bfc*/
  v4 = __CFADD__(8 * n0x40, *a1); /*0xffde3c08*/
  *a1 += 8 * n0x40; /*0xffde3c08*/
  a1[1] += v4; /*0xffde3c0d*/
  *((_BYTE *)a1 + n0x40 + 44) = 0x80; /*0xffde3c10*/
  n0x40_1 = ++a1[10]; /*0xffde3c18*/
  if ( n0x40_1 > 0x38 ) /*0xffde3c1e*/
  {
    while ( n0x40_1 < 0x40 ) /*0xffde3c2f*/
    {
      *((_BYTE *)a1 + n0x40_1 + 44) = 0; /*0xffde3c22*/
      n0x40_1 = ++a1[10]; /*0xffde3c29*/
    }
    Sha256Transform((int)a1, (int)(a1 + 11)); /*0xffde3c36*/
    a1[10] = 0; /*0xffde3c3d*/
  }
  while ( (unsigned int)a1[10] < 0x38 ) /*0xffde3c50*/
    *((_BYTE *)a1 + a1[10]++ + 44) = 0; /*0xffde3c45*/
  v6 = a1[1]; /*0xffde3c52*/
  v7 = *a1; /*0xffde3c57*/
  v8 = *a1; /*0xffde3c59*/
  *((_BYTE *)a1 + 100) = HIBYTE(v6); /*0xffde3c5e*/
  *((_BYTE *)a1 + 101) = BYTE2(v6); /*0xffde3c66*/
  *((_BYTE *)a1 + 102) = BYTE1(v6); /*0xffde3c6e*/
  *((_BYTE *)a1 + 103) = v6; /*0xffde3c77*/
  *((_BYTE *)a1 + 104) = HIBYTE(v8); /*0xffde3c7d*/
  *((_BYTE *)a1 + 107) = v7; /*0xffde3c84*/
  *((_BYTE *)a1 + 105) = BYTE2(v7); /*0xffde3c90*/
  *((_BYTE *)a1 + 106) = BYTE1(v7); /*0xffde3c97*/
  Sha256Transform((int)a1, (int)(a1 + 11)); /*0xffde3ca2*/
  v9 = (_BYTE *)(a2 + 2); /*0xffde3caf*/
  v10 = a1 + 2; /*0xffde3cb2*/
  n8 = 8; /*0xffde3cb5*/
  do /*0xffde3cdb*/
  {
    v12 = *v10; /*0xffde3cb6*/
    v13 = HIBYTE(*v10++); /*0xffde3cba*/
    *(v9 - 2) = v13; /*0xffde3cc0*/
    *(v9 - 1) = BYTE2(v12); /*0xffde3cc8*/
    *v9 = BYTE1(v12); /*0xffde3cd0*/
    v9 += 4; /*0xffde3cd2*/
    *(v9 - 3) = v12; /*0xffde3cd5*/
    --n8; /*0xffde3cd8*/
  }
  while ( n8 ); /*0xffde3cdb*/
  return 0; /*0xffde3bff*/
}

// === 0xffde3963 ===
int Sha256ContextSize()
{
  return 112; /*0xffde3966*/
}

// === 0xffde3967 ===
char __cdecl Sha256InitWrapper(_DWORD *a1)
{
  Sha256Init(a1); /*0xffde396b*/
  return 1; /*0xffde3973*/
}

// === 0xffde3974 ===
BOOL __cdecl Sha256UpdateWrapper(int a1, int src, unsigned int n0x40)
{
  return Sha256Update(a1, src, n0x40) == 0; /*0xffde398d*/
}

// === 0xffde394e ===
BOOL __cdecl Sha256FinalWrapper(int *a1, int a2)
{
  return Sha256Final(a1, a2) == 0; /*0xffde3962*/
}

// === 0xffde34e6 ===
int DebugPrint(int a1, const char *a2, ...)
{
  int result; // eax
  int (__cdecl **v3)(int, const char *, char *); // esi
  va_list va; // [esp+10h] [ebp+Ch] BYREF

  va_start(va, a2);
  result = GetDebugPeiServicesPtr(); /*0xffde34e7*/
  v3 = (int (__cdecl **)(int, const char *, char *))result; /*0xffde34ec*/
  if ( result ) /*0xffde34f0*/
  {
    result = GetDebugLevel(); /*0xffde34f2*/
    if ( (result & a1) != 0 ) /*0xffde34fd*/
      return (*v3)(a1, a2, (char *)va); /*0xffde3509*/
  }
  return result; /*0xffde350e*/
}

// === 0xffde34b5 ===
int GetDebugPeiServicesPtr()
{
  int PeiServices; // eax
  _BYTE v2[4]; // [esp+0h] [ebp-8h] BYREF
  int v3; // [esp+4h] [ebp-4h] BYREF

  PeiServices = GetPeiServices(); /*0xffde34ba*/
  if ( (*(int (__cdecl **)(int, void *, _DWORD, _BYTE *, int *))(*(_DWORD *)PeiServices + 32))( /*0xffde34d9*/
         PeiServices,
         &unk_FFDE4C5C,
         0,
         v2,
         &v3) >= 0 )
    return v3; /*0xffde34df*/
  else
    return 0; /*0xffde34db*/
}

// === 0xffde3510 ===
int __fastcall DebugAssert(
        int e:__hs__MdePkg__Library__BaseLib__X86ReadIdtr.c,
        int n37,
        const char *PeiServices____((void__)_0))
{
  int result; // eax

  result = GetDebugPeiServicesPtr(); /*0xffde3516*/
  if ( result ) /*0xffde351d*/
    return (*(int (__cdecl **)(int, int, const char *))(result + 4))( /*0xffde3525*/
             e:__hs__MdePkg__Library__BaseLib__X86ReadIdtr.c,
             n37,
             PeiServices____((void__)_0));
  return result; /*0xffde352b*/
}

// === 0xffde3572 ===
int DebugClear()
{
  int PeiServices; // eax

  PeiServices = GetPeiServices(); /*0xffde3572*/
  return (*(int (__cdecl **)(int, void *))(*(_DWORD *)PeiServices + 24))(PeiServices, &unk_FFDE4CB8); /*0xffde3584*/
}

// === 0xffde3446 ===
int __cdecl GetPcdPei()
{
  int PeiServices; // eax
  int v1; // eax
  int DebugPeiServicesPtr; // eax
  int v4; // [esp+0h] [ebp-4h] BYREF

  PeiServices = GetPeiServices(); /*0xffde344a*/
  v4 = (int)&v4; /*0xffde3452*/
  v1 = (*(int (__cdecl **)(int, void *, _DWORD, _DWORD))(*(_DWORD *)PeiServices + 32))(PeiServices, &unk_FFDE4C9C, 0, 0); /*0xffde345f*/
  if ( v1 < 0 ) /*0xffde3467*/
  {
    DebugPrint(0x80000000, "\nASSERT_EFI_ERROR (Status = %r)\n", v1); /*0xffde3474*/
    DebugPeiServicesPtr = GetDebugPeiServicesPtr(); /*0xffde347c*/
    if ( DebugPeiServicesPtr ) /*0xffde3483*/
      (*(void (__cdecl **)(const char *, int, const char *))(DebugPeiServicesPtr + 4))( /*0xffde3491*/
        "e:\\hs\\MdePkg\\Library\\PeiPcdLib\\PeiPcdLib.c",
        49,
        "!EFI_ERROR (Status)");
  }
  return v4; /*0xffde349c*/
}

// === 0xffde3791 ===
int GetDebugLevel()
{
  unsigned __int8 v0; // al
  char n3; // al
  char n3_1; // cl

  v0 = __inbyte(0x70u); /*0xffde3797*/
  __outbyte(0x70u, v0 & 0x80 | 0x4A); /*0xffde379c*/
  n3 = __inbyte(0x71u); /*0xffde37a3*/
  n3_1 = n3; /*0xffde37a4*/
  if ( (unsigned __int8)n3 <= 3u ) /*0xffde37a9*/
  {
LABEL_4:
    if ( !n3_1 ) /*0xffde37c4*/
      return 0; /*0xffde37c4*/
    goto LABEL_5; /*0xffde37c4*/
  }
  n3_1 = n3; /*0xffde37ab*/
  if ( !n3 ) /*0xffde37b3*/
  {
    n3_1 = MEMORY[0xFDAF0490] & 2 | 1; /*0xffde37bf*/
    goto LABEL_4; /*0xffde37bf*/
  }
LABEL_5:
  if ( n3_1 != -1 )
    return n3_1 != 1 ? -2147483578 : -2147483644;
  return 0; /*0xffde37dc*/
}

// === 0xffde352e ===
char __cdecl DebugEnabled()
{
  return 1; /*0xffde3530*/
}

// === 0xffde3531 ===
bool __cdecl DebugLevelEnabled(int a1)
{
  return a1 != 0; /*0xffde3539*/
}

// === 0xffde349e ===
int __cdecl SetPcd(int n15, int a2)
{
  int PcdPei; // eax

  PcdPei = GetPcdPei(); /*0xffde349e*/
  (*(void (__cdecl **)(int, int))(PcdPei + 68))(n15, a2); /*0xffde34ab*/
  return a2; /*0xffde34b4*/
}

// === 0xffde37e0 ===
int GetPeiServices()
{
  int v0; // esi
  _BYTE v2[2]; // [esp+4h] [ebp-8h] BYREF
  int v3; // [esp+6h] [ebp-6h]

  ReadIdtr(v2); /*0xffde37e9*/
  v0 = *(_DWORD *)(v3 - 4); /*0xffde37f1*/
  if ( !v0 ) /*0xffde37f6*/
    DebugAssert( /*0xffde3805*/
      (int)"e:\\hs\\MdePkg\\Library\\PeiServicesTablePointerLibIdt\\PeiServicesTablePointer.c",
      48,
      "PeiServices != ((void *) 0)");
  return v0; /*0xffde380d*/
}

// === 0xffde3812 ===
void *__thiscall ReadIdtr(void *this)
{
  void *this_1; // eax

  if ( !this ) /*0xffde3818*/
    DebugAssert((int)"e:\\hs\\MdePkg\\Library\\BaseLib\\X86ReadIdtr.c", 37, "Idtr != ((void *) 0)"); /*0xffde3827*/
  this_1 = this; /*0xffde382d*/
  __sidt(this); /*0xffde3830*/
  return this_1; /*0xffde3834*/
}

// === 0xffde3765 ===
__int64 __thiscall ReadUnaligned64(void *this)
{
  int DebugPeiServicesPtr; // eax

  if ( !this ) /*0xffde376a*/
  {
    DebugPeiServicesPtr = GetDebugPeiServicesPtr(); /*0xffde376c*/
    if ( DebugPeiServicesPtr ) /*0xffde3773*/
      (*(void (__cdecl **)(const char *, int, const char *))(DebugPeiServicesPtr + 4))( /*0xffde3784*/
        "e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
        192,
        "Buffer != ((void *) 0)");
  }
  return *(_QWORD *)this; /*0xffde378f*/
}

// === 0xffde3121 ===
int __cdecl LocateBootGuardHashKey(int p_ZeroPool)
{
  int v1; // ecx
  int v2; // esi
  int v3; // edi
  int result; // eax
  int v5; // [esp+10h] [ebp-8h] BYREF
  int v6; // [esp+14h] [ebp-4h] BYREF

  v2 = v1; /*0xffde312c*/
  v5 = 0; /*0xffde3135*/
  v3 = 0; /*0xffde313c*/
  (*(void (__cdecl **)(int, _DWORD, int *))(*(_DWORD *)v1 + 56))(v1, 0, &v6); /*0xffde3140*/
  result = (*(int (__cdecl **)(int, _DWORD, int *))(*(_DWORD *)v2 + 56))(v2, 0, &v6); /*0xffde314f*/
  if ( result >= 0 ) /*0xffde3157*/
  {
    while ( 2 ) /*0xffde315e*/
    {
      v5 = 0; /*0xffde315e*/
      while ( (*(int (__cdecl **)(int, int, int, int *))(*(_DWORD *)v2 + 60))(v2, 2, v6, &v5) != -2147483634 ) /*0xffde3188*/
      {
        if ( IsBootGuardHashGuid(v5) ) /*0xffde3169*/
        {
          result = (*(int (__cdecl **)(int, int, int, int))(*(_DWORD *)v2 + 64))(v2, 25, v5, p_ZeroPool); /*0xffde31ac*/
          if ( result < 0 ) /*0xffde31b4*/
            return -2147483634; /*0xffde31b6*/
          return result; /*0xffde31b6*/
        }
      }
      result = (*(int (__cdecl **)(int, int, int *))(*(_DWORD *)v2 + 56))(v2, ++v3, &v6); /*0xffde3194*/
      if ( result >= 0 ) /*0xffde319c*/
        continue; /*0xffde319c*/
      break;
    }
  }
  return result; /*0xffde31b8*/
}

// === 0xffde363d ===
bool __thiscall IsBootGuardHashGuid(int this)
{
  __int64 Unaligned64; // rax
  int Unaligned64_1; // ebx
  __int64 Unaligned64_3; // rax
  int Unaligned64_2; // edi
  __int64 v6; // kr00_8
  __int64 v7; // rax
  int v9; // [esp+10h] [ebp-8h]
  int v10; // [esp+14h] [ebp-4h]

  Unaligned64 = ReadUnaligned64((void *)this); /*0xffde3645*/
  v10 = HIDWORD(Unaligned64); /*0xffde364f*/
  Unaligned64_1 = Unaligned64; /*0xffde3653*/
  Unaligned64_3 = ReadUnaligned64(&unk_FFDE4CC4); /*0xffde3655*/
  v9 = HIDWORD(Unaligned64_3); /*0xffde365d*/
  Unaligned64_2 = Unaligned64_3; /*0xffde3661*/
  v6 = ReadUnaligned64((void *)(this + 8)); /*0xffde366f*/
  v7 = ReadUnaligned64(&unk_FFDE4CCC); /*0xffde3671*/
  return Unaligned64_1 == Unaligned64_2 && v10 == v9 && v6 == v7; /*0xffde3692*/
}

// === 0xffde353a ===
void *__thiscall AllocatePool(void *this)
{
  int PeiServices; // eax

  PeiServices = GetPeiServices(); /*0xffde353e*/
  if ( (*(int (__stdcall **)(int))(*(_DWORD *)PeiServices + 76))(PeiServices) >= 0 ) /*0xffde3554*/
    return this; /*0xffde355a*/
  else
    return 0; /*0xffde3556*/
}

// === 0xffde3561 ===
int __thiscall AllocateZeroPool(void *this)
{
  int buf_1; // eax
  void *buf; // esi
  int DebugPeiServicesPtr; // eax

  buf_1 = (int)AllocatePool(this); /*0xffde3561*/
  if ( buf_1 ) /*0xffde3568*/
  {
    buf = (void *)buf_1; /*0xffde3715*/
    if ( (unsigned int)-buf_1 < 0x50 ) /*0xffde373f*/
    {
      DebugPeiServicesPtr = GetDebugPeiServicesPtr(); /*0xffde3741*/
      if ( DebugPeiServicesPtr ) /*0xffde3748*/
        (*(void (__cdecl **)(const char *, int, const char *))(DebugPeiServicesPtr + 4))( /*0xffde3752*/
          "e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\ZeroMemWrapper.c",
          54,
          "Length <= (0xFFFFFFFF - (UINTN)Buffer + 1)");
    }
    return (int)SetMemZero(buf, 0x50u); /*0xffde375b*/
  }
  return buf_1; /*0xffde3571*/
}

// === 0xffde3e04 ===
unsigned int __stdcall Udiv64(unsigned __int64 a1, __int64 a2)
{
  unsigned int v2; // ecx
  unsigned __int64 v3; // rax
  unsigned int v4; // ebx
  unsigned int v5; // ebx
  unsigned __int64 v6; // rax
  unsigned __int64 v8; // rtt

  v2 = HIDWORD(a2); /*0xffde3e04*/
  if ( HIDWORD(a2) ) /*0xffde3e0a*/
  {
    v3 = a1; /*0xffde3e14*/
    v4 = a2; /*0xffde3e1c*/
    do /*0xffde3e2a*/
    {
      v3 >>= 1; /*0xffde3e20*/
      v4 = __PAIR64__(v2, v4) >> 1; /*0xffde3e24*/
      v2 >>= 1; /*0xffde3e28*/
    }
    while ( v2 ); /*0xffde3e2a*/
    v5 = v3 / v4; /*0xffde3e2e*/
    v6 = (unsigned int)a2 * (unsigned __int64)v5; /*0xffde3e34*/
    if ( __CFADD__(v5 * HIDWORD(a2), HIDWORD(v6)) || (HIDWORD(v6) = (a2 * (unsigned __int64)v5) >> 32, a1 < v6) ) /*0xffde3e47*/
      --v5; /*0xffde3e49*/
    return v5; /*0xffde3e58*/
  }
  else
  {
    LODWORD(v8) = a1; /*0xffde3e74*/
    HIDWORD(v8) = HIDWORD(a1) % (unsigned int)a2; /*0xffde3e74*/
    return v8 / (unsigned int)a2; /*0xffde3e74*/
  }
}