/*=============================================================================
 *IPMI Device Amount Driver
 *Source: IpmiDeviceAmount.efi (HR650X BIOS, Index 0094)
 *Module: LenovoServerPkg/IpmiDeviceAmount/LnvIpmiDeviceAmount.c
 *
 *This driver enumerates SATA/AHCI devices attached to the system,
 *counts HDDs and SSDs separately, calculates total storage capacity,
 *and reports the device counts via IPMI to the BMC.
 *
 *Auto-decompiled from IDA Pro. All function names are placeholders
 * (sub_XXXX) pending reverse-engineering refinement.
 *
 *Original source path (from debug strings):
 *e:\hs\LenovoServerPkg\IpmiDeviceAmount\LnvIpmiDeviceAmount.c
 *
 *Key UEFI Protocols Used:
 * - EFI_ATA_PASS_THRU_PROTOCOL
 * - EFI_BLOCK_IO_PROTOCOL
 * - EFI_STORAGE_SECURITY_COMMAND_PROTOCOL
 *
 *===========================================================================*/

#include "IpmiDeviceAmount.h"

/*=============================================================================
 *Global Variable Definitions
 *===========================================================================*/
EFI_HANDLE ImageHandle = NULL;
EFI_SYSTEM_TABLE *SystemTable = NULL;
EFI_BOOT_SERVICES *BootServices = NULL;
EFI_RUNTIME_SERVICES *RuntimeServices = NULL;
EFI_SYSTEM_TABLE *SystemTable_0 = NULL;
EFI_BOOT_SERVICES *BootServices_0 = NULL;
EFI_RUNTIME_SERVICES *RuntimeServices_0 = NULL;

/*=============================================================================
 *Forward Declarations
 *===========================================================================*/

/*=============================================================================
 *Function: ModuleEntryPoint
 *Address: 0x370
 *Size: 0xD7
 *Purpose: UEFI driver entry point. Initializes global protocol pointers
 *and calls sub_18F4 (library init) and sub_1850 (secondary init).
 *===========================================================================*/
EFI_STATUS EFIAPI ModuleEntryPoint(
 IN EFI_HANDLE ImageHandle,
 IN EFI_SYSTEM_TABLE *SystemTable
 )
{
 if (!ImageHandle) {
 sub_1810(
 "e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
 51,
 "gImageHandle != ((void *) 0)");
 }
 ::ImageHandle = (__int64)ImageHandle;

 if (!SystemTable) {
 sub_1810(
 "e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
 57,
 "gST != ((void *) 0)");
 }
 ::SystemTable = (__int64)SystemTable;

 BootServices = (__int64)SystemTable->BootServices;
 if (!BootServices) {
 sub_1810(
 "e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
 63,
 "gBS != ((void *) 0)");
 }

 RuntimeServices = (__int64)SystemTable->RuntimeServices;
 if (!RuntimeServices) {
 sub_1810(
 "e:\\hs\\MdePkg\\Library\\UefiRuntimeServicesTableLib\\UefiRuntimeServicesTableLib.c",
 47,
 "gRT != ((void *) 0)");
 }

 sub_18F4();

 if (!SystemTable_0) {
 SystemTable_0 = (__int64)SystemTable;
 BootServices_0 = (__int64)SystemTable->BootServices;
 RuntimeServices_0 = (__int64)SystemTable->RuntimeServices;
 }

 sub_1850(0LL, 0LL, 0LL, 0LL);
 return 0;
}

/*=============================================================================
 *Function: sub_448
 *Address: 0x448
 *Size: 0x5DA
 *Purpose: Main device enumeration routine. Opens all handles, locates
 *ATA Pass Thru protocols, and counts devices/capacity.
 *
 *NOTE: IDA output truncated - this is a partial decompilation.
 *Full source is ~10,277 chars but only 1,023 were returned.
 *===========================================================================*/
