/*
 *CmosPei - Decompiled CmosPei
 *Source: Auto-generated from IDA Pro decompilation
 *
 *Decompiled from port 13404
 */

#include "CmosPei.h"

/*
 *SetMem at 0xffe6427c
 */
void *SetMem(void *buf, unsigned int count, char value)
{
 memset(buf, value, count); /*0xffe64289*/
 return buf; /*0xffe6428f*/
}

/*
 *CopyMem at 0xffe642bc
 */
char *CopyMem(char *dst, char *src, unsigned int count)
{
 unsigned int count_1; // edx char *dst_1; // edi char *src_1; // esi count_1 = count; /*0xffe642c6*/
 if ( src < dst && &src[count - 1] >= dst ) /*0xffe642d4*/
 {
 src_1 = &src[count - 1]; /*0xffe642e8*/
 dst_1 = &dst[count - 1]; /*0xffe642ea*/
 }
 else
 {
 count_1 = count & 3; /*0xffe642d8*/
 qmemcpy(dst, src, 4 * (count >> 2)); /*0xffe642e1*/
 src_1 = &src[4 * (count >> 2)]; /*0xffe642e1*/
 dst_1 = &dst[4 * (count >> 2)]; /*0xffe642e1*/
 }
 qmemcpy(dst_1, src_1, count_1); /*0xffe642f1*/
 return dst; /*0xffe642f8*/
}

/*
 *SetMem32 at 0xffe642fc
 */
int SetMem32(int a1, int a2, int a3, int a4)
{
 do /*0xffe64315*/
 {
 *(_DWORD *)(a1 + 8 *a2 - 8) = a3; /*0xffe6430d*/
 *(_DWORD *)(a1 + 8 *a2-- - 4) = a4; /*0xffe64311*/
 }
 while ( a2 ); /*0xffe64315*/
 return a1; /*0xffe64319*/
}

/*
 *SetMemN at 0xffe6431c
 */
void *SetMemN(void *buf, unsigned int count, int value)
{
 memset32(buf, value, count); /*0xffe64329*/
 return buf; /*0xffe6432f*/
}

/*
 *_ModuleEntryPoint at 0xffe6433c
 */
EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
 _DWORD *v2; // eax _DWORD *v3; // esi if ( *(char *)(PcdGetPtr() + 1024068) >= 0 ) /*0xffe6434a*/
 {
 PcdSet16(); /*0xffe6434c*/
 PcdSetBit(); /*0xffe64351*/
 }
 DebugPrint(-1, SystemTable, "CmosManagerPeiEntry Entry\n"); /*0xffe646c7*/
 v2 = CmosControllerConstructor(SystemTable); /*0xffe646d1*/
 v3 = v2; /*0xffe646d6*/
 if ( v2 && (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v2 + 170))(v2, 8) ) /*0xffe646e3*/
 {
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 2) ) /*0xffe646f6*/
 return 0; /*0xffe64704*/
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 0x80000) /*0xffe64729*/
 && (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 0x20000) )
 {
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 16) /*0xffe6474a*/
 && (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 0x10000) )
 {
 goto LABEL_22; /*0xffe64754*/
 }
 (*(void ( **)(_DWORD *, _DWORD))((char *)v3 + 182))(v3, 0); /*0xffe64775*/
 }
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 174))(v3, 4224) ) /*0xffe64783*/
 {
 if ( !(*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 128) /*0xffe647b8*/
 && !(*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 4096) )
 {
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 0x80000) ) /*0xffe647d3*/
 (*(int ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 0x40000); /*0xffe647e5*/
 }
 }
 else
 {
 ((void ( *)(_DWORD *))v3[8])(v3); /*0xffe64830*/
 if ( (*(unsigned __int8 ( **)(_DWORD *, int))((char *)v3 + 170))(v3, 1) ) /*0xffe64836*/
 {
 (*(void ( **)(EFI_SYSTEM_TABLE *, void *))(LODWORD(SystemTable->Hdr.Signature) + 36))( /*0xffe64862*/
 SystemTable,
 &unk_FFE66C40);
 return 0; /*0xffe64867*/
 }
 }
LABEL_22:
 JUMPOUT(0xFFE64550); /*0xffe64550*/
 }
 return -2147483645; /*0xffe64859*/
}

/*
 *CmosControllerValidate at 0xffe6486c
 */
int CmosControllerValidate(int a1)
{
 int Result; // edi Result = 0; /*0xffe64872*/
 if ( a1 && (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 8) ) /*0xffe6487b*/
 return a1; /*0xffe64887*/
 return Result; /*0xffe6488b*/
}

/*
 *CmosFlagCheckAllSet at 0xffe6488e
 */
bool CmosFlagCheckAllSet(int a1, int a2)
{
 return (a2 & *(_DWORD *)(a1 + 158)) == a2; /*0xffe648a3*/
}

/*
 *CmosFlagCheckAnySet at 0xffe648a4
 */
bool CmosFlagCheckAnySet(int a1, int a2)
{
 return (a2 & *(_DWORD *)(a1 + 158)) != 0; /*0xffe648b5*/
}

/*
 *CmosFlagSetOrClear at 0xffe648b6
 */
int CmosFlagSetOrClear(int a1, int n8, int a3)
{
 __int16 n8_1; // bx int result; // eax int Result; // ecx n8_1 = n8; /*0xffe648bb*/
 if ( a3 == 1 ) /*0xffe648c4*/
 {
 *(_DWORD *)(a1 + 158) |= n8; /*0xffe648c6*/
 result = (*(int ( **)(int, int))(a1 + 170))(a1, 0x80000); /*0xffe648d2*/
 if ( (_BYTE)result ) /*0xffe648dc*/
 {
 if ( (n8_1 & 0x1000) != 0 ) /*0xffe648e4*/
 result = (*(int ( **)(int, int, int))(a1 + 8))(a1, 4658, 1); /*0xffe648ed*/
 if ( (n8_1 & 0x80u) != 0 ) /*0xffe648f5*/
 result = (*(int ( **)(int, int, int))(a1 + 8))(a1, 4659, 1); /*0xffe648fe*/
 if ( (n8_1 & 0x4000) != 0 ) /*0xffe6490a*/
 result = (*(int ( **)(int, int, int))(a1 + 8))(a1, 4660, 1); /*0xffe64913*/
 if ( (n8_1 & 0x10) != 0 ) /*0xffe6491c*/
 result = (*(int ( **)(int, int, int))(a1 + 8))(a1, 4661, 1); /*0xffe64925*/
 }
 }
 else
 {
 result = ~n8; /*0xffe6492f*/
 *(_DWORD *)(a1 + 158) &= ~n8; /*0xffe64931*/
 }
 if ( (n8_1 & 0x1080) != 0 ) /*0xffe6493d*/
 result = CmosSmiInterruptConfig((_DWORD *)a1, n8_1, a3); /*0xffe64947*/
 Result = *(_DWORD *)(a1 + 178); /*0xffe6494d*/
 if ( Result ) /*0xffe64955*/
 {
 result = *(_DWORD *)(a1 + 158); /*0xffe64957*/
 *(_DWORD *)(Result + 24) = result; /*0xffe6495d*/
 }
 return result; /*0xffe64960*/
}

/*
 *CmosFlagSet at 0xffe64964
 */
int CmosFlagSet(int a1, int n8)
{
 return CmosFlagSetOrClear(a1, n8, 1); /*0xffe64974*/
}

/*
 *CmosFlagClear at 0xffe64975
 */
int CmosFlagClear(int a1, int n8)
{
 return CmosFlagSetOrClear(a1, n8, 0); /*0xffe64985*/
}

/*
 *CmosControllerInit at 0xffe64986
 */
int CmosControllerInit(_DWORD *a1, char a2)
{
 unsigned int dst_1; // ecx unsigned int dst; // [esp+0h] [ebp-4h] BYREF dst = dst_1; /*0xffe64989*/
 if ( (a2 & 0xC) == 0xC ) /*0xffe64992*/
 return -2147483646; /*0xffe64999*/
 if ( (a2 & 4) == 0 ) /*0xffe649ac*/
 goto LABEL_8; /*0xffe649ac*/
 if ( !(*(unsigned __int8 ( **)(_DWORD *, int))((char *)a1 + 170))(a1, 0x2000) ) /*0xffe649b0*/
 {
 if ( !(*(unsigned __int8 ( **)(_DWORD *, int))((char *)a1 + 170))(a1, 64) ) /*0xffe649bf*/
 {
 (*(void ( **)(_DWORD, int, unsigned int *))(*(_DWORD *)*a1 + 76))( /*0xffe649db*/
 *a1,
 2 * *((unsigned __int16 *)a1 + 61),
 &dst);
 CopyMemOverlap(dst, *(char **)((char *)a1 + 118), 2 * *((unsigned __int16 *)a1 + 61)); /*0xffe649eb*/
 *(_DWORD *)((char *)a1 + 118) = dst; /*0xffe649f6*/
 }
 (*(void ( **)(_DWORD *, int))((char *)a1 + 162))(a1, 0x2000); /*0xffe649fc*/
 (*(void ( **)(_DWORD *, _DWORD *))((char *)a1 + 142))(a1, a1 + 35); /*0xffe64a0a*/
 (*(void ( **)(_DWORD *, _DWORD))((char *)a1 + 150))(a1, *((unsigned __int16 *)a1 + 70)); /*0xffe64a15*/
LABEL_8:
 if ( (a2 & 8) != 0 ) /*0xffe64a23*/
 (*(void ( **)(_DWORD *, int))((char *)a1 + 166))(a1, 0x2000); /*0xffe64a27*/
 }
 return 0; /*0xffe64a35*/
}

/*
 *CmosIoWrite32 at 0xffe64a37
 */
int CmosIoWrite32(int a1, unsigned int a2)
{
 unsigned int v2; // edi unsigned int i; // ebx v2 = a2; /*0xffe64a3f*/
 if ( !a2 ) /*0xffe64a44*/
 v2 = (*(int ( **)(int))(a1 + 36))(a1); /*0xffe64a4b*/
 if ( !(*(unsigned __int8 ( **)(int, int))(a1 + 174))(a1, 0x80000) ) /*0xffe64a53*/
 return -2147483641; /*0xffe64a5f*/
 for ( i = 0; i < 4; ++i ) /*0xffe64a67*/
 {
 HIBYTE(a2) = v2 >> (8 * (3 - i)); /*0xffe64a79*/
 CmosRegisterReadModifyWrite(a1, 0, i + 66, 255, (char *)&a2 + 3); /*0xffe64a89*/
 }
 return 0; /*0xffe64a9a*/
}

