/*
 *Recovery - Decompiled Recovery
 *Source: Auto-generated from IDA Pro decompilation
 *
 *Decompiled from port 13402
 */

#include "Recovery.h"

/*
 *InternalMemCopyMem at 0x260
 */
char *InternalMemCopyMem(char *dst, char *src, unsigned int count)
{
 unsigned int count_1; // edx char *dst_1; // edi char *src_1; // esi count_1 = count; /*0x26a*/
 if ( src < dst && &src[count - 1] >= dst ) /*0x278*/
 {
 src_1 = &src[count - 1]; /*0x28c*/
 dst_1 = &dst[count - 1]; /*0x28e*/
 }
 else
 {
 count_1 = count & 3; /*0x27c*/
 qmemcpy(dst, src, 4 * (count >> 2)); /*0x285*/
 src_1 = &src[4 * (count >> 2)]; /*0x285*/
 dst_1 = &dst[4 * (count >> 2)]; /*0x285*/
 }
 qmemcpy(dst_1, src_1, count_1); /*0x295*/
 return dst; /*0x29c*/
}

/*
 *SetMem at 0x2c0
 */
void *SetMem(void *buf, unsigned int count, char value)
{
 memset(buf, value, count); /*0x2cd*/
 return buf; /*0x2d3*/
}

/*
 *SetMem64 at 0x2e0
 */
int SetMem64(int a1, int a2, int a3, int a4)
{
 do /*0x2f9*/
 {
 *(_DWORD *)(a1 + 8 *a2 - 8) = a3; /*0x2f1*/
 *(_DWORD *)(a1 + 8 *a2-- - 4) = a4; /*0x2f5*/
 }
 while ( a2 ); /*0x2f9*/
 return a1; /*0x2fd*/
}

/*
 *SetMem32 at 0x300
 */
void *SetMem32(void *buf, unsigned int count, int value)
{
 memset32(buf, value, count); /*0x30d*/
 return buf; /*0x313*/
}

/*
 *_ModuleEntryPoint at 0x320
 */
EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
 return (*(int ( **)(EFI_SYSTEM_TABLE *, void *))(LODWORD(SystemTable->Hdr.Signature) + 24))( /*0x331*/
 SystemTable,
 &unk_1E50);
}

/*
 *RecoveryLoadCapsule at 0x332
 */
int RecoveryLoadCapsule(int *a1, int a2, int FvFileIndex, unsigned int CapsuleSize)
{
 int CapsuleSize_1; // edi int Status; // eax int LoadStatus; // esi unsigned int PreviousSize; // eax int ValidateStatus; // ebx int ValidationFlags; // [esp+10h] [ebp-4h] BYREF CapsuleSize_1 = CapsuleSize; /*0x337*/
 if ( CapsuleSize > ::CapsuleSize ) /*0x345*/
 {
 Status = (*(int ( **)(int *, int, unsigned int, __int64 *))(*a1 + 72))( /*0x358*/
 a1,
 6,
 (CapsuleSize >> 12) + 1,
 &FvImageBase);
 if ( Status < 0 ) /*0x360*/
 return Status; /*0x360*/
 ::CapsuleSize = CapsuleSize_1; /*0x366*/
 }
 DebugPrint(68, (int)"Loading Recovery Image..."); /*0x373*/
 LoadStatus = (*(int ( **)(int *, int, int, _DWORD))(a2 + 8))(a1, a2, FvFileIndex, FvImageBase); /*0x387*/
 DebugPrint(68, (int)"done. Status: %r\n", LoadStatus);
 if ( LoadStatus < 0 ) /*0x39b*/
 return LoadStatus; /*0x39d*/
 PreviousSize = *(_DWORD *)((char *)CapsuleData + 37); /*0x3aa*/
 if ( PreviousSize ) /*0x3af*/
 {
 if ( PreviousSize > 0x1004000 ) /*0x3c0*/
 FvImageBase += PreviousSize - 0x1000000; /*0x3c7*/
 }
 else
 {
 *(_DWORD *)((char *)CapsuleData + 37) = ::CapsuleSize; /*0x3b6*/
 }
 ValidateStatus = ValidateFirmwareCapsule(a1, (unsigned int *)&FvImageBase, (int *)&CapsuleSize, &ValidationFlags); /*0x3f0*/
 *((_QWORD *)CapsuleData + 3) = FvImageBase; /*0x3fa*/
 *(_DWORD *)((char *)CapsuleData + 33) = ValidationFlags; /*0x410*/
 *((_BYTE *)CapsuleData + 32) = ValidateStatus; /*0x419*/
 if ( ValidateStatus < 0 ) /*0x41e*/
 ReportStatusCode(-2147483646, 50532353); /*0x42d*/
 return ValidateStatus; /*0x437*/
}

/*
 *PeiLocateProtocol at 0x43d
 */
int PeiLocateProtocol(int *a1, unsigned __int8 ( *sub_4DA)(_BYTE *, int), int a3)
{
 int FvIndex; // ebx int Status; // eax int FvFileIndex; // esi int FvHandle; // [esp+10h] [ebp-20h] BYREF unsigned int FileCount; // [esp+14h] [ebp-1Ch] BYREF unsigned int FileSize; // [esp+18h] [ebp-18h] BYREF _BYTE GuidBuf[4]; // [esp+1Ch] [ebp-14h] BYREF _BYTE FileGuid[16]; // [esp+20h] [ebp-10h] BYREF FvIndex = 0; /*0x448*/
LABEL_2:
 while ( 1 ) /*0x45d*/
 {
 Status = (*(int ( **)(int *, void *, int, _BYTE *, int *))(*a1 + 32))( /*0x45d*/
 a1,
 &unk_1E40,
 FvIndex++,
 GuidBuf,
 &FvHandle);
 if ( Status < 0 ) /*0x466*/
 return Status; /*0x4d2*/
 if ( (*(int ( **)(int *, int, unsigned int *))FvHandle)(a1, FvHandle, &FileCount) >= 0 ) /*0x47a*/
 {
 FvFileIndex = 0; /*0x47c*/
 if ( FileCount ) /*0x482*/
 {
 while ( 1 ) /*0x495*/
 {
 if ( (*(int ( **)(int *, int, int, unsigned int *, _BYTE *))(FvHandle + 4))( /*0x49d*/
 a1,
 FvHandle,
 FvFileIndex,
 &FileSize,
 FileGuid) >= 0 )
 {
 if ( sub_4DA(FileGuid, a3) ) /*0x4a8*/
 {
 Status = RecoveryLoadCapsule(a1, FvHandle, FvFileIndex, FileSize); /*0x4bb*/
 if ( Status >= 0 ) /*0x4c4*/
 return Status; /*0x4c4*/
 }
 }
 if ( ++FvFileIndex >= FileCount ) /*0x4cb*/
 goto LABEL_2; /*0x4cb*/
 }
 }
 }
 }
}

/*
 *GuidMatchAnyInList at 0x4da
 */
unsigned __int8 GuidMatchAnyInList(_BYTE *a1, _BYTE **a2)
{
 while ( 1 ) /*0x4fa*/
 {
 if ( !*a2 ) /*0x4fa*/
 return 1; /*0x505*/
 if ( IsGuidEqual(*a2, (int)a1) ) /*0x4ec*/
 break; /*0x4ec*/
 ++a2; /*0x4f7*/
 }
 return 0; /*0x501*/
}

/*
 *IsRecoveryMode at 0x50a
 */
BOOL IsRecoveryMode()
{
 int PeiServicesResult; // eax int Status; // eax int PeiServices; // eax _BYTE ProtocolBuffer[4]; // [esp+4h] [ebp-4h] BYREF PeiServicesResult = GetPeiServices(); /*0x50f*/
 Status = (*(int ( **)(int, void *, _DWORD, _DWORD, _BYTE *))(*(_DWORD *)PeiServicesResult + 32))( /*0x524*/
 PeiServicesResult,
 &unk_17B0,
 0,
 0,
 ProtocolBuffer);
 if ( Status < 0 ) /*0x52c*/
 {
 PeiServices = GetPeiServices(); /*0x52e*/
 Status = (*(int ( **)(int, void *, _DWORD, _DWORD, _BYTE *))(*(_DWORD *)PeiServices + 32))( /*0x541*/
 PeiServices,
 &unk_17C0,
 0,
 0,
 ProtocolBuffer);
 }
 return Status >= 0; /*0x54c*/
}

