#include "Mtftp4Dxe.h"

//
// Mtftp4Dxe - UEFI Module
// Total functions: 123
//

// Function: CopyMem @ 0x2c0 (0x42 bytes)

char *__fastcall CopyMem(char *dst, char *src, unsigned __int64 count)
{
  char *dst_1; // rax
  unsigned __int64 count_1; // rcx
  char *dst_2; // rdi
  char *src_1; // rsi

  dst_1 = dst; /*0x2d0*/
  if ( src < dst && &src[count - 1] >= dst ) /*0x2d8*/
  {
    src_1 = &src[count - 1]; /*0x2f0*/
    dst_2 = &dst[count - 1]; /*0x2f3*/
  }
  else
  {
    count_1 = count; /*0x2da*/
    count &= 7u; /*0x2dd*/
    count_1 >>= 3; /*0x2e4*/
    qmemcpy(dst, src, 8 * count_1); /*0x2e8*/
    src_1 = &src[8 * count_1]; /*0x2e8*/
    dst_2 = &dst[8 * count_1]; /*0x2e8*/
  }
  qmemcpy(dst_2, src_1, count); /*0x2fc*/
  return dst_1; /*0x2ff*/
}


// Function: ZeroMem @ 0x310 (0x20 bytes)

char *__fastcall ZeroMem(char *buf, unsigned __int64 a2)
{
  memset(buf, 0, 8 * (a2 >> 3)); /*0x326*/
  memset(&buf[8 * (a2 >> 3)], 0, a2 & 7); /*0x32b*/
  return buf; /*0x32e*/
}


// Function: CompareMem @ 0x330 (0x1d bytes)

unsigned __int64 __fastcall CompareMem(_BYTE *a1, _BYTE *a2, __int64 n4)
{
  bool v6; // zf

  do /*0x33b*/
  {
    if ( !n4 ) /*0x33b*/
      break; /*0x33b*/
    v6 = *a1++ == *a2++; /*0x33b*/
    --n4; /*0x33b*/
  }
  while ( v6 ); /*0x33b*/
  return (unsigned __int8)*(a1 - 1) - (unsigned __int64)(unsigned __int8)*(a2 - 1); /*0x34a*/
}


// Function: Mtftp4Unload @ 0x3a4 (0x184 bytes)

__int64 __fastcall Mtftp4Unload(__int64 a1)
{
  __int64 result; // rax
  unsigned __int64 i; // rbx
  __int64 v4; // rcx
  unsigned __int64 j; // rdi
  __int64 v6; // [rsp+30h] [rbp-10h] BYREF
  __int64 v7; // [rsp+38h] [rbp-8h] BYREF
  __int64 v8; // [rsp+68h] [rbp+28h] BYREF
  __int64 v9; // [rsp+70h] [rbp+30h] BYREF
  unsigned __int64 j_1; // [rsp+78h] [rbp+38h] BYREF

  result = (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD, unsigned __int64 *, __int64 *))(BootServices + 312))( /*0x3d1*/
             0,
             0,
             0,
             &j_1,
             &v9);
  if ( result >= 0 ) /*0x3da*/
  {
    for ( i = 0; i < j_1; ++i ) /*0x3e6*/
    {
      if ( (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices + 152))( /*0x40f*/
             *(_QWORD *)(v9 + 8 * i),
             &unk_9610,
             &v8) >= 0 )
      {
        v4 = v8; /*0x415*/
        if ( *(_QWORD *)(v8 + 32) == a1 ) /*0x41d*/
        {
          for ( j = 0; j < j_1; ++j ) /*0x429*/
          {
            (*(void (__fastcall **)(_QWORD, _QWORD, _QWORD))(BootServices + 272))( /*0x441*/
              *(_QWORD *)(v9 + 8 * j),
              *(_QWORD *)(v4 + 40),
              0);
            v4 = v8; /*0x447*/
          }
          (*(void (__fastcall **)(_QWORD, void *, __int64))(BootServices + 144))(*(_QWORD *)(v4 + 40), &unk_9610, v4); /*0x469*/
          if ( (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices + 152))( /*0x492*/
                 *(_QWORD *)(v9 + 8 * i),
                 &unk_9630,
                 &v6) >= 0 )
            (*(void (__fastcall **)(_QWORD, void *, __int64))(BootServices + 144))(*(_QWORD *)(v8 + 40), &unk_9630, v6); /*0x4ae*/
          if ( (*(__int64 (__fastcall **)(_QWORD, void *, __int64 *))(BootServices + 152))( /*0x4d7*/
                 *(_QWORD *)(v9 + 8 * i),
                 &unk_95B0,
                 &v7) >= 0 )
            (*(void (__fastcall **)(_QWORD, void *, __int64))(BootServices + 144))(*(_QWORD *)(v8 + 40), &unk_95B0, v7); /*0x4f3*/
        }
      }
    }
    if ( v9 ) /*0x50d*/
      (*(void (**)(void))(BootServices + 72))(); /*0x516*/
    return 0; /*0x519*/
  }
  return result; /*0x520*/
}


// Function: _ModuleEntryPoint @ 0x528 (0x88 bytes)

EFI_STATUS ModuleEntryPoint(EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
  __int64 v4; // rax
  __int64 v6; // [rsp+40h] [rbp+18h] BYREF

  Mtftp4LibConstructor((__int64)ImageHandle, SystemTable); /*0x538*/
  v4 = (*(__int64 (__fastcall **)(EFI_HANDLE, void *, __int64 *))(BootServices + 152))(ImageHandle, &unk_9580, &v6); /*0x553*/
  if ( v4 < 0 ) /*0x55c*/
  {
    DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v4); /*0x56d*/
    Assert_( /*0x585*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiDriverEntryPoint\\DriverEntryPoint.c",
      126,
      (__int64)"!EFI_ERROR (Status)");
  }
  *(_QWORD *)(v6 + 88) = Mtftp4Unload; /*0x599*/
  return Mtftp4DriverEntryPoint((__int64)ImageHandle, SystemTable); /*0x5aa*/
}


// Function: Mtftp4LibConstructor @ 0x5b0 (0xf2 bytes)

__int64 __fastcall Mtftp4LibConstructor(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
  __int64 result; // rax

  ImageHandle_1 = ImageHandle; /*0x5b6*/
  if ( !ImageHandle ) /*0x5c3*/
    Assert_( /*0x5d6*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
      51,
      (__int64)"gImageHandle != ((void *) 0)");
  ::SystemTable = (__int64)SystemTable; /*0x5db*/
  if ( !SystemTable ) /*0x5e5*/
    Assert_( /*0x5f8*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
      57,
      (__int64)"gST != ((void *) 0)");
  BootServices = (__int64)SystemTable->BootServices; /*0x601*/
  if ( !BootServices ) /*0x60b*/
    Assert_( /*0x61e*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiBootServicesTableLib\\UefiBootServicesTableLib.c",
      63,
      (__int64)"gBS != ((void *) 0)");
  RuntimeServices = (__int64)SystemTable->RuntimeServices; /*0x627*/
  if ( !RuntimeServices ) /*0x631*/
    Assert_( /*0x644*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiRuntimeServicesTableLib\\UefiRuntimeServicesTableLib.c",
      47,
      (__int64)"gRT != ((void *) 0)");
  AssertCpuDeadLoop(); /*0x649*/
  result = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_9640, 0, &qword_9780); /*0x665*/
  if ( result < 0 ) /*0x66e*/
  {
    DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", result); /*0x67f*/
    return Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeDpcLib\\DpcLib.c", 46, (__int64)"!EFI_ERROR (Status)"); /*0x697*/
  }
  return result; /*0x69c*/
}


// Function: Mtftp4DriverEntryPoint @ 0x6a4 (0xff bytes)

__int64 __fastcall Mtftp4DriverEntryPoint(__int64 ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
{
  EFI_RUNTIME_SERVICES *RuntimeServices; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  _BYTE v7[24]; // [rsp+40h] [rbp-18h] BYREF
  __int64 n10; // [rsp+68h] [rbp+10h] BYREF

  RuntimeServices = SystemTable->RuntimeServices; /*0x6b0*/
  n10 = 10; /*0x6bb*/
  v4 = ((__int64 (__fastcall *)(const __int16 *, void *, _QWORD, __int64 *, _BYTE *))RuntimeServices->GetVariable)( /*0x6df*/
         L"NetworkStackVar",
         &unk_9650,
         0,
         &n10,
         v7);
  if ( !v4 ) /*0x6e5*/
  {
    if ( v7[0] ) /*0x6ef*/
    {
      ::ImageHandle = ImageHandle; /*0x720*/
      ImageHandle_0 = ImageHandle; /*0x73a*/
      v5 = (*(__int64 (__fastcall **)(__int64 *, void *, __int64 (__fastcall **)(), void *, _UNKNOWN **, void *, _UNKNOWN **, _QWORD))(BootServices + 328))( /*0x75b*/
             &ImageHandle_0,
             &unk_9610,
             off_9660,
             &unk_9630,
             &off_96A8,
             &unk_95B0,
             &off_9690,
             0);
      v4 = v5; /*0x761*/
      if ( v5 < 0 ) /*0x767*/
      {
        DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v5); /*0x778*/
        Assert_((__int64)"e:\\hs\\MdePkg\\Library\\UefiLib\\UefiDriverModel.c", 287, (__int64)"!EFI_ERROR (Status)"); /*0x790*/
      }
    }
    else
    {
      return 0x8000000000000003uLL; /*0x6f1*/
    }
  }
  return v4; /*0x79d*/
}


// Function: Mtftp4UdpIoConfigure @ 0x7a4 (0x37 bytes)

__int64 __fastcall Mtftp4UdpIoConfigure(__int64 a1, __int64 a2)
{
  return (*(__int64 (__fastcall **)(__int64, void *, _QWORD, _QWORD, __int64, int))(BootServices + 280))( /*0x7d6*/
           a2,
           &unk_95C0,
           0,
           *(_QWORD *)(a1 + 40),
           a2,
           4);
}


// Function: Mtftp4CreateService @ 0x7e0 (0x14d bytes)

__int64 __fastcall Mtftp4CreateService(__int64 a1, __int64 a2, _QWORD *a3)
{
  __int64 v6; // rax
  _QWORD *v7; // rbx
  __int64 BootServices; // rax
  __int64 v10; // rdi
  __int64 v11; // r9
  __int64 v12; // rax

  *a3 = 0; /*0x805*/
  v6 = AllocatePool(a1, 88); /*0x80f*/
  v7 = (_QWORD *)v6; /*0x814*/
  if ( !v6 ) /*0x81a*/
    return 0x8000000000000009uLL; /*0x826*/
  *(_DWORD *)v6 = 1347700308; /*0x836*/
  *(_WORD *)(v6 + 24) = 0; /*0x83c*/
  *(_OWORD *)(v6 + 8) = *(_OWORD *)off_78A0; /*0x841*/
  InitializeListHead((_QWORD *)(v6 + 32)); /*0x846*/
  BootServices = BootServices; /*0x84b*/
  v7[6] = 0; /*0x85a*/
  v7[7] = 0; /*0x861*/
  v7[8] = a1; /*0x86b*/
  v7[9] = a2; /*0x874*/
  v7[10] = 0; /*0x87d*/
  v10 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD *(__fastcall *)(__int64, __int64), _QWORD *, _QWORD *))(BootServices + 80))( /*0x889*/
          2147484160LL,
          8,
          Mtftp4CheckTimeout,
          v7,
          v7 + 6);
  if ( v10 < 0 ) /*0x88f*/
    goto LABEL_4; /*0x88f*/
  v10 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD))(BootServices + 80))(0x80000000LL, 8, 0); /*0x8bc*/
  if ( v10 < 0 ) /*0x8c2*/
  {
LABEL_8:
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v7[6]); /*0x8fb*/
LABEL_4:
    AssertCpuDeadLoop_0(); /*0x891*/
    return v10; /*0x89c*/
  }
  v12 = DxeConfig_3(a1, a2, sub_7DC, v11, 0); /*0x8d6*/
  v7[10] = v12; /*0x8db*/
  if ( !v12 ) /*0x8e2*/
  {
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v7[7]); /*0x8ee*/
    v10 = 0x8000000000000007uLL; /*0x8f1*/
    goto LABEL_8; /*0x8f1*/
  }
  *a3 = v7; /*0x90b*/
  return 0; /*0x91f*/
}


// Function: Mtftp4ServiceBindingCreateChild @ 0x930 (0x11a bytes)