/*
 *CmosIoRead32 at 0xffe64a9e
 */
int CmosIoRead32(int a1, int *a2)
{
 int v2; // edi int v3; // esi unsigned __int8 i; // bl v2 = a1; /*0xffe64aa4*/
 v3 = 0; /*0xffe64aa7*/
 if ( !(*(unsigned __int8 ( **)(int, int))(a1 + 174))(a1, 0x80000) ) /*0xffe64aaf*/
 return -2147483641; /*0xffe64abb*/
 for ( i = 0; i < 4u; ++i ) /*0xffe64ac3*/
 {
 CmosAccessByRange(v2, 1, (unsigned __int16)(i + 66), (unsigned __int8 *)&a1 + 3); /*0xffe64add*/
 v3 = HIBYTE(a1) | (v3 << 8); /*0xffe64ae9*/
 }
 *a2 = v3; /*0xffe64af8*/
 return 0; /*0xffe64afc*/
}

/*
 *CmosPpiNotify at 0xffe64b02
 */
int CmosPpiNotify(_DWORD *a1)
{
 int Result; // edi Result = (*(int ( **)(_DWORD, _DWORD *))(*(_DWORD *)*a1 + 24))(*a1, a1 + 18); /*0xffe64b14*/
 if ( Result < 0 ) /*0xffe64b1a*/
 {
 (*(void ( **)(_DWORD *, int))((char *)a1 + 162))(a1, 4); /*0xffe64b2c*/
 (*(void ( **)(_DWORD *, int))((char *)a1 + 166))(a1, 1); /*0xffe64b35*/
 }
 else
 {
 (*(void ( **)(_DWORD *, int))((char *)a1 + 162))(a1, 1); /*0xffe64b1f*/
 }
 return Result; /*0xffe64b40*/
}

/*
 *CmosControllerInstall at 0xffe64b43
 */
int CmosControllerInstall(int SystemTable, _DWORD *buf)
{
 *buf = SystemTable; /*0xffe64b46*/
 buf[1] = CmosRead; /*0xffe64b48*/
 buf[2] = CmosWrite; /*0xffe64b4f*/
 buf[3] = CmosRegisterLookupByOffset; /*0xffe64b56*/
 buf[4] = CmosGetRegisterTable; /*0xffe64b5d*/
 buf[5] = CmosGetDateTime; /*0xffe64b64*/
 buf[6] = CmosSetDateTime; /*0xffe64b6b*/
 buf[9] = CmosControllerValidate; /*0xffe64b72*/
 buf[8] = CmosPpiNotify; /*0xffe64b79*/
 *(_DWORD *)((char *)buf + 142) = CmosChecksumVerify; /*0xffe64b80*/
 *(_DWORD *)((char *)buf + 146) = CmosChecksumGetSaved; /*0xffe64b8a*/
 *(_DWORD *)((char *)buf + 150) = CmosChecksumUpdate; /*0xffe64b94*/
 buf[34] = CmosControllerInit; /*0xffe64b9e*/
 *(_DWORD *)((char *)buf + 170) = CmosFlagCheckAllSet; /*0xffe64ba8*/
 *(_DWORD *)((char *)buf + 174) = CmosFlagCheckAnySet; /*0xffe64bb2*/
 *(_DWORD *)((char *)buf + 162) = CmosFlagSet; /*0xffe64bbc*/
 *(_DWORD *)((char *)buf + 166) = CmosFlagClear; /*0xffe64bc6*/
 *(_DWORD *)((char *)buf + 154) = CmosLoadDefaults; /*0xffe64bd0*/
 *(_DWORD *)((char *)buf + 182) = CmosIoWrite32; /*0xffe64bda*/
 *(_DWORD *)((char *)buf + 186) = CmosIoRead32; /*0xffe64be4*/
 CmosFlagSet((int)buf, 8); /*0xffe64bee*/
 return 0; /*0xffe64bf7*/
}

/*
 *CmosControllerConstructor at 0xffe64bf8
 */
char *__thiscall CmosControllerConstructor(EFI_SYSTEM_TABLE *SystemTable)
{
 int value; // eax char *buf_1; // eax unsigned __int8 ( **v5)(_DWORD); // edi unsigned __int8 ( **v6)(_DWORD); // ebx unsigned __int8 ( **v7)(_DWORD); // esi unsigned __int8 ( **i)(_DWORD); // ebp char *buf; // [esp+8h] [ebp-4h] BYREF if ( (*(int ( **)(EFI_SYSTEM_TABLE *, void *, _DWORD, _DWORD, char **))(LODWORD(SystemTable->Hdr.Signature) + 32))( /*0xffe64c0e*/
 SystemTable,
 &unk_FFE66BEC,
 0,
 0,
 &buf) )
 {
 value = (*(int ( **)(EFI_SYSTEM_TABLE *, int, char **))(LODWORD(SystemTable->Hdr.Signature) + 76))( /*0xffe64c3f*/
 SystemTable,
 220,
 &buf);
 if ( value >= 0 ) /*0xffe64c47*/
 {
 SetMemM(value, buf, 0xDCu, 0); /*0xffe64c57*/
 CmosControllerInstall((int)SystemTable, buf); /*0xffe64c65*/
 ((void (__thiscall *)(char *))loc_FFE645D2)(buf); /*0xffe64c6e*/
 buf_1 = buf; /*0xffe64c73*/
 v5 = *(unsigned __int8 ( ***)(_DWORD))(buf + 194); /*0xffe64c77*/
 v6 = *(unsigned __int8 ( ***)(_DWORD))(buf + 198); /*0xffe64c7d*/
 v7 = *(unsigned __int8 ( ***)(_DWORD))(buf + 202); /*0xffe64c83*/
 for ( i = *(unsigned __int8 ( ***)(_DWORD))(buf + 206); *i; ++i ) /*0xffe64c89*/
 {
 if ( (*i)(*(_DWORD *)buf_1) ) /*0xffe64c98*/
 (*(void ( **)(char *, int))(buf + 162))(buf, 0x80000); /*0xffe64ca9*/
 else
 (*(void ( **)(char *, int))(buf + 166))(buf, 0x80000); /*0xffe64cb1*/
 buf_1 = buf; /*0xffe64cb7*/
 }
 while ( *v5 ) /*0xffe64cc7*/
 {
 if ( (*v5)(*(_DWORD *)buf_1) ) /*0xffe64ccb*/
 (*(void ( **)(char *, int))(buf + 162))(buf, 16); /*0xffe64cd9*/
 buf_1 = buf; /*0xffe64ce1*/
 ++v5; /*0xffe64ce5*/
 }
 while ( *v6 ) /*0xffe64cee*/
 {
 if ( (*v6)(*(_DWORD *)buf_1) ) /*0xffe64cf2*/
 (*(void ( **)(char *, int))(buf + 162))(buf, 0x10000); /*0xffe64d03*/
 buf_1 = buf; /*0xffe64d0b*/
 ++v6; /*0xffe64d0f*/
 }
 while ( *v7 ) /*0xffe64d18*/
 {
 if ( (*v7)(*(_DWORD *)buf_1) ) /*0xffe64d1c*/
 (*(void ( **)(char *, int))(buf + 162))(buf, 0x20000); /*0xffe64d2d*/
 buf_1 = buf; /*0xffe64d35*/
 ++v7; /*0xffe64d39*/
 }
 (*(void ( **)(char *, int))(buf_1 + 162))(buf_1, 0x40000); /*0xffe64d44*/
 (*(void ( **)(char *, char *))(buf + 142))(buf, buf + 140); /*0xffe64d56*/
 CmosCheckBatteryStatus(buf); /*0xffe64d63*/
 return buf; /*0xffe64d68*/
 }
 else
 {
 return 0; /*0xffe64c49*/
 }
 }
 else
 {
 (*(void ( **)(char *, int))(buf + 162))(buf, 2); /*0xffe64c1f*/
 return buf; /*0xffe64c25*/
 }
}

/*
 *CmosRegisterLookupByIndex at 0xffe64d71
 */
unsigned __int16 CmosRegisterLookupByIndex(int a1, __int16 n0xE)
{
 unsigned __int16 v2; // di unsigned __int16 Index; // si int v4; // ecx v2 = *(_WORD *)(a1 + 116); /*0xffe64d74*/
 Index = 1; /*0xffe64d7d*/
 if ( v2 > 1u ) /*0xffe64d83*/
 {
 v4 = *(_DWORD *)(a1 + 112); /*0xffe64d85*/
 do /*0xffe64d95*/
 {
 if ( *(_WORD *)(v4 + 2 *Index) == n0xE ) /*0xffe64d8f*/
 break; /*0xffe64d8f*/
 ++Index; /*0xffe64d91*/
 }
 while ( Index < v2 ); /*0xffe64d95*/
 }
 if ( Index >= v2 ) /*0xffe64d9a*/
 return 0; /*0xffe64da1*/
 else return Index; /*0xffe64d9c*/
}

/*
 *CmosRegisterLookupByOffset at 0xffe64da7
 */
int CmosRegisterLookupByOffset(int a1, __int16 a2)
{
 unsigned __int16 Index; // cx unsigned __int16 v3; // di int result; // eax Index = 1; /*0xffe64daf*/
 v3 = *(_WORD *)(a1 + 116); /*0xffe64db4*/
 if ( v3 > 1u ) /*0xffe64db9*/
 {
 do /*0xffe64dde*/
 {
 if ( ((*(_WORD *)(*(_DWORD *)(a1 + 112) + 2 *Index) >> 3) & 0x1FF) == a2 ) /*0xffe64dd8*/
 break; /*0xffe64dd8*/
 ++Index; /*0xffe64dda*/
 }
 while ( Index < v3 ); /*0xffe64dde*/
 }
 if ( Index >= *(_WORD *)(a1 + 116) ) /*0xffe64de7*/
 return 0; /*0xffe64de7*/
 result = *(unsigned __int16 *)(*(_DWORD *)(a1 + 112) + 2 *Index); /*0xffe64df4*/
 if ( (result & 0xF000) != 0x8000 ) /*0xffe64e03*/
 return 0; /*0xffe64e05*/
 return result; /*0xffe64de2*/
}

/*
 *CmosAccessByRange at 0xffe64e08
 */