/*
 *RecoveryModuleEntry at 0x551
 */
int RecoveryModuleEntry(int *a1)
{
 int LocateResult_1; // eax _DWORD *CapsuleDataFields; // edi _DWORD *CapsuleData; // eax int RetryCount; // edi int *ProtocolList; // esi int LocateResult; // [esp+10h] [ebp-8h]
 int BootMode; // [esp+14h] [ebp-4h] BYREF LocateResult_1 = (*(int ( **)(int *, int, int, _DWORD **))(*a1 + 52))(a1, 4, 41, &CapsuleData); /*0x56c*/
 if ( LocateResult_1 >= 0 ) /*0x574*/
 {
 CapsuleDataFields = CapsuleData + 2; /*0x58b*/
 CapsuleData[2] = unk_1760; /*0x58e*/
 *++CapsuleDataFields = unk_1764; /*0x58f*/
 *++CapsuleDataFields = unk_1768; /*0x590*/
 CapsuleDataFields[1] = unk_176C; /*0x591*/
 CapsuleData = CapsuleData; /*0x592*/
 CapsuleData[6] = 0; /*0x599*/
 CapsuleData[7] = 0; /*0x59c*/
 *(_DWORD *)((char *)CapsuleData + 33) = 0; /*0x5a4*/
 *(_DWORD *)((char *)CapsuleData + 37) = 0; /*0x5ac*/
 *((_BYTE *)CapsuleData + 32) = 14; /*0x5b4*/
 if ( (*(int ( **)(int *, int *))(*a1 + 40))(a1, &BootMode) >= 0 && BootMode == 18 && IsRecoveryMode() ) /*0x5ca*/
 {
 return LoadRecoveryFirmware(a1); /*0x5d5*/
 }
 else
 {
 RetryCount = 0; /*0x5dc*/
 while ( 1 ) /*0x5e5*/
 {
 ProtocolList = (int *)&off_1E5C; /*0x5e5*/
 if ( off_1E5C ) /*0x5ea*/
 break; /*0x5ea*/
LABEL_10:
 LocateResult_1 = PeiLocateProtocol(a1, GuidMatchAnyInList, (int)&off_1E5C); /*0x607*/
 LocateResult = LocateResult_1; /*0x618*/
 if ( LocateResult_1 >= 0 ) /*0x61f*/
 return LocateResult_1; /*0x61f*/
 if ( (unsigned int)++RetryCount >= 3 ) /*0x625*/
 {
 ReportStatusCode(-2147483646, 50532352); /*0x634*/
 *((_BYTE *)CapsuleData + 32) = LocateResult; /*0x645*/
 return LocateResult; /*0x648*/
 }
 }
 while ( 1 ) /*0x5f5*/
 {
 LocateResult_1 = PeiLocateProtocol(a1, (unsigned __int8 ( *)(_BYTE *, int))IsGuidEqual, *ProtocolList); /*0x5f5*/
 if ( LocateResult_1 >= 0 ) /*0x5fd*/
 break; /*0x5fd*/
 if ( !*++ProtocolList ) /*0x602*/
 goto LABEL_10; /*0x605*/
 }
 }
 }
 return LocateResult_1; /*0x64a*/
}

/*
 *FindFvSection at 0x651
 */
int FindFvSection(int this, _DWORD *CapsuleData, int *p_FvImageBase, unsigned int *p_FvImageSize)
{
 int FvIndex; // edi int PeiServicesResult; // eax int EnumerateStatus; // esi int PagesBuffer; // eax int PagesBuffer_1; // ebx _DWORD *CapsuleData_2; // ecx unsigned int FvSize; // edi int HobResult; // ebp _DWORD *HobByTypeResult; // eax int Size; // [esp-4h] [ebp-38h]
 int Size; // [esp+14h] [ebp-20h] BYREF unsigned int FvSize_1; // [esp+18h] [ebp-1Ch] BYREF _DWORD *CapsuleData_1; // [esp+1Ch] [ebp-18h]
 _BYTE Size[20]; // [esp+20h] [ebp-14h] BYREF CapsuleData_1 = CapsuleData; /*0x658*/
 FvIndex = 0; /*0x65e*/
 while ( 1 ) /*0x6ac*/
 {
 do /*0x6ac*/
 {
 PeiServicesResult = GetPeiServices(); /*0x660*/
 EnumerateStatus = (*(int ( **)(int, void *, int, _DWORD, int *))(*(_DWORD *)PeiServicesResult + 32))( /*0x67b*/
 PeiServicesResult,
 &unk_1E40,
 FvIndex++,
 0,
 &Size);
 if ( EnumerateStatus < 0 ) /*0x680*/
 return EnumerateStatus; /*0x680*/
 }
 while ( (*(int ( **)(int, int, _DWORD, unsigned int *, _BYTE *))(Size + 4))(this, Size, 0, &FvSize_1, Size) < 0 /*0x6ac*/
 || !IsGuidEqual(Size, (int)&unk_1D80) );
 PagesBuffer = AllocatePages(Size, (FvSize_1 >> 12) + ((FvSize_1 & 0xFFF) != 0)); /*0x6ce*/
 PagesBuffer_1 = PagesBuffer; /*0x6d3*/
 if ( !PagesBuffer ) /*0x6d7*/
 break; /*0x6d7*/
 EnumerateStatus = (*(int ( **)(int, int, _DWORD, int))(Size + 8))(this, Size, 0, PagesBuffer); /*0x6e5*/
 if ( EnumerateStatus >= 0 ) /*0x6ec*/
 {
 CapsuleData_2 = CapsuleData_1; /*0x6f6*/
 FvSize = FvSize_1; /*0x6fa*/
 *p_FvImageBase = PagesBuffer_1; /*0x6fe*/
 CapsuleData_2[7] = 0; /*0x704*/
 HobResult = CapsuleData_2[7]; /*0x708*/
 CapsuleData_2[6] = PagesBuffer_1; /*0x70b*/
 *(_DWORD *)((char *)CapsuleData_2 + 37) = FvSize; /*0x70e*/
 *p_FvImageSize = FvSize; /*0x711*/
 HobByTypeResult = GetHobByType(CapsuleData_2); /*0x713*/
 if ( HobByTypeResult ) /*0x71a*/
 {
 HobByTypeResult[5] = 0; /*0x71c*/
 HobByTypeResult[2] = PagesBuffer_1; /*0x720*/
 HobByTypeResult[3] = HobResult; /*0x723*/
 HobByTypeResult[4] = FvSize; /*0x726*/
 }
 return EnumerateStatus; /*0x732*/
 }
 }
 return -2147483639; /*0x72b*/
}

/*
 *LoadRecoveryFirmware at 0x73a
 */