signed __int64 __fastcall Mtftp4ServiceBindingCreateChild(__int64 a1, __int64 a2)
{
  signed __int64 result; // rax
  _QWORD *v4; // rbx
  __int64 v5; // rdi
  _QWORD *v6; // [rsp+40h] [rbp+8h] BYREF
  __int64 v7; // [rsp+48h] [rbp+10h] BYREF

  v7 = a2; /*0x935*/
  if ( !(*(__int64 (__fastcall **)(__int64, void *, _QWORD, _QWORD, __int64, int))(BootServices + 280))( /*0x96a*/
          a2,
          &unk_9600,
          0,
          *(_QWORD *)(a1 + 40),
          a2,
          4) )
    return 0x8000000000000014uLL; /*0x975*/
  result = Mtftp4CreateService(v7, *(_QWORD *)(a1 + 40), &v6); /*0x992*/
  if ( result >= 0 ) /*0x99a*/
  {
    v4 = v6; /*0x9a0*/
    if ( !v6 ) /*0x9a8*/
      Assert_( /*0x9bd*/
        (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
        337,
        (__int64)"MtftpSb != ((void *) 0)");
    v5 = (*(__int64 (__fastcall **)(_QWORD, __int64, __int64))(BootServices + 88))(v4[6], 1, 10000000); /*0x9db*/
    if ( v5 < 0 /*0xa09*/
      || (v5 = (*(__int64 (__fastcall **)(__int64 *, void *, _QWORD *, _QWORD))(BootServices + 328))(
                 &v7,
                 &unk_9600,
                 v4 + 1,
                 0),
          v5 < 0) )
    {
      DxeConfig_5(v4[10]); /*0xa13*/
      (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v4[7]); /*0xa23*/
      (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v4[6]); /*0xa31*/
      AssertCpuDeadLoop_0(); /*0xa37*/
      return v5; /*0xa3c*/
    }
    else
    {
      return 0; /*0xa0b*/
    }
  }
  return result; /*0xa44*/
}


// Function: Mtftp4DestroyChildCallback @ 0xa4c (0x9b bytes)

__int64 __fastcall Mtftp4DestroyChildCallback(_QWORD *i, _QWORD *a2)
{
  __int64 v2; // rbx
  _QWORD *i_1; // rdi
  unsigned __int64 v5; // rax
  __int64 v6; // rcx

  v2 = 0; /*0xa5b*/
  i_1 = i; /*0xa60*/
  if ( !i || !a2 ) /*0xa6b*/
    return 0x8000000000000002uLL; /*0xacd*/
  if ( *((_DWORD *)i - 2) == 1886676596 ) /*0xa74*/
    i_1 = i - 1; /*0xa90*/
  else
    Assert_( /*0xa89*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
      394,
      (__int64)"CR has Bad Signature");
  v5 = a2[1]; /*0xa94*/
  v6 = a2[2]; /*0xa9b*/
  if ( !v5 || !v6 ) /*0xaa7*/
    return 0; /*0xac0*/
  while ( i_1[14] != *(_QWORD *)(v6 + 8 * v2) ) /*0xab6*/
  {
    if ( ++v2 >= v5 ) /*0xabe*/
      return 0; /*0xabe*/
  }
  return (*(__int64 (__fastcall **)(_QWORD))(*a2 + 8LL))(*a2); /*0xae1*/
}


// Function: Mtftp4ServiceBindingDestroyChild @ 0xae8 (0x1df bytes)

__int64 __fastcall Mtftp4ServiceBindingDestroyChild(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 v7; // r14
  unsigned __int64 v8; // rax
  _BYTE *v9; // rcx
  __int64 v10; // rdi
  _QWORD *v12; // rbx
  __int64 v13; // [rsp+30h] [rbp-30h] BYREF
  __int64 v14; // [rsp+38h] [rbp-28h] BYREF
  unsigned __int64 v15; // [rsp+40h] [rbp-20h] BYREF
  __int64 v16[3]; // [rsp+48h] [rbp-18h] BYREF

  if ( (*(__int64 (__fastcall **)(__int64, void *, __int64 *, unsigned __int64 *))(BootServices + 296))( /*0xb35*/
         a2,
         &unk_9620,
         &v14,
         &v15) < 0 )
    return 0; /*0xb35*/
  v7 = 0; /*0xb3f*/
  v8 = 0; /*0xb46*/
  if ( v15 ) /*0xb4b*/
  {
    v9 = (_BYTE *)(v14 + 16); /*0xb4d*/
    while ( (*v9 & 0x10) == 0 ) /*0xb54*/
    {
      ++v8; /*0xb56*/
      v9 += 24; /*0xb59*/
      if ( v8 >= v15 ) /*0xb60*/
        goto LABEL_8; /*0xb60*/
    }
    v7 = *(_QWORD *)(v14 + 24 * v8 + 8); /*0xb68*/
  }
LABEL_8:
  (*(void (__fastcall **)(__int64))(BootServices + 72))(v14); /*0xb77*/
  if ( !v7 ) /*0xb7d*/
    return 0; /*0xca7*/
  v10 = (*(__int64 (__fastcall **)(__int64, void *, __int64 *, _QWORD, __int64, int))(BootServices + 280))( /*0xbaf*/
          v7,
          &unk_9600,
          &v13,
          *(_QWORD *)(a1 + 40),
          v7,
          2);
  if ( v10 < 0 ) /*0xbb5*/
    return 0x8000000000000007uLL; /*0xbb7*/
  v12 = (_QWORD *)(v13 - 8); /*0xbca*/
  if ( *(_DWORD *)(v13 - 8) != 1347700308 ) /*0xbd4*/
  {
    Assert_( /*0xbe9*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
      459,
      (__int64)"CR has Bad Signature");
    v12 = (_QWORD *)v13; /*0xbee*/
  }
  if ( !IsListEmpty(v12 + 4) ) /*0xbf9*/
  {
    v16[0] = v13; /*0xc06*/
    v16[1] = a3; /*0xc0a*/
    v16[2] = a4; /*0xc0e*/
    if ( v12 == (_QWORD *)-32LL ) /*0xc15*/
      v10 = 0x8000000000000002uLL; /*0xc28*/
    else
      v10 = NetDestroyChildrenInList(v12 + 4, v16); /*0xc23*/
  }
  if ( !a3 && IsListEmpty(v12 + 4) ) /*0xc3a*/
  {
    (*(void (__fastcall **)(__int64, void *, __int64))(BootServices + 144))(v7, &unk_9600, v13); /*0xc58*/
    DxeConfig_5(v12[10]); /*0xc62*/
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v12[7]); /*0xc72*/
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(v12[6]); /*0xc80*/
    if ( src_0 ) /*0xc8a*/
    {
      Assert_0(); /*0xc8c*/
      src_0 = 0; /*0xc91*/
    }
    AssertCpuDeadLoop_0(); /*0xc9b*/
    return 0; /*0xca0*/
  }
  return v10; /*0xcbe*/
}


// Function: Mtftp4DriverBindingStart @ 0xcc8 (0x260 bytes)

__int64 __fastcall Mtftp4DriverBindingStart(__int64 a1, __int64 *a2)
{
  __int64 v3; // rdi
  __int64 buf; // rbx
  __int64 v6; // r9
  __int64 v7; // rax
  __int64 v8; // rsi
  __int64 v9; // rax
  __int64 v10; // rcx
  __int64 v11; // rax
  _QWORD *v12; // rdx
  __int64 v13; // rbx
  __int64 BootServices; // rax
  char v15; // [rsp+50h] [rbp+8h] BYREF

  v3 = a1; /*0xce3*/
  if ( !a1 || !a2 ) /*0xcf2*/
    return 0x8000000000000002uLL; /*0xf05*/
  buf = AllocatePool(a1, 272); /*0xd04*/
  if ( !buf ) /*0xd0a*/
    return 0x8000000000000009uLL; /*0xd16*/
  if ( *(_DWORD *)(v3 - 8) == 1347700308 ) /*0xd22*/
    v3 -= 8; /*0xd3e*/
  else
    Assert_( /*0xd37*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
      558,
      (__int64)"CR has Bad Signature");
  MemGetInfo((char *)buf, 0x110u); /*0xd48*/
  *(_DWORD *)buf = 1886676596; /*0xd51*/
  InitializeListHead((_QWORD *)(buf + 8)); /*0xd5a*/
  MemConfig_0((char *)(buf + 24), src, 0x40u); /*0xd73*/
  *(_QWORD *)(buf + 88) = 0; /*0xd78*/
  *(_QWORD *)(buf + 104) = v3; /*0xd84*/
  InitializeListHead((_QWORD *)(buf + 192)); /*0xd88*/
  v7 = DxeConfig_3(*(_QWORD *)(v3 + 64), *(_QWORD *)(v3 + 72), sub_7DC, v6, buf); /*0xda1*/
  *(_QWORD *)(buf + 224) = v7; /*0xda6*/
  if ( !v7 ) /*0xdb0*/
  {
    v8 = 0x8000000000000009uLL; /*0xdb2*/
LABEL_12:
    AssertCpuDeadLoop_0(); /*0xdef*/
    return v8; /*0xdfa*/
  }
  v8 = (*(__int64 (__fastcall **)(__int64 *, void *, __int64, _QWORD))(BootServices + 328))(a2, &unk_95A0, buf + 24, 0); /*0xddb*/
  if ( v8 < 0 ) /*0xde1*/
  {
LABEL_11:
    DxeConfig_5(*(_QWORD *)(buf + 224)); /*0xde3*/
    goto LABEL_12; /*0xdea*/
  }
  v9 = *a2; /*0xdff*/
  *(_QWORD *)(buf + 112) = *a2; /*0xe07*/
  v8 = (*(__int64 (__fastcall **)(_QWORD, void *, char *, __int64, __int64, int))(BootServices + 280))( /*0xe3b*/
         *(_QWORD *)(*(_QWORD *)(v3 + 80) + 56LL),
         &unk_9620,
         &v15,
         ImageHandle_0,
         v9,
         8);
  if ( v8 < 0 ) /*0xe41*/
  {
LABEL_16:
    v10 = *(_QWORD *)(buf + 112); /*0xead*/
    if ( v10 ) /*0xeb4*/
      (*(void (__fastcall **)(__int64, void *, __int64, _QWORD))(BootServices + 336))(v10, &unk_95A0, buf + 24, 0); /*0xece*/
    goto LABEL_11; /*0xed4*/
  }
  v8 = (*(__int64 (__fastcall **)(_QWORD, void *, char *, __int64, _QWORD, int))(BootServices + 280))( /*0xe7f*/
         *(_QWORD *)(*(_QWORD *)(buf + 224) + 56LL),
         &unk_9620,
         &v15,
         ImageHandle_0,
         *(_QWORD *)(buf + 112),
         8);
  if ( v8 < 0 ) /*0xe8c*/
  {
    (*(void (__fastcall **)(_QWORD, void *, __int64, __int64 *))(BootServices + 288))( /*0xea7*/
      *(_QWORD *)(*(_QWORD *)(v3 + 80) + 56LL),
      &unk_9620,
      ImageHandle_0,
      a2);
    goto LABEL_16; /*0xea7*/
  }
  v11 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0xede*/
  v12 = (_QWORD *)(buf + 8); /*0xee5*/
  v13 = v11; /*0xee8*/
  InsertTailList((_QWORD *)(v3 + 32), v12); /*0xeeb*/
  BootServices = BootServices; /*0xef0*/
  ++*(_WORD *)(v3 + 24); /*0xefa*/
  (*(void (__fastcall **)(__int64))(BootServices + 32))(v13); /*0xefe*/
  return 0; /*0xf1e*/
}


// Function: Mtftp4DriverBindingStop @ 0xf28 (0x1f3 bytes)

__int64 __fastcall Mtftp4DriverBindingStop(__int64 a1, __int64 a2)
{
  __int64 v3; // rsi
  __int64 result; // rax
  __int64 v5; // rdi
  __int64 BootServices; // rax
  __int64 v7; // rcx
  __int64 v8; // rbx
  __int64 v9; // [rsp+40h] [rbp+8h] BYREF

  v3 = a1; /*0xf3b*/
  if ( !a1 || !a2 ) /*0xf4a*/
    return 0x8000000000000002uLL; /*0xf4a*/
  if ( (*(__int64 (__fastcall **)(__int64, void *, __int64 *, __int64, __int64, int))(BootServices + 280))( /*0xf80*/
         a2,
         &unk_95A0,
         &v9,
         ImageHandle_0,
         a2,
         2) < 0 )
    return 0x8000000000000003uLL; /*0xf8c*/
  v5 = v9 - 24; /*0xf96*/
  if ( *(_DWORD *)(v9 - 24) != 1886676596 ) /*0xfa0*/
  {
    Assert_( /*0xfb5*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
      706,
      (__int64)"CR has Bad Signature");
    v5 = v9; /*0xfba*/
  }
  if ( *(_DWORD *)(v3 - 8) == 1347700308 ) /*0xfc6*/
    v3 -= 8; /*0xfe2*/
  else
    Assert_( /*0xfdb*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Driver.c",
      707,
      (__int64)"CR has Bad Signature");
  if ( *(_QWORD *)(v5 + 104) != v3 ) /*0xfea*/
    return 0x8000000000000002uLL; /*0x1101*/
  if ( *(_BYTE *)(v5 + 96) ) /*0xff0*/
    return 0; /*0xff8*/
  BootServices = BootServices; /*0xffd*/
  *(_BYTE *)(v5 + 96) = 1; /*0x100b*/
  (*(void (__fastcall **)(_QWORD, void *, __int64, __int64))(BootServices + 288))( /*0x1021*/
    *(_QWORD *)(*(_QWORD *)(v3 + 80) + 56LL),
    &unk_9620,
    ImageHandle_0,
    a2);
  (*(void (__fastcall **)(_QWORD, void *, __int64, __int64))(BootServices + 288))( /*0x104a*/
    *(_QWORD *)(*(_QWORD *)(v5 + 224) + 56LL),
    &unk_9620,
    ImageHandle_0,
    a2);
  v7 = *(_QWORD *)(v5 + 264); /*0x1050*/
  if ( v7 ) /*0x105a*/
    (*(void (__fastcall **)(_QWORD, void *, __int64, __int64))(BootServices + 288))( /*0x1078*/
      *(_QWORD *)(v7 + 56),
      &unk_9620,
      ImageHandle_0,
      a2);
  result = (*(__int64 (__fastcall **)(__int64, void *, __int64))(BootServices + 144))(a2, &unk_95A0, v9); /*0x1094*/
  if ( result >= 0 ) /*0x109d*/
  {
    v8 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0x10c1*/
    Mtftp4Cleanup(v5, 0x8000000000000007uLL); /*0x10c4*/
    DxeConfig_5(*(_QWORD *)(v5 + 224)); /*0x10d0*/
    RemoveEntryList((_QWORD *)(v5 + 8)); /*0x10d9*/
    --*(_WORD *)(v3 + 24); /*0x10e6*/
    (*(void (__fastcall **)(__int64))(BootServices + 32))(v8); /*0x10f1*/
    AssertCpuDeadLoop_0(); /*0x10f7*/
    return 0; /*0x10fc*/
  }
  *(_BYTE *)(v5 + 96) = 0; /*0x109f*/
  return result; /*0x1115*/
}


// Function: Mtftp4GetBestLanguage @ 0x111c (0x33 bytes)

unsigned __int64 __fastcall Mtftp4GetBestLanguage(__int64 (__fastcall **a1)(), _BYTE *src, _QWORD *a3)
{
  // "eng;en" /*0x114a*/
  return Mtftp4ConfigStringLookup( /*0x114a*/
           src,
           a1[2],
           src_1, // "eng;en"
           a3,
           a1 == (__int64 (__fastcall **)())&off_96A8);
}


// Function: Mtftp4ConfigNotification @ 0x1150 (0xd0 bytes)

__int64 __fastcall Mtftp4ConfigNotification(__int64 (__fastcall **a1)(_QWORD, _BYTE *))
{
  __int64 result; // rax
  _BYTE v2[20]; // [rsp+40h] [rbp-E8h] BYREF
  unsigned __int16 v3; // [rsp+54h] [rbp-D4h]
  _QWORD v4[21]; // [rsp+80h] [rbp-A8h] BYREF

  if ( !a1 ) /*0x115a*/
    return 0x8000000000000002uLL; /*0x115c*/
  result = (*a1)(a1, v2); /*0x1170*/
  if ( result >= 0 ) /*0x1175*/
  {
    UnicodeSPrint((__int64)v4, 0xA0u, L"MTFTPv4 (ServerIp=%d.%d.%d.%d, ServerPort=%d)", v2[16], v2[17], v2[18], v2[19], v3); /*0x11bb*/
    if ( src_0 ) /*0x11c8*/
    {
      Assert_0(); /*0x11ca*/
      src_0 = 0; /*0x11cf*/
    }
    result = Assert(byte_78B0, (char *)off_96B8, v4, 1); /*0x11f0*/
    if ( result >= 0 ) /*0x11f8*/
      return Assert(byte_78B4, (char *)off_96A0, v4, 0); /*0x1213*/
  }
  return result; /*0x1218*/
}


// Function: Mtftp4OpenProtocol @ 0x1220 (0x125 bytes)

__int64 __fastcall Mtftp4OpenProtocol(__int64 (__fastcall **a1)(), __int64 a2, __int64 a3, _BYTE *src, _QWORD *a5)
{
  __int64 result; // rax
  __int64 v9; // rbx
  unsigned __int64 v10; // rcx
  _BYTE *v11; // rax
  unsigned __int64 v12; // [rsp+30h] [rbp-18h] BYREF
  __int64 (__fastcall **v13)(_QWORD, _BYTE *); // [rsp+38h] [rbp-10h] BYREF
  __int64 v14; // [rsp+60h] [rbp+18h] BYREF

  if ( !a3 ) /*0x1243*/
    return 0x8000000000000003uLL; /*0x1245*/
  v9 = 0x8000000000000003uLL; /*0x1275*/
  if ( (*(__int64 (__fastcall **)(__int64, void *, __int64 *, unsigned __int64 *))(BootServices + 296))( /*0x1282*/
         a2,
         &unk_9620,
         &v14,
         &v12) < 0 )
    return v9; /*0x1282*/
  v10 = 0; /*0x1289*/
  if ( v12 ) /*0x1293*/
  {
    v11 = (_BYTE *)(v14 + 16); /*0x1295*/
    while ( *((_QWORD *)v11 - 1) != a3 || (*v11 & 8) == 0 ) /*0x12a2*/
    {
      ++v10; /*0x12a4*/
      v11 += 24; /*0x12a7*/
      if ( v10 >= v12 ) /*0x12ae*/
        goto LABEL_11; /*0x12ae*/
    }
    v9 = 0; /*0x12b2*/
  }
LABEL_11:
  AssertCpuDeadLoop_0(); /*0x12b7*/
  if ( v9 < 0 ) /*0x12bf*/
    return v9; /*0x12c1*/
  result = (*(__int64 (__fastcall **)(__int64, void *, __int64 (__fastcall ***)(_QWORD, _BYTE *), _QWORD, _QWORD, int))(BootServices + 280))( /*0x12ed*/
             a3,
             &unk_95A0,
             &v13,
             0,
             0,
             2);
  if ( result >= 0 ) /*0x12f6*/
  {
    result = Mtftp4ConfigNotification(v13); /*0x12fd*/
    if ( result >= 0 ) /*0x1305*/
      return Mtftp4ConfigStringLookup(src, a1[2], src_0, a5, a1 == (__int64 (__fastcall **)())&off_96A8); /*0x132b*/
  }
  return result; /*0x133f*/
}


// Function: Mtftp4Cleanup @ 0x1348 (0x1d2 bytes)

char *__fastcall Mtftp4Cleanup(__int64 a1, __int64 a2)
{
  _QWORD *v2; // rax
  __int64 v4; // rcx
  __int64 v5; // rdi
  __int64 v6; // rdx
  __int64 v7; // rcx
  __int64 v8; // rcx
  _QWORD *v9; // rdi
  _QWORD *v10; // r14
  char *result; // rax

  v2 = *(_QWORD **)(a1 + 152); /*0x1361*/
  if ( v2 ) /*0x1370*/
  {
    v4 = v2[1]; /*0x1372*/
    *v2 = a2; /*0x1376*/
    if ( v4 ) /*0x137c*/
      (*(void (**)(void))(BootServices + 104))(); /*0x1385*/
    *(_QWORD *)(a1 + 152) = 0; /*0x1388*/
  }
  if ( !*(_QWORD *)(a1 + 224) ) /*0x138f*/
    Assert_( /*0x13ab*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
      53,
      (__int64)"Instance->UnicastPort != ((void *) 0)");
  v5 = *(_QWORD *)(a1 + 224); /*0x13b0*/
  if ( ((*(_BYTE *)(v5 + 32) - 4) & 0xFD) != 0 ) /*0x13be*/
    Assert_( /*0x13d3*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      897,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  DxeGetInfo_2(v5); /*0x13db*/
  v6 = *(_QWORD *)(v5 + 736); /*0x13e4*/
  if ( *(_BYTE *)(v5 + 32) == 4 ) /*0x13eb*/
  {
    if ( v6 ) /*0x13f0*/
      (*(void (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(v5 + 744) + 48LL))(*(_QWORD *)(v5 + 744), v6 + 40); /*0x1400*/
  }
  else if ( v6 ) /*0x1408*/
  {
    (*(void (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(v5 + 744) + 40LL))(*(_QWORD *)(v5 + 744), v6 + 40); /*0x1418*/
  }
  (*(void (__fastcall **)(_QWORD, _QWORD))(*(_QWORD *)(v5 + 744) + 8LL))(*(_QWORD *)(v5 + 744), 0); /*0x1427*/
  v7 = *(_QWORD *)(a1 + 232); /*0x142a*/
  if ( v7 ) /*0x1434*/
  {
    DxeConfig_14(v7); /*0x1436*/
    *(_QWORD *)(a1 + 232) = 0; /*0x143b*/
  }
  v8 = *(_QWORD *)(a1 + 264); /*0x1442*/
  if ( v8 ) /*0x144c*/
  {
    (*(void (__fastcall **)(_QWORD, void *, __int64, _QWORD))(BootServices + 288))( /*0x146b*/
      *(_QWORD *)(v8 + 56),
      &unk_9620,
      ImageHandle_0,
      *(_QWORD *)(a1 + 112));
    DxeConfig_5(*(_QWORD *)(a1 + 264)); /*0x1478*/
    *(_QWORD *)(a1 + 264) = 0; /*0x147d*/
  }
  v9 = *(_QWORD **)(a1 + 192); /*0x148b*/
  v10 = (_QWORD *)*v9; /*0x148e*/
  while ( v9 != (_QWORD *)(a1 + 192) ) /*0x14ac*/
  {
    RemoveEntryList(v9); /*0x1496*/
    AssertCpuDeadLoop_0(); /*0x149e*/
    v9 = v10; /*0x14a3*/
    v10 = (_QWORD *)*v10; /*0x14a6*/
  }
  result = MemGetInfo((char *)(a1 + 160), 0x14u); /*0x14ba*/
  *(_WORD *)(a1 + 184) = 0; /*0x14c9*/
  *(_DWORD *)(a1 + 208) = 0; /*0x14d0*/
  *(_QWORD *)(a1 + 212) = 0; /*0x14d6*/
  *(_QWORD *)(a1 + 240) = 0; /*0x14dd*/
  *(_QWORD *)(a1 + 248) = 0; /*0x14e4*/
  *(_DWORD *)(a1 + 256) = 0; /*0x14eb*/
  *(_WORD *)(a1 + 260) = 0; /*0x14f1*/
  *(_DWORD *)(a1 + 180) = 0x2000000; /*0x14fd*/
  *(_BYTE *)(a1 + 262) = 1; /*0x1507*/
  return result; /*0x1513*/
}


// Function: Mtftp4PacketCallback @ 0x151c (0xe6 bytes)

unsigned __int64 __fastcall Mtftp4PacketCallback(__int64 a1, __int64 a2, unsigned __int16 count, char *src)
{
  char ***v5; // rbx
  __int16 n6; // ax
  unsigned __int64 v8; // rax

  v5 = *(char ****)(a2 + 72); /*0x1537*/
  n6 = __ROL2__(*(_WORD *)src, 8); /*0x153f*/
  if ( n6 == 5 ) /*0x1549*/
  {
    if ( *((_WORD *)src + 1) == 1 ) /*0x156e*/
      DebugPrint(0x80000000LL, (__int64)"TFTP error code 1 (File Not Found)\n"); /*0x1577*/
    else
      DebugPrint(0x80000000LL, (__int64)"TFTP error code %d\n", *((unsigned __int16 *)src + 1)); /*0x158a*/
    v8 = 0x8000000000000017uLL; /*0x158f*/
  }
  else
  {
    if ( n6 == 6 ) /*0x154e*/
    {
      v5[2] = 0; /*0x155c*/
      goto LABEL_10; /*0x1561*/
    }
    v8 = 0x8000000000000018uLL; /*0x1550*/
  }
  v5[2] = (char **)v8; /*0x1599*/
LABEL_10:
  if ( (*(__int64 (__fastcall **)(__int64, _QWORD, char **))(BootServices + 64))(4, count, *v5) >= 0 ) /*0x15b7*/
  {
    *(_DWORD *)v5[1] = count; /*0x15d6*/
    MemConfig_0(**v5, src, count); /*0x15de*/
  }
  else
  {
    v5[2] = (char **)0x8000000000000009LL; /*0x15c3*/
  }
  return 0x8000000000000015uLL; /*0x15fc*/
}


// Function: Mtftp4CheckAddress @ 0x1604 (0x123 bytes)

bool __fastcall Mtftp4CheckAddress(_BYTE *buf, char *src)
{
  int dst__1; // edx
  bool v5; // zf
  int dst__3; // r11d
  int v7; // ebx
  int dst_; // [rsp+48h] [rbp+10h] BYREF
  __int16 dst; // [rsp+50h] [rbp+18h] BYREF
  __int16 v11; // [rsp+52h] [rbp+1Ah]
  __int16 dst__2; // [rsp+58h] [rbp+20h] BYREF
  __int16 v13; // [rsp+5Ah] [rbp+22h]

  MemConfig_0((char *)&dst, src + 4, 4u); /*0x1623*/
  if ( (((unsigned __int16)__ROL2__(dst, 8) << 16) | (unsigned int)(unsigned __int16)__ROL2__(v11, 8)) - 1 > 0xFFFFFFFD ) /*0x1651*/
    return 0; /*0x1651*/
  MemConfig_0((char *)&dst_, src, 4u); /*0x1662*/
  dst__1 = ((unsigned __int16)__ROL2__(dst_, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(dst_), 8); /*0x1681*/
  v5 = buf[120] == 0; /*0x1683*/
  dst_ = dst__1; /*0x1687*/
  if ( !v5 || !dst__1 ) /*0x1693*/
    return 1; /*0x1693*/
  MemConfig_0((char *)&dst__2, buf + 125, 4u); /*0x16a5*/
  MemConfig_0((char *)&dst, buf + 121, 4u); /*0x16b6*/
  dst__3 = ((unsigned __int16)__ROL2__(dst__2, 8) << 16) | (unsigned __int16)__ROL2__(v13, 8); /*0x16da*/
  v7 = ((unsigned __int16)__ROL2__(dst, 8) << 16) | (unsigned __int16)__ROL2__(v11, 8); /*0x16f3*/
  if ( dst__3 ) /*0x16f8*/
  {
    if ( !NetIp4IsNetmaskValid(dst_, dst__3) ) /*0x1701*/
      return 0; /*0x1701*/
  }
  return (dst_ & dst__3) == (v7 & dst__3); /*0x171d*/
}


// Function: Mtftp4ResolveAddress @ 0x1728 (0xd5 bytes)

bool __fastcall Mtftp4ResolveAddress(__int64 buf, __int64 a2, __int64 a3)
{
  __int64 v6; // rdi
  __int64 v7; // rbx
  _BYTE v9[96]; // [rsp+30h] [rbp-68h] BYREF

  if ( !*(_BYTE *)(buf + 120) ) /*0x173f*/
    Assert_( /*0x1761*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
      247,
      (__int64)"Instance->Config.UseDefaultSetting");
  v6 = *(_QWORD *)(buf + 104); /*0x1766*/
  v7 = *(_QWORD *)(a2 + 744); /*0x177c*/
  if ( (*(__int64 (__fastcall **)(_QWORD, __int64, __int64))(BootServices + 88))(*(_QWORD *)(v6 + 56), 2, 50000000) >= 0 ) /*0x178d*/
  {
    while ( (*(__int64 (__fastcall **)(_QWORD))(BootServices + 120))(*(_QWORD *)(v6 + 56)) < 0 ) /*0x17a0*/
    {
      (*(void (__fastcall **)(__int64))(v7 + 56))(v7); /*0x17a5*/
      if ( (*(__int64 (__fastcall **)(__int64, _QWORD, _BYTE *, _QWORD, _QWORD))v7)(v7, 0, v9, 0, 0) >= 0 && v9[36] ) /*0x17c7*/
      {
        (*(void (__fastcall **)(__int64, _QWORD))(v7 + 8))(v7, 0); /*0x17ce*/
        return (*(__int64 (__fastcall **)(__int64, __int64))(v7 + 8))(v7, a3) == 0; /*0x17e0*/
      }
    }
  }
  return 0; /*0x17f8*/
}


// Function: Mtftp4SendUdpPacket @ 0x1800 (0x144 bytes)

__int64 __fastcall Mtftp4SendUdpPacket(__int64 a1, __int64 buf)
{
  char v2; // al
  int v5; // edx
  __int64 v6; // rdi
  _QWORD *v8; // rbx
  int v9; // [rsp+30h] [rbp-30h] BYREF
  __int16 n0x4000; // [rsp+34h] [rbp-2Ch]
  char v11; // [rsp+36h] [rbp-2Ah]
  __int64 v12; // [rsp+38h] [rbp-28h]
  char v13; // [rsp+40h] [rbp-20h]
  char dst[4]; // [rsp+41h] [rbp-1Fh] BYREF
  char dst_1[5]; // [rsp+45h] [rbp-1Bh] BYREF
  __int16 v16; // [rsp+4Ah] [rbp-16h]
  char dst_2[4]; // [rsp+4Ch] [rbp-14h] BYREF
  __int16 v18; // [rsp+50h] [rbp-10h]
  int src; // [rsp+80h] [rbp+20h] BYREF

  v2 = *(_BYTE *)(buf + 120); /*0x181b*/
  v9 = 0; /*0x1824*/
  n0x4000 = 0x4000; /*0x182b*/
  v11 = 0; /*0x1835*/
  v12 = 0; /*0x183d*/
  v13 = v2; /*0x1844*/
  MemConfig_0(dst, (char *)(buf + 121), 4u); /*0x184b*/
  MemConfig_0(dst_1, (char *)(buf + 125), 4u); /*0x185b*/
  v5 = *(_DWORD *)(buf + 208); /*0x1860*/
  v16 = 0; /*0x186b*/
  v18 = 0; /*0x188a*/
  src = ((unsigned __int16)__ROL2__(v5, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(v5), 8); /*0x188f*/
  MemConfig_0(dst_2, (char *)&src, 4u); /*0x1896*/
  v6 = (*(__int64 (__fastcall **)(_QWORD, int *))(*(_QWORD *)(a1 + 744) + 8LL))(*(_QWORD *)(a1 + 744), &v9); /*0x18ac*/
  if ( v6 == 0x8000000000000011uLL && Mtftp4ResolveAddress(buf, a1, (__int64)&v9) ) /*0x18c8*/
    return 0; /*0x18d1*/
  if ( !*(_BYTE *)(buf + 120) ) /*0x18d5*/
  {
    v8 = (_QWORD *)(buf + 132); /*0x18db*/
    if ( MemConfig(v8, 4) ) /*0x18e8*/
    {
      v6 = (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD *, _QWORD *, _QWORD *))(*(_QWORD *)(a1 + 744) + 24LL))( /*0x1910*/
             *(_QWORD *)(a1 + 744),
             0,
             &unk_9778,
             &unk_9778,
             v8);
      if ( v6 < 0 ) /*0x1916*/
        (*(void (__fastcall **)(_QWORD, _QWORD))(*(_QWORD *)(a1 + 744) + 8LL))(*(_QWORD *)(a1 + 744), 0); /*0x1924*/
    }
  }
  return v6; /*0x193b*/
}


// Function: Mtftp4Start @ 0x1944 (0x40b bytes)

unsigned __int64 __fastcall Mtftp4Start(__int64 buf, __int64 a2, __int16 n7)
{
  __int64 buf_1; // rbx
  __int64 v7; // r12
  signed __int64 v8; // rdi
  __int64 src; // r15
  unsigned int v11; // edx
  __int16 v12; // ax
  int *v13; // r13
  int v14; // edx
  unsigned __int16 v15; // ax
  char *v16; // rax
  __int64 (__fastcall *IpConfig_8)(); // rdx
  char *v18; // rax

  if ( !buf /*0x19c5*/
    || !a2
    || !*(_QWORD *)(a2 + 24)
    || *(_DWORD *)(a2 + 40) && !*(_QWORD *)(a2 + 48)
    || (n7 == 1 || n7 == 7) && !*(_QWORD *)(a2 + 64) && !*(_QWORD *)(a2 + 80)
    || n7 == 2 && !*(_QWORD *)(a2 + 64) && !*(_QWORD *)(a2 + 96) )
  {
    return 0x8000000000000002uLL; /*0x1d28*/
  }
  buf_1 = buf - 24; /*0x19cf*/
  if ( *(_DWORD *)(buf - 24) != 1886676596 ) /*0x19d9*/
  {
    Assert_( /*0x19ee*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
      394,
      (__int64)"CR has Bad Signature");
    buf_1 = buf; /*0x19f3*/
  }
  v7 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0x1a09*/
  v8 = -(__int64)(*(_QWORD *)(buf_1 + 88) != 1) & 0x8000000000000013uLL; /*0x1a1f*/
  if ( *(_WORD *)(buf_1 + 180) ) /*0x1a2c*/
    v8 = 0x800000000000000FuLL; /*0x1a34*/
  if ( v8 < 0 ) /*0x1a3b*/
  {
    (*(void (__fastcall **)(__int64))(BootServices + 32))(v7); /*0x1a47*/
    return v8; /*0x1a4d*/
  }
  *(_WORD *)(buf_1 + 180) = n7; /*0x1a52*/
  src = *(_QWORD *)(a2 + 16); /*0x1a59*/
  if ( src && !Mtftp4CheckAddress((_BYTE *)buf_1, *(char **)(a2 + 16)) ) /*0x1a68*/
  {
    v8 = 0x8000000000000002uLL; /*0x1a71*/
LABEL_23:
    Mtftp4Cleanup(buf_1, v8); /*0x1a7b*/
    (*(void (__fastcall **)(__int64))(BootServices + 32))(v7); /*0x1a90*/
    return v8; /*0x1a93*/
  }
  v11 = *(_DWORD *)(a2 + 40); /*0x1a95*/
  if ( v11 ) /*0x1a9a*/
  {
    v8 = Mtftp4ParseOptions(*(_QWORD *)(a2 + 48), v11, 1, (char *)(buf_1 + 160)); /*0x1aaf*/
    if ( v8 < 0 ) /*0x1ab5*/
      goto LABEL_23; /*0x1ab5*/
  }
  *(_QWORD *)(buf_1 + 152) = a2; /*0x1abc*/
  *(_WORD *)(buf_1 + 182) = 512; /*0x1aca*/
  MemConfig_0((char *)(buf_1 + 208), (char *)(buf_1 + 136), 4u); /*0x1ae1*/
  *(_DWORD *)(buf_1 + 208) = ((unsigned __int16)__ROL2__(*(_DWORD *)(buf_1 + 208), 8) << 16) /*0x1b0d*/
                           | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)(buf_1 + 208)), 8);
  v12 = *(_WORD *)(buf_1 + 140); /*0x1b0f*/
  *(_WORD *)(buf_1 + 214) = 0; /*0x1b16*/
  v13 = (int *)(buf_1 + 216); /*0x1b1e*/
  *(_WORD *)(buf_1 + 212) = v12; /*0x1b28*/
  MemConfig_0((char *)(buf_1 + 216), (char *)(buf_1 + 132), 4u); /*0x1b2f*/
  *(_DWORD *)(buf_1 + 216) = ((unsigned __int16)__ROL2__(*(_DWORD *)(buf_1 + 216), 8) << 16) /*0x1b50*/
                           | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)(buf_1 + 216)), 8);
  *(_DWORD *)(buf_1 + 248) = *(unsigned __int16 *)(buf_1 + 142); /*0x1b5b*/
  *(_DWORD *)(buf_1 + 252) = *(unsigned __int16 *)(buf_1 + 144); /*0x1b68*/
  *(_BYTE *)(buf_1 + 262) = 1; /*0x1b6e*/
  if ( src ) /*0x1b78*/
  {
    MemConfig_0((char *)(buf_1 + 208), (char *)(src + 4), 4u); /*0x1b8b*/
    MemConfig_0((char *)(buf_1 + 216), (char *)src, 4u); /*0x1b9c*/
    v14 = *v13; /*0x1bb6*/
    v15 = __ROL2__(HIWORD(*v13), 8); /*0x1bc4*/
    *(_DWORD *)(buf_1 + 208) = ((unsigned __int16)__ROL2__(*(_DWORD *)(buf_1 + 208), 8) << 16) /*0x1bc8*/
                             | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)(buf_1 + 208)), 8);
    *v13 = ((unsigned __int16)__ROL2__(v14, 8) << 16) | v15; /*0x1bd9*/
    *(_WORD *)(buf_1 + 212) = *(_WORD *)(src + 8); /*0x1be2*/
    *(_DWORD *)(buf_1 + 248) = *(unsigned __int16 *)(src + 10); /*0x1bee*/
    *(_DWORD *)(buf_1 + 252) = *(unsigned __int16 *)(src + 12); /*0x1bf9*/
  }
  if ( !*(_WORD *)(buf_1 + 212) ) /*0x1c02*/
    *(_WORD *)(buf_1 + 212) = 69; /*0x1c10*/
  if ( !*(_DWORD *)(buf_1 + 248) ) /*0x1c17*/
    *(_DWORD *)(buf_1 + 248) = 5; /*0x1c20*/
  if ( !*(_DWORD *)(buf_1 + 252) ) /*0x1c2a*/
    *(_DWORD *)(buf_1 + 252) = 3; /*0x1c33*/
  v8 = Mtftp4SendUdpPacket(*(_QWORD *)(buf_1 + 224), buf_1); /*0x1c4c*/
  if ( v8 < 0 ) /*0x1c52*/
    goto LABEL_23; /*0x1c52*/
  *(_QWORD *)a2 = 0x8000000000000006uLL; /*0x1c67*/
  if ( n7 == 2 ) /*0x1c6e*/
  {
    v16 = Mtftp4AllocateBlockRangeEntry(0, 0xFFFFu); /*0x1c72*/
    if ( v16 ) /*0x1c7a*/
    {
      InsertTailList((_QWORD *)(buf_1 + 192), v16); /*0x1c86*/
      v8 = Mtftp4BuildPacket(buf_1); /*0x1c93*/
      if ( v8 >= 0 ) /*0x1c99*/
      {
        IpConfig_8 = (__int64 (__fastcall *)())IpConfig_1; /*0x1c9b*/
LABEL_42:
        v8 = DxeConfig_10(*(_QWORD *)(buf_1 + 224), IpConfig_8, buf_1); /*0x1cd9*/
        goto LABEL_44; /*0x1ceb*/
      }
      goto LABEL_44; /*0x1c99*/
    }
LABEL_43:
    v8 = 0x8000000000000009uLL; /*0x1ced*/
    goto LABEL_44; /*0x1ced*/
  }
  v18 = Mtftp4AllocateBlockRangeEntry(1u, 0xFFFFu); /*0x1ca9*/
  if ( !v18 ) /*0x1cb1*/
    goto LABEL_43; /*0x1cb1*/
  InsertTailList((_QWORD *)(buf_1 + 192), v18); /*0x1cbd*/
  v8 = Mtftp4BuildPacket(buf_1); /*0x1cca*/
  if ( v8 >= 0 ) /*0x1cd0*/
  {
    IpConfig_8 = (__int64 (__fastcall *)())IpConfig_0; /*0x1cd2*/
    goto LABEL_42; /*0x1cd2*/
  }
LABEL_44:
  (*(void (__fastcall **)(__int64))(BootServices + 32))(v7); /*0x1cf7*/
  if ( v8 < 0 ) /*0x1d07*/
    goto LABEL_23; /*0x1d07*/
  if ( *(_QWORD *)(a2 + 8) ) /*0x1d0d*/
    return 0; /*0x1d13*/
  while ( *(_QWORD *)a2 == 0x8000000000000006uLL ) /*0x1d21*/
    (*(void (__fastcall **)(__int64))(buf + 56))(buf); /*0x1d1a*/
  return *(_QWORD *)a2; /*0x1d41*/
}


// Function: Mtftp4GetInfo @ 0x1d50 (0xad bytes)

unsigned __int64 __fastcall Mtftp4GetInfo(__int64 a1, __int64 dst)
{
  __int64 v3; // rdi
  __int64 v4; // rsi
  __int64 BootServices; // rax

  v3 = a1; /*0x1d62*/
  if ( !a1 || !dst ) /*0x1d6d*/
    return 0x8000000000000002uLL; /*0x1de3*/
  v4 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0x1d85*/
  if ( *(_DWORD *)(v3 - 24) == 1886676596 ) /*0x1d88*/
    v3 -= 24; /*0x1da4*/
  else
    Assert_( /*0x1d9d*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
      563,
      (__int64)"CR has Bad Signature");
  MemConfig_0((char *)dst, (char *)(v3 + 120), 0x1Au); /*0x1db5*/
  *(_QWORD *)(dst + 48) = 0; /*0x1dba*/
  *(_QWORD *)(dst + 32) = blksize_; // "blksize" /*0x1dc6*/
  BootServices = BootServices; /*0x1dcd*/
  *(_BYTE *)(dst + 26) = 4; /*0x1dd4*/
  *(_BYTE *)(dst + 40) = 0; /*0x1dd8*/
  (*(void (__fastcall **)(__int64))(BootServices + 32))(v4); /*0x1ddc*/
  return 0; /*0x1df7*/
}


// Function: Mtftp4Input @ 0x1e00 (0x246 bytes)

unsigned __int64 __fastcall Mtftp4Input(__int64 a1, char *src)
{
  __int64 v3; // rdi
  __int64 v4; // rbx
  __int64 v5; // rcx
  int dst_2; // r14d
  int dst__2; // r11d
  int dst__3; // esi
  __int64 i; // rax
  __int64 v10; // rax
  __int64 v11; // rsi
  char dst_1[4]; // [rsp+20h] [rbp-10h] BYREF
  int dst; // [rsp+60h] [rbp+30h] BYREF
  int dst_; // [rsp+70h] [rbp+40h] BYREF
  int dst__1; // [rsp+78h] [rbp+48h] BYREF

  v3 = a1; /*0x1e19*/
  if ( a1 ) /*0x1e1f*/
  {
    if ( *(_DWORD *)(a1 - 24) == 1886676596 ) /*0x1e2c*/
      v3 = a1 - 24; /*0x1e48*/
    else
      Assert_( /*0x1e41*/
        (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
        642,
        (__int64)"CR has Bad Signature");
    if ( !src ) /*0x1e4f*/
    {
      v4 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0x1e6b*/
      Mtftp4Cleanup(v3, 0x8000000000000015uLL); /*0x1e6e*/
      MemGetInfo((char *)(v3 + 120), 0x1Au); /*0x1e7c*/
      v5 = v4; /*0x1e81*/
      *(_QWORD *)(v3 + 88) = 0; /*0x1e84*/
LABEL_23:
      (*(void (__fastcall **)(__int64))(BootServices + 32))(v5); /*0x201d*/
      return 0; /*0x2029*/
    }
    MemConfig_0((char *)&dst, src + 1, 4u); /*0x1e9d*/
    MemConfig_0((char *)&dst_, src + 5, 4u); /*0x1ead*/
    MemConfig_0((char *)&dst__1, src + 12, 4u); /*0x1ebd*/
    MemConfig_0(dst_1, src + 16, 4u); /*0x1ecd*/
    dst_2 = ((unsigned __int16)__ROL2__(dst, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(dst), 8); /*0x1eef*/
    dst__2 = ((unsigned __int16)__ROL2__(dst_, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(dst_), 8); /*0x1f0c*/
    dst = dst_2; /*0x1f0f*/
    dst_ = dst__2; /*0x1f15*/
    dst__3 = ((unsigned __int16)__ROL2__(dst__1, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(dst__1), 8); /*0x1f30*/
    dst__1 = dst__3; /*0x1f4a*/
    *(_DWORD *)dst_1 = ((unsigned __int16)__ROL2__(*(_WORD *)dst_1, 8) << 16) /*0x1f4d*/
                     | (unsigned __int16)__ROL2__(*(_WORD *)&dst_1[2], 8);
    if ( (unsigned int)(*(_DWORD *)dst_1 - 1) <= 0xFFFFFFFD ) /*0x1f56*/
    {
      if ( *src ) /*0x1f5c*/
        goto LABEL_27; /*0x1f5c*/
      for ( i = 0; i <= 32; ++i ) /*0x1f61*/
      {
        if ( dst__2 == dword_8E60[i] ) /*0x1f6f*/
          break; /*0x1f6f*/
      }
      if ( i != 33 && (!dst__2 || NetIp4IsNetmaskValid(dst_2, dst__2)) ) /*0x1f8f*/
      {
LABEL_27:
        if ( !dst__3 || (dst__2 & dst__3) == (dst_2 & dst__2) && (!dst__2 || NetIp4IsNetmaskValid(dst__3, dst__2)) ) /*0x1fbb*/
        {
          v10 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(8); /*0x1fd0*/
          v11 = v10; /*0x1fd8*/
          if ( *(_QWORD *)(v3 + 88) == 1 && *(_WORD *)(v3 + 180) ) /*0x1fdd*/
          {
            (*(void (__fastcall **)(__int64))(BootServices + 32))(v10); /*0x1ff1*/
            return 0x800000000000000FuLL; /*0x1ffe*/
          }
          MemConfig_0((char *)(v3 + 120), src, 0x1Au); /*0x200d*/
          v5 = v11; /*0x2012*/
          *(_QWORD *)(v3 + 88) = 1; /*0x2015*/
          goto LABEL_23; /*0x2015*/
        }
      }
    }
  }
  return 0x8000000000000002uLL; /*0x203a*/
}


// Function: Mtftp4ParseOptionOack @ 0x2048 (0x5e bytes)

signed __int64 __fastcall Mtftp4ParseOptionOack(__int64 a1, __int64 n2, _WORD *dst, _DWORD *a4, __int64 *a5)
{
  signed __int64 result; // rax

  if ( !a1 || (unsigned int)n2 < 2 || !dst || !a4 ) /*0x2066*/
    return 0x8000000000000002uLL; /*0x2096*/
  result = Mtftp4ParseOack(dst, n2, a4, a5); /*0x2073*/
  if ( result >= 0 ) /*0x207b*/
    return -(__int64)(*a4 == 0) & 0x800000000000000EuLL; /*0x2091*/
  return result; /*0x20a0*/
}


// Function: Mtftp4ReadFile @ 0x20cc (0xf1 bytes)

unsigned __int64 __fastcall Mtftp4ReadFile(
        __int64 buf,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        unsigned __int8 a5,
        __int64 a6,
        _DWORD *a7,
        _QWORD *a8)
{
  unsigned __int64 result; // rax
  _QWORD v9[2]; // [rsp+20h] [rbp-59h] BYREF
  __int64 v10; // [rsp+30h] [rbp-49h]
  __int64 v11[5]; // [rsp+40h] [rbp-39h] BYREF
  int v12; // [rsp+68h] [rbp-11h]
  __int64 v13; // [rsp+70h] [rbp-9h]
  __int64 v14; // [rsp+78h] [rbp-1h]
  __int64 v15; // [rsp+80h] [rbp+7h]
  _QWORD *v16; // [rsp+88h] [rbp+Fh]
  unsigned __int64 (__fastcall *Mtftp4PacketCallback_1)(__int64, __int64, unsigned __int16, char *); // [rsp+90h] [rbp+17h]
  __int64 v18; // [rsp+98h] [rbp+1Fh]
  __int64 v19; // [rsp+A0h] [rbp+27h]

  if ( !buf || !a3 || !a7 || a5 && !a6 ) /*0x2111*/
    return 0x8000000000000002uLL; /*0x21a2*/
  if ( a8 ) /*0x211e*/
    *a8 = 0; /*0x2120*/
  *a7 = 0; /*0x2124*/
  v10 = 0; /*0x2128*/
  v11[0] = 0; /*0x212d*/
  v11[1] = 0; /*0x2132*/
  v14 = 0; /*0x2137*/
  v15 = 0; /*0x213c*/
  v18 = 0; /*0x2141*/
  v19 = 0; /*0x2146*/
  v9[0] = a8; /*0x214b*/
  v12 = a5; /*0x2155*/
  v16 = v9; /*0x215c*/
  v11[3] = a3; /*0x2167*/
  v13 = a6; /*0x2171*/
  Mtftp4PacketCallback_1 = Mtftp4PacketCallback; /*0x2179*/
  v9[1] = a7; /*0x217d*/
  v11[2] = a2; /*0x2181*/
  v11[4] = a4; /*0x2185*/
  result = Mtftp4Start(buf, (__int64)v11, 1); /*0x2189*/
  if ( result == 0x8000000000000015uLL ) /*0x219b*/
    return v10; /*0x219b*/
  return result; /*0x21b4*/
}


// Function: IpConfig_5 @ 0x21c0 (0x8d bytes)

__int64 __fastcall IpConfig_5(__int64 a1)
{
  __int64 v1; // rbx

  v1 = a1; /*0x21c6*/
  if ( !a1 ) /*0x21cc*/
    return 0x8000000000000002uLL; /*0x21ce*/
  if ( *(_DWORD *)(a1 - 24) == 1886676596 ) /*0x21e5*/
    v1 = a1 - 24; /*0x2201*/
  else
    Assert_( /*0x21fa*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Impl.c",
      1086,
      (__int64)"CR has Bad Signature");
  if ( !*(_QWORD *)(v1 + 88) ) /*0x2205*/
    return 0x8000000000000013uLL; /*0x220c*/
  if ( *(_QWORD *)(v1 + 88) == 2 ) /*0x2221*/
    return 0x8000000000000007uLL; /*0x2223*/
  return (*(__int64 (__fastcall **)(_QWORD))(*(_QWORD *)(*(_QWORD *)(v1 + 224) + 744LL) + 56LL))(*(_QWORD *)(*(_QWORD *)(v1 + 224) + 744LL)); /*0x21d8*/
}


// Function: Mtftp4AllocateBlockRangeEntry @ 0x2250 (0x54 bytes)

char *__fastcall Mtftp4AllocateBlockRangeEntry(unsigned __int16 a1, unsigned __int16 n0xFFFF)
{
  char *result; // rax
  char *v5; // rbx

  result = GetInfo_0(0x30u); /*0x226a*/
  v5 = result; /*0x226f*/
  if ( result ) /*0x2275*/
  {
    InitializeListHead(result); /*0x227a*/
    *((_QWORD *)v5 + 2) = a1; /*0x2282*/
    *((_QWORD *)v5 + 3) = n0xFFFF; /*0x2289*/
    *((_QWORD *)v5 + 5) = n0xFFFF; /*0x228d*/
    return v5; /*0x2291*/
  }
  return result; /*0x229e*/
}


// Function: Assert_1 @ 0x22a4 (0x63 bytes)

bool __fastcall Assert_1(_QWORD *a1, unsigned __int16 n0xFFFF)
{
  bool result; // al
  __int64 n0xFFFF_1; // rdi
  __int64 v6; // rbx

  result = IsListEmpty(a1); /*0x22b9*/
  if ( !result ) /*0x22c0*/
  {
    n0xFFFF_1 = n0xFFFF; /*0x22c2*/
    while ( 1 ) /*0x22c5*/
    {
      v6 = a1[1]; /*0x22c5*/
      if ( *(_QWORD *)(v6 + 16) <= n0xFFFF_1 ) /*0x22cd*/
        break; /*0x22cd*/
      RemoveEntryList((_QWORD *)a1[1]); /*0x22d2*/
      AssertCpuDeadLoop_0(); /*0x22da*/
      result = IsListEmpty(a1); /*0x22e2*/
      if ( result ) /*0x22e9*/
        return result; /*0x22e9*/
    }
    if ( *(_QWORD *)(v6 + 24) > n0xFFFF_1 ) /*0x22f1*/
      *(_QWORD *)(v6 + 24) = n0xFFFF_1; /*0x22f3*/
  }
  return result; /*0x2301*/
}


// Function: Mtftp4BlockRangeInsert @ 0x2308 (0x112 bytes)

unsigned __int64 __fastcall Mtftp4BlockRangeInsert(char ***a1, unsigned __int16 n0xFFFF, char a3, _QWORD *a4)
{
  char **v4; // rbx
  __int64 n0xFFFF_1; // r10
  __int64 n0xFFFF_2; // rax
  __int64 v9; // rdx
  char *n0xFFFF_3; // rax
  char *v11; // rax

  v4 = *a1; /*0x2317*/
  if ( *a1 == (char **)a1 ) /*0x2323*/
    return 0x800000000000000EuLL; /*0x2323*/
  n0xFFFF_1 = n0xFFFF; /*0x2325*/
  while ( (__int64)v4[3] < n0xFFFF ) /*0x232d*/
  {
    v4 = (char **)*v4; /*0x232f*/
    if ( v4 == (char **)a1 ) /*0x2335*/
      return 0x800000000000000EuLL; /*0x2335*/
  }
  n0xFFFF_2 = (__int64)v4[2]; /*0x2351*/
  if ( n0xFFFF_2 > n0xFFFF ) /*0x2358*/
    return 0x800000000000000EuLL; /*0x2337*/
  if ( n0xFFFF_2 == n0xFFFF ) /*0x235a*/
  {
    v9 = (__int64)v4[4]; /*0x235c*/
    v4[2] = (char *)(n0xFFFF_2 + 1); /*0x2364*/
    *a4 = n0xFFFF_1; /*0x2368*/
    if ( v9 > 0 ) /*0x236e*/
      *a4 = &v4[5][n0xFFFF_1 + 1 + (v9 - 1) * (unsigned int)(*((_DWORD *)v4 + 10) + 1)]; /*0x2387*/
    if ( n0xFFFF_2 + 1 > (__int64)v4[5] ) /*0x238e*/
    {
      v4[2] = 0; /*0x2390*/
      v4[4] = (char *)(v9 + 1); /*0x2399*/
    }
    if ( (__int64)v4[2] > (__int64)v4[3] || a3 ) /*0x23aa*/
    {
      RemoveEntryList(v4); /*0x23af*/
      AssertCpuDeadLoop_0(); /*0x23b7*/
    }
    return 0; /*0x23b7*/
  }
  n0xFFFF_3 = v4[3]; /*0x23c0*/
  if ( n0xFFFF_3 == (char *)n0xFFFF ) /*0x23c7*/
  {
    v4[3] = n0xFFFF_3 - 1; /*0x23cc*/
    return 0; /*0x23be*/
  }
  v11 = Mtftp4AllocateBlockRangeEntry(n0xFFFF + 1, (unsigned __int16)n0xFFFF_3); /*0x23dd*/
  if ( v11 ) /*0x23e8*/
  {
    v4[3] = (char *)(n0xFFFF - 1); /*0x2400*/
    *((_QWORD *)v11 + 1) = v4; /*0x2404*/
    *(_QWORD *)v11 = *v4; /*0x240b*/
    *((_QWORD *)*v4 + 1) = v11; /*0x2411*/
    *v4 = v11; /*0x2415*/
    return 0; /*0x2418*/
  }
  return 0x8000000000000009uLL; /*0x234b*/
}


// Function: Mtftp4BuildPacket @ 0x241c (0x27f bytes)

__int64 __fastcall Mtftp4BuildPacket(__int64 buf)
{
  __int64 v1; // rbp
  char *octet; // r12
  char **p_octet; // r15
  unsigned __int64 v4; // rax
  unsigned __int64 v5; // r14
  unsigned int n4; // edi
  unsigned __int64 v7; // r13
  char **p_octet_1; // rsi
  int v9; // ebx
  int v10; // eax
  char *v11; // rax
  __int64 v12; // rsi
  _WORD *v14; // rbx
  unsigned int n0xF4240; // edi
  unsigned __int64 octet_1; // rbx
  __int64 v17; // rax
  unsigned __int64 v18; // rbx
  unsigned int n0xF4240_1; // edi
  __int64 v20; // rax
  unsigned __int64 octet_2; // r14
  unsigned int n0xF4240_2; // edi
  unsigned __int64 v23; // rbx
  unsigned __int64 v24; // r13
  unsigned __int64 v25; // r12
  __int64 v26; // rax
  unsigned __int64 v27; // r14
  unsigned int n0xF4240_3; // edi
  __int64 v29; // rax
  unsigned __int64 v31; // [rsp+68h] [rbp+10h]
  char *v32; // [rsp+70h] [rbp+18h]

  v1 = *(_QWORD *)(buf + 152); /*0x2435*/
  octet = "octet"; /*0x243c*/
  if ( *(_QWORD *)(v1 + 32) ) /*0x2443*/
    octet = *(char **)(v1 + 32); /*0x244c*/
  p_octet = *(char ***)(v1 + 48); /*0x2451*/
  v31 = AsciiStrLen(*(_BYTE **)(v1 + 24)); /*0x245d*/
  v4 = AsciiStrLen(octet); /*0x2465*/
  v5 = 0; /*0x246d*/
  n4 = v4 + v31 + 4; /*0x2470*/
  v7 = v4; /*0x2472*/
  if ( *(_DWORD *)(v1 + 40) ) /*0x2475*/
  {
    p_octet_1 = p_octet; /*0x247b*/
    do /*0x24a6*/
    {
      v9 = AsciiStrLen(*p_octet_1); /*0x248a*/
      v10 = AsciiStrLen(p_octet_1[1]); /*0x248d*/
      p_octet_1 += 2; /*0x2495*/
      ++v5; /*0x249b*/
      n4 += v9 + v10 + 2; /*0x249e*/
    }
    while ( v5 < *(unsigned int *)(v1 + 40) ); /*0x24a6*/
  }
  v11 = DxeConfig_12(n4); /*0x24aa*/
  v32 = v11; /*0x24af*/
  v12 = (__int64)v11; /*0x24b4*/
  if ( !v11 ) /*0x24ba*/
    return 0x8000000000000009uLL; /*0x24bc*/
  v14 = (_WORD *)DxeConfig_4((__int64)v11, n4); /*0x24dc*/
  if ( !v14 ) /*0x24e2*/
    Assert_( /*0x24f3*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      320,
      (__int64)"Packet != ((void *) 0)");
  n0xF4240 = n4 - 2; /*0x24fd*/
  *v14 = __ROL2__(*(_WORD *)(buf + 180), 8); /*0x250d*/
  octet_1 = (unsigned __int64)(v14 + 1); /*0x2510*/
  v17 = AsciiStrCpyS(octet_1, n0xF4240, *(char **)(v1 + 24)); /*0x251b*/
  if ( v17 < 0 ) /*0x2528*/
  {
    DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v17); /*0x2534*/
    Assert_( /*0x2548*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      327,
      (__int64)"!EFI_ERROR (Status)");
  }
  v18 = v31 + octet_1; /*0x2557*/
  n0xF4240_1 = -1 - v31 + n0xF4240; /*0x255a*/
  v20 = AsciiStrCpyS(v18 + 1, n0xF4240_1, octet); /*0x2565*/
  if ( v20 < 0 ) /*0x256d*/
  {
    DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v20); /*0x257e*/
    Assert_( /*0x2592*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      331,
      (__int64)"!EFI_ERROR (Status)");
  }
  octet_2 = v18 + v7 + 2; /*0x25a1*/
  n0xF4240_2 = -1 - v7 + n0xF4240_1; /*0x25a4*/
  v23 = 0; /*0x25a6*/
  if ( *(_DWORD *)(v1 + 40) ) /*0x25a8*/
  {
    do /*0x266e*/
    {
      v24 = AsciiStrLen(*p_octet); /*0x25c2*/
      v25 = AsciiStrLen(p_octet[1]); /*0x25d2*/
      v26 = AsciiStrCpyS(octet_2, n0xF4240_2, *p_octet); /*0x25d5*/
      if ( v26 < 0 ) /*0x25dd*/
      {
        DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v26); /*0x25ec*/
        Assert_( /*0x2604*/
          (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
          340,
          (__int64)"!EFI_ERROR (Status)");
      }
      v27 = v24 + octet_2; /*0x2613*/
      n0xF4240_3 = -1 - v24 + n0xF4240_2; /*0x2616*/
      v29 = AsciiStrCpyS(v27 + 1, n0xF4240_3, p_octet[1]); /*0x261e*/
      if ( v29 < 0 ) /*0x2626*/
      {
        DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v29); /*0x2635*/
        Assert_( /*0x264d*/
          (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
          345,
          (__int64)"!EFI_ERROR (Status)");
      }
      octet_2 = v25 + v27 + 2; /*0x265c*/
      n0xF4240_2 = -1 - v25 + n0xF4240_3; /*0x265f*/
      ++v23; /*0x2661*/
      p_octet += 2; /*0x2667*/
    }
    while ( v23 < *(unsigned int *)(v1 + 40) ); /*0x266e*/
    v12 = (__int64)v32; /*0x2674*/
  }
  return Mtftp4TransmitPacket(buf, v12); /*0x268b*/
}


// Function: Mtftp4SendError @ 0x269c (0xb3 bytes)

__int64 __fastcall Mtftp4SendError(__int64 buf, __int16 a2, char *octet)
{
  unsigned int n4; // ebx
  char *v7; // rax
  __int64 v8; // rsi
  _WORD *v10; // rdi

  n4 = AsciiStrLen(octet) + 5; /*0x26c5*/
  v7 = DxeConfig_12(n4); /*0x26ca*/
  v8 = (__int64)v7; /*0x26cf*/
  if ( !v7 ) /*0x26d5*/
    return 0x8000000000000009uLL; /*0x26d7*/
  v10 = (_WORD *)DxeConfig_4((__int64)v7, n4); /*0x26ed*/
  if ( !v10 ) /*0x26f3*/
    Assert_( /*0x2708*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      385,
      (__int64)"TftpError != ((void *) 0)");
  *v10 = 1280; /*0x271f*/
  v10[1] = __ROL2__(a2, 8); /*0x2722*/
  AsciiStrCpyS((unsigned __int64)(v10 + 2), n4, octet); /*0x2726*/
  return Mtftp4TransmitPacket(buf, v8); /*0x2745*/
}


// Function: Mtftp4TransmitPacket @ 0x2758 (0xf9 bytes)

__int64 __fastcall Mtftp4TransmitPacket(__int64 buf, __int64 a2)
{
  __int64 v4; // rcx
  bool v5; // zf
  int v6; // eax
  _WORD *v7; // rsi
  __int16 n7; // cx
  __int16 v9; // ax
  __int64 v10; // rcx
  __int64 result; // rax
  char bufa[20]; // [rsp+30h] [rbp-38h] BYREF
  int v13; // [rsp+44h] [rbp-24h]
  __int16 v14; // [rsp+54h] [rbp-14h]

  v4 = *(_QWORD *)(buf + 232); /*0x276d*/
  if ( v4 ) /*0x2777*/
    DxeConfig_14(v4); /*0x2779*/
  *(_DWORD *)(buf + 244) = 0; /*0x277e*/
  v5 = *(_BYTE *)(buf + 262) == 0; /*0x2785*/
  v6 = *(_DWORD *)(buf + 252); /*0x278c*/
  *(_QWORD *)(buf + 232) = a2; /*0x2792*/
  if ( v5 ) /*0x2799*/
    v6 *= 2; /*0x279b*/
  *(_DWORD *)(buf + 240) = v6; /*0x27a2*/
  MemGetInfo(bufa, 0x28u); /*0x27ad*/
  v13 = *(_DWORD *)(buf + 208); /*0x27bd*/
  v7 = (_WORD *)DxeConfig_13((_DWORD *)a2, 0, 0); /*0x27c9*/
  if ( !v7 ) /*0x27cf*/
    Assert_( /*0x27e4*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      484,
      (__int64)"Buffer != ((void *) 0)");
  n7 = __ROL2__(*v7, 8); /*0x27f1*/
  if ( (unsigned __int16)(n7 - 1) <= 1u || n7 == 7 ) /*0x2804*/
    v9 = *(_WORD *)(buf + 212); /*0x280f*/
  else
    v9 = *(_WORD *)(buf + 214); /*0x2806*/
  ++*(_QWORD *)(a2 + 8); /*0x2816*/
  v10 = *(_QWORD *)(buf + 224); /*0x281f*/
  v14 = v9; /*0x2829*/
  result = DxeConfig_9(v10, a2, bufa); /*0x2833*/
  if ( result < 0 ) /*0x283b*/
    --*(_QWORD *)(a2 + 8); /*0x283d*/
  return result; /*0x284b*/
}


// Function: Mtftp4ResendPacket @ 0x2854 (0xee bytes)

__int64 __fastcall Mtftp4ResendPacket(__int64 buf)
{
  _DWORD *v2; // rcx
  _WORD *v3; // rdi
  __int16 n7; // cx
  __int16 v5; // ax
  __int64 result; // rax
  char bufa[20]; // [rsp+30h] [rbp-38h] BYREF
  int v8; // [rsp+44h] [rbp-24h]
  __int16 v9; // [rsp+54h] [rbp-14h]

  if ( !*(_QWORD *)(buf + 232) ) /*0x285e*/
    Assert_( /*0x287e*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      533,
      (__int64)"Instance->LastPacket != ((void *) 0)");
  MemGetInfo(bufa, 0x28u); /*0x288d*/
  v2 = *(_DWORD **)(buf + 232); /*0x289b*/
  v8 = *(_DWORD *)(buf + 208); /*0x28a4*/
  v3 = (_WORD *)DxeConfig_13(v2, 0, 0); /*0x28ad*/
  if ( !v3 ) /*0x28b3*/
    Assert_( /*0x28c8*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Support.c",
      542,
      (__int64)"Buffer != ((void *) 0)");
  n7 = __ROL2__(*v3, 8); /*0x28d5*/
  if ( (unsigned __int16)(n7 - 1) <= 1u || n7 == 7 ) /*0x28e8*/
    v5 = *(_WORD *)(buf + 212); /*0x28f3*/
  else
    v5 = *(_WORD *)(buf + 214); /*0x28ea*/
  v9 = v5; /*0x28fa*/
  ++*(_QWORD *)(*(_QWORD *)(buf + 232) + 8LL); /*0x2910*/
  result = DxeConfig_9(*(_QWORD *)(buf + 224), *(_QWORD *)(buf + 232), bufa); /*0x2922*/
  if ( result < 0 ) /*0x292a*/
    --*(_QWORD *)(*(_QWORD *)(buf + 232) + 8LL); /*0x2933*/
  return result; /*0x293c*/
}


// Function: Mtftp4CheckTimeout @ 0x2944 (0xe0 bytes)

_QWORD *__fastcall Mtftp4CheckTimeout(__int64 a1, __int64 a2)
{
  _QWORD *v2; // rsi
  _QWORD *result; // rax
  _QWORD *v4; // rdi
  _QWORD *v5; // rbx
  int v6; // eax
  int v7; // eax
  __int64 (__fastcall *v8)(_QWORD *); // rax
  __int64 v9; // rdx
  int v10; // eax

  v2 = (_QWORD *)(a2 + 32); /*0x2953*/
  result = *(_QWORD **)(a2 + 32); /*0x2957*/
  v4 = (_QWORD *)*result; /*0x295a*/
  while ( result != v2 ) /*0x2a0e*/
  {
    v5 = result - 1; /*0x2962*/
    v6 = *((_DWORD *)result + 58); /*0x2966*/
    if ( v6 ) /*0x296e*/
    {
      v7 = v6 - 1; /*0x2974*/
      *((_DWORD *)v5 + 60) = v7; /*0x2977*/
      if ( !v7 ) /*0x297d*/
      {
        v8 = *(__int64 (__fastcall **)(_QWORD *))(v5[19] + 88LL); /*0x298a*/
        if ( v8 && v8(v5 + 3) < 0 ) /*0x299c*/
        {
          Mtftp4SendError((__int64)v5, 8, "User aborted the transfer in time out"); /*0x29ad*/
          v9 = 0x8000000000000015uLL; /*0x29b2*/
LABEL_12:
          Mtftp4Cleanup((__int64)v5, v9); /*0x29fd*/
          goto LABEL_13; /*0x2a00*/
        }
        if ( ++*((_DWORD *)v5 + 61) >= *((_DWORD *)v5 + 62) ) /*0x29d0*/
        {
          v9 = 0x8000000000000012uLL; /*0x29f3*/
          goto LABEL_12; /*0x29f3*/
        }
        Mtftp4ResendPacket((__int64)v5); /*0x29d5*/
        v10 = *((_DWORD *)v5 + 63); /*0x29e1*/
        if ( !*((_BYTE *)v5 + 262) ) /*0x29da*/
          v10 *= 2; /*0x29e9*/
        *((_DWORD *)v5 + 60) = v10; /*0x29eb*/
      }
    }
LABEL_13:
    result = v4; /*0x2a05*/
    v4 = (_QWORD *)*v4; /*0x2a08*/
  }
  return result; /*0x2a1e*/
}


// Function: IpConfig_7 @ 0x2a24 (0x74 bytes)

bool __fastcall IpConfig_7(char *a1, char *blksize)
{
  char *blksize_1; // rdi
  char *v3; // rbx
  char v4; // dl
  char v5; // cl

  blksize_1 = blksize; /*0x2a2e*/
  v3 = a1; /*0x2a31*/
  if ( !a1 || !blksize ) /*0x2a3c*/
    Assert_( /*0x2a51*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Option.c",
      44,
      (__int64)"(Str1 != ((void *) 0)) && (Str2 != ((void *) 0))");
  while ( 1 ) /*0x2a7c*/
  {
    v5 = *v3; /*0x2a7c*/
    if ( !*v3 ) /*0x2a7c*/
      return *v3 == *blksize_1; /*0x2a7c*/
    v4 = *blksize_1; /*0x2a58*/
    if ( !*blksize_1 ) /*0x2a58*/
      return *v3 == *blksize_1; /*0x2a86*/
    if ( (unsigned __int8)(v5 - 65) <= 0x19u ) /*0x2a63*/
      v5 += 32; /*0x2a65*/
    if ( (unsigned __int8)(v4 - 65) <= 0x19u ) /*0x2a6d*/
      v4 += 32; /*0x2a6f*/
    if ( v5 != v4 ) /*0x2a74*/
      break; /*0x2a74*/
    ++v3; /*0x2a76*/
    ++blksize_1; /*0x2a79*/
  }
  return 0; /*0x2a8e*/
}


// Function: IpGetInfo_1 @ 0x2a98 (0x52 bytes)

__int64 __fastcall IpGetInfo_1(unsigned __int8 *a1)
{
  unsigned int v1; // ebx
  unsigned __int8 *v2; // rdi
  unsigned __int8 n0x39; // al

  v1 = 0; /*0x2aa2*/
  v2 = a1; /*0x2aa4*/
  if ( !a1 ) /*0x2aaa*/
    Assert_( /*0x2abd*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Option.c",
      85,
      (__int64)"Str != ((void *) 0)");
  while ( 1 ) /*0x2ad7*/
  {
    n0x39 = *v2; /*0x2ad7*/
    if ( *v2 < 0x30u || n0x39 > 0x39u ) /*0x2ac6*/
      break; /*0x2ac6*/
    ++v2; /*0x2ad1*/
    v1 = n0x39 + 2 * (5 * v1 - 24); /*0x2ad4*/
  }
  return v1; /*0x2ae4*/
}


// Function: Mtftp4ParseOptionPairs @ 0x2aec (0xa3 bytes)

unsigned __int64 __fastcall Mtftp4ParseOptionPairs(_WORD *dst, unsigned int n2, _DWORD *a3, __int64 a4)
{
  char *v4; // r10
  unsigned __int8 v5; // r11
  char *v6; // rdx
  char *v7; // rdi
  _BYTE *v8; // r10
  _BYTE *v9; // rbx
  __int64 v10; // rcx

  v4 = (char *)(dst + 1); /*0x2af8*/
  v5 = 0; /*0x2b00*/
  v6 = (char *)dst + n2 - 1; /*0x2b03*/
  while ( v4 < v6 ) /*0x2b54*/
  {
    v7 = v4; /*0x2b08*/
    while ( *v4 ) /*0x2b14*/
      ++v4; /*0x2b0d*/
    if ( v4 == v6 ) /*0x2b19*/
      return 0x8000000000000002uLL; /*0x2b75*/
    v8 = v4 + 1; /*0x2b1b*/
    v9 = v8; /*0x2b1e*/
    while ( *v8 ) /*0x2b2a*/
      ++v8; /*0x2b23*/
    ++v5; /*0x2b2c*/
    if ( a4 && (unsigned int)v5 <= *a3 ) /*0x2b3b*/
    {
      v10 = 2LL * (v5 - 1); /*0x2b42*/
      *(_QWORD *)(a4 + 8 * v10) = v7; /*0x2b45*/
      *(_QWORD *)(a4 + 8 * v10 + 8) = v9; /*0x2b49*/
    }
    v4 = v8 + 1; /*0x2b4e*/
  }
  if ( *a3 >= (unsigned int)v5 && a4 ) /*0x2b62*/
  {
    *a3 = v5; /*0x2b64*/
    return 0; /*0x2b67*/
  }
  else
  {
    *a3 = v5; /*0x2b77*/
    return 0x8000000000000005uLL; /*0x2b7a*/
  }
}


// Function: Mtftp4ParseOack @ 0x2b90 (0xb8 bytes)

unsigned __int64 __fastcall Mtftp4ParseOack(_WORD *dst, __int64 n2, _DWORD *a3, __int64 *a4)
{
  unsigned int n2_1; // edi
  unsigned __int64 result; // rax
  unsigned int *v9; // r8
  __int64 v10; // rax

  *a3 = 0; /*0x2ba5*/
  n2_1 = n2; /*0x2bac*/
  if ( a4 ) /*0x2bb7*/
    *a4 = 0; /*0x2bb9*/
  if ( __ROL2__(*dst, 8) != 6 ) /*0x2bc8*/
    return 0x8000000000000002uLL; /*0x2bc8*/
  if ( (_DWORD)n2 == 2 ) /*0x2bd9*/
    return 0; /*0x2c30*/
  if ( *((_BYTE *)dst + (unsigned int)n2 - 1) ) /*0x2bdb*/
    return 0x8000000000000002uLL; /*0x2bd4*/
  result = Mtftp4ParseOptionPairs(dst, n2, a3, 0); /*0x2be7*/
  if ( result == 0x8000000000000005uLL ) /*0x2bf9*/
  {
    if ( a4 ) /*0x2bfe*/
    {
      v10 = AllocatePool(0x8000000000000005uLL, 16LL * *v9); /*0x2c07*/
      *a4 = v10; /*0x2c0c*/
      if ( !v10 ) /*0x2c12*/
        return 0x8000000000000009uLL; /*0x2c1e*/
      Mtftp4ParseOptionPairs(dst, n2_1, a3, v10); /*0x2c2b*/
    }
    return 0; /*0x2c2b*/
  }
  return result; /*0x2c41*/
}


// Function: Mtftp4ParseMulticastOption @ 0x2c48 (0x135 bytes)

unsigned __int64 __fastcall Mtftp4ParseMulticastOption(_BYTE *a1, char *buf)
{
  bool v3; // zf
  _BYTE *v4; // rbx
  unsigned __int8 *v5; // rsi
  int v6; // r15d
  unsigned __int64 n3; // r14
  unsigned int Info_1; // eax
  unsigned __int8 *v9; // rbx
  unsigned int n0xFFFF; // eax
  unsigned __int8 *v11; // rbx
  unsigned int n2; // eax

  v3 = *a1 == 44; /*0x2c65*/
  v4 = a1; /*0x2c68*/
  *((_DWORD *)buf + 2) = 0; /*0x2c6b*/
  if ( !v3 ) /*0x2c6e*/
  {
    v5 = a1; /*0x2c70*/
    v6 = 0; /*0x2c73*/
    n3 = 0; /*0x2c76*/
    while ( *v5 >= 0x30u ) /*0x2c79*/
    {
      if ( *v5 > 0x39u ) /*0x2c85*/
        break; /*0x2c85*/
      Info_1 = IpGetInfo_1(v5); /*0x2c8e*/
      if ( Info_1 > 0xFF ) /*0x2c98*/
        break; /*0x2c98*/
      v6 = Info_1 | (v6 << 8); /*0x2ca2*/
      while ( *v5 >= 0x30u && *v5 <= 0x39u ) /*0x2ca9*/
        ++v5; /*0x2cab*/
      if ( n3 < 3 && *v5 != 46 ) /*0x2cbd*/
        break; /*0x2cbd*/
      ++v5; /*0x2cc3*/
      if ( ++n3 >= 4 ) /*0x2ccd*/
      {
        *((_DWORD *)buf + 2) = v6; /*0x2ccf*/
        while ( *v4 ) /*0x2ce0*/
        {
          if ( *v4 == 44 ) /*0x2cd7*/
            goto LABEL_18; /*0x2cd7*/
          ++v4; /*0x2cd9*/
        }
        goto LABEL_17; /*0x2ce0*/
      }
    }
    return 0x8000000000000002uLL; /*0x2cbd*/
  }
LABEL_17:
  if ( *v4 != 44 ) /*0x2ce5*/
    return 0x8000000000000002uLL; /*0x2ce5*/
LABEL_18:
  v9 = v4 + 1; /*0x2ce7*/
  if ( *v9 == 44 ) /*0x2ced*/
  {
    *((_WORD *)buf + 6) = 0; /*0x2cef*/
    goto LABEL_25; /*0x2cf3*/
  }
  n0xFFFF = IpGetInfo_1(v9); /*0x2cf8*/
  if ( n0xFFFF > 0xFFFF ) /*0x2d02*/
    return 0x8000000000000002uLL; /*0x2d5a*/
  *((_WORD *)buf + 6) = n0xFFFF; /*0x2d04*/
  while ( *v9 >= 0x30u && *v9 <= 0x39u ) /*0x2d0c*/
    ++v9; /*0x2d0e*/
LABEL_25:
  if ( *v9 != 44 ) /*0x2d1a*/
    return 0x8000000000000002uLL; /*0x2d1a*/
  v11 = v9 + 1; /*0x2d1c*/
  n2 = IpGetInfo_1(v11); /*0x2d22*/
  if ( n2 >= 2 ) /*0x2d2a*/
    return 0x8000000000000002uLL; /*0x2d2a*/
  buf[14] = n2 == 1; /*0x2d32*/
  while ( *v11 >= 0x30u && *v11 <= 0x39u ) /*0x2d39*/
    ++v11; /*0x2d3b*/
  return -(__int64)(*v11 != 0) & 0x8000000000000002uLL; /*0x2d73*/
}


// Function: Mtftp4ParseOptions @ 0x2d80 (0x14c bytes)

signed __int64 __fastcall Mtftp4ParseOptions(__int64 a1, unsigned int a2, char a3, char *buf)
{
  int v4; // esi
  unsigned __int8 **i; // rbx
  char *v9; // rcx
  int Info_1; // eax
  int v11; // eax
  int v12; // eax
  signed __int64 result; // rax

  *((_DWORD *)buf + 4) = 0; /*0x2d99*/
  v4 = 0; /*0x2d9e*/
  if ( !a2 ) /*0x2dab*/
    return 0; /*0x2ea3*/
  for ( i = (unsigned __int8 **)(a1 + 8); ; i += 2 ) /*0x2db1*/
  {
    v9 = (char *)*(i - 1); /*0x2db5*/
    if ( !v9 || !*i ) /*0x2dc2*/
      return 0x8000000000000002uLL; /*0x2e77*/
    if ( IpConfig_7(v9, "blksize") ) /*0x2dd3*/
    {
      Info_1 = IpGetInfo_1(*i); /*0x2ddf*/
      if ( (unsigned int)(Info_1 - 8) > 0xFFB0 ) /*0x2ded*/
        return 0x8000000000000002uLL; /*0x2ded*/
      *((_DWORD *)buf + 4) |= 1u; /*0x2def*/
      *(_WORD *)buf = Info_1; /*0x2df3*/
      goto LABEL_20; /*0x2df6*/
    }
    if ( IpConfig_7((char *)*(i - 1), "timeout") ) /*0x2e06*/
    {
      v11 = IpGetInfo_1(*i); /*0x2e12*/
      if ( (unsigned int)(v11 - 1) > 0xFE ) /*0x2e20*/
        return 0x8000000000000002uLL; /*0x2e20*/
      buf[2] = v11; /*0x2e22*/
      goto LABEL_20; /*0x2e25*/
    }
    if ( IpConfig_7((char *)*(i - 1), "tsize") ) /*0x2e32*/
    {
      v12 = IpGetInfo_1(*i); /*0x2e3e*/
      *((_DWORD *)buf + 4) |= 4u; /*0x2e43*/
      *((_DWORD *)buf + 1) = v12; /*0x2e47*/
      goto LABEL_20; /*0x2e4a*/
    }
    if ( !IpConfig_7((char *)*(i - 1), "multicast") ) /*0x2e57*/
      break; /*0x2e57*/
    if ( a3 ) /*0x2e63*/
    {
      if ( **i ) /*0x2e68*/
        return 0x8000000000000002uLL; /*0x2e6b*/
    }
    else
    {
      result = Mtftp4ParseMulticastOption(*i, buf); /*0x2e7f*/
      if ( result < 0 ) /*0x2e87*/
        return result; /*0x2e87*/
    }
    *((_DWORD *)buf + 4) |= 8u; /*0x2e89*/
LABEL_20:
    if ( ++v4 >= a2 ) /*0x2e9d*/
      return 0; /*0x2e9d*/
  }
  if ( !a3 ) /*0x2e92*/
    goto LABEL_20; /*0x2e92*/
  return 0x8000000000000003uLL; /*0x2eb9*/
}


// Function: IpConfig_6 @ 0x2ecc (0x7b bytes)

signed __int64 __fastcall IpConfig_6(_WORD *dst, __int64 n2, char *buf)
{
  signed __int64 result; // rax
  unsigned int v5; // ebx
  signed __int64 v6; // rbx
  unsigned int v7; // [rsp+40h] [rbp+18h] BYREF
  __int64 v8; // [rsp+48h] [rbp+20h] BYREF

  *((_DWORD *)buf + 4) = 0; /*0x2ed6*/
  result = Mtftp4ParseOack(dst, n2, &v7, &v8); /*0x2ee8*/
  if ( result >= 0 ) /*0x2ef0*/
  {
    v5 = v7; /*0x2ef2*/
    if ( v7 ) /*0x2ef8*/
    {
      if ( !v8 ) /*0x2f00*/
        Assert_( /*0x2f15*/
          (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Option.c",
          528,
          (__int64)"OptionList != ((void *) 0)");
      v6 = Mtftp4ParseOptions(v8, v5, 0, buf); /*0x2f31*/
      AssertCpuDeadLoop_0(); /*0x2f34*/
      return v6; /*0x2f39*/
    }
  }
  return result; /*0x2f41*/
}


// Function: IpGetInfo @ 0x2f48 (0x92 bytes)

__int64 __fastcall IpGetInfo(__int64 buf, __int16 a2)
{
  char *v4; // rax
  __int64 v5; // rbx
  _WORD *v7; // rdi

  v4 = DxeConfig_12(4u); /*0x2f69*/
  v5 = (__int64)v4; /*0x2f6e*/
  if ( !v4 ) /*0x2f74*/
    return 0x8000000000000009uLL; /*0x2f76*/
  v7 = (_WORD *)DxeConfig_4((__int64)v4, 4u); /*0x2f8c*/
  if ( !v7 ) /*0x2f92*/
    Assert_( /*0x2fa5*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
      113,
      (__int64)"Ack != ((void *) 0)");
  *v7 = 1024; /*0x2fb3*/
  v7[1] = __ROL2__(a2, 8); /*0x2fbc*/
  return Mtftp4TransmitPacket(buf, v5); /*0x2fd4*/
}


// Function: Mtftp4ProcessDataPacket @ 0x2fdc (0x168 bytes)

__int64 __fastcall Mtftp4ProcessDataPacket(__int64 buf, char *dst, int n4)
{
  __int64 count; // r12
  _QWORD *v4; // rdi
  unsigned __int16 n4_1; // bp
  unsigned __int16 n0xFFFF; // si
  char v9; // r14
  __int64 result; // rax
  __int64 (__fastcall *v11)(__int64, _QWORD *, _QWORD, char *); // rax
  __int64 v12; // rcx
  __int64 v13; // r9
  __int64 v14; // rbp
  __int64 v15; // [rsp+50h] [rbp+8h] BYREF

  count = (unsigned int)(n4 - 4); /*0x2ffc*/
  v4 = *(_QWORD **)(buf + 152); /*0x300a*/
  n4_1 = n4; /*0x3011*/
  n0xFFFF = __ROL2__(*((_WORD *)dst + 1), 8); /*0x3014*/
  v9 = 0; /*0x301e*/
  if ( (unsigned int)count < *(unsigned __int16 *)(buf + 182) ) /*0x3024*/
  {
    *(_WORD *)(buf + 184) = n0xFFFF; /*0x3026*/
    v9 = 1; /*0x3037*/
    Assert_1((_QWORD *)(buf + 192), n0xFFFF); /*0x303a*/
  }
  result = Mtftp4BlockRangeInsert((char ***)(buf + 192), n0xFFFF, v9, &v15); /*0x3051*/
  if ( result == 0x800000000000000EuLL ) /*0x3063*/
    return 0; /*0x3063*/
  if ( result < 0 ) /*0x306c*/
    return result; /*0x306c*/
  v11 = (__int64 (__fastcall *)(__int64, _QWORD *, _QWORD, char *))v4[10]; /*0x3072*/
  if ( v11 && v11(buf + 24, v4, n4_1, dst) < 0 ) /*0x308e*/
  {
    Mtftp4SendError(buf, 4, "User aborted download"); /*0x309f*/
    return 0x8000000000000015uLL; /*0x30ae*/
  }
  v12 = v4[8]; /*0x30b0*/
  if ( !v12 ) /*0x30b7*/
    return 0; /*0x30b7*/
  v13 = *(unsigned __int16 *)(buf + 182) * (v15 - 1); /*0x30c8*/
  v14 = count + v13; /*0x30cf*/
  if ( (unsigned __int64)(count + v13) <= v4[7] ) /*0x30d7*/
  {
    MemConfig_0((char *)(v13 + v12), dst + 4, (unsigned int)count); /*0x30e0*/
    if ( *(_WORD *)(buf + 184) == n0xFFFF ) /*0x30ec*/
    {
      if ( v9 ) /*0x30f1*/
        v4[7] = v14; /*0x30f3*/
    }
    return 0; /*0x30f3*/
  }
  if ( !*(_WORD *)(buf + 184) ) /*0x311e*/
    return 0; /*0x30f7*/
  v4[7] = v14; /*0x3125*/
  Mtftp4SendError(buf, 3, "User provided memory block is too small"); /*0x3133*/
  return 0x8000000000000005uLL; /*0x3108*/
}


// Function: IpConfig_3 @ 0x3144 (0x11b bytes)

__int64 __fastcall IpConfig_3(__int64 buf, char *dst, int n4, __int64 a4, _BYTE *a5)
{
  _QWORD *v5; // r14
  unsigned __int16 v7; // bp
  __int64 v10; // rdi
  __int64 v11; // rsi
  __int64 result; // rax
  __int16 v13; // di

  v5 = (_QWORD *)(buf + 192); /*0x3164*/
  v7 = __ROL2__(*((_WORD *)dst + 1), 8); /*0x3176*/
  *a5 = 0; /*0x3180*/
  v10 = -1; /*0x3189*/
  if ( IsListEmpty((_QWORD *)(buf + 192)) ) /*0x3184*/
  {
    v11 = -1; /*0x3191*/
LABEL_4:
    Assert_( /*0x31a2*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
      263,
      (__int64)"Expected >= 0");
    goto LABEL_5; /*0x31b5*/
  }
  v11 = *(_QWORD *)(*v5 + 16LL); /*0x3199*/
  if ( v11 < 0 ) /*0x31a0*/
    goto LABEL_4; /*0x31a0*/
LABEL_5:
  if ( !*(_BYTE *)(buf + 262) || v11 == v7 ) /*0x31c9*/
  {
    result = Mtftp4ProcessDataPacket(buf, dst, n4); /*0x31de*/
    if ( result < 0 ) /*0x31e6*/
      return result; /*0x31e6*/
    if ( !*(_BYTE *)(buf + 262) ) /*0x31e8*/
      *(_DWORD *)(buf + 240) = 2 * *(_DWORD *)(buf + 252); /*0x31f9*/
    if ( !IsListEmpty(v5) ) /*0x3202*/
      v10 = *(_QWORD *)(*v5 + 16LL); /*0x320e*/
    if ( *(_BYTE *)(buf + 262) || v10 < 0 ) /*0x321e*/
    {
      if ( v10 >= 0 ) /*0x3223*/
      {
        v13 = v10 - 1; /*0x3232*/
      }
      else
      {
        v13 = *(_WORD *)(buf + 184); /*0x3225*/
        *a5 = 1; /*0x322c*/
      }
      IpGetInfo(buf, v13); /*0x323b*/
    }
  }
  else
  {
    Mtftp4ResendPacket(buf); /*0x31ce*/
  }
  return 0; /*0x3251*/
}


// Function: Mtftp4SetupMulticastReceive @ 0x3260 (0x163 bytes)

__int64 __fastcall Mtftp4SetupMulticastReceive(__int64 a1, __int64 a2)
{
  char v2; // al
  int v5; // edx
  __int64 result; // rax
  __int64 v7; // rsi
  __int64 v8; // rdx
  int v9; // [rsp+30h] [rbp-30h] BYREF
  __int16 n0x4000; // [rsp+34h] [rbp-2Ch]
  char v11; // [rsp+36h] [rbp-2Ah]
  __int64 v12; // [rsp+38h] [rbp-28h]
  char v13; // [rsp+40h] [rbp-20h]
  char dst[4]; // [rsp+41h] [rbp-1Fh] BYREF
  char dst_1[5]; // [rsp+45h] [rbp-1Bh] BYREF
  __int16 v16; // [rsp+4Ah] [rbp-16h]
  char dst_2[4]; // [rsp+4Ch] [rbp-14h] BYREF
  __int16 v18; // [rsp+50h] [rbp-10h]
  int src; // [rsp+90h] [rbp+30h] BYREF
  char dst_; // [rsp+98h] [rbp+38h] BYREF

  v2 = *(_BYTE *)(a2 + 120); /*0x3273*/
  v9 = 0; /*0x327c*/
  n0x4000 = 0x4000; /*0x3283*/
  v11 = 0; /*0x328d*/
  v12 = 0; /*0x3295*/
  v13 = v2; /*0x329c*/
  MemConfig_0(dst, (char *)(a2 + 121), 4u); /*0x32a3*/
  MemConfig_0(dst_1, (char *)(a2 + 125), 4u); /*0x32b3*/
  v5 = *(_DWORD *)(a2 + 208); /*0x32b8*/
  v16 = *(_WORD *)(a2 + 260); /*0x32c8*/
  v18 = 0; /*0x32e8*/
  src = ((unsigned __int16)__ROL2__(v5, 8) << 16) | (unsigned __int16)__ROL2__(HIWORD(v5), 8); /*0x32ed*/
  MemConfig_0(dst_2, (char *)&src, 4u); /*0x32f4*/
  result = (*(__int64 (__fastcall **)(_QWORD, int *))(*(_QWORD *)(a1 + 744) + 8LL))(*(_QWORD *)(a1 + 744), &v9); /*0x3307*/
  if ( result >= 0 ) /*0x330d*/
  {
    if ( *(_BYTE *)(a2 + 120) /*0x3354*/
      || !MemConfig((_QWORD *)(a2 + 132), 4)
      || (v7 = (*(__int64 (__fastcall **)(_QWORD, _QWORD, _QWORD *, _QWORD *, __int64))(*(_QWORD *)(a1 + 744) + 24LL))(
                 *(_QWORD *)(a1 + 744),
                 0,
                 &unk_9778,
                 &unk_9778,
                 a2 + 132),
          v7 >= 0) )
    {
      src = ((unsigned __int16)__ROL2__(*(_DWORD *)(a2 + 256), 8) << 16) /*0x3390*/
          | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)(a2 + 256)), 8);
      MemConfig_0(&dst_, (char *)&src, 4u); /*0x3397*/
      LOBYTE(v8) = 1; /*0x33a7*/
      return (*(__int64 (__fastcall **)(_QWORD, __int64, char *))(*(_QWORD *)(a1 + 744) + 16LL))( /*0x33ac*/
               *(_QWORD *)(a1 + 744),
               v8,
               &dst_);
    }
    else
    {
      (*(void (__fastcall **)(_QWORD, _QWORD))(*(_QWORD *)(a1 + 744) + 8LL))(*(_QWORD *)(a1 + 744), 0); /*0x3362*/
      return v7; /*0x3366*/
    }
  }
  return result; /*0x33b7*/
}


// Function: IpConfig @ 0x33c4 (0x2db bytes)

__int64 __fastcall IpConfig(__int64 buf, _WORD *dst, __int64 n2, __int64 a4, _BYTE *a5)
{
  __int64 v5; // rdi
  unsigned int n2_1; // esi
  __int64 v9; // rdi
  __int64 v11; // r11
  __int16 v12; // cx
  unsigned __int8 v13; // al
  __int16 v14; // r8
  __int64 v15; // r9
  int v16; // r10d
  __int64 v17; // rax
  __int64 v18; // rcx
  __int64 v19; // rsi
  char *Illegal_multicast_setting; // r8
  char bufa[8]; // [rsp+30h] [rbp-38h] BYREF
  unsigned int v22; // [rsp+38h] [rbp-30h]
  __int16 v23; // [rsp+3Ch] [rbp-2Ch]
  char v24; // [rsp+3Eh] [rbp-2Ah]
  int v25; // [rsp+40h] [rbp-28h]

  v5 = buf + 192; /*0x33e4*/
  n2_1 = n2; /*0x33f4*/
  *a5 = 0; /*0x33fa*/
  if ( IsListEmpty((_QWORD *)(buf + 192)) ) /*0x33fd*/
  {
    v9 = -1; /*0x3406*/
LABEL_4:
    Assert_( /*0x3419*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
      499,
      (__int64)"Expected != -1");
    goto LABEL_5; /*0x342c*/
  }
  v9 = *(_QWORD *)(*(_QWORD *)v5 + 16LL); /*0x340f*/
  if ( v9 == -1 ) /*0x3417*/
    goto LABEL_4; /*0x3417*/
LABEL_5:
  if ( *(_BYTE *)(buf + 262) && v9 != 1 ) /*0x3443*/
    return 0; /*0x3447*/
  MemGetInfo(bufa, 0x14u); /*0x3456*/
  v11 = IpConfig_6(dst, n2_1, bufa); /*0x346a*/
  if ( v11 >= 0 && (~*(_DWORD *)(buf + 176) & v25) == 0 ) /*0x3484*/
  {
    v12 = *(_WORD *)bufa; /*0x348a*/
    if ( (v25 & 1) == 0 || *(_WORD *)bufa <= *(_WORD *)(buf + 160) ) /*0x349b*/
    {
      v13 = bufa[2]; /*0x34a1*/
      if ( (v25 & 2) == 0 || bufa[2] == *(_BYTE *)(buf + 162) ) /*0x34b0*/
      {
        if ( (v14 = v23, v15 = v22, (v25 & 8) == 0) /*0x34ee*/
          || (v16 = *(_DWORD *)(buf + 256)) == 0
          || (!v22 || v22 == v16) && (!v23 || v23 == *(_WORD *)(buf + 260)) )
        {
          if ( (v25 & 8) == 0 ) /*0x34f6*/
          {
            *(_BYTE *)(buf + 262) = 1; /*0x3627*/
            if ( v12 ) /*0x3631*/
              *(_WORD *)(buf + 182) = v12; /*0x3633*/
LABEL_38:
            if ( v13 ) /*0x363c*/
              *(_DWORD *)(buf + 252) = v13; /*0x3641*/
            return IpGetInfo(buf, (unsigned __int16)v9 - 1); /*0x3641*/
          }
          *(_BYTE *)(buf + 262) = v24; /*0x3500*/
          if ( *(_DWORD *)(buf + 256) ) /*0x3506*/
            return IpGetInfo(buf, (unsigned __int16)v9 - 1); /*0x3656*/
          if ( (_DWORD)v15 && v14 ) /*0x3520*/
          {
            *(_DWORD *)(buf + 256) = v15; /*0x3526*/
            *(_WORD *)(buf + 260) = v14; /*0x352d*/
            if ( !*(_QWORD *)(buf + 264) ) /*0x3535*/
            {
              v17 = DxeConfig_3( /*0x355a*/
                      *(_QWORD *)(*(_QWORD *)(buf + 104) + 64LL),
                      *(_QWORD *)(*(_QWORD *)(buf + 104) + 72LL),
                      Mtftp4SetupMulticastReceive,
                      v15,
                      buf);
              *(_QWORD *)(buf + 264) = v17; /*0x355f*/
              if ( v17 ) /*0x3569*/
              {
                if ( (*(__int64 (__fastcall **)(_QWORD, void *, _BYTE **, _QWORD, _QWORD, int))(BootServices + 280))( /*0x35a7*/
                       *(_QWORD *)(v17 + 56),
                       &unk_9620,
                       &a5,
                       *(_QWORD *)(*(_QWORD *)(buf + 104) + 72LL),
                       *(_QWORD *)(buf + 112),
                       8) < 0 )
                {
                  DxeConfig_5(*(_QWORD *)(buf + 264)); /*0x35b0*/
                  *(_QWORD *)(buf + 264) = 0; /*0x35b5*/
                  return 0x8000000000000007uLL; /*0x35c6*/
                }
              }
            }
            v18 = *(_QWORD *)(buf + 264); /*0x35cb*/
            if ( !v18 ) /*0x35d5*/
              return 0x8000000000000007uLL; /*0x35d5*/
            v19 = DxeConfig_10(v18, (__int64 (__fastcall *)())IpConfig_0, buf); /*0x35e6*/
            if ( v19 < 0 ) /*0x35ec*/
            {
              Mtftp4SendError(buf, 2, "Failed to create socket to receive multicast packet"); /*0x35fd*/
              return v19; /*0x3605*/
            }
            if ( *(_WORD *)bufa ) /*0x360f*/
              *(_WORD *)(buf + 182) = *(_WORD *)bufa; /*0x3611*/
            v13 = bufa[2]; /*0x3618*/
            goto LABEL_38; /*0x361c*/
          }
          Illegal_multicast_setting = "Illegal multicast setting"; /*0x361e*/
          goto LABEL_43; /*0x3625*/
        }
      }
    }
  }
  if ( v11 != 0x8000000000000009uLL ) /*0x3665*/
  {
    Illegal_multicast_setting = "Mal-formated OACK packet"; /*0x3667*/
LABEL_43:
    Mtftp4SendError(buf, 4, Illegal_multicast_setting); /*0x366e*/
  }
  return 0x8000000000000017uLL; /*0x3696*/
}


// Function: IpConfig_0 @ 0x36a0 (0x2a0 bytes)

void __fastcall IpConfig_0(_DWORD *a1, int *a2, __int64 a3, __int64 buf)
{
  __int64 v8; // rdi
  char v9; // r12
  bool v10; // r15
  int v11; // r13d
  bool v12; // cf
  __int64 v13; // rcx
  __int16 v14; // ax
  unsigned int n4; // ebp
  char *dst; // rax
  __int64 v17; // rdx
  char *dst_1; // r14
  __int64 v19; // r9
  __int64 v20; // rdx
  __int16 n5; // r15
  __int64 (__fastcall *v22)(__int64, __int64, _QWORD, char *); // r10
  __int64 v23; // rax
  __int64 v24; // rcx
  char v25; // [rsp+70h] [rbp+8h] BYREF
  bool v26; // [rsp+80h] [rbp+18h]
  int v27; // [rsp+88h] [rbp+20h]

  if ( !buf || *(_DWORD *)buf != 1886676596 ) /*0x36cf*/
    Assert_( /*0x36e4*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
      654,
      (__int64)"((Instance) != ((void *) 0)) && ((Instance)->Signature == (((('t') | ('f' << 8)) | ((('t') | ('p' << 8)) << 16))))");
  v25 = 0; /*0x36e9*/
  v8 = 0; /*0x36ee*/
  v9 = 0; /*0x36f1*/
  v10 = 0; /*0x36f4*/
  if ( a3 < 0 ) /*0x36fa*/
  {
    v8 = a3; /*0x36fc*/
    goto LABEL_38; /*0x36ff*/
  }
  if ( !a1 ) /*0x3707*/
    Assert_( /*0x371c*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
      666,
      (__int64)"UdpPacket != ((void *) 0)");
  v11 = *a2; /*0x3727*/
  v27 = *(_DWORD *)(buf + 256); /*0x372d*/
  v10 = v11 == v27; /*0x3734*/
  v12 = a1[33] < 2u; /*0x3738*/
  v26 = v11 == v27; /*0x373f*/
  if ( !v12 ) /*0x3747*/
  {
    v13 = *((unsigned __int16 *)a2 + 18); /*0x374d*/
    v14 = *(_WORD *)(buf + 214); /*0x3752*/
    if ( (_WORD)v13 != v14 ) /*0x375c*/
    {
      if ( v14 ) /*0x3761*/
        goto LABEL_38; /*0x3761*/
      *(_WORD *)(buf + 214) = v13; /*0x3767*/
    }
    n4 = a1[33]; /*0x376e*/
    if ( a1[32] <= 1u ) /*0x377f*/
    {
      dst_1 = (char *)DxeConfig_13(a1, 0, 0); /*0x37bc*/
      if ( !dst_1 ) /*0x37c2*/
        Assert_( /*0x37d7*/
          (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Rrq.c",
          708,
          (__int64)"Packet != ((void *) 0)");
    }
    else
    {
      dst = (char *)AllocatePool(v13, n4); /*0x3783*/
      dst_1 = dst; /*0x3788*/
      if ( !dst ) /*0x378e*/
      {
        v8 = 0x8000000000000009uLL; /*0x3790*/
        goto LABEL_38; /*0x379a*/
      }
      DxeConfig_2(a1, v17, n4, dst); /*0x37a8*/
    }
    v20 = *(_QWORD *)(buf + 152); /*0x37dc*/
    n5 = __ROL2__(*(_WORD *)dst_1, 8); /*0x37e7*/
    v22 = *(__int64 (__fastcall **)(__int64, __int64, _QWORD, char *))(v20 + 80); /*0x37ec*/
    if ( v22 ) /*0x37f3*/
    {
      if ( (unsigned __int16)(n5 - 5) <= 1u ) /*0x3801*/
      {
        v8 = v22(buf + 24, v20, (unsigned __int16)n4, dst_1); /*0x3811*/
        if ( v8 < 0 ) /*0x3817*/
        {
          if ( n5 != 5 ) /*0x381e*/
            Mtftp4SendError(buf, 8, "User aborted the transfer"); /*0x382f*/
          v8 = 0x8000000000000015uLL; /*0x3834*/
          goto LABEL_35; /*0x383e*/
        }
      }
    }
    if ( n5 == 3 ) /*0x3847*/
    {
      if ( n4 > (unsigned int)*(unsigned __int16 *)(buf + 182) + 4 || n4 < 4 ) /*0x3899*/
        goto LABEL_35; /*0x3899*/
      v23 = IpConfig_3(buf, dst_1, n4, v19, &v25); /*0x38ae*/
    }
    else
    {
      if ( n5 == 5 ) /*0x384c*/
      {
        v8 = 0x8000000000000017uLL; /*0x387c*/
LABEL_35:
        if ( a1[32] > 1u ) /*0x38c6*/
          AssertCpuDeadLoop_0(); /*0x38cb*/
        v10 = v26; /*0x38d0*/
        goto LABEL_38; /*0x38d0*/
      }
      if ( n5 != 6 || v11 == v27 || n4 <= 2 ) /*0x3860*/
        goto LABEL_35; /*0x3860*/
      v23 = IpConfig(buf, dst_1, n4, v19, &v25); /*0x3875*/
    }
    v9 = v25; /*0x38b3*/
    v8 = v23; /*0x38b8*/
    goto LABEL_35; /*0x38b8*/
  }
LABEL_38:
  if ( a1 ) /*0x38db*/
    DxeConfig_14((__int64)a1); /*0x38e0*/
  if ( v8 < 0 ) /*0x38e8*/
    goto LABEL_48; /*0x38e8*/
  if ( !v9 ) /*0x38ed*/
  {
    if ( v10 ) /*0x38fc*/
      v24 = *(_QWORD *)(buf + 264); /*0x38fe*/
    else
      v24 = *(_QWORD *)(buf + 224); /*0x3907*/
    v8 = DxeConfig_10(v24, (__int64 (__fastcall *)())IpConfig_0, buf); /*0x3913*/
  }
  if ( v8 < 0 || v9 ) /*0x391e*/
LABEL_48:
    Mtftp4Cleanup(buf, v8); /*0x3926*/
}


// Function: IpConfig_2 @ 0x3940 (0x1c8 bytes)

unsigned __int64 __fastcall IpConfig_2(__int64 buf, unsigned __int16 n0xFFFF)
{
  char *v4; // rax
  __int64 v5; // r14
  __int64 v7; // r15
  __int64 v8; // rsi
  unsigned __int16 count_3; // dx
  __int64 v10; // r12
  unsigned __int16 count_4; // ax
  unsigned __int16 count_2; // cx
  unsigned __int16 count_1; // ax
  unsigned __int16 count; // [rsp+60h] [rbp+40h] BYREF
  char *src; // [rsp+70h] [rbp+50h] BYREF

  v4 = DxeConfig_12((unsigned int)*(unsigned __int16 *)(buf + 182) + 4); /*0x3967*/
  v5 = (__int64)v4; /*0x396f*/
  if ( !v4 ) /*0x3975*/
    return 0x8000000000000009uLL; /*0x3981*/
  v7 = DxeConfig_4((__int64)v4, 4u); /*0x3993*/
  if ( !v7 ) /*0x3999*/
    Assert_( /*0x39ac*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
      55,
      (__int64)"Packet != ((void *) 0)");
  *(_WORD *)v7 = 768; /*0x39b9*/
  *(_WORD *)(v7 + 2) = __ROL2__(n0xFFFF, 8); /*0x39c1*/
  v8 = *(_QWORD *)(buf + 152); /*0x39c6*/
  count_3 = *(_WORD *)(buf + 182); /*0x39cd*/
  count = count_3; /*0x39d4*/
  if ( *(_QWORD *)(v8 + 64) ) /*0x39d8*/
  {
    v10 = count_3 * (__int64)(n0xFFFF - 1); /*0x39e9*/
    if ( *(_QWORD *)(v8 + 56) < (unsigned __int64)count_3 + v10 ) /*0x39f5*/
    {
      count_4 = *(_WORD *)(v8 + 56) - v10; /*0x3a02*/
      *(_WORD *)(buf + 184) = n0xFFFF; /*0x3a06*/
      count = count_4; /*0x3a10*/
      Assert_1((_QWORD *)(buf + 192), n0xFFFF); /*0x3a14*/
      count_3 = count; /*0x3a19*/
    }
    if ( count_3 ) /*0x3a20*/
    {
      DxeConfig_4(v5, count_3); /*0x3a2c*/
      MemConfig_0((char *)(v7 + 4), (char *)(v10 + *(_QWORD *)(v8 + 64)), count); /*0x3a41*/
    }
    return Mtftp4TransmitPacket(buf, v5); /*0x3ac5*/
  }
  src = 0; /*0x3a4c*/
  if ( (*(__int64 (__fastcall **)(__int64, __int64, unsigned __int16 *, char **))(v8 + 96))(buf + 24, v8, &count, &src) >= 0 ) /*0x3a61*/
  {
    count_2 = *(_WORD *)(buf + 182); /*0x3a63*/
    count_1 = count; /*0x3a6a*/
    if ( count <= count_2 ) /*0x3a71*/
    {
      if ( count < count_2 ) /*0x3a73*/
      {
        *(_WORD *)(buf + 184) = n0xFFFF; /*0x3a7c*/
        Assert_1((_QWORD *)(buf + 192), n0xFFFF); /*0x3a86*/
        count_1 = count; /*0x3a8b*/
      }
      if ( count_1 ) /*0x3a92*/
      {
        DxeConfig_4(v5, count_1); /*0x3a9a*/
        MemConfig_0((char *)(v7 + 4), src, count); /*0x3aac*/
        AssertCpuDeadLoop_0(); /*0x3ab5*/
      }
      return Mtftp4TransmitPacket(buf, v5); /*0x3ab5*/
    }
  }
  if ( src ) /*0x3ace*/
    AssertCpuDeadLoop_0(); /*0x3ad0*/
  Mtftp4SendError(buf, 8, "User aborted the transfer"); /*0x3ae4*/
  return 0x8000000000000015uLL; /*0x3af8*/
}


// Function: IpConfig_4 @ 0x3b08 (0x10a bytes)

unsigned __int64 __fastcall IpConfig_4(__int64 buf, _WORD *dst, __int64 a3, char *a4)
{
  __int16 v4; // si
  char ***v5; // r14
  unsigned __int16 n0xFFFF; // si
  __int64 n0xFFFF_2; // rdi
  __int16 n0xFFFF_1; // ax
  __int64 v12; // [rsp+40h] [rbp+8h] BYREF

  v4 = dst[1]; /*0x3b1b*/
  v5 = (char ***)(buf + 192); /*0x3b1f*/
  *a4 = 0; /*0x3b29*/
  n0xFFFF = __ROL2__(v4, 8); /*0x3b30*/
  if ( IsListEmpty((_QWORD *)(buf + 192)) ) /*0x3b37*/
  {
    n0xFFFF_2 = -1; /*0x3b40*/
  }
  else
  {
    n0xFFFF_2 = (__int64)(*v5)[2]; /*0x3b49*/
    if ( n0xFFFF_2 >= 0 ) /*0x3b50*/
      goto LABEL_5; /*0x3b50*/
  }
  Assert_( /*0x3b65*/
    (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
    154,
    (__int64)"Expected >= 0");
LABEL_5:
  if ( n0xFFFF_2 != n0xFFFF ) /*0x3b70*/
    return 0; /*0x3b74*/
  Mtftp4BlockRangeInsert(v5, n0xFFFF, *a4, &v12); /*0x3b87*/
  if ( !IsListEmpty(v5) && (__int64)(*v5)[2] >= 0 ) /*0x3ba0*/
    return IpConfig_2(buf, *((_WORD *)*v5 + 8)); /*0x3ba9*/
  n0xFFFF_1 = *(_WORD *)(buf + 184); /*0x3bb0*/
  if ( n0xFFFF_1 == n0xFFFF ) /*0x3bba*/
  {
    if ( !n0xFFFF_1 ) /*0x3bc0*/
      Assert_( /*0x3bd5*/
        (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
        181,
        (__int64)"Instance->LastBlock >= 1");
    *a4 = 1; /*0x3bda*/
    return 0; /*0x3bde*/
  }
  Mtftp4SendError(buf, 8, "Block number rolls back, not supported, try blksize option"); /*0x3bef*/
  return 0x8000000000000017uLL; /*0x3c08*/
}


// Function: GetInfo @ 0x3c14 (0x125 bytes)

unsigned __int64 __fastcall GetInfo(__int64 buf, _WORD *dst, __int64 n2, char *a4)
{
  __int64 v4; // rdi
  unsigned int n2_1; // esi
  __int64 v9; // r8
  unsigned __int8 v10; // al
  __int64 dst_1[2]; // [rsp+20h] [rbp-48h] BYREF
  char bufa[16]; // [rsp+30h] [rbp-38h] BYREF
  int v14; // [rsp+40h] [rbp-28h]

  v4 = buf + 192; /*0x3c2c*/
  *a4 = 0; /*0x3c3f*/
  n2_1 = n2; /*0x3c42*/
  if ( IsListEmpty((_QWORD *)(buf + 192)) || *(_QWORD *)(*(_QWORD *)v4 + 16LL) ) /*0x3c58*/
    return 0; /*0x3d1d*/
  MemGetInfo(bufa, 0x14u); /*0x3c6b*/
  v9 = IpConfig_6(dst, n2_1, bufa); /*0x3c7f*/
  if ( v9 < 0 /*0x3cb9*/
    || (~*(_DWORD *)(buf + 176) & v14) != 0
    || (v14 & 1) != 0 && *(_WORD *)bufa > *(_WORD *)(buf + 160)
    || (v10 = bufa[2], (v14 & 2) != 0) && bufa[2] != *(_BYTE *)(buf + 162) )
  {
    if ( v9 != 0x8000000000000009uLL ) /*0x3cfb*/
      Mtftp4SendError(buf, 4, "Mal-formated OACK packet"); /*0x3d0c*/
    return 0x8000000000000017uLL; /*0x3d11*/
  }
  else
  {
    if ( *(_WORD *)bufa ) /*0x3cbe*/
      *(_WORD *)(buf + 182) = *(_WORD *)bufa; /*0x3cc0*/
    if ( v10 ) /*0x3cc9*/
      *(_DWORD *)(buf + 252) = v10; /*0x3cce*/
    LODWORD(dst_1[0]) = 1024; /*0x3cd7*/
    return IpConfig_4(buf, dst_1, v9, a4); /*0x3ce7*/
  }
}


// Function: IpConfig_1 @ 0x3d3c (0x24e bytes)

void __fastcall IpConfig_1(_DWORD *a1, __int64 a2, __int64 Info, __int64 buf)
{
  char v8; // r12
  __int64 Info_1; // rbx
  __int64 v10; // rcx
  __int16 v11; // ax
  unsigned int n4; // ebp
  char *dst; // rax
  __int64 v14; // rdx
  _WORD *dst_1; // r14
  __int64 v16; // r8
  __int64 v17; // rdx
  __int16 n5; // r15
  __int64 (__fastcall *v19)(__int64, __int64, _QWORD, _WORD *); // r10
  unsigned __int64 Info_2; // rax
  char v21; // [rsp+50h] [rbp+8h] BYREF

  if ( !buf || *(_DWORD *)buf != 1886676596 ) /*0x3d7a*/
    Assert_( /*0x3d8b*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
      355,
      (__int64)"((Instance) != ((void *) 0)) && ((Instance)->Signature == (((('t') | ('f' << 8)) | ((('t') | ('p' << 8)) << 16))))");
  v21 = 0; /*0x3d90*/
  v8 = 0; /*0x3d95*/
  Info_1 = 0; /*0x3d98*/
  if ( Info < 0 ) /*0x3d9e*/
  {
    Info_1 = Info; /*0x3da0*/
    goto LABEL_35; /*0x3da3*/
  }
  if ( !a1 ) /*0x3dab*/
    Assert_( /*0x3dbc*/
      (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
      366,
      (__int64)"UdpPacket != ((void *) 0)");
  if ( a1[33] >= 2u ) /*0x3dc8*/
  {
    v10 = *(unsigned __int16 *)(a2 + 36); /*0x3dce*/
    v11 = *(_WORD *)(buf + 214); /*0x3dd3*/
    if ( (_WORD)v10 != v11 ) /*0x3ddd*/
    {
      if ( v11 ) /*0x3de2*/
        goto LABEL_35; /*0x3de2*/
      *(_WORD *)(buf + 214) = v10; /*0x3de8*/
    }
    n4 = a1[33]; /*0x3def*/
    if ( a1[32] <= 1u ) /*0x3e00*/
    {
      dst_1 = (_WORD *)DxeConfig_13(a1, 0, 0); /*0x3e3d*/
      if ( !dst_1 ) /*0x3e43*/
        Assert_( /*0x3e54*/
          (__int64)"e:\\hs\\AmiNetworkPkg\\UefiNetworkStack\\Ipv4\\Mtftp4Dxe\\Mtftp4Wrq.c",
          401,
          (__int64)"Packet != ((void *) 0)");
    }
    else
    {
      dst = (char *)AllocatePool(v10, n4); /*0x3e04*/
      dst_1 = dst; /*0x3e09*/
      if ( !dst ) /*0x3e0f*/
      {
        Info_1 = 0x8000000000000009uLL; /*0x3e11*/
        goto LABEL_35; /*0x3e1b*/
      }
      DxeConfig_2(a1, v14, n4, dst); /*0x3e29*/
    }
    v17 = *(_QWORD *)(buf + 152); /*0x3e59*/
    n5 = __ROL2__(*dst_1, 8); /*0x3e64*/
    v19 = *(__int64 (__fastcall **)(__int64, __int64, _QWORD, _WORD *))(v17 + 80); /*0x3e69*/
    if ( v19 ) /*0x3e70*/
    {
      if ( (unsigned __int16)(n5 - 5) <= 1u ) /*0x3e7e*/
      {
        Info_1 = v19(buf + 24, v17, (unsigned __int16)n4, dst_1); /*0x3e8e*/
        if ( Info_1 < 0 ) /*0x3e94*/
        {
          if ( n5 != 5 ) /*0x3e9b*/
            Mtftp4SendError(buf, 8, "User aborted the transfer"); /*0x3eac*/
          Info_1 = 0x8000000000000015uLL; /*0x3eb1*/
          goto LABEL_33; /*0x3ebb*/
        }
      }
    }
    if ( n5 == 4 ) /*0x3ec4*/
    {
      if ( n4 != 4 ) /*0x3ef9*/
        goto LABEL_33; /*0x3ef9*/
      Info_2 = IpConfig_4(buf, dst_1, v16, &v21); /*0x3f06*/
    }
    else
    {
      if ( n5 == 5 ) /*0x3ec9*/
      {
        Info_1 = 0x8000000000000017uLL; /*0x3eea*/
        goto LABEL_33; /*0x3ef4*/
      }
      if ( n5 != 6 || n4 <= 2 ) /*0x3ed3*/
      {
LABEL_33:
        if ( a1[32] > 1u ) /*0x3f1e*/
          AssertCpuDeadLoop_0(); /*0x3f23*/
        goto LABEL_35; /*0x3f23*/
      }
      Info_2 = GetInfo(buf, dst_1, n4, &v21); /*0x3ee3*/
    }
    v8 = v21; /*0x3f0b*/
    Info_1 = Info_2; /*0x3f10*/
    goto LABEL_33; /*0x3f10*/
  }
LABEL_35:
  if ( a1 ) /*0x3f2b*/
    DxeConfig_14((__int64)a1); /*0x3f30*/
  if ( Info_1 < 0 ) /*0x3f38*/
    goto LABEL_42; /*0x3f38*/
  if ( !v8 ) /*0x3f3d*/
    Info_1 = DxeConfig_10(*(_QWORD *)(buf + 224), (__int64 (__fastcall *)())IpConfig_1, buf); /*0x3f55*/
  if ( Info_1 < 0 || v8 ) /*0x3f60*/
LABEL_42:
    Mtftp4Cleanup(buf, Info_1); /*0x3f68*/
}


// Function: IsListValid @ 0x3f8c (0x69 bytes)

char __fastcall IsListValid(_QWORD *a1)
{
  if ( !a1 ) /*0x3f98*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c", 80, (__int64)"List != ((void *) 0)"); /*0x3fab*/
  if ( !*a1 ) /*0x3fb0*/
    Assert_( /*0x3fc9*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
      81,
      (__int64)"List->ForwardLink != ((void *) 0)");
  if ( !a1[1] ) /*0x3fce*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c", 82, (__int64)"List->BackLink != ((void *) 0)"); /*0x3fe8*/
  return 1; /*0x3fef*/
}


// Function: InitializeListHead @ 0x3ff8 (0x36 bytes)

_QWORD *__fastcall InitializeListHead(_QWORD *a1)
{
  if ( !a1 ) /*0x4004*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c", 193, (__int64)"ListHead != ((void *) 0)"); /*0x4019*/
  *a1 = a1; /*0x401e*/
  a1[1] = a1; /*0x4024*/
  return a1; /*0x4028*/
}


// Function: InsertHeadList @ 0x4030 (0x50 bytes)

__int64 *__fastcall InsertHeadList(__int64 *a1, __int64 *a2)
{
  __int64 v4; // rax

  if ( !IsListValid(a1) ) /*0x4040*/
    Assert_( /*0x405c*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
      232,
      (__int64)"InternalBaseLibIsListValid (ListHead)");
  v4 = *a1; /*0x4061*/
  *a2 = *a1; /*0x4064*/
  a2[1] = (__int64)a1; /*0x4067*/
  *(_QWORD *)(v4 + 8) = a2; /*0x406b*/
  *a1 = (__int64)a2; /*0x4072*/
  return a1; /*0x407a*/
}


// Function: InsertTailList @ 0x4080 (0x51 bytes)

_QWORD *__fastcall InsertTailList(_QWORD *a1, _QWORD *a2)
{
  _QWORD *v4; // rax

  if ( !IsListValid(a1) ) /*0x4090*/
    Assert_( /*0x40ac*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
      273,
      (__int64)"InternalBaseLibIsListValid (ListHead)");
  *a2 = a1; /*0x40b1*/
  v4 = (_QWORD *)a1[1]; /*0x40b4*/
  a2[1] = v4; /*0x40b8*/
  *v4 = a2; /*0x40bc*/
  a1[1] = a2; /*0x40c2*/
  return a1; /*0x40cb*/
}


// Function: IsListEmpty @ 0x40d4 (0x36 bytes)

bool __fastcall IsListEmpty(_QWORD *a1)
{
  if ( !IsListValid(a1) ) /*0x40dd*/
    Assert_( /*0x40f9*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
      416,
      (__int64)"InternalBaseLibIsListValid (ListHead)");
  return *a1 == (_QWORD)a1; /*0x4104*/
}


// Function: RemoveEntryList @ 0x410c (0x48 bytes)

__int64 __fastcall RemoveEntryList(_QWORD *a1)
{
  if ( IsListEmpty(a1) ) /*0x4115*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c", 600, (__int64)"!IsListEmpty (Entry)"); /*0x4131*/
  *(_QWORD *)(*a1 + 8LL) = a1[1]; /*0x413d*/
  *(_QWORD *)a1[1] = *a1; /*0x4148*/
  return *a1; /*0x414e*/
}


// Function: StrLen @ 0x4154 (0x93 bytes)

unsigned __int64 __fastcall StrLen(_WORD *src)
{
  _WORD *src_1; // rbx
  unsigned __int64 n0xF4240; // rdi

  src_1 = src; /*0x4165*/
  if ( !src ) /*0x416b*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 172, (__int64)"String != ((void *) 0)"); /*0x4180*/
  if ( ((unsigned __int8)src_1 & 1) != 0 ) /*0x4188*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 173, (__int64)"((UINTN) String & 0x00000001) == 0"); /*0x419d*/
  n0xF4240 = 0; /*0x41a2*/
  while ( *src_1 ) /*0x41d2*/
  {
    if ( n0xF4240 >= 0xF4240 ) /*0x41ae*/
      Assert_( /*0x41c3*/
        (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
        181,
        (__int64)"Length < _gPcd_FixedAtBuild_PcdMaximumUnicodeStringLength");
    ++src_1; /*0x41c8*/
    ++n0xF4240; /*0x41cc*/
  }
  return n0xF4240; /*0x41e1*/
}


// Function: AsciiStrLen @ 0x41e8 (0x6b bytes)

unsigned __int64 __fastcall AsciiStrLen(_BYTE *a1)
{
  _BYTE *v1; // rbx
  unsigned __int64 i; // rdi

  v1 = a1; /*0x41f2*/
  if ( !a1 ) /*0x41f8*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 1082, (__int64)"String != ((void *) 0)"); /*0x420d*/
  for ( i = 0; *v1; ++i ) /*0x4214*/
  {
    if ( i >= 0xF4240 ) /*0x4220*/
      Assert_( /*0x4235*/
        (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
        1090,
        (__int64)"Length < _gPcd_FixedAtBuild_PcdMaximumAsciiStringLength");
    ++v1; /*0x423a*/
  }
  return i; /*0x424d*/
}


// Function: AsciiStrnCmp @ 0x4254 (0xc9 bytes)

__int64 __fastcall AsciiStrnCmp(_BYTE *src, _BYTE *a2, unsigned __int64 n0xF4240)
{
  unsigned __int64 n0xF4240_1; // rdi
  _BYTE *src_1; // rbx

  n0xF4240_1 = n0xF4240; /*0x4263*/
  src_1 = src; /*0x4269*/
  if ( !n0xF4240 ) /*0x426f*/
    return 0; /*0x4271*/
  if ( AsciiStrLen(src) == -1 ) /*0x4281*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 1320, (__int64)"AsciiStrSize (FirstString)"); /*0x4296*/
  if ( AsciiStrLen(a2) == -1 ) /*0x42a7*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c", 1321, (__int64)"AsciiStrSize (SecondString)"); /*0x42bc*/
  if ( n0xF4240_1 > 0xF4240 ) /*0x42c8*/
    Assert_( /*0x42dd*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\String.c",
      1324,
      (__int64)"Length <= _gPcd_FixedAtBuild_PcdMaximumAsciiStringLength");
  while ( *src_1 && *a2 && *src_1 == *a2 && n0xF4240_1 > 1 ) /*0x42f1*/
  {
    ++src_1; /*0x42f3*/
    ++a2; /*0x42f6*/
    --n0xF4240_1; /*0x42f9*/
  }
  return (char)*src_1 - (char)*a2; /*0x4317*/
}


// Function: StrnLenS @ 0x4320 (0x56 bytes)

unsigned __int64 __fastcall StrnLenS(_WORD *octet)
{
  unsigned __int64 n0xF4240; // rax

  if ( ((unsigned __int8)octet & 1) != 0 ) /*0x432c*/
    Assert_( /*0x4341*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c",
      128,
      (__int64)"((UINTN) String & 0x00000001) == 0");
  if ( !octet ) /*0x434b*/
    return 0; /*0x436e*/
  n0xF4240 = 0; /*0x434d*/
  if ( *octet ) /*0x434f*/
  {
    while ( n0xF4240 < 0xF4240 ) /*0x435a*/
    {
      if ( !octet[++n0xF4240] ) /*0x435f*/
        return n0xF4240; /*0x4363*/
    }
    return 1000001; /*0x4367*/
  }
  return n0xF4240; /*0x4370*/
}


// Function: AsciiStrnLenS @ 0x4378 (0x2a bytes)

unsigned __int64 __fastcall AsciiStrnLenS(_BYTE *octet, unsigned __int64 n0xF4240)
{
  unsigned __int64 result; // rax

  if ( !octet || !n0xF4240 ) /*0x4380*/
    return 0; /*0x439f*/
  result = 0; /*0x4382*/
  if ( *octet ) /*0x4384*/
  {
    while ( result < n0xF4240 - 1 ) /*0x438f*/
    {
      if ( !octet[++result] ) /*0x4394*/
        return result; /*0x4398*/
    }
    return n0xF4240; /*0x439b*/
  }
  return result; /*0x439a*/
}


// Function: AsciiStrCpyS @ 0x43a4 (0x14b bytes)

__int64 __fastcall AsciiStrCpyS(unsigned __int64 octet, unsigned __int64 n0xF4240, char *octet_2)
{
  unsigned __int64 octet_1; // rbx
  const char *(Destination____((void__)_0)); // r8
  __int64 n1820; // rdx
  unsigned __int64 n0xF4240_1; // rax
  __int64 v10; // rdx
  unsigned __int64 n0xF4240_2; // rbp
  char v12; // al
  char *v13; // rdi

  octet_1 = octet; /*0x43be*/
  if ( !octet ) /*0x43c4*/
  {
    (Destination____((void__)_0)) = "(Destination != ((void *) 0))"; /*0x43c6*/
    n1820 = 1820; /*0x43cd*/
LABEL_3:
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c", n1820, (__int64)(Destination____((void__)_0))); /*0x43d2*/
    return 0x8000000000000002uLL; /*0x43e8*/
  }
  if ( !octet_2 ) /*0x43f0*/
  {
    (Destination____((void__)_0)) = "(Source != ((void *) 0))"; /*0x43f2*/
    n1820 = 1821; /*0x43f9*/
    goto LABEL_3; /*0x43fe*/
  }
  if ( n0xF4240 > 0xF4240 ) /*0x4407*/
  {
    (Destination____((void__)_0)) = "(DestMax <= (_gPcd_FixedAtBuild_PcdMaximumAsciiStringLength))"; /*0x4409*/
    n1820 = 1827; /*0x4410*/
    goto LABEL_3; /*0x4415*/
  }
  if ( !n0xF4240 ) /*0x441a*/
  {
    (Destination____((void__)_0)) = "(DestMax != 0)"; /*0x441c*/
    n1820 = 1833; /*0x4423*/
    goto LABEL_3; /*0x4428*/
  }
  n0xF4240_1 = AsciiStrnLenS(octet_2, n0xF4240); /*0x442d*/
  n0xF4240_2 = n0xF4240_1; /*0x4432*/
  if ( n0xF4240 <= n0xF4240_1 ) /*0x4438*/
  {
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c", 1839, (__int64)"(DestMax > SourceLen)"); /*0x444d*/
    return 0x8000000000000005uLL; /*0x445c*/
  }
  if ( (unsigned __int64)octet_2 > octet_1 ) /*0x4461*/
    goto LABEL_15; /*0x4461*/
  if ( octet_1 >= (unsigned __int64)&octet_2[n0xF4240_1 + 1] ) /*0x446d*/
  {
    if ( octet_1 > (unsigned __int64)octet_2 ) /*0x4472*/
      goto LABEL_18; /*0x4472*/
LABEL_15:
    if ( (unsigned __int64)octet_2 >= octet_1 + v10 ) /*0x447b*/
      goto LABEL_17; /*0x447b*/
  }
  Assert_( /*0x447d*/
    (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\SafeString.c",
    1844,
    (__int64)"InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1)");
LABEL_17:
  if ( (unsigned __int64)octet_2 > octet_1 ) /*0x4498*/
  {
LABEL_20:
    if ( (unsigned __int64)octet_2 < octet_1 + n0xF4240 ) /*0x44b2*/
      return 0x800000000000000FuLL; /*0x44b2*/
    goto LABEL_22; /*0x44b2*/
  }
LABEL_18:
  if ( octet_1 < (unsigned __int64)&octet_2[n0xF4240_2 + 1] ) /*0x44a4*/
    return 0x800000000000000FuLL; /*0x44be*/
  if ( (unsigned __int64)octet_2 >= octet_1 ) /*0x44a9*/
    goto LABEL_20; /*0x44a9*/
LABEL_22:
  v12 = *octet_2; /*0x44c0*/
  if ( *octet_2 ) /*0x44c0*/
  {
    v13 = &octet_2[-octet_1]; /*0x44c6*/
    do /*0x44d3*/
    {
      *(_BYTE *)octet_1++ = v12; /*0x44c9*/
      v12 = v13[octet_1]; /*0x44ce*/
    }
    while ( v12 ); /*0x44d3*/
  }
  *(_BYTE *)octet_1 = 0; /*0x44d5*/
  return 0; /*0x44e9*/
}


// Function: MemConfig_0 @ 0x44f0 (0x99 bytes)

char *__fastcall MemConfig_0(char *dst, char *src, unsigned __int64 count)
{
  char *dst_1; // rax
  unsigned __int64 v7; // rbp

  dst_1 = dst; /*0x450d*/
  if ( count ) /*0x4513*/
  {
    v7 = count - 1; /*0x4515*/
    if ( count - 1 > ~(unsigned __int64)dst ) /*0x451f*/
      Assert_( /*0x4534*/
        (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
        56,
        (__int64)"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)DestinationBuffer)");
    if ( v7 > ~(unsigned __int64)src ) /*0x4542*/
      Assert_( /*0x4557*/
        (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CopyMemWrapper.c",
        57,
        (__int64)"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)SourceBuffer)");
    if ( dst == src ) /*0x455f*/
      return dst; /*0x4561*/
    else
      return CopyMem(dst, src, count); /*0x456f*/
  }
  return dst_1; /*0x4583*/
}


// Function: MemGetInfo @ 0x458c (0x63 bytes)

char *__fastcall sub_458C(char *buf, unsigned __int64 a2)
{
  if ( !buf ) /*0x459f*/
    Assert_( /*0x45b2*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\ZeroMemWrapper.c",
      53,
      (__int64)"Buffer != ((void *) 0)");
  if ( a2 > -(__int64)buf ) /*0x45c0*/
    Assert_( /*0x45d5*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\ZeroMemWrapper.c",
      54,
      (__int64)"Length <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)Buffer + 1)");
  return ZeroMem(buf, a2); /*0x45e5*/
}


// Function: MemConfig @ 0x45f0 (0xbc bytes)

unsigned __int64 __fastcall sub_45F0(_QWORD *a1, __int64 n4)
{
  if ( &unk_9778 == a1 ) /*0x4619*/
    return 0; /*0x461b*/
  if ( !a1 ) /*0x4622*/
    Assert_( /*0x4635*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
      61,
      (__int64)"SourceBuffer != ((void *) 0)");
  if ( n4 - 1 > (unsigned __int64)(-1LL - (_QWORD)&unk_9778) ) /*0x464b*/
    Assert_( /*0x465e*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
      62,
      (__int64)"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)DestinationBuffer)");
  if ( n4 - 1 > (unsigned __int64)(-1LL - (_QWORD)a1) ) /*0x4669*/
    Assert_( /*0x467e*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BaseMemoryLibRepStr\\CompareMemWrapper.c",
      63,
      (__int64)"(Length - 1) <= (0xFFFFFFFFFFFFFFFFULL - (UINTN)SourceBuffer)");
  return CompareMem(&unk_9778, a1, n4); /*0x46a5*/
}


// Function: CompareGuid @ 0x46ac (0x6e bytes)

bool __fastcall CompareGuid(__int64 a1, __int64 a2)
{
  __int64 v3; // rdi
  __int64 v4; // rbx
  __int64 v5; // rbp
  __int64 v6; // rax

  v3 = ReadUnaligned64((__int64)&unk_95F0); /*0x46d2*/
  v4 = ReadUnaligned64(a2); /*0x46e1*/
  v5 = ReadUnaligned64((__int64)&unk_95F8); /*0x46ed*/
  v6 = ReadUnaligned64(a2 + 8); /*0x46f0*/
  return v3 == v4 && v5 == v6; /*0x4714*/
}


// Function: GetDebugOutput @ 0x471c (0x7f bytes)

__int64 GetDebugOutput()
{
  __int64 result; // rax
  unsigned __int64 n0x10; // rbx
  __int64 v2; // rax
  __int64 v3; // rcx

  result = qword_9768; /*0x4726*/
  if ( !qword_9768 ) /*0x4732*/
  {
    n0x10 = (*(__int64 (__fastcall **)(__int64))(BootServices + 24))(31); /*0x474b*/
    (*(void (__fastcall **)(unsigned __int64))(BootServices + 32))(n0x10); /*0x474e*/
    if ( n0x10 <= 0x10 ) /*0x4755*/
    {
      v2 = (*(__int64 (__fastcall **)(void *, _QWORD, __int64 *))(BootServices + 320))(&unk_9590, 0, &qword_9768); /*0x4772*/
      v3 = qword_9768; /*0x4778*/
      if ( v2 < 0 ) /*0x4782*/
        v3 = 0; /*0x4782*/
      qword_9768 = v3; /*0x4786*/
      return v3; /*0x478d*/
    }
    else
    {
      return 0; /*0x4757*/
    }
  }
  return result; /*0x4795*/
}


// Function: DebugPrint @ 0x479c (0x88 bytes)

char DebugPrint(__int64 a1, __int64 a2, ...)
{
  __int64 v3; // rax
  __int64 v4; // r8
  char (__fastcall **v5)(__int64, __int64, __int64 *); // r9
  unsigned __int8 v6; // al
  char n3_1; // al
  char n3; // cl
  va_list va; // [rsp+40h] [rbp+18h] BYREF

  va_start(va, a2);
  v3 = GetDebugOutput(); /*0x47b3*/
  v4 = 0; /*0x47b8*/
  v5 = (char (__fastcall **)(__int64, __int64, __int64 *))v3; /*0x47bb*/
  if ( v3 ) /*0x47c1*/
  {
    v6 = __inbyte(0x70u); /*0x47c7*/
    __outbyte(0x70u, v6 & 0x80 | 0x4B); /*0x47cc*/
    n3_1 = __inbyte(0x71u); /*0x47d1*/
    n3 = n3_1; /*0x47d2*/
    if ( (unsigned __int8)n3_1 > 3u ) /*0x47d8*/
    {
      n3 = n3; /*0x47da*/
      if ( !n3 ) /*0x47e2*/
        n3 = MEMORY[0xFDAF0490] & 2 | 1; /*0x47ee*/
    }
    LOBYTE(v3) = n3 - 1; /*0x47f2*/
    if ( (unsigned __int8)(n3 - 1) <= 0xFDu ) /*0x47f6*/
    {
      LOBYTE(v3) = 4; /*0x47fa*/
      v4 = 2147483718LL; /*0x47ff*/
      if ( n3 == 1 ) /*0x4805*/
        v4 = 2147483652LL; /*0x4805*/
    }
    if ( (v4 & a1) != 0 ) /*0x480c*/
      LOBYTE(v3) = (*v5)(a1, a2, (__int64 *)va); /*0x481b*/
  }
  return v3; /*0x481e*/
}


// Function: Assert_ @ 0x4824 (0x3e bytes)

__int64 __fastcall Assert_(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  result = GetDebugOutput(); /*0x483c*/
  if ( result ) /*0x4844*/
    return (*(__int64 (__fastcall **)(__int64, __int64, __int64))(result + 8))(a1, a2, a3); /*0x484f*/
  return result; /*0x485c*/
}


// Function: IpGetInfo_0 @ 0x4864 (0x8b bytes)

unsigned __int64 __fastcall IpGetInfo_0(
        unsigned __int64 _r_n,
        unsigned __int64 n160,
        unsigned __int8 *MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d),
        unsigned __int16 *va)
{
  if ( (_r_n & 1) != 0 ) /*0x4887*/
    Assert_( /*0x489c*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BasePrintLib\\PrintLib.c",
      77,
      (__int64)"(((UINTN) (StartOfBuffer)) & 0x01) == 0");
  if ( ((unsigned __int8)MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d) & 1) != 0 ) /*0x48a4*/
    Assert_( /*0x48b9*/
      (__int64)"e:\\hs\\MdePkg\\Library\\BasePrintLib\\PrintLib.c",
      78,
      (__int64)"(((UINTN) (FormatString)) & 0x01) == 0");
  return SPrint(_r_n, n160 >> 1, 320, MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d), va); /*0x48e9*/
}


// Function: UnicodeSPrint @ 0x48f0 (0x1d bytes)

unsigned __int64 UnicodeSPrint(
        unsigned __int64 _r_n,
        unsigned __int64 n160,
        unsigned __int8 *MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d),
        ...)
{
  va_list va; // [rsp+48h] [rbp+20h] BYREF

  va_start(va, MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d));
  return IpGetInfo_0(_r_n, n160, MTFTPv4_(ServerIp_%d.%d.%d.%d__ServerPort_%d), (unsigned __int16 *)va); /*0x4908*/
}


// Function: PadBuffer @ 0x4910 (0x33 bytes)

_BYTE *__fastcall PadBuffer(_BYTE *_r_n, unsigned __int64 _r_n_1, __int64 i, __int16 n32, __int64 n2)
{
  __int64 j; // r10

  for ( j = 0; j < i; ++j ) /*0x4916*/
  {
    if ( (unsigned __int64)_r_n >= _r_n_1 ) /*0x491b*/
      break; /*0x491b*/
    *_r_n = n32; /*0x4923*/
    if ( n2 != 1 ) /*0x4926*/
      _r_n[1] = HIBYTE(n32); /*0x492f*/
    _r_n += n2; /*0x4932*/
  }
  return _r_n; /*0x4942*/
}


// Function: ValueToString @ 0x4944 (0x76 bytes)

_BYTE *__fastcall ValueToString(_BYTE *_r_n, unsigned __int64 a2, __int64 n16)
{
  int n16_1; // edi
  unsigned __int64 n16_2; // rbp
  _BYTE *_r_n_1; // rbx
  unsigned __int64 v7; // rtt

  n16_1 = n16; /*0x4958*/
  *_r_n = 0; /*0x495b*/
  n16_2 = (unsigned int)n16; /*0x4961*/
  _r_n_1 = _r_n; /*0x4964*/
  do /*0x49a0*/
  {
    if ( !n16_1 ) /*0x4969*/
      Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\DivU64x32Remainder.c", 47, (__int64)"Divisor != 0"); /*0x497c*/
    ++_r_n_1; /*0x498d*/
    v7 = a2; /*0x4990*/
    a2 /= n16_2; /*0x4993*/
    *_r_n_1 = a0123456789abcd[(unsigned int)(v7 % n16_2)]; /*0x499b*/
  }
  while ( a2 ); /*0x49a0*/
  return _r_n_1; /*0x49b4*/
}


// Function: SPrint @ 0x49bc (0xe13 bytes)

unsigned __int64 __fastcall SPrint(
        unsigned __int64 _r_n,
        unsigned __int64 n0xF4240,
        __int16 n320,
        unsigned __int8 *octet,
        unsigned __int16 *va)
{
  unsigned __int8 *octet_2; // r13
  __int64 v6; // r14
  unsigned __int64 _r_n_1; // r15
  __int64 v9; // rdi
  const char *(Buffer____((void__)_0)); // r8
  __int64 n578; // rdx
  __int64 n2_2; // r9
  __int64 n0xFFFF; // rdx
  unsigned __int64 _r_n_12; // rbx
  unsigned __int64 v16; // r10
  int v17; // eax
  bool v18; // zf
  unsigned __int64 n10; // rcx
  unsigned __int8 *octet_3; // rdx
  unsigned __int8 *octet_4; // r8
  unsigned __int64 v22; // r10
  char n43; // di
  char v24; // r11
  unsigned __int64 v25; // rsi
  const char *_r_n_3; // rbx
  unsigned __int16 *va_1; // r9
  unsigned __int8 *octet_5; // rdx
  int v29; // eax
  unsigned __int64 n13_1; // rcx
  const char *v31; // rax
  int v32; // eax
  unsigned __int8 *octet_6; // rdx
  unsigned __int64 v34; // rcx
  unsigned __int64 v35; ... [29173 chars total]


// Function: UnicodeVSPrint @ 0x57d0 (0x22 bytes)

unsigned __int64 UnicodeVSPrint(_BYTE *_r_n, unsigned __int64 n38, __int16 n320, char *%02d_%02d_%04d__%02d:%02d, ...)
{
  va_list va; // [rsp+60h] [rbp+28h] BYREF

  va_start(va, %02d_%02d_%04d__%02d:%02d);
  return SPrint( /*0x57ed*/
           (unsigned __int64)_r_n,
           n38,
           n320,
           (unsigned __int8 *)%02d_%02d_%04d__%02d:%02d,
           (unsigned __int16 *)va);
}


// Function: AllocatePool @ 0x57f4 (0x2e bytes)

__int64 __fastcall AllocatePool(__int64 a1, __int64 a2)
{
  __int64 v2; // rax
  __int64 v3; // rcx
  __int64 v5; // [rsp+40h] [rbp+18h] BYREF

  v2 = (*(__int64 (__fastcall **)(__int64, __int64, __int64 *))(BootServices + 64))(4, a2, &v5); /*0x5809*/
  v3 = v5; /*0x580c*/
  if ( v2 < 0 ) /*0x5816*/
    return 0; /*0x5816*/
  return v3; /*0x581d*/
}


// Function: GetInfo_0 @ 0x5824 (0x2c bytes)

char *__fastcall GetInfo_0(unsigned __int64 n48)
{
  char *buf; // rax

  buf = (char *)AllocatePool(n48, n48); /*0x5830*/
  if ( buf ) /*0x5838*/
  {
    if ( n48 ) /*0x583d*/
      return MemGetInfo(buf, n48); /*0x5845*/
  }
  return buf; /*0x584a*/
}


// Function: MemConfig_1 @ 0x5850 (0x76 bytes)

char *__fastcall MemConfig_1(__int64 a1, unsigned __int64 count, char *src)
{
  char *dst; // rax

  if ( !src ) /*0x5863*/
    Assert_( /*0x5878*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
      569,
      (__int64)"Buffer != ((void *) 0)");
  if ( count > -(__int64)src ) /*0x5886*/
    Assert_( /*0x589b*/
      (__int64)"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
      570,
      (__int64)"AllocationSize <= (0xFFFFFFFFFFFFFFFFULL - (UINTN) Buffer + 1)");
  dst = (char *)AllocatePool(a1, count); /*0x58a3*/
  if ( dst ) /*0x58ab*/
    return MemConfig_0(dst, src, count); /*0x58b6*/
  return dst; /*0x58c0*/
}


// Function: AssertCpuDeadLoop_0 @ 0x58c8 (0x44 bytes)

__int64 sub_58C8()
{
  __int64 result; // rax

  result = (*(__int64 (**)(void))(BootServices + 72))(); /*0x58d3*/
  if ( result < 0 ) /*0x58d9*/
  {
    DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", result); /*0x58ea*/
    return Assert_( /*0x5902*/
             (__int64)"e:\\hs\\MdePkg\\Library\\UefiMemoryAllocationLib\\MemoryAllocationLib.c",
             819,
             (__int64)"!EFI_ERROR (Status)");
  }
  return result; /*0x5907*/
}


// Function: CompareMem3Bytes @ 0x590c (0x65 bytes)

bool __fastcall CompareMem3Bytes(_DWORD *src, _DWORD *a2)
{
  int v4; // ebx

  if ( !src ) /*0x591f*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 89, (__int64)"Buffer != ((void *) 0)"); /*0x5932*/
  v4 = *src & 0xFFFFFF; /*0x5939*/
  if ( !a2 ) /*0x5942*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 89, (__int64)"Buffer != ((void *) 0)"); /*0x5955*/
  return v4 == (*a2 & 0xFFFFFF); /*0x596b*/
}


// Function: GetHobList @ 0x5974 (0x77 bytes)

unsigned __int64 __fastcall GetHobList(__int64 a1)
{
  __int64 SystemTable; // rdi
  __int64 v2; // rbx
  __int64 i; // rsi

  SystemTable = SystemTable; /*0x5983*/
  v2 = 0; /*0x598a*/
  qword_9770 = 0; /*0x598c*/
  if ( !*(_QWORD *)(SystemTable + 104) ) /*0x5994*/
    return 0x800000000000000EuLL; /*0x59b9*/
  for ( i = 0; !CompareGuid(a1, i + *(_QWORD *)(SystemTable + 112)); i += 24 ) /*0x599a*/
  {
    if ( (unsigned __int64)++v2 >= *(_QWORD *)(SystemTable + 104) ) /*0x59b7*/
      return 0x800000000000000EuLL; /*0x59b7*/
  }
  qword_9770 = *(_QWORD *)(*(_QWORD *)(SystemTable + 112) + 24 * v2 + 16); /*0x59e2*/
  return 0; /*0x59cd*/
}


// Function: Mtftp4ConfigStringLookup @ 0x59ec (0x144 bytes)

unsigned __int64 __fastcall Mtftp4ConfigStringLookup(_BYTE *src, _BYTE *src_4, char *a3, _QWORD *a4, char a5)
{
  char *v6; // rsi
  _DWORD *src_1; // rbx
  char i; // al
  unsigned __int64 n0xF4240_1; // rdi
  char n59_2; // al
  unsigned __int64 n0xF4240; // rdi
  char n59; // al
  _BYTE *src_2; // rbx
  char n59_1; // al
  _BYTE *src_3; // rcx

  v6 = a3; /*0x5a08*/
  src_1 = src_4; /*0x5a0b*/
  if ( !src || !a4 ) /*0x5a1d*/
    return 0x8000000000000002uLL; /*0x5b0b*/
  if ( src_4 && a3 ) /*0x5a2f*/
  {
    for ( i = *src_4; i; i = *(_BYTE *)src_1 ) /*0x5a35*/
    {
      if ( a5 ) /*0x5a44*/
      {
        if ( CompareMem3Bytes(src, src_1) ) /*0x5a4c*/
          goto LABEL_31; /*0x5a53*/
        src_1 = (_DWORD *)((char *)src_1 + 3); /*0x5a59*/
      }
      else
      {
        n0xF4240_1 = 0; /*0x5a5f*/
        while ( i && i != 59 ) /*0x5a65*/
          i = *((_BYTE *)src_1 + ++n0xF4240_1); /*0x5a6a*/
        if ( !AsciiStrnCmp(src_1, src, n0xF4240_1) && !src[n0xF4240_1] ) /*0x5a87*/
        {
LABEL_31:
          src_2 = *(_BYTE **)v6; /*0x5aec*/
          if ( !*(_QWORD *)v6 ) /*0x5aec*/
            return 0x8000000000000003uLL; /*0x5af2*/
          while ( 1 ) /*0x5ae2*/
          {
            n59 = *src_2; /*0x5ae2*/
            if ( !*src_2 ) /*0x5ae2*/
            {
              v6 += 16; /*0x5ae8*/
              goto LABEL_31; /*0x5ae8*/
            }
            n0xF4240 = 0; /*0x5aa3*/
            while ( n59 && n59 != 59 ) /*0x5aa9*/
              n59 = src_2[++n0xF4240]; /*0x5aae*/
            if ( !AsciiStrnCmp(src_2, src, n0xF4240) ) /*0x5abe*/
              break; /*0x5abe*/
            src_2 += n0xF4240; /*0x5ac8*/
            if ( *src_2 ) /*0x5acb*/
            {
              n59_1 = *src_2; /*0x5ad0*/
              src_3 = src_2; /*0x5ad2*/
              do /*0x5adc*/
              {
                if ( n59_1 != 59 ) /*0x5ad7*/
                  break; /*0x5ad7*/
                n59_1 = *++src_3; /*0x5adc*/
              }
              while ( *src_3 ); /*0x5adc*/
            }
          }
          *a4 = *((_QWORD *)v6 + 1); /*0x5b04*/
          return 0; /*0x5b09*/
        }
        src_1 = (_DWORD *)((char *)src_1 + n0xF4240_1); /*0x5a89*/
        n59_2 = *(_BYTE *)src_1; /*0x5a8c*/
        if ( !*(_BYTE *)src_1 ) /*0x5a90*/
          return 0x8000000000000003uLL; /*0x5a90*/
        do /*0x5a99*/
        {
          if ( n59_2 != 59 ) /*0x5a94*/
            break; /*0x5a94*/
          src_1 = (_DWORD *)((char *)src_1 + 1); /*0x5a96*/
          n59_2 = *(_BYTE *)src_1; /*0x5a99*/
        }
        while ( *(_BYTE *)src_1 ); /*0x5a99*/
      }
    }
  }
  return 0x8000000000000003uLL; /*0x5b29*/
}


// Function: Assert @ 0x5b30 (0x1ff bytes)

unsigned __int64 __fastcall Assert(char *src, _BYTE *src_6, char *src_3, char a4)
{
  _DWORD *src_1; // rbx
  char i; // al
  __int64 v10; // rcx
  unsigned __int64 n0xF4240; // rdi
  char n59; // al
  char *src_2; // rsi
  __int64 v14; // rdi
  char *dst; // rax
  char *src_4; // rbx
  unsigned __int64 n0xF4240_1; // rbp
  char n59_1; // al
  char *src_5; // rbx
  char n59_2; // al
  unsigned __int64 v21; // rax
  __int64 v22; // rcx
  char *v23; // rax
  __int64 v24; // rdi
  unsigned __int64 v25; // rax
  __int64 v26; // rcx
  char *v27; // rax

  src_1 = src_6; /*0x5b4f*/
  if ( !src_3 ) /*0x5b58*/
    return 0x8000000000000002uLL; /*0x5b58*/
  if ( !src_6 ) /*0x5b61*/
    return 0x8000000000000003uLL; /*0x5b6d*/
  if ( !*(_WORD *)src_3 ) /*0x5b72*/
    return 0x8000000000000002uLL; /*0x5d0e*/
  for ( i = *src_6; ; i = *(_BYTE *)src_1 ) /*0x5b7c*/
  {
    if ( !i ) /*0x5bda*/
      return 0x8000000000000003uLL; /*0x5bda*/
    if ( !a4 ) /*0x5b83*/
      break; /*0x5b83*/
    if ( CompareMem3Bytes(src, src_1) ) /*0x5b8b*/
      goto LABEL_20; /*0x5b92*/
    src_1 = (_DWORD *)((char *)src_1 + 3); /*0x5b94*/
LABEL_17:
    ; /*0x5bd6*/
  }
  n0xF4240 = 0; /*0x5b9a*/
  while ( i && i != 59 ) /*0x5ba1*/
    i = *((_BYTE *)src_1 + ++n0xF4240); /*0x5ba6*/
  if ( AsciiStrnCmp(src_1, src, n0xF4240) ) /*0x5bb6*/
  {
    src_1 = (_DWORD *)((char *)src_1 + n0xF4240); /*0x5bc0*/
    n59 = *(_BYTE *)src_1; /*0x5bc3*/
    if ( !*(_BYTE *)src_1 ) /*0x5bc7*/
      return 0x8000000000000003uLL; /*0x5bc7*/
    do /*0x5bd0*/
    {
      if ( n59 != 59 ) /*0x5bcb*/
        break; /*0x5bcb*/
      src_1 = (_DWORD *)((char *)src_1 + 1); /*0x5bcd*/
      n59 = *(_BYTE *)src_1; /*0x5bd0*/
    }
    while ( *(_BYTE *)src_1 ); /*0x5bd0*/
    goto LABEL_17; /*0x5bd4*/
  }
LABEL_20:
  src_2 = src_0; /*0x5bde*/
  v14 = 0; /*0x5be5*/
  if ( !src_0 ) /*0x5beb*/
    goto LABEL_21; /*0x5beb*/
LABEL_33:
  src_5 = *(char **)src_2; /*0x5c5a*/
  if ( !*(_QWORD *)src_2 ) /*0x5c60*/
  {
LABEL_21:
    dst = (char *)AllocatePool(v10, 16 * (v14 + 2)); /*0x5bed*/
    src_4 = dst; /*0x5bfa*/
    if ( dst ) /*0x5c00*/
    {
      if ( src_0 ) /*0x5c7d*/
        MemConfig_0(dst, src_0, 16 * v14); /*0x5c89*/
      v21 = AsciiStrLen(src); /*0x5c91*/
      v23 = MemConfig_1(v22, v21 + 1, src); /*0x5c9d*/
      v24 = 2 * v14; /*0x5ca2*/
      *(_QWORD *)&src_4[8 * v24] = v23; /*0x5ca5*/
      if ( v23 ) /*0x5cac*/
      {
        v25 = StrLen(src_3); /*0x5cbe*/
        v27 = MemConfig_1(v26, 2 * v25 + 2, src_3); /*0x5cce*/
        *(_QWORD *)&src_4[8 * v24 + 8] = v27; /*0x5cd3*/
        if ( v27 ) /*0x5cdb*/
        {
          *(_QWORD *)&src_4[8 * v24 + 16] = 0; /*0x5ce8*/
          *(_QWORD *)&src_4[8 * v24 + 24] = 0; /*0x5ced*/
          if ( src_0 ) /*0x5cfc*/
            AssertCpuDeadLoop_0(); /*0x5cfe*/
          src_0 = src_4; /*0x5d03*/
          return 0; /*0x5d0c*/
        }
        AssertCpuDeadLoop_0(); /*0x5ce1*/
      }
      AssertCpuDeadLoop_0(); /*0x5cb1*/
    }
    return 0x8000000000000009uLL; /*0x5c0c*/
  }
  while ( 1 ) /*0x5c4d*/
  {
    n59_1 = *src_5; /*0x5c4d*/
    if ( !*src_5 ) /*0x5c4d*/
    {
LABEL_32:
      src_2 += 16; /*0x5c53*/
      ++v14; /*0x5c57*/
      goto LABEL_33; /*0x5c57*/
    }
    n0xF4240_1 = 0; /*0x5c11*/
    while ( n59_1 && n59_1 != 59 ) /*0x5c18*/
      n59_1 = src_5[++n0xF4240_1]; /*0x5c1d*/
    if ( !AsciiStrnCmp(src, src_5, n0xF4240_1) ) /*0x5c2d*/
      return 0x8000000000000014uLL; /*0x5d22*/
    src_5 += n0xF4240_1; /*0x5c37*/
    n59_2 = *src_5; /*0x5c3a*/
    if ( !*src_5 ) /*0x5c3e*/
      goto LABEL_32; /*0x5c3e*/
    do /*0x5c47*/
    {
      if ( n59_2 != 59 ) /*0x5c42*/
        break; /*0x5c42*/
      n59_2 = *++src_5; /*0x5c47*/
    }
    while ( *src_5 ); /*0x5c47*/
  }
}


// Function: Assert_0 @ 0x5d30 (0x68 bytes)

__int64 Assert_0()
{
  char *src; // rbx
  __int64 v1; // rsi
  char *src_1; // rdi

  src = src_0; /*0x5d3f*/
  if ( src_0 ) /*0x5d49*/
  {
    v1 = 0; /*0x5d4b*/
    if ( *(_QWORD *)src_0 ) /*0x5d4d*/
    {
      src_1 = src_0; /*0x5d52*/
      do /*0x5d78*/
      {
        AssertCpuDeadLoop_0(); /*0x5d58*/
        if ( *((_QWORD *)src_1 + 1) ) /*0x5d5d*/
          AssertCpuDeadLoop_0(); /*0x5d66*/
        ++v1; /*0x5d6b*/
        src_1 = &src[16 * v1]; /*0x5d75*/
      }
      while ( *(_QWORD *)src_1 ); /*0x5d78*/
    }
    AssertCpuDeadLoop_0(); /*0x5d81*/
  }
  return 0; /*0x5d92*/
}


// Function: AssertCpuDeadLoop @ 0x5d98 (0x74 bytes)

__int64 __fastcall sub_5D98(__int64 a1)
{
  __int64 result; // rax
  signed __int64 v2; // rax

  result = qword_9770; /*0x5d9c*/
  if ( !qword_9770 ) /*0x5da6*/
  {
    v2 = GetHobList(a1); /*0x5da8*/
    if ( v2 < 0 ) /*0x5db0*/
    {
      DebugPrint(0x80000000LL, (__int64)"\nASSERT_EFI_ERROR (Status = %r)\n", v2); /*0x5dc1*/
      Assert_((__int64)"e:\\hs\\MdePkg\\Library\\DxeHobLib\\HobLib.c", 54, (__int64)"!EFI_ERROR (Status)"); /*0x5dd9*/
    }
    result = qword_9770; /*0x5dde*/
    if ( !qword_9770 ) /*0x5de8*/
    {
      Assert_((__int64)"e:\\hs\\MdePkg\\Library\\DxeHobLib\\HobLib.c", 55, (__int64)"mHobList != ((void *) 0)"); /*0x5dfb*/
      return qword_9770; /*0x5e00*/
    }
  }
  return result; /*0x5e07*/
}


// Function: NetIp4IsNetmaskValid @ 0x5e0c (0x92 bytes)

bool __fastcall NetIp4IsNetmaskValid(int dst_, int a2)
{
  __int64 n2; // r8
  __int64 i; // rax
  int v5; // edx
  int v6; // ecx

  if ( dst_ < 0 ) /*0x5e19*/
  {
    if ( (HIBYTE(dst_) & 0xC0) == 0x80 ) /*0x5e28*/
    {
      n2 = 2; /*0x5e2c*/
    }
    else if ( (HIBYTE(dst_) & 0xE0) == 0xC0 ) /*0x5e3b*/
    {
      n2 = 3; /*0x5e3d*/
    }
    else
    {
      n2 = ((HIBYTE(dst_) & 0xF0) != 0xE0) + 4LL; /*0x5e54*/
    }
  }
  else
  {
    n2 = 1; /*0x5e1b*/
  }
  if ( (unsigned int)(dst_ - 1) > 0xFFFFFFFD ) /*0x5e5e*/
    return 0; /*0x5e5e*/
  if ( !a2 ) /*0x5e69*/
    a2 = dword_8E60[8 * n2]; /*0x5e6f*/
  for ( i = 0; i <= 32; ++i ) /*0x5e73*/
  {
    if ( a2 == dword_8E60[i] ) /*0x5e78*/
      break; /*0x5e78*/
  }
  if ( i == 31 ) /*0x5e87*/
    return 1; /*0x5e87*/
  v5 = ~a2; /*0x5e89*/
  v6 = dst_ & v5; /*0x5e8d*/
  return (dst_ & v5) != v5 && v6; /*0x5e98*/
}


// Function: NetSwapBytes16 @ 0x5ea0 (0x10e bytes)

char *__fastcall NetSwapBytes16(char *src)
{
  unsigned __int64 srca; // [rsp+30h] [rbp+8h] BYREF
  unsigned __int64 dst; // [rsp+38h] [rbp+10h] BYREF

  MemConfig_0((char *)&dst, src, 8u); /*0x5ec2*/
  MemConfig_0((char *)&srca, src + 8, 8u); /*0x5ed3*/
  dst = (unsigned __int16)__ROL2__(HIWORD(dst), 8) /*0x5f4e*/
      | (((unsigned __int16)__ROL2__(WORD2(dst), 8)
        | ((((unsigned __int64)(unsigned __int16)__ROL2__(dst, 8) << 16) | (unsigned __int16)__ROL2__(WORD1(dst), 8)) << 16)) << 16);
  srca = (unsigned __int16)__ROL2__(HIWORD(srca), 8) /*0x5f7b*/
       | ((unsigned __int16)__ROL2__(WORD2(srca), 8) << 16)
       | ((((unsigned __int64)(unsigned __int16)__ROL2__(srca, 8) << 16) | (unsigned __int16)__ROL2__(WORD1(srca), 8)) << 32);
  MemConfig_0(src, (char *)&srca, 8u); /*0x5f85*/
  MemConfig_0(src + 8, (char *)&dst, 8u); /*0x5f96*/
  return src; /*0x5fa8*/
}


// Function: NetDestroyChildrenInList @ 0x5fb0 (0x10c bytes)

__int64 __fastcall NetDestroyChildrenInList(_QWORD *i, _QWORD *a2)
{
  __int64 result; // rax
  __int64 v5; // rax
  __int64 v6; // rsi
  _QWORD *j; // rdi
  _QWORD *k; // rax
  _QWORD *i_1; // rcx

  if ( !Mtftp4DestroyChildCallback ) /*0x5fd4*/
    return 0x8000000000000002uLL; /*0x5fd6*/
  v5 = 0; /*0x5fe5*/
  do /*0x609f*/
  {
    v6 = v5; /*0x5fe7*/
LABEL_5:
    if ( !IsListValid(i) ) /*0x5fed*/
      Assert_( /*0x6009*/
        (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
        311,
        (__int64)"InternalBaseLibIsListValid (List)");
    for ( j = (_QWORD *)*i; ; j = (_QWORD *)*j ) /*0x600e*/
    {
      if ( !IsListValid(i) ) /*0x6014*/
        Assert_( /*0x6030*/
          (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
          457,
          (__int64)"InternalBaseLibIsListValid (List)");
      if ( j == i ) /*0x6038*/
        break; /*0x6038*/
      result = Mtftp4DestroyChildCallback(j, a2); /*0x6040*/
      if ( result < 0 ) /*0x6048*/
        return result; /*0x6048*/
      for ( k = (_QWORD *)*i; k != i; k = (_QWORD *)*k ) /*0x604a*/
      {
        if ( k == j ) /*0x6052*/
          goto LABEL_17; /*0x6052*/
      }
      if ( k != j ) /*0x605f*/
        goto LABEL_5; /*0x605f*/
LABEL_17:
      if ( !IsListValid(i) ) /*0x6064*/
        Assert_( /*0x6080*/
          (__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\LinkedList.c",
          347,
          (__int64)"InternalBaseLibIsListValid (List)");
    }
    i_1 = (_QWORD *)*i; /*0x608a*/
    v5 = 0; /*0x608d*/
    while ( i_1 != i ) /*0x609a*/
    {
      i_1 = (_QWORD *)*i_1; /*0x6091*/
      ++v5; /*0x6094*/
    }
  }
  while ( v5 != v6 ); /*0x609f*/
  return 0; /*0x60b6*/
}


// Function: DxeGetInfo @ 0x60bc (0x91 bytes)

__int64 __fastcall sub_60BC(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 result; // rax
  _QWORD v9[3]; // [rsp+30h] [rbp-18h] BYREF

  if ( !a3 || !a4 ) /*0x60e4*/
    Assert_( /*0x60f9*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\DxeNetLib.c",
      1873,
      (__int64)"(ServiceBindingGuid != ((void *) 0)) && (ChildHandle != ((void *) 0))");
  result = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD *, __int64, __int64, int))(BootServices + 280))( /*0x6120*/
             a1,
             a3,
             v9,
             a2,
             a1,
             2);
  if ( result >= 0 ) /*0x6129*/
    return (*(__int64 (__fastcall **)(_QWORD, __int64))v9[0])(v9[0], a4); /*0x6136*/
  return result; /*0x6147*/
}


// Function: DxeGetInfo_0 @ 0x6150 (0x8d bytes)

__int64 __fastcall sub_6150(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 result; // rax
  _QWORD v9[3]; // [rsp+30h] [rbp-18h] BYREF

  if ( !a3 ) /*0x6173*/
    Assert_( /*0x6188*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\DxeNetLib.c",
      1927,
      (__int64)"ServiceBindingGuid != ((void *) 0)");
  result = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD *, __int64, __int64, int))(BootServices + 280))( /*0x61af*/
             a1,
             a3,
             v9,
             a2,
             a1,
             2);
  if ( result >= 0 ) /*0x61b8*/
    return (*(__int64 (__fastcall **)(_QWORD, __int64))(v9[0] + 8LL))(v9[0], a4); /*0x61c5*/
  return result; /*0x61d7*/
}


// Function: DxeConfig_11 @ 0x61e0 (0xb8 bytes)

char *__fastcall sub_61E0(int a1, int a2)
{
  char *v4; // rax
  char *v5; // rbx
  char *v7; // rax

  if ( !a2 ) /*0x61f6*/
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 47, (__int64)"BlockOpNum >= 1"); /*0x620b*/
  v4 = GetInfo_0(40LL * (unsigned int)(a2 - 1) + 176); /*0x621f*/
  v5 = v4; /*0x6224*/
  if ( !v4 ) /*0x622a*/
    return 0; /*0x622a*/
  *(_DWORD *)v4 = 1718968942; /*0x6234*/
  *((_QWORD *)v4 + 1) = 1; /*0x623a*/
  *((_DWORD *)v4 + 32) = a2; /*0x6242*/
  InitializeListHead((_QWORD *)v4 + 2); /*0x6248*/
  if ( a1 ) /*0x624f*/
  {
    v7 = GetInfo_0(16 * ((unsigned int)(a1 - 1) + 4LL)); /*0x625c*/
    if ( !v7 ) /*0x6264*/
    {
      AssertCpuDeadLoop_0(); /*0x6269*/
      return 0; /*0x622e*/
    }
    *(_DWORD *)v7 = 1667593838; /*0x6270*/
    *((_QWORD *)v7 + 1) = 1; /*0x6276*/
    *((_DWORD *)v7 + 10) = a1; /*0x627e*/
    *((_QWORD *)v5 + 15) = v7; /*0x6281*/
  }
  return v5; /*0x6292*/
}


// Function: DxeConfig_12 @ 0x6298 (0xa5 bytes)

char *__fastcall DxeConfig_12(unsigned int n4)
{
  __int64 n4_1; // rdi
  __int64 v2; // rcx
  char *v3; // rbx
  __int64 v5; // rcx
  __int64 v6; // rax

  n4_1 = n4; /*0x62a7*/
  if ( !n4 ) /*0x62ab*/
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 105, (__int64)"Len > 0"); /*0x62be*/
  v3 = DxeConfig_11(1, 1); /*0x62cf*/
  if ( !v3 ) /*0x62d5*/
    return 0; /*0x62d5*/
  v5 = AllocatePool(v2, n4_1); /*0x62e3*/
  if ( !v5 ) /*0x62e9*/
  {
    AssertCpuDeadLoop_0(); /*0x62ee*/
    return 0; /*0x62d9*/
  }
  v6 = *((_QWORD *)v3 + 15); /*0x62f5*/
  *(_DWORD *)(v6 + 36) = n4_1; /*0x62f9*/
  *(_QWORD *)(v6 + 56) = v5; /*0x62fc*/
  *(_DWORD *)(v6 + 48) = n4_1; /*0x6300*/
  *((_DWORD *)v3 + 42) = 0; /*0x6307*/
  *((_QWORD *)v3 + 18) = n4_1 + v5; /*0x630e*/
  *((_QWORD *)v3 + 17) = v5; /*0x6318*/
  *((_QWORD *)v3 + 19) = v5; /*0x631f*/
  *((_QWORD *)v3 + 20) = v5; /*0x6326*/
  return v3; /*0x6337*/
}


// Function: DxeConfig_8 @ 0x6340 (0xcc bytes)

__int64 __fastcall sub_6340(__int64 a1)
{
  unsigned int v1; // edi
  __int64 result; // rax

  v1 = 0; /*0x634a*/
  if ( a1 ) /*0x6352*/
  {
    if ( *(_DWORD *)a1 == 1667593838 ) /*0x6374*/
      goto LABEL_5; /*0x6374*/
  }
  else
  {
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 156, (__int64)"Vector != ((void *) 0)"); /*0x6367*/
  }
  result = Assert_( /*0x6389*/
             (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
             157,
             (__int64)"((Vector) != ((void *) 0)) && ((Vector)->Signature == (((('n') | ('v' << 8)) | ((('e') | ('c' << 8)) << 16))))");
LABEL_5:
  if ( *(__int64 *)(a1 + 8) <= 0 ) /*0x6392*/
    result = Assert_( /*0x63a7*/
               (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
               158,
               (__int64)"Vector->RefCnt > 0");
  if ( (__int64)--*(_QWORD *)(a1 + 8) <= 0 ) /*0x63b4*/
  {
    if ( *(_QWORD *)(a1 + 16) ) /*0x63b6*/
    {
      if ( (*(_BYTE *)(a1 + 32) & 1) != 0 ) /*0x63c0*/
        (*(void (__fastcall **)(_QWORD))(BootServices + 72))(*(_QWORD *)(a1 + 56)); /*0x63cd*/
      (*(void (__fastcall **)(_QWORD))(a1 + 16))(*(_QWORD *)(a1 + 24)); /*0x63d4*/
    }
    else if ( *(_DWORD *)(a1 + 40) ) /*0x63d9*/
    {
      do /*0x63f7*/
        (*(void (__fastcall **)(_QWORD))(BootServices + 72))(*(_QWORD *)(a1 + 16LL * v1++ + 56)); /*0x63ef*/
      while ( v1 < *(_DWORD *)(a1 + 40) ); /*0x63f7*/
    }
    return AssertCpuDeadLoop_0(); /*0x63fc*/
  }
  return result; /*0x6406*/
}


// Function: DxeConfig_14 @ 0x640c (0x85 bytes)

__int64 __fastcall sub_640C(__int64 a1)
{
  __int64 result; // rax

  if ( a1 ) /*0x6418*/
  {
    if ( *(_DWORD *)a1 == 1718968942 ) /*0x643a*/
      goto LABEL_5; /*0x643a*/
  }
  else
  {
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 209, (__int64)"Nbuf != ((void *) 0)"); /*0x642d*/
  }
  result = Assert_( /*0x644f*/
             (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
             210,
             (__int64)"((Nbuf) != ((void *) 0)) && ((Nbuf)->Signature == (((('n') | ('b' << 8)) | ((('u') | ('f' << 8)) << 16))))");
LABEL_5:
  if ( *(__int64 *)(a1 + 8) <= 0 ) /*0x6459*/
    result = Assert_( /*0x646e*/
               (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
               211,
               (__int64)"Nbuf->RefCnt > 0");
  if ( (*(_QWORD *)(a1 + 8))-- == 1 ) /*0x6473*/
  {
    DxeConfig_8(*(_QWORD *)(a1 + 120)); /*0x647e*/
    return AssertCpuDeadLoop_0(); /*0x6486*/
  }
  return result; /*0x648b*/
}


// Function: DxeConfig_13 @ 0x6494 (0xa1 bytes)

__int64 __fastcall sub_6494(_DWORD *a1, unsigned int a2, _DWORD *a3)
{
  unsigned int v6; // r9d
  unsigned int v7; // r8d
  __int64 v8; // rcx
  _DWORD *i; // rdx
  unsigned int v10; // r10d

  if ( !a1 || *a1 != 1718968942 ) /*0x64b6*/
    Assert_( /*0x64cb*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      383,
      (__int64)"((Nbuf) != ((void *) 0)) && ((Nbuf)->Signature == (((('n') | ('b' << 8)) | ((('u') | ('f' << 8)) << 16))))");
  if ( a2 >= a1[33] ) /*0x64d6*/
    return 0; /*0x64d6*/
  v6 = a1[32]; /*0x64d8*/
  v7 = 0; /*0x64df*/
  v8 = 0; /*0x64e2*/
  if ( !v6 ) /*0x64e7*/
    return 0; /*0x6509*/
  for ( i = a1 + 42; ; i += 10 ) /*0x64e9*/
  {
    v10 = v7 + *i; /*0x64f3*/
    if ( v10 > a2 ) /*0x64f9*/
      break; /*0x64f9*/
    v8 = (unsigned int)(v8 + 1); /*0x64fb*/
    v7 = v10; /*0x6501*/
    if ( (unsigned int)v8 >= v6 ) /*0x6507*/
      return 0; /*0x6507*/
  }
  if ( a3 ) /*0x651e*/
    *a3 = v8; /*0x6520*/
  return *(_QWORD *)&a1[10 * v8 + 38] + a2 - v7; /*0x6515*/
}


// Function: DxeConfig_6 @ 0x6538 (0xe4 bytes)

_DWORD *__fastcall DxeConfig_6(__int64 a1, __int64 dst, unsigned int a3, unsigned int a4)
{
  __int64 v4; // rsi
  __int64 v6; // rbp
  _DWORD *result; // rax
  __int64 v9; // rdx
  __int64 v10; // rcx

  v4 = a4; /*0x654c*/
  v6 = a3; /*0x6552*/
  if ( !a1 || *(_DWORD *)a1 != 1718968942 ) /*0x6563*/
    Assert_( /*0x6578*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      437,
      (__int64)"((Nbuf) != ((void *) 0)) && ((Nbuf)->Signature == (((('n') | ('b' << 8)) | ((('u') | ('f' << 8)) << 16))))");
  result = *(_DWORD **)(a1 + 120); /*0x657d*/
  if ( !result || *result != 1667593838 ) /*0x658c*/
    result = (_DWORD *)Assert_( /*0x65a1*/
                         (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
                         438,
                         (__int64)"((Nbuf->Vector) != ((void *) 0)) && ((Nbuf->Vector)->Signature == (((('n') | ('v' << 8"
                                  ")) | ((('e') | ('c' << 8)) << 16))))");
  if ( (unsigned int)v4 >= *(_DWORD *)(a1 + 128) ) /*0x65ac*/
    result = (_DWORD *)Assert_( /*0x65c1*/
                         (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
                         439,
                         (__int64)"Index < Nbuf->BlockOpNum");
  v9 = 5 * v4; /*0x65c6*/
  v10 = *(_QWORD *)(a1 + 120) + 16 * (v4 + 3); /*0x65d7*/
  *(_DWORD *)v10 = v6; /*0x65db*/
  *(_QWORD *)(v10 + 8) = dst; /*0x65dd*/
  *(_DWORD *)(a1 + 8 * v9 + 168) = v6; /*0x65e5*/
  *(_QWORD *)(a1 + 8 * v9 + 144) = dst + v6; /*0x65f1*/
  *(_QWORD *)(a1 + 8 * v9 + 160) = dst + v6; /*0x65f9*/
  *(_QWORD *)(a1 + 8 * v9 + 136) = dst; /*0x6601*/
  *(_QWORD *)(a1 + 8 * v9 + 152) = dst; /*0x6609*/
  return result; /*0x6616*/
}


// Function: DxeConfig_1 @ 0x661c (0x255 bytes)

__int64 __fastcall DxeConfig_1(
        unsigned int *p_count,
        unsigned int a2,
        __int64 a3,
        unsigned int count,
        __int64 a5,
        __int64 a6)
{
  __int64 dst_1; // r15
  int v10; // edi
  unsigned int v11; // esi
  int v12; // r13d
  __int64 dst_2; // rax
  char *dst; // rcx
  unsigned int *p_count_1; // rbx
  __int64 count_2; // rax
  __int128 v18; // xmm0
  char *v19; // rax
  __int64 v20; // rbx
  __int64 v21; // rbp
  unsigned int *v22; // rdi
  unsigned int v23; // ebp
  __int128 v24; // [rsp+20h] [rbp-58h]
  unsigned int v25; // [rsp+80h] [rbp+8h]
  int v26; // [rsp+88h] [rbp+10h]
  int v27; // [rsp+88h] [rbp+10h]
  unsigned int v28; // [rsp+90h] [rbp+18h]
  unsigned int count_1; // [rsp+98h] [rbp+20h]
  __int64 dst_3; // [rsp+A0h] [rbp+28h]
  __int64 v31; // [rsp+A0h] [rbp+28h]

  if ( !p_count || !a2 ) /*0x6643*/
    Assert_( /*0x6658*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      741,
      (__int64)"(ExtFragment != ((void *) 0)) && (ExtNum > 0) && (ExtFree != ((void *) 0))");
  dst_1 = 0; /*0x665d*/
  *((_QWORD *)&v24 + 1) = 0; /*0x6660*/
  v10 = a2; /*0x6665*/
  LODWORD(v24) = 0; /*0x6668*/
  v11 = 0; /*0x666c*/
  count_1 = 0; /*0x666e*/
  v12 = 0; /*0x6675*/
  v25 = 0; /*0x6678*/
  v28 = 0; /*0x667f*/
  if ( *p_count >= count || a2 == 1 ) /*0x6690*/
    count = 0; /*0x6692*/
  if ( count ) /*0x6696*/
  {
    count_1 = count; /*0x669e*/
    dst_2 = AllocatePool((__int64)p_count, count); /*0x66a5*/
    dst_1 = dst_2; /*0x66aa*/
    if ( !dst_2 ) /*0x66b0*/
      return 0; /*0x66b4*/
    dst_3 = dst_2; /*0x66b9*/
    v10 = a2 + 1; /*0x66c1*/
    v26 = a2 + 1; /*0x66c5*/
    dst = (char *)dst_2; /*0x66cc*/
    if ( a2 ) /*0x66d2*/
    {
      p_count_1 = p_count; /*0x66d8*/
      while ( count >= *p_count_1 ) /*0x66dd*/
      {
        MemConfig_0(dst, *((char **)p_count_1 + 1), *p_count_1); /*0x66e6*/
        count_2 = *p_count_1; /*0x66eb*/
        --v10; /*0x66ed*/
        v12 += count_2; /*0x66f7*/
        v28 += count_2; /*0x66fa*/
        dst = (char *)(count_2 + dst_3); /*0x6701*/
        dst_3 += count_2; /*0x6704*/
        v26 = v10; /*0x670c*/
        count -= count_2; /*0x6713*/
        if ( !count ) /*0x6715*/
        {
          ++v11; /*0x6724*/
          goto LABEL_18; /*0x6726*/
        }
        ++v11; /*0x6717*/
        p_count_1 += 4; /*0x6719*/
        if ( v11 >= a2 ) /*0x6720*/
          goto LABEL_18; /*0x6720*/
      }
      MemConfig_0(dst, *(char **)&p_count[4 * v11 + 2], count); /*0x6737*/
      v18 = *(_OWORD *)&p_count[4 * v11]; /*0x673c*/
      *(_QWORD *)&p_count[4 * v11 + 2] += count; /*0x6741*/
      v12 += count; /*0x6746*/
      v28 += count; /*0x6749*/
      p_count[4 * v11] -= count; /*0x6750*/
      v10 = v26; /*0x6754*/
      v24 = v18; /*0x675b*/
      v25 = v11; /*0x6761*/
    }
  }
LABEL_18:
  v19 = DxeConfig_11(v10, v10); /*0x6768*/
  v20 = (__int64)v19; /*0x6771*/
  if ( !v19 ) /*0x6777*/
  {
    if ( dst_1 ) /*0x677c*/
      AssertCpuDeadLoop_0(); /*0x6785*/
    return 0; /*0x678a*/
  }
  v21 = *((_QWORD *)v19 + 15); /*0x678f*/
  v31 = v21; /*0x67a1*/
  *(_QWORD *)(v21 + 16) = DxeGetInfo_3; /*0x67a9*/
  *(_QWORD *)(v21 + 24) = a6; /*0x67b5*/
  *(_DWORD *)(v21 + 32) = count_1 != 0; /*0x67c0*/
  v27 = 0; /*0x67c5*/
  if ( count_1 ) /*0x67ce*/
  {
    DxeConfig_6((__int64)v19, dst_1, v28, 0); /*0x67e3*/
    *(_DWORD *)(v20 + 168) = v28; /*0x67e8*/
    v27 = 1; /*0x67ee*/
  }
  if ( v11 < a2 ) /*0x67fc*/
  {
    v22 = &p_count[4 * v11]; /*0x680b*/
    v23 = v27 - v11; /*0x680e*/
    do /*0x682f*/
    {
      DxeConfig_6(v20, *((_QWORD *)v22 + 1), *v22, v11 + v23); /*0x681e*/
      v12 += *v22; /*0x6823*/
      ++v11; /*0x6826*/
      v22 += 4; /*0x6828*/
    }
    while ( v11 < a2 ); /*0x682f*/
    v21 = v31; /*0x6831*/
  }
  *(_DWORD *)(v21 + 36) = v12; /*0x6840*/
  *(_DWORD *)(v20 + 132) = v12; /*0x6844*/
  if ( v25 ) /*0x684d*/
    *(_OWORD *)&p_count[4 * v25] = v24; /*0x6857*/
  return v20; /*0x6860*/
}


// Function: NetbufGetFragmentTable @ 0x6874 (0x72 bytes)

unsigned __int64 __fastcall NetbufGetFragmentTable(__int64 a1, __int64 a2, unsigned int *va)
{
  unsigned int v3; // r9d
  __int64 i; // r10
  __int64 v6; // rcx

  v3 = 0; /*0x6879*/
  for ( i = 0; (unsigned int)i < *(_DWORD *)(a1 + 128); i = (unsigned int)(i + 1) ) /*0x6885*/
  {
    if ( *(_DWORD *)(a1 + 40 * i + 168) ) /*0x6892*/
    {
      if ( v3 >= *va ) /*0x68a0*/
        return 0x8000000000000005uLL; /*0x68da*/
      v6 = 2LL * v3++; /*0x68ad*/
      *(_QWORD *)(a2 + 8 * v6 + 8) = *(_QWORD *)(a1 + 40 * i + 152); /*0x68b3*/
      *(_DWORD *)(a2 + 8 * v6) = *(_DWORD *)(a1 + 40 * i + 168); /*0x68c0*/
    }
  }
  *va = v3; /*0x68cf*/
  return 0; /*0x68d9*/
}


// Function: DxeConfig_4 @ 0x68e8 (0x120 bytes)

__int64 __fastcall sub_68E8(__int64 a1, unsigned int a2)
{
  unsigned int v2; // edi
  unsigned __int64 v3; // rsi
  _DWORD *v5; // rax
  int v6; // edx
  __int64 v7; // r8
  unsigned int v9; // [rsp+40h] [rbp+18h] BYREF

  v2 = 0; /*0x68fc*/
  v3 = a2; /*0x68fe*/
  v9 = 0; /*0x6900*/
  if ( !a1 || *(_DWORD *)a1 != 1718968942 ) /*0x6911*/
    Assert_( /*0x6926*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      1056,
      (__int64)"((Nbuf) != ((void *) 0)) && ((Nbuf)->Signature == (((('n') | ('b' << 8)) | ((('u') | ('f' << 8)) << 16))))");
  v5 = *(_DWORD **)(a1 + 120); /*0x692b*/
  if ( !v5 || *v5 != 1667593838 ) /*0x693a*/
    Assert_( /*0x694f*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      1057,
      (__int64)"((Nbuf->Vector) != ((void *) 0)) && ((Nbuf->Vector)->Signature == (((('n') | ('v' << 8)) | ((('e') | ('c'"
               " << 8)) << 16))))");
  if ( !(_DWORD)v3 ) /*0x6956*/
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 1059, (__int64)"Len > 0"); /*0x696b*/
  v6 = *(_DWORD *)(a1 + 132); /*0x6970*/
  if ( v6 ) /*0x6978*/
  {
    DxeConfig_13((_DWORD *)a1, v6 - 1, &v9); /*0x6984*/
    v2 = v9; /*0x6989*/
    if ( *(_QWORD *)(a1 + 40LL * v9 + 144) - *(_QWORD *)(a1 + 40LL * v9 + 160) < v3 && v9 < *(_DWORD *)(a1 + 128) - 1 ) /*0x69b4*/
      v2 = v9 + 1; /*0x69b6*/
  }
  v7 = *(_QWORD *)(a1 + 40LL * v2 + 160); /*0x69c1*/
  if ( *(_QWORD *)(a1 + 40LL * v2 + 144) - v7 < v3 ) /*0x69d7*/
    return 0; /*0x69d9*/
  *(_DWORD *)(a1 + 40LL * v2 + 168) += v3; /*0x69dd*/
  *(_QWORD *)(a1 + 40LL * v2 + 160) = v7 + v3; /*0x69e7*/
  *(_DWORD *)(a1 + 132) += v3; /*0x69f2*/
  return v7; /*0x6a02*/
}


// Function: DxeConfig_2 @ 0x6a08 (0x17d bytes)

__int64 __fastcall DxeConfig_2(_DWORD *a1, __int64 a2, unsigned int n4, char *dst)
{
  unsigned int n4_1; // eax
  unsigned int v8; // r9d
  __int64 v9; // rbp
  _DWORD *v10; // rcx
  char *src; // rdx
  unsigned int count; // r14d
  char *dst_1; // r15
  unsigned int count_1; // esi
  unsigned int count_2; // eax

  if ( !a1 || *a1 != 1718968942 ) /*0x6a34*/
    Assert_( /*0x6a49*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c",
      1253,
      (__int64)"((Nbuf) != ((void *) 0)) && ((Nbuf)->Signature == (((('n') | ('b' << 8)) | ((('u') | ('f' << 8)) << 16))))");
  if ( !dst ) /*0x6a51*/
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeNetLib\\NetBuffer.c", 1254, (__int64)"Dest"); /*0x6a66*/
  if ( !n4 ) /*0x6a6d*/
    return 0; /*0x6a6d*/
  n4_1 = a1[33]; /*0x6a73*/
  if ( !n4_1 ) /*0x6a7b*/
    return 0; /*0x6b6a*/
  v8 = a1[32]; /*0x6a81*/
  if ( n4_1 < n4 ) /*0x6a8a*/
    n4 = a1[33]; /*0x6a8a*/
  v9 = 0; /*0x6a8f*/
  if ( v8 ) /*0x6a94*/
  {
    v10 = a1 + 42; /*0x6a96*/
    do /*0x6ab8*/
    {
      if ( *v10 ) /*0x6a9d*/
        break; /*0x6aa1*/
      v9 = (unsigned int)(v9 + 1); /*0x6aaf*/
      v10 += 10; /*0x6ab1*/
    }
    while ( (unsigned int)v9 < v8 ); /*0x6ab8*/
  }
  src = *(char **)&a1[10 * v9 + 38]; /*0x6ad4*/
  count = a1[10 * v9 + 42]; /*0x6adc*/
  if ( n4 > count ) /*0x6ae2*/
  {
    MemConfig_0(dst, src, count); /*0x6af6*/
    dst_1 = &dst[count]; /*0x6afb*/
    count_1 = n4 - count; /*0x6afe*/
    while ( 1 ) /*0x6b3b*/
    {
      v9 = (unsigned int)(v9 + 1); /*0x6b3b*/
      if ( (unsigned int)v9 >= a1[32] ) /*0x6b43*/
        break; /*0x6b43*/
      count_2 = a1[10 * v9 + 42]; /*0x6b11*/
      if ( count_1 <= count_2 ) /*0x6b1a*/
      {
        count += count_1; /*0x6b55*/
        MemConfig_0(dst_1, *(char **)&a1[10 * v9 + 38], count_1); /*0x6b60*/
        return count; /*0x6b60*/
      }
      count_1 -= count_2; /*0x6b27*/
      count += count_2; /*0x6b29*/
      MemConfig_0(dst_1, *(char **)&a1[10 * v9 + 38], count_2); /*0x6b2c*/
      dst_1 += (unsigned int)a1[10 * v9 + 42]; /*0x6b38*/
    }
    return count; /*0x6b65*/
  }
  else
  {
    MemConfig_0(dst, src, n4); /*0x6ae7*/
    return n4; /*0x6aec*/
  }
}


// Function: DxeGetInfo_4 @ 0x6b88 (0x4f bytes)

__int64 __fastcall DxeGetInfo_4(__int64 a1)
{
  char n4; // cl

  n4 = *(_BYTE *)(*(_QWORD *)(a1 + 24) + 32LL); /*0x6b95*/
  if ( n4 == 4 || n4 == 6 ) /*0x6ba0*/
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(*(_QWORD *)(a1 + 96)); /*0x6bad*/
  else
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c", 45, (__int64)"((BOOLEAN)(0==1))"); /*0x6bc5*/
  return AssertCpuDeadLoop_0(); /*0x6bcd*/
}


// Function: DxeGetInfo_5 @ 0x6bd8 (0x4f bytes)

__int64 __fastcall DxeGetInfo_5(__int64 a1)
{
  char n4; // cl

  n4 = *(_BYTE *)(*(_QWORD *)(a1 + 8) + 32LL); /*0x6be5*/
  if ( n4 == 4 || n4 == 6 ) /*0x6bf0*/
    (*(void (__fastcall **)(_QWORD))(BootServices + 112))(*(_QWORD *)(a1 + 40)); /*0x6bfd*/
  else
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c", 67, (__int64)"((BOOLEAN)(0==1))"); /*0x6c15*/
  return AssertCpuDeadLoop_0(); /*0x6c1d*/
}


// Function: DxeGetInfo_1 @ 0x6c28 (0x7b bytes)

__int64 __fastcall sub_6C28(__int64 a1)
{
  if ( *(_DWORD *)a1 != 1414546517 ) /*0x6c37*/
    Assert_( /*0x6c4c*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      91,
      (__int64)"TxToken->Signature == ((('U') | ('D' << 8)) | ((('P') | ('T' << 8)) << 16))");
  if ( ((*(_BYTE *)(*(_QWORD *)(a1 + 24) + 32LL) - 4) & 0xFD) != 0 ) /*0x6c5e*/
    Assert_( /*0x6c73*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      93,
      (__int64)"(TxToken->UdpIo->UdpVersion == 4) || (TxToken->UdpIo->UdpVersion == 6)");
  RemoveEntryList((_QWORD *)(a1 + 8)); /*0x6c7c*/
  (*(void (__fastcall **)(_QWORD, _QWORD, _QWORD, _QWORD))(a1 + 32))( /*0x6c93*/
    *(_QWORD *)(a1 + 40),
    0,
    *(_QWORD *)(a1 + 104),
    *(_QWORD *)(a1 + 48));
  return DxeGetInfo_4(a1); /*0x6c99*/
}


// Function: QueueDpc @ 0x6ca4 (0x1c bytes)

__int64 __fastcall QueueDpc(__int64 a1, __int64 a2)
{
  return (*(__int64 (__fastcall **)(__int64, __int64, __int64 (__fastcall *)(__int64), __int64))qword_9780)(
           qword_9780,
           8,
           DxeGetInfo_1,
           a2);
}


// Function: DxeGetInfo_3 @ 0x6cc0 (0x53 bytes)

__int64 __fastcall DxeGetInfo_3(__int64 a1)
{
  char n4; // cl

  n4 = *(_BYTE *)(*(_QWORD *)(a1 + 8) + 32LL); /*0x6ccd*/
  if ( n4 == 4 || n4 == 6 ) /*0x6cd8*/
    (*(void (__fastcall **)(_QWORD))(BootServices + 104))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 16LL)); /*0x6ce9*/
  else
    Assert_((__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c", 147, (__int64)"((BOOLEAN)(0==1))"); /*0x6d01*/
  return DxeGetInfo_5(a1); /*0x6d09*/
}


// Function: DxeConfig @ 0x6d14 (0x279 bytes)

__int64 __fastcall DxeConfig(__int64 a1)
{
  __int64 v2; // r8
  __int64 v3; // rbx
  char n4; // cl
  __int64 v5; // rsi
  bool v6; // zf
  __int64 v7; // rcx
  __int64 v9; // [rsp+20h] [rbp-40h]
  char buf[4]; // [rsp+30h] [rbp-30h] BYREF
  __int16 v11; // [rsp+40h] [rbp-20h]
  char dst[4]; // [rsp+44h] [rbp-1Ch] BYREF
  __int16 v13; // [rsp+54h] [rbp-Ch]

  MemGetInfo(buf, 0x28u); /*0x6d37*/
  if ( *(_DWORD *)a1 != 1380992085 || a1 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 736LL) ) /*0x6d4f*/
    Assert_( /*0x6d64*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      181,
      (__int64)"(RxToken->Signature == ((('U') | ('D' << 8)) | ((('P') | ('R' << 8)) << 16))) && (RxToken == RxToken->Udp"
               "Io->RecvRequest)");
  if ( ((*(_BYTE *)(*(_QWORD *)(a1 + 8) + 32LL) - 4) & 0xFD) != 0 ) /*0x6d76*/
    Assert_( /*0x6d8b*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      184,
      (__int64)"(RxToken->UdpIo->UdpVersion == 4) || (RxToken->UdpIo->UdpVersion == 6)");
  *(_QWORD *)(*(_QWORD *)(a1 + 8) + 736LL) = 0; /*0x6d98*/
  v2 = *(_QWORD *)(a1 + 48); /*0x6da4*/
  v3 = *(_QWORD *)(a1 + 56); /*0x6da8*/
  n4 = *(_BYTE *)(*(_QWORD *)(a1 + 8) + 32LL); /*0x6dac*/
  if ( v2 < 0 || !v3 ) /*0x6dbb*/
  {
    if ( v2 == 0x8000000000000015uLL ) /*0x6f62*/
      return DxeGetInfo_5(a1); /*0x6f72*/
LABEL_21:
    (*(void (__fastcall **)(_QWORD, _QWORD, __int64, _QWORD))(a1 + 16))(0, 0, v2, *(_QWORD *)(a1 + 24)); /*0x6f64*/
    return DxeGetInfo_5(a1); /*0x6f6c*/
  }
  if ( n4 == 4 ) /*0x6dc4*/
  {
    if ( *(_DWORD *)(v3 + 36) ) /*0x6dca*/
    {
      v5 = DxeConfig_1((unsigned int *)(v3 + 48), *(_DWORD *)(v3 + 40), v2, *(_DWORD *)(a1 + 32), v9, a1); /*0x6de9*/
      if ( !v5 ) /*0x6def*/
      {
LABEL_11:
        (*(void (__fastcall **)(_QWORD))(BootServices + 104))(*(_QWORD *)(v3 + 16)); /*0x6df1*/
        v2 = 0x8000000000000009uLL; /*0x6dff*/
        goto LABEL_21; /*0x6e09*/
      }
      v11 = *(_WORD *)(v3 + 34); /*0x6e16*/
      v13 = *(_WORD *)(v3 + 28); /*0x6e28*/
      MemConfig_0(buf, (char *)(v3 + 30), 4u); /*0x6e2c*/
      MemConfig_0(dst, (char *)(v3 + 24), 4u); /*0x6e3f*/
      *(_DWORD *)buf = ((unsigned __int16)__ROL2__(*(_WORD *)buf, 8) << 16) /*0x6e6b*/
                     | (unsigned __int16)__ROL2__(*(_WORD *)&buf[2], 8);
      *(_DWORD *)dst = ((unsigned __int16)__ROL2__(*(_WORD *)dst, 8) << 16) /*0x6e81*/
                     | (unsigned __int16)__ROL2__(*(_WORD *)&dst[2], 8);
      return (*(__int64 (__fastcall **)(__int64, char *, _QWORD, _QWORD))(a1 + 16))(v5, buf, 0, *(_QWORD *)(a1 + 24)); /*0x6f53*/
    }
  }
  else if ( *(_DWORD *)(v3 + 60) ) /*0x6e89*/
  {
    v5 = DxeConfig_1((unsigned int *)(v3 + 72), *(_DWORD *)(v3 + 64), v2, *(_DWORD *)(a1 + 32), v9, a1); /*0x6eee*/
    if ( !v5 ) /*0x6ef4*/
      goto LABEL_11; /*0x6ef4*/
    v11 = *(_WORD *)(v3 + 58); /*0x6f02*/
    v13 = *(_WORD *)(v3 + 40); /*0x6f14*/
    MemConfig_0(buf, (char *)(v3 + 42), 0x10u); /*0x6f18*/
    MemConfig_0(dst, (char *)(v3 + 24), 0x10u); /*0x6f2b*/
    NetSwapBytes16(buf); /*0x6f34*/
    NetSwapBytes16(dst); /*0x6f3d*/
    return (*(__int64 (__fastcall **)(__int64, char *, _QWORD, _QWORD))(a1 + 16))(v5, buf, 0, *(_QWORD *)(a1 + 24)); /*0x6f3d*/
  }
  v6 = n4 == 4; /*0x6e96*/
  v7 = *(_QWORD *)(v3 + 16); /*0x6e99*/
  if ( v6 ) /*0x6e9d*/
  {
    (*(void (__fastcall **)(__int64))(BootServices + 104))(v7); /*0x6e9f*/
    return (*(__int64 (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 744LL) + 40LL))( /*0x6eb3*/
             *(_QWORD *)(*(_QWORD *)(a1 + 8) + 744LL),
             a1 + 40);
  }
  else
  {
    (*(void (__fastcall **)(__int64))(BootServices + 104))(v7); /*0x6ebc*/
    return (*(__int64 (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 744LL) + 32LL))( /*0x6ed0*/
             *(_QWORD *)(*(_QWORD *)(a1 + 8) + 744LL),
             a1 + 40);
  }
}


// Function: QueueDpcForReceive @ 0x6f90 (0x1c bytes)

__int64 __fastcall QueueDpcForReceive(__int64 a1, __int64 a2)
{
  return (*(__int64 (__fastcall **)(__int64, __int64, __int64 (__fastcall *)(__int64), __int64))qword_9780)(
           qword_9780,
           8,
           DxeConfig,
           a2);
}


// Function: DxeConfig_7 @ 0x6fac (0xcf bytes)

__int64 __fastcall DxeConfig_7(__int64 a1, __int64 (__fastcall *sub_3D3C)(), __int64 buf)
{
  __int64 v6; // rax
  __int64 v7; // rbx

  if ( ((*(_BYTE *)(a1 + 32) - 4) & 0xFD) != 0 ) /*0x6fd0*/
    Assert_( /*0x6fe5*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      361,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  v6 = AllocatePool(a1, 64); /*0x6fef*/
  v7 = v6; /*0x6ff4*/
  if ( !v6 ) /*0x6ffa*/
    return 0; /*0x6ffa*/
  *(_DWORD *)(v6 + 32) = 0; /*0x7000*/
  *(_DWORD *)v6 = 1380992085; /*0x700b*/
  *(_QWORD *)(v6 + 8) = a1; /*0x7014*/
  *(_QWORD *)(v6 + 16) = sub_3D3C; /*0x701d*/
  *(_QWORD *)(v6 + 24) = buf; /*0x7026*/
  *(_QWORD *)(v6 + 56) = 0; /*0x7038*/
  *(_QWORD *)(v6 + 48) = 0x8000000000000006uLL; /*0x703d*/
  if ( (*(__int64 (__fastcall **)(__int64, __int64, __int64 (__fastcall *)(__int64, __int64), __int64, __int64))(BootServices + 80))( /*0x7057*/
         512,
         16,
         QueueDpcForReceive,
         v6,
         v6 + 40) < 0 )
  {
    AssertCpuDeadLoop_0(); /*0x705c*/
    return 0; /*0x6ffe*/
  }
  return v7; /*0x7075*/
}


// Function: DxeConfig_0 @ 0x707c (0x258 bytes)

_DWORD *DxeConfig_0(__int64 a1, __int64 a2, __int64 src, ...)
{
  __int64 v6; // rax
  __int64 v7; // rdi
  bool v9; // zf
  __int64 *v10; // rsi
  __int64 v11; // rbx
  __int64 v12; // [rsp+20h] [rbp-38h]
  int srca; // [rsp+60h] [rbp+8h] BYREF
  __int64 va; // [rsp+78h] [rbp+20h] BYREF
  va_list vaa; // [rsp+78h] [rbp+20h]
  __int64 v16; // [rsp+80h] [rbp+28h]
  __int64 v17; // [rsp+88h] [rbp+30h]
  va_list va1; // [rsp+90h] [rbp+38h] BYREF

  va_start(va1, src);
  va_start(vaa, src);
  va = va_arg(va1, _QWORD); /*0x707c*/
  v16 = va_arg(va1, _QWORD); /*0x707c*/
  v17 = va_arg(va1, _QWORD); /*0x707c*/
  if ( !a2 ) /*0x709d*/
    Assert_( /*0x70b2*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      442,
      (__int64)"Packet != ((void *) 0)");
  if ( ((*(_BYTE *)(a1 + 32) - 4) & 0xFD) != 0 ) /*0x70be*/
    Assert_( /*0x70d3*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      444,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  v6 = AllocatePool(a1, 16 * ((unsigned int)(*(_DWORD *)(a2 + 128) - 1) + 10LL)); /*0x70e8*/
  v7 = v6; /*0x70ed*/
  if ( !v6 ) /*0x70f3*/
    return 0; /*0x70f3*/
  *(_DWORD *)v6 = 1414546517; /*0x7100*/
  InitializeListHead((_QWORD *)(v6 + 8)); /*0x7106*/
  *(_QWORD *)(v7 + 24) = a1; /*0x710b*/
  *(_QWORD *)(v7 + 32) = j_DxeConfig_14; /*0x7116*/
  *(_QWORD *)(v7 + 48) = v17; /*0x712d*/
  *(_QWORD *)(v7 + 40) = a2; /*0x7134*/
  v9 = *(_BYTE *)(a1 + 32) == 4; /*0x7143*/
  LODWORD(va) = *(_DWORD *)(a2 + 128); /*0x7147*/
  *(_QWORD *)(v7 + 104) = 0x8000000000000006uLL; /*0x7155*/
  v12 = v7 + 96; /*0x7160*/
  if ( v9 ) /*0x7165*/
  {
    if ( (*(__int64 (__fastcall **)(__int64, __int64, __int64 (__fastcall *)(__int64, __int64), __int64, __int64))(BootServices + 80))( /*0x7176*/
           512,
           16,
           QueueDpc,
           v7,
           v12) < 0 )
    {
LABEL_9:
      AssertCpuDeadLoop_0(); /*0x7178*/
      return 0; /*0x70f7*/
    }
    v10 = (__int64 *)(v7 + 120); /*0x7185*/
    *(_QWORD *)(v7 + 112) = v7 + 120; /*0x718c*/
    *(_QWORD *)(v7 + 120) = 0; /*0x7194*/
    *(_QWORD *)(v7 + 128) = 0; /*0x719d*/
    *(_DWORD *)(v7 + 136) = *(_DWORD *)(a2 + 132); /*0x71a8*/
    NetbufGetFragmentTable(a2, v7 + 144, (unsigned int *)vaa); /*0x71ab*/
    *(_DWORD *)(v7 + 140) = va; /*0x71b5*/
    if ( src ) /*0x71bc*/
    {
      v11 = v7 + 60; /*0x71c5*/
      srca = ((unsigned __int16)__ROL2__(*(_DWORD *)src, 8) << 16) /*0x71ec*/
           | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)src), 8);
      MemConfig_0((char *)(v7 + 60), (char *)&srca, 4u); /*0x71f3*/
      srca = ((unsigned __int16)__ROL2__(*(_DWORD *)(src + 20), 8) << 16) /*0x721f*/
           | (unsigned __int16)__ROL2__(HIWORD(*(_DWORD *)(src + 20)), 8);
      MemConfig_0((char *)(v7 + 66), (char *)&srca, 4u); /*0x7227*/
      *(_WORD *)(v7 + 64) = *(_WORD *)(src + 16); /*0x7231*/
      *(_WORD *)(v7 + 70) = *(_WORD *)(src + 36); /*0x723a*/
LABEL_15:
      *v10 = v11; /*0x72bd*/
    }
  }
  else
  {
    if ( (*(__int64 (__fastcall **)(__int64, __int64, __int64 (__fastcall *)(__int64, __int64), __int64, __int64))(BootServices + 80))( /*0x724f*/
           512,
           16,
           QueueDpc,
           v7,
           v12) < 0 )
      goto LABEL_9; /*0x724f*/
    v10 = (__int64 *)(v7 + 120); /*0x7255*/
    *(_QWORD *)(v7 + 112) = v7 + 120; /*0x725c*/
    *(_QWORD *)(v7 + 120) = 0; /*0x7264*/
    *(_DWORD *)(v7 + 128) = *(_DWORD *)(a2 + 132); /*0x7273*/
    NetbufGetFragmentTable(a2, v7 + 136, (unsigned int *)vaa); /*0x7276*/
    *(_DWORD *)(v7 + 132) = va; /*0x7280*/
    if ( src ) /*0x7287*/
    {
      v11 = v7 + 60; /*0x7289*/
      MemConfig_0((char *)(v7 + 60), (char *)src, 0x10u); /*0x7296*/
      MemConfig_0((char *)(v7 + 78), (char *)(src + 20), 0x10u); /*0x72a6*/
      *(_WORD *)(v7 + 76) = *(_WORD *)(src + 16); /*0x72b0*/
      *(_WORD *)(v7 + 94) = *(_WORD *)(src + 36); /*0x72b9*/
      goto LABEL_15; /*0x72b9*/
    }
  }
  return (_DWORD *)v7; /*0x72c8*/
}


// Function: DxeConfig_3 @ 0x72d4 (0x16f bytes)

__int64 __fastcall sub_72D4(
        __int64 a1,
        __int64 a2,
        __int64 (__fastcall *sub_7DC)(__int64, __int64),
        __int64 a4,
        __int64 buf)
{
  __int64 v8; // rax
  __int64 v9; // rbx
  __int64 *v10; // r14

  if ( !sub_7DC ) /*0x72f8*/
    Assert_( /*0x730d*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      611,
      (__int64)"Configure != ((void *) 0)");
  v8 = AllocatePool(a1, 808); /*0x7317*/
  v9 = v8; /*0x731c*/
  if ( v8 ) /*0x7322*/
  {
    *(_BYTE *)(v8 + 32) = 4; /*0x732c*/
    *(_DWORD *)v8 = 1229997141; /*0x7330*/
    InitializeListHead((_QWORD *)(v8 + 8)); /*0x7336*/
    *(_QWORD *)(v9 + 24) = 1; /*0x7342*/
    *(_QWORD *)(v9 + 40) = a1; /*0x734a*/
    *(_QWORD *)(v9 + 48) = a2; /*0x734e*/
    InitializeListHead((_QWORD *)(v9 + 720)); /*0x7352*/
    *(_QWORD *)(v9 + 736) = 0; /*0x7357*/
    v10 = (__int64 *)(v9 + 56); /*0x735f*/
    *(_QWORD *)(v9 + 56) = 0; /*0x7363*/
    if ( DxeGetInfo(a1, a2, (__int64)&unk_95C0, v9 + 56) >= 0 ) /*0x737f*/
    {
      if ( (*(__int64 (__fastcall **)(__int64, void *, __int64, __int64, __int64, int))(BootServices + 280))( /*0x73b9*/
             *v10,
             &unk_9620,
             v9 + 744,
             a2,
             a1,
             16) >= 0 )
      {
        if ( sub_7DC(v9, buf) >= 0 /*0x73e7*/
          && (**(__int64 (__fastcall ***)(_QWORD, _QWORD, _QWORD, _QWORD, __int64))(v9 + 744))(
               *(_QWORD *)(v9 + 744),
               0,
               0,
               0,
               v9 + 64) >= 0 )
        {
          return v9; /*0x73ec*/
        }
        (*(void (__fastcall **)(__int64, void *, __int64, __int64))(BootServices + 288))(*v10, &unk_9620, a2, a1); /*0x7405*/
      }
      DxeGetInfo_0(a1, a2, (__int64)&unk_95C0, *v10); /*0x741b*/
    }
    AssertCpuDeadLoop_0(); /*0x7423*/
  }
  return 0; /*0x7439*/
}


// Function: DxeGetInfo_2 @ 0x7444 (0x79 bytes)

char __fastcall sub_7444(__int64 a1)
{
  char result; // al
  _QWORD **v3; // rcx
  _QWORD *v4; // rsi
  _QWORD **v5; // rdx
  __int64 v6; // rax

  result = *(_BYTE *)(a1 + 32) - 4; /*0x7459*/
  if ( (result & 0xFD) != 0 ) /*0x745d*/
    result = Assert_( /*0x7472*/
               (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
               775,
               (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  v3 = *(_QWORD ***)(a1 + 720); /*0x747e*/
  v4 = *v3; /*0x7481*/
  while ( v3 != (_QWORD **)(a1 + 720) ) /*0x74ab*/
  {
    v5 = v3 + 11; /*0x748a*/
    v6 = *(_QWORD *)(a1 + 744); /*0x748e*/
    if ( *(_BYTE *)(a1 + 32) == 4 ) /*0x7498*/
      result = (*(__int64 (__fastcall **)(__int64, _QWORD **))(v6 + 48))(v6, v5); /*0x749a*/
    else
      result = (*(__int64 (__fastcall **)(__int64, _QWORD **))(v6 + 40))(v6, v5); /*0x749f*/
    v3 = (_QWORD **)v4; /*0x74a2*/
    v4 = (_QWORD *)*v4; /*0x74a5*/
  }
  return result; /*0x74b7*/
}


// Function: DxeConfig_5 @ 0x74c0 (0xfb bytes)

__int64 __fastcall sub_74C0(__int64 a1)
{
  __int64 v2; // rdx
  void *v3; // r8

  if ( ((*(_BYTE *)(a1 + 32) - 4) & 0xFD) != 0 ) /*0x74d4*/
    Assert_( /*0x74e9*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      810,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  DxeGetInfo_2(a1); /*0x74f1*/
  v2 = *(_QWORD *)(a1 + 736); /*0x74fa*/
  if ( *(_BYTE *)(a1 + 32) == 4 ) /*0x7501*/
  {
    if ( v2 ) /*0x7506*/
      (*(void (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(a1 + 744) + 48LL))(*(_QWORD *)(a1 + 744), v2 + 40); /*0x7516*/
    (*(void (__fastcall **)(_QWORD, void *, _QWORD, _QWORD))(BootServices + 288))( /*0x7533*/
      *(_QWORD *)(a1 + 56),
      &unk_9620,
      *(_QWORD *)(a1 + 48),
      *(_QWORD *)(a1 + 40));
    v3 = &unk_95C0; /*0x7539*/
  }
  else
  {
    if ( v2 ) /*0x7545*/
      (*(void (__fastcall **)(_QWORD, __int64))(*(_QWORD *)(a1 + 744) + 40LL))(*(_QWORD *)(a1 + 744), v2 + 40); /*0x7555*/
    (*(void (__fastcall **)(_QWORD, void *, _QWORD, _QWORD))(BootServices + 288))( /*0x7572*/
      *(_QWORD *)(a1 + 56),
      &unk_95D0,
      *(_QWORD *)(a1 + 48),
      *(_QWORD *)(a1 + 40));
    v3 = &unk_95E0; /*0x7578*/
  }
  DxeGetInfo_0(*(_QWORD *)(a1 + 40), *(_QWORD *)(a1 + 48), (__int64)v3, *(_QWORD *)(a1 + 56)); /*0x758b*/
  if ( !IsListEmpty((_QWORD *)(a1 + 8)) ) /*0x7594*/
    RemoveEntryList((_QWORD *)(a1 + 8)); /*0x75a1*/
  AssertCpuDeadLoop_0(); /*0x75a9*/
  return 0; /*0x75b5*/
}


// Function: DxeConfig_9 @ 0x75bc (0xc1 bytes)

__int64 __fastcall DxeConfig_9(__int64 a1, __int64 a2, char *buf)
{
  __int64 *v6; // rax
  __int64 v7; // rdi
  __int64 v9; // rdx
  __int64 v10; // rax
  __int64 v11; // rax
  __int64 v12; // rbx

  if ( ((*(_BYTE *)(a1 + 32) - 4) & 0xFD) != 0 ) /*0x75db*/
    Assert_( /*0x75f0*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      956,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  v6 = (__int64 *)DxeConfig_0(a1, a2, (__int64)buf); /*0x7608*/
  v7 = (__int64)v6; /*0x760d*/
  if ( !v6 ) /*0x7613*/
    return 0x8000000000000009uLL; /*0x7615*/
  InsertHeadList((__int64 *)(a1 + 720), v6 + 1); /*0x762c*/
  v9 = v7 + 96; /*0x7635*/
  v10 = *(_QWORD *)(a1 + 744); /*0x7639*/
  if ( *(_BYTE *)(a1 + 32) == 4 ) /*0x7643*/
    v11 = (*(__int64 (__fastcall **)(__int64, __int64))(v10 + 32))(v10, v9); /*0x7645*/
  else
    v11 = (*(__int64 (__fastcall **)(__int64, __int64))(v10 + 24))(v10, v9); /*0x764a*/
  v12 = v11; /*0x764d*/
  if ( v11 >= 0 ) /*0x7653*/
    return 0; /*0x766b*/
  RemoveEntryList((_QWORD *)(v7 + 8)); /*0x7659*/
  DxeGetInfo_4(v7); /*0x7661*/
  return v12; /*0x7677*/
}


// Function: DxeConfig_10 @ 0x7680 (0xbf bytes)

__int64 __fastcall DxeConfig_10(__int64 a1, __int64 (__fastcall *sub_3D3C)(), __int64 buf)
{
  __int64 v7; // rax
  __int64 v8; // rdi
  bool v9; // zf
  __int64 v10; // rdx
  __int64 v11; // rax
  __int64 v12; // rax
  __int64 v13; // rsi

  if ( ((*(_BYTE *)(a1 + 32) - 4) & 0xFD) != 0 ) /*0x769f*/
    Assert_( /*0x76b4*/
      (__int64)"e:\\hs\\MdeModulePkg\\Library\\DxeUdpIoLib\\DxeUdpIoLib.c",
      1064,
      (__int64)"(UdpIo->UdpVersion == 4) || (UdpIo->UdpVersion == 6)");
  if ( *(_QWORD *)(a1 + 736) ) /*0x76b9*/
    return 0x8000000000000014uLL; /*0x76c3*/
  v7 = DxeConfig_7(a1, sub_3D3C, buf); /*0x76d8*/
  v8 = v7; /*0x76dd*/
  if ( !v7 ) /*0x76e3*/
    return 0x8000000000000009uLL; /*0x76e5*/
  v9 = *(_BYTE *)(a1 + 32) == 4; /*0x76f1*/
  v10 = v7 + 40; /*0x76f5*/
  v11 = *(_QWORD *)(a1 + 744); /*0x76f9*/
  *(_QWORD *)(a1 + 736) = v8; /*0x7703*/
  if ( v9 ) /*0x770a*/
    v12 = (*(__int64 (__fastcall **)(__int64, __int64))(v11 + 40))(v11, v10); /*0x770c*/
  else
    v12 = (*(__int64 (__fastcall **)(__int64, __int64))(v11 + 32))(v11, v10); /*0x7711*/
  v13 = v12; /*0x7714*/
  if ( v12 < 0 ) /*0x771a*/
  {
    *(_QWORD *)(a1 + 736) = 0; /*0x771c*/
    DxeGetInfo_5(v8); /*0x7727*/
  }
  return v13; /*0x7739*/
}


// Function: ReadUnaligned64 @ 0x7740 (0x2f bytes)

__int64 __fastcall ReadUnaligned64(__int64 a1)
{
  if ( !a1 ) /*0x774c*/
    Assert_((__int64)"e:\\hs\\MdePkg\\Library\\BaseLib\\Unaligned.c", 192, (__int64)"Buffer != ((void *) 0)"); /*0x7761*/
  return *(_QWORD *)a1; /*0x7769*/
}