int CmosAccessByRange(int a1, int a2, int a3, unsigned __int8 *a4)
{
 int Result; // esi unsigned __int8 Index; // bl unsigned __int16 v7; // bp int v8; // ecx int v9; // edx int v10; // eax int v11; // esi unsigned __int8 v12; // al Result = -2147483634; /*0xffe64e15*/
 Index = 1; /*0xffe64e1b*/
 v7 = *(_WORD *)(a1 + 218); /*0xffe64e1d*/
 if ( v7 > 1u ) /*0xffe64e27*/
 {
 v8 = *(_DWORD *)(a1 + 214); /*0xffe64e2d*/
 v9 = a3; /*0xffe64e33*/
 while ( 1 ) /*0xffe64e3a*/
 {
 v10 = 12 *Index; /*0xffe64e3a*/
 if ( (unsigned __int16)v9 >= *(_WORD *)(v10 + v8 + 4) && (unsigned __int16)v9 <= *(_WORD *)(v10 + v8 + 6) ) /*0xffe64e49*/
 {
 if ( *(_DWORD *)(v10 + v8 + 8) ) /*0xffe64e4b*/
 return (*(int ( **)(_DWORD, int, int, unsigned __int8 *))(12 *Index + v8 + 8))(*(_DWORD *)a1, a2, v9, a4); /*0xffe64ecf*/
 v7 = *(_WORD *)(a1 + 218); /*0xffe64e58*/
 if ( *(_WORD *)(v10 + v8) ) /*0xffe64e54*/
 {
 v9 = a3; /*0xffe64e68*/
 if ( *(_WORD *)(v10 + v8 + 2) ) /*0xffe64e63*/
 break; /*0xffe64e63*/
 }
 }
 if ( ++Index >= v7 ) /*0xffe64e76*/
 return Result; /*0xffe64e76*/
 }
 v11 = 12 *Index; /*0xffe64e7d*/
 __outbyte(*(_WORD *)(v11 + v8), a3); /*0xffe64e88*/
 if ( a2 == 1 ) /*0xffe64e8e*/
 {
 v12 = __inbyte(*(_WORD *)(*(_DWORD *)(a1 + 214) + v11 + 2)); /*0xffe64e9b*/
 *a4 = v12; /*0xffe64ea2*/
 }
 else
 {
 __outbyte(*(_WORD *)(*(_DWORD *)(a1 + 214) + v11 + 2), *a4); /*0xffe64eb9*/
 }
 return 0; /*0xffe64ed6*/
 }
 return Result; /*0xffe64ed8*/
}

/*
 *CmosRegisterReadModifyWrite at 0xffe64ee0
 */
int CmosRegisterReadModifyWrite(int va_, int a2, unsigned int n0xD, char n255, char *va)
{
 unsigned int v8; // [esp+8h] [ebp-Ch] BYREF unsigned __int8 v9[4]; // [esp+Ch] [ebp-8h] BYREF unsigned __int8 v10[4]; // [esp+10h] [ebp-4h] BYREF v8 = 0; /*0xffe64ee6*/
 CmosAccessByRange(va_, 1, n0xD, v10); /*0xffe64efa*/
 if ( a2 == 1 ) /*0xffe64f04*/
 {
 *va = v10[0]; /*0xffe64f0c*/
 }
 else
 {
 v9[0] = *va | v10[0] & ~n255; /*0xffe64f27*/
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 1024) ) /*0xffe64f2a*/
 CmosChecksumAccumulateRegister(va_, n0xD, v10[0], v9[0], &v8); /*0xffe64f45*/
 CmosAccessByRange(va_, 0, n0xD, v9); /*0xffe64f58*/
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 1024) /*0xffe64f72*/
 && (*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 256) )
 {
 (*(void ( **)(int, int))(va_ + 162))(va_, 1024); /*0xffe64f80*/
 CmosChecksumUpdate(va_, v8); /*0xffe64f8a*/
 (*(void ( **)(int, int))(va_ + 166))(va_, 1024); /*0xffe64f91*/
 }
 }
 return 0; /*0xffe64f9a*/
}

/*
 *CmosBufferReadWrite at 0xffe64fa2
 */
int CmosBufferReadWrite(int va_, int a2, unsigned __int16 i, char n255, _BYTE *va)
{
 int Ptr; // ebp char v7; // cl unsigned __int8 v8; // bl unsigned int v10; // [esp+8h] [ebp-8h] BYREF unsigned __int8 v11[4]; // [esp+Ch] [ebp-4h]

 v10 = 0; /*0xffe64fa4*/
 if ( (unsigned __int16)(i - 64) > 0x31u )
 {
 ((void (*)(int, const char *, ...))loc_FFE64550)(va_, " CmosBufferReadWrite: Invalid CmosAddress (0x%X)\n", i);
 return -2147483646; /*0xffe6507a*/
 }
 else
 {
 Ptr = (unsigned __int16)(i - 63); /*0xffe64fc7*/
 v7 = *(_BYTE *)(*(_DWORD *)(va_ + 118) + 2 *Ptr); /*0xffe64fc9*/
 v11[0] = *(_BYTE *)(*(_DWORD *)(va_ + 118) + 2 *Ptr); /*0xffe64fd0*/
 if ( a2 == 1 ) /*0xffe64fd7*/
 {
 *va = v7; /*0xffe64fd9*/
 }
 else
 {
 v8 = *va | v7 & ~n255; /*0xffe64fe9*/
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 1024) ) /*0xffe64ff5*/
 CmosChecksumAccumulateRegister(va_, i, v11[0], v8, &v10); /*0xffe65012*/
 *(_BYTE *)(*(_DWORD *)(va_ + 118) + 2 *Ptr) = v8; /*0xffe65024*/
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 1024) ) /*0xffe65027*/
 {
 if ( (*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 256) ) /*0xffe6503a*/
 {
 (*(void ( **)(int, int))(va_ + 162))(va_, 1024); /*0xffe65048*/
 CmosChecksumUpdate(va_, v10); /*0xffe65053*/
 (*(void ( **)(int, int))(va_ + 166))(va_, 1024); /*0xffe6505a*/
 }
 }
 }
 return 0; /*0xffe65063*/
 }
}

/*
 *CmosSelectAccessMethod at 0xffe65084
 */
int CmosSelectAccessMethod(int va_, int a2, unsigned int i, char n255, char *va)
{
 unsigned __int16 j_1; // dx unsigned __int16 j; // cx if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 0x2000) ) /*0xffe65091*/
 return CmosRegisterReadModifyWrite(va_, a2, i, n255, va); /*0xffe65091*/
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 0x80000) /*0xffe650b9*/
 || !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 0x8000) )
 {
 return CmosBufferReadWrite(va_, a2, i, n255, va); /*0xffe650b9*/
 }
 j_1 = *(_WORD *)(va_ + 128); /*0xffe650c5*/
 for ( j = 1; j < j_1; ++j ) /*0xffe650d2*/
 {
 if ( (unsigned __int16)i <= *(_WORD *)(*(_DWORD *)(va_ + 124) + 2 *j) ) /*0xffe650df*/
 break; /*0xffe650df*/
 }
 if ( (_WORD)i == *(_WORD *)(*(_DWORD *)(va_ + 124) + 2 *j) ) /*0xffe650f2*/
 return CmosRegisterReadModifyWrite(va_, a2, i, n255, va); /*0xffe65115*/
 else return CmosBufferReadWrite(va_, a2, i, n255, va); /*0xffe65101*/
}

/*
 *CmosBitFieldAccess at 0xffe65121
 */
int CmosBitFieldAccess(int a1, int a2, unsigned __int16 a3, char *va)
{
 int v4; // ebp char n255; // [esp+10h] [ebp-Ch]

 v4 = *(_DWORD *)(a1 + 112); /*0xffe65126*/
 n255 = 0; /*0xffe65138*/
 if ( !a2 ) /*0xffe6514d*/
 {
 if ( ((unsigned __int8)~(255 >> (8 - (*(unsigned __int16 *)(v4 + 2 *a3) >> 12))) & (unsigned __int8)*va) != 0 ) /*0xffe65165*/
 return -2147483646; /*0xffe6516c*/
 *va <<= *(_BYTE *)(v4 + 2 *a3) & 7; /*0xffe65177*/
 n255 = (unsigned __int8)(255 >> (8 - (*(unsigned __int16 *)(v4 + 2 *a3) >> 12))) << (*(_BYTE *)(v4 + 2 *a3) & 7); /*0xffe65196*/
 }
 CmosSelectAccessMethod(a1, a2, (*(_WORD *)(v4 + 2 *a3) >> 3) & 0x1FF, n255, va); /*0xffe651b8*/
 if ( a2 == 1 ) /*0xffe651c5*/
 {
 *va = (unsigned __int8)*va >> (*(_BYTE *)(v4 + 2 *a3) & 7); /*0xffe651ce*/
 *va &= 255 >> (8 - (*(unsigned __int16 *)(v4 + 2 *a3) >> 12)); /*0xffe651df*/
 }
 return 0; /*0xffe651e3*/
}

/*
 *CmosRead at 0xffe651eb
 */
int CmosRead(int a1, int n0xE, unsigned __int8 *va)
{
 int v3; // ecx unsigned __int16 v5; // ax if ( (unsigned __int16)n0xE <= 0xEu ) /*0xffe651f7*/
 {
 v3 = a1; /*0xffe651f9*/
 return CmosAccessByRange(v3, 1, n0xE, va); /*0xffe65232*/
 }
 if ( (unsigned __int16)n0xE < 0x1000u ) /*0xffe65206*/
 {
 if ( !(*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 0x80000) ) /*0xffe65211*/
 return -2147483641; /*0xffe65222*/
 v3 = a1; /*0xffe65224*/
 return CmosAccessByRange(v3, 1, n0xE, va); /*0xffe65224*/
 }
 v5 = CmosRegisterLookupByIndex(a1, n0xE); /*0xffe65239*/
 if ( v5 ) /*0xffe65244*/
 return CmosBitFieldAccess(a1, 1, v5, (char *)va); /*0xffe65250*/
 else return -2147483646; /*0xffe65259*/
}

/*
 *CmosGetRegisterTable at 0xffe65262
 */