int __thiscall LoadRecoveryFirmware(int *this)
{
 _DWORD *CapsuleData; // ebp int HobType; // ecx _WORD *HobStart; // esi _WORD *FvHob; // eax _WORD *FvHobEntry; // esi int FvImageBase; // edi bool IsMatch; // al int FvSectionResult; // esi unsigned int FvImageSize; // esi int HeaderSize; // eax int FvImageBase_3; // eax bool IsError; // sf int FvImageSize_3; // ecx int PeiServices; // eax int HobType_1; // [esp-4h] [ebp-28h]
 int FvImageBase_2; // [esp+14h] [ebp-10h] BYREF unsigned int FvImageSize_2; // [esp+18h] [ebp-Ch] BYREF unsigned int FvImageSize_1; // [esp+1Ch] [ebp-8h] BYREF int FvImageBase_1; // [esp+20h] [ebp-4h] BYREF CapsuleData = ::CapsuleData; /*0x73f*/
 DebugPrint(-1, (int)"Loading new firmware image..."); /*0x750*/
 for ( HobStart = (_WORD *)GetNextHob(); /*0x75c*/
 HobStart;
 HobStart = (_WORD *)((char *)FvHobEntry + (unsigned __int16)FvHobEntry[1]) )
 {
 FvHob = FindFvHob(HobType, HobStart); /*0x762*/
 FvHobEntry = FvHob; /*0x767*/
 if ( !FvHob ) /*0x76b*/
 break; /*0x76b*/
 FvImageBase = *((_DWORD *)FvHob + 2); /*0x76d*/
 if ( !IsGuidEqual((_BYTE *)FvImageBase, (int)&unk_1E6C) ) /*0x776*/
 {
 IsMatch = IsGuidEqual((_BYTE *)FvImageBase, (int)&unk_1EF0); /*0x787*/
 HobType = HobType_1; /*0x78d*/
 if ( !IsMatch ) /*0x790*/
 continue; /*0x790*/
 }
 FvImageSize = *((_DWORD *)FvHobEntry + 4); /*0x7d3*/
 goto LABEL_11; /*0x7d6*/
 }
 FvSectionResult = FindFvSection((int)this, CapsuleData, &FvImageBase_1, &FvImageSize_1); /*0x7af*/
 if ( FvSectionResult < 0 ) /*0x7b5*/
 {
 (*(void ( **)(int *, int, int, _DWORD, _DWORD, _DWORD))(*this + 88))(this, -2147483646, 50532352, 0, 0, 0); /*0x7c9*/
 return FvSectionResult; /*0x7ce*/
 }
 FvImageSize = FvImageSize_1; /*0x7d8*/
 FvImageBase = FvImageBase_1; /*0x7dc*/
LABEL_11:
 if ( IsGuidEqual((_BYTE *)FvImageBase, (int)&unk_1F00) ) /*0x7e6*/
 {
 HeaderSize = *(_DWORD *)(FvImageBase + 16); /*0x800*/
 FvImageBase += HeaderSize; /*0x803*/
 FvImageSize -= HeaderSize; /*0x805*/
 }
 else
 {
 IsGuidEqual((_BYTE *)FvImageBase, (int)&unk_1E7C); /*0x7f7*/
 }
 FvImageBase_2 = FvImageBase; /*0x80a*/
 FvImageSize_2 = FvImageSize; /*0x813*/
 FvImageBase_3 = ValidateFirmwareCapsule( /*0x81e*/
 this,
 (unsigned int *)&FvImageBase_2,
 (int *)&FvImageSize_2,
 (_DWORD *)((char *)CapsuleData + 33));
 FvImageBase_1 = FvImageBase_3; /*0x826*/
 IsError = FvImageBase_3 < 0; /*0x82f*/
 CapsuleData[6] = FvImageBase_2; /*0x832*/
 FvImageSize_3 = FvImageSize_2; /*0x835*/
 CapsuleData[7] = 0; /*0x83a*/
 *((_BYTE *)CapsuleData + 32) = FvImageBase_3; /*0x83d*/
 *(_DWORD *)((char *)CapsuleData + 37) = FvImageSize_3; /*0x840*/
 PeiServices = *this; /*0x843*/
 if ( IsError ) /*0x846*/
 (*(void ( **)(int *, int, int, _DWORD, _DWORD, _DWORD))(PeiServices + 88))( /*0x852*/
 this,
 -2147483646,
 50532353,
 0,
 0,
 0);
 else
 (*(void ( **)(int *, int, int, _DWORD, _DWORD, _DWORD))(PeiServices + 88))(this, 1, 50532354, 0, 0, 0); /*0x85c*/
 return FvImageBase_1; /*0x866*/
}

/*
 *AllocatePages at 0x86e
 */
int AllocatePages(int a1, int a2)
{
 int PeiServices; // eax int Result; // [esp+4h] [ebp-8h] BYREF if ( a2 /*0x895*/
 && (PeiServices = GetPeiServices(),
 (*(int ( **)(int, int, int, int *))(*(_DWORD *)PeiServices + 72))(PeiServices, 6, a2, &Result) >= 0) )
 {
 return Result; /*0x897*/
 }
 else
 {
 return 0; /*0x87a*/
 }
}

/*
 *GetDebugInstance at 0x89f
 */
int GetDebugInstance()
{
 int PeiServices; // eax _BYTE v2[4]; // [esp+0h] [ebp-8h] BYREF int Result; // [esp+4h] [ebp-4h] BYREF PeiServices = GetPeiServices(); /*0x8a4*/
 if ( (*(int ( **)(int, void *, _DWORD, _BYTE *, int *))(*(_DWORD *)PeiServices + 32))( /*0x8c3*/
 PeiServices,
 &unk_1D90,
 0,
 v2,
 &Result) >= 0 )
 return Result; /*0x8c9*/
 else return 0; /*0x8c5*/
}

/*
 *DebugPrint at 0x8d0
 */
int DebugPrint(int a1, int a2, ...)
{
 int result; // eax int ( **v3)(int, int, char *); // esi va_list va; // [esp+10h] [ebp+Ch] BYREF va_start(va, a2);
 result = GetDebugInstance(); /*0x8d1*/
 v3 = (int ( **)(int, int, char *))result; /*0x8d6*/
 if ( result ) /*0x8da*/
 {
 result = GetDebugLevel(); /*0x8dc*/
 if ( (result & a1) != 0 ) /*0x8e7*/
 return (*v3)(a1, a2, (char *)va); /*0x8f3*/
 }
 return result; /*0x8f8*/
}

/*
 *DebugAssert at 0x8fa
 */
int DebugAssert(
 int e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
 int n48,
 int PeiServices____((void__)_0))
{
 int result; // eax result = GetDebugInstance(); /*0x900*/
 if ( result ) /*0x907*/
 return (*(int ( **)(int, int, int))(result + 4))( /*0x90f*/
 e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
 n48,
 PeiServices____((void__)_0));
 return result; /*0x915*/
}

/*
 *IsGuidEqual at 0x918
 */
bool IsGuidEqual(_BYTE *a1, int a2)
{
 __int64 Guid1; // kr00_8 __int64 Unaligned64; // rax unsigned int Unaligned64_1; // ebx __int64 Guid1Hi; // kr08_8 __int64 Guid1Hi_1; // rax _BYTE *TempPtr; // [esp+18h] [ebp+4h]

 Guid1 = ReadUnaligned64(a1); /*0x930*/
 Unaligned64 = ReadUnaligned64((void *)a2); /*0x934*/
 TempPtr = (_BYTE *)HIDWORD(Unaligned64); /*0x93c*/
 Unaligned64_1 = Unaligned64; /*0x940*/
 Guid1Hi = ReadUnaligned64(a1 + 8); /*0x94e*/
 Guid1Hi_1 = ReadUnaligned64((void *)(a2 + 8)); /*0x950*/
 return Guid1 == __PAIR64__((unsigned int)TempPtr, Unaligned64_1) && Guid1Hi == Guid1Hi_1; /*0x973*/
}

/*
 *GetNextHob at 0x979
 */
int GetNextHob()
{
 int PeiServicesResult; // eax int Status; // eax int DebugInstanceResult; // eax int DebugInstance; // eax int Result; // [esp+4h] [ebp-4h] BYREF PeiServicesResult = GetPeiServices(); /*0x97e*/
 Status = (*(int ( **)(int, int *))(*(_DWORD *)PeiServicesResult + 48))(PeiServicesResult, &Result); /*0x98a*/
 if ( Status < 0 ) /*0x996*/
 {
 DebugPrint(0x80000000, (int)"\nASSERT_EFI_ERROR (Status = %r)\n", Status); /*0x9a3*/
 DebugInstanceResult = GetDebugInstance(); /*0x9ab*/
 if ( DebugInstanceResult ) /*0x9b2*/
 (*(void ( **)(const char *, int, const char *))(DebugInstanceResult + 4))( /*0x9bc*/
 "e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
 50,
 "!EFI_ERROR (Status)");
 }
 if ( !Result ) /*0x9c6*/
 {
 DebugInstance = GetDebugInstance(); /*0x9c8*/
 if ( DebugInstance ) /*0x9cf*/
 (*(void ( **)(const char *, int, const char *))(DebugInstance + 4))( /*0x9d9*/
 "e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
 51,
 "HobList != ((void *) 0)");
 }
 return Result; /*0x9e2*/
}

/*
 *FindFvHob at 0x9e7
 */