__int64 sub_448(unsigned __int8 *a1, _WORD *a2)
{
 __int64 Ptr; // rbx unsigned __int8 *v3; // r13 unsigned __int8 n4_3; // r14 __int64 v5; // rax __int64 v6; // rsi unsigned __int64 v8; // r12 __int64 n4; // r15 __int64 v10; // rax _BYTE *i; // rdx __int64 v12; // rax __int64 v13; // rsi __int64 v14; // r12 __int64 v15; // rax __int64 v16; // rax __int64 v17; // r14 unsigned __int64 v18; // r13 unsigned __int8 n4_1; // cl __int64 v20; // r14 __int64 v21; // rcx __int64 v22; // rax const char *v23; // rsi __int64 v24; // rax __int64 v25; // r15 __int64 v26; // r15 __int64 v27; // rax unsigned int v28; // r15d __int64 v29; // r9 _QWORD *v30; // r10 unsigned __int64 v31; // r8

 // NOTE: Full decompilation was too large for IDA output.
 // See sub_A24 for the per-controller enumeration logic,
 // and sub_E2C for the per-controller iteration.
 // This function appears to be the outermost dispatcher.
 return 0;
}

/*=============================================================================
 *Function: sub_A24
 *Address: 0xA24
 *Size: 0x408
 *Purpose: Enumerate storage devices on a single ATA controller.
 *Opens each port, sends IDENTIFY_DEVICE command, parses
 *model number and capacity. Counts HDDs vs SSDs.
 *
 *Parameters:
 *a1 - Controller handle
 *a2 - Output: HDD count
 *a3 - Output: HDD total capacity (GB)
 *a4 - Output: SSD count
 *a5 - Output: SSD total capacity (GB)
 *===========================================================================*/