int CmosGetRegisterTable(int a1, char *p_n0xD)
{
 char *p_n0xD_1; // esi char *va; // [esp-8h] [ebp-Ch]

 p_n0xD_1 = p_n0xD; /*0xffe65266*/
 if ( !p_n0xD ) /*0xffe6526b*/
 return -2147483646; /*0xffe6526d*/
 va = p_n0xD + 3; /*0xffe6527e*/
 *p_n0xD = 14; /*0xffe65281*/
 p_n0xD_1[2] = 13; /*0xffe65289*/
 CmosRegisterReadModifyWrite(a1, 1, 0xDu, 0, va); /*0xffe6528f*/
 CmosRegisterReadModifyWrite(a1, 1, (unsigned __int8)*p_n0xD_1, 0, p_n0xD_1 + 1); /*0xffe652a3*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 0x2000) ) /*0xffe652ae*/
 p_n0xD_1[4] |= 1u; /*0xffe652bb*/
 else p_n0xD_1[4] &= ~1u; /*0xffe652c1*/
 p_n0xD_1[4] &= 0xC3u; /*0xffe652c5*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 0x80000) ) /*0xffe652cf*/
 {
 p_n0xD_1[4] &= ~2u; /*0xffe652df*/
 (*(void ( **)(int, int, char *))(a1 + 4))(a1, 4658, (char *)&p_n0xD + 3); /*0xffe652ed*/
 p_n0xD_1[4] ^= (p_n0xD_1[4] ^ (p_n0xD_1[4] | (4 *HIBYTE(p_n0xD)))) & 4; /*0xffe6530c*/
 (*(void ( **)(int, int, char *))(a1 + 4))(a1, 4660, (char *)&p_n0xD + 3); /*0xffe6530f*/
 p_n0xD_1[4] ^= (p_n0xD_1[4] ^ (p_n0xD_1[4] | (16 *HIBYTE(p_n0xD)))) & 0x10; /*0xffe6532e*/
 (*(void ( **)(int, int, char *))(a1 + 4))(a1, 4661, (char *)&p_n0xD + 3); /*0xffe65331*/
 p_n0xD_1[4] ^= (p_n0xD_1[4] ^ (p_n0xD_1[4] | (32 *HIBYTE(p_n0xD)))) & 0x20; /*0xffe65350*/
 (*(void ( **)(int, int, char *))(a1 + 4))(a1, 4659, (char *)&p_n0xD + 3); /*0xffe65353*/
 p_n0xD_1[4] ^= (p_n0xD_1[4] ^ (p_n0xD_1[4] | (8 *HIBYTE(p_n0xD)))) & 8; /*0xffe6536b*/
 }
 else
 {
 p_n0xD_1[4] |= 2u; /*0xffe65370*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 4096) ) /*0xffe6537a*/
 p_n0xD_1[4] |= 4u; /*0xffe65386*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 0x4000) ) /*0xffe65390*/
 p_n0xD_1[4] |= 0x10u; /*0xffe6539c*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 16) ) /*0xffe653a3*/
 p_n0xD_1[4] |= 0x20u; /*0xffe653af*/
 if ( (*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 128) ) /*0xffe653b9*/
 p_n0xD_1[4] |= 8u; /*0xffe653c5*/
 }
 return 0; /*0xffe653cc*/
}

/*
 *CmosChecksumGetSaved at 0xffe653cf
 */
int CmosChecksumGetSaved(int va_, _WORD *a2)
{
 (*(void ( **)(int, int, _WORD *))(va_ + 4))(va_, 33280, a2); /*0xffe653e0*/
 *a2 <<= 8; /*0xffe653e3*/
 (*(void ( **)(int, int, _WORD *))(va_ + 4))(va_, 33288, a2); /*0xffe653ee*/
 return 0; /*0xffe653f6*/
}

/*
 *CmosChecksumUpdate at 0xffe653f9
 */
int CmosChecksumUpdate(int va_, unsigned int a2)
{
 int v2; // eax v2 = *(_DWORD *)(va_ + 178); /*0xffe65404*/
 if ( v2 ) /*0xffe6540c*/
 *(_WORD *)(v2 + 28) = a2; /*0xffe6540e*/
 (*(void ( **)(int, int))(va_ + 162))(va_, 1024); /*0xffe65419*/
 (*(void ( **)(int, int, unsigned int))(va_ + 8))(va_, 33288, a2); /*0xffe65426*/
 (*(void ( **)(int, int, unsigned int))(va_ + 8))(va_, 33280, a2 >> 8); /*0xffe65433*/
 (*(void ( **)(int, int))(va_ + 166))(va_, 1024); /*0xffe65438*/
 return 0; /*0xffe65443*/
}

/*
 *CmosCheckBatteryStatus at 0xffe65447
 */
int __thiscall CmosCheckBatteryStatus(char *this)
{
 int ( **v2)(_DWORD); // edi int ( *v3)(_DWORD); // eax char v4; // cl v2 = *(int ( ***)(_DWORD))(this + 210); /*0xffe6544b*/
 v3 = *v2; /*0xffe65451*/
 if ( !*v2 ) /*0xffe65451*/
 goto LABEL_5; /*0xffe65451*/
 do /*0xffe65461*/
 {
 ++v2; /*0xffe6545c*/
 v4 = v3(*(_DWORD *)this); /*0xffe6545f*/
 v3 = *v2; /*0xffe65461*/
 }
 while ( *v2 ); /*0xffe65461*/
 if ( v4 ) /*0xffe65469*/
 (*(void ( **)(char *, int))(this + 166))(this, 4096); /*0xffe65471*/
 else LABEL_5:
 (*(void ( **)(char *, int))(this + 162))(this, 4096); /*0xffe6547f*/
 return 0; /*0xffe65487*/
}

/*
 *CmosSmiInterruptConfig at 0xffe6548c
 */
int CmosSmiInterruptConfig(_DWORD *a1, __int16 n8, int a3)
{
 unsigned __int8 v6; // [esp+Bh] [ebp-1h] BYREF if ( (n8 & 0x80u) != 0 ) /*0xffe65498*/
 {
 CmosAccessByRange((int)a1, 1, 14, &v6); /*0xffe654a3*/
 if ( a3 == 1 ) /*0xffe654ae*/
 {
 v6 |= 0x40u; /*0xffe654b0*/
 }
 else if ( !*a1 ) /*0xffe654b6*/
 {
 v6 &= ~0x40u; /*0xffe654bb*/
 }
 CmosAccessByRange((int)a1, 0, 14, &v6); /*0xffe654c9*/
 }
 if ( (n8 & 0x1000) != 0 ) /*0xffe654d6*/
 {
 CmosAccessByRange((int)a1, 1, 14, &v6); /*0xffe654e3*/
 if ( a3 == 1 ) /*0xffe654ee*/
 {
 v6 |= 0x80u; /*0xffe654f0*/
 }
 else if ( !*a1 ) /*0xffe654f6*/
 {
 v6 &= ~0x80u; /*0xffe654fb*/
 }
 CmosAccessByRange((int)a1, 0, 14, &v6); /*0xffe65509*/
 }
 return 0; /*0xffe65510*/
}

/*
 *CmosChecksumAccumulateRegister at 0xffe65518
 */
int CmosChecksumAccumulateRegister(
 int va_,
 unsigned __int16 n0xD,
 unsigned __int8 a3,
 unsigned __int8 a4,
 _WORD *a5)
{
 unsigned __int16 v6; // si unsigned __int16 v7; // cx unsigned __int16 v8; // bx unsigned __int16 v9; // bx v6 = 1; /*0xffe65520*/
 v7 = 1; /*0xffe65521*/
 v8 = *(_WORD *)(va_ + 128); /*0xffe65523*/
 if ( v8 > 1u ) /*0xffe6552d*/
 {
 do /*0xffe65540*/
 {
 if ( n0xD <= *(_WORD *)(*(_DWORD *)(va_ + 124) + 2 *v7) ) /*0xffe6553a*/
 break; /*0xffe6553a*/
 ++v7; /*0xffe6553c*/
 }
 while ( v7 < v8 ); /*0xffe65540*/
 }
 v9 = *(_WORD *)(va_ + 134); /*0xffe65542*/
 if ( v9 > 1u ) /*0xffe6554c*/
 {
 do /*0xffe65562*/
 {
 if ( n0xD <= *(_WORD *)(*(_DWORD *)(va_ + 130) + 2 *v6) ) /*0xffe6555c*/
 break; /*0xffe6555c*/
 ++v6; /*0xffe6555e*/
 }
 while ( v6 < v9 ); /*0xffe65562*/
 }
 if ( n0xD == *(_WORD *)(*(_DWORD *)(va_ + 124) + 2 *v7) || n0xD == *(_WORD *)(*(_DWORD *)(va_ + 130) + 2 *v6) ) /*0xffe6557d*/
 {
 (*(void ( **)(int, int))(va_ + 166))(va_, 256); /*0xffe655b1*/
 }
 else
 {
 CmosChecksumGetSaved(va_, a5); /*0xffe65585*/
 *a5 += a4 - a3; /*0xffe65597*/
 (*(void ( **)(int, int))(va_ + 162))(va_, 256); /*0xffe655a0*/
 }
 return 0; /*0xffe655b9*/
}

/*
 *CmosChecksumVerify at 0xffe655c0
 */
int CmosChecksumVerify(int va_, _WORD *a2)
{
 int va__1; // esi unsigned __int16 j_1; // bx unsigned __int16 k_1; // bp unsigned int i; // edi unsigned __int16 j; // cx unsigned __int16 k; // cx __int16 v9; // [esp+10h] [ebp-4h] BYREF va__1 = va_; /*0xffe655c8*/
 j_1 = 1; /*0xffe655d0*/
 k_1 = 1; /*0xffe655d1*/
 *a2 = 0; /*0xffe655d5*/
 for ( i = *(unsigned __int16 *)(va__1 + 108); (unsigned __int16)i <= *(_WORD *)(va__1 + 110); ++i ) /*0xffe655d8*/
 {
 for ( j = *(_WORD *)(va__1 + 134); j_1 < j; ++j_1 ) /*0xffe655e8*/
 {
 if ( (unsigned __int16)i <= *(_WORD *)(*(_DWORD *)(va__1 + 130) + 2 *j_1) ) /*0xffe655f7*/
 break; /*0xffe655f7*/
 }
 if ( (_WORD)i != *(_WORD *)(*(_DWORD *)(va__1 + 130) + 2 *j_1) ) /*0xffe6560c*/
 {
 for ( k = *(_WORD *)(va__1 + 128); k_1 < k; ++k_1 ) /*0xffe65618*/
 {
 if ( (unsigned __int16)i <= *(_WORD *)(*(_DWORD *)(va__1 + 124) + 2 *k_1) ) /*0xffe65624*/
 break; /*0xffe65624*/
 }
 if ( (_WORD)i != *(_WORD *)(*(_DWORD *)(va__1 + 124) + 2 *k_1) ) /*0xffe65636*/
 {
 CmosSelectAccessMethod(va__1, 1, i, 0, (char *)&va_); /*0xffe65645*/
 *a2 += (unsigned __int8)va_; /*0xffe65656*/
 }
 }
 }
 CmosChecksumGetSaved(va__1, &v9); /*0xffe6566a*/
 if ( *a2 == v9 ) /*0xffe65683*/
 {
 (*(void ( **)(int, int))(va__1 + 166))(va__1, 128); /*0xffe6569b*/
 }
 else
 {
 (*(void ( **)(int, int))(va__1 + 162))(va__1, 128); /*0xffe65685*/
 ((void ( *)(int, const char *))loc_FFE64550)(va__1, " ...CMOS_BAD_CHECKSUM\n"); /*0xffe65691*/
 }
 return 0; /*0xffe656a3*/
}