_WORD *FindFvHob(int HobType, _WORD *i)
{
 _WORD *HobWalker; // esi int DebugInstanceResult; // eax HobWalker = i; /*0x9e8*/
 if ( !i ) /*0x9ec*/
 {
 DebugInstanceResult = GetDebugInstance(); /*0x9ee*/
 if ( DebugInstanceResult ) /*0x9f5*/
 (*(void ( **)(const char *, int, const char *))(DebugInstanceResult + 4))( /*0xa03*/
 "e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
 82,
 "HobStart != ((void *) 0)");
 }
 while ( 1 ) /*0xa1c*/
 {
 if ( *HobWalker == 0xFFFF ) /*0xa22*/
 return 0; /*0xa27*/
 if ( *HobWalker == 11 ) /*0xa14*/
 break; /*0xa14*/
 HobWalker = (_WORD *)((char *)HobWalker + (unsigned __int16)HobWalker[1]); /*0xa1a*/
 }
 return HobWalker; /*0xa26*/
}

/*
 *GetHobByType at 0xa2c
 */
void *__thiscall GetHobByType(void *this)
{
 int PeiServicesResult; // eax int DebugInstanceResult; // eax void *this_1; // [esp+0h] [ebp-4h]

 this_1 = this; /*0xa2f*/
 PeiServicesResult = GetPeiServices(); /*0xa30*/
 if ( (*(int (__stdcall **)(int))(*(_DWORD *)PeiServicesResult + 52))(PeiServicesResult) < 0 ) /*0xa48*/
 this_1 = 0; /*0xa4a*/
 if ( !this_1 ) /*0xa52*/
 {
 DebugInstanceResult = GetDebugInstance(); /*0xa54*/
 if ( DebugInstanceResult ) /*0xa5b*/
 (*(void ( **)(const char *, int, const char *))(DebugInstanceResult + 4))( /*0xa6c*/
 "e:\\hs\\MdePkg\\Library\\PeiHobLib\\HobLib.c",
 250,
 "Hob != ((void *) 0)");
 }
 return this_1; /*0xa77*/
}

/*
 *ReportStatusCode at 0xa79
 */
int ReportStatusCode(int n2, int n50532352)
{
 int PeiServices; // eax int Result; // eax if ( (unsigned __int8)n2 != 2 && (unsigned __int8)n2 != 3 ) /*0xa8a*/
 return -2147483645; /*0xa8c*/
 PeiServices = GetPeiServices(); /*0xa93*/
 Result = (*(int ( **)(int, int, int, _DWORD, void *, _DWORD))(*(_DWORD *)PeiServices + 88))( /*0xaa6*/
 PeiServices,
 n2,
 n50532352,
 0,
 &unk_1E20,
 0);
 return Result != -1610612734 ? Result : 0;
}

/*
 *ValidateBiosVersion at 0xabd
 */
int ValidateBiosVersion(_BYTE *a1, _DWORD *a2)
{
 int v4; // esi int result; // eax double v6; // [esp-18h] [ebp-40h]
 double v7; // [esp-10h] [ebp-38h]
 double v8; // [esp+0h] [ebp-28h]
 double v9; // [esp+8h] [ebp-20h]
 _BYTE buf[8]; // [esp+10h] [ebp-18h] BYREF _DWORD v11[4]; // [esp+18h] [ebp-10h] BYREF v11[0] = -582768602; /*0xaca*/
 v11[1] = 1270593801; /*0xad7*/
 v11[2] = -192756318; /*0xae1*/
 v11[3] = 1989909044; /*0xae9*/
 SetMemAligned((int)buf, buf, 6u, 0); /*0xaf1*/
 CopyMem(buf, (unsigned int)(a1 + 7), 5u); /*0xb01*/
 v4 = 100 *AsciiStrDecimalToUintn(a1 + 38); /*0xb1d*/
 HIDWORD(v7) = AsciiStrDecimalToUintn(a1 + 41) + v4; /*0xb2b*/
 LODWORD(v7) = 834; /*0xb2c*/
 HIDWORD(v6) = buf; /*0xb31*/
 LODWORD(v6) = "HR6N0"; /*0xb37*/
 DebugPrint(
 64,
 (int)"Org/New BiosTag: %a=%a\nOrg/New ProjVer: %d=%d\nOrg/New FwGuid: %g=%g\n",
 v6,
 v7,
 v11,
 a1 + 16,
 v8,
 v9);
 result = CompareMem("HR6N0", a1 + 7, 5); /*0xb4a*/
 if ( result ) /*0xb54*/
 return -2147483622; /*0xb5b*/
 *a2 = 0; /*0xb56*/
 return result; /*0xb60*/
}

/*
 *VerifySignatureSection at 0xb68
 */
int VerifySignatureSection(int a1, int a2, _DWORD *a3)
{
 int v3; // esi int Index; // ebx _DWORD *i; // esi _BYTE *v6; // ebp _BYTE *v7; // edi unsigned int v8; // eax int v10; // [esp+10h] [ebp-4h]

 v3 = a1 + *(unsigned __int16 *)(a1 + 30); /*0xb70*/
 v10 = a2; /*0xb72*/
 Index = *(_DWORD *)(v3 + 12); /*0xb77*/
 if ( !Index ) /*0xb7c*/
 return -2147483622; /*0xbcf*/
 for ( i = (_DWORD *)(v3 + 8); (i[3] & 0xA) == 0 || (i[3] & 0x200) == 0; i += 6 ) /*0xb7e*/
 {
LABEL_9:
 Index = i[7]; /*0xbc5*/
 if ( !Index ) /*0xbcd*/
 return -2147483622; /*0xbcd*/
 }
 v6 = (_BYTE *)(a2 + *i); /*0xb96*/
 v7 = v6; /*0xb98*/
 while ( CompareMem(byte_1E8C, v7, 16) || *((_DWORD *)v7 + 4) != 1145652772 ) /*0xbb5*/
 {
 v8 = (unsigned int)v7++; /*0xbb7*/
 if ( v8 >= (unsigned int)&v6[Index] ) /*0xbbf*/
 {
 a2 = v10; /*0xbc1*/
 goto LABEL_9; /*0xbc1*/
 }
 }
 return ValidateBiosVersion(v7 + 16, a3); /*0xbd4*/
}

/*
 *FindCapsuleHeader at 0xbed
 */
int FindCapsuleHeader(_DWORD *a1, _DWORD *a2)
{
 _BYTE *v3; // edi _DWORD *v4; // esi _DWORD *v5; // eax _DWORD *v7; // [esp+10h] [ebp-4h]

 v7 = a1; /*0xbf6*/
 v3 = a1 + 4194293; /*0xbfa*/
 v4 = a1 + 0x400000; /*0xc00*/
 while ( *(_DWORD *)v3 != dword_1E9C[0] ) /*0xc0a*/
 {
LABEL_8:
 v5 = v3; /*0xc5c*/
 --v4; /*0xc5e*/
 v3 -= 4; /*0xc61*/
 if ( v5 == a1 ) /*0xc66*/
 return -2147483634; /*0xc72*/
 }
 if ( CompareMem(dword_1E9C, v3, 16) /*0xc4e*/
 || CompareMem(byte_1ECC, (_BYTE *)v4 - 16, 16)
 || (*(v4 - 6) & 0xFFFFFFu) < v4[4] + 44
 || CompareMem(v4, byte_1EAC, 16) )
 {
 a1 = v7; /*0xc58*/
 goto LABEL_8; /*0xc58*/
 }
 *a2 = v4; /*0xc73*/
 return 0; /*0xc6d*/
}

/*
 *HashFirmwareImage at 0xc7a
 */