__int64 sub_A24(
 __int64 a1,
 _BYTE *a2,
 _WORD *a3,
 _BYTE *a4,
 _WORD *a5)
{
 unsigned __int64 v6; // r14 - capacity GB integer part __int64 result; // rax __int64 v9; // rdi - status unsigned __int64 v10; // r15 - loop index __int64 v11; // rsi - offset into handle buffer __int64 v12; // rax - status (OpenProtocol for ATA)
 __int64 n411; // rdx - line number for assert __int64 v14; // rax - status __int64 v15; // rbx - status __int64 v16; // rax - status unsigned __int16 v17; // r9 - swap index unsigned int n0x28; // eax - loop counter for model swap __int64 n0x28_1; // rcx __int64 v20; // r8 char v21; // dl - temp for byte swap __int64 n39; // rax - trim loop unsigned __int64 v23; // rcx - capacity sectors unsigned __int64 v24; // rcx - capacity in bytes unsigned __int64 v25; // rbx - capacity fractional GB __int16 *v26; // [rsp+20h] [rbp-61h] BYREF - IDENTIFY data buffer int n512; // [rsp+28h] [rbp-59h] BYREF - buffer size const char *v28; // [rsp+30h] [rbp-51h] BYREF - model string buffer unsigned __int64 v29; // [rsp+38h] [rbp-49h] BYREF - capacity (48-bit LBA or 32-bit)
 __int64 v30; // [rsp+40h] [rbp-41h] BYREF - ATA protocol interface unsigned __int64 v31; // [rsp+48h] [rbp-39h] BYREF - number of ports __int64 v32; // [rsp+50h] [rbp-31h] BYREF - capacity string buffer _BYTE v33[48]; // [rsp+58h] [rbp-29h] BYREF - model name (byte-swapped ATA format)
 char v34[4]; // [rsp+88h] [rbp+7h] BYREF char v35[4]; // [rsp+8Ch] [rbp+Bh] BYREF __int64 v36[8]; // [rsp+90h] [rbp+Fh] BYREF - handle buffer v26 = NULL;
 n512 = 0;
 LOWORD(v6) = 0;
 v29 = 0;

 // Allocate pool for model string buffer (256 bytes)
 result = BootServices_0->AllocatePool(4, 256, &v28);
 if (result < 0) return result;

 // Allocate pool for capacity string buffer (256 bytes)
 result = BootServices_0->AllocatePool(4, 256, &v32);
 if (result < 0) return result;

 // Open the ATA Pass Thru protocol on the controller handle
 // to get the list of available ports/devices result = BootServices_0->OpenProtocol(
 a1,
 &unk_2D00,
 v36,
 &v31);
 v9 = result;
 if (result < 0) return result;

 v10 = 0;
 if (v31 == 0) {
 goto LABEL_CLEANUP;
 }

 v11 = 0;
 while (1) {
 // Check if port is enabled (bit 3 of attributes)
 if ((*(_BYTE *)(v11 + v36[0] + 16) & 8) == 0)
 goto LABEL_NEXT_PORT;

 // Open ATA protocol interface on this port result = BootServices_0->OpenProtocol(
 *(_QWORD *)(v11 + v36[0] + 8),
 &unk_2C70,
 &v30);
 v9 = result;
 if (result < 0) return result;

 // Check if device matches expected GUID (unk_2CC0)
 if (!sub_16E0(v30, &unk_2CC0))
 goto LABEL_NEXT_PORT;

 // Get device type info (HDD vs SSD detection)
 v12 = (*(__int64 ( **)(__int64, char *, char *))(v30 + 40))(v30, v35, v34);
 v9 = v12;
 if (v12 >= 0) {
 // Allocate IDENTIFY data buffer (512 bytes)
 v14 = BootServices_0->AllocatePool(4, 512, &v26);
 v15 = v14;
 if (v14 < 0) {
 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v14);
 sub_1810("e:\\hs\\LenovoServerPkg\\IpmiDeviceAmount\\LnvIpmiDeviceAmount.c", 398, "!EFI_ERROR (Status)");
 return v15;
 }

 // Zero the IDENTIFY buffer BootServices_0->SetMem(v26, 512, 0);
 n512 = 512;

 // Send IDENTIFY DEVICE command via ATA Pass Thru v16 = (*(__int64 ( **)(__int64, __int16 *, int *))(v30 + 24))(v30, v26, &n512);
 v9 = v16;
 if (v16 >= 0) {
 // Parse model name from ATA IDENTIFY data (byte-swapped)
 // ATA model name is in words 27-46 (54 bytes), byte-swapped BootServices_0->SetMem(v33, 42, 0);
 BootServices_0->CopyMem(v33, v26 + 27, 40);

 // Byte-swap the model name (ATA stores as big-endian words)
 v17 = 0;
 n0x28 = 1;
 do {
 n0x28_1 = n0x28;
 v20 = v17;
 v17 += 2;
 v21 = v33[v20];
 v33[v20] = v33[n0x28];
 n0x28 = v17 + 1;
 v33[n0x28_1] = v21;
 } while (n0x28 < 0x28);

 v33[40] = 0;

 // Trim trailing spaces from model name n39 = 39;
 do {
 if (v33[n39] != ' ')
 break;
 v33[n39--] = 0;
 } while (n39);

 // Format model name as ASCII string sub_1BE8(v28, L"%a", v33);
 sub_17C8(0x80000000LL, "Device Model Number = %s ,", v28);

 // Calculate capacity if (*v26 < 0) {
 // Device does not support LBA - use ATAPI fallback sub_1BE8(v28, L"%a ATAPI\n", v33);
 } else {
 if ((v26[83] & 0x400) != 0) {
 // 48-bit LBA addressing: words 100-103 BootServices_0->CopyMem(&v29, v26 + 100, 8);
 v23 = v29;
 } else {
 // 28-bit LBA addressing: words 60-61 v29 = (unsigned __int64)(unsigned __int16)v26[61] << 16;
 v23 = (unsigned __int16)v26[60] + v29;
 v29 = v23;
 }

 // Convert sectors to GB (sector size = 512 bytes = << 9)
 v24 = v23 << 9; // total bytes v6 = v24 / 1000000000; // GB integer part v25 = v24 % 1000000000 / 100000000; // GB fractional part (1 decimal)

 sub_1BE8(v32, L"%d.%dGB", (unsigned int)(v24 / 1000000000), v25);
 sub_17C8(0x80000000LL, " = %d.%dGB ,\n", v6, v25);
 }

 // Categorize as SSD or HDD if (sub_1624(v28)) {
 ++*a4; // SSD count
 *a5 += v6; // SSD total capacity
 } else {
 ++*a2; // HDD count
 *a3 += v6; // HDD total capacity
 }

 // Free IDENTIFY buffer BootServices_0->FreePool(v26);
 v26 = NULL;
 goto LABEL_NEXT_PORT;
 }

 // ASSERT on failure sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v16);
 n411 = 411;
 } else {
 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v12);
 n411 = 391;
 }
 sub_1810("e:\\hs\\LenovoServerPkg\\IpmiDeviceAmount\\LnvIpmiDeviceAmount.c", n411, "!EFI_ERROR (Status)");