/*
 *CmosWrite at 0xffe656ab
 */
int CmosWrite(int a1, int n0xE, ...)
{
 int v2; // ecx unsigned __int16 v4; // ax va_list va; // [esp+18h] [ebp+10h] BYREF va_start(va, n0xE);
 if ( (unsigned __int16)n0xE <= 0xEu ) /*0xffe656b7*/
 {
 v2 = a1; /*0xffe656b9*/
 return CmosAccessByRange(v2, 0, n0xE, (unsigned __int8 *)va); /*0xffe656fb*/
 }
 if ( (unsigned __int16)n0xE >= 0x1000u ) /*0xffe656c6*/
 {
 v4 = CmosRegisterLookupByIndex(a1, n0xE); /*0xffe65702*/
 if ( v4 ) /*0xffe6570d*/
 return CmosBitFieldAccess(a1, 0, v4, (char *)va); /*0xffe65720*/
 }
 else
 {
 if ( !(*(unsigned __int8 ( **)(int, int))(a1 + 170))(a1, 0x80000) ) /*0xffe656d1*/
 return -2147483641; /*0xffe656e2*/
 if ( (unsigned __int16)(n0xE - 64) > 0x3Fu ) /*0xffe656eb*/
 {
 v2 = a1; /*0xffe656ed*/
 return CmosAccessByRange(v2, 0, n0xE, (unsigned __int8 *)va); /*0xffe656ed*/
 }
 }
 return -2147483646; /*0xffe65727*/
}

/*
 *CmosLoadDefaults at 0xffe6572b
 */
int CmosLoadDefaults(int va__2)
{
 int va_; // esi unsigned __int16 Index; // bx int Result; // ebp int v4; // eax unsigned int i; // edi int v6; // edx unsigned __int16 v7; // cx int v8; // esi int v9; // edx unsigned __int16 v10; // dx int Index; // ecx int v12; // esi char va__1; // [esp+13h] [ebp-15h] BYREF int v15; // [esp+14h] [ebp-14h]
 int v16; // [esp+18h] [ebp-10h]
 unsigned int v17; // [esp+1Ch] [ebp-Ch] BYREF int v18; // [esp+24h] [ebp-4h]

 va_ = va__2; /*0xffe65731*/
 Index = 1; /*0xffe65737*/
 v16 = 1; /*0xffe6573f*/
 v15 = 1; /*0xffe65743*/
 Result = 0; /*0xffe65747*/
 v4 = *(_DWORD *)(va__2 + 158) & 0x2000; /*0xffe65751*/
 v17 = 0; /*0xffe65753*/
 v18 = v4; /*0xffe65758*/
 (*(void ( **)(int, int))(va__2 + 166))(va__2, 0x2000); /*0xffe6575c*/
 (*(void ( **)(int, int))(va_ + 162))(va_, 1024); /*0xffe65768*/
 if ( (*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 16) ) /*0xffe65771*/
 (*(void ( **)(int, int))(va__2 + 166))(va__2, 128); /*0xffe65784*/
 i = *(unsigned __int16 *)(va__2 + 108); /*0xffe6578c*/
 if ( (unsigned __int16)i <= *(_WORD *)(va__2 + 110) )
 {
 v6 = v15; /*0xffe6579a*/
 while ( (unsigned __int16)v6 < *(_WORD *)(va_ + 122) )
 {
 v7 = *(_WORD *)(va_ + 134); /*0xffe657a8*/
 if ( Index < v7 ) /*0xffe657b2*/
 {
 v8 = *(_DWORD *)(va_ + 130); /*0xffe657b4*/
 do /*0xffe657c7*/
 {
 if ( (unsigned __int16)i <= *(_WORD *)(v8 + 2 *Index) ) /*0xffe657c1*/
 break; /*0xffe657c1*/
 ++Index; /*0xffe657c3*/
 }
 while ( Index < v7 ); /*0xffe657c7*/
 va_ = va__2; /*0xffe657c9*/
 }
 if ( (_WORD)i == *(_WORD *)(*(_DWORD *)(va_ + 130) + 2 *Index) )
 {
 v9 = v6 + 0xFFFF; /*0xffe657dc*/
 }
 else
 {
 if ( !(*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 32896) ) /*0xffe657ea*/
 goto LABEL_32; /*0xffe657ea*/
 v10 = *(_WORD *)(va_ + 128); /*0xffe657f6*/
 Index = v16; /*0xffe657fd*/
 if ( (unsigned __int16)v16 < v10 ) /*0xffe65804*/
 {
 v12 = *(_DWORD *)(va_ + 124); /*0xffe65806*/
 do /*0xffe65816*/
 {
 if ( (unsigned __int16)i <= *(_WORD *)(v12 + 2 * (unsigned __int16)Index) ) /*0xffe65810*/
 break; /*0xffe65810*/
 ++Index; /*0xffe65812*/
 }
 while ( (unsigned __int16)Index < v10 ); /*0xffe65816*/
 va_ = va__2; /*0xffe65818*/
 v16 = Index; /*0xffe6581c*/
 }
 if ( (_WORD)i != *(_WORD *)(*(_DWORD *)(va_ + 124) + 2 * (unsigned __int16)Index) )
 {
LABEL_32:
 va__1 = *(_BYTE *)(*(_DWORD *)(va_ + 118) + 2 * (unsigned __int16)v15); /*0xffe6583d*/
 Result = CmosSelectAccessMethod(va_, 0, i, 255, &va__1); /*0xffe65851*/
 if ( Result < 0 )
 {
 ((void (*)(int, const char *, ...))loc_FFE64550)(
 va_,
 " Error: unable to write to register: 0x%X\n",
 (unsigned __int16)i);
 (*(void ( **)(int, int))(va_ + 162))(va_, 512); /*0xffe65885*/
 break; /*0xffe65885*/
 }
 }
 v9 = v15; /*0xffe6585a*/
 }
 ++i; /*0xffe6585e*/
 v6 = v9 + 1; /*0xffe6585f*/
 v15 = v6; /*0xffe65860*/
 if ( (unsigned __int16)i > *(_WORD *)(va_ + 110) ) /*0xffe65868*/
 break; /*0xffe65868*/
 }
 if ( Result < 0 ) /*0xffe65890*/
 goto LABEL_28; /*0xffe65890*/
 }
 if ( (*(unsigned __int8 ( **)(int, int))(va_ + 170))(va_, 512) )
 {
LABEL_28:
 ((void ( *)(int, const char *))loc_FFE64550)(va_, " Error: Could not load Optimal Defaults\n");
 Result = -2147483645; /*0xffe658d7*/
 }
 else
 {
 CmosChecksumVerify(va_, &v17); /*0xffe658aa*/
 CmosChecksumUpdate(va_, v17); /*0xffe658b4*/
 (*(void ( **)(int, int))(va_ + 166))(va_, 128); /*0xffe658bf*/
 }
 *(_DWORD *)(va_ + 158) |= v18; /*0xffe658e0*/
 (*(void ( **)(int, int))(va_ + 166))(va_, 1024); /*0xffe658ec*/
 (*(void ( **)(int, int))(va_ + 162))(va_, 0x4000); /*0xffe658f8*/
 return Result; /*0xffe65903*/
}

/*
 *CmosBcdToBin at 0xffe6590b
 */
char CmosBcdToBin(int a1, unsigned __int8 a2)
{
 unsigned __int8 v3; // [esp+1h] [ebp-1h] BYREF v3 = HIBYTE(a1); /*0xffe6590e*/
 CmosAccessByRange(a1, 1, a2, &v3); /*0xffe6591a*/
 return (v3 & 0xF) + 10 * (v3 >> 4); /*0xffe65936*/
}

/*
 *CmosBinToBcd at 0xffe65938
 */
int CmosBinToBcd(int a1, unsigned __int8 a2, unsigned __int8 a3)
{
 a3 = a3 % 0xAu + 16 * (a3 / 0xAu); /*0xffe6594f*/
 return CmosAccessByRange(a1, 0, a2, &a3); /*0xffe65963*/
}

/*
 *CmosSetDateTime at 0xffe65966
 */
int CmosSetDateTime(int a1, int a2)
{
 int v2; // edi v2 = a2; /*0xffe6596b*/
 if ( !a2 || !a1 ) /*0xffe6597b*/
 return -2147483646; /*0xffe65a3b*/
 CmosAccessByRange(a1, 1, 11, (unsigned __int8 *)&a2 + 3); /*0xffe6598d*/
 HIBYTE(a2) |= 0x80u; /*0xffe65992*/
 CmosAccessByRange(a1, 0, 11, (unsigned __int8 *)&a2 + 3); /*0xffe659a0*/
 CmosBinToBcd(a1, 0x32u, *(_WORD *)v2 / 0x64u); /*0xffe659b4*/
 CmosBinToBcd(a1, 9u, *(_WORD *)v2 % 0x64u); /*0xffe659c5*/
 CmosBinToBcd(a1, 8u, *(_BYTE *)(v2 + 2)); /*0xffe659d3*/
 CmosBinToBcd(a1, 7u, *(_BYTE *)(v2 + 3)); /*0xffe659e1*/
 CmosBinToBcd(a1, 4u, *(_BYTE *)(v2 + 4)); /*0xffe659ef*/
 CmosBinToBcd(a1, 2u, *(_BYTE *)(v2 + 5)); /*0xffe659fd*/
 CmosBinToBcd(a1, 0, *(_BYTE *)(v2 + 6)); /*0xffe65a0b*/
 CmosAccessByRange(a1, 1, 11, (unsigned __int8 *)&a2 + 3); /*0xffe65a1b*/
 HIBYTE(a2) &= ~0x80u; /*0xffe65a20*/
 CmosAccessByRange(a1, 0, 11, (unsigned __int8 *)&a2 + 3); /*0xffe65a2e*/
 return 0; /*0xffe65a40*/
}