int HashFirmwareImage(int a1, int a2, unsigned int a3, int a4)
{
 int v4; // ebx int v5; // esi int v6; // eax int Index; // ecx unsigned int Index; // ebp unsigned int v9; // eax _DWORD *v10; // edx int v11; // edx unsigned int Ptr; // ecx unsigned int v13; // esi int v14; // edi int v15; // edi unsigned int Index; // eax unsigned int Index; // ecx unsigned int *v18; // ebx int Result; // esi unsigned int v21; // [esp+10h] [ebp-14h]
 unsigned int v22; // [esp+14h] [ebp-10h]
 int v23; // [esp+18h] [ebp-Ch]
 int v24; // [esp+1Ch] [ebp-8h]

 v4 = a1; /*0xc7e*/
 v5 = *(unsigned __int16 *)(a1 + 30); /*0xc87*/
 v6 = *(unsigned __int16 *)(a1 + 28); /*0xc8d*/
 Index = 0; /*0xc91*/
 v23 = v4; /*0xc95*/
 Index = 0; /*0xc9e*/
 v9 = (v6 - v5) / 0x18u; /*0xca1*/
 v24 = v5 + v4; /*0xca3*/
 if ( v9 ) /*0xca9*/
 {
 v10 = (_DWORD *)(v5 + v4 + 20); /*0xcab*/
 do /*0xcc2*/
 {
 if ( !*(v10 - 2) ) /*0xcae*/
 break; /*0xcb2*/
 if ( (*v10 & 0x200) != 0 ) /*0xcba*/
 ++Index; /*0xcbc*/
 ++Index; /*0xcbd*/
 v10 += 6; /*0xcbe*/
 }
 while ( Index < v9 ); /*0xcc2*/
 }
 v11 = dword_1F14; /*0xcc4*/
 Ptr = Index + 2; /*0xcca*/
 if ( dword_1F14 && (v13 = dword_1F10) != 0 && dword_1F10 >= Ptr )
 {
 v14 = dword_1F18; /*0xcdf*/
 }
 else
 {
 dword_1F10 = Ptr; /*0xce9*/
 v15 = 4 *Ptr; /*0xcf5*/
 if ( (*(int ( **)(int, unsigned int, int *))(*(_DWORD *)this + 76))(this, 8 *Ptr, &dword_1F14) < 0 )
 {
 DebugPrintWorker(
 -1,
 this,
 "ASSERT in %s on %i: %s\n",
 "e:\\hs\\AmiModulePkg\\SecureFlash\\SecFlashUpd\\VerifyFwCapsule.c",
 325,
 "!EFI_ERROR(Status)");
 while ( 1 ) /*0xd3c*/
 ; /*0xd3c*/
 }
 v11 = dword_1F14; /*0xd48*/
 v14 = dword_1F14 + v15; /*0xd4e*/
 v13 = dword_1F10; /*0xd50*/
 dword_1F18 = v14; /*0xd56*/
 }
 Index = 0; /*0xd5c*/
 Index = 0; /*0xd5e*/
 v22 = 0; /*0xd60*/
 if ( Index ) /*0xd66*/
 {
 v18 = (unsigned int *)(v24 + 8); /*0xd70*/
 while ( Index < v13 ) /*0xd75*/
 {
 v21 = v18[1]; /*0xd80*/
 v13 = dword_1F10; /*0xd84*/
 if ( v21 ) /*0xd8a*/
 {
 if ( (v18[3] & 0x200) != 0 ) /*0xd93*/
 {
 if ( *v18 > a3 || *v18 + (unsigned __int64)v21 > a3 ) /*0xdbd*/
 return -2147483622; /*0xdbd*/
 *(_DWORD *)(v11 + 4 *Index) = a2 + *v18; /*0xdc7*/
 v13 = dword_1F10; /*0xdcd*/
 *(_DWORD *)(v14 + 4 *Index++) = v18[1]; /*0xdd3*/
 v11 = dword_1F14; /*0xdd7*/
 Index = v22; /*0xddd*/
 }
 ++Index; /*0xde1*/
 v18 += 6; /*0xde2*/
 v22 = Index; /*0xde5*/
 if ( Index < Index ) /*0xdeb*/
 continue; /*0xdeb*/
 }
 v4 = v23; /*0xded*/
 goto LABEL_25; /*0xded*/
 }
 return -2147483622; /*0xd75*/
 }
LABEL_25:
 if ( Index < v13 )
 {
 if ( (*(_BYTE *)(v4 + 20) & 2) == 0 )
 {
LABEL_29:
 *(_DWORD *)(v11 + 4 *Index) = v24; /*0xe10*/
 *(_DWORD *)(v14 + 4 *Index) = 24 * (Index + 1); /*0xe21*/
 Result = (*(int ( **)(int, int, unsigned int, int, int, void *))dword_1F1C)( /*0xe3e*/
 dword_1F1C,
 a4,
 Index + 1,
 dword_1F14,
 v14,
 &unk_1F28);
 DebugPrint(64, (int)"Hash the FW Image: %r, Hash Algorithm %g\n", Result, a4);
 return Result; /*0xe59*/
 }
 *(_DWORD *)(v11 + 4 *Index) = v4; /*0xdfb*/
 *(_DWORD *)(v14 + 4 *Index++) = 56; /*0xdfe*/
 if ( Index < v13 ) /*0xe08*/
 {
 v11 = dword_1F14; /*0xe0a*/
 goto LABEL_29; /*0xe0a*/
 }
 }
 return -2147483622; /*0xe52*/
}

/*
 *VerifyHashSha256 at 0xe61
 */
int VerifyHashSha256(int a1, int a2, unsigned int a3, int a4, _DWORD *a5)
{
 _DWORD *v5; // ebx _BYTE *src; // edi int n48; // ebp int v8; // eax int Result; // esi int result; // eax _DWORD *v11; // eax int Result; // edx int Result; // ecx int ErrorLevel; // [esp+10h] [ebp-48h] BYREF int v15; // [esp+14h] [ebp-44h]
 int v16; // [esp+18h] [ebp-40h]
 void *v17; // [esp+1Ch] [ebp-3Ch] BYREF int v18; // [esp+20h] [ebp-38h]
 int v19; // [esp+24h] [ebp-34h]
 _BYTE dst[48]; // [esp+28h] [ebp-30h] BYREF v5 = a5; /*0xe65*/
 v16 = a2; /*0xe69*/
 v15 = a1; /*0xe6d*/
 ErrorLevel = 1; /*0xe71*/
 if ( !a5 ) /*0xe7e*/
 return -2147483622; /*0xe7e*/
 *a5 = 3; /*0xe88*/
 if ( !a4 ) /*0xe90*/
 return -2147483622; /*0xe90*/
 src = *(_BYTE **)(a4 + 20); /*0xe96*/
 if ( !src ) /*0xe9b*/
 return -2147483622; /*0xfcf*/
 if ( CompareMem((_BYTE *)a4, byte_1DE0, 16) ) /*0xeaa*/
 {
 if ( CompareMem((_BYTE *)a4, byte_1DB0, 16) ) /*0xec2*/
 return -2147483645; /*0xf60*/
 CopyMem(dst, (unsigned int)src, 0x20u); /*0xed8*/
 src = dst; /*0xee0*/
 n48 = 48; /*0xee6*/
 }
 else
 {
 n48 = *(_DWORD *)(a4 + 16); /*0xeb4*/
 }
 v17 = &unk_1F28; /*0xef0*/
 v8 = *(_DWORD *)(v15 + 32) - 24; /*0xefe*/
 v19 = v15 + 56; /*0xf01*/
 v18 = v8; /*0xf06*/
 Result = (*(int ( **)(int, int, int, int *))(dword_1F1C + 20))(dword_1F1C, v15 + 56, v8, &ErrorLevel); /*0xf18*/
 DebugPrint(64, (int)"Get Hash Algorithm %r, %d\n", Result, ErrorLevel); /*0xf22*/
 if ( Result < 0 ) /*0xf2c*/
 return Result; /*0xf30*/
 switch ( ErrorLevel ) /*0xf3c*/
 {
 case 1: /*0xf3c*/
 v11 = dword_1DA0; /*0xf80*/
 a5 = (_DWORD *)(word_1C + 4); /*0xf85*/
 break;
 case 2: /*0xf3c*/
 v11 = &unk_1E00; /*0xf71*/
 a5 = (_DWORD *)(word_28 + 8); /*0xf76*/
 break;
 case 3: /*0xf3c*/
 v11 = &unk_1E10; /*0xf62*/
 a5 = (_DWORD *)byte_40; /*0xf67*/
 break;
 default:
 DebugPrint(64, (int)"Unsupported Hash Algorithm(1-3) %d\n", ErrorLevel); /*0xf53*/
 return -2147483645; /*0xf53*/
 }
 Result = v16; /*0xf8d*/
 Result = v15; /*0xf92*/
 *v5 = 2; /*0xf9b*/
 result = HashFirmwareImage(Result, Result, a3, (int)v11); /*0xfa1*/
 if ( result >= 0 ) /*0xfab*/
 return (*(int ( **)(int, int, int, _BYTE *, int, void **, _DWORD **))(dword_1F1C + 16))( /*0xfc7*/
 dword_1F1C,
 v19,
 v18,
 src,
 n48,
 &v17,
 &a5);
 return result; /*0xfd4*/
}

/*
 *VerifyCertificateSignature at 0xfdc
 */