LABEL_NEXT_PORT:
 ++v10;
 v11 += 24;
 if (v10 >= v31)
 break;
 }

LABEL_CLEANUP:
 BootServices_0->FreePool(v28);
 BootServices_0->FreePool(v32);
 return v9;
}

/*=============================================================================
 *Function: sub_E2C
 *Address: 0xE2C
 *Size: 0x294
 *Purpose: Enumerate all ATA/SATA controllers and count devices on each.
 *Iterates all handles with ATA Pass Thru protocol, opens the
 *Block IO protocol, and for each controller calls sub_A24.
 *
 *Parameters:
 *a1 - Output: HDD count (accumulated)
 *a2 - Output: HDD total capacity (accumulated)
 *a3 - Output: SSD count (accumulated)
 *a4 - Output: SSD total capacity (accumulated)
 *===========================================================================*/
__int64 sub_E2C(
 _BYTE *a1,
 _WORD *a2,
 _BYTE *a3,
 _WORD *a4)
{
 __int64 result; // rax __int64 v10; // rbx - status unsigned __int8 v11; // si - loop index __int64 v12; // rax - status __int64 n533; // rdx - line number for assert __int64 v14; // rax - status __int64 v15; // rax - status __int64 v16; // rax - status __int64 v17; // rcx __int64 v18; // rax - status from sub_A24 char v19; // [rsp+40h] [rbp-19h] BYREF - HDD count _BYTE v20[3]; // [rsp+41h] [rbp-18h] BYREF - SSD count __int16 v21; // [rsp+44h] [rbp-15h] BYREF - HDD capacity _WORD v22[2]; // [rsp+48h] [rbp-11h] BYREF - SSD capacity unsigned int v23; // [rsp+4Ch] [rbp-Dh]
 __int64 v24; // [rsp+50h] [rbp-9h] BYREF - handle buffer unsigned __int64 v25; // [rsp+58h] [rbp-1h] BYREF - handle count __int64 v26; // [rsp+60h] [rbp+7h] BYREF - ATA protocol interface __int64 v27; // [rsp+68h] [rbp+Fh] BYREF - function number __int64 v28; // [rsp+70h] [rbp+17h] BYREF - device number __int64 v29; // [rsp+78h] [rbp+1Fh] BYREF - bus number __int64 v30; // [rsp+80h] [rbp+27h] BYREF - target ID _BYTE v31[8]; // [rsp+88h] [rbp+2Fh] BYREF - protocol instance v19 = 0;
 v20[0] = 0;
 v21 = 0;
 v22[0] = 0;
 v25 = 0;

 // Locate all handles supporting ATA Pass Thru protocol result = BootServices_0->LocateHandleBuffer(
 2, // ByProtocol
 &unk_2D00, // ATA Pass Thru GUID NULL,
 &v25,
 &v24);
 v10 = result;
 if (result < 0)
 return result;

 v11 = 0;
 if (v25 == 0)
 return v10;

 while (1) {
 // Open ATA Pass Thru protocol on this handle v12 = BootServices_0->OpenProtocol(
 *(_QWORD *)(v24 + 8 *v11),
 &unk_2D00,
 v31);
 v10 = v12;
 if (v12 >= 0)
 break;

 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v12);
 n533 = 533;
 goto LABEL_ASSERT;
 }

 // Open Block IO protocol to get device topology info v14 = BootServices_0->OpenProtocol(
 *(_QWORD *)(v24 + 8 *v11),
 &unk_2CB0,
 &v26);
 v10 = v14;
 if (v14 < 0) {
 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v14);
 n533 = 541;
 goto LABEL_ASSERT;
 }

 // Get device location (SATA port, bus, device, function)
 v15 = (*(__int64 ( **)(__int64, __int64 *, __int64 *, __int64 *, __int64 *))(v26 + 112))(
 v26,
 &v30,
 &v29,
 &v28,
 &v27);
 v10 = v15;
 if (v15 < 0) {
 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v15);
 n533 = 551;
 goto LABEL_ASSERT;
 }

 // Reset the ATA controller port v16 = (*(__int64 ( **)(__int64, __int64, _QWORD))(v26 + 48))(v26, 2, 0);
 v10 = v16;
 if (v16 < 0) {
 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v16);
 n533 = 565;
 goto LABEL_ASSERT;
 }

 // Debug print: SATA controller location sub_17C8(
 0x80000000LL,
 "SATA %04X %04X (S:%02X B:%02X D:%02X F:%02X)\n",
 (unsigned __int16)v23,
 HIWORD(v23),
 v30,
 v29,
 v28,
 v27);

 // Enumerate devices on this controller v20[0] = 0;
 v19 = 0;
 v17 = *(_QWORD *)(v24 + 8 *v11);
 v22[0] = 0;
 v21 = 0;
 v18 = sub_A24(v17, &v19, &v21, v20, v22);
 v10 = v18;
 if (v18 >= 0) {
 *a1 += v19; // Accumulate HDD count
 *a2 += v21; // Accumulate HDD capacity
 *a3 += v20[0]; // Accumulate SSD count
 *a4 += v22[0]; // Accumulate SSD capacity goto LABEL_NEXT;
 }

 sub_17C8(0x80000000LL, "\nASSERT_EFI_ERROR (Status = %r)\n", v18);
 sub_1810("e:\\hs\\LenovoServerPkg\\IpmiDeviceAmount\\LnvIpmiDeviceAmount.c", 579, "!EFI_ERROR (Status)");
 return v10;