/*
 *CmosGetDateTime at 0xffe65a44
 */
int CmosGetDateTime(int a1, int a2)
{
 __int16 v2; // si char v3; // al if ( !a2 || !a1 ) /*0xffe65a54*/
 return -2147483646; /*0xffe65abd*/
 v2 = 100 * (unsigned __int8)CmosBcdToBin(a1, 0x32u); /*0xffe65a67*/
 *(_WORD *)a2 = v2 + (unsigned __int8)CmosBcdToBin(a1, 9u); /*0xffe65a79*/
 *(_BYTE *)(a2 + 2) = CmosBcdToBin(a1, 8u); /*0xffe65a83*/
 *(_BYTE *)(a2 + 3) = CmosBcdToBin(a1, 7u); /*0xffe65a8f*/
 *(_BYTE *)(a2 + 4) = CmosBcdToBin(a1, 4u); /*0xffe65a9b*/
 *(_BYTE *)(a2 + 5) = CmosBcdToBin(a1, 2u); /*0xffe65aa7*/
 v3 = CmosBcdToBin(a1, 0); /*0xffe65aac*/
 *(_DWORD *)(a2 + 8) = 0; /*0xffe65ab1*/
 *(_BYTE *)(a2 + 6) = v3; /*0xffe65ab5*/
 return 0; /*0xffe65ac2*/
}

/*
 *DebugGetPpi at 0xffe65ac5
 */
int DebugGetPpi()
{
 int Ptr; // eax _BYTE v2[4]; // [esp+0h] [ebp-8h] BYREF int Result; // [esp+4h] [ebp-4h] BYREF Ptr = PeiServicesGetPtr(); /*0xffe65aca*/
 if ( (*(int ( **)(int, void *, _DWORD, _BYTE *, int *))(*(_DWORD *)Ptr + 32))(Ptr, &unk_FFE66BAC, 0, v2, &Result) >= 0 ) /*0xffe65ae9*/
 return Result; /*0xffe65aef*/
 else return 0; /*0xffe65aeb*/
}

/*
 *DebugVPrint at 0xffe65af6
 */
int DebugVPrint(int a1, int _nASSERT_EFI_ERROR_(Status___%r)_n, ...)
{
 int result; // eax int ( **v3)(int, int, char *); // esi va_list va; // [esp+10h] [ebp+Ch] BYREF va_start(va, _nASSERT_EFI_ERROR_(Status___%r)_n);
 result = DebugGetPpi(); /*0xffe65af7*/
 v3 = (int ( **)(int, int, char *))result; /*0xffe65afc*/
 if ( result ) /*0xffe65b00*/
 {
 result = PcdGetBool(); /*0xffe65b02*/
 if ( (result & a1) != 0 ) /*0xffe65b0d*/
 return (*v3)(a1, _nASSERT_EFI_ERROR_(Status___%r)_n, (char *)va); /*0xffe65b19*/
 }
 return result; /*0xffe65b1e*/
}

/*
 *DebugAssert at 0xffe65b20
 */
int DebugAssert(
 int e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
 int n48,
 int PeiServices____((void__)_0))
{
 int result; // eax result = DebugGetPpi(); /*0xffe65b26*/
 if ( result ) /*0xffe65b2d*/
 return (*(int ( **)(int, int, int))(result + 4))( /*0xffe65b35*/
 e:__hs__MdePkg__Library__PeiServicesTablePointerLibIdt__PeiServ,
 n48,
 PeiServices____((void__)_0));
 return result; /*0xffe65b3b*/
}

/*
 *DebugPrint at 0xffe65b3e
 */
int DebugPrint(int a1, EFI_SYSTEM_TABLE *SystemTable, char *CmosManagerPeiEntry_Entry_n, ...)
{
 int result; // eax char *CmosManagerPeiEntry_Entry_n_1; // eax va_list va; // [esp+18h] [ebp+14h] BYREF va_start(va, CmosManagerPeiEntry_Entry_n);
 result = (*(int (__stdcall **)(EFI_SYSTEM_TABLE *))(LODWORD(SystemTable->Hdr.Signature) + 32))(SystemTable); /*0xffe65b57*/
 if ( result >= 0 ) /*0xffe65b5f*/
 {
 if ( SystemTable ) /*0xffe65b67*/
 {
 result = PcdGetBool(); /*0xffe65b69*/
 if ( (result & a1) != 0 ) /*0xffe65b73*/
 {
 CmosManagerPeiEntry_Entry_n_1 = CmosManagerPeiEntry_Entry_n; /*0xffe65b75*/
 if ( *CmosManagerPeiEntry_Entry_n ) /*0xffe65b78*/
 {
 do /*0xffe65b98*/
 {
 if ( *CmosManagerPeiEntry_Entry_n_1 == 37 ) /*0xffe65b80*/
 {
 if ( *++CmosManagerPeiEntry_Entry_n_1 == 115 ) /*0xffe65b88*/
 {
 *CmosManagerPeiEntry_Entry_n_1 = 97; /*0xffe65b8a*/
 }
 else if ( *CmosManagerPeiEntry_Entry_n_1 == 71 ) /*0xffe65b92*/
 {
 *CmosManagerPeiEntry_Entry_n_1 = 103; /*0xffe65b94*/
 }
 }
 ++CmosManagerPeiEntry_Entry_n_1; /*0xffe65b97*/
 }
 while ( *CmosManagerPeiEntry_Entry_n_1 ); /*0xffe65b98*/
 CmosManagerPeiEntry_Entry_n_1 = CmosManagerPeiEntry_Entry_n; /*0xffe65b9d*/
 }
 return ((int ( *)(int, char *, char *))LODWORD(SystemTable->Hdr.Signature))( /*0xffe65ba6*/
 a1,
 CmosManagerPeiEntry_Entry_n_1,
 (char *)va);
 }
 }
 }
 return result; /*0xffe65bae*/
}

/*
 *DivU64x32 at 0xffe65bb0
 */
int DivU64x32(unsigned int _EDI, unsigned int *p_n0xA, int n0xA, int _EDX)
{
 int n0xA_1; // eax int n64; // ecx n0xA_1 = n0xA; /*0xffe65bbf*/
 _EDX = _EDX; /*0xffe65bc2*/
 _EDI = 0; /*0xffe65bc8*/
 n64 = 64; /*0xffe65bca*/
 do
 {
 __asm /*0xffe65bd1*/
 {
 rcl edx, 1 rcl edi, 1
 }
 n0xA_1 = 2 *n0xA_1 + (_EDI >= _EDI); /*0xffe65bda*/
 _EDI = _EDI - (_EDI >= _EDI ? _EDI : 0);
 --n64; /*0xffe65be0*/
 }
 while ( n64 );
 if ( p_n0xA ) /*0xffe65bf3*/
 *p_n0xA = _EDI; /*0xffe65bf8*/
 return n0xA_1; /*0xffe65bee*/
}

/*
 *NumberToString at 0xffe65c04
 */
_BYTE *NumberToString(_BYTE *a1, unsigned int n10, __int64 n0xA, char a4)
{
 int v4; // ebx int _EDX; // edx int n0xA_1; // ecx char v9; // al v4 = HIDWORD(n0xA); /*0xffe65c05*/
 if ( n0xA >= 0 ) /*0xffe65c16*/
 goto LABEL_2; /*0xffe65c16*/
 if ( n10 == 10 ) /*0xffe65c25*/
 {
 n0xA_1 = -(int)n0xA; /*0xffe65c2b*/
 _EDX = (unsigned __int64)-n0xA >> 32; /*0xffe65c30*/
 goto LABEL_8; /*0xffe65c32*/
 }
 if ( a4 ) /*0xffe65c39*/
LABEL_2:
 _EDX = HIDWORD(n0xA); /*0xffe65c1e*/
 else _EDX = 0; /*0xffe65c3b*/
 n0xA_1 = n0xA; /*0xffe65c3d*/
LABEL_8:
 if ( __PAIR64__(n0xA_1, _EDX) ) /*0xffe65c43*/
 {
 do /*0xffe65c6c*/
 {
 n0xA_1 = DivU64x32(n10, (unsigned int *)&n0xA, n0xA_1, _EDX); /*0xffe65c54*/
 if ( (unsigned int)n0xA >= 0xA ) /*0xffe65c5d*/
 v9 = n0xA + 87; /*0xffe65c63*/
 else v9 = n0xA + 48; /*0xffe65c5f*/
 *a1++ = v9; /*0xffe65c65*/
 }
 while ( __PAIR64__(n0xA_1, _EDX) ); /*0xffe65c6c*/
 }
 else
 {
 *a1++ = 48; /*0xffe65c70*/
 }
 if ( n10 == 10 && v4 < 0 ) /*0xffe65c7b*/
 *a1++ = 45; /*0xffe65c83*/
 *a1 = 0; /*0xffe65c88*/
 return a1 - 1; /*0xffe65c87*/
}

/*
 *NumberToStringReverse at 0xffe65c92
 */
char *NumberToStringReverse(char *a1, unsigned int n10, __int64 n0xA, char a4)
{
 char *v5; // esi char *v6; // eax char v7; // dl v5 = a1; /*0xffe65c9e*/
 v6 = NumberToString(a1, n10, n0xA, a4); /*0xffe65ca4*/
 if ( a1 < v6 ) /*0xffe65cae*/
 {
 do /*0xffe65cbc*/
 {
 v7 = *v5; /*0xffe65cb2*/
 *v5++ = *v6; /*0xffe65cb4*/
 *v6-- = v7; /*0xffe65cb7*/
 }
 while ( v5 < v6 ); /*0xffe65cbc*/
 }
 return a1; /*0xffe65cc0*/
}

/*
 *AsciiStrParseDecimal at 0xffe65cc3
 */