int VerifyCertificateSignature(int a1, int a2, unsigned int a3, _DWORD *a4)
{
 int v5; // ebp int result; // eax unsigned int v7; // edi int ErrorLevel; // esi unsigned int v9; // edi unsigned __int64 v10; // kr00_8 int v11; // eax int Result; // edx int n256; // [esp+14h] [ebp-40h] BYREF int v14; // [esp+18h] [ebp-3Ch] BYREF int v15; // [esp+1Ch] [ebp-38h]
 _DWORD v16[5]; // [esp+20h] [ebp-34h] BYREF unsigned int v17; // [esp+34h] [ebp-20h]
 _DWORD v18[7]; // [esp+38h] [ebp-1Ch] BYREF v15 = a2; /*0xfec*/
 v18[0] = dword_1DA0[0]; /*0xff6*/
 v5 = (*(_DWORD *)(a1 + 20) & 1) + 1; /*0xffd*/
 v18[1] = dword_1DA0[1]; /*0xffe*/
 v18[2] = dword_1DA0[2]; /*0xfff*/
 v18[3] = dword_1DA0[3]; /*0x1000*/
 v18[4] = 32; /*0x1001*/
 v18[5] = &unk_1F28; /*0x1009*/
 if ( !a4 ) /*0x1013*/
 return -2147483622; /*0x1015*/
 v16[4] = 256; /*0x101f*/
 *a4 = 3; /*0x1030*/
 v16[0] = unk_1770; /*0x1040*/
 v16[1] = unk_1774; /*0x1047*/
 v16[2] = unk_1778; /*0x1048*/
 v16[3] = unk_177C; /*0x1049*/
 v7 = a1 + 72; /*0x104a*/
 v17 = a1 + 72; /*0x104d*/
 ErrorLevel = (*(int ( **)(int, void *, _DWORD *))(dword_1F1C + 4))(dword_1F1C, &unk_1EBC, v16); /*0x1054*/
 DebugPrint(64, (int)"Compare Platform and SignCert Keys : %r\n", ErrorLevel);
 if ( ErrorLevel < 0 )
 {
 v9 = a1 + 584; /*0x1075*/
 v10 = (unsigned int)(a1 + 32) + (unsigned __int64)*(unsigned int *)(a1 + 32); /*0x107b*/
 if ( !HIDWORD(v10) ) /*0x1089*/
 goto LABEL_8; /*0x1089*/
 while ( *(_BYTE *)(v9 + 16) )
 {
 v17 = v9 + 16; /*0x1097*/
 ErrorLevel = (*(int ( **)(int, void *, _DWORD *))(dword_1F1C + 4))(dword_1F1C, &unk_1EBC, v16); /*0x10ae*/
 DebugPrint(64, (int)"Compare Platform and RootCert Keys : %r\n", ErrorLevel);
 if ( ErrorLevel >= 0 )
 {
 if ( (*(_BYTE *)(a1 + 20) & 4) != 0 ) /*0x10eb*/
 {
 v11 = a1 + 72; /*0x10ed*/
 n256 = 256; /*0x10f0*/
 }
 else
 {
 v11 = a1 + 32; /*0x10fa*/
 n256 = 552; /*0x10fd*/
 }
 v14 = v11; /*0x1105*/
 if ( (*(int ( **)(int, _DWORD *, int, int *, int *, void *))dword_1F1C)( /*0x112c*/
 dword_1F1C,
 dword_1DA0,
 1,
 &v14,
 &n256,
 &unk_1F28) < 0 )
 return -2147483622; /*0x112c*/
 ErrorLevel = (*(int ( **)(int, _DWORD *, _DWORD *, unsigned int, int, int))(dword_1F1C + 8))( /*0x1152*/
 dword_1F1C,
 v16,
 v18,
 v9 + 272,
 256,
 v5);
 DebugPrint(64, (int)"Verify Root Cert : %r\n", ErrorLevel);
 break; /*0x115c*/
 }
 v9 += 528; /*0x10cb*/
 LODWORD(v10) = a1 + 32 + *(_DWORD *)(a1 + 32); /*0x10d9*/
 if ( !(((unsigned int)(a1 + 32) + (unsigned __int64)*(unsigned int *)(a1 + 32)) >> 32) ) /*0x10d9*/
 {
LABEL_8:
 if ( v9 >= (unsigned int)v10 ) /*0x10e3*/
 break; /*0x10e3*/
 }
 }
 if ( ErrorLevel < 0 ) /*0x1166*/
 return -2147483622; /*0x1166*/
 v7 = a1 + 72; /*0x116c*/
 }
 Result = v15; /*0x1173*/
 *a4 = 2; /*0x1183*/
 result = HashFirmwareImage(a1, Result, a3, (int)dword_1DA0); /*0x1189*/
 if ( result >= 0 ) /*0x1193*/
 {
 v17 = v7; /*0x11a1*/
 return (*(int ( **)(int, _DWORD *, _DWORD *, int, int, int))(dword_1F1C + 8))( /*0x11b6*/
 dword_1F1C,
 v16,
 v18,
 a1 + 328,
 256,
 v5);
 }
 return result; /*0x11bc*/
}

/*
 *ValidateFirmwareCapsule at 0x11c4
 */