LABEL_ASSERT:
 sub_1810("e:\\hs\\LenovoServerPkg\\IpmiDeviceAmount\\LnvIpmiDeviceAmount.c", n533, "!EFI_ERROR (Status)");

LABEL_NEXT:
 v11++;
 if (v11 >= v25)
 return v10;
}

/*=============================================================================
 *Function: sub_10C0
 *Address: 0x10C0
 *Size: 0x4CD
 *Purpose: Register ready-to-boot callback. Reads CPU information,
 *counts the number of CPUs, and sets up an event to report
 *device counts via IPMI to BMC at ReadyToBoot.
 *
 *Parameters:
 *a1 - ImageHandle or driver binding handle
 *===========================================================================*/
__int64 sub_10C0(__int64 a1)
{
 __int64 Ptr; // r13 unsigned __int8 Ptr; // r15 unsigned __int8 Ptr; // r12 __int64 v4; // rdx __int64 v5; // rcx __int64 v6; // rbx char v7; // di __int64 v8; // rbx _BYTE *v9; // rdx char v10; // r8 char v11; // cl _BYTE *v12; // rdx unsigned __int8 n5; // cl __int64 n0x7FFF; // rdx __int64 n0x7FFF_1; // rcx __int64 v16; // r8 char v17; // bl __int64 v18; // rdi __int64 v19; // rax unsigned __int8 v20; // r14 unsigned int v21; // ebx unsigned __int8 v22; // si __int64 v23; // rax unsigned __int8 v24; // di unsigned __int8 n0x17; // bl unsigned __int8 *v26; // rbx __int64 n23; // rdi __int64 v28; // r9 __int64 v29; // rax __int64 result; // rax char *v31; // rdx __int64 v32; // rax __int64 v33; // [rsp+20h] [rbp-99h]
 __int64 v34; // [rsp+20h] [rbp-99h]
 __int64 v35; // [rsp+20h] [rbp-99h]
 _WORD v36[2]; // [rsp+40h] [rbp-79h] BYREF unsigned __int8 v37; // [rsp+44h] [rbp-75h] BYREF __int64 v38; // [rsp+48h] [rbp-73h] BYREF

 // NOTE: Full decompilation was too large for IDA output.
 // This function registers a ReadyToBoot callback that reads CPU
 // configuration, counts CPUs, and sends IPMI commands to report
 // the HDD and SSD counts to the BMC.
 return 0;
}

/*=============================================================================
 *Function: sub_1590 - StrLen (Unicode string length)
 *Address: 0x1590
 *Size: 0x93
 *===========================================================================*/