int AsciiStrParseDecimal(char *a1, char **p_%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x)
{
 char Ptr; // bl unsigned int n0x7FFFFFFF; // esi char n57; // al char n10; // al char v7; // [esp+Ch] [ebp-4h]

 Ptr = 1; /*0xffe65cc9*/
 v7 = 0; /*0xffe65ccd*/
 n0x7FFFFFFF = 0; /*0xffe65cd1*/
 while ( *a1 == 32 || *a1 == 9 ) /*0xffe65cdb*/
 ++a1; /*0xffe65cdd*/
 if ( !*a1 ) /*0xffe65ce0*/
 {
 *p_%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x = a1; /*0xffe65ce6*/
 return 0; /*0xffe65cea*/
 }
 if ( *a1 == 45 ) /*0xffe65cee*/
 {
 Ptr = -1; /*0xffe65cf0*/
 ++a1; /*0xffe65cf3*/
 }
 if ( *a1 == 43 ) /*0xffe65cf7*/
 ++a1; /*0xffe65cf9*/
 while ( 1 ) /*0xffe65d00*/
 {
 n57 = *a1; /*0xffe65d00*/
 if ( *a1 >= 48 && n57 <= 57 ) /*0xffe65d08*/
 {
 n10 = n57 - 48; /*0xffe65d0a*/
 goto LABEL_17; /*0xffe65d0c*/
 }
 if ( (n57 & 0xDFu) < 0x41 || (n57 & 0xDFu) > 0x5A ) /*0xffe65d1b*/
 break; /*0xffe65d1b*/
 n10 = (n57 & 0xDF) - 55; /*0xffe65d1f*/
LABEL_17:
 if ( n10 >= 10 ) /*0xffe65d27*/
 break; /*0xffe65d27*/
 n0x7FFFFFFF = n10 + 10 *n0x7FFFFFFF; /*0xffe65d2c*/
 if ( Ptr == 1 ) /*0xffe65d31*/
 {
 if ( n0x7FFFFFFF < 0x80000000 ) /*0xffe65d35*/
 goto LABEL_23; /*0xffe65d35*/
 }
 else if ( n0x7FFFFFFF <= 0x80000000 ) /*0xffe65d3b*/
 {
 goto LABEL_23; /*0xffe65d3b*/
 }
 v7 = 1; /*0xffe65d3d*/
LABEL_23:
 ++a1; /*0xffe65d42*/
 }
 *p_%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x = a1; /*0xffe65d45*/
 if ( v7 ) /*0xffe65d4c*/
 {
 n0x7FFFFFFF = 0x7FFFFFFF; /*0xffe65d4e*/
 if ( Ptr == -1 ) /*0xffe65d56*/
 n0x7FFFFFFF = 0x80000000; /*0xffe65d58*/
 }
 return n0x7FFFFFFF *Ptr; /*0xffe65d61*/
}

/*
 *AsciiStrToUpper at 0xffe65d66
 */
char *__thiscall AsciiStrToUpper(char *this)
{
 char *i; // eax char n122; // dl for ( i = this; *i; ++i ) /*0xffe65d66*/
 {
 n122 = *i; /*0xffe65d6d*/
 if ( *i >= 97 && n122 <= 122 ) /*0xffe65d77*/
 *i = n122 - 32; /*0xffe65d7c*/
 }
 return this; /*0xffe65d86*/
}

/*
 *StatusToString at 0xffe65d87
 */
char *StatusToString(unsigned int n2)
{
 unsigned int Ptr; // edx if ( !n2 ) /*0xffe65d89*/
 return "EFI_SUCCESS"; /*0xffe65d90*/
 if ( (n2 & 0x80000000) != 0 ) /*0xffe65d91*/
 {
 Ptr = n2 & 0x1FFFFFFF; /*0xffe65dc7*/
 if ( (n2 & 0xA0000000) == 0xA0000000 ) /*0xffe65dd0*/
 {
 if ( Ptr >= 3 ) /*0xffe65dd5*/
 return 0; /*0xffe65dd5*/
 // "EFI_INTERRUPT_PENDING"
 return &aEfiInterruptPe[25 *Ptr]; /*0xffe65dda*/
 }
 else if ( (n2 & 0xC0000000) == 0xC0000000 ) /*0xffe65de9*/
 {
 if ( Ptr > 2 ) /*0xffe65dee*/
 return 0; /*0xffe65dee*/
 // "ABLE_YET"
 return &aAbleYet[25 *Ptr]; /*0xffe65df3*/
 }
 else
 {
 if ( Ptr > 0x1E ) /*0xffe65dfd*/
 return 0; /*0xffe65dfd*/
 // "E_BOF"
 return &aEBof[25 *Ptr]; /*0xffe65e02*/
 }
 }
 else if ( (n2 & 0x20000000) != 0 ) /*0xffe65d99*/
 {
 if ( n2 >= 2 ) /*0xffe65d9e*/
 return 0; /*0xffe65da2*/
 // "EFI_WARN_INTERRUPT_SOURCE_PENDING"
 return &aEfiWarnInterru[35 *n2]; /*0xffe65da6*/
 }
 else
 {
 if ( n2 > 4 ) /*0xffe65daf*/
 return 0; /*0xffe65daf*/
 // "... DEBUG BUFFER OVERFLOW!!!\n"
 return &src[26 *n2 + 6]; /*0xffe65db4*/
 }
}

/*
 *AsciiSPrintFormat at 0xffe65e09
 */
int AsciiSPrintFormat(char *a1, int a2, char *%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x, int va)
{
 char *v4; // ebx int v5; // edi char *%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x_1; // esi int *v7; // ecx int i_1; // edx char n37; // al char *v10; // esi int i_2; // edx int *v12; // ecx int m_2; // eax char n97; // ah char *k; // ecx unsigned __int8 *v16; // edi int Unaligned32; // ebx int Unaligned16; // esi int v19; // ecx int v20; // eax int n10_1; // eax char *v22; // eax char n105; // ah unsigned int n10_3; // eax int *v25; // ecx unsigned int n10_4; // edx char v27; // dl unsigned int m; // eax char *v29; // ecx char *j; // eax int v32; // [esp-1Ch] [ebp-6Ch]
 int v33; // [esp-18h] [ebp-68h]
 int v34; // [esp-14h] [ebp-64h]
 int v35; // [esp-10h] [ebp-60h]
 int v36; // [esp-Ch] [ebp-5Ch]
 __int64 n0xA; // [esp-Ch] [ebp-5Ch]
 int v38; // [esp-8h] [ebp-58h]
 int v39; // [esp-4h] [ebp-54h]
 int ... [11015 chars total]

/*
 *AsciiSPrint at 0xffe6617e
 */
int AsciiSPrint(char *a1, int a2, char *%08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x, ...)
{
 va_list va; // [esp+10h] [ebp+10h] BYREF va_start(va, %08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x);
 return AsciiSPrintFormat(a1, a2, %08x_%04x_%04x_%02x%02x_%02x%02x%02x%02x%02x%02x, (int)va); /*0xffe66196*/
}

/*
 *CmosIoReadWrite at 0xffe66197
 */
int CmosIoReadWrite(int a1, int a2, unsigned __int16 n0x7F, unsigned __int8 *a4)
{
 char v5; // al unsigned __int8 v6; // al if ( n0x7F > 0x7Fu ) /*0xffe661a2*/
 return -2147483646; /*0xffe661a4*/
 if ( n0x7F <= 9u && a2 == 1 ) /*0xffe661bd*/
 {
 do /*0xffe661cb*/
 {
 __outbyte(0x70u, 0x8Au); /*0xffe661c4*/
 v5 = __inbyte(0x71u); /*0xffe661c8*/
 }
 while ( v5 < 0 ); /*0xffe661cb*/
 }
 __outbyte(0x70u, n0x7F | 0x80); /*0xffe661d5*/
 if ( a2 == 1 ) /*0xffe661da*/
 {
 v6 = __inbyte(0x71u); /*0xffe661df*/
 *a4 = v6; /*0xffe661e3*/
 }
 else
 {
 __outbyte(0x71u, *a4); /*0xffe661ef*/
 }
 return 0; /*0xffe661a9*/
}

/*
 *CmosCheckPowerFail at 0xffe661f6
 */
int CmosCheckPowerFail()
{
 unsigned __int8 Result; // al __outbyte(0x70u, 0x8Du); /*0xffe661fe*/
 Result = __inbyte(0x71u); /*0xffe66205*/
 return Result >> 7; /*0xffe6620c*/
}

/*
 *MonotonicCounterCheck at 0xffe6620d
 */
char MonotonicCounterCheck(int a1)
{
 char Result; // bl _DWORD v3[4]; // [esp+4h] [ebp-18h] BYREF int n4; // [esp+14h] [ebp-8h] BYREF int ( **v5)(_DWORD, const __int16 *, _DWORD *, _DWORD, int *, int *); // [esp+18h] [ebp-4h] BYREF Result = 0; /*0xffe66217*/
 n4 = 4; /*0xffe66219*/
 v3[0] = 20351105; /*0xffe66220*/
 v3[1] = 1260242093; /*0xffe66227*/
 v3[2] = 2060792246; /*0xffe6622e*/
 v3[3] = 1809565838; /*0xffe66235*/
 v5 = 0; /*0xffe6623c*/
 if ( a1 /*0xffe66278*/
 && ((*(int ( **)(int, void *, _DWORD, _DWORD, int ( ***)(_DWORD, const __int16 *, _DWORD *, _DWORD, int *, int *)))(*(_DWORD *)a1 + 32))(
 a1,
 &unk_FFE66B9C,
 0,
 0,
 &v5) < 0
 || (*v5)(v5, L"MonotonicCounter", v3, 0, &n4, &a1) < 0) )
 {
 return 1; /*0xffe6627a*/
 }
 return Result; /*0xffe6627e*/
}

/*
 *PlatformReturnTrue at 0xffe66283
 */
char PlatformReturnTrue()
{
 return 1; /*0xffe66285*/
}

/*
 *CmosExtIoReadWrite at 0xffe66286
 */
int CmosExtIoReadWrite(int a1, int a2, __int16 a3, unsigned __int8 *a4)
{
 unsigned __int8 v4; // al if ( (unsigned __int16)(a3 - 128) > 0x7Fu ) /*0xffe66291*/
 return -2147483646; /*0xffe662c0*/
 __outbyte(0x72u, a3); /*0xffe66299*/
 if ( a2 == 1 ) /*0xffe6629f*/
 {
 v4 = __inbyte(0x73u); /*0xffe662a7*/
 *a4 = v4; /*0xffe662ac*/
 }
 else
 {
 __outbyte(0x73u, *a4); /*0xffe662bc*/
 }
 return 0; /*0xffe662bf*/
}

/*
 *PcdSetBit at 0xffe662c6
 */
char PcdSetBit()
{
 int Result; // ecx char result; // al Result = PcdGetPtr(); /*0xffe662cb*/
 result = *(_BYTE *)(Result + 1024068) | 0x80; /*0xffe662d3*/
 *(_BYTE *)(Result + 1024068) = result; /*0xffe662d5*/
 return result; /*0xffe662db*/
}

/*
 *PcdGetBool at 0xffe6630c
 */
int PcdGetBool()
{
 unsigned __int8 v0; // al char Result; // al char n3_1; // cl v0 = __inbyte(0x70u); /*0xffe66312*/
 __outbyte(0x70u, v0 & 0x80 | 0x4A); /*0xffe66317*/
 Result = __inbyte(0x71u); /*0xffe6631e*/
 n3_1 = Result; /*0xffe6631f*/
 if ( (unsigned __int8)Result <= 3u ) /*0xffe66324*/
 {
LABEL_4:
 if ( !n3_1 ) /*0xffe6633f*/
 return 0; /*0xffe6633f*/
 goto LABEL_5; /*0xffe6633f*/
 }
 n3_1 = Result; /*0xffe66326*/
 if ( !Result ) /*0xffe6632e*/
 {
 n3_1 = MEMORY[0xFDAF0490] & 2 | 1; /*0xffe6633a*/
 goto LABEL_4; /*0xffe6633a*/
 }
LABEL_5:
 if ( n3_1 != -1 )
 return n3_1 != 1 ? -2147483578 : -2147483644;
 return 0; /*0xffe66357*/
}

/*
 *ReadUnaligned16 at 0xffe6635b
 */
__int16 __thiscall ReadUnaligned16(void *this)
{
 int Ppi; // eax if ( !this ) /*0xffe66360*/
 {
 Ppi = DebugGetPpi(); /*0xffe66362*/
 if ( Ppi ) /*0xffe66369*/
 (*(void ( **)(const char *, int, const char *))(Ppi + 4))( /*0xffe66377*/
 "e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
 38,
 "Buffer != ((void *) 0)");
 }
 return *(_WORD *)this; /*0xffe66380*/
}

/*
 *ReadUnaligned32 at 0xffe66382
 */
int __thiscall ReadUnaligned32(void *this)
{
 int Ppi; // eax if ( !this ) /*0xffe66387*/
 {
 Ppi = DebugGetPpi(); /*0xffe66389*/
 if ( Ppi ) /*0xffe66390*/
 (*(void ( **)(const char *, int, const char *))(Ppi + 4))( /*0xffe663a1*/
 "e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c",
 141,
 "Buffer != ((void *) 0)");
 }
 return *(_DWORD *)this; /*0xffe663a9*/
}

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

 ReadIdtr(v2); /*0xffe663d1*/
 Result = *(_DWORD *)(v3 - 4); /*0xffe663d9*/
 if ( !Result ) /*0xffe663de*/
 DebugAssert( /*0xffe663ed*/
 (int)"e:\\hs\\MdePkg\\Library\\PeiServicesTablePointerLibIdt\\PeiServicesTablePointer.c",
 48,
 (int)"PeiServices != ((void *) 0)");
 return Result; /*0xffe663f5*/
}