signed int ValidateFirmwareCapsule(
 int *this,
 unsigned int *p_FvImageBase,
 int *p_FvImageSize,
 _DWORD *p_ValidationFlags)
{
 int v6; // eax unsigned int FvImageSize; // eax _DWORD *p_ValidationFlags_1; // ebp signed int result; // eax double v10; // rdi _DWORD *p_ValidationFlags_2; // ebx unsigned int n0x4000_3; // edx unsigned int n0x4000; // ecx int n0x4000_1; // eax unsigned int v15; // ett bool v16; // cf int v17; // esi int v18; // eax int v19; // esi int v20; // [esp+0h] [ebp-3Ch]
 int n32; // [esp+18h] [ebp-24h] BYREF unsigned int n0x4000_2; // [esp+1Ch] [ebp-20h]
 _BYTE v24[16]; // [esp+20h] [ebp-1Ch] BYREF int v25; // [esp+30h] [ebp-Ch]
 _DWORD *v26; // [esp+34h] [ebp-8h]

 v6 = *this; /*0x11d8*/
 ::this = (int)this; /*0x11db*/
 (*(void ( **)(int *, int *))(v6 + 40))(this, &n32); /*0x11e1*/
 if ( p_FvImageSize ) /*0x11ec*/
 FvImageSize = *p_FvImageSize; /*0x11ee*/
 else FvImageSize = 0; /*0x11f2*/
 DebugPrint(64, (int)"\nValidating FW Capsule (size %X) BootMode %X...\n", FvImageSize, n32); /*0x1200*/
 p_ValidationFlags_1 = p_ValidationFlags; /*0x1205*/
 if ( !p_ValidationFlags ) /*0x120e*/
 return -2147483622; /*0x120e*/
 *p_ValidationFlags = 1; /*0x1217*/
 result = (*(int ( **)(int *, void *, _DWORD, _DWORD, int *))(*this + 32))(this, &unk_1E30, 0, 0, &dword_1F1C); /*0x1228*/
 if ( result < 0 ) /*0x1230*/
 return result; /*0x1230*/
 if ( !p_FvImageBase || !*p_FvImageBase ) /*0x1236*/
 return -2147483622; /*0x1239*/
 p_ValidationFlags = (_DWORD *)*p_FvImageBase; /*0x1246*/
 LODWORD(v10) = p_ValidationFlags; /*0x123b*/
 p_ValidationFlags_2 = p_ValidationFlags; /*0x124a*/
 if ( CompareMem(p_ValidationFlags, byte_1EAC, 16) ) /*0x124c*/
 {
 if ( FindCapsuleHeader((_DWORD *)LODWORD(v10), &p_ValidationFlags) < 0 ) /*0x127a*/
 return -2147483622; /*0x127a*/
 LODWORD(v10) = p_ValidationFlags; /*0x127c*/
 }
 else
 {
 p_ValidationFlags_2 = (_DWORD *)(LODWORD(v10) + *(unsigned __int16 *)(LODWORD(v10) + 28)); /*0x125a*/
 if ( (unsigned int)p_ValidationFlags_2 < LODWORD(v10) ) /*0x125e*/
 return -2147483622; /*0x1260*/
 }
 HIDWORD(v10) = *(_DWORD *)(LODWORD(v10) + 24) - *(unsigned __int16 *)(LODWORD(v10) + 28); /*0x128b*/
 p_ValidationFlags = (_DWORD *)HIDWORD(v10); /*0x1291*/
 DebugPrint(
 64,
 (int)"FW Capsule Hdr offs 0x%X\nGUID: %g\nPayload Size: 0x%X\n",
 LODWORD(v10) - *p_FvImageBase,
 v10,
 v20);
 if ( !p_FvImageSize ) /*0x12ad*/
 return -2147483622; /*0x12ad*/
 if ( HIDWORD(v10) > *p_FvImageSize ) /*0x12b1*/
 return -2147483622; /*0x12b1*/
 if ( *(_WORD *)(LODWORD(v10) + 38) != 3825 ) /*0x12bc*/
 return -2147483622; /*0x12bc*/
 if ( *(_DWORD *)(LODWORD(v10) + 24) > 0x1004000u ) /*0x12c5*/
 return -2147483622; /*0x12c5*/
 n0x4000_3 = *(_DWORD *)(LODWORD(v10) + 16); /*0x12c7*/
 if ( n0x4000_3 > *(_DWORD *)(LODWORD(v10) + 24) ) /*0x12cd*/
 return -2147483622; /*0x12cd*/
 n0x4000 = *(unsigned __int16 *)(LODWORD(v10) + 28); /*0x12cf*/
 if ( n0x4000_3 > n0x4000 ) /*0x12d5*/
 return -2147483622; /*0x12d5*/
 if ( (unsigned __int16)n0x4000 > 0x4000u ) /*0x12df*/
 return -2147483622; /*0x12df*/
 n0x4000_1 = *(unsigned __int16 *)(LODWORD(v10) + 30); /*0x12e5*/
 if ( (unsigned __int16)n0x4000_1 > (unsigned __int16)n0x4000 ) /*0x12ec*/
 return -2147483622; /*0x12ec*/
 v15 = ((unsigned __int64)*(unsigned int *)(LODWORD(v10) + 32) + 32) >> 32; /*0x12fa*/
 n0x4000_2 = *(_DWORD *)(LODWORD(v10) + 32) + 32; /*0x12fa*/
 v16 = v15 < n0x4000_1 >> 31; /*0x1301*/
 if ( v15 > n0x4000_1 >> 31 || !v16 && n0x4000_2 > n0x4000_1 ) /*0x130f*/
 return -2147483622; /*0x130f*/
 v25 = 0; /*0x1319*/
 v26 = 0; /*0x131e*/
 *p_FvImageBase = (unsigned int)p_ValidationFlags_2; /*0x1323*/
 *p_FvImageSize = HIDWORD(v10); /*0x1329*/
 *p_ValidationFlags_1 = 3; /*0x1330*/
 v17 = (*(int ( **)(int, void *, _BYTE *))(dword_1F1C + 12))(dword_1F1C, &unk_1EBC, v24); /*0x134c*/
 DebugPrint(64, (int)"Get FW Key (%r), %X (%d bytes)\n", v17, *v26, v25); /*0x135c*/
 if ( v17 < 0 ) /*0x1366*/
 return 0; /*0x136a*/
 if ( *v26 == 1145127460 ) /*0x137b*/
 {
 DebugPrint(64, (int)"FW Key store if empty...\n"); /*0x1384*/
 return 0; /*0x138b*/
 }
 if ( CompareMem((_BYTE *)(LODWORD(v10) + 40), byte_1DC0, 16) ) /*0x1397*/
 v18 = VerifyCertificateSignature( /*0x13bd*/
 SLODWORD(v10),
 (int)p_ValidationFlags_2,
 (unsigned int)p_ValidationFlags,
 p_ValidationFlags_1);
 else v18 = VerifyHashSha256( /*0x13af*/
 SLODWORD(v10),
 (int)p_ValidationFlags_2,
 (unsigned int)p_ValidationFlags,
 (int)v24,
 p_ValidationFlags_1);
 v19 = v18; /*0x13c4*/
 DebugPrint(64, (int)"Verify Sign Certificate Sig : %r\n", v18);
 if ( v19 >= 0 )
 {
 *p_ValidationFlags_1 = 4; /*0x13e4*/
 v19 = VerifySignatureSection(SLODWORD(v10), (int)p_ValidationFlags_2, p_ValidationFlags_1); /*0x13f6*/
 DebugPrint(64, (int)"FW Revision test %r (FailedVTask = %x)\n", v19, *p_ValidationFlags_1); /*0x1400*/
 if ( v19 == -2147483623 )
 return n32 != 32 ? 0x80000019 : 0;
 }
 return v19; /*0x1265*/
}

/*
 *GetPeiServices at 0x1423
 */
int GetPeiServices()
{
 int Result; // esi _BYTE v2[2]; // [esp+4h] [ebp-8h] BYREF int v3; // [esp+6h] [ebp-6h]

 ReadIdtr(v2); /*0x142c*/
 Result = *(_DWORD *)(v3 - 4); /*0x1434*/
 if ( !Result ) /*0x1439*/
 DebugAssert( /*0x1448*/
 (int)"e:\\hs\\MdePkg\\Library\\PeiServicesTablePointerLibIdt\\PeiServicesTablePointer.c",
 48,
 (int)"PeiServices != ((void *) 0)");
 return Result; /*0x1450*/
}

/*
 *GetDebugLevel at 0x1455
 */
int GetDebugLevel()
{
 unsigned __int8 v0; // al char Result; // al char n3_1; // cl v0 = __inbyte(0x70u); /*0x145b*/
 __outbyte(0x70u, v0 & 0x80 | 0x4A); /*0x1460*/
 Result = __inbyte(0x71u); /*0x1467*/
 n3_1 = Result; /*0x1468*/
 if ( (unsigned __int8)Result <= 3u ) /*0x146d*/
 {
LABEL_4:
 if ( !n3_1 ) /*0x1488*/
 return 0; /*0x1488*/
 goto LABEL_5; /*0x1488*/
 }
 n3_1 = Result; /*0x146f*/
 if ( !Result ) /*0x1477*/
 {
 n3_1 = MEMORY[0xFDAF0490] & 2 | 1; /*0x1483*/
 goto LABEL_4; /*0x1483*/
 }
LABEL_5:
 if ( n3_1 != -1 )
 return n3_1 != 1 ? -2147483578 : -2147483644;
 return 0; /*0x14a0*/
}

/*
 *ReadUnaligned64 at 0x14a4
 */
__int64 __thiscall ReadUnaligned64(void *this)
{
 int DebugInstance; // eax if ( !this ) /*0x14a9*/
 {
 DebugInstance = GetDebugInstance(); /*0x14ab*/
 if ( DebugInstance ) /*0x14b2*/
 (*(void ( **)(const char *, int, const char *))(DebugInstance + 4))( /*0x14c3*/
 "e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
 192,
 "Buffer != ((void *) 0)");
 }
 return *(_QWORD *)this; /*0x14ce*/
}

/*
 *ReadIdtr at 0x14d0
 */
void *__thiscall ReadIdtr(void *this)
{
 void *this_1; // eax if ( !this ) /*0x14d6*/
 DebugAssert((int)"e:\\hs\\MdePkg\\Library\\BaseLib\\X86ReadIdtr.c", 37, (int)"Idtr != ((void *) 0)"); /*0x14e5*/
 this_1 = this; /*0x14eb*/
 __sidt(this); /*0x14ee*/
 return this_1; /*0x14f2*/
}

/*
 *CompareMem at 0x14f3
 */