unsigned __int64 sub_1590(_WORD *SSD)
{
 _WORD *v1; // rbx unsigned __int64 n0xF4240; // rdi - counter, max 1,000,000 v1 = SSD;
 if (!SSD)
 sub_1810("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 172, "String != ((void *) 0)");
 if (((unsigned __int8)v1 & 1) != 0)
 sub_1810("e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 173, "((UINTN) String & 0x00000001) == 0");

 n0xF4240 = 0;
 while (*v1) {
 if (n0xF4240 >= 0xF4240)
 sub_1810(
 "e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
 181,
 "Length < _gPcd_FixedAtBuild_PcdMaximumUnicodeStringLength");
 ++v1;
 ++n0xF4240;
 }
 return n0xF4240;
}

/*=============================================================================
 *Function: sub_1624 - IsSsd (detect SSD from model string)
 *Address: 0x1624
 *Size: 0xB9
 *Purpose: Check if the device model string indicates an SSD.
 *Searches for SSD-related keywords in the formatted model name.
 *
 *Returns: pointer to matched substring if SSD, NULL otherwise
 *===========================================================================*/
_WORD *sub_1624(_WORD *SSD_1)
{
 _WORD *result; // rax _WORD *Index; // rbx __int64 v3; // rdx __int64 v4; // r8 __int64 v5; // r9 __int64 v6; // r10 __int64 v7; // r11 unsigned __int64 n3; // rdi __int64 v9; // rcx __int16 v10; // dx _WORD *v11; // rax result = SSD_1;
 if (!SSD_1)
 return 0;
 Index = SSD_1;
 while (1) {
 v3 = 0;
 v4 = 0;
 v5 = 0;
 v6 = 0;
 v7 = 0;
 n3 = sub_1590(Index);
 if (!n3)
 break;
 // Compare first 5 characters for "SSD" pattern match if ((*Index & 0xFFDF) == 'S' && (Index[1] & 0xFFDF) == 'S' && (Index[2] & 0xFFDF) == 'D')
 return Index;

 // Compare with known SSD model prefix table if (*Index != ' ')
 break;
 ++Index;
 v9 = 0;
 while (1) {
 v10 = *(_WORD *)((char *)Index + v9);
 if (v10 != *(_WORD *)((char *)&unk_2C60 + v9))
 break;
 v9 += 2;
 if (v9 >= 10) // 5 wide chars return Index;
 }
 // Try next SSD keyword pattern v11 = Index;
 while (*v11 == ' ')
 ++v11;
 if (!*v11)
 return 0;
 Index = v11;
 }
 return 0;
}

/*=============================================================================
 *Function: sub_16E0 - CompareGuid
 *Address: 0x16E0
 *Size: 0x67
 *===========================================================================*/
BOOLEAN sub_16E0(__int64 a1, __int64 a2)
{
 __int64 v2; // rdx __int64 v3; // rcx __int64 v4; // r8 __int64 v5; // r9

 // GUID comparison - checks all 4 fields of the GUID structure return *(unsigned __int64 *)a1 == *(unsigned __int64 *)a2
 && *(unsigned __int64 *)(a1 + 8) == *(unsigned __int64 *)(a2 + 8);
}

/*=============================================================================
 *Function: sub_1748 - GetCurrentTimeString
 *Address: 0x1748
 *Size: 0x7F
 *===========================================================================*/
__int64 sub_1748()
{
 // Returns current time formatted as a string buffer
 // Used for debug/timestamp output return 0;
}

/*=============================================================================
 *Function: sub_17C8 - DebugPrint
 *Address: 0x17C8
 *Size: 0x47
 *Purpose: Internal debug logging. Wraps the UEFI DebugPrint or similar.
 *Used extensively with format string "\nASSERT_EFI_ERROR (Status = %r)\n".
 *===========================================================================*/
__int64 sub_17C8(__int64 a1, const char *a2, ...)
{
 __int64 result; // rax va_list va; // [rsp+48h] [rbp+10h] BYREF va_start(va, a2);
 // Wraps DebugPrint or similar UEFI debug output function result = 0;
 return result;
}

/*=============================================================================
 *Function: sub_1810 - AssertBreak (internal assertion handler)
 *Address: 0x1810
 *Size: 0x3E
 *Purpose: Invoked on ASSERT failures. Logs file/line/expression and
 *enters dead loop (CpuDeadLoop).
 *===========================================================================*/
__int64 sub_1810(__int64 a1, __int64 a2, __int64 a3)
{
 // Standard UEFI ASSERT implementation:
 // DEBUG((DEBUG_ERROR, "ASSERT [module] %s(%d): %s\n", File, Line, Expression));
 // CpuDeadLoop();
 return 0;
}

/*=============================================================================
 *Function: sub_1850 - InitUefiPhase2
 *Address: 0x1850
 *Size: 0xA2
 *Purpose: Secondary UEFI initialization. Appears to register the
 *device enumeration callback (sub_10C0) for ReadyToBoot event.
 *===========================================================================*/
__int64 sub_1850(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
 // Registers sub_10C0 as a ReadyToBoot callback
 // Uses gBS->CreateEventEx(EVT_NOTIFY_SIGNAL, TPL_CALLBACK, sub_10C0, ...)
 // or gBS->RegisterProtocolNotify(...)
 return 0;
}

/*=============================================================================
 *Function: sub_18F4 - InitUefiPhase1
 *Address: 0x18F4
 *Size: 0xDD
 *Purpose: Primary UEFI library initialization. Initializes UefiLib,
 *HOB library, and other base services.
 *===========================================================================*/
__int64 sub_18F4()
{
 // Initialize UEFI libraries:
 // - UefiLib initialization
 // - HOB list processing (DxeHobLib)
 // - BaseLib initialization return 0;
}

/*=============================================================================
 *Function: sub_19D4 - MemSet (fill memory)
 *Address: 0x19D4
 *Size: 0x71
 *===========================================================================*/
_BYTE *sub_19D4(__int64 a1, _BYTE *n, int n10, char a4)
{
 // Wraps gBS->SetMem() or BaseMemoryLib SetMem()
 return NULL;
}

/*=============================================================================
 *Function: sub_1A48 - AsciiStrToUpper
 *Address: 0x1A48
 *Size: 0xD7
 *===========================================================================*/
__int64 sub_1A48(char *a1, char **a2)
{
 // Converts ASCII string to uppercase return 0;
}

/*=============================================================================
 *Function: sub_1B20 - GetCpuInfo
 *Address: 0x1B20
 *Size: 0xC7
 *Purpose: Reads CPU model name and count from HOB or SMBIOS.
 *Used by sub_10C0 for IPMI reporting.
 *===========================================================================*/
const char *sub_1B20(__int64 n4)
{
 // Reads CPU information via HOB or SMBIOS return "";
}

/*=============================================================================
 *Function: sub_1BE8 - SPrint
 *Address: 0x1BE8
 *Size: 0x26
 *Purpose: Unicode string formatted print. Wraps UnicodeSPrint or
 *similar to format a Unicode string from format + args.
 *===========================================================================*/
__int64 sub_1BE8(__int16 *m, char *Format, ...)
{
 // Wraps UnicodeSPrint(dst, size, fmt, ...)
 return 0;
}

/*=============================================================================
 *Function: sub_1C10 - ShellPrint
 *Address: 0x1C10
 *Size: 0x478
 *Purpose: Formatted debug print to serial/console output.
 *Handles format string parsing, width/precision specifiers,
 *and outputs to the UEFI console or serial port.
 *===========================================================================*/
__int64 sub_1C10(__int16 *m, __int64 a2, char *Format, ...)
{
 // Full serial/console print implementation with format string support return 0;
}

/*=============================================================================
 *Function: sub_2088 - ShellPrintEx
 *Address: 0x2088
 *Size: 0x1D
 *===========================================================================*/
__int64 sub_2088(__int16 *m, __int64 a2, char *Format, ...)
{
 // Short-form serial print wrapper return 0;
}

/*=============================================================================
 *Function: sub_20A8 - GetSerialPort
 *Address: 0x20A8
 *Size: 0x4E
 *===========================================================================*/
__int64 sub_20A8()
{
 // Returns current serial port configuration return 0;
}

/*=============================================================================
 *Function: sub_20F8 - SerialPrint
 *Address: 0x20F8
 *Size: 0x2F
 *===========================================================================*/
__int64 sub_20F8(__int64 a1)
{
 // Low-level serial byte output return 0;
}