/*
 *PcdGetPtr at 0xffe663fa
 */
int __thiscall PcdGetPtr(void *this)
{
 int ( **Ptr)(int); // eax Ptr = (int ( **)(int))PeiPcdGetPtr(this); /*0xffe663fa*/
 return Ptr[4](5); /*0xffe66405*/
}

/*
 *PcdSet16 at 0xffe66406
 */
int __thiscall PcdSet16(void *this)
{
 int v1; // ebx int Ppi; // eax v1 = PcdGetPtr(this) + 1024064; /*0xffe662dd*/
 if ( (v1 & 1) != 0 ) /*0xffe662e2*/
 {
 Ppi = DebugGetPpi(); /*0xffe662e4*/
 if ( Ppi ) /*0xffe662eb*/
 (*(void ( **)(const char *, int, const char *))(Ppi + 4))( /*0xffe662fc*/
 "e:\\hs\\MdePkg\\Library\\BaseIoLibIntrinsic\\IoLib.c",
 183,
 "(Address & 1) == 0");
 }
 *(_WORD *)v1 = 1280; /*0xffe66307*/
 return 1280; /*0xffe6630b*/
}

/*
 *ReadIdtr at 0xffe66417
 */
void *__thiscall ReadIdtr(void *this)
{
 void *this_1; // eax if ( !this ) /*0xffe6641d*/
 DebugAssert((int)"e:\\hs\\MdePkg\\Library\\BaseLib\\X86ReadIdtr.c", 37, (int)"Idtr != ((void *) 0)"); /*0xffe6642c*/
 this_1 = this; /*0xffe66432*/
 __sidt(this); /*0xffe66435*/
 return this_1; /*0xffe66439*/
}

/*
 *PeiPcdGetPtr at 0xffe6643a
 */
void *__thiscall PeiPcdGetPtr(void *this)
{
 int Ptr; // eax int Status; // eax int Ppi; // eax void *this_1; // [esp+0h] [ebp-4h]

 this_1 = this; /*0xffe6643d*/
 Ptr = PeiServicesGetPtr(); /*0xffe6643e*/
 Status = (*(int (__stdcall **)(int))(*(_DWORD *)Ptr + 32))(Ptr); /*0xffe66453*/
 if ( Status < 0 ) /*0xffe6645b*/
 {
 DebugVPrint(0x80000000, (int)"\nASSERT_EFI_ERROR (Status = %r)\n", Status); /*0xffe66468*/
 Ppi = DebugGetPpi(); /*0xffe66470*/
 if ( Ppi ) /*0xffe66477*/
 (*(void ( **)(const char *, int, const char *))(Ppi + 4))( /*0xffe66485*/
 "e:\\hs\\MdePkg\\Library\\PeiPcdLib\\PeiPcdLib.c",
 49,
 "!EFI_ERROR (Status)");
 }
 return this_1; /*0xffe66490*/
}

/*
 *SetMemM at 0xffe664a6
 */
char *__usercall SetMemM@<eax>(int value@<eax>, char *buf, unsigned int n220, char a4)
{
 unsigned int n220_1; // ecx char *buf_1; // edi __int16 value_1; // bx int value_2; // eax int v8; // edx char n220_2; // dl unsigned int count; // ecx n220_1 = n220; /*0xffe664a6*/
 LOBYTE(value) = a4; /*0xffe664aa*/
 buf_1 = buf; /*0xffe664af*/
 BYTE1(value) = a4; /*0xffe664b8*/
 value_1 = value; /*0xffe664ba*/
 value_2 = value << 16; /*0xffe664bd*/
 LOWORD(value_2) = value_1; /*0xffe664c0*/
 if ( n220 >= 4 ) /*0xffe664c6*/
 {
 v8 = (unsigned __int8)buf & 3; /*0xffe664ca*/
 if ( ((unsigned __int8)buf & 3) != 0 ) /*0xffe664cd*/
 {
 memset(buf, value_1, 4 - v8); /*0xffe664d8*/
 buf_1 = &buf[4 - v8]; /*0xffe664d8*/
 n220_1 = n220 - (4 - v8); /*0xffe664da*/
 }
 n220_2 = n220_1; /*0xffe664dc*/
 count = n220_1 >> 2; /*0xffe664de*/
 memset32(buf_1, value_2, count); /*0xffe664e1*/
 buf_1 += 4 *count; /*0xffe664e1*/
 n220_1 = n220_2 & 3; /*0xffe664e6*/
 }
 memset(buf_1, value_1, n220_1); /*0xffe664e8*/
 return buf; /*0xffe664ec*/
}

/*
 *CopyMemOverlap at 0xffe664fc
 */
unsigned int CopyMemOverlap(unsigned int dst, char *src, unsigned int n4)
{
 char *src_1; // esi unsigned int dst_1; // edi unsigned int n4_1; // ecx char v10; // dl char *n4_2; // eax unsigned int count; // eax int count_1; // ebx char n4_3; // al unsigned int Ptr; // ecx int n4_4; // eax __asm { pushfw } /*0xffe66502*/
 src_1 = src; /*0xffe66507*/
 dst_1 = dst; /*0xffe6650a*/
 n4_1 = n4; /*0xffe6650d*/
 v10 = 0; /*0xffe66510*/
 n4_2 = &src[-dst]; /*0xffe66514*/
 if ( (unsigned int)src < dst ) /*0xffe66516*/
 {
 n4_2 = (char *)(dst - (_DWORD)src); /*0xffe6651b*/
 if ( (unsigned int)&src[n4] >= dst ) /*0xffe6651f*/
 {
 src_1 = &src[n4]; /*0xffe66521*/
 dst_1 = n4 + dst; /*0xffe66523*/
 v10 = 1; /*0xffe66526*/
 }
 }
 if ( n4 < 4 || (unsigned int)n4_2 < 4 ) /*0xffe66531*/
 goto LABEL_19; /*0xffe66531*/
 count = (unsigned __int8)src_1 & 3; /*0xffe66537*/
 count_1 = dst_1 & 3; /*0xffe6653a*/
 if ( v10 ) /*0xffe6653f*/
 {
 --src_1; /*0xffe66541*/
 --dst_1; /*0xffe66542*/
 }
 if ( count == count_1 && count ) /*0xffe66549*/
 {
 if ( !v10 ) /*0xffe6654d*/
 count = 4 - count; /*0xffe66551*/
 qmemcpy((void *)dst_1, src_1, count); /*0xffe66557*/
 src_1 += count; /*0xffe66557*/
 dst_1 += count; /*0xffe66557*/
 n4_1 = n4 - count; /*0xffe66559*/
 }
 if ( v10 ) /*0xffe6655d*/
 {
 src_1 -= 3; /*0xffe6655f*/
 dst_1 -= 3; /*0xffe66562*/
 }
 n4_3 = n4_1; /*0xffe66565*/
 Ptr = n4_1 >> 2; /*0xffe66567*/
 qmemcpy((void *)dst_1, src_1, 4 *Ptr); /*0xffe6656a*/
 src_1 += 4 *Ptr; /*0xffe6656a*/
 dst_1 += 4 *Ptr; /*0xffe6656a*/
 n4_4 = n4_3 & 3; /*0xffe6656c*/
 if ( n4_4 ) /*0xffe6656f*/
 {
 if ( v10 ) /*0xffe66573*/
 {
 src_1 += 4; /*0xffe66575*/
 dst_1 += 4; /*0xffe66578*/
 }
 n4_1 = n4_4; /*0xffe6657b*/
LABEL_19:
 if ( v10 ) /*0xffe6657f*/
 {
 --src_1; /*0xffe66581*/
 --dst_1; /*0xffe66582*/
 }
 qmemcpy((void *)dst_1, src_1, n4_1); /*0xffe66583*/
 }
 __asm { popfw } /*0xffe66585*/
 return dst; /*0xffe66588*/
}