int CompareMem(_BYTE *a1, _BYTE *a2, int a3)
{
 _BYTE *v3; // esi _BYTE *v4; // edi int n4; // ebx int v6; // ecx v3 = a1; /*0x14fa*/
 v4 = &a1[a3]; /*0x14fe*/
 n4 = (unsigned __int8)a1 & 3; /*0x1500*/
 if ( ((unsigned __int8)a1 & 3) != 0 && n4 == ((unsigned __int8)a2 & 3) ) /*0x150c*/
 {
 v6 = 4 - n4; /*0x1511*/
 if ( n4 != 4 ) /*0x1513*/
 {
 do /*0x1520*/
 {
 if ( *v3 != *a2 ) /*0x1519*/
 break; /*0x1519*/
 ++v3; /*0x151b*/
 ++a2; /*0x151c*/
 --v6; /*0x151d*/
 }
 while ( v6 ); /*0x1520*/
 }
 }
 while ( v3 <= v4 - 4 && *(_DWORD *)v3 == *(_DWORD *)a2 ) /*0x152b*/
 {
 v3 += 4; /*0x152d*/
 a2 += 4; /*0x1530*/
 }
 while ( 1 ) /*0x1541*/
 {
 if ( v3 >= v4 ) /*0x1543*/
 return 0; /*0x154a*/
 if ( *v3 != *a2 ) /*0x153d*/
 break; /*0x153d*/
 ++v3; /*0x153f*/
 ++a2; /*0x1540*/
 }
 return (char)*v3 - (char)*a2; /*0x1547*/
}

/*
 *AsciiStrDecimalToUintn at 0x1555
 */
int __thiscall AsciiStrDecimalToUintn(char *this)
{
 int Result; // ecx char n57; // al Result = 0; /*0x1557*/
 while ( 1 ) /*0x156b*/
 {
 n57 = *this; /*0x156b*/
 if ( *this < 48 || n57 > 57 ) /*0x155d*/
 break; /*0x155d*/
 Result = n57 + 10 *Result - 48; /*0x1568*/
 ++this; /*0x156a*/
 }
 return Result; /*0x1573*/
}

/*
 *DebugPrintWorker at 0x1574
 */
int DebugPrintWorker(int a1, int this, char *ASSERT_in_%s_on_%i:_%s_n, ...)
{
 int result; // eax char *ASSERT_in_%s_on_%i:_%s_n_1; // eax va_list va; // [esp+18h] [ebp+14h] BYREF va_start(va, ASSERT_in_%s_on_%i:_%s_n);
 result = (*(int (__stdcall **)(int))(*(_DWORD *)this + 32))(this); /*0x158d*/
 if ( result >= 0 ) /*0x1595*/
 {
 if ( this ) /*0x159d*/
 {
 result = GetDebugLevel(); /*0x159f*/
 if ( (result & a1) != 0 ) /*0x15a9*/
 {
 ASSERT_in_%s_on_%i:_%s_n_1 = ASSERT_in_%s_on_%i:_%s_n; /*0x15ab*/
 if ( *ASSERT_in_%s_on_%i:_%s_n ) /*0x15ae*/
 {
 do /*0x15ce*/
 {
 if ( *ASSERT_in_%s_on_%i:_%s_n_1 == 37 ) /*0x15b6*/
 {
 if ( *++ASSERT_in_%s_on_%i:_%s_n_1 == 115 ) /*0x15be*/
 {
 *ASSERT_in_%s_on_%i:_%s_n_1 = 97; /*0x15c0*/
 }
 else if ( *ASSERT_in_%s_on_%i:_%s_n_1 == 71 ) /*0x15c8*/
 {
 *ASSERT_in_%s_on_%i:_%s_n_1 = 103; /*0x15ca*/
 }
 }
 ++ASSERT_in_%s_on_%i:_%s_n_1; /*0x15cd*/
 }
 while ( *ASSERT_in_%s_on_%i:_%s_n_1 ); /*0x15ce*/
 ASSERT_in_%s_on_%i:_%s_n_1 = ASSERT_in_%s_on_%i:_%s_n; /*0x15d3*/
 }
 return (*(int ( **)(int, char *, char *))this)(a1, ASSERT_in_%s_on_%i:_%s_n_1, (char *)va); /*0x15dc*/
 }
 }
 }
 return result; /*0x15e4*/
}

/*
 *SetMemAligned at 0x15fa
 */
_BYTE *__usercall SetMemAligned@<eax>(int value@<eax>, _BYTE *buf, unsigned int n6, char a4)
{
 unsigned int n6_1; // ecx _BYTE *buf_1; // edi __int16 value_1; // bx int value_2; // eax int v8; // edx char n6_2; // dl unsigned int count; // ecx n6_1 = n6; /*0x15fa*/
 LOBYTE(value) = a4; /*0x15fe*/
 buf_1 = buf; /*0x1603*/
 BYTE1(value) = a4; /*0x160c*/
 value_1 = value; /*0x160e*/
 value_2 = value << 16; /*0x1611*/
 LOWORD(value_2) = value_1; /*0x1614*/
 if ( n6 >= 4 ) /*0x161a*/
 {
 v8 = (unsigned __int8)buf & 3; /*0x161e*/
 if ( ((unsigned __int8)buf & 3) != 0 ) /*0x1621*/
 {
 memset(buf, value_1, 4 - v8); /*0x162c*/
 buf_1 = &buf[4 - v8]; /*0x162c*/
 n6_1 = n6 - (4 - v8); /*0x162e*/
 }
 n6_2 = n6_1; /*0x1630*/
 count = n6_1 >> 2; /*0x1632*/
 memset32(buf_1, value_2, count); /*0x1635*/
 buf_1 += 4 *count; /*0x1635*/
 n6_1 = n6_2 & 3; /*0x163a*/
 }
 memset(buf_1, value_1, n6_1); /*0x163c*/
 return buf; /*0x1640*/
}

/*
 *CopyMem at 0x1650
 */
_BYTE *CopyMem(_BYTE *dst, unsigned int src, unsigned int n5)
{
 unsigned int src_1; // esi _BYTE *dst_1; // edi unsigned int n5_1; // ecx char v10; // dl _BYTE *n4; // eax unsigned int count; // eax int count_1; // ebx char n5_2; // al unsigned int Ptr; // ecx int n5_3; // eax __asm { pushfw } /*0x1656*/
 src_1 = src; /*0x165b*/
 dst_1 = dst; /*0x165e*/
 n5_1 = n5; /*0x1661*/
 v10 = 0; /*0x1664*/
 n4 = (_BYTE *)(src - (_DWORD)dst); /*0x1668*/
 if ( src < (unsigned int)dst ) /*0x166a*/
 {
 n4 = &dst[-src]; /*0x166f*/
 if ( n5 + src >= (unsigned int)dst ) /*0x1673*/
 {
 src_1 = n5 + src; /*0x1675*/
 dst_1 = &dst[n5]; /*0x1677*/
 v10 = 1; /*0x167a*/
 }
 }
 if ( n5 < 4 || (unsigned int)n4 < 4 ) /*0x1685*/
 goto LABEL_19; /*0x1685*/
 count = src_1 & 3; /*0x168b*/
 count_1 = (unsigned __int8)dst_1 & 3; /*0x168e*/
 if ( v10 ) /*0x1693*/
 {
 --src_1; /*0x1695*/
 --dst_1; /*0x1696*/
 }
 if ( count == count_1 && count ) /*0x169d*/
 {
 if ( !v10 ) /*0x16a1*/
 count = 4 - count; /*0x16a5*/
 qmemcpy(dst_1, (const void *)src_1, count); /*0x16ab*/
 src_1 += count; /*0x16ab*/
 dst_1 += count; /*0x16ab*/
 n5_1 = n5 - count; /*0x16ad*/
 }
 if ( v10 ) /*0x16b1*/
 {
 src_1 -= 3; /*0x16b3*/
 dst_1 -= 3; /*0x16b6*/
 }
 n5_2 = n5_1; /*0x16b9*/
 Ptr = n5_1 >> 2; /*0x16bb*/
 qmemcpy(dst_1, (const void *)src_1, 4 *Ptr); /*0x16be*/
 src_1 += 4 *Ptr; /*0x16be*/
 dst_1 += 4 *Ptr; /*0x16be*/
 n5_3 = n5_2 & 3; /*0x16c0*/
 if ( n5_3 ) /*0x16c3*/
 {
 if ( v10 ) /*0x16c7*/
 {
 src_1 += 4; /*0x16c9*/
 dst_1 += 4; /*0x16cc*/
 }
 n5_1 = n5_3; /*0x16cf*/
LABEL_19:
 if ( v10 ) /*0x16d3*/
 {
 --src_1; /*0x16d5*/
 --dst_1; /*0x16d6*/
 }
 qmemcpy(dst_1, (const void *)src_1, n5_1); /*0x16d7*/
 }
 __asm { popfw } /*0x16d9*/
 return dst; /*0x16dc*/
}