M-CTF-2025/neuralink/build/service/pseudocode_all.c

================================================================================
Function: .init_proc at 0x6000
================================================================================

__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}



================================================================================
Function: sub_6020 at 0x6020
================================================================================

void sub_6020()
{
  JUMPOUT(0);
}



================================================================================
Function: sub_6030 at 0x6030
================================================================================

void sub_6030()
{
  sub_6020();
}



================================================================================
Function: sub_6040 at 0x6040
================================================================================

void sub_6040()
{
  sub_6020();
}



================================================================================
Function: sub_6050 at 0x6050
================================================================================

void sub_6050()
{
  sub_6020();
}



================================================================================
Function: sub_6060 at 0x6060
================================================================================

void sub_6060()
{
  sub_6020();
}



================================================================================
Function: sub_6070 at 0x6070
================================================================================

void sub_6070()
{
  sub_6020();
}



================================================================================
Function: sub_6080 at 0x6080
================================================================================

void sub_6080()
{
  sub_6020();
}



================================================================================
Function: sub_6090 at 0x6090
================================================================================

void sub_6090()
{
  sub_6020();
}



================================================================================
Function: sub_60A0 at 0x60a0
================================================================================

void sub_60A0()
{
  sub_6020();
}



================================================================================
Function: sub_60B0 at 0x60b0
================================================================================

void sub_60B0()
{
  sub_6020();
}



================================================================================
Function: sub_60C0 at 0x60c0
================================================================================

void sub_60C0()
{
  sub_6020();
}



================================================================================
Function: sub_60D0 at 0x60d0
================================================================================

void sub_60D0()
{
  sub_6020();
}



================================================================================
Function: sub_60E0 at 0x60e0
================================================================================

void sub_60E0()
{
  sub_6020();
}



================================================================================
Function: sub_60F0 at 0x60f0
================================================================================

void sub_60F0()
{
  sub_6020();
}



================================================================================
Function: sub_6100 at 0x6100
================================================================================

void sub_6100()
{
  sub_6020();
}



================================================================================
Function: sub_6110 at 0x6110
================================================================================

void sub_6110()
{
  sub_6020();
}



================================================================================
Function: sub_6120 at 0x6120
================================================================================

void sub_6120()
{
  sub_6020();
}



================================================================================
Function: sub_6130 at 0x6130
================================================================================

void sub_6130()
{
  sub_6020();
}



================================================================================
Function: sub_6140 at 0x6140
================================================================================

void sub_6140()
{
  sub_6020();
}



================================================================================
Function: sub_6150 at 0x6150
================================================================================

void sub_6150()
{
  sub_6020();
}



================================================================================
Function: sub_6160 at 0x6160
================================================================================

void sub_6160()
{
  sub_6020();
}



================================================================================
Function: sub_6170 at 0x6170
================================================================================

void sub_6170()
{
  sub_6020();
}



================================================================================
Function: sub_6180 at 0x6180
================================================================================

void sub_6180()
{
  sub_6020();
}



================================================================================
Function: sub_6190 at 0x6190
================================================================================

void sub_6190()
{
  sub_6020();
}



================================================================================
Function: sub_61A0 at 0x61a0
================================================================================

void sub_61A0()
{
  sub_6020();
}



================================================================================
Function: sub_61B0 at 0x61b0
================================================================================

void sub_61B0()
{
  sub_6020();
}



================================================================================
Function: sub_61C0 at 0x61c0
================================================================================

void sub_61C0()
{
  sub_6020();
}



================================================================================
Function: sub_61D0 at 0x61d0
================================================================================

void sub_61D0()
{
  sub_6020();
}



================================================================================
Function: sub_61E0 at 0x61e0
================================================================================

void sub_61E0()
{
  sub_6020();
}



================================================================================
Function: sub_61F0 at 0x61f0
================================================================================

void sub_61F0()
{
  sub_6020();
}



================================================================================
Function: sub_6200 at 0x6200
================================================================================

void sub_6200()
{
  sub_6020();
}



================================================================================
Function: sub_6210 at 0x6210
================================================================================

void sub_6210()
{
  sub_6020();
}



================================================================================
Function: sub_6220 at 0x6220
================================================================================

void sub_6220()
{
  sub_6020();
}



================================================================================
Function: sub_6230 at 0x6230
================================================================================

void sub_6230()
{
  sub_6020();
}



================================================================================
Function: sub_6240 at 0x6240
================================================================================

void sub_6240()
{
  sub_6020();
}



================================================================================
Function: sub_6250 at 0x6250
================================================================================

void sub_6250()
{
  sub_6020();
}



================================================================================
Function: sub_6260 at 0x6260
================================================================================

void sub_6260()
{
  sub_6020();
}



================================================================================
Function: sub_6270 at 0x6270
================================================================================

void sub_6270()
{
  sub_6020();
}



================================================================================
Function: sub_6280 at 0x6280
================================================================================

void sub_6280()
{
  sub_6020();
}



================================================================================
Function: sub_6290 at 0x6290
================================================================================

void sub_6290()
{
  sub_6020();
}



================================================================================
Function: sub_62A0 at 0x62a0
================================================================================

void sub_62A0()
{
  sub_6020();
}



================================================================================
Function: sub_62B0 at 0x62b0
================================================================================

void sub_62B0()
{
  sub_6020();
}



================================================================================
Function: sub_62C0 at 0x62c0
================================================================================

void sub_62C0()
{
  sub_6020();
}



================================================================================
Function: sub_62D0 at 0x62d0
================================================================================

void sub_62D0()
{
  sub_6020();
}



================================================================================
Function: sub_62E0 at 0x62e0
================================================================================

void sub_62E0()
{
  sub_6020();
}



================================================================================
Function: sub_62F0 at 0x62f0
================================================================================

void sub_62F0()
{
  sub_6020();
}



================================================================================
Function: sub_6300 at 0x6300
================================================================================

void sub_6300()
{
  sub_6020();
}



================================================================================
Function: sub_6310 at 0x6310
================================================================================

void sub_6310()
{
  sub_6020();
}



================================================================================
Function: sub_6320 at 0x6320
================================================================================

void sub_6320()
{
  sub_6020();
}



================================================================================
Function: sub_6330 at 0x6330
================================================================================

void sub_6330()
{
  sub_6020();
}



================================================================================
Function: sub_6340 at 0x6340
================================================================================

void sub_6340()
{
  sub_6020();
}



================================================================================
Function: sub_6350 at 0x6350
================================================================================

void sub_6350()
{
  sub_6020();
}



================================================================================
Function: sub_6360 at 0x6360
================================================================================

void sub_6360()
{
  sub_6020();
}



================================================================================
Function: sub_6370 at 0x6370
================================================================================

void sub_6370()
{
  sub_6020();
}



================================================================================
Function: sub_6380 at 0x6380
================================================================================

void sub_6380()
{
  sub_6020();
}



================================================================================
Function: sub_6390 at 0x6390
================================================================================

void sub_6390()
{
  sub_6020();
}



================================================================================
Function: sub_63A0 at 0x63a0
================================================================================

void sub_63A0()
{
  sub_6020();
}



================================================================================
Function: sub_63B0 at 0x63b0
================================================================================

void sub_63B0()
{
  sub_6020();
}



================================================================================
Function: sub_63C0 at 0x63c0
================================================================================

void sub_63C0()
{
  sub_6020();
}



================================================================================
Function: sub_63D0 at 0x63d0
================================================================================

void sub_63D0()
{
  sub_6020();
}



================================================================================
Function: sub_63E0 at 0x63e0
================================================================================

void sub_63E0()
{
  sub_6020();
}



================================================================================
Function: sub_63F0 at 0x63f0
================================================================================

void sub_63F0()
{
  sub_6020();
}



================================================================================
Function: sub_6400 at 0x6400
================================================================================

void sub_6400()
{
  sub_6020();
}



================================================================================
Function: sub_6410 at 0x6410
================================================================================

void sub_6410()
{
  sub_6020();
}



================================================================================
Function: sub_6420 at 0x6420
================================================================================

void sub_6420()
{
  sub_6020();
}



================================================================================
Function: sub_6430 at 0x6430
================================================================================

void sub_6430()
{
  sub_6020();
}



================================================================================
Function: sub_6440 at 0x6440
================================================================================

void sub_6440()
{
  sub_6020();
}



================================================================================
Function: sub_6450 at 0x6450
================================================================================

void sub_6450()
{
  sub_6020();
}



================================================================================
Function: sub_6460 at 0x6460
================================================================================

void sub_6460()
{
  sub_6020();
}



================================================================================
Function: sub_6470 at 0x6470
================================================================================

void sub_6470()
{
  sub_6020();
}



================================================================================
Function: sub_6480 at 0x6480
================================================================================

void sub_6480()
{
  sub_6020();
}



================================================================================
Function: sub_6490 at 0x6490
================================================================================

void sub_6490()
{
  sub_6020();
}



================================================================================
Function: sub_64A0 at 0x64a0
================================================================================

void sub_64A0()
{
  sub_6020();
}



================================================================================
Function: sub_64B0 at 0x64b0
================================================================================

void sub_64B0()
{
  sub_6020();
}



================================================================================
Function: sub_64C0 at 0x64c0
================================================================================

void sub_64C0()
{
  sub_6020();
}



================================================================================
Function: sub_64D0 at 0x64d0
================================================================================

void sub_64D0()
{
  sub_6020();
}



================================================================================
Function: sub_64E0 at 0x64e0
================================================================================

void sub_64E0()
{
  sub_6020();
}



================================================================================
Function: sub_64F0 at 0x64f0
================================================================================

void sub_64F0()
{
  sub_6020();
}



================================================================================
Function: sub_6500 at 0x6500
================================================================================

void sub_6500()
{
  sub_6020();
}



================================================================================
Function: sub_6510 at 0x6510
================================================================================

void sub_6510()
{
  sub_6020();
}



================================================================================
Function: sub_6520 at 0x6520
================================================================================

void sub_6520()
{
  sub_6020();
}



================================================================================
Function: sub_6530 at 0x6530
================================================================================

void sub_6530()
{
  sub_6020();
}



================================================================================
Function: sub_6540 at 0x6540
================================================================================

void sub_6540()
{
  sub_6020();
}



================================================================================
Function: sub_6550 at 0x6550
================================================================================

void sub_6550()
{
  sub_6020();
}



================================================================================
Function: sub_6560 at 0x6560
================================================================================

void sub_6560()
{
  sub_6020();
}



================================================================================
Function: sub_6570 at 0x6570
================================================================================

void sub_6570()
{
  sub_6020();
}



================================================================================
Function: sub_6580 at 0x6580
================================================================================

void sub_6580()
{
  sub_6020();
}



================================================================================
Function: sub_6590 at 0x6590
================================================================================

void sub_6590()
{
  sub_6020();
}



================================================================================
Function: sub_65A0 at 0x65a0
================================================================================

void sub_65A0()
{
  sub_6020();
}



================================================================================
Function: sub_65B0 at 0x65b0
================================================================================

void sub_65B0()
{
  sub_6020();
}



================================================================================
Function: sub_65C0 at 0x65c0
================================================================================

void sub_65C0()
{
  sub_6020();
}



================================================================================
Function: sub_65D0 at 0x65d0
================================================================================

void sub_65D0()
{
  sub_6020();
}



================================================================================
Function: sub_65E0 at 0x65e0
================================================================================

void sub_65E0()
{
  sub_6020();
}



================================================================================
Function: sub_65F0 at 0x65f0
================================================================================

void sub_65F0()
{
  sub_6020();
}



================================================================================
Function: sub_6600 at 0x6600
================================================================================

void sub_6600()
{
  sub_6020();
}



================================================================================
Function: sub_6610 at 0x6610
================================================================================

void sub_6610()
{
  sub_6020();
}



================================================================================
Function: sub_6620 at 0x6620
================================================================================

void sub_6620()
{
  sub_6020();
}



================================================================================
Function: sub_6630 at 0x6630
================================================================================

void sub_6630()
{
  sub_6020();
}



================================================================================
Function: sub_6640 at 0x6640
================================================================================

void sub_6640()
{
  sub_6020();
}



================================================================================
Function: sub_6650 at 0x6650
================================================================================

void sub_6650()
{
  sub_6020();
}



================================================================================
Function: sub_6660 at 0x6660
================================================================================

void sub_6660()
{
  sub_6020();
}



================================================================================
Function: sub_6670 at 0x6670
================================================================================

void sub_6670()
{
  sub_6020();
}



================================================================================
Function: sub_6680 at 0x6680
================================================================================

void sub_6680()
{
  sub_6020();
}



================================================================================
Function: sub_6690 at 0x6690
================================================================================

void sub_6690()
{
  sub_6020();
}



================================================================================
Function: sub_66A0 at 0x66a0
================================================================================

void sub_66A0()
{
  sub_6020();
}



================================================================================
Function: sub_66B0 at 0x66b0
================================================================================

void sub_66B0()
{
  sub_6020();
}



================================================================================
Function: sub_66C0 at 0x66c0
================================================================================

void sub_66C0()
{
  sub_6020();
}



================================================================================
Function: sub_66D0 at 0x66d0
================================================================================

void sub_66D0()
{
  sub_6020();
}



================================================================================
Function: __cxa_finalize at 0x66e0
================================================================================

// attributes: thunk
int _cxa_finalize(void *a1)
{
  return __cxa_finalize(a1);
}



================================================================================
Function: ._ZSt24__throw_out_of_range_fmtPKcz at 0x66f0
================================================================================

// attributes: thunk
void __fastcall __noreturn std::__throw_out_of_range_fmt(const char *a1)
{
  _ZSt24__throw_out_of_range_fmtPKcz(a1);
}



================================================================================
Function: ._ZSt19__throw_logic_errorPKc at 0x6700
================================================================================

// attributes: thunk
void __fastcall __noreturn std::__throw_logic_error(const char *a1)
{
  _ZSt19__throw_logic_errorPKc(a1);
}



================================================================================
Function: ._ZN4pqxx8internal23check_pqxx_version_7_10Ev at 0x6710
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::internal::check_pqxx_version_7_10(pqxx::internal *this)
{
  return _ZN4pqxx8internal23check_pqxx_version_7_10Ev(this);
}



================================================================================
Function: .printf at 0x6720
================================================================================

// attributes: thunk
int printf(const char *format, ...)
{
  return printf(format);
}



================================================================================
Function: ._ZSt8to_charsPcS_fSt12chars_formati at 0x6730
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_fSt12chars_formati();
}



================================================================================
Function: .memcpy at 0x6740
================================================================================

// attributes: thunk
void *memcpy(void *dest, const void *src, size_t n)
{
  return memcpy(dest, src, n);
}



================================================================================
Function: ._ZSt17__throw_bad_allocv at 0x6750
================================================================================

// attributes: thunk
void __noreturn std::__throw_bad_alloc(void)
{
  _ZSt17__throw_bad_allocv();
}



================================================================================
Function: ._ZdlPvm at 0x6760
================================================================================

// attributes: thunk
void __fastcall operator delete(void *a1, unsigned __int64 a2)
{
  _ZdlPvm(a1, a2);
}



================================================================================
Function: ._ZNSt6locale7classicEv at 0x6770
================================================================================

// attributes: thunk
__int64 __fastcall std::locale::classic(std::locale *this)
{
  return _ZNSt6locale7classicEv(this);
}



================================================================================
Function: .frexpl at 0x6780
================================================================================

// attributes: thunk
long double frexpl(long double x, int *exponent)
{
  return frexpl(x, exponent);
}



================================================================================
Function: .sodium_init at 0x6790
================================================================================

// attributes: thunk
__int64 sodium_init()
{
  return sodium_init();
}



================================================================================
Function: ._Znwm at 0x67a0
================================================================================

// attributes: thunk
__int64 __fastcall operator new(unsigned __int64 a1)
{
  return _Znwm(a1);
}



================================================================================
Function: .memmove at 0x67b0
================================================================================

// attributes: thunk
void *memmove(void *dest, const void *src, size_t n)
{
  return memmove(dest, src, n);
}



================================================================================
Function: .crypto_hash_sha256 at 0x67c0
================================================================================

// attributes: thunk
__int64 crypto_hash_sha256()
{
  return crypto_hash_sha256();
}



================================================================================
Function: ._ZN4pqxx8internal17basic_transactionD2Ev at 0x67d0
================================================================================

// attributes: thunk
void __fastcall pqxx::internal::basic_transaction::~basic_transaction(pqxx::internal::basic_transaction *this)
{
  _ZN4pqxx8internal17basic_transactionD2Ev(this);
}



================================================================================
Function: .toupper at 0x67e0
================================================================================

// attributes: thunk
int toupper(int c)
{
  return toupper(c);
}



================================================================================
Function: ._ZNSt13random_device7_M_finiEv at 0x67f0
================================================================================

// attributes: thunk
__int64 __fastcall std::random_device::_M_fini(std::random_device *this)
{
  return _ZNSt13random_device7_M_finiEv(this);
}



================================================================================
Function: ._ZN4pqxx14argument_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x6800
================================================================================

// attributes: thunk
__int64 pqxx::argument_error::argument_error()
{
  return _ZN4pqxx14argument_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE();
}



================================================================================
Function: ._ZSt21__glibcxx_assert_failPKciS0_S0_ at 0x6810
================================================================================

// attributes: thunk
__int64 __fastcall std::__glibcxx_assert_fail(const char *a1, int a2, const char *a3, const char *a4)
{
  return _ZSt21__glibcxx_assert_failPKciS0_S0_(a1, a2, a3, a4);
}



================================================================================
Function: ._ZNK4pqxx3rowixEi at 0x6820
================================================================================

// attributes: thunk
__int64 pqxx::row::operator[]()
{
  return _ZNK4pqxx3rowixEi();
}



================================================================================
Function: ._ZN4pqxx16transaction_base6commitEv at 0x6830
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::transaction_base::commit(pqxx::transaction_base *this)
{
  return _ZN4pqxx16transaction_base6commitEv(this);
}



================================================================================
Function: ._ZSt8to_charsPcS_DF128_St12chars_formati at 0x6840
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_DF128_St12chars_formati();
}



================================================================================
Function: ._ZNSt13random_device9_M_getvalEv at 0x6850
================================================================================

// attributes: thunk
__int64 __fastcall std::random_device::_M_getval(std::random_device *this)
{
  return _ZNSt13random_device9_M_getvalEv(this);
}



================================================================================
Function: ._ZNKSt6localeeqERKS_ at 0x6860
================================================================================

// attributes: thunk
__int64 std::locale::operator==()
{
  return _ZNKSt6localeeqERKS_();
}



================================================================================
Function: ._ZNK4pqxx6result4sizeEv at 0x6870
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::result::size(pqxx::result *this)
{
  return _ZNK4pqxx6result4sizeEv(this);
}



================================================================================
Function: ._ZN4pqxx8internal18demangle_type_nameB5cxx11EPKc at 0x6880
================================================================================

// attributes: thunk
__int64 pqxx::internal::demangle_type_name[abi:cxx11]()
{
  return _ZN4pqxx8internal18demangle_type_nameB5cxx11EPKc();
}



================================================================================
Function: ._ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE at 0x6890
================================================================================

// attributes: thunk
__int64 std::operator<<<char>()
{
  return _ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE();
}



================================================================================
Function: ._ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev at 0x68a0
================================================================================

// attributes: thunk
__int64 std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream()
{
  return _ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev();
}



================================================================================
Function: .memset at 0x68b0
================================================================================

// attributes: thunk
void *memset(void *s, int c, size_t n)
{
  return memset(s, c, n);
}



================================================================================
Function: ._ZSt8to_charsPcS_fSt12chars_format at 0x68c0
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_fSt12chars_format();
}



================================================================================
Function: .__cxa_guard_acquire at 0x68d0
================================================================================

// attributes: thunk
int __cxa_guard_acquire(__guard *a1)
{
  return _cxa_guard_acquire(a1);
}



================================================================================
Function: ._ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev at 0x68e0
================================================================================

// attributes: thunk
__int64 std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
{
  return _ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev();
}



================================================================================
Function: ._ZNR4pqxx6params6appendERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x68f0
================================================================================

// attributes: thunk
__int64 pqxx::params::append()
{
  return _ZNR4pqxx6params6appendERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE();
}



================================================================================
Function: ._ZNSt16invalid_argumentD2Ev at 0x6900
================================================================================

// attributes: thunk
void __fastcall std::invalid_argument::~invalid_argument(std::invalid_argument *this)
{
  _ZNSt16invalid_argumentD2Ev(this);
}



================================================================================
Function: .__cxa_allocate_exception at 0x6910
================================================================================

// attributes: thunk
void *__cxa_allocate_exception(size_t thrown_size)
{
  return _cxa_allocate_exception(thrown_size);
}



================================================================================
Function: ._ZNK4pqxx5field7is_nullEv at 0x6920
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::field::is_null(pqxx::field *this)
{
  return _ZNK4pqxx5field7is_nullEv(this);
}



================================================================================
Function: .strlen at 0x6930
================================================================================

// attributes: thunk
size_t strlen(const char *s)
{
  return strlen(s);
}



================================================================================
Function: .__cxa_guard_abort at 0x6940
================================================================================

// attributes: thunk
void __cxa_guard_abort(__guard *a1)
{
  _cxa_guard_abort(a1);
}



================================================================================
Function: ._ZNSt13runtime_errorD2Ev at 0x6950
================================================================================

// attributes: thunk
void __fastcall std::runtime_error::~runtime_error(std::runtime_error *this)
{
  _ZNSt13runtime_errorD2Ev(this);
}



================================================================================
Function: .memchr at 0x6960
================================================================================

// attributes: thunk
void *memchr(const void *s, int c, size_t n)
{
  return memchr(s, c, n);
}



================================================================================
Function: ._ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE at 0x6970
================================================================================

// attributes: thunk
__int64 std::operator>><char>()
{
  return _ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE();
}



================================================================================
Function: ._ZSt8to_charsPcS_d at 0x6980
================================================================================

// attributes: thunk
__int64 __fastcall std::to_chars(char *a1, char *a2, double a3)
{
  return _ZSt8to_charsPcS_d(a1, a2, a3);
}



================================================================================
Function: ._ZSt28__throw_bad_array_new_lengthv at 0x6990
================================================================================

// attributes: thunk
__int64 std::__throw_bad_array_new_length(void)
{
  return _ZSt28__throw_bad_array_new_lengthv();
}



================================================================================
Function: ._ZSt8to_charsPcS_dSt12chars_format at 0x69a0
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_dSt12chars_format();
}



================================================================================
Function: ._ZNKR4pqxx5field5c_strEv at 0x69b0
================================================================================

// attributes: thunk
__int64 pqxx::field::c_str()
{
  return _ZNKR4pqxx5field5c_strEv();
}



================================================================================
Function: .fflush at 0x69c0
================================================================================

// attributes: thunk
int fflush(FILE *stream)
{
  return fflush(stream);
}



================================================================================
Function: .__gttf2 at 0x69d0
================================================================================

// attributes: thunk
__int64 __gttf2()
{
  return _gttf2();
}



================================================================================
Function: ._ZN4pqxx10connection4initEPKc at 0x69e0
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::connection::init(pqxx::connection *this, const char *a2)
{
  return _ZN4pqxx10connection4initEPKc(this, a2);
}



================================================================================
Function: ._ZNK4pqxx5field4sizeEv at 0x69f0
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::field::size(pqxx::field *this)
{
  return _ZNK4pqxx5field4sizeEv(this);
}



================================================================================
Function: ._ZNSi6ignoreEli at 0x6a00
================================================================================

// attributes: thunk
__int64 __fastcall std::istream::ignore(std::istream *this, __int64 a2, int a3)
{
  return _ZNSi6ignoreEli(this, a2, a3);
}



================================================================================
Function: ._ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw at 0x6a10
================================================================================

// attributes: thunk
__int64 std::operator<<<char,std::char_traits<char>>()
{
  return _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw();
}



================================================================================
Function: ._ZNKRSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv at 0x6a20
================================================================================

// attributes: thunk
__int64 std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str()
{
  return _ZNKRSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv();
}



================================================================================
Function: ._ZdlPv at 0x6a30
================================================================================

// attributes: thunk
void __fastcall operator delete(void *a1)
{
  _ZdlPv(a1);
}



================================================================================
Function: ._ZSt8to_charsPcS_eSt12chars_formati at 0x6a40
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_eSt12chars_formati();
}



================================================================================
Function: ._ZN4pqxx16transaction_base5closeEv at 0x6a50
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::transaction_base::close(pqxx::transaction_base *this)
{
  return _ZN4pqxx16transaction_base5closeEv(this);
}



================================================================================
Function: ._ZSt8to_charsPcS_DF128_ at 0x6a60
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_DF128_();
}



================================================================================
Function: .__cxa_guard_release at 0x6a70
================================================================================

// attributes: thunk
void __cxa_guard_release(__guard *a1)
{
  _cxa_guard_release(a1);
}



================================================================================
Function: ._ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc at 0x6a80
================================================================================

// attributes: thunk
__int64 std::operator<<<std::char_traits<char>>()
{
  return _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc();
}



================================================================================
Function: ._ZNKSt7__cxx118numpunctIcE8truenameEv at 0x6a90
================================================================================

// attributes: thunk
__int64 std::numpunct<char>::truename()
{
  return _ZNKSt7__cxx118numpunctIcE8truenameEv();
}



================================================================================
Function: ._ZSt8to_charsPcS_f at 0x6aa0
================================================================================

// attributes: thunk
__int64 __fastcall std::to_chars(char *a1, char *a2, float a3)
{
  return _ZSt8to_charsPcS_f(a1, a2, a3);
}



================================================================================
Function: .__isoc23_scanf at 0x6ab0
================================================================================

// attributes: thunk
__int64 __isoc23_scanf()
{
  return _isoc23_scanf();
}



================================================================================
Function: .__udivti3 at 0x6ac0
================================================================================

// attributes: thunk
__int64 __udivti3()
{
  return _udivti3();
}



================================================================================
Function: ._ZSt20__throw_length_errorPKc at 0x6ad0
================================================================================

// attributes: thunk
void __fastcall __noreturn std::__throw_length_error(const char *a1)
{
  _ZSt20__throw_length_errorPKc(a1);
}



================================================================================
Function: .__cxa_throw at 0x6ae0
================================================================================

// attributes: thunk
void __noreturn __cxa_throw(void *a1, struct type_info *lptinfo, void (*a3)(void *))
{
  _cxa_throw(a1, lptinfo, a3);
}



================================================================================
Function: ._ZN4pqxx8internal21throw_null_conversionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x6af0
================================================================================

// attributes: thunk
__int64 pqxx::internal::throw_null_conversion()
{
  return _ZN4pqxx8internal21throw_null_conversionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE();
}



================================================================================
Function: ._Unwind_Resume at 0x6b00
================================================================================

// attributes: thunk
void __noreturn _Unwind_Resume(struct _Unwind_Exception *a1)
{
  Unwind_Resume(a1);
}



================================================================================
Function: .exit at 0x6b10
================================================================================

// attributes: thunk
void __noreturn exit(int status)
{
  exit(status);
}



================================================================================
Function: ._ZNKSt7__cxx118numpunctIcE13decimal_pointEv at 0x6b20
================================================================================

// attributes: thunk
__int64 std::numpunct<char>::decimal_point()
{
  return _ZNKSt7__cxx118numpunctIcE13decimal_pointEv();
}



================================================================================
Function: ._ZSt8to_charsPcS_eSt12chars_format at 0x6b30
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_eSt12chars_format();
}



================================================================================
Function: ._ZNKSt6locale4nameB5cxx11Ev at 0x6b40
================================================================================

// attributes: thunk
__int64 std::locale::name[abi:cxx11]()
{
  return _ZNKSt6locale4nameB5cxx11Ev();
}



================================================================================
Function: ._ZSt8to_charsPcS_DF128_St12chars_format at 0x6b50
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_DF128_St12chars_format();
}



================================================================================
Function: ._ZNKRSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv at 0x6b60
================================================================================

// attributes: thunk
__int64 std::ostringstream::str()
{
  return _ZNKRSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv();
}



================================================================================
Function: ._ZNSt6localeC1ERKS_ at 0x6b70
================================================================================

// attributes: thunk
__int64 __fastcall std::locale::locale(std::locale *this, const std::locale *a2)
{
  return _ZNSt6localeC1ERKS_(this, a2);
}



================================================================================
Function: ._ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St8_SetfillIS3_E at 0x6b80
================================================================================

// attributes: thunk
__int64 std::operator<<<char,std::char_traits<char>>()
{
  return _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St8_SetfillIS3_E();
}



================================================================================
Function: ._ZSt9use_facetINSt7__cxx118numpunctIcEEERKT_RKSt6locale at 0x6b90
================================================================================

// attributes: thunk
__int64 std::use_facet<std::numpunct<char>>()
{
  return _ZSt9use_facetINSt7__cxx118numpunctIcEEERKT_RKSt6locale();
}



================================================================================
Function: .getenv at 0x6ba0
================================================================================

// attributes: thunk
char *getenv(const char *name)
{
  return getenv(name);
}



================================================================================
Function: ._ZN4pqxx16transaction_base20internal_exec_paramsESt17basic_string_viewIcSt11char_traitsIcEERKNS_8internal8c_paramsE at 0x6bb0
================================================================================

// attributes: thunk
__int64 pqxx::transaction_base::internal_exec_params()
{
  return _ZN4pqxx16transaction_base20internal_exec_paramsESt17basic_string_viewIcSt11char_traitsIcEERKNS_8internal8c_paramsE();
}



================================================================================
Function: ._ZNSt6localeC1Ev at 0x6bc0
================================================================================

// attributes: thunk
__int64 __fastcall std::locale::locale(std::locale *this)
{
  return _ZNSt6localeC1Ev(this);
}



================================================================================
Function: ._ZSt8to_charsPcS_dSt12chars_formati at 0x6bd0
================================================================================

// attributes: thunk
__int64 std::to_chars()
{
  return _ZSt8to_charsPcS_dSt12chars_formati();
}



================================================================================
Function: ._ZNKSt7__cxx118numpunctIcE8groupingEv at 0x6be0
================================================================================

// attributes: thunk
__int64 std::numpunct<char>::grouping()
{
  return _ZNKSt7__cxx118numpunctIcE8groupingEv();
}



================================================================================
Function: .__unordtf2 at 0x6bf0
================================================================================

// attributes: thunk
__int64 __unordtf2()
{
  return _unordtf2();
}



================================================================================
Function: ._ZNSolsEj at 0x6c00
================================================================================

// attributes: thunk
__int64 std::ostream::operator<<()
{
  return _ZNSolsEj();
}



================================================================================
Function: ._ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x6c10
================================================================================

// attributes: thunk
__int64 std::random_device::_M_init()
{
  return _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE();
}



================================================================================
Function: .__cxa_atexit at 0x6c20
================================================================================

// attributes: thunk
int __cxa_atexit(void (*lpfunc)(void *), void *obj, void *lpdso_handle)
{
  return _cxa_atexit(lpfunc, obj, lpdso_handle);
}



================================================================================
Function: .__cxa_free_exception at 0x6c30
================================================================================

// attributes: thunk
void __cxa_free_exception(void *a1)
{
  _cxa_free_exception(a1);
}



================================================================================
Function: ._ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev at 0x6c40
================================================================================

// attributes: thunk
__int64 std::ostringstream::~ostringstream()
{
  return _ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev();
}



================================================================================
Function: ._ZN4pqxx8internal17basic_transactionC2ERNS_10connectionENS_5zviewE at 0x6c50
================================================================================

// attributes: thunk
__int64 pqxx::internal::basic_transaction::basic_transaction()
{
  return _ZN4pqxx8internal17basic_transactionC2ERNS_10connectionENS_5zviewE();
}



================================================================================
Function: ._ZNKSt7__cxx118numpunctIcE13thousands_sepEv at 0x6c60
================================================================================

// attributes: thunk
__int64 std::numpunct<char>::thousands_sep()
{
  return _ZNKSt7__cxx118numpunctIcE13thousands_sepEv();
}



================================================================================
Function: ._ZNK4pqxx6params13make_c_paramsEv at 0x6c70
================================================================================

// attributes: thunk
__int64 __fastcall pqxx::params::make_c_params(pqxx::params *this)
{
  return _ZNK4pqxx6params13make_c_paramsEv(this);
}



================================================================================
Function: ._ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev at 0x6c80
================================================================================

// attributes: thunk
__int64 std::ostringstream::basic_ostringstream()
{
  return _ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev();
}



================================================================================
Function: ._ZNSi3getEv at 0x6c90
================================================================================

// attributes: thunk
__int64 __fastcall std::istream::get(std::istream *this)
{
  return _ZNSi3getEv(this);
}



================================================================================
Function: .frexp at 0x6ca0
================================================================================

// attributes: thunk
double frexp(double x, int *exponent)
{
  return frexp(x, exponent);
}



================================================================================
Function: .frexpf at 0x6cb0
================================================================================

// attributes: thunk
float frexpf(float x, int *exponent)
{
  return frexpf(x, exponent);
}



================================================================================
Function: ._ZNSt6localeD1Ev at 0x6cc0
================================================================================

// attributes: thunk
void __fastcall std::locale::~locale(std::locale *this)
{
  _ZNSt6localeD1Ev(this);
}



================================================================================
Function: .puts at 0x6cd0
================================================================================

// attributes: thunk
int puts(const char *s)
{
  return puts(s);
}



================================================================================
Function: ._ZNSolsEPFRSoS_E at 0x6ce0
================================================================================

// attributes: thunk
__int64 std::ostream::operator<<()
{
  return _ZNSolsEPFRSoS_E();
}



================================================================================
Function: ._ZNSt13runtime_errorC2EPKc at 0x6cf0
================================================================================

// attributes: thunk
__int64 __fastcall std::runtime_error::runtime_error(std::runtime_error *this, const char *a2)
{
  return _ZNSt13runtime_errorC2EPKc(this, a2);
}



================================================================================
Function: ._ZNSolsEm at 0x6d00
================================================================================

// attributes: thunk
__int64 std::ostream::operator<<()
{
  return _ZNSolsEm();
}



================================================================================
Function: .memcmp at 0x6d10
================================================================================

// attributes: thunk
int memcmp(const void *s1, const void *s2, size_t n)
{
  return memcmp(s1, s2, n);
}



================================================================================
Function: ._ZNK4pqxx6resultixEi at 0x6d20
================================================================================

// attributes: thunk
__int64 pqxx::result::operator[]()
{
  return _ZNK4pqxx6resultixEi();
}



================================================================================
Function: ._ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate at 0x6d30
================================================================================

// attributes: thunk
__int64 std::ios::clear()
{
  return _ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate();
}



================================================================================
Function: .__umodti3 at 0x6d40
================================================================================

// attributes: thunk
__int64 __umodti3()
{
  return _umodti3();
}



================================================================================
Function: ._ZNR4pqxx6params7reserveEm at 0x6d50
================================================================================

// attributes: thunk
__int64 pqxx::params::reserve()
{
  return _ZNR4pqxx6params7reserveEm();
}



================================================================================
Function: ._ZSt8to_charsPcS_e at 0x6d60
================================================================================

// attributes: thunk
__int64 __fastcall std::to_chars(char *a1, char *a2, long double a3)
{
  return _ZSt8to_charsPcS_e(a1, a2, a3);
}



================================================================================
Function: ._ZNKSt7__cxx118numpunctIcE9falsenameEv at 0x6d70
================================================================================

// attributes: thunk
__int64 std::numpunct<char>::falsename()
{
  return _ZNKSt7__cxx118numpunctIcE9falsenameEv();
}



================================================================================
Function: ._ZN4pqxx16transaction_base4execESt17basic_string_viewIcSt11char_traitsIcEES4_ at 0x6d80
================================================================================

// attributes: thunk
__int64 pqxx::transaction_base::exec()
{
  return _ZN4pqxx16transaction_base4execESt17basic_string_viewIcSt11char_traitsIcEES4_();
}



================================================================================
Function: ._ZNSolsEPFRSt8ios_baseS0_E at 0x6d90
================================================================================

// attributes: thunk
__int64 std::ostream::operator<<()
{
  return _ZNSolsEPFRSt8ios_baseS0_E();
}



================================================================================
Function: _start at 0x6da0
================================================================================

// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main((int (*)(int, char **, char **))main, v4, &retaddr, 0, 0, a3, &v5);
  __halt();
}



================================================================================
Function: deregister_tm_clones at 0x6dd0
================================================================================

void *deregister_tm_clones()
{
  return &edata;
}



================================================================================
Function: register_tm_clones at 0x6e00
================================================================================

__int64 register_tm_clones()
{
  return 0;
}



================================================================================
Function: __do_global_dtors_aux at 0x6e40
================================================================================

void *_do_global_dtors_aux()
{
  void *result; // rax

  if ( !completed_0 )
  {
    if ( &__cxa_finalize )
      _cxa_finalize(_dso_handle);
    result = deregister_tm_clones();
    completed_0 = 1;
  }
  return result;
}



================================================================================
Function: frame_dummy at 0x6e80
================================================================================

__int64 frame_dummy()
{
  return register_tm_clones();
}



================================================================================
Function: _Z9printLogov at 0x6e89
================================================================================

int printLogo(void)
{
  return puts(
           "\n"
           "    ********************************************************\n"
           "    *                                                      *\n"
           "    *         Welcome to Neuralink Chip Manager            *\n"
           "    *                                                      *\n"
           "    ********************************************************");
}



================================================================================
Function: _Z16clearInputBufferv at 0x6ea3
================================================================================

__int64 clearInputBuffer(void)
{
  __int64 v0; // rax

  std::ios::clear();
  v0 = std::numeric_limits<long>::max(&unk_38190, 0);
  return std::istream::ignore((std::istream *)&std::cin, v0, 10);
}



================================================================================
Function: _Z15printSystemDataNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEb at 0x6ee1
================================================================================

void __fastcall printSystemData(__int64 a1, char a2)
{
  _BYTE v2[32]; // [rsp+10h] [rbp-70h] BYREF
  _BYTE v3[32]; // [rsp+30h] [rbp-50h] BYREF
  _BYTE v4[40]; // [rsp+50h] [rbp-30h] BYREF

  if ( a2 )
  {
    std::operator+<char>(v3, "\n", a1);
    std::operator+<char>(v2, v3, "\n");
    std::operator<<<char>();
    std::ostream::operator<<();
    std::string::~string(v2);
    std::string::~string(v3);
  }
  else
  {
    std::operator+<char>(v4, a1, "\n");
    std::operator<<<char>();
    std::ostream::operator<<();
    std::string::~string(v4);
  }
}



================================================================================
Function: _Z15printSystemDataPKcb at 0x701d
================================================================================

int __fastcall printSystemData(const char *a1, char a2)
{
  if ( a2 )
    printf("\n%s\n", a1);
  else
    puts(a1);
  return fflush(stdout);
}



================================================================================
Function: _Z13initSodiumLibv at 0x7082
================================================================================

_BOOL8 initSodiumLib(void)
{
  return (int)sodium_init() >= 0;
}



================================================================================
Function: _Z17generateRandomIntv at 0x70a4
================================================================================

__int64 generateRandomInt(void)
{
  unsigned int v0; // eax

  if ( !(_BYTE)`guard variable for'generateRandomInt(void)::rd
    && __cxa_guard_acquire(&`guard variable for'generateRandomInt(void)::rd) )
  {
    std::random_device::random_device((std::random_device *)&generateRandomInt(void)::rd);
    __cxa_atexit(std::random_device::~random_device, &generateRandomInt(void)::rd, &_dso_handle);
    __cxa_guard_release(&`guard variable for'generateRandomInt(void)::rd);
  }
  if ( !(_BYTE)`guard variable for'generateRandomInt(void)::gen
    && __cxa_guard_acquire(&`guard variable for'generateRandomInt(void)::gen) )
  {
    v0 = std::random_device::operator()(&generateRandomInt(void)::rd);
    std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::mersenne_twister_engine(
      &generateRandomInt(void)::gen,
      v0);
    __cxa_guard_release(&`guard variable for'generateRandomInt(void)::gen);
  }
  if ( !(_BYTE)`guard variable for'generateRandomInt(void)::dis
    && __cxa_guard_acquire(&`guard variable for'generateRandomInt(void)::dis) )
  {
    std::uniform_int_distribution<int>::uniform_int_distribution(&generateRandomInt(void)::dis, 48, 57);
    __cxa_guard_release(&`guard variable for'generateRandomInt(void)::dis);
  }
  return std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
           &generateRandomInt(void)::dis,
           &generateRandomInt(void)::gen);
}



================================================================================
Function: _Z18generateRandomCharv at 0x7263
================================================================================

__int64 generateRandomChar(void)
{
  unsigned int v0; // eax

  if ( !(_BYTE)`guard variable for'generateRandomChar(void)::rd
    && __cxa_guard_acquire(&`guard variable for'generateRandomChar(void)::rd) )
  {
    std::random_device::random_device((std::random_device *)&generateRandomChar(void)::rd);
    __cxa_atexit(std::random_device::~random_device, &generateRandomChar(void)::rd, &_dso_handle);
    __cxa_guard_release(&`guard variable for'generateRandomChar(void)::rd);
  }
  if ( !(_BYTE)`guard variable for'generateRandomChar(void)::gen
    && __cxa_guard_acquire(&`guard variable for'generateRandomChar(void)::gen) )
  {
    v0 = std::random_device::operator()(&generateRandomChar(void)::rd);
    std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::mersenne_twister_engine(
      &generateRandomChar(void)::gen,
      v0);
    __cxa_guard_release(&`guard variable for'generateRandomChar(void)::gen);
  }
  if ( !(_BYTE)`guard variable for'generateRandomChar(void)::dis
    && __cxa_guard_acquire(&`guard variable for'generateRandomChar(void)::dis) )
  {
    std::uniform_int_distribution<int>::uniform_int_distribution(&generateRandomChar(void)::dis, 97, 122);
    __cxa_guard_release(&`guard variable for'generateRandomChar(void)::dis);
  }
  return std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
           &generateRandomChar(void)::dis,
           &generateRandomChar(void)::gen);
}



================================================================================
Function: _Z18makeUniqueUsernameRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x7422
================================================================================

__int64 __fastcall makeUniqueUsername(__int64 a1, __int64 a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  _BYTE v5[47]; // [rsp+10h] [rbp-70h] BYREF
  char v6; // [rsp+3Fh] [rbp-41h] BYREF
  _BYTE v7[40]; // [rsp+40h] [rbp-40h] BYREF
  char *v8; // [rsp+68h] [rbp-18h]

  v8 = &v6;
  std::string::basic_string<std::allocator<char>>(v5, 8, 0, &v6);
  v2 = std::string::end(v5);
  v3 = std::string::begin(v5);
  std::generate<__gnu_cxx::__normal_iterator<char *,std::string>,char (*)(void)>(v3, v2, generateRandomChar);
  std::operator+<char>(v7, a2, "_");
  std::operator+<char>(a1, v7, v5);
  std::string::~string(v7);
  std::string::~string(v5);
  return a1;
}



================================================================================
Function: _Z15makeNewPasswordB5cxx11v at 0x751b
================================================================================

__int64 __fastcall makeNewPassword[abi:cxx11](__int64 a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  char v4; // [rsp+17h] [rbp-19h] BYREF
  char *v5; // [rsp+18h] [rbp-18h]

  v5 = &v4;
  std::string::basic_string<std::allocator<char>>(a1, 8, 0, &v4);
  v1 = std::string::end(a1);
  v2 = std::string::begin(a1);
  std::generate<__gnu_cxx::__normal_iterator<char *,std::string>,char (*)(void)>(v2, v1, generateRandomChar);
  return a1;
}



================================================================================
Function: _Z12generateCodeB5cxx11v at 0x75b1
================================================================================

__int64 __fastcall generateCode[abi:cxx11](__int64 a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  char v4; // [rsp+17h] [rbp-19h] BYREF
  char *v5; // [rsp+18h] [rbp-18h]

  v5 = &v4;
  std::string::basic_string<std::allocator<char>>(a1, 3, 0, &v4);
  v1 = std::string::end(a1);
  v2 = std::string::begin(a1);
  std::generate<__gnu_cxx::__normal_iterator<char *,std::string>,char (*)(void)>(v2, v1, generateRandomInt);
  return a1;
}



================================================================================
Function: _Z12waitForInputv at 0x7647
================================================================================

__int64 waitForInput(void)
{
  printSystemData("Press any key to continue...", 1);
  clearInputBuffer();
  return std::istream::get((std::istream *)&std::cin);
}



================================================================================
Function: _Z12hashPasswordRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x767a
================================================================================

__int64 __fastcall hashPassword(__int64 a1, __int64 a2)
{
  __int64 v2; // rsi
  unsigned int i; // [rsp+1BCh] [rbp-14h]

  std::string::length(a2);
  std::string::c_str(a2);
  crypto_hash_sha256();
  std::ostringstream::basic_ostringstream();
  for ( i = 0; i <= 0x1F; ++i )
  {
    std::ostream::operator<<();
    v2 = (unsigned int)std::setw(2);
    std::operator<<<char,std::char_traits<char>>();
    std::setfill<char>(48, v2);
    std::operator<<<char,std::char_traits<char>>();
    std::ostream::operator<<();
  }
  std::ostringstream::str();
  std::ostringstream::~ostringstream();
  return a1;
}



================================================================================
Function: _ZnwmPv at 0x77a8
================================================================================

void *__fastcall operator new(unsigned __int64 a1, void *a2)
{
  return a2;
}



================================================================================
Function: _ZdlPvS_ at 0x77be
================================================================================

void __fastcall operator delete(void *a1, void *a2)
{
  ;
}



================================================================================
Function: _ZSt21is_constant_evaluatedv at 0x77d1
================================================================================

__int64 std::is_constant_evaluated(void)
{
  return 0;
}



================================================================================
Function: _ZNSt11char_traitsIcE6assignERcRKc at 0x77e0
================================================================================

_BYTE *__fastcall std::char_traits<char>::assign(_BYTE *a1, _BYTE *a2)
{
  _BYTE *result; // rax

  result = a1;
  *a1 = *a2;
  return result;
}



================================================================================
Function: _ZNSt11char_traitsIcE6lengthEPKc at 0x7822
================================================================================

size_t __fastcall std::char_traits<char>::length(const char *a1)
{
  return strlen(a1);
}



================================================================================
Function: _ZNSt11char_traitsIcE4copyEPcPKcm at 0x7858
================================================================================

void *__fastcall std::char_traits<char>::copy(void *a1, const void *a2, size_t a3)
{
  if ( a3 )
    return memcpy(a1, a2, a3);
  else
    return a1;
}



================================================================================
Function: _ZNSt11char_traitsIcE6assignEPcmc at 0x78bf
================================================================================

void *__fastcall std::char_traits<char>::assign(void *a1, size_t a2, char a3)
{
  if ( a2 )
    return memset(a1, a3, a2);
  else
    return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderD2Ev at 0x7920
================================================================================

__int64 __fastcall std::string::_Alloc_hider::~_Alloc_hider(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_M_local_dataEv at 0x7938
================================================================================

__int64 __fastcall std::string::_M_local_data(__int64 a1)
{
  return std::__ptr_traits_ptr_to<char *,char,false>::pointer_to(a1 + 16);
}



================================================================================
Function: _ZNSt19__ptr_traits_ptr_toIPccLb0EE10pointer_toERc at 0x795a
================================================================================

__int64 __fastcall std::__ptr_traits_ptr_to<char *,char,false>::pointer_to(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcOS3_ at 0x797e
================================================================================

_QWORD *__fastcall std::string::_Alloc_hider::_Alloc_hider(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZStanSt13_Ios_FmtflagsS_ at 0x79ca
================================================================================

__int64 __fastcall std::operator&(unsigned int a1, int a2)
{
  return a2 & a1;
}



================================================================================
Function: _ZStorSt13_Ios_FmtflagsS_ at 0x79e0
================================================================================

__int64 __fastcall std::operator|(unsigned int a1, int a2)
{
  return a2 | a1;
}



================================================================================
Function: _ZStcoSt13_Ios_Fmtflags at 0x79f6
================================================================================

__int64 __fastcall std::operator~(int a1)
{
  return (unsigned int)~a1;
}



================================================================================
Function: _ZStoRRSt13_Ios_FmtflagsS_ at 0x7a08
================================================================================

unsigned int *__fastcall std::operator|=(unsigned int *a1, int a2)
{
  *a1 = std::operator|(*a1, a2);
  return a1;
}



================================================================================
Function: _ZStaNRSt13_Ios_FmtflagsS_ at 0x7a39
================================================================================

unsigned int *__fastcall std::operator&=(unsigned int *a1, int a2)
{
  *a1 = std::operator&(*a1, a2);
  return a1;
}



================================================================================
Function: _ZNSt8ios_base4setfESt13_Ios_FmtflagsS0_ at 0x7a6a
================================================================================

__int64 __fastcall std::ios_base::setf(__int64 a1, unsigned int a2, int a3)
{
  int v3; // eax
  int v4; // eax
  unsigned int v7; // [rsp+1Ch] [rbp-4h]

  v7 = *(_DWORD *)(a1 + 24);
  v3 = std::operator~(a3);
  std::operator&=((unsigned int *)(a1 + 24), v3);
  v4 = std::operator&(a2, a3);
  std::operator|=((unsigned int *)(a1 + 24), v4);
  return v7;
}



================================================================================
Function: _ZSt3hexRSt8ios_base at 0x7ad0
================================================================================

__int64 __fastcall std::hex(__int64 a1)
{
  std::ios_base::setf(a1, 8u, 74);
  return a1;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv at 0x7afc
================================================================================

__int64 __fastcall std::string::size(__int64 a1)
{
  __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = *(_QWORD *)(a1 + 8);
  std::string::max_size(a1);
  return v2;
}



================================================================================
Function: _ZSt4setwi at 0x7b33
================================================================================

__int64 __fastcall std::setw(unsigned int a1)
{
  return a1;
}



================================================================================
Function: _ZNSt14numeric_limitsIlE3maxEv at 0x7b43
================================================================================

__int64 std::numeric_limits<long>::max()
{
  return 0x7FFFFFFFFFFFFFFFLL;
}



================================================================================
Function: _ZNSt13random_deviceC2Ev at 0x7b58
================================================================================

void __fastcall std::random_device::random_device(std::random_device *this)
{
  _BYTE v1[39]; // [rsp+10h] [rbp-40h] BYREF
  char v2; // [rsp+37h] [rbp-19h] BYREF
  char *v3; // [rsp+38h] [rbp-18h]

  v3 = &v2;
  std::string::basic_string<std::allocator<char>>(v1, "default", &v2);
  std::random_device::_M_init();
  std::string::~string(v1);
}



================================================================================
Function: _ZNSt13random_deviceD2Ev at 0x7bda
================================================================================

void __fastcall std::random_device::~random_device(std::random_device *a1)
{
  std::random_device::_M_fini(a1);
}



================================================================================
Function: _ZNSt13random_deviceclEv at 0x7bfa
================================================================================

__int64 __fastcall std::random_device::operator()(std::random_device *a1)
{
  return std::random_device::_M_getval(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEmcRKS3_ at 0x7c18
================================================================================

__int64 __fastcall std::string::basic_string<std::allocator<char>>(__int64 a1, __int64 a2, char a3, __int64 a4)
{
  __int64 v4; // rax

  v4 = std::string::_M_local_data(a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v4, a4);
  return std::string::_M_construct(a1, a2, (unsigned int)a3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_Alloc_hiderC2EPcRKS3_ at 0x7c98
================================================================================

_QWORD *__fastcall std::string::_Alloc_hider::_Alloc_hider(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc at 0x7cdc
================================================================================

__int64 __fastcall std::string::_M_construct(__int64 a1, unsigned __int64 a2, char a3)
{
  __int64 v3; // rax
  unsigned __int64 v4; // rbx
  __int64 v5; // rax
  unsigned __int64 v8; // [rsp+10h] [rbp-30h] BYREF
  __int64 v9; // [rsp+18h] [rbp-28h]
  unsigned __int64 i; // [rsp+20h] [rbp-20h]
  __int64 v11; // [rsp+28h] [rbp-18h]

  v9 = a1;
  v8 = a2;
  if ( a2 <= 0xF )
  {
    v11 = v9;
    if ( (unsigned __int8)std::is_constant_evaluated() )
    {
      for ( i = 0; i <= 0xF; ++i )
        *(_BYTE *)(v11 + i + 16) = 0;
    }
  }
  else
  {
    v3 = std::string::_M_create(v9, &v8, 0);
    std::string::_M_data(v9, v3);
    std::string::_M_capacity(v9, v8);
  }
  if ( v8 )
  {
    v4 = v8;
    v5 = std::string::_M_data(v9);
    std::string::_S_assign(v5, v4, (unsigned int)a3);
  }
  return std::string::_M_set_length(v9, v8);
}



================================================================================
Function: _ZSt12construct_atIcJRKcEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S2_pispcl7declvalIT0_EEEEEPS2_S5_DpOS4_ at 0x7dc4
================================================================================

_BYTE *__fastcall ZSt12construct_atIcJRKcEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S2_pispcl7declvalIT0_EEEEEPS2_S5_DpOS4_(
        void *a1,
        _BYTE *a2)
{
  _BYTE *v2; // rbx

  v2 = operator new(1u, a1);
  *v2 = *a2;
  return v2;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE6lengthEPKc at 0x7e28
================================================================================

__int64 __fastcall __gnu_cxx::char_traits<char>::length(__int64 a1)
{
  char v2; // [rsp+17h] [rbp-9h] BYREF
  __int64 i; // [rsp+18h] [rbp-8h]

  for ( i = 0; ; ++i )
  {
    v2 = 0;
    if ( (unsigned __int8)__gnu_cxx::char_traits<char>::eq(i + a1, &v2) == 1 )
      break;
  }
  return i;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE4copyEPcPKcm at 0x7e72
================================================================================

void *__fastcall __gnu_cxx::char_traits<char>::copy(void *a1, const void *a2, size_t a3)
{
  if ( a3 )
    memcpy(a1, a2, a3);
  return a1;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE6assignEPcmc at 0x7f04
================================================================================

void *__fastcall __gnu_cxx::char_traits<char>::assign(void *a1, size_t a2, unsigned __int8 a3)
{
  unsigned __int8 v4; // [rsp+Ch] [rbp-24h]
  size_t n; // [rsp+10h] [rbp-20h]
  void *s; // [rsp+18h] [rbp-18h]
  unsigned __int8 v7; // [rsp+27h] [rbp-9h]

  s = a1;
  n = a2;
  v4 = a3;
  if ( a2 )
  {
    v7 = v4;
    memset(s, v4, n);
  }
  return s;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv at 0x7f8c
================================================================================

__int64 __fastcall std::string::c_str(__int64 a1)
{
  return std::string::_M_data(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_M_set_lengthEm at 0x7faa
================================================================================

_BYTE *__fastcall std::string::_M_set_length(__int64 a1, __int64 a2)
{
  __int64 v2; // rax
  char v4; // [rsp+1Fh] [rbp-1h] BYREF

  std::string::_M_length(a1, a2);
  v4 = 0;
  v2 = std::string::_M_data(a1);
  return std::char_traits<char>::assign((_BYTE *)(v2 + a2), &v4);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev at 0x7ffa
================================================================================

void __fastcall std::string::~string(__int64 a1)
{
  std::string::_M_dispose(a1);
  std::string::_Alloc_hider::~_Alloc_hider(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EOS4_ at 0x8026
================================================================================

_BYTE *__fastcall std::string::basic_string(_QWORD *a1, __int64 a2)
{
  __int64 v2; // rsi
  __int64 v3; // rax
  __int64 v4; // rax
  __int64 v5; // rax
  __int64 v6; // rax
  unsigned __int64 j; // [rsp+10h] [rbp-40h]
  unsigned __int64 i; // [rsp+28h] [rbp-28h]

  std::string::_M_get_allocator(a2);
  v2 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v2);
  if ( (unsigned __int8)std::string::_M_is_local(a2) )
  {
    if ( (unsigned __int8)std::is_constant_evaluated() )
    {
      for ( i = 0; i <= 0xF; ++i )
        *((_BYTE *)a1 + i + 16) = 0;
    }
    v3 = std::string::length(a2);
    std::char_traits<char>::copy(a1 + 2, (const void *)(a2 + 16), v3 + 1);
  }
  else
  {
    v4 = std::string::_M_data(a2);
    std::string::_M_data(a1, v4);
    std::string::_M_capacity(a1, *(_QWORD *)(a2 + 16));
  }
  v5 = std::string::length(a2);
  std::string::_M_length(a1, v5);
  if ( (unsigned __int8)std::is_constant_evaluated() )
  {
    for ( j = 0; j <= 0xF; ++j )
      *(_BYTE *)(a2 + j + 16) = 0;
  }
  v6 = std::string::_M_local_data(a2);
  std::string::_M_data(a2, v6);
  return std::string::_M_set_length(a2, 0);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16_M_get_allocatorEv at 0x81b6
================================================================================

__int64 __fastcall std::string::_M_get_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZSt3minImERKT_S2_S2_ at 0x81c8
================================================================================

_QWORD *__fastcall std::min<unsigned long>(_QWORD *a1, _QWORD *a2)
{
  if ( *a2 >= *a1 )
    return a1;
  else
    return a2;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8max_sizeEv at 0x81f8
================================================================================

__int64 std::string::max_size()
{
  __int64 v1; // [rsp+10h] [rbp-10h] BYREF
  __int64 v2; // [rsp+18h] [rbp-8h] BYREF

  v2 = 0x7FFFFFFFFFFFFFFFLL;
  v1 = -1;
  return *std::min<unsigned long>(&v2, &v1) - 1LL;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_ at 0x823a
================================================================================

__int64 __fastcall std::string::basic_string<std::allocator<char>>(_QWORD *a1, const char *a2)
{
  __int64 v2; // rax
  size_t v3; // rax

  v2 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v2);
  if ( !a2 )
    std::__throw_logic_error("basic_string: construction from null is not valid");
  v3 = std::char_traits<char>::length(a2);
  return std::string::_M_construct<char const*>(a1, a2, &a2[v3]);
}



================================================================================
Function: _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_ at 0x82e2
================================================================================

__int64 __fastcall std::operator+<char>(__int64 a1, const char *a2, __int64 a3)
{
  __int64 v3; // r12
  __int64 v4; // rbx
  size_t v5; // rax
  _BYTE v8[17]; // [rsp+2Fh] [rbp-11h] BYREF

  std::string::get_allocator(v8, a3);
  v3 = std::string::size(a3);
  v4 = std::string::c_str(a3);
  v5 = std::char_traits<char>::length(a2);
  std::__str_concat<std::string>(a1, a2, v5, v4, v3, v8);
  return a1;
}



================================================================================
Function: _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_ at 0x8378
================================================================================

_QWORD *__fastcall std::operator+<char>(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 v4; // [rsp+28h] [rbp-8h]

  v4 = std::string::append(a2, a3);
  std::string::basic_string(a1, v4);
  return a1;
}



================================================================================
Function: _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_PKS5_ at 0x83c0
================================================================================

__int64 __fastcall std::operator+<char>(__int64 a1, __int64 a2, const char *a3)
{
  size_t v3; // r12
  __int64 v4; // rbx
  __int64 v5; // rax
  _BYTE v8[17]; // [rsp+2Fh] [rbp-11h] BYREF

  std::string::get_allocator(v8, a2);
  v3 = std::char_traits<char>::length(a3);
  v4 = std::string::size(a2);
  v5 = std::string::c_str(a2);
  std::__str_concat<std::string>(a1, v5, v4, a3, v3, v8);
  return a1;
}



================================================================================
Function: _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEC2Em at 0x845a
================================================================================

__int64 __fastcall std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::mersenne_twister_engine(
        __int64 a1,
        __int64 a2)
{
  return std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::seed(
           a1,
           a2);
}



================================================================================
Function: _ZNSt24uniform_int_distributionIiEC2Eii at 0x8484
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::uniform_int_distribution(
        __int64 a1,
        unsigned int a2,
        unsigned int a3)
{
  return std::uniform_int_distribution<int>::param_type::param_type(a1, a2, a3);
}



================================================================================
Function: _ZNSt24uniform_int_distributionIiEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEiRT_ at 0x84b2
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
        __int64 a1,
        __int64 a2)
{
  return std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm at 0x84e0
================================================================================

__int64 __fastcall std::string::_M_create(__int64 a1, __int64 *a2, unsigned __int64 a3)
{
  unsigned __int64 v3; // rbx
  unsigned __int64 v4; // rbx
  __int64 v5; // rbx
  __int64 allocator; // rax

  v3 = *a2;
  if ( std::string::max_size() < v3 )
    std::__throw_length_error("basic_string::_M_create");
  if ( a3 < *a2 && *a2 < 2 * a3 )
  {
    *a2 = 2 * a3;
    v4 = *a2;
    if ( std::string::max_size() < v4 )
      *a2 = std::string::max_size();
  }
  v5 = *a2 + 1;
  allocator = std::string::_M_get_allocator(a1);
  return std::string::_S_allocate(allocator, v5);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7_M_dataEPc at 0x85ac
================================================================================

_QWORD *__fastcall std::string::_M_data(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_capacityEm at 0x85ca
================================================================================

__int64 __fastcall std::string::_M_capacity(__int64 a1, __int64 a2)
{
  __int64 result; // rax

  result = a1;
  *(_QWORD *)(a1 + 16) = a2;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_S_assignEPcmc at 0x85e9
================================================================================

_BYTE *__fastcall std::string::_S_assign(_BYTE *a1, size_t a2, char a3)
{
  char v4[4]; // [rsp+Ch] [rbp-14h] BYREF
  size_t v5; // [rsp+10h] [rbp-10h]
  _BYTE *v6; // [rsp+18h] [rbp-8h]

  v6 = a1;
  v5 = a2;
  v4[0] = a3;
  if ( a2 == 1 )
    return std::char_traits<char>::assign(v6, v4);
  else
    return std::char_traits<char>::assign(v6, v5, v4[0]);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7_M_dataEv at 0x863c
================================================================================

__int64 __fastcall std::string::_M_data(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv at 0x8652
================================================================================

__int64 __fastcall std::string::begin(__int64 a1)
{
  return std::string::_M_data(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv at 0x8682
================================================================================

__int64 __fastcall std::string::end(__int64 a1)
{
  __int64 v1; // rbx

  v1 = std::string::_M_data(a1);
  return v1 + std::string::size(a1);
}



================================================================================
Function: _ZSt8generateIN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEPFcvEEvT_SC_T0_ at 0x86c8
================================================================================

__int64 __fastcall std::generate<__gnu_cxx::__normal_iterator<char *,std::string>,char (*)(void)>(
        __int64 a1,
        __int64 a2,
        __int64 (*a3)(void))
{
  int v3; // eax
  __int64 result; // rax
  __int64 v6; // [rsp+10h] [rbp-20h] BYREF
  _QWORD v7[3]; // [rsp+18h] [rbp-18h] BYREF

  v7[0] = a1;
  v6 = a2;
  while ( 1 )
  {
    v7[2] = v7;
    v7[1] = &v6;
    v3 = v6;
    LOBYTE(v3) = v7[0] == v6;
    result = v3 ^ 1u;
    if ( !(_BYTE)result )
      break;
    *(_BYTE *)v7[0]++ = a3();
  }
  return result;
}



================================================================================
Function: _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_ at 0x872a
================================================================================

_QWORD *__fastcall std::operator+<char>(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 v4; // [rsp+28h] [rbp-8h]

  v4 = std::string::append(a2, a3);
  std::string::basic_string(a1, v4);
  return a1;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv at 0x8772
================================================================================

__int64 __fastcall std::string::length(__int64 a1)
{
  return std::string::size(a1);
}



================================================================================
Function: _ZSt7setfillIcESt8_SetfillIT_ES1_ at 0x8790
================================================================================

__int64 __fastcall std::setfill<char>(unsigned __int8 a1)
{
  return a1;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE2eqERKcS3_ at 0x87a3
================================================================================

bool __fastcall __gnu_cxx::char_traits<char>::eq(_BYTE *a1, _BYTE *a2)
{
  return *a1 == *a2;
}



================================================================================
Function: _ZSt12construct_atIcJRcEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S1_pispcl7declvalIT0_EEEEEPS1_S4_DpOS3_ at 0x87c8
================================================================================

_BYTE *__fastcall ZSt12construct_atIcJRcEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S1_pispcl7declvalIT0_EEEEEPS1_S4_DpOS3_(
        void *a1,
        _BYTE *a2)
{
  _BYTE *v2; // rbx

  v2 = operator new(1u, a1);
  *v2 = *a2;
  return v2;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_lengthEm at 0x882c
================================================================================

__int64 __fastcall std::string::_M_length(__int64 a1, __int64 a2)
{
  __int64 result; // rax

  result = a1;
  *(_QWORD *)(a1 + 8) = a2;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv at 0x884c
================================================================================

__int64 __fastcall std::string::_M_dispose(__int64 a1)
{
  __int64 result; // rax

  result = (unsigned int)std::string::_M_is_local(a1) ^ 1;
  if ( (_BYTE)result )
    return std::string::_M_destroy(a1, *(_QWORD *)(a1 + 16));
  return result;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8capacityEv at 0x888a
================================================================================

unsigned __int64 __fastcall std::string::capacity(__int64 a1)
{
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  if ( (unsigned __int8)std::string::_M_is_local(a1) )
    v2 = 15;
  else
    v2 = *(_QWORD *)(a1 + 16);
  if ( v2 > 0xE )
    std::string::max_size();
  return v2;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_is_localEv at 0x88ee
================================================================================

_BOOL8 __fastcall std::string::_M_is_local(__int64 a1)
{
  __int64 v1; // rbx

  v1 = std::string::_M_data(a1);
  return v1 == std::string::_M_local_data(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm at 0x8942
================================================================================

__int64 __fastcall std::string::reserve(_QWORD *a1, unsigned __int64 a2)
{
  __int64 result; // rax
  __int64 v3; // rbx
  __int64 v4; // rax
  unsigned __int64 v5; // [rsp+0h] [rbp-30h] BYREF
  _QWORD *v6; // [rsp+8h] [rbp-28h]
  __int64 v7; // [rsp+10h] [rbp-20h]
  unsigned __int64 v8; // [rsp+18h] [rbp-18h]

  v6 = a1;
  v5 = a2;
  v8 = std::string::capacity((__int64)a1);
  result = a2;
  if ( v8 < a2 )
  {
    v7 = std::string::_M_create((__int64)v6, (__int64 *)&v5, v8);
    v3 = std::string::length((__int64)v6) + 1;
    v4 = std::string::_M_data((__int64)v6);
    std::string::_S_copy(v7, v4, v3);
    std::string::_M_dispose((__int64)v6);
    std::string::_M_data(v6, v7);
    return std::string::_M_capacity((__int64)v6, v5);
  }
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE16_M_get_allocatorEv at 0x89fc
================================================================================

__int64 __fastcall std::string::_M_get_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tagEN6_GuardC2EPS4_ at 0x8a0e
================================================================================

_QWORD *__fastcall std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)::_Guard::_Guard(
        _QWORD *a1,
        __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tagEN6_GuardD2Ev at 0x8a2c
================================================================================

__int64 __fastcall std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)::_Guard::~_Guard(
        __int64 *a1)
{
  __int64 result; // rax

  result = *a1;
  if ( *a1 )
    return std::string::_M_dispose(*a1);
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag at 0x8a5a
================================================================================

__int64 __fastcall std::string::_M_construct<char const*>(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 v3; // rax
  __int64 v4; // rax
  __int64 v7; // [rsp+38h] [rbp-48h] BYREF
  __int64 v8; // [rsp+40h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+48h] [rbp-38h]
  _QWORD *v10; // [rsp+50h] [rbp-30h]
  __int64 v11; // [rsp+58h] [rbp-28h]
  __int64 v12; // [rsp+60h] [rbp-20h]
  __int64 v13; // [rsp+68h] [rbp-18h]

  v13 = a3;
  v12 = a2;
  v11 = a3;
  v8 = a3 - a2;
  if ( (unsigned __int64)(a3 - a2) <= 0xF )
  {
    v10 = a1;
    if ( (unsigned __int8)std::is_constant_evaluated() )
    {
      for ( i = 0; i <= 0xF; ++i )
        *((_BYTE *)v10 + i + 16) = 0;
    }
  }
  else
  {
    v3 = std::string::_M_create((__int64)a1, &v8, 0);
    std::string::_M_data(a1, v3);
    std::string::_M_capacity((__int64)a1, v8);
  }
  std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)::_Guard::_Guard(
    &v7,
    (__int64)a1);
  v4 = std::string::_M_data((__int64)a1);
  std::string::_S_copy_chars<char const*>(v4, a2, a3);
  v7 = 0;
  std::string::_M_set_length((__int64)a1, v8);
  return std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)::_Guard::~_Guard(&v7);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13get_allocatorEv at 0x8ba6
================================================================================

__int64 __fastcall std::string::get_allocator(__int64 a1, __int64 a2)
{
  std::string::_M_get_allocator(a2);
  return a1;
}



================================================================================
Function: _ZSt12__str_concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEET_PKNS6_10value_typeENS6_9size_typeES9_SA_RKNS6_14allocator_typeE at 0x8beb
================================================================================

_QWORD *__fastcall std::__str_concat<std::string>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  char v10; // [rsp+3Fh] [rbp-41h] BYREF
  __int64 v11; // [rsp+40h] [rbp-40h]
  char *v12; // [rsp+48h] [rbp-38h]
  __int64 v13; // [rsp+50h] [rbp-30h]
  char *v14; // [rsp+58h] [rbp-28h]
  __int64 v15; // [rsp+60h] [rbp-20h]
  __int64 v16; // [rsp+68h] [rbp-18h]

  v16 = a6;
  v15 = a6;
  v14 = &v10;
  v13 = a6;
  v12 = &v10;
  v11 = a6;
  std::string::basic_string(a1, &v10);
  std::string::reserve(a1, a5 + a3);
  std::string::append(a1, a2, a3);
  std::string::append(a1, a4, a5);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc at 0x8cca
================================================================================

__int64 __fastcall std::string::append(__int64 a1, const char *a2)
{
  size_t v3; // [rsp+18h] [rbp-8h]

  v3 = std::char_traits<char>::length(a2);
  std::string::_M_check_length(a1, 0, v3, "basic_string::append");
  return std::string::_M_append(a1, a2, v3);
}



================================================================================
Function: _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE4seedEm at 0x8d24
================================================================================

_QWORD *__fastcall std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::seed(
        _QWORD *a1,
        __int64 a2)
{
  __int64 v2; // rax
  _QWORD *result; // rax
  __int64 v4; // [rsp+10h] [rbp-10h]
  unsigned __int64 i; // [rsp+18h] [rbp-8h]

  *a1 = std::__detail::__mod<unsigned long,4294967296ul,1ul,0ul>(a2);
  for ( i = 1; i <= 0x26F; ++i )
  {
    v4 = 1812433253LL * ((a1[i - 1] >> 30) ^ a1[i - 1]);
    v2 = std::__detail::__mod<unsigned long,624ul,1ul,0ul>(i);
    a1[i] = std::__detail::__mod<unsigned long,4294967296ul,1ul,0ul>(v2 + v4);
  }
  result = a1;
  a1[624] = 624;
  return result;
}



================================================================================
Function: _ZNSt24uniform_int_distributionIiE10param_typeC2Eii at 0x8dce
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::param_type::param_type(_DWORD *a1, int a2, int a3)
{
  __int64 result; // rax

  *a1 = a2;
  a1[1] = a3;
  result = *a1 > a1[1];
  if ( *a1 > a1[1] )
    return std::__glibcxx_assert_fail(
             "/usr/include/c++/15/bits/uniform_int_dist.h",
             108,
             "std::uniform_int_distribution<_IntType>::param_type::param_type(_IntType, _IntType) [with _IntType = int]",
             "_M_a <= _M_b");
  return result;
}



================================================================================
Function: _ZNSt24uniform_int_distributionIiEclISt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEEEiRT_RKNS0_10param_typeE at 0x8e36
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  __int64 v3; // rbx
  __int64 v4; // rax
  int v5; // eax
  _DWORD v8[3]; // [rsp+24h] [rbp-5Ch] BYREF
  unsigned __int64 v9; // [rsp+30h] [rbp-50h]
  unsigned __int64 v10; // [rsp+38h] [rbp-48h]
  __int64 v11; // [rsp+40h] [rbp-40h]
  unsigned __int64 v12; // [rsp+48h] [rbp-38h]
  __int64 v13; // [rsp+50h] [rbp-30h]
  __int64 v14; // [rsp+58h] [rbp-28h]
  __int64 v15; // [rsp+60h] [rbp-20h]
  unsigned __int64 v16; // [rsp+68h] [rbp-18h]

  v15 = 0;
  v14 = 0xFFFFFFFFLL;
  v13 = 0xFFFFFFFFLL;
  v3 = (int)std::uniform_int_distribution<int>::param_type::b(a3);
  v12 = v3 - (int)std::uniform_int_distribution<int>::param_type::a(a3);
  if ( v12 > 0xFFFFFFFE )
  {
    if ( v12 <= 0xFFFFFFFF )
    {
      v16 = std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::operator()(a2);
    }
    else
    {
      do
      {
        do
        {
          v11 = 0x100000000LL;
          std::uniform_int_distribution<int>::param_type::param_type(v8, 0, SHIDWORD(v12));
          v10 = (__int64)(int)std::uniform_int_distribution<int>::operator()<std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>>(
                                a1,
                                a2,
                                v8) << 32;
          v4 = std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::operator()(a2);
          v16 = v10 + v4;
        }
        while ( v12 < v10 + v4 );
      }
      while ( v16 < v10 );
    }
  }
  else
  {
    v9 = v12 + 1;
    v8[2] = v12 + 1;
    v16 = (unsigned int)std::uniform_int_distribution<int>::_S_nd<unsigned long,std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>,unsigned int>(
                          a2,
                          (unsigned int)(v12 + 1));
  }
  v5 = std::uniform_int_distribution<int>::param_type::a(a3);
  return (unsigned int)(v5 + v16);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_S_allocateERS3_m at 0x8f73
================================================================================

__int64 __fastcall std::string::_S_allocate(__int64 a1, __int64 a2)
{
  return std::__new_allocator<char>::allocate(a1, a2, 0);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendERKS4_ at 0x8ffc
================================================================================

__int64 __fastcall std::string::append(__int64 a1, __int64 a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax

  v2 = std::string::size(a2);
  v3 = std::string::_M_data(a2);
  return std::string::append(a1, v3, v2);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_destroyEm at 0x9048
================================================================================

__int64 __fastcall std::string::_M_destroy(__int64 a1, __int64 a2)
{
  __int64 allocator; // [rsp+20h] [rbp-30h]
  __int64 v4; // [rsp+30h] [rbp-20h]

  v4 = std::string::_M_data(a1);
  allocator = std::string::_M_get_allocator(a1);
  return std::__new_allocator<char>::deallocate(allocator, v4, a2 + 1);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_M_local_dataEv at 0x90e0
================================================================================

__int64 __fastcall std::string::_M_local_data(__int64 a1)
{
  return std::__ptr_traits_ptr_to<char const*,char const,false>::pointer_to(a1 + 16);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7_S_copyEPcPKcm at 0x9102
================================================================================

_BYTE *__fastcall std::string::_S_copy(_BYTE *a1, _BYTE *a2, size_t a3)
{
  if ( a3 == 1 )
    return std::char_traits<char>::assign(a1, a2);
  else
    return std::char_traits<char>::copy(a1, a2, a3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13_S_copy_charsIPKcEEvPcT_S9_ at 0x9150
================================================================================

_BYTE *__fastcall std::string::_S_copy_chars<char const*>(_BYTE *a1, _BYTE *a2, __int64 a3)
{
  return std::string::_S_copy(a1, a2, a3 - (_QWORD)a2);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS3_ at 0x9192
================================================================================

_BYTE *__fastcall std::string::basic_string(_QWORD *a1)
{
  __int64 v1; // rax
  unsigned __int64 i; // [rsp+10h] [rbp-20h]

  v1 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v1);
  if ( (unsigned __int8)std::is_constant_evaluated() )
  {
    for ( i = 0; i <= 0xF; ++i )
      *((_BYTE *)a1 + i + 16) = 0;
  }
  return std::string::_M_set_length((__int64)a1, 0);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKcm at 0x921e
================================================================================

__int64 __fastcall std::string::append(__int64 a1, __int64 a2, __int64 a3)
{
  std::string::_M_check_length(a1, 0, a3, "basic_string::append");
  return std::string::_M_append(a1, a2, a3);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE15_M_check_lengthEmmPKc at 0x926c
================================================================================

bool __fastcall std::string::_M_check_length(__int64 a1, __int64 a2, unsigned __int64 a3, const char *a4)
{
  __int64 v4; // rbx
  bool result; // al

  v4 = std::string::max_size();
  result = v4 + a2 - std::string::size(a1) < a3;
  if ( result )
    std::__throw_length_error(a4);
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm at 0x92ce
================================================================================

__int64 __fastcall std::string::_M_append(__int64 a1, _BYTE *a2, size_t a3)
{
  __int64 v3; // rbx
  __int64 v4; // rax
  __int64 v5; // rax
  unsigned __int64 v8; // [rsp+28h] [rbp-18h]

  v8 = a3 + std::string::size(a1);
  if ( std::string::capacity(a1) < v8 )
  {
    v5 = std::string::size(a1);
    std::string::_M_mutate(a1, v5, 0, a2, a3);
  }
  else if ( a3 )
  {
    v3 = std::string::_M_data(a1);
    v4 = std::string::size(a1);
    std::string::_S_copy((_BYTE *)(v3 + v4), a2, a3);
  }
  std::string::_M_set_length(a1, v8);
  return a1;
}



================================================================================
Function: _ZNSt8__detail5__modImLm4294967296ELm1ELm0EEET_S1_ at 0x939b
================================================================================

__int64 __fastcall std::__detail::__mod<unsigned long,4294967296ul,1ul,0ul>(__int64 a1)
{
  return std::__detail::_Mod<unsigned long,4294967296ul,1ul,0ul,true,true>::__calc(a1);
}



================================================================================
Function: _ZNSt8__detail5__modImLm624ELm1ELm0EEET_S1_ at 0x93b9
================================================================================

__int64 __fastcall std::__detail::__mod<unsigned long,624ul,1ul,0ul>(__int64 a1)
{
  return std::__detail::_Mod<unsigned long,624ul,1ul,0ul,true,true>::__calc(a1);
}



================================================================================
Function: _ZNKSt24uniform_int_distributionIiE10param_type1bEv at 0x93d8
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::param_type::b(__int64 a1)
{
  return *(unsigned int *)(a1 + 4);
}



================================================================================
Function: _ZNKSt24uniform_int_distributionIiE10param_type1aEv at 0x93ee
================================================================================

__int64 __fastcall std::uniform_int_distribution<int>::param_type::a(unsigned int *a1)
{
  return *a1;
}



================================================================================
Function: _ZNSt24uniform_int_distributionIiE5_S_ndImSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEjEET1_RT0_S4_ at 0x9402
================================================================================

unsigned __int64 __fastcall std::uniform_int_distribution<int>::_S_nd<unsigned long,std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>,unsigned int>(
        __int64 a1,
        unsigned int a2)
{
  __int64 v2; // rax
  __int64 v3; // rax
  unsigned int v5; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v2 = std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::operator()(a1);
  v6 = a2 * v2;
  v5 = a2 * v2;
  if ( a2 * (unsigned int)v2 < a2 )
  {
    while ( v5 < -a2 % a2 )
    {
      v3 = std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::operator()(a1);
      v6 = a2 * v3;
      v5 = a2 * v3;
    }
  }
  return HIDWORD(v6);
}



================================================================================
Function: _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EEclEv at 0x947e
================================================================================

unsigned __int64 __fastcall std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::operator()(
        __int64 a1)
{
  __int64 v1; // rax
  unsigned __int64 v3; // [rsp+18h] [rbp-8h]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  if ( *(_QWORD *)(a1 + 4992) > 0x26Fu )
    std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::_M_gen_rand(a1);
  v1 = *(_QWORD *)(a1 + 4992);
  *(_QWORD *)(a1 + 4992) = v1 + 1;
  v3 = (unsigned int)(*(_QWORD *)(a1 + 8 * v1) >> 11) ^ *(_QWORD *)(a1 + 8 * v1);
  v4 = ((((_DWORD)v3 << 7) & 0x9D2C5680 ^ (unsigned int)v3) << 15) & 0xEFC60000 ^ ((_DWORD)v3 << 7) & 0x9D2C5680 ^ v3;
  return (v4 >> 18) ^ v4;
}



================================================================================
Function: _ZNSt19__ptr_traits_ptr_toIPKcS0_Lb0EE10pointer_toERS0_ at 0x9515
================================================================================

__int64 __fastcall std::__ptr_traits_ptr_to<char const*,char const,false>::pointer_to(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm at 0x9538
================================================================================

__int64 __fastcall std::string::_M_mutate(_QWORD *a1, size_t a2, __int64 a3, _BYTE *a4, size_t a5)
{
  unsigned __int64 v5; // rax
  _BYTE *v6; // rax
  __int64 v7; // rax
  __int64 v12; // [rsp+38h] [rbp-18h] BYREF
  _BYTE *v13; // [rsp+40h] [rbp-10h]
  size_t v14; // [rsp+48h] [rbp-8h]

  v14 = std::string::length((__int64)a1) - a2 - a3;
  v12 = a5 + std::string::length((__int64)a1) - a3;
  v5 = std::string::capacity((__int64)a1);
  v13 = (_BYTE *)std::string::_M_create((__int64)a1, &v12, v5);
  if ( a2 )
  {
    v6 = (_BYTE *)std::string::_M_data((__int64)a1);
    std::string::_S_copy(v13, v6, a2);
  }
  if ( a4 && a5 )
    std::string::_S_copy(&v13[a2], a4, a5);
  if ( v14 )
  {
    v7 = std::string::_M_data((__int64)a1);
    std::string::_S_copy(&v13[a5 + a2], (_BYTE *)(v7 + a2 + a3), v14);
  }
  std::string::_M_dispose((__int64)a1);
  std::string::_M_data(a1, (__int64)v13);
  return std::string::_M_capacity((__int64)a1, v12);
}



================================================================================
Function: _ZNSt8__detail4_ModImLm4294967296ELm1ELm0ELb1ELb1EE6__calcEm at 0x9680
================================================================================

__int64 __fastcall std::__detail::_Mod<unsigned long,4294967296ul,1ul,0ul,true,true>::__calc(unsigned int a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail4_ModImLm624ELm1ELm0ELb1ELb1EE6__calcEm at 0x96a3
================================================================================

unsigned __int64 __fastcall std::__detail::_Mod<unsigned long,624ul,1ul,0ul,true,true>::__calc(unsigned __int64 a1)
{
  return a1 % 0x270;
}



================================================================================
Function: _ZNSt23mersenne_twister_engineImLm32ELm624ELm397ELm31ELm2567483615ELm11ELm4294967295ELm7ELm2636928640ELm15ELm4022730752ELm18ELm1812433253EE11_M_gen_randEv at 0x96ec
================================================================================

__int64 __fastcall std::mersenne_twister_engine<unsigned long,32ul,624ul,397ul,31ul,2567483615ul,11ul,4294967295ul,7ul,2636928640ul,15ul,4022730752ul,18ul,1812433253ul>::_M_gen_rand(
        __int64 a1)
{
  __int64 v1; // rax
  __int64 v2; // rax
  __int64 v3; // rax
  __int64 result; // rax
  unsigned __int64 j; // [rsp+38h] [rbp-10h]
  unsigned __int64 i; // [rsp+40h] [rbp-8h]

  for ( i = 0; i <= 0xE2; ++i )
  {
    if ( (*(_BYTE *)(a1 + 8 * (i + 1)) & 1) != 0 )
      v1 = 2567483615LL;
    else
      v1 = 0;
    *(_QWORD *)(a1 + 8 * i) = *(_QWORD *)(a1 + 8 * (i + 397))
                            ^ ((*(_QWORD *)(a1 + 8 * i) & 0xFFFFFFFF80000000LL
                              | *(_QWORD *)(a1 + 8 * (i + 1)) & 0x7FFFFFFFLL) >> 1)
                            ^ v1;
  }
  for ( j = 227; j <= 0x26E; ++j )
  {
    if ( (*(_BYTE *)(a1 + 8 * (j + 1)) & 1) != 0 )
      v2 = 2567483615LL;
    else
      v2 = 0;
    *(_QWORD *)(a1 + 8 * j) = *(_QWORD *)(a1 + 8 * (j - 227))
                            ^ ((*(_QWORD *)(a1 + 8 * j) & 0xFFFFFFFF80000000LL
                              | *(_QWORD *)(a1 + 8 * (j + 1)) & 0x7FFFFFFFLL) >> 1)
                            ^ v2;
  }
  if ( (*(_BYTE *)a1 & 1) != 0 )
    v3 = 2567483615LL;
  else
    v3 = 0;
  *(_QWORD *)(a1 + 4984) = v3
                         ^ *(_QWORD *)(a1 + 3168)
                         ^ ((*(_QWORD *)(a1 + 4984) & 0xFFFFFFFF80000000LL | *(_QWORD *)a1 & 0x7FFFFFFFLL) >> 1);
  result = a1;
  *(_QWORD *)(a1 + 4992) = 0;
  return result;
}



================================================================================
Function: _ZNSt15__new_allocatorIcE8allocateEmPKv at 0x98a6
================================================================================

__int64 __fastcall std::__new_allocator<char>::allocate(__int64 a1, unsigned __int64 a2)
{
  if ( a2 > 0x7FFFFFFFFFFFFFFFLL )
    std::__throw_bad_alloc();
  return operator new(a2);
}



================================================================================
Function: _ZNSt15__new_allocatorIcE10deallocateEPcm at 0x98f8
================================================================================

void __fastcall std::__new_allocator<char>::deallocate(__int64 a1, void *a2, unsigned __int64 a3)
{
  operator delete(a2, a3);
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm at 0x9925
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm at 0x9941
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(exception, (struct type_info *)&`typeinfo for'pqxx::argument_error, pqxx::argument_error::~argument_error);
}



================================================================================
Function: _Z12settingsMenuv at 0x9b71
================================================================================

void settingsMenu(void)
{
  while ( 1 )
  {
    printSystemData("--- Settings menu ---", 1);
    printSystemData("1. Change password", 0);
    printSystemData("2. Show security code", 0);
    printSystemData("3. Return to previous menu", 0);
    printf("Choose an option (1-3): ");
    fflush(stdout);
    __isoc23_scanf();
    clearInputBuffer();
    printSystemData("Invalid option selected.", 1);
  }
}



================================================================================
Function: _Z14changePasswordv at 0x9c9b
================================================================================

void changePassword(void)
{
  char v0; // bl
  const char *v1; // rax
  const char *v2; // rax
  _BYTE v3[32]; // [rsp+0h] [rbp-90h] BYREF
  _BYTE v4[32]; // [rsp+20h] [rbp-70h] BYREF
  _BYTE v5[32]; // [rsp+40h] [rbp-50h] BYREF
  _BYTE v6[40]; // [rsp+60h] [rbp-30h] BYREF

  std::string::basic_string(v3);
  makeNewPassword[abi:cxx11]((__int64)v4);
  std::string::operator=(v3, v4);
  std::string::~string((__int64)v4);
  std::string::basic_string(v5, v3);
  std::string::basic_string(v6, &USERNAME[abi:cxx11]);
  v0 = dbChangePassword(v6, v5);
  std::string::~string((__int64)v6);
  std::string::~string((__int64)v5);
  if ( v0 )
  {
    printSystemData("Changing password...", 1);
    printSystemData("---Your new credentials ---", 1);
    v1 = (const char *)std::string::c_str((__int64)&USERNAME[abi:cxx11]);
    printf("Username: %s\n", v1);
    v2 = (const char *)std::string::c_str((__int64)v3);
    printf("Password: %s\n", v2);
    printSystemData("Use this credentials to gain access to the system.", 1);
  }
  else
  {
    printSystemData("Unexpected error. Please try later.", 1);
  }
  waitForInput();
  std::string::~string((__int64)v3);
}



================================================================================
Function: _Z8showCodev at 0x9e54
================================================================================

void showCode(void)
{
  const char *v0; // rax
  _BYTE v1[32]; // [rsp+0h] [rbp-70h] BYREF
  _BYTE v2[32]; // [rsp+20h] [rbp-50h] BYREF
  _BYTE v3[40]; // [rsp+40h] [rbp-30h] BYREF

  std::string::basic_string(v1);
  std::string::basic_string(v3, &USERNAME[abi:cxx11]);
  dbGetSecurityCode(v2, v3);
  std::string::operator=(v1, v2);
  std::string::~string((__int64)v2);
  std::string::~string((__int64)v3);
  if ( (unsigned __int8)std::operator==<char>(v1, &unk_273F4) != 1 )
  {
    v0 = (const char *)std::string::c_str((__int64)v1);
    printf("Security code: %s\n", v0);
  }
  else
  {
    printSystemData("Unexpected error. Please try later.", 1);
  }
  std::string::~string((__int64)v1);
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v at 0x9f61
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z12settingsMenuv at 0xa0dc
================================================================================

int GLOBAL__sub_I__Z12settingsMenuv()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: _ZNSt11char_traitsIcE2ltERKcS2_ at 0xa0eb
================================================================================

bool __fastcall std::char_traits<char>::lt(_BYTE *a1, _BYTE *a2)
{
  return *a1 < *a2;
}



================================================================================
Function: _ZNSt11char_traitsIcE7compareEPKcS2_m at 0xa112
================================================================================

int __fastcall std::char_traits<char>::compare(const void *a1, const void *a2, size_t a3)
{
  if ( a3 )
    return memcmp(a1, a2, a3);
  else
    return 0;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EvQ26is_default_constructible_vIT1_E at 0xa1d6
================================================================================

_BYTE *__fastcall std::string::basic_string(_QWORD *a1)
{
  __int64 v1; // rax
  char v3; // [rsp+17h] [rbp-29h] BYREF
  char *v4; // [rsp+18h] [rbp-28h]
  unsigned __int64 i; // [rsp+20h] [rbp-20h]
  _QWORD *v6; // [rsp+28h] [rbp-18h]

  v4 = &v3;
  v1 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v1);
  v6 = a1;
  if ( (unsigned __int8)std::is_constant_evaluated() )
  {
    for ( i = 0; i <= 0xF; ++i )
      *((_BYTE *)v6 + i + 16) = 0;
  }
  return std::string::_M_set_length((__int64)a1, 0);
}



================================================================================
Function: _ZNKSt9type_info4nameEv at 0xa26a
================================================================================

__int64 __fastcall std::type_info::name(std::type_info *this)
{
  if ( **((_BYTE **)this + 1) == 42 )
    return *((_QWORD *)this + 1) + 1LL;
  else
    return *((_QWORD *)this + 1);
}



================================================================================
Function: _ZN4pqxx14argument_errorD2Ev at 0xa29e
================================================================================

void __fastcall pqxx::argument_error::~argument_error(std::invalid_argument *a1)
{
  *(_QWORD *)a1 = off_37828;
  std::invalid_argument::~invalid_argument(a1);
}



================================================================================
Function: _ZN4pqxx14argument_errorD0Ev at 0xa2cc
================================================================================

void __fastcall pqxx::argument_error::~argument_error(pqxx::argument_error *this)
{
  pqxx::argument_error::~argument_error(this);
  operator delete(this, 0x10u);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_ at 0xa2fc
================================================================================

__int64 __fastcall std::string::basic_string(_QWORD *a1, __int64 a2)
{
  __int64 v2; // rax
  __int64 v3; // rbx
  __int64 v4; // rax
  char v6; // [rsp+1Fh] [rbp-41h] BYREF
  __int64 v7; // [rsp+20h] [rbp-40h]
  char *v8; // [rsp+28h] [rbp-38h]
  __int64 v9; // [rsp+30h] [rbp-30h]
  char *v10; // [rsp+38h] [rbp-28h]
  __int64 v11; // [rsp+40h] [rbp-20h]
  __int64 allocator; // [rsp+48h] [rbp-18h]

  allocator = std::string::_M_get_allocator(a2);
  v11 = allocator;
  v10 = &v6;
  v9 = allocator;
  v8 = &v6;
  v7 = allocator;
  v2 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v2);
  v3 = std::string::length(a2);
  v4 = std::string::_M_data(a2);
  return std::string::_M_construct<true>(a1, v4, v3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5clearEv at 0xa3ca
================================================================================

_BYTE *__fastcall std::string::clear(__int64 a1)
{
  return std::string::_M_set_length(a1, 0);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_ at 0xa3ee
================================================================================

_QWORD *__fastcall std::string::operator=(_QWORD *a1, _QWORD *a2)
{
  size_t v2; // r12
  _BYTE *v3; // rbx
  _BYTE *v4; // rax
  __int64 v5; // rax
  __int64 v6; // rax
  __int64 v7; // rax
  __int64 v8; // rax
  unsigned __int64 i; // [rsp+10h] [rbp-60h]
  __int64 v11; // [rsp+50h] [rbp-20h]
  __int64 v12; // [rsp+58h] [rbp-18h]

  std::string::_M_is_local((__int64)a1);
  std::string::_M_get_allocator((__int64)a2);
  std::string::_M_get_allocator((__int64)a1);
  if ( std::string::_M_is_local((__int64)a2) )
  {
    if ( a1 != a2 )
    {
      if ( std::string::size((__int64)a2) )
      {
        v2 = std::string::size((__int64)a2);
        v3 = (_BYTE *)std::string::_M_data((__int64)a2);
        v4 = (_BYTE *)std::string::_M_data((__int64)a1);
        std::string::_S_copy(v4, v3, v2);
      }
      v5 = std::string::size((__int64)a2);
      std::string::_M_set_length((__int64)a1, v5);
    }
  }
  else
  {
    v12 = 0;
    if ( !std::string::_M_is_local((__int64)a1) )
    {
      v12 = std::string::_M_data((__int64)a1);
      v11 = a1[2];
    }
    v6 = std::string::_M_data((__int64)a2);
    std::string::_M_data(a1, v6);
    v7 = std::string::length((__int64)a2);
    std::string::_M_length((__int64)a1, v7);
    std::string::_M_capacity((__int64)a1, a2[2]);
    if ( v12 )
    {
      std::string::_M_data(a2, v12);
      std::string::_M_capacity((__int64)a2, v11);
    }
    else
    {
      if ( (unsigned __int8)std::is_constant_evaluated() )
      {
        for ( i = 0; i <= 0xF; ++i )
          *((_BYTE *)a2 + i + 16) = 0;
      }
      v8 = std::string::_M_local_data((__int64)a2);
      std::string::_M_data(a2, v8);
    }
  }
  std::string::clear((__int64)a2);
  return a1;
}



================================================================================
Function: _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_ at 0xa69c
================================================================================

_BOOL8 __fastcall std::operator==<char>(__int64 a1, const void *a2)
{
  __int64 v2; // rbx
  size_t v3; // rbx
  const void *v4; // rax
  _BOOL8 result; // rax

  v2 = std::string::size(a1);
  result = 0;
  if ( v2 == std::char_traits<char>::length((const char *)a2) )
  {
    v3 = std::string::size(a1);
    v4 = (const void *)std::string::data(a1);
    if ( !std::char_traits<char>::compare(v4, a2, v3) )
      return 1;
  }
  return result;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4dataEv at 0xa718
================================================================================

__int64 __fastcall std::string::data(__int64 a1)
{
  return std::string::_M_data(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructILb1EEEvPKcm at 0xa736
================================================================================

__int64 __fastcall std::string::_M_construct<true>(_QWORD *a1, _BYTE *a2, unsigned __int64 a3)
{
  __int64 v3; // rax
  size_t v4; // rbx
  _BYTE *v5; // rax
  unsigned __int64 v7; // [rsp+8h] [rbp-48h] BYREF
  _BYTE *v8; // [rsp+10h] [rbp-40h]
  _QWORD *v9; // [rsp+18h] [rbp-38h]
  unsigned __int64 i; // [rsp+30h] [rbp-20h]
  _QWORD *v11; // [rsp+38h] [rbp-18h]

  v9 = a1;
  v8 = a2;
  v7 = a3;
  if ( a3 <= 0xF )
  {
    v11 = v9;
    if ( (unsigned __int8)std::is_constant_evaluated() )
    {
      for ( i = 0; i <= 0xF; ++i )
        *((_BYTE *)v11 + i + 16) = 0;
    }
  }
  else
  {
    v3 = std::string::_M_create((__int64)v9, (__int64 *)&v7, 0);
    std::string::_M_data(v9, v3);
    std::string::_M_capacity((__int64)v9, v7);
  }
  v4 = v7 + 1;
  v5 = (_BYTE *)std::string::_M_data((__int64)v9);
  std::string::_S_copy(v5, v8, v4);
  return std::string::_M_length((__int64)v9, v7);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_assignERKS4_ at 0xa816
================================================================================

unsigned __int8 __fastcall std::string::_M_assign(_QWORD *a1, __int64 a2)
{
  unsigned __int8 result; // al
  _BYTE *v3; // rbx
  _BYTE *v4; // rax
  __int64 v5[2]; // [rsp+18h] [rbp-38h] BYREF
  __int64 v6; // [rsp+28h] [rbp-28h]
  unsigned __int64 v7; // [rsp+30h] [rbp-20h]
  unsigned __int64 v8; // [rsp+38h] [rbp-18h]

  v5[1] = a2;
  result = a1 != (_QWORD *)a2;
  if ( a1 != (_QWORD *)a2 )
  {
    v8 = std::string::length(a2);
    v7 = std::string::capacity((__int64)a1);
    if ( v7 < v8 )
    {
      v5[0] = v8;
      v6 = std::string::_M_create((__int64)a1, v5, v7);
      std::string::_M_dispose((__int64)a1);
      std::string::_M_data(a1, v6);
      std::string::_M_capacity((__int64)a1, v5[0]);
    }
    if ( v8 )
    {
      v3 = (_BYTE *)std::string::_M_data(a2);
      v4 = (_BYTE *)std::string::_M_data((__int64)a1);
      std::string::_S_copy(v4, v3, v8);
    }
    return (unsigned __int8)std::string::_M_set_length((__int64)a1, v8);
  }
  return result;
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm_0 at 0xa916
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm_0 at 0xa932
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'pqxx::argument_error,
    (void (*)(void *))pqxx::argument_error::~argument_error);
}



================================================================================
Function: _Z12implantsMenuv at 0xab62
================================================================================

void implantsMenu(void)
{
  while ( 1 )
  {
    printSystemData("--- Implants menu ---", 1);
    printSystemData("1. Add new implant", 0);
    printSystemData("2. Delete implant", 0);
    printSystemData("3. Show info about implant", 0);
    printSystemData("4. Return to previous menu", 0);
    printf("Choose an option (1-4): ");
    fflush(stdout);
    __isoc23_scanf();
    clearInputBuffer();
    printSystemData("Invalid option selected.", 1);
  }
}



================================================================================
Function: _Z10addImplantv at 0xacb1
================================================================================

void addImplant(void)
{
  _QWORD v0[4]; // [rsp+0h] [rbp-B0h] BYREF
  _QWORD v1[4]; // [rsp+20h] [rbp-90h] BYREF
  _QWORD v2[4]; // [rsp+40h] [rbp-70h] BYREF
  _QWORD v3[4]; // [rsp+60h] [rbp-50h] BYREF
  _QWORD v4[5]; // [rsp+80h] [rbp-30h] BYREF

  std::string::basic_string(v1);
  std::string::basic_string(v0);
  printf("\nEnter implant name: ");
  std::operator>><char>();
  printf("\nEnter implant info: ");
  std::operator>><char>();
  std::string::basic_string(v2, (__int64)&USERNAME[abi:cxx11]);
  std::string::basic_string(v3, (__int64)v0);
  std::string::basic_string(v4, (__int64)v1);
  dbAddImplant(v4, v3, v2);
  std::string::~string((__int64)v4);
  std::string::~string((__int64)v3);
  std::string::~string((__int64)v2);
  std::string::~string((__int64)v0);
  std::string::~string((__int64)v1);
}



================================================================================
Function: _Z13deleteImplantv at 0xae4b
================================================================================

void deleteImplant(void)
{
  char UserImplants; // bl
  char v1; // bl
  _QWORD v2[4]; // [rsp+0h] [rbp-B0h] BYREF
  _QWORD v3[4]; // [rsp+20h] [rbp-90h] BYREF
  _QWORD v4[4]; // [rsp+40h] [rbp-70h] BYREF
  _QWORD v5[4]; // [rsp+60h] [rbp-50h] BYREF
  _QWORD v6[5]; // [rsp+80h] [rbp-30h] BYREF

  std::string::basic_string(v2);
  printSystemData("Getting list of implants. Please wait...", 1);
  std::string::basic_string(v3, (__int64)&USERNAME[abi:cxx11]);
  UserImplants = dbGetUserImplants(v3);
  std::string::~string((__int64)v3);
  if ( UserImplants )
  {
    printf("\nEnter implant name: ");
    fflush(stdout);
    std::operator>><char>();
    std::string::basic_string(v4, (__int64)v2);
    std::string::basic_string(v5, (__int64)&USERNAME[abi:cxx11]);
    v1 = dbCheckOwnerImplant(v5, v4);
    std::string::~string((__int64)v5);
    std::string::~string((__int64)v4);
    if ( v1 )
    {
      printSystemData("Deleting implant...", 1);
      std::string::basic_string(v6, (__int64)v2);
      dbDeleteImplant(v6);
      std::string::~string((__int64)v6);
    }
    else
    {
      printSystemData("Invalid option selected.", 1);
    }
  }
  std::string::~string((__int64)v2);
}



================================================================================
Function: _Z15showInfoImplantv at 0xb03f
================================================================================

void showInfoImplant(void)
{
  char UserImplants; // bl
  char v1; // bl
  _QWORD v2[4]; // [rsp+0h] [rbp-B0h] BYREF
  _QWORD v3[4]; // [rsp+20h] [rbp-90h] BYREF
  _QWORD v4[4]; // [rsp+40h] [rbp-70h] BYREF
  _QWORD v5[4]; // [rsp+60h] [rbp-50h] BYREF
  _QWORD v6[5]; // [rsp+80h] [rbp-30h] BYREF

  std::string::basic_string(v2);
  printSystemData("Getting list of implants. Please wait...", 1);
  std::string::basic_string(v3, (__int64)&USERNAME[abi:cxx11]);
  UserImplants = dbGetUserImplants(v3);
  std::string::~string((__int64)v3);
  if ( UserImplants )
  {
    printf("\nEnter implant name: ");
    fflush(stdout);
    std::operator>><char>();
    std::string::basic_string(v4, (__int64)v2);
    std::string::basic_string(v5, (__int64)&USERNAME[abi:cxx11]);
    v1 = dbCheckOwnerImplant(v5, v4);
    std::string::~string((__int64)v5);
    std::string::~string((__int64)v4);
    if ( v1 )
    {
      printSystemData("Getting implant info...", 1);
      std::string::basic_string(v6, (__int64)v2);
      dbGetInfoAboutImplant(v6);
      std::string::~string((__int64)v6);
    }
    else
    {
      printSystemData("Invalid option selected.", 1);
    }
  }
  std::string::~string((__int64)v2);
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v_0 at 0xb233
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z12implantsMenuv at 0xb3ae
================================================================================

int GLOBAL__sub_I__Z12implantsMenuv()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm_1 at 0xb3bd
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm_1 at 0xb3d9
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'pqxx::argument_error,
    (void (*)(void *))pqxx::argument_error::~argument_error);
}



================================================================================
Function: _Z7appMenuv at 0xb609
================================================================================

_BOOL8 appMenu(void)
{
  _BOOL8 result; // rax
  _QWORD s[8]; // [rsp+0h] [rbp-80h] BYREF
  _QWORD v2[8]; // [rsp+40h] [rbp-40h] BYREF

  v2[0] = 0x746C7561666564LL;
  memset(&v2[1], 0, 56);
  memset(s, 0, sizeof(s));
  while ( 1 )
  {
    result = std::operator==<char>((__int64)&USERNAME[abi:cxx11], "default");
    if ( result )
      break;
    printSystemData("--- Application menu ---", 1);
    printSystemData("1. Implant menu", 0);
    printSystemData("2. Settings menu", 0);
    printSystemData("3. Log out", 0);
    printf("Choose an option (1-3): ");
    fflush(stdout);
    __isoc23_scanf();
    switch ( LOBYTE(s[0]) )
    {
      case '1':
        implantsMenu();
        break;
      case '2':
        settingsMenu();
        break;
      case '3':
        std::string::assign(&USERNAME[abi:cxx11], v2);
        break;
      default:
        printSystemData("Invalid option selected.", 1);
        break;
    }
    memset(s, 0, sizeof(s));
  }
  return result;
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v_1 at 0xb7bb
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z7appMenuv at 0xb936
================================================================================

int GLOBAL__sub_I__Z7appMenuv()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: _ZNSt11char_traitsIcE4moveEPcPKcm at 0xb945
================================================================================

void *__fastcall std::char_traits<char>::move(void *a1, const void *a2, size_t a3)
{
  if ( a3 )
    return memmove(a1, a2, a3);
  else
    return a1;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE4moveEPcPKcm at 0xb9a6
================================================================================

void *__fastcall __gnu_cxx::char_traits<char>::move(void *a1, const void *a2, size_t a3)
{
  if ( a3 )
    memmove(a1, a2, a3);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc at 0xba0e
================================================================================

__int64 __fastcall std::string::assign(__int64 a1, const char *a2)
{
  size_t v2; // rbx
  __int64 v3; // rax

  v2 = std::char_traits<char>::length(a2);
  v3 = std::string::size(a1);
  return std::string::_M_replace(a1, 0, v3, a2, v2);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm at 0xba66
================================================================================

_QWORD *__fastcall std::string::_M_replace(_QWORD *a1, size_t a2, __int64 a3, _BYTE *a4, unsigned __int64 a5)
{
  __int64 allocator; // rax
  _BYTE *v6; // rax
  _BYTE *v7; // rax
  __int64 v12; // [rsp+40h] [rbp-30h]
  _BYTE *v13; // [rsp+48h] [rbp-28h]
  size_t v14; // [rsp+50h] [rbp-20h]
  _BYTE *v15; // [rsp+58h] [rbp-18h]
  unsigned __int64 v16; // [rsp+60h] [rbp-10h]
  __int64 v17; // [rsp+68h] [rbp-8h]

  std::string::_M_check_length((__int64)a1, a3, a5, "basic_string::_M_replace");
  v17 = std::string::size((__int64)a1);
  v16 = v17 + a5 - a3;
  if ( std::string::capacity((__int64)a1) < v16 )
  {
    std::string::_M_mutate(a1, a2, a3, a4, a5);
  }
  else
  {
    v15 = (_BYTE *)(a2 + std::string::_M_data((__int64)a1));
    v14 = v17 - a2 - a3;
    if ( (unsigned __int8)std::is_constant_evaluated() )
    {
      allocator = std::string::_M_get_allocator((__int64)a1);
      v13 = (_BYTE *)std::string::_S_allocate(allocator, v16);
      v6 = (_BYTE *)std::string::_M_data((__int64)a1);
      std::string::_S_copy(v13, v6, a2);
      std::string::_S_copy(&v13[a2], a4, a5);
      std::string::_S_copy(&v13[a5 + a2], &v15[a3], v14);
      v7 = (_BYTE *)std::string::_M_data((__int64)a1);
      std::string::_S_copy(v7, v13, v16);
      v12 = std::string::_M_get_allocator((__int64)a1);
      std::__new_allocator<char>::deallocate(v12, v13, v16);
    }
    else if ( (unsigned __int8)std::string::_M_disjunct(a1, a4) )
    {
      if ( v14 && a3 != a5 )
        std::string::_S_move(&v15[a5], &v15[a3], v14);
      if ( a5 )
        std::string::_S_copy(v15, a4, a5);
    }
    else
    {
      std::string::_M_replace_cold(a1, v15, a3, a4, a5, v14);
    }
  }
  std::string::_M_set_length((__int64)a1, v16);
  return a1;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE11_M_disjunctEPKc at 0xbcf4
================================================================================

_BOOL8 __fastcall std::string::_M_disjunct(__int64 a1, __int64 a2)
{
  __int64 v2; // rax
  __int64 v3; // rbx
  __int64 v4; // rax
  _BOOL8 result; // rax
  char v6; // [rsp+1Eh] [rbp-12h] BYREF
  _BYTE v7[9]; // [rsp+1Fh] [rbp-11h] BYREF

  v2 = std::string::_M_data(a1);
  result = 1;
  if ( !(unsigned __int8)std::less<char const*>::operator()(&v6, a2, v2) )
  {
    v3 = std::string::_M_data(a1);
    v4 = std::string::size(a1);
    if ( !(unsigned __int8)std::less<char const*>::operator()(v7, v3 + v4, a2) )
      return 0;
  }
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7_S_moveEPcPKcm at 0xbd77
================================================================================

_BYTE *__fastcall std::string::_S_move(_BYTE *a1, _BYTE *a2, size_t a3)
{
  if ( a3 == 1 )
    return std::char_traits<char>::assign(a1, a2);
  else
    return std::char_traits<char>::move(a1, a2, a3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE15_M_replace_coldEPcmPKcmm at 0xbdc6
================================================================================

_BYTE *__fastcall std::string::_M_replace_cold(__int64 a1, _BYTE *a2, size_t a3, _BYTE *a4, size_t a5, size_t a6)
{
  _BYTE *result; // rax

  if ( a5 && a3 >= a5 )
    std::string::_S_move(a2, a4, a5);
  if ( a6 && a3 != a5 )
    std::string::_S_move(&a2[a5], &a2[a3], a6);
  result = (_BYTE *)a5;
  if ( a3 < a5 )
  {
    if ( &a2[a3] < &a4[a5] )
    {
      if ( a4 < &a2[a3] )
      {
        std::string::_S_move(a2, a4, &a2[a3] - a4);
        return std::string::_S_copy(&a2[&a2[a3] - a4], &a2[a5], a5 - (&a2[a3] - a4));
      }
      else
      {
        return std::string::_S_copy(a2, &a4[a5 - a3], a5);
      }
    }
    else
    {
      return std::string::_S_move(a2, a4, a5);
    }
  }
  return result;
}



================================================================================
Function: _ZNKSt4lessIPKcEclES1_S1_ at 0xbf32
================================================================================

bool __fastcall std::less<char const*>::operator()(__int64 a1, unsigned __int64 a2, unsigned __int64 a3)
{
  return a2 < a3;
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm_2 at 0xbf6c
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm_2 at 0xbf88
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'pqxx::argument_error,
    (void (*)(void *))pqxx::argument_error::~argument_error);
}



================================================================================
Function: _Z11startupMenuv at 0xc1b8
================================================================================

void startupMenu(void)
{
  printLogo();
  while ( 1 )
  {
    if ( !std::operator==<char>((__int64)&USERNAME[abi:cxx11], "default") )
    {
      appMenu();
    }
    else
    {
      printSystemData("--- Startup menu ---", 1);
      printSystemData("1. Register new account", 0);
      printSystemData("2. Login to account", 0);
      printSystemData("3. Restore an account", 0);
      printSystemData("4. Exit from program", 0);
      printf("Choose an option (1-4): ");
      fflush(stdout);
      __isoc23_scanf();
      clearInputBuffer();
      printSystemData("Invalid option selected.", 1);
    }
  }
}



================================================================================
Function: _Z12registerUserv at 0xc33f
================================================================================

void registerUser(void)
{
  char v0; // bl
  char User; // bl
  const char *v2; // rax
  const char *v3; // rax
  const char *v4; // rax
  _QWORD v5[4]; // [rsp+0h] [rbp-130h] BYREF
  _QWORD v6[4]; // [rsp+20h] [rbp-110h] BYREF
  _QWORD v7[4]; // [rsp+40h] [rbp-F0h] BYREF
  _QWORD v8[4]; // [rsp+60h] [rbp-D0h] BYREF
  _QWORD v9[4]; // [rsp+80h] [rbp-B0h] BYREF
  _QWORD v10[4]; // [rsp+A0h] [rbp-90h] BYREF
  _QWORD v11[4]; // [rsp+C0h] [rbp-70h] BYREF
  _QWORD v12[4]; // [rsp+E0h] [rbp-50h] BYREF
  _QWORD v13[5]; // [rsp+100h] [rbp-30h] BYREF

  std::string::basic_string(v7);
  std::string::basic_string(v6);
  std::string::basic_string(v5);
  printf("\nEnter username: ");
  std::operator>><char>();
  printf("Enter password: ");
  std::operator>><char>();
  printSystemData("Creating new account. Please wait...", 1);
  makeUniqueUsername((__int64)v8, (__int64)v7);
  std::string::operator=(v7, v8);
  std::string::~string((__int64)v8);
  generateCode[abi:cxx11]((__int64)v9);
  std::string::operator=(v5, v9);
  std::string::~string((__int64)v9);
  std::string::basic_string(v10, (__int64)v7);
  v0 = dbCheckUsername(v10);
  std::string::~string((__int64)v10);
  if ( v0 )
  {
    printSystemData("User already exists.", 1);
  }
  else
  {
    std::string::basic_string(v11, (__int64)v5);
    std::string::basic_string(v12, (__int64)v6);
    std::string::basic_string(v13, (__int64)v7);
    User = dbCreateUser(v13, v12, v11);
    std::string::~string((__int64)v13);
    std::string::~string((__int64)v12);
    std::string::~string((__int64)v11);
    if ( User )
    {
      printSystemData("---Your credentials ---", 1);
      v2 = (const char *)std::string::c_str((__int64)v7);
      printf("Username: %s\n", v2);
      v3 = (const char *)std::string::c_str((__int64)v6);
      printf("Password: %s\n", v3);
      v4 = (const char *)std::string::c_str((__int64)v5);
      printf("Security code: %s\n", v4);
      printSystemData("Use this credentials to gain access to the system.", 1);
    }
    else
    {
      printSystemData("Failed to create user.", 1);
    }
  }
  std::string::~string((__int64)v5);
  std::string::~string((__int64)v6);
  std::string::~string((__int64)v7);
}



================================================================================
Function: _Z9loginUserv at 0xc6c6
================================================================================

void loginUser(void)
{
  char v0; // bl
  _QWORD v1[4]; // [rsp+0h] [rbp-90h] BYREF
  _QWORD v2[4]; // [rsp+20h] [rbp-70h] BYREF
  _QWORD v3[4]; // [rsp+40h] [rbp-50h] BYREF
  _QWORD v4[5]; // [rsp+60h] [rbp-30h] BYREF

  std::string::basic_string(v2);
  std::string::basic_string(v1);
  printf("\nEnter username: ");
  std::operator>><char>();
  printf("Enter password: ");
  std::operator>><char>();
  printSystemData("Trying to log in...", 1);
  std::string::basic_string(v3, (__int64)v1);
  std::string::basic_string(v4, (__int64)v2);
  v0 = dbCheckUser(v4, v3);
  std::string::~string((__int64)v4);
  std::string::~string((__int64)v3);
  if ( v0 )
  {
    printSystemData("Successfully logged in.", 1);
    std::string::operator=(&USERNAME[abi:cxx11], v2);
  }
  else
  {
    printSystemData("Failed to log in.", 1);
  }
  std::string::~string((__int64)v1);
  std::string::~string((__int64)v2);
}



================================================================================
Function: _Z11restoreUserv at 0xc870
================================================================================

void restoreUser(void)
{
  char v0; // bl
  char v1; // bl
  const char *v2; // rax
  const char *v3; // rax
  _QWORD v4[4]; // [rsp+0h] [rbp-110h] BYREF
  _QWORD v5[4]; // [rsp+20h] [rbp-F0h] BYREF
  _QWORD v6[4]; // [rsp+40h] [rbp-D0h] BYREF
  _QWORD v7[4]; // [rsp+60h] [rbp-B0h] BYREF
  _QWORD v8[4]; // [rsp+80h] [rbp-90h] BYREF
  _QWORD v9[4]; // [rsp+A0h] [rbp-70h] BYREF
  _QWORD v10[4]; // [rsp+C0h] [rbp-50h] BYREF
  _QWORD v11[5]; // [rsp+E0h] [rbp-30h] BYREF

  std::string::basic_string(v6);
  std::string::basic_string(v5);
  std::string::basic_string(v4);
  printf("\nEnter username: ");
  std::operator>><char>();
  printf("Enter security code: ");
  std::operator>><char>();
  printSystemData("Trying to find user...", 1);
  std::string::basic_string(v7, (__int64)v4);
  std::string::basic_string(v8, (__int64)v6);
  v0 = dbCheckRestoreUser(v8, v7);
  std::string::~string((__int64)v8);
  std::string::~string((__int64)v7);
  if ( v0 )
  {
    printSystemData("Successfully found user.", 1);
    makeNewPassword[abi:cxx11]((__int64)v9);
    std::string::operator=(v5, v9);
    std::string::~string((__int64)v9);
    std::string::basic_string(v10, (__int64)v5);
    std::string::basic_string(v11, (__int64)v6);
    v1 = dbChangePassword(v11, v10);
    std::string::~string((__int64)v11);
    std::string::~string((__int64)v10);
    if ( v1 )
    {
      printSystemData("Changing password...", 1);
      printSystemData("---Your new credentials ---", 1);
      v2 = (const char *)std::string::c_str((__int64)v6);
      printf("Username: %s\n", v2);
      v3 = (const char *)std::string::c_str((__int64)v5);
      printf("Password: %s\n", v3);
      printSystemData("Use this credentials to gain access to the system.", 1);
    }
    else
    {
      printSystemData("Unexpected error. Please try later.", 1);
    }
  }
  else
  {
    printSystemData("Failed to find user.", 1);
  }
  std::string::~string((__int64)v4);
  std::string::~string((__int64)v5);
  std::string::~string((__int64)v6);
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v_2 at 0xcbbc
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z11startupMenuv at 0xcd37
================================================================================

int GLOBAL__sub_I__Z11startupMenuv()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_ at 0xcd46
================================================================================

__int64 __fastcall std::string::operator=(__int64 a1, __int64 a2)
{
  return std::string::assign(a1, a2);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignERKS4_ at 0xcd70
================================================================================

_QWORD *__fastcall std::string::assign(_QWORD *a1, __int64 a2)
{
  std::string::_M_assign(a1, a2);
  return a1;
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm_3 at 0xcfd3
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm_3 at 0xcfef
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'pqxx::argument_error,
    (void (*)(void *))pqxx::argument_error::~argument_error);
}



================================================================================
Function: _Z6initDbv at 0xd21f
================================================================================

__int64 initDb(void)
{
  __int64 v0; // rbx
  _BYTE v2[40]; // [rsp+0h] [rbp-80h] BYREF
  char *v3; // [rsp+28h] [rbp-58h] BYREF
  char *v4; // [rsp+30h] [rbp-50h] BYREF
  _QWORD v5[3]; // [rsp+38h] [rbp-48h] BYREF
  _QWORD v6[6]; // [rsp+50h] [rbp-30h] BYREF

  v3 = getenv("POSTGRES_DB");
  v4 = getenv("POSTGRES_PASSWORD");
  v5[0] = getenv("POSTGRES_USER");
  v5[1] = 37;
  v5[2] = "user={} host=db password={} dbname={}";
  std::format<char *,char *,char *>(v2, 37, "user={} host=db password={} dbname={}", v5, &v4, &v3);
  v0 = operator new(0x88u);
  pqxx::zview::zview(v6, v2);
  pqxx::connection::connection(v0, v6[0], v6[1]);
  DB_CONNECTION = v0;
  std::string::~string((__int64)v2);
  return 1;
}



================================================================================
Function: _Z15dbCheckUsernameNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xd359
================================================================================

_BOOL8 __fastcall dbCheckUsername(__int64 a1)
{
  _BOOL4 v1; // ebx
  _BYTE v3[64]; // [rsp+10h] [rbp-F0h] BYREF
  _BYTE v4[112]; // [rsp+50h] [rbp-B0h] BYREF
  _BYTE v5[32]; // [rsp+C0h] [rbp-40h] BYREF
  _QWORD v6[3]; // [rsp+E0h] [rbp-20h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v4, DB_CONNECTION);
  pqxx::params::params<std::string &>(v5, a1);
  std::string_view::basic_string_view(v6, "SELECT id FROM users WHERE username=$1");
  pqxx::transaction_base::exec(v3, v4, v6[0], v6[1], v5);
  pqxx::params::~params((pqxx::params *)v5);
  v1 = pqxx::result::size((pqxx::result *)v3) != 0;
  pqxx::result::~result((pqxx::result *)v3);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v4);
  return v1;
}



================================================================================
Function: _Z11dbCheckUserNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_ at 0xd466
================================================================================

_BOOL8 __fastcall dbCheckUser(__int64 a1, __int64 a2)
{
  _BOOL4 v2; // ebx
  _BYTE v4[64]; // [rsp+10h] [rbp-130h] BYREF
  _BYTE v5[112]; // [rsp+50h] [rbp-F0h] BYREF
  _QWORD v6[4]; // [rsp+C0h] [rbp-80h] BYREF
  _QWORD v7[4]; // [rsp+E0h] [rbp-60h] BYREF
  _BYTE v8[32]; // [rsp+100h] [rbp-40h] BYREF
  _QWORD v9[3]; // [rsp+120h] [rbp-20h] BYREF

  std::string::basic_string(v6);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v5, DB_CONNECTION);
  hashPassword((__int64)v7, a2);
  std::string::operator=(v6, v7);
  std::string::~string((__int64)v7);
  if ( std::operator==<char>((__int64)v6, &unk_27D6F) )
  {
    v2 = 0;
  }
  else
  {
    pqxx::params::params<std::string &,std::string &>(v8, a1, v6);
    std::string_view::basic_string_view(v9, "SELECT id FROM users WHERE username=$1 AND password=$2");
    pqxx::transaction_base::exec(v4, v5, v9[0], v9[1], v8);
    pqxx::params::~params((pqxx::params *)v8);
    v2 = pqxx::result::size((pqxx::result *)v4) != 0;
    pqxx::result::~result((pqxx::result *)v4);
  }
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v5);
  std::string::~string((__int64)v6);
  return v2;
}



================================================================================
Function: _Z18dbCheckRestoreUserNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_ at 0xd604
================================================================================

_BOOL8 __fastcall dbCheckRestoreUser(__int64 a1, __int64 a2)
{
  _BOOL4 v2; // ebx
  _BYTE v4[64]; // [rsp+10h] [rbp-F0h] BYREF
  _BYTE v5[112]; // [rsp+50h] [rbp-B0h] BYREF
  _BYTE v6[32]; // [rsp+C0h] [rbp-40h] BYREF
  _QWORD v7[3]; // [rsp+E0h] [rbp-20h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v5, DB_CONNECTION);
  pqxx::params::params<std::string &,std::string &>(v6, a1, a2);
  std::string_view::basic_string_view(v7, "SELECT * FROM users WHERE username=$1 AND securitycode=$2");
  pqxx::transaction_base::exec(v4, v5, v7[0], v7[1], v6);
  pqxx::params::~params((pqxx::params *)v6);
  v2 = pqxx::result::size((pqxx::result *)v4) != 0;
  pqxx::result::~result((pqxx::result *)v4);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v5);
  return v2;
}



================================================================================
Function: _Z12dbCreateUserNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_S4_ at 0xd71f
================================================================================

__int64 __fastcall dbCreateUser(__int64 a1, __int64 a2, __int64 a3)
{
  unsigned int v3; // ebx
  _BYTE v6[64]; // [rsp+20h] [rbp-130h] BYREF
  _BYTE v7[112]; // [rsp+60h] [rbp-F0h] BYREF
  _QWORD v8[4]; // [rsp+D0h] [rbp-80h] BYREF
  _QWORD v9[4]; // [rsp+F0h] [rbp-60h] BYREF
  _BYTE v10[32]; // [rsp+110h] [rbp-40h] BYREF
  _QWORD v11[3]; // [rsp+130h] [rbp-20h] BYREF

  std::string::basic_string(v8);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v7, DB_CONNECTION);
  hashPassword((__int64)v9, a2);
  std::string::operator=(v8, v9);
  std::string::~string((__int64)v9);
  if ( std::operator==<char>((__int64)v8, &unk_27D6F) )
  {
    v3 = 0;
  }
  else
  {
    pqxx::params::params<std::string &,std::string &,std::string &>(v10, a1, v8, a3);
    std::string_view::basic_string_view(v11, "INSERT INTO users (username, password, securitycode) VALUES ($1, $2, $3)");
    pqxx::transaction_base::exec(v6, v7, v11[0], v11[1], v10);
    pqxx::params::~params((pqxx::params *)v10);
    pqxx::transaction_base::commit((pqxx::transaction_base *)v7);
    v3 = 1;
    pqxx::result::~result((pqxx::result *)v6);
  }
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v7);
  std::string::~string((__int64)v8);
  return v3;
}



================================================================================
Function: _Z16dbChangePasswordNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_ at 0xd8d5
================================================================================

__int64 __fastcall dbChangePassword(__int64 a1, __int64 a2)
{
  unsigned int v2; // ebx
  _BYTE v4[64]; // [rsp+10h] [rbp-130h] BYREF
  _BYTE v5[112]; // [rsp+50h] [rbp-F0h] BYREF
  _QWORD v6[4]; // [rsp+C0h] [rbp-80h] BYREF
  _QWORD v7[4]; // [rsp+E0h] [rbp-60h] BYREF
  _BYTE v8[32]; // [rsp+100h] [rbp-40h] BYREF
  _QWORD v9[3]; // [rsp+120h] [rbp-20h] BYREF

  std::string::basic_string(v6);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v5, DB_CONNECTION);
  hashPassword((__int64)v7, a2);
  std::string::operator=(v6, v7);
  std::string::~string((__int64)v7);
  if ( std::operator==<char>((__int64)v6, &unk_27D6F) )
  {
    v2 = 0;
  }
  else
  {
    pqxx::params::params<std::string &,std::string &>(v8, a1, v6);
    std::string_view::basic_string_view(v9, "UPDATE users SET password = $2 WHERE username = $1");
    pqxx::transaction_base::exec(v4, v5, v9[0], v9[1], v8);
    pqxx::params::~params((pqxx::params *)v8);
    pqxx::transaction_base::commit((pqxx::transaction_base *)v5);
    v2 = 1;
    pqxx::result::~result((pqxx::result *)v4);
  }
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v5);
  std::string::~string((__int64)v6);
  return v2;
}



================================================================================
Function: _Z17dbGetSecurityCodeNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xda80
================================================================================

_QWORD *__fastcall dbGetSecurityCode(_QWORD *a1, __int64 a2)
{
  _BYTE v3[64]; // [rsp+10h] [rbp-1A0h] BYREF
  _BYTE v4[112]; // [rsp+50h] [rbp-160h] BYREF
  _BYTE v5[32]; // [rsp+C0h] [rbp-F0h] BYREF
  _QWORD v6[2]; // [rsp+E0h] [rbp-D0h] BYREF
  _BYTE v7[80]; // [rsp+F0h] [rbp-C0h] BYREF
  _BYTE v8[87]; // [rsp+140h] [rbp-70h] BYREF
  char v9; // [rsp+197h] [rbp-19h] BYREF
  char *v10; // [rsp+198h] [rbp-18h]

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v4, DB_CONNECTION);
  pqxx::params::params<std::string &>(v5, a2);
  std::string_view::basic_string_view(v6, "SELECT securitycode FROM users WHERE username=$1");
  pqxx::transaction_base::exec(v3, v4, v6[0], v6[1], v5);
  pqxx::params::~params((pqxx::params *)v5);
  if ( (unsigned int)pqxx::result::size((pqxx::result *)v3) )
  {
    pqxx::result::operator[]();
    pqxx::row::operator[]();
    pqxx::field::as<std::string>(a1, v7);
    pqxx::field::~field((pqxx::field *)v7);
    pqxx::row::~row((pqxx::row *)v8);
  }
  else
  {
    v10 = &v9;
    std::string::basic_string<std::allocator<char>>(a1, (const char *)&unk_27D6F);
  }
  pqxx::result::~result((pqxx::result *)v3);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v4);
  return a1;
}



================================================================================
Function: _Z17dbGetUserImplantsNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xdc73
================================================================================

__int64 __fastcall dbGetUserImplants(__int64 a1)
{
  unsigned int v1; // ebx
  const char *v2; // rax
  int v3; // eax
  _BYTE v5[32]; // [rsp+10h] [rbp-220h] BYREF
  _QWORD v6[4]; // [rsp+30h] [rbp-200h] BYREF
  _BYTE v7[64]; // [rsp+50h] [rbp-1E0h] BYREF
  _BYTE v8[112]; // [rsp+90h] [rbp-1A0h] BYREF
  _BYTE v9[32]; // [rsp+100h] [rbp-130h] BYREF
  _QWORD v10[2]; // [rsp+120h] [rbp-110h] BYREF
  _BYTE v11[80]; // [rsp+130h] [rbp-100h] BYREF
  _BYTE v12[80]; // [rsp+180h] [rbp-B0h] BYREF
  _QWORD v13[4]; // [rsp+1D0h] [rbp-60h] BYREF
  _BYTE v14[44]; // [rsp+1F0h] [rbp-40h] BYREF
  int i; // [rsp+21Ch] [rbp-14h]

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v8, DB_CONNECTION);
  pqxx::params::params<std::string &>(v9, a1);
  std::string_view::basic_string_view(v10, "SELECT name FROM implants WHERE ownername=$1");
  pqxx::transaction_base::exec(v7, v8, v10[0], v10[1], v9);
  pqxx::params::~params((pqxx::params *)v9);
  if ( (unsigned int)pqxx::result::size((pqxx::result *)v7) )
  {
    for ( i = 0; ; ++i )
    {
      v3 = pqxx::result::size((pqxx::result *)v7);
      if ( i >= v3 )
        break;
      pqxx::result::operator[]();
      pqxx::row::operator[]();
      pqxx::field::as<std::string>(v5, v11);
      pqxx::field::~field((pqxx::field *)v11);
      pqxx::row::~row((pqxx::row *)v12);
      std::to_string((std::__cxx11 *)v14, i + 1);
      std::operator+<char>(v13, (__int64)v14, (__int64)". ");
      std::operator+<char>(v6, (__int64)v13, (__int64)v5);
      std::string::~string((__int64)v13);
      std::string::~string((__int64)v14);
      v2 = (const char *)std::string::c_str((__int64)v6);
      puts(v2);
      std::string::~string((__int64)v6);
      std::string::~string((__int64)v5);
    }
    v1 = 1;
  }
  else
  {
    printSystemData("No implants found for this user.", 1);
    v1 = 0;
  }
  pqxx::result::~result((pqxx::result *)v7);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v8);
  return v1;
}



================================================================================
Function: _Z19dbCheckOwnerImplantNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_ at 0xdf73
================================================================================

_BOOL8 __fastcall dbCheckOwnerImplant(__int64 a1, __int64 a2)
{
  _BOOL4 v2; // ebx
  _BYTE v4[64]; // [rsp+10h] [rbp-F0h] BYREF
  _BYTE v5[112]; // [rsp+50h] [rbp-B0h] BYREF
  _BYTE v6[32]; // [rsp+C0h] [rbp-40h] BYREF
  _QWORD v7[3]; // [rsp+E0h] [rbp-20h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v5, DB_CONNECTION);
  pqxx::params::params<std::string &,std::string &>(v6, a1, a2);
  std::string_view::basic_string_view(v7, "SELECT id FROM implants WHERE ownername=$1 AND name=$2");
  pqxx::transaction_base::exec(v4, v5, v7[0], v7[1], v6);
  pqxx::params::~params((pqxx::params *)v6);
  v2 = pqxx::result::size((pqxx::result *)v4) != 0;
  pqxx::result::~result((pqxx::result *)v4);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v5);
  return v2;
}



================================================================================
Function: _Z21dbGetInfoAboutImplantNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xe08e
================================================================================

__int64 __fastcall dbGetInfoAboutImplant(__int64 a1)
{
  _BYTE v2[64]; // [rsp+10h] [rbp-1D0h] BYREF
  _BYTE v3[112]; // [rsp+50h] [rbp-190h] BYREF
  _BYTE v4[32]; // [rsp+C0h] [rbp-120h] BYREF
  _QWORD v5[2]; // [rsp+E0h] [rbp-100h] BYREF
  _BYTE v6[32]; // [rsp+F0h] [rbp-F0h] BYREF
  _BYTE v7[32]; // [rsp+110h] [rbp-D0h] BYREF
  _BYTE v8[80]; // [rsp+130h] [rbp-B0h] BYREF
  _BYTE v9[88]; // [rsp+180h] [rbp-60h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v3, DB_CONNECTION);
  pqxx::params::params<std::string &>(v4, a1);
  std::string_view::basic_string_view(v5, "SELECT info FROM implants WHERE name=$1");
  pqxx::transaction_base::exec(v2, v3, v5[0], v5[1], v4);
  pqxx::params::~params((pqxx::params *)v4);
  if ( (unsigned int)pqxx::result::size((pqxx::result *)v2) )
  {
    pqxx::result::operator[]();
    pqxx::row::operator[]();
    pqxx::field::as<std::string>(v7, v8);
    std::operator+<char>(v6, "Implant info: ", v7);
    printSystemData((__int64)v6, 1);
    std::string::~string((__int64)v6);
    std::string::~string((__int64)v7);
    pqxx::field::~field((pqxx::field *)v8);
    pqxx::row::~row((pqxx::row *)v9);
  }
  else
  {
    printSystemData("Unexpected error. Please try later.", 1);
  }
  pqxx::result::~result((pqxx::result *)v2);
  return pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v3);
}



================================================================================
Function: _Z15dbDeleteImplantNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xe2e7
================================================================================

__int64 __fastcall dbDeleteImplant(__int64 a1)
{
  __int64 v1; // rax
  __int64 v2; // rdx
  _BYTE v4[64]; // [rsp+10h] [rbp-100h] BYREF
  _BYTE v5[112]; // [rsp+50h] [rbp-C0h] BYREF
  _QWORD v6[4]; // [rsp+C0h] [rbp-50h] BYREF
  _BYTE v7[40]; // [rsp+E0h] [rbp-30h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v5, DB_CONNECTION);
  std::operator+<char>((__int64)v7, "DELETE FROM implants WHERE name = '", a1);
  std::operator+<char>(v6, (__int64)v7, (__int64)"'");
  v1 = std::string::operator std::string_view(v6);
  pqxx::transaction_base::exec(v4, v5, v1, v2);
  std::string::~string((__int64)v6);
  std::string::~string((__int64)v7);
  pqxx::transaction_base::commit((pqxx::transaction_base *)v5);
  pqxx::result::~result((pqxx::result *)v4);
  return pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v5);
}



================================================================================
Function: _Z12dbAddImplantNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_S4_ at 0xe423
================================================================================

__int64 __fastcall dbAddImplant(__int64 a1, __int64 a2, __int64 a3)
{
  _BYTE v5[64]; // [rsp+20h] [rbp-F0h] BYREF
  _BYTE v6[112]; // [rsp+60h] [rbp-B0h] BYREF
  _BYTE v7[32]; // [rsp+D0h] [rbp-40h] BYREF
  _QWORD v8[3]; // [rsp+F0h] [rbp-20h] BYREF

  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(v6, DB_CONNECTION);
  pqxx::params::params<std::string &,std::string &,std::string &>(v7, a1, a2, a3);
  std::string_view::basic_string_view(v8, "INSERT INTO implants (name, info, ownername) VALUES ($1, $2, $3)");
  pqxx::transaction_base::exec(v5, v6, v8[0], v8[1], v7);
  pqxx::params::~params((pqxx::params *)v7);
  pqxx::transaction_base::commit((pqxx::transaction_base *)v6);
  pqxx::result::~result((pqxx::result *)v5);
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(v6);
  return 1;
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v_3 at 0xe556
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z6initDbv at 0xe6d1
================================================================================

int GLOBAL__sub_I__Z6initDbv()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: _ZSteqSt15strong_orderingNSt9__cmp_cat8__unspecE at 0xe6e0
================================================================================

bool __fastcall std::operator==(char a1)
{
  return a1 == 0;
}



================================================================================
Function: _ZStltSt15strong_orderingNSt9__cmp_cat8__unspecE at 0xe6f7
================================================================================

char __fastcall std::operator<(unsigned __int8 a1)
{
  return a1 >> 7;
}



================================================================================
Function: _ZN9__gnu_cxx5__ops15__iter_less_valEv at 0xe70c
================================================================================

void __fastcall __gnu_cxx::__ops::__iter_less_val(__gnu_cxx::__ops *this)
{
  ;
}



================================================================================
Function: _ZN9__gnu_cxx5__ops15__val_less_iterEv at 0xe717
================================================================================

void __fastcall __gnu_cxx::__ops::__val_less_iter(__gnu_cxx::__ops *this)
{
  ;
}



================================================================================
Function: _ZNSt11char_traitsIcE2eqERKcS2_ at 0xe722
================================================================================

bool __fastcall std::char_traits<char>::eq(_BYTE *a1, _BYTE *a2)
{
  return *a1 == *a2;
}



================================================================================
Function: _ZNSt11char_traitsIcE4findEPKcmRS1_ at 0xe747
================================================================================

void *__fastcall std::char_traits<char>::find(const void *a1, size_t a2, char *a3)
{
  if ( a2 )
    return memchr(a1, *a3, a2);
  else
    return 0;
}



================================================================================
Function: _ZSt10__sv_checkmmPKc at 0xe7ae
================================================================================

unsigned __int64 __fastcall std::__sv_check(unsigned __int64 a1, unsigned __int64 a2, const char *a3)
{
  if ( a1 < a2 )
    std::__throw_out_of_range_fmt("%s: __pos (which is %zu) > __size (which is %zu)");
  return a2;
}



================================================================================
Function: _ZZNSt7__cxx119to_stringEiENKUlPcmE_clES0_m at 0xe7f6
================================================================================

__int64 __fastcall std::to_string(int)::{lambda(char *,unsigned long)#1}::operator()(
        unsigned __int8 *a1,
        _BYTE *a2,
        __int64 a3)
{
  *a2 = 45;
  std::__detail::__to_chars_10_impl<unsigned int>(&a2[*a1], *((unsigned int *)a1 + 1), *((unsigned int *)a1 + 2));
  return a3;
}



================================================================================
Function: _ZNSt7__cxx119to_stringEi at 0xe844
================================================================================

std::__cxx11 *__fastcall std::to_string(std::__cxx11 *this, int a2)
{
  __int64 v3; // [rsp+18h] [rbp-18h]
  int v4; // [rsp+24h] [rbp-Ch]
  bool v5; // [rsp+2Bh] [rbp-5h]
  unsigned int v6; // [rsp+2Ch] [rbp-4h]

  v5 = a2 < 0;
  if ( a2 >= 0 )
    v6 = a2;
  else
    v6 = -a2;
  v4 = std::__detail::__to_chars_len<unsigned int>(v6, 10);
  std::string::basic_string(this);
  LODWORD(v3) = v5;
  HIDWORD(v3) = v4;
  std::string::__resize_and_overwrite<std::to_string(int)::{lambda(char *,unsigned long)#1}>(
    this,
    (unsigned int)v5 + v4,
    v3,
    v6);
  return this;
}



================================================================================
Function: _ZNSt8__detail14__to_chars_lenIjEEjT_i at 0xe8e0
================================================================================

__int64 __fastcall std::__detail::__to_chars_len<unsigned int>(unsigned int a1, unsigned int a2)
{
  unsigned int i; // [rsp+24h] [rbp-4h]

  for ( i = 1; ; i += 4 )
  {
    if ( a1 < a2 )
      return i;
    if ( a1 < a2 * a2 )
      return i + 1;
    if ( a1 < a2 * a2 * a2 )
      return i + 2;
    if ( a1 < (unsigned __int64)(a2 * a2 * a2 * a2) )
      break;
    a1 /= a2 * a2 * a2 * a2;
  }
  return i + 3;
}



================================================================================
Function: _ZNSt8__detail14__to_chars_lenImEEjT_i at 0xe96c
================================================================================

__int64 __fastcall std::__detail::__to_chars_len<unsigned long>(unsigned __int64 a1, unsigned int a2)
{
  unsigned __int64 v4; // [rsp+14h] [rbp-18h]
  unsigned int v5; // [rsp+28h] [rbp-4h]

  v5 = 1;
  v4 = a2 * a2 * a2 * a2;
  while ( 1 )
  {
    if ( a1 < a2 )
      return v5;
    if ( a1 < a2 * a2 )
      return v5 + 1;
    if ( a1 < a2 * a2 * a2 )
      return v5 + 2;
    if ( a1 < v4 )
      break;
    a1 /= v4;
    v5 += 4;
  }
  return v5 + 3;
}



================================================================================
Function: _ZNSt8__detail14__to_chars_lenIyEEjT_i at 0xea01
================================================================================

__int64 __fastcall std::__detail::__to_chars_len<unsigned long long>(unsigned __int64 a1, unsigned int a2)
{
  unsigned __int64 v4; // [rsp+14h] [rbp-18h]
  unsigned int v5; // [rsp+28h] [rbp-4h]

  v5 = 1;
  v4 = a2 * a2 * a2 * a2;
  while ( 1 )
  {
    if ( a1 < a2 )
      return v5;
    if ( a1 < a2 * a2 )
      return v5 + 1;
    if ( a1 < a2 * a2 * a2 )
      return v5 + 2;
    if ( a1 < v4 )
      break;
    a1 /= v4;
    v5 += 4;
  }
  return v5 + 3;
}



================================================================================
Function: _ZNSt14_Function_baseD2Ev at 0xea96
================================================================================

void __fastcall std::_Function_base::~_Function_base(std::_Function_base *this)
{
  if ( *((_QWORD *)this + 2) )
    (*((void (__fastcall **)(std::_Function_base *, std::_Function_base *, __int64))this + 2))(this, this, 3);
}



================================================================================
Function: _ZNSt15_Rb_tree_headerC2Ev at 0xead4
================================================================================

__int64 __fastcall std::_Rb_tree_header::_Rb_tree_header(std::_Rb_tree_header *this)
{
  *(_DWORD *)this = 0;
  return std::_Rb_tree_header::_M_reset(this);
}



================================================================================
Function: _ZNSt15_Rb_tree_header8_M_resetEv at 0xeafe
================================================================================

std::_Rb_tree_header *__fastcall std::_Rb_tree_header::_M_reset(std::_Rb_tree_header *this)
{
  std::_Rb_tree_header *result; // rax

  *((_QWORD *)this + 1) = 0;
  *((_QWORD *)this + 2) = this;
  *((_QWORD *)this + 3) = this;
  result = this;
  *((_QWORD *)this + 4) = 0;
  return result;
}



================================================================================
Function: _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv at 0xeb3e
================================================================================

char __fastcall std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(volatile signed __int32 *a1)
{
  char result; // al
  signed __int32 v2; // eax
  signed __int32 v3; // [rsp+20h] [rbp-40h]
  volatile signed __int32 *v4; // [rsp+38h] [rbp-28h]

  if ( *((_QWORD *)a1 + 1) == 0x100000001LL )
  {
    *((_DWORD *)a1 + 2) = 0;
    *((_DWORD *)a1 + 3) = *((_DWORD *)a1 + 2);
    (*(void (__fastcall **)(volatile signed __int32 *))(*(_QWORD *)a1 + 16LL))(a1);
    return (*(__int64 (__fastcall **)(volatile signed __int32 *))(*(_QWORD *)a1 + 24LL))(a1);
  }
  else
  {
    v4 = a1 + 2;
    if ( _libc_single_threaded )
    {
      v3 = (*v4)--;
      v2 = v3;
    }
    else
    {
      v2 = _InterlockedExchangeAdd(v4, 0xFFFFFFFF);
    }
    result = v2 == 1;
    if ( result )
      return std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(a1);
  }
  return result;
}



================================================================================
Function: _ZSt8to_charsPcS_mi at 0xec6e
================================================================================

__int64 __fastcall std::to_chars(char *a1, char *a2, __int64 a3, unsigned int a4)
{
  return std::__to_chars_i<unsigned long>(a1, a2, a3, a4);
}



================================================================================
Function: _ZSt11__bit_widthIjEiT_ at 0xeca2
================================================================================

__int64 __fastcall std::__bit_width<unsigned int>(unsigned int a1)
{
  return 32 - (unsigned int)std::__countl_zero<unsigned int>(a1);
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4sizeEv at 0xecce
================================================================================

__int64 __fastcall std::string_view::size(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZN4pqxx13check_versionEv at 0xece3
================================================================================

__int64 __fastcall pqxx::check_version(pqxx *this)
{
  if ( !(_BYTE)`guard variable for'pqxx::check_version(void)::version_ok
    && __cxa_guard_acquire(&`guard variable for'pqxx::check_version(void)::version_ok) )
  {
    pqxx::check_version(void)::version_ok = pqxx::internal::check_pqxx_version_7_10((pqxx::internal *)&`guard variable for'pqxx::check_version(void)::version_ok);
    __cxa_guard_release(&`guard variable for'pqxx::check_version(void)::version_ok);
  }
  return pqxx::ignore_unused<int const&>(&pqxx::check_version(void)::version_ok);
}



================================================================================
Function: _ZN4pqxx5zviewC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0xed40
================================================================================

__int64 __fastcall pqxx::zview::zview(__int64 a1, __int64 a2)
{
  __int64 v2; // r12
  __int64 v3; // rax

  v2 = std::string::c_str(a2);
  v3 = std::string::size(a2);
  return std::string_view::basic_string_view(a1, v2, v3);
}



================================================================================
Function: _ZNKR4pqxx5zview5c_strEv at 0xed8e
================================================================================

__int64 __fastcall pqxx::zview::c_str(__int64 a1)
{
  return std::string_view::data(a1);
}



================================================================================
Function: _ZN4pqxx13string_traitsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE11from_stringESt17basic_string_viewIcS4_E at 0xedac
================================================================================

__int64 __fastcall pqxx::string_traits<std::string>::from_string(__int64 a1, __int64 a2, __int64 a3)
{
  _QWORD v4[3]; // [rsp+0h] [rbp-30h] BYREF
  __int64 v5; // [rsp+18h] [rbp-18h]
  char v6; // [rsp+27h] [rbp-9h] BYREF
  char *v7; // [rsp+28h] [rbp-8h]

  v5 = a1;
  v4[0] = a2;
  v4[1] = a3;
  v7 = &v6;
  std::string::basic_string<std::string_view,void>(a1, v4, &v6);
  return v5;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE12_Alloc_hiderD2Ev at 0xedfe
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_Alloc_hider::~_Alloc_hider(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKc at 0xee16
================================================================================

size_t *__fastcall std::string_view::basic_string_view(size_t *a1, const char *a2)
{
  size_t *result; // rax

  *a1 = std::char_traits<char>::length(a2);
  result = a1;
  a1[1] = (size_t)a2;
  return result;
}



================================================================================
Function: _ZNSt12__shared_ptrIK9pg_resultLN9__gnu_cxx12_Lock_policyE2EED2Ev at 0xee4c
================================================================================

__int64 __fastcall std::__shared_ptr<pg_result const,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(__int64 a1)
{
  return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(a1 + 8);
}



================================================================================
Function: _ZNSt10shared_ptrIK9pg_resultED2Ev at 0xee70
================================================================================

__int64 __fastcall std::shared_ptr<pg_result const>::~shared_ptr(__int64 a1)
{
  return std::__shared_ptr<pg_result const,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(a1);
}



================================================================================
Function: _ZNSt12__shared_ptrIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEELN9__gnu_cxx12_Lock_policyE2EED2Ev at 0xee90
================================================================================

__int64 __fastcall std::__shared_ptr<std::string const,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(__int64 a1)
{
  return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(a1 + 8);
}



================================================================================
Function: _ZNSt10shared_ptrIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev at 0xeeb4
================================================================================

__int64 __fastcall std::shared_ptr<std::string const>::~shared_ptr(__int64 a1)
{
  return std::__shared_ptr<std::string const,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(a1);
}



================================================================================
Function: _ZNSt12__shared_ptrIN4pqxx8internal14notice_waitersELN9__gnu_cxx12_Lock_policyE2EED2Ev at 0xeed4
================================================================================

__int64 __fastcall std::__shared_ptr<pqxx::internal::notice_waiters,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(
        __int64 a1)
{
  return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(a1 + 8);
}



================================================================================
Function: _ZNSt10shared_ptrIN4pqxx8internal14notice_waitersEED2Ev at 0xeef8
================================================================================

__int64 __fastcall std::shared_ptr<pqxx::internal::notice_waiters>::~shared_ptr(__int64 a1)
{
  return std::__shared_ptr<pqxx::internal::notice_waiters,(__gnu_cxx::_Lock_policy)2>::~__shared_ptr(a1);
}



================================================================================
Function: _ZN4pqxx6resultD2Ev at 0xef18
================================================================================

void __fastcall pqxx::result::~result(pqxx::result *this)
{
  std::shared_ptr<pqxx::internal::notice_waiters>::~shared_ptr((__int64)this + 32);
  std::shared_ptr<std::string const>::~shared_ptr((__int64)this + 16);
  std::shared_ptr<pg_result const>::~shared_ptr((__int64)this);
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2EPKcm at 0xef58
================================================================================

_QWORD *__fastcall std::string_view::basic_string_view(_QWORD *a1, __int64 a2, __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a3;
  result = a1;
  a1[1] = a2;
  return result;
}



================================================================================
Function: _ZN4pqxx6params11append_packEv at 0xef86
================================================================================

void __fastcall pqxx::params::append_pack(pqxx::params *this)
{
  ;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE13_Rb_tree_implISF_Lb1EED2Ev at 0xef96
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree_impl<std::less<std::string>,true>::~_Rb_tree_impl(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EEC2Ev at 0xefae
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree(
        __int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree_impl<std::less<std::string>,true>::_Rb_tree_impl(a1);
}



================================================================================
Function: _ZNSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverESt4lessIS5_ESaISt4pairIKS5_S8_EEEC2Ev at 0xefce
================================================================================

__int64 __fastcall std::multimap<std::string,pqxx::notification_receiver *>::multimap(__int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree(a1);
}



================================================================================
Function: _ZNSt8multimapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverESt4lessIS5_ESaISt4pairIKS5_S8_EEED2Ev at 0xefee
================================================================================

__int64 __fastcall std::multimap<std::string,pqxx::notification_receiver *>::~multimap(__int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::~_Rb_tree(a1);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE13_Rb_tree_implISH_Lb1EED2Ev at 0xf00e
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree_impl<std::less<std::string>,true>::~_Rb_tree_impl(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EEC2Ev at 0xf026
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree(
        __int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree_impl<std::less<std::string>,true>::_Rb_tree_impl(a1);
}



================================================================================
Function: _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEESt4lessIS5_ESaISt4pairIKS5_SA_EEEC2Ev at 0xf046
================================================================================

__int64 __fastcall std::map<std::string,std::function<void ()(pqxx::notification)>>::map(__int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree(a1);
}



================================================================================
Function: _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEESt4lessIS5_ESaISt4pairIKS5_SA_EEED2Ev at 0xf066
================================================================================

__int64 __fastcall std::map<std::string,std::function<void ()(pqxx::notification)>>::~map(__int64 a1)
{
  return std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::~_Rb_tree(a1);
}



================================================================================
Function: _ZN4pqxx10connectionC2EPKc at 0xf086
================================================================================

__int64 __fastcall pqxx::connection::connection(pqxx::connection *this, const char *a2)
{
  pqxx *v2; // rdi

  *(_QWORD *)this = 0;
  *((_QWORD *)this + 1) = 0;
  std::shared_ptr<pqxx::internal::notice_waiters>::shared_ptr((char *)this + 16);
  std::multimap<std::string,pqxx::notification_receiver *>::multimap((__int64)this + 32);
  v2 = (pqxx::connection *)((char *)this + 80);
  std::map<std::string,std::function<void ()(pqxx::notification)>>::map((__int64)v2);
  *((_DWORD *)this + 32) = 0;
  pqxx::check_version(v2);
  return pqxx::connection::init(this, a2);
}



================================================================================
Function: _ZN4pqxx10connectionC2ENS_5zviewE at 0xf152
================================================================================

__int64 __fastcall pqxx::connection::connection(pqxx::connection *a1, __int64 a2, __int64 a3)
{
  const char *v3; // rax
  _QWORD v5[3]; // [rsp+0h] [rbp-20h] BYREF
  pqxx::connection *v6; // [rsp+18h] [rbp-8h]

  v6 = a1;
  v5[0] = a2;
  v5[1] = a3;
  v3 = (const char *)pqxx::zview::c_str((__int64)v5);
  return pqxx::connection::connection(v6, v3);
}



================================================================================
Function: _ZNKR4pqxx5field4viewEv at 0xf19c
================================================================================

__int64 __fastcall pqxx::field::view(pqxx::field *a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  __int64 v4; // [rsp+10h] [rbp-20h] BYREF

  v1 = pqxx::field::size(a1);
  v2 = pqxx::field::c_str();
  std::string_view::basic_string_view(&v4, v2, v1);
  return v4;
}



================================================================================
Function: _ZN4pqxx5fieldD2Ev at 0xf1ec
================================================================================

void __fastcall pqxx::field::~field(pqxx::field *this)
{
  pqxx::result::~result((pqxx::field *)((char *)this + 8));
}



================================================================================
Function: _ZN4pqxx3rowD2Ev at 0xf210
================================================================================

void __fastcall pqxx::row::~row(pqxx::row *this)
{
  pqxx::result::~result(this);
}



================================================================================
Function: _ZN4pqxx8internal8c_paramsD2Ev at 0xf230
================================================================================

void __fastcall pqxx::internal::c_params::~c_params(pqxx::internal::c_params *this)
{
  std::vector<pqxx::format>::~vector((char *)this + 48);
  std::vector<int>::~vector((char *)this + 24);
  std::vector<char const*>::~vector(this);
}



================================================================================
Function: _ZN4pqxx16transaction_base4execESt17basic_string_viewIcSt11char_traitsIcEENS_6paramsE at 0xf270
================================================================================

__int64 __fastcall pqxx::transaction_base::exec(__int64 a1)
{
  _BYTE v2[88]; // [rsp+30h] [rbp-60h] BYREF

  pqxx::params::make_c_params((pqxx::params *)v2);
  pqxx::transaction_base::internal_exec_params();
  pqxx::internal::c_params::~c_params((pqxx::internal::c_params *)v2);
  return a1;
}



================================================================================
Function: _ZN4pqxx16transaction_base4execESt17basic_string_viewIcSt11char_traitsIcEE at 0xf306
================================================================================

__int64 __fastcall pqxx::transaction_base::exec(__int64 a1)
{
  __int64 v2; // [rsp+20h] [rbp-20h] BYREF

  std::string_view::basic_string_view(&v2);
  pqxx::transaction_base::exec();
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EE12_Vector_implD2Ev at 0xf362
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl::~_Vector_impl(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EEC2Ev at 0xf37a
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_base(
        __int64 a1)
{
  return std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl::_Vector_impl(a1);
}



================================================================================
Function: _ZNSt6vectorISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EEC2Ev at 0xf39a
================================================================================

__int64 __fastcall std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::vector(
        __int64 a1)
{
  return std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_base(a1);
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EE12_Vector_implC2EvQ26is_default_constructible_vIN9__gnu_cxx14__alloc_traitsIT0_NSL_10value_typeEE6rebindIT_E5otherEE at 0xf3ba
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl::_Vector_impl(
        __int64 a1)
{
  return std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl_data::_Vector_impl_data(a1);
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EE17_Vector_impl_dataC2Ev at 0xf3ec
================================================================================

_QWORD *__fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl_data::_Vector_impl_data(
        _QWORD *a1)
{
  _QWORD *result; // rax

  *a1 = 0;
  a1[1] = 0;
  result = a1;
  a1[2] = 0;
  return result;
}



================================================================================
Function: _ZN4pqxx6paramsD2Ev at 0xf41e
================================================================================

void __fastcall pqxx::params::~params(pqxx::params *this)
{
  std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::~vector(this);
}



================================================================================
Function: _ZNSt9__unicode17__is_scalar_valueEDi at 0xf43d
================================================================================

_BOOL8 __fastcall std::__unicode::__is_scalar_value(std::__unicode *this)
{
  if ( (unsigned int)this <= 0xD7FF )
    return 1;
  return (unsigned int)this > 0xDFFF && (unsigned int)this <= 0x10FFFF;
}



================================================================================
Function: _ZNKSt9__unicode5_ReplclEv at 0xf47a
================================================================================

__int64 std::__unicode::_Repl::operator()()
{
  return 65533;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_013__field_widthEDi at 0xf48d
================================================================================

unsigned __int64 __fastcall std::__unicode::__v16_0_0::__field_width(std::__unicode::__v16_0_0 *this)
{
  _DWORD v2[3]; // [rsp+Ch] [rbp-14h] BYREF
  __int64 v3; // [rsp+18h] [rbp-8h]

  v2[0] = (_DWORD)this;
  if ( (unsigned int)this < 0x1100 )
    return 1;
  v3 = std::upper_bound<char32_t const*,char32_t>(&std::__unicode::__v16_0_0::__width_edges, &unk_294D8, v2);
  return (((v3 - (__int64)&std::__unicode::__v16_0_0::__width_edges < 0)
         + (unsigned __int8)((v3 - (__int64)&std::__unicode::__v16_0_0::__width_edges) >> 2))
        & 1)
       - ((unsigned __int64)(v3 - (_QWORD)&std::__unicode::__v16_0_0::__width_edges) >> 63)
       + 1;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_024__should_escape_categoryEDi at 0xf504
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::__should_escape_category(std::__unicode::__v16_0_0 *this)
{
  int v2; // [rsp+14h] [rbp-1Ch] BYREF
  __int64 v3; // [rsp+18h] [rbp-18h]
  void *v4; // [rsp+20h] [rbp-10h]
  int v5; // [rsp+2Ch] [rbp-4h]

  v5 = 1;
  v4 = &unk_2ABE4;
  v2 = 2 * (_DWORD)this + 2;
  v3 = std::lower_bound<unsigned int const*,unsigned int>(&std::__unicode::__v16_0_0::__escape_edges, &unk_2ABE4, &v2);
  return *(_DWORD *)(v3 - 4) & 1;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_033__grapheme_cluster_break_propertyEDi at 0xf560
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::__grapheme_cluster_break_property(std::__unicode::__v16_0_0 *this)
{
  int v2; // [rsp+14h] [rbp-1Ch] BYREF
  __int64 v3; // [rsp+18h] [rbp-18h]
  void *v4; // [rsp+20h] [rbp-10h]
  int v5; // [rsp+2Ch] [rbp-4h]

  v5 = 15;
  v4 = &unk_2C6D4;
  v2 = (16 * (_DWORD)this) | 0xF;
  v3 = std::lower_bound<unsigned int const*,unsigned int>(&std::__unicode::__v16_0_0::__gcb_edges, &unk_2C6D4, &v2);
  return *(_DWORD *)(v3 - 4) & 0xF;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_016__is_incb_linkerEDi at 0xf5ba
================================================================================

bool __fastcall std::__unicode::__v16_0_0::__is_incb_linker(std::__unicode::__v16_0_0 *this)
{
  __int64 v1; // rax
  _DWORD v3[3]; // [rsp+Ch] [rbp-14h] BYREF
  void *v4; // [rsp+18h] [rbp-8h]

  v3[0] = (_DWORD)this;
  v4 = &unk_2C6F8;
  v1 = std::find<char32_t const*,char32_t>(&std::__unicode::__v16_0_0::__incb_linkers, &unk_2C6F8, v3);
  return v4 != (void *)v1;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_015__incb_propertyEDi at 0xf5f7
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::__incb_property(std::__unicode::__v16_0_0 *this)
{
  int v2; // [rsp+14h] [rbp-1Ch] BYREF
  __int64 v3; // [rsp+18h] [rbp-18h]
  void *v4; // [rsp+20h] [rbp-10h]
  int v5; // [rsp+2Ch] [rbp-4h]

  if ( (unsigned int)(4 * (_DWORD)this) < 0xC02 )
    return 0;
  v5 = 3;
  v4 = &unk_2D358;
  v2 = (4 * (_DWORD)this) | 3;
  v3 = std::lower_bound<unsigned int const*,unsigned int>(&std::__unicode::__v16_0_0::__incb_edges, &unk_2D358, &v2);
  return *(_DWORD *)(v3 - 4) & 3;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_026__is_extended_pictographicEDi at 0xf667
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::__is_extended_pictographic(std::__unicode::__v16_0_0 *this)
{
  _DWORD v2[3]; // [rsp+Ch] [rbp-14h] BYREF

  v2[0] = (_DWORD)this;
  if ( (unsigned int)this >= 0xA9 )
    return ((std::upper_bound<char32_t const*,char32_t>(&std::__unicode::__v16_0_0::__xpicto_edges, &unk_2D5D0, v2)
           - (__int64)&std::__unicode::__v16_0_0::__xpicto_edges) >> 2)
         & 1;
  else
    return 0;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_031_Grapheme_cluster_iterator_base8_M_resetEDiNS0_13_Gcb_propertyE at 0xf6c8
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_reset(__int64 a1, int a2, int a3)
{
  __int64 result; // rax

  *(_DWORD *)a1 = a2;
  *(_DWORD *)(a1 + 4) = a3;
  *(_BYTE *)(a1 + 8) = 0;
  *(_BYTE *)(a1 + 9) = 0;
  result = a1;
  *(_BYTE *)(a1 + 10) = 0;
  return result;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_031_Grapheme_cluster_iterator_base26_M_update_xpicto_seq_stateEDiNS0_13_Gcb_propertyE at 0xf708
================================================================================

unsigned int *__fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_xpicto_seq_state(
        unsigned int *a1,
        unsigned int a2,
        int a3)
{
  unsigned int *result; // rax
  char v5; // [rsp+1Fh] [rbp-1h]

  result = (unsigned int *)*((unsigned __int8 *)a1 + 8);
  if ( (_BYTE)result != 3 )
  {
    v5 = 3;
    if ( *((_BYTE *)a1 + 8) == 1 )
    {
      if ( !a3
        && (unsigned __int8)std::__unicode::__v16_0_0::__is_extended_pictographic((std::__unicode::__v16_0_0 *)a2) )
      {
        v5 = 2;
      }
    }
    else if ( a3 == 10 )
    {
      if ( *((_BYTE *)a1 + 8) == 2 )
      {
        v5 = 1;
      }
      else if ( (unsigned __int8)std::__unicode::__v16_0_0::__is_extended_pictographic((std::__unicode::__v16_0_0 *)*a1) )
      {
        v5 = 1;
      }
    }
    else if ( a3 == 4 )
    {
      v5 = *((_BYTE *)a1 + 8);
    }
    result = a1;
    *((_BYTE *)a1 + 8) = v5;
  }
  return result;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_031_Grapheme_cluster_iterator_base18_M_update_ri_countENS0_13_Gcb_propertyE at 0xf7b8
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_ri_count(__int64 a1, int a2)
{
  __int64 result; // rax

  result = a1;
  if ( a2 == 13 )
    ++*(_BYTE *)(a1 + 9);
  else
    *(_BYTE *)(a1 + 9) = 0;
  return result;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_031_Grapheme_cluster_iterator_base20_M_update_incb_stateEDiNS0_13_Gcb_propertyE at 0xf7ec
================================================================================

bool __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_incb_state(
        __int64 a1,
        unsigned int a2)
{
  bool result; // al

  result = std::__unicode::__v16_0_0::__is_incb_linker((std::__unicode::__v16_0_0 *)a2);
  if ( result )
  {
    result = a1;
    *(_BYTE *)(a1 + 10) = 1;
  }
  return result;
}



================================================================================
Function: _ZNSt8__detail25__from_chars_alnum_to_valILb0EEEhh at 0xf81b
================================================================================

__int64 __fastcall std::__detail::__from_chars_alnum_to_val<false>(unsigned __int8 a1)
{
  return std::__detail::__from_chars_alnum_to_val_table<false>::value[a1];
}



================================================================================
Function: _ZNSt12format_errorC2EPKc at 0xf83c
================================================================================

std::format_error *__fastcall std::format_error::format_error(std::format_error *this, const char *a2)
{
  std::format_error *result; // rax

  std::runtime_error::runtime_error(this, a2);
  result = this;
  *(_QWORD *)this = off_37940;
  return result;
}



================================================================================
Function: _ZNSt12format_errorD2Ev at 0xf874
================================================================================

void __fastcall std::format_error::~format_error(std::runtime_error *a1)
{
  *(_QWORD *)a1 = off_37940;
  std::runtime_error::~runtime_error(a1);
}



================================================================================
Function: _ZNSt12format_errorD0Ev at 0xf8a2
================================================================================

void __fastcall std::format_error::~format_error(std::format_error *this)
{
  std::format_error::~format_error(this);
  operator delete(this, 0x10u);
}



================================================================================
Function: _ZSt20__throw_format_errorPKc at 0xf8d1
================================================================================

void __fastcall __noreturn std::__throw_format_error(const char *a1)
{
  std::format_error *exception; // rbx

  exception = (std::format_error *)__cxa_allocate_exception(0x10u);
  std::format_error::format_error(exception, a1);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'std::format_error,
    (void (*)(void *))std::format_error::~format_error);
}



================================================================================
Function: _ZNSt8__format39__unmatched_left_brace_in_format_stringEv at 0xf933
================================================================================

void __fastcall __noreturn std::__format::__unmatched_left_brace_in_format_string(std::__format *this)
{
  std::__throw_format_error("format error: unmatched '{' in format string");
}



================================================================================
Function: _ZNSt8__format40__unmatched_right_brace_in_format_stringEv at 0xf94a
================================================================================

void __fastcall __noreturn std::__format::__unmatched_right_brace_in_format_string(std::__format *this)
{
  std::__throw_format_error("format error: unmatched '}' in format string");
}



================================================================================
Function: _ZNSt8__format39__conflicting_indexing_in_format_stringEv at 0xf961
================================================================================

void __fastcall __noreturn std::__format::__conflicting_indexing_in_format_string(std::__format *this)
{
  std::__throw_format_error("format error: conflicting indexing style in format string");
}



================================================================================
Function: _ZNSt8__format33__invalid_arg_id_in_format_stringEv at 0xf978
================================================================================

void __fastcall __noreturn std::__format::__invalid_arg_id_in_format_string(std::__format *this)
{
  std::__throw_format_error("format error: invalid arg-id in format string");
}



================================================================================
Function: _ZNSt8__format29__failed_to_parse_format_specEv at 0xf98f
================================================================================

void __fastcall __noreturn std::__format::__failed_to_parse_format_spec(std::__format *this)
{
  std::__throw_format_error("format error: failed to parse format-spec");
}



================================================================================
Function: _ZNSt8__format10__is_digitEc at 0xf9a6
================================================================================

bool __fastcall std::__format::__is_digit(std::__format *this)
{
  return (unsigned __int8)std::__detail::__from_chars_alnum_to_val<false>((unsigned __int8)this) <= 9u;
}



================================================================================
Function: _ZNSt8__format11__is_xdigitEc at 0xf9cc
================================================================================

bool __fastcall std::__format::__is_xdigit(std::__format *this)
{
  return (unsigned __int8)std::__detail::__from_chars_alnum_to_val<false>((unsigned __int8)this) <= 0xFu;
}



================================================================================
Function: _ZNSt8__format23__should_escape_unicodeEDib at 0xf9f2
================================================================================

bool __fastcall std::__format::__should_escape_unicode(std::__format *this, char a2)
{
  if ( (unsigned __int8)std::__unicode::__v16_0_0::__should_escape_category((std::__unicode::__v16_0_0 *)(unsigned int)this) )
    return (_DWORD)this != 32;
  if ( a2 != 1 )
    return 0;
  return (unsigned int)std::__unicode::__v16_0_0::__grapheme_cluster_break_property((std::__unicode::__v16_0_0 *)(unsigned int)this) == 4;
}



================================================================================
Function: _ZNSt8__format16_Optional_localeC2ERKSt6locale at 0xfa42
================================================================================

std::__format::_Optional_locale *__fastcall std::__format::_Optional_locale::_Optional_locale(
        std::__format::_Optional_locale *this,
        const std::locale *a2)
{
  std::__format::_Optional_locale *result; // rax

  std::locale::locale(this, a2);
  result = this;
  *((_BYTE *)this + 8) = 1;
  return result;
}



================================================================================
Function: _ZNSt8__format16_Optional_localeD2Ev at 0xfa74
================================================================================

void __fastcall std::__format::_Optional_locale::~_Optional_locale(std::__format::_Optional_locale *this)
{
  if ( *((_BYTE *)this + 8) )
    std::locale::~locale(this);
}



================================================================================
Function: _ZNSt8__format16_Optional_locale5valueEv at 0xfaa0
================================================================================

std::__format::_Optional_locale *__fastcall std::__format::_Optional_locale::value(
        std::__format::_Optional_locale *this)
{
  if ( *((_BYTE *)this + 8) != 1 )
  {
    ZSt12construct_atISt6localeJEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S1_pispcl7declvalIT0_EEEEEPS1_S4_DpOS3_(this);
    *((_BYTE *)this + 8) = 1;
  }
  return this;
}



================================================================================
Function: _ZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev at 0xfada
================================================================================

void __fastcall std::__format::_Seq_sink<std::string>::~_Seq_sink(_QWORD *a1)
{
  *a1 = off_377B8;
  std::string::~string((__int64)(a1 + 36));
}



================================================================================
Function: _ZSt7vformatB5cxx11St17basic_string_viewIcSt11char_traitsIcEESt17basic_format_argsISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE at 0xfb0d
================================================================================

__int64 __fastcall std::vformat[abi:cxx11](__int64 a1, __int64 a2, __int64 a3, __int64 a4, __int64 a5)
{
  _QWORD v9[6]; // [rsp+30h] [rbp-1E0h] BYREF
  _QWORD v10[2]; // [rsp+60h] [rbp-1B0h] BYREF
  _QWORD v11[4]; // [rsp+70h] [rbp-1A0h] BYREF
  __int64 v12; // [rsp+90h] [rbp-180h] BYREF
  _QWORD v13[6]; // [rsp+190h] [rbp-80h] BYREF
  __int64 v14; // [rsp+1C0h] [rbp-50h] BYREF
  __int64 v15; // [rsp+1C8h] [rbp-48h]
  _QWORD *v16; // [rsp+1D8h] [rbp-38h]
  _QWORD *v17; // [rsp+1E0h] [rbp-30h]
  _QWORD *v18; // [rsp+1E8h] [rbp-28h]
  _QWORD *v19; // [rsp+1F0h] [rbp-20h]
  _QWORD *v20; // [rsp+1F8h] [rbp-18h]

  v17 = v11;
  std::span<char,18446744073709551615ul>::span<256ul>(&v14, &v12);
  v16 = v11;
  v10[0] = v14;
  v10[1] = v15;
  v11[0] = &off_37918;
  v11[1] = v14;
  v11[2] = v15;
  v11[3] = std::span<char,18446744073709551615ul>::begin(v10);
  *v17 = &off_378F0;
  v11[0] = off_377B8;
  std::string::basic_string(v13);
  v20 = v11;
  v19 = v11;
  v18 = v11;
  v13[5] = v11;
  v9[5] = v11;
  v9[2] = a2;
  v9[3] = a3;
  v9[0] = a4;
  v9[1] = a5;
  std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
    v11,
    a2,
    a3,
    v9,
    0);
  std::__format::_Seq_sink<std::string>::get(a1, v11);
  std::__format::_Seq_sink<std::string>::~_Seq_sink(v11);
  return a1;
}



================================================================================
Function: _ZNSt8__format8_ScannerIcE14_Parse_contextCI2St26basic_format_parse_contextIcEESt17basic_string_viewIcSt11char_traitsIcEEm at 0xfd04
================================================================================

__int64 __fastcall ZNSt8__format8_ScannerIcE14_Parse_contextCI2St26basic_format_parse_contextIcEESt17basic_string_viewIcSt11char_traitsIcEEm(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  __int64 result; // rax

  std::basic_format_parse_context<char>::basic_format_parse_context(a1, a2, a3, a4, a5, a6, a2, a3, a4);
  result = a1;
  *(_QWORD *)(a1 + 40) = 0;
  return result;
}



================================================================================
Function: _ZNSt8__format8_ScannerIcEC2ESt17basic_string_viewIcSt11char_traitsIcEEm at 0xfd58
================================================================================

__int64 __fastcall std::__format::_Scanner<char>::_Scanner(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  *a1 = &off_378D0;
  return ZNSt8__format8_ScannerIcE14_Parse_contextCI2St26basic_format_parse_contextIcEESt17basic_string_viewIcSt11char_traitsIcEEm(
           (__int64)(a1 + 1),
           a2,
           a3,
           a4,
           a5,
           a6);
}



================================================================================
Function: _ZNSt26basic_format_parse_contextIcEC2ESt17basic_string_viewIcSt11char_traitsIcEEm at 0xfdb6
================================================================================

__int64 __fastcall std::basic_format_parse_context<char>::basic_format_parse_context(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v4; // rax
  __int64 v5; // rax
  __int64 result; // rax
  _QWORD v7[2]; // [rsp+0h] [rbp-20h] BYREF
  __int64 v8; // [rsp+10h] [rbp-10h]
  __int64 v9; // [rsp+18h] [rbp-8h]

  v9 = a1;
  v7[0] = a2;
  v7[1] = a3;
  v8 = a4;
  v4 = std::string_view::begin(v7);
  *(_QWORD *)v9 = v4;
  v5 = std::string_view::end(v7);
  *(_QWORD *)(v9 + 8) = v5;
  *(_DWORD *)(v9 + 16) = 0;
  *(_QWORD *)(v9 + 24) = 0;
  result = v9;
  *(_QWORD *)(v9 + 32) = v8;
  return result;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5beginEv at 0xfe30
================================================================================

__int64 __fastcall std::string_view::begin(__int64 a1)
{
  return *(_QWORD *)(a1 + 8);
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE3endEv at 0xfe46
================================================================================

__int64 __fastcall std::string_view::end(_QWORD *a1)
{
  return a1[1] + *a1;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEEixEm at 0xfe66
================================================================================

unsigned __int64 __fastcall std::string_view::operator[](unsigned __int64 *a1, unsigned __int64 a2)
{
  if ( a2 >= *a1 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/string_view",
      260,
      "constexpr const std::basic_string_view<_CharT, _Traits>::value_type& std::basic_string_view<_CharT, _Traits>::oper"
      "ator[](size_type) const [with _CharT = char; _Traits = std::char_traits<char>; const_reference = const char&; size"
      "_type = long unsigned int]",
      "__pos < this->_M_len");
  return a1[1] + a2;
}



================================================================================
Function: _ZNSt8__format8_ScannerIcE7_M_scanEv at 0xfec4
================================================================================

char __fastcall std::__format::_Scanner<char>::_M_scan(void (__fastcall ***a1)(_QWORD, unsigned __int64))
{
  __int64 v1; // rdx
  __int64 v3; // rax
  void (__fastcall *v4)(_QWORD, unsigned __int64); // rbx
  __int64 arg_id; // rax
  char result; // al
  bool v7; // al
  void (__fastcall *v8)(_QWORD, __int64); // rbx
  __int64 v9; // rax
  __int64 v10; // rax
  unsigned __int64 v11; // rbx
  __int64 v13; // rax
  __int64 v14; // rdx
  __int64 v15; // rdx
  __int64 v16; // rax
  __int64 v18; // rax
  __int64 v19; // rdx
  unsigned __int8 v20; // [rsp+1Fh] [rbp-51h]
  __int64 v21; // [rsp+20h] [rbp-50h] BYREF
  __int64 v22; // [rsp+28h] [rbp-48h]
  unsigned __int64 v23; // [rsp+38h] [rbp-38h]
  bool v24; // [rsp+47h] [rbp-29h]
  __int64 v25; // [rsp+48h] [rbp-28h]
  unsigned __int64 v26; // [rsp+50h] [rbp-20h]
  unsigned __int64 v27; // [rsp+58h] [rbp-18h]

  v21 = std::__format::_Scanner<char>::_M_fmt_str(a1);
  v22 = v1;
  if ( std::string_view::size((__int64)&v21) == 2
    && *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v21, 0) == 123
    && *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v21, 1u) == 125 )
  {
    v3 = std::__format::_Scanner<char>::begin(a1);
    std::basic_format_parse_context<char>::advance_to(a1 + 1, v3 + 1);
    v4 = (*a1)[1];
    arg_id = std::basic_format_parse_context<char>::next_arg_id(a1 + 1);
    return ((__int64 (__fastcall *)(_QWORD, __int64))v4)(a1, arg_id);
  }
  else
  {
    v27 = std::string_view::find(&v21, 123, 0);
    v26 = std::string_view::find(&v21, 125, 0);
    while ( 1 )
    {
      result = std::string_view::size((__int64)&v21) != 0;
      if ( !result )
        break;
      if ( v27 == v26 )
      {
        v20 = 0;
        v7 = std::operator==(0);
      }
      else if ( v27 >= v26 )
      {
        v20 = 1;
        v7 = std::operator==(1);
      }
      else
      {
        v20 = -1;
        v7 = std::operator==(255);
      }
      if ( v7 )
      {
        v8 = (void (__fastcall *)(_QWORD, __int64))**a1;
        v9 = std::__format::_Scanner<char>::end(a1);
        v8(a1, v9);
        v10 = std::__format::_Scanner<char>::end(a1);
        return std::basic_format_parse_context<char>::advance_to(a1 + 1, v10);
      }
      if ( std::operator<(v20) )
      {
        v11 = v27 + 1;
        if ( v11 == std::string_view::size((__int64)&v21)
          || v26 == -1 && *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v21, v27 + 1) != 123 )
        {
          std::__format::__unmatched_left_brace_in_format_string((std::__format *)&v21);
        }
        v24 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v21, v27 + 1) == 123;
        v13 = std::__format::_Scanner<char>::begin(a1);
        v23 = v24 + v27 + v13;
        (**a1)(a1, v23);
        std::basic_format_parse_context<char>::advance_to(a1 + 1, v23 + 1);
        v21 = std::__format::_Scanner<char>::_M_fmt_str(a1);
        v22 = v14;
        if ( v24 )
        {
          if ( v26 != -1 )
            v26 = v26 - v27 - 2;
          v27 = std::string_view::find(&v21, 123, 0);
        }
        else
        {
          std::__format::_Scanner<char>::_M_on_replacement_field(a1);
          v21 = std::__format::_Scanner<char>::_M_fmt_str(a1);
          v22 = v15;
          v27 = std::string_view::find(&v21, 123, 0);
          v26 = std::string_view::find(&v21, 125, 0);
        }
      }
      else
      {
        ++v26;
        v16 = std::string_view::size((__int64)&v21);
        if ( v26 == v16 || *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v21, v26) != 125 )
          std::__format::__unmatched_right_brace_in_format_string((std::__format *)&v21);
        v18 = std::__format::_Scanner<char>::begin(a1);
        v25 = v26 + v18;
        (**a1)(a1, v26 + v18);
        std::basic_format_parse_context<char>::advance_to(a1 + 1, v25 + 1);
        v21 = std::__format::_Scanner<char>::_M_fmt_str(a1);
        v22 = v19;
        if ( v27 != -1 )
          v27 = v27 - v26 - 1;
        v26 = std::string_view::find(&v21, 125, 0);
      }
    }
  }
  return result;
}



================================================================================
Function: _ZNKSt8__format8_ScannerIcE10_M_fmt_strEv at 0x102be
================================================================================

__int64 __fastcall std::__format::_Scanner<char>::_M_fmt_str(__int64 a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  __int64 v4; // [rsp+10h] [rbp-20h] BYREF

  v1 = std::__format::_Scanner<char>::begin(a1);
  v2 = std::__format::_Scanner<char>::end(a1);
  std::string_view::basic_string_view<char const*,char const*>(&v4, v1, v2);
  return v4;
}



================================================================================
Function: _ZNKSt8__format8_ScannerIcE5beginEv at 0x1030a
================================================================================

__int64 __fastcall std::__format::_Scanner<char>::begin(__int64 a1)
{
  return std::basic_format_parse_context<char>::begin(a1 + 8);
}



================================================================================
Function: _ZNKSt26basic_format_parse_contextIcE5beginEv at 0x1032c
================================================================================

__int64 __fastcall std::basic_format_parse_context<char>::begin(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNKSt8__format8_ScannerIcE3endEv at 0x10342
================================================================================

__int64 __fastcall std::__format::_Scanner<char>::end(__int64 a1)
{
  return std::basic_format_parse_context<char>::end(a1 + 8);
}



================================================================================
Function: _ZNKSt26basic_format_parse_contextIcE3endEv at 0x10364
================================================================================

__int64 __fastcall std::basic_format_parse_context<char>::end(__int64 a1)
{
  return *(_QWORD *)(a1 + 8);
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2IPKcS5_EET_T0_ at 0x1037a
================================================================================

_QWORD *__fastcall std::string_view::basic_string_view<char const*,char const*>(_QWORD *a1, __int64 a2, __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a3 - a2;
  result = a1;
  a1[1] = a2;
  return result;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4findEcm at 0x103b8
================================================================================

char *__fastcall std::string_view::find(unsigned __int64 *a1, char a2, unsigned __int64 a3)
{
  char v4[4]; // [rsp+14h] [rbp-2Ch] BYREF
  unsigned __int64 *v5; // [rsp+18h] [rbp-28h]
  char *v6; // [rsp+28h] [rbp-18h]
  size_t v7; // [rsp+30h] [rbp-10h]
  __int64 v8; // [rsp+38h] [rbp-8h]

  v5 = a1;
  v4[0] = a2;
  v8 = -1;
  if ( a3 < *a1 )
  {
    v7 = *v5 - a3;
    v6 = (char *)std::char_traits<char>::find((const void *)(v5[1] + a3), v7, v4);
    if ( v6 )
      return &v6[-v5[1]];
  }
  return (char *)v8;
}



================================================================================
Function: _ZN9__gnu_cxx11char_traitsIcE4findEPKcmRS2_ at 0x1043c
================================================================================

__int64 __fastcall __gnu_cxx::char_traits<char>::find(__int64 a1, unsigned __int64 a2, _BYTE *a3)
{
  unsigned __int64 i; // [rsp+28h] [rbp-8h]

  for ( i = 0; i < a2; ++i )
  {
    if ( __gnu_cxx::char_traits<char>::eq((_BYTE *)(i + a1), a3) )
      return a1 + i;
  }
  return 0;
}



================================================================================
Function: _ZNSt8__format8_ScannerIcE11_M_on_charsEPKc at 0x104a0
================================================================================

void std::__format::_Scanner<char>::_M_on_chars()
{
  ;
}



================================================================================
Function: _ZNSt26basic_format_parse_contextIcE10advance_toEPKc at 0x104b4
================================================================================

_QWORD *__fastcall std::basic_format_parse_context<char>::advance_to(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZSt3getILm0EtPKcEONSt13tuple_elementIXT_ESt4pairIT0_T1_EE4typeEOS6_ at 0x104d2
================================================================================

__int64 __fastcall std::get<0ul,unsigned short,char const*>(__int64 a1)
{
  return std::__pair_get<0ul>::__move_get<unsigned short,char const*>(a1);
}



================================================================================
Function: _ZNSt10__pair_getILm0EE10__move_getItPKcEEOT_OSt4pairIS4_T0_E at 0x104f8
================================================================================

__int64 __fastcall std::__pair_get<0ul>::__move_get<unsigned short,char const*>(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZSt3getILm1EtPKcEONSt13tuple_elementIXT_ESt4pairIT0_T1_EE4typeEOS6_ at 0x10512
================================================================================

__int64 __fastcall std::get<1ul,unsigned short,char const*>(__int64 a1)
{
  return std::__pair_get<1ul>::__move_get<unsigned short,char const*>(a1);
}



================================================================================
Function: _ZNSt10__pair_getILm1EE10__move_getItPKcEEOT0_OSt4pairIT_S4_E at 0x10538
================================================================================

__int64 __fastcall std::__pair_get<1ul>::__move_get<unsigned short,char const*>(__int64 a1)
{
  return a1 + 8;
}



================================================================================
Function: _ZNSt8__format8_ScannerIcE23_M_on_replacement_fieldEv at 0x10556
================================================================================

_QWORD *__fastcall std::__format::_Scanner<char>::_M_on_replacement_field(std::__format *a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  __int64 v3; // rdx
  __int64 v4; // rbx
  __int64 v6; // rax
  int v8; // [rsp+10h] [rbp-40h] BYREF
  __int64 v9; // [rsp+18h] [rbp-38h]
  __int64 *v10; // [rsp+20h] [rbp-30h]
  unsigned __int16 *v11; // [rsp+28h] [rbp-28h]
  _BYTE *v12; // [rsp+30h] [rbp-20h]
  __int64 arg_id; // [rsp+38h] [rbp-18h]

  v12 = (_BYTE *)std::__format::_Scanner<char>::begin((__int64)a1);
  if ( *v12 == 125 )
  {
    arg_id = std::basic_format_parse_context<char>::next_arg_id((char *)a1 + 8);
  }
  else if ( *v12 == 58 )
  {
    arg_id = std::basic_format_parse_context<char>::next_arg_id((char *)a1 + 8);
    std::basic_format_parse_context<char>::advance_to((_QWORD *)a1 + 1, (__int64)++v12);
  }
  else
  {
    v1 = std::__format::_Scanner<char>::end((__int64)a1);
    v2 = std::__format::_Scanner<char>::begin((__int64)a1);
    v8 = std::__format::__parse_arg_id<char>(v2, v1);
    v9 = v3;
    v11 = (unsigned __int16 *)std::get<0ul,unsigned short,char const*>((__int64)&v8);
    v10 = (__int64 *)std::get<1ul,unsigned short,char const*>((__int64)&v8);
    if ( !*v10 || *(_BYTE *)*v10 != 125 && *(_BYTE *)*v10 != 58 )
      std::__format::__invalid_arg_id_in_format_string((std::__format *)&v8);
    arg_id = *v11;
    std::basic_format_parse_context<char>::check_arg_id((char *)a1 + 8, arg_id);
    if ( *(_BYTE *)*v10 == 58 )
      ++*v10;
    std::basic_format_parse_context<char>::advance_to((_QWORD *)a1 + 1, *v10);
  }
  (*(void (__fastcall **)(std::__format *, __int64))(*(_QWORD *)a1 + 8LL))(a1, arg_id);
  v4 = std::__format::_Scanner<char>::begin((__int64)a1);
  if ( v4 == std::__format::_Scanner<char>::end((__int64)a1)
    || *(_BYTE *)std::__format::_Scanner<char>::begin((__int64)a1) != 125 )
  {
    std::__format::__unmatched_left_brace_in_format_string(a1);
  }
  v6 = std::__format::_Scanner<char>::begin((__int64)a1);
  return std::basic_format_parse_context<char>::advance_to((_QWORD *)a1 + 1, v6 + 1);
}



================================================================================
Function: _ZNSt26basic_format_parse_contextIcE11next_arg_idEv at 0x10766
================================================================================

__int64 __fastcall std::basic_format_parse_context<char>::next_arg_id(__int64 a1)
{
  __int64 result; // rax

  if ( *(_DWORD *)(a1 + 16) == 1 )
    std::__format::__conflicting_indexing_in_format_string((std::__format *)a1);
  *(_DWORD *)(a1 + 16) = 2;
  if ( (unsigned __int8)std::is_constant_evaluated() && *(_QWORD *)(a1 + 24) == *(_QWORD *)(a1 + 32) )
    std::__format::__invalid_arg_id_in_format_string((std::__format *)a1);
  result = *(_QWORD *)(a1 + 24);
  *(_QWORD *)(a1 + 24) = result + 1;
  return result;
}



================================================================================
Function: _ZZNSt8__format15__formatter_strIcE5parseERSt26basic_format_parse_contextIcEENKUlvE_clEv at 0x107cc
================================================================================

__int64 __fastcall std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(
        __int64 *a1)
{
  __int64 v1; // rdx
  __int64 result; // rax

  v1 = a1[1];
  result = *a1;
  *(_QWORD *)result = *(_QWORD *)v1;
  *(_DWORD *)(result + 8) = *(_DWORD *)(v1 + 8);
  return result;
}



================================================================================
Function: _ZZNSt8__format15__formatter_strIcE5parseERSt26basic_format_parse_contextIcEENKUlvE0_clEv at 0x107f6
================================================================================

__int64 __fastcall std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(
        _QWORD **a1)
{
  if ( **a1 != *a1[1] && *(_BYTE *)**a1 != 125 )
    return 0;
  std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(a1[2]);
  return 1;
}



================================================================================
Function: _ZNSt8__format15__formatter_strIcE5parseERSt26basic_format_parse_contextIcE at 0x10850
================================================================================

_BYTE *__fastcall std::__format::__formatter_str<char>::parse(__int64 a1, __int64 a2)
{
  _QWORD *v3[4]; // [rsp+10h] [rbp-50h] BYREF
  _QWORD v4[2]; // [rsp+30h] [rbp-30h] BYREF
  __int64 v5; // [rsp+44h] [rbp-1Ch] BYREF
  int v6; // [rsp+4Ch] [rbp-14h]
  __int64 v7; // [rsp+50h] [rbp-10h] BYREF
  _BYTE *v8; // [rsp+58h] [rbp-8h] BYREF

  v8 = (_BYTE *)std::basic_format_parse_context<char>::begin(a2);
  v7 = std::basic_format_parse_context<char>::end(a2);
  v5 = 0;
  v6 = 32;
  v4[0] = a1;
  v4[1] = &v5;
  v3[0] = &v8;
  v3[1] = &v7;
  v3[2] = v4;
  if ( (unsigned __int8)std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_fill_and_align(&v5, v8, v7);
  if ( (unsigned __int8)std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_width(&v5, v8, v7, a2);
  if ( (unsigned __int8)std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_precision(&v5, v8, v7, a2);
  if ( (unsigned __int8)std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v8;
  if ( *v8 == 115 )
    ++v8;
  if ( !(unsigned __int8)std::__format::__formatter_str<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    std::__format::__failed_to_parse_format_spec((std::__format *)v3);
  return v8;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4dataEv at 0x109a8
================================================================================

__int64 __fastcall std::string_view::data(__int64 a1)
{
  return *(_QWORD *)(a1 + 8);
}



================================================================================
Function: _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_ at 0x109be
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10_impl<unsigned int>(_BYTE *a1, int a2, unsigned int a3)
{
  _BYTE *result; // rax
  char v5[212]; // [rsp+10h] [rbp-E0h] BYREF
  unsigned int v6; // [rsp+E4h] [rbp-Ch]
  int v7; // [rsp+E8h] [rbp-8h]
  int v8; // [rsp+ECh] [rbp-4h]

  strcpy(
    v5,
    "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657"
    "585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
  v8 = a2 - 1;
  while ( a3 > 0x63 )
  {
    v6 = 2 * (a3 % 0x64);
    a3 /= 0x64u;
    a1[v8] = v5[v6 + 1];
    a1[v8 - 1] = v5[v6];
    v8 -= 2;
  }
  if ( a3 <= 9 )
  {
    result = a1;
    *a1 = a3 + 48;
  }
  else
  {
    v7 = 2 * a3;
    a1[1] = v5[2 * a3 + 1];
    result = a1;
    *a1 = v5[v7];
  }
  return result;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNS_9to_stringEiEUlPcmE_EEvmT_EN11_TerminatorD2Ev at 0x10c6a
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::to_string(int)::{lambda(char *,unsigned long)#1}>(unsigned long,std::to_string(int)::{lambda(char *,unsigned long)#1})::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNS_9to_stringEiEUlPcmE_EEvmT_ at 0x10c98
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::to_string(int)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        unsigned __int64 a2,
        __int64 a3,
        int a4)
{
  __int64 v5; // [rsp+0h] [rbp-50h] BYREF
  int v6; // [rsp+8h] [rbp-48h]
  unsigned __int64 v7; // [rsp+10h] [rbp-40h]
  _QWORD *v8; // [rsp+18h] [rbp-38h]
  __int128 v9; // [rsp+20h] [rbp-30h] BYREF
  __int64 v10; // [rsp+30h] [rbp-20h]
  _BYTE *v11; // [rsp+38h] [rbp-18h]

  v8 = a1;
  v7 = a2;
  v5 = a3;
  v6 = a4;
  std::string::reserve(a1, a2);
  v11 = (_BYTE *)std::string::_M_data((__int64)a1);
  v9 = (unsigned __int64)a1;
  v10 = std::to_string(int)::{lambda(char *,unsigned long)#1}::operator()((unsigned __int8 *)&v5, v11, a2);
  *((_QWORD *)&v9 + 1) = v10;
  return std::string::__resize_and_overwrite<std::to_string(int)::{lambda(char *,unsigned long)#1}>(unsigned long,std::to_string(int)::{lambda(char *,unsigned long)#1})::_Terminator::~_Terminator((__int64 *)&v9);
}



================================================================================
Function: _ZNSt8__detail18__to_chars_10_implImEEvPcjT_ at 0x10d96
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10_impl<unsigned long>(_BYTE *a1, int a2, unsigned __int64 a3)
{
  _BYTE *result; // rax
  char v5[216]; // [rsp+18h] [rbp-F0h] BYREF
  unsigned __int64 v6; // [rsp+F0h] [rbp-18h]
  __int64 v7; // [rsp+F8h] [rbp-10h]
  int v8; // [rsp+104h] [rbp-4h]

  strcpy(
    v5,
    "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657"
    "585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
  v8 = a2 - 1;
  while ( a3 > 0x63 )
  {
    v6 = 2 * (a3 % 0x64);
    a3 /= 0x64u;
    a1[v8] = v5[v6 + 1];
    a1[v8 - 1] = v5[v6];
    v8 -= 2;
  }
  if ( a3 <= 9 )
  {
    result = a1;
    *a1 = a3 + 48;
  }
  else
  {
    v7 = 2 * a3;
    a1[1] = v5[2 * a3 + 1];
    result = a1;
    *a1 = v5[v7];
  }
  return result;
}



================================================================================
Function: _ZNSt8__detail18__to_chars_10_implIyEEvPcjT_ at 0x11078
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10_impl<unsigned long long>(_BYTE *a1, int a2, unsigned __int64 a3)
{
  _BYTE *result; // rax
  char v5[216]; // [rsp+18h] [rbp-F0h] BYREF
  unsigned __int64 v6; // [rsp+F0h] [rbp-18h]
  __int64 v7; // [rsp+F8h] [rbp-10h]
  int v8; // [rsp+104h] [rbp-4h]

  strcpy(
    v5,
    "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657"
    "585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
  v8 = a2 - 1;
  while ( a3 > 0x63 )
  {
    v6 = 2 * (a3 % 0x64);
    a3 /= 0x64u;
    a1[v8] = v5[v6 + 1];
    a1[v8 - 1] = v5[v6];
    v8 -= 2;
  }
  if ( a3 <= 9 )
  {
    result = a1;
    *a1 = a3 + 48;
  }
  else
  {
    v7 = 2 * a3;
    a1[1] = v5[2 * a3 + 1];
    result = a1;
    *a1 = v5[v7];
  }
  return result;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEcvSt17basic_string_viewIcS2_EEv at 0x1135a
================================================================================

__int64 __fastcall std::string::operator std::string_view(__int64 a1)
{
  __int64 v1; // rbx
  __int64 v2; // rax
  __int64 v4; // [rsp+10h] [rbp-20h] BYREF

  v1 = std::string::size(a1);
  v2 = std::string::data(a1);
  std::string_view::basic_string_view(&v4, v2, v1);
  return v4;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2EPKcmRKS3_ at 0x113aa
================================================================================

__int64 __fastcall std::string::basic_string(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 v3; // rax

  v3 = std::string::_M_local_data((__int64)a1);
  std::string::_Alloc_hider::_Alloc_hider(a1, v3);
  if ( !a2 && a3 )
    std::__throw_logic_error("basic_string: construction from null is not valid");
  return std::string::_M_construct<char const*>(a1, a2, a3 + a2);
}



================================================================================
Function: _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_ at 0x1144d
================================================================================

_QWORD *__fastcall std::operator+<char>(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 v4; // [rsp+28h] [rbp-8h]

  v4 = std::string::insert(a3, 0, a2);
  std::string::basic_string(a1, v4);
  return a1;
}



================================================================================
Function: _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv at 0x11498
================================================================================

__int64 __fastcall std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(__int64 a1)
{
  return std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use(a1);
}



================================================================================
Function: _ZSt12__to_chars_iIhESt15to_chars_resultPcS1_T_i at 0x114b7
================================================================================

__int64 __fastcall std::__to_chars_i<unsigned char>(_BYTE *a1, unsigned __int64 a2, unsigned __int8 a3, int a4)
{
  if ( a4 <= 1 || a4 > 36 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/charconv",
      326,
      "constexpr std::to_chars_result std::__to_chars_i(char*, char*, _Tp, int) [with _Tp = unsigned char]",
      "2 <= __base && __base <= 36");
  if ( (unsigned __int64)a1 >= a2 )
    return a2;
  if ( !a3 )
  {
    *a1 = 48;
    return (__int64)(a1 + 1);
  }
  if ( a4 == 16 )
    return std::__detail::__to_chars_16<unsigned int>(a1, a2, a3);
  if ( a4 <= 16 )
  {
    if ( a4 == 10 )
      return std::__detail::__to_chars_10<unsigned int>(a1, a2, a3);
    if ( a4 <= 10 )
    {
      if ( a4 == 2 )
        return std::__detail::__to_chars_2<unsigned int>(a1, a2, a3);
      if ( a4 == 8 )
        return std::__detail::__to_chars_8<unsigned int>(a1, a2, a3);
    }
  }
  return std::__detail::__to_chars<unsigned int>(a1, a2, a3, (unsigned int)a4);
}



================================================================================
Function: _ZSt12__to_chars_iIjESt15to_chars_resultPcS1_T_i at 0x11628
================================================================================

__int64 __fastcall std::__to_chars_i<unsigned int>(_BYTE *a1, unsigned __int64 a2, unsigned int a3, int a4)
{
  if ( a4 <= 1 || a4 > 36 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/charconv",
      326,
      "constexpr std::to_chars_result std::__to_chars_i(char*, char*, _Tp, int) [with _Tp = unsigned int]",
      "2 <= __base && __base <= 36");
  if ( (unsigned __int64)a1 >= a2 )
    return a2;
  if ( !a3 )
  {
    *a1 = 48;
    return (__int64)(a1 + 1);
  }
  if ( a4 == 16 )
    return std::__detail::__to_chars_16<unsigned int>(a1, a2, a3);
  if ( a4 <= 16 )
  {
    if ( a4 == 10 )
      return std::__detail::__to_chars_10<unsigned int>(a1, a2, a3);
    if ( a4 <= 10 )
    {
      if ( a4 == 2 )
        return std::__detail::__to_chars_2<unsigned int>(a1, a2, a3);
      if ( a4 == 8 )
        return std::__detail::__to_chars_8<unsigned int>(a1, a2, a3);
    }
  }
  return std::__detail::__to_chars<unsigned int>(a1, a2, a3, (unsigned int)a4);
}



================================================================================
Function: _ZSt12__to_chars_iImESt15to_chars_resultPcS1_T_i at 0x11796
================================================================================

__int64 __fastcall std::__to_chars_i<unsigned long>(_BYTE *a1, unsigned __int64 a2, __int64 a3, int a4)
{
  if ( a4 <= 1 || a4 > 36 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/charconv",
      326,
      "constexpr std::to_chars_result std::__to_chars_i(char*, char*, _Tp, int) [with _Tp = long unsigned int]",
      "2 <= __base && __base <= 36");
  if ( (unsigned __int64)a1 >= a2 )
    return a2;
  if ( !a3 )
  {
    *a1 = 48;
    return (__int64)(a1 + 1);
  }
  if ( a4 == 16 )
    return std::__detail::__to_chars_16<unsigned long>(a1, a2, a3);
  if ( a4 <= 16 )
  {
    if ( a4 == 10 )
      return std::__detail::__to_chars_10<unsigned long>(a1, a2, a3);
    if ( a4 <= 10 )
    {
      if ( a4 == 2 )
        return std::__detail::__to_chars_2<unsigned long>(a1, a2, a3);
      if ( a4 == 8 )
        return std::__detail::__to_chars_8<unsigned long>(a1, a2, a3);
    }
  }
  return std::__detail::__to_chars<unsigned long>(a1, a2, a3, (unsigned int)a4);
}



================================================================================
Function: _ZSt12__to_chars_iIyESt15to_chars_resultPcS1_T_i at 0x1190d
================================================================================

__int64 __fastcall std::__to_chars_i<unsigned long long>(_BYTE *a1, unsigned __int64 a2, __int64 a3, int a4)
{
  if ( a4 <= 1 || a4 > 36 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/charconv",
      326,
      "constexpr std::to_chars_result std::__to_chars_i(char*, char*, _Tp, int) [with _Tp = long long unsigned int]",
      "2 <= __base && __base <= 36");
  if ( (unsigned __int64)a1 >= a2 )
    return a2;
  if ( !a3 )
  {
    *a1 = 48;
    return (__int64)(a1 + 1);
  }
  if ( a4 == 16 )
    return std::__detail::__to_chars_16<unsigned long>(a1, a2, a3);
  if ( a4 <= 16 )
  {
    if ( a4 == 10 )
      return std::__detail::__to_chars_10<unsigned long>(a1, a2, a3);
    if ( a4 <= 10 )
    {
      if ( a4 == 2 )
        return std::__detail::__to_chars_2<unsigned long>(a1, a2, a3);
      if ( a4 == 8 )
        return std::__detail::__to_chars_8<unsigned long>(a1, a2, a3);
    }
  }
  return std::__detail::__to_chars<unsigned long>(a1, a2, a3, (unsigned int)a4);
}



================================================================================
Function: _ZSt13__countl_zeroIjEiT_ at 0x11a84
================================================================================

__int64 __fastcall std::__countl_zero<unsigned int>(unsigned int a1)
{
  unsigned int v1; // eax

  if ( !a1 )
    return 32;
  _BitScanReverse(&v1, a1);
  return v1 ^ 0x1F;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEm at 0x11aac
================================================================================

__int64 __fastcall std::string::resize(__int64 a1, __int64 a2)
{
  return std::string::resize(a1, a2, 0);
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE4copyEPcmm at 0x11adc
================================================================================

size_t __fastcall std::string_view::copy(_QWORD *a1, void *a2, __int64 a3, unsigned __int64 a4)
{
  unsigned __int64 v4; // rax
  __int64 v5; // rax
  unsigned __int64 v8; // [rsp+0h] [rbp-30h]
  __int64 v9; // [rsp+8h] [rbp-28h] BYREF
  void *v10; // [rsp+10h] [rbp-20h]
  _QWORD *v11; // [rsp+18h] [rbp-18h]
  unsigned __int64 v12; // [rsp+20h] [rbp-10h] BYREF
  size_t v13; // [rsp+28h] [rbp-8h]

  v11 = a1;
  v10 = a2;
  v9 = a3;
  v4 = std::string_view::size((__int64)a1);
  v8 = std::__sv_check(v4, a4, "basic_string_view::copy");
  v12 = *a1 - v8;
  v13 = *std::min<unsigned long>(&v9, &v12);
  v5 = std::string_view::data((__int64)v11);
  std::char_traits<char>::copy(v10, (const void *)(v5 + v8), v13);
  return v13;
}



================================================================================
Function: _ZN4pqxx13ignore_unusedIJRKiEEEvDpOT_ at 0x11b77
================================================================================

void pqxx::ignore_unused<int const&>()
{
  ;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2Ev at 0x11b86
================================================================================

_QWORD *__fastcall std::string_view::basic_string_view(_QWORD *a1)
{
  _QWORD *result; // rax

  *a1 = 0;
  result = a1;
  a1[1] = 0;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ISt17basic_string_viewIcS2_EvEERKT_RKS3_ at 0x11bac
================================================================================

__int64 __fastcall std::string::basic_string<std::string_view,void>(__int64 a1, _QWORD *a2, __int64 a3)
{
  __int64 v3; // rax
  _QWORD v6[2]; // [rsp+20h] [rbp-10h] BYREF

  v3 = std::string::_S_to_string_view(*a2, a2[1]);
  std::string::__sv_wrapper::__sv_wrapper(v6, v3);
  return std::string::basic_string(a1, v6[0], v6[1], a3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EED2Ev at 0x11c08
================================================================================

__int64 __fastcall std::basic_string<std::byte>::~basic_string(__int64 a1)
{
  std::basic_string<std::byte>::_M_dispose(a1);
  return std::basic_string<std::byte>::_Alloc_hider::~_Alloc_hider(a1);
}



================================================================================
Function: _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev at 0x11c34
================================================================================

char __fastcall std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(volatile signed __int32 **a1)
{
  volatile signed __int32 *v1; // rax

  v1 = *a1;
  if ( *a1 )
    LOBYTE(v1) = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*a1);
  return (char)v1;
}



================================================================================
Function: _ZNSt10shared_ptrIN4pqxx8internal14notice_waitersEEC2Ev at 0x11c62
================================================================================

__int64 __fastcall std::shared_ptr<pqxx::internal::notice_waiters>::shared_ptr(__int64 a1)
{
  return std::__shared_ptr<pqxx::internal::notice_waiters,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(a1);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv at 0x11c82
================================================================================

bool __fastcall std::string::empty(__int64 a1)
{
  return *(_QWORD *)(a1 + 8) == 0;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4dataEv at 0x11c9e
================================================================================

__int64 __fastcall std::string::data(__int64 a1)
{
  return std::string::_M_data(a1);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE13_Rb_tree_implISF_Lb1EEC2Ev at 0x11cbc
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree_impl<std::less<std::string>,true>::_Rb_tree_impl(
        __int64 a1)
{
  std::_Rb_tree_key_compare<std::less<std::string>>::_Rb_tree_key_compare(a1);
  return std::_Rb_tree_header::_Rb_tree_header((std::_Rb_tree_header *)(a1 + 8));
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EED2Ev at 0x11cfe
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::~_Rb_tree(
        __int64 a1)
{
  __int64 v1; // rax

  v1 = std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_begin_node(a1);
  std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_erase(
    a1,
    v1);
  return std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_Rb_tree_impl<std::less<std::string>,true>::~_Rb_tree_impl(a1);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE13_Rb_tree_implISH_Lb1EEC2Ev at 0x11d3c
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree_impl<std::less<std::string>,true>::_Rb_tree_impl(
        __int64 a1)
{
  std::_Rb_tree_key_compare<std::less<std::string>>::_Rb_tree_key_compare(a1);
  return std::_Rb_tree_header::_Rb_tree_header((std::_Rb_tree_header *)(a1 + 8));
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EED2Ev at 0x11d7e
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::~_Rb_tree(
        __int64 a1)
{
  __int64 v1; // rax

  v1 = std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_begin_node(a1);
  std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_erase(
    a1,
    v1);
  return std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_Rb_tree_impl<std::less<std::string>,true>::~_Rb_tree_impl(a1);
}



================================================================================
Function: _ZNSt6vectorIPKcSaIS1_EED2Ev at 0x11dbc
================================================================================

__int64 __fastcall std::vector<char const*>::~vector(_QWORD *a1)
{
  std::_Vector_base<char const*>::_M_get_Tp_allocator(a1);
  std::_Destroy<char const**>(*a1, a1[1]);
  return std::_Vector_base<char const*>::~_Vector_base(a1);
}



================================================================================
Function: _ZNSt6vectorIiSaIiEED2Ev at 0x11e16
================================================================================

__int64 __fastcall std::vector<int>::~vector(_QWORD *a1)
{
  std::_Vector_base<int>::_M_get_Tp_allocator(a1);
  std::_Destroy<int *>(*a1, a1[1]);
  return std::_Vector_base<int>::~_Vector_base(a1);
}



================================================================================
Function: _ZNSt6vectorIN4pqxx6formatESaIS1_EED2Ev at 0x11e70
================================================================================

__int64 __fastcall std::vector<pqxx::format>::~vector(_QWORD *a1)
{
  std::_Vector_base<pqxx::format>::_M_get_Tp_allocator(a1);
  std::_Destroy<pqxx::format *>(*a1, a1[1]);
  return std::_Vector_base<pqxx::format>::~_Vector_base(a1);
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EED2Ev at 0x11eca
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::~_Vector_base(
        _QWORD *a1)
{
  std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_M_deallocate(
    a1,
    *a1,
    0xCCCCCCCCCCCCCCCDLL * ((__int64)(a1[2] - *a1) >> 3));
  return std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_Vector_impl::~_Vector_impl((__int64)a1);
}



================================================================================
Function: _ZNSt6vectorISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EED2Ev at 0x11f26
================================================================================

__int64 __fastcall std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::~vector(
        _QWORD *a1)
{
  std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_M_get_Tp_allocator(a1);
  std::_Destroy<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> *>(
    *a1,
    a1[1]);
  return std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::~_Vector_base(a1);
}



================================================================================
Function: _ZSteqIcSt11char_traitsIcEEbSt17basic_string_viewIT_T0_ENSt13type_identityIS5_E4typeE at 0x11f80
================================================================================

_BOOL8 __fastcall std::operator==<char,std::char_traits<char>>(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 v4; // rbx
  __int64 v6; // [rsp+0h] [rbp-30h] BYREF
  __int64 v7; // [rsp+8h] [rbp-28h]
  _QWORD v8[3]; // [rsp+10h] [rbp-20h] BYREF

  v8[0] = a1;
  v8[1] = a2;
  v6 = a3;
  v7 = a4;
  v4 = std::string_view::size((__int64)v8);
  return v4 == std::string_view::size((__int64)&v6) && !(unsigned int)std::string_view::compare(v8, v6, v7);
}



================================================================================
Function: _ZSt11upper_boundIPKDiDiET_S2_S2_RKT0_ at 0x11ffb
================================================================================

__int64 __fastcall std::upper_bound<char32_t const*,char32_t>(__gnu_cxx::__ops *a1, __int64 a2, __int64 a3)
{
  __gnu_cxx::__ops::__val_less_iter(a1);
  return std::__upper_bound<char32_t const*,char32_t,__gnu_cxx::__ops::_Val_less_iter>(a1, a2, a3);
}



================================================================================
Function: _ZSt11lower_boundIPKjjET_S2_S2_RKT0_ at 0x12031
================================================================================

__int64 __fastcall std::lower_bound<unsigned int const*,unsigned int>(__gnu_cxx::__ops *a1, __int64 a2, __int64 a3)
{
  __gnu_cxx::__ops::__iter_less_val(a1);
  return std::__lower_bound<unsigned int const*,unsigned int,__gnu_cxx::__ops::_Iter_less_val>(a1, a2, a3);
}



================================================================================
Function: _ZSt4findIPKDiDiET_S2_S2_RKT0_ at 0x12067
================================================================================

__int64 __fastcall std::find<char32_t const*,char32_t>(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 v3; // rax

  v3 = __gnu_cxx::__ops::__iter_equals_val<char32_t const>(a3);
  return std::__find_if<char32_t const*,__gnu_cxx::__ops::_Iter_equals_val<char32_t const>>(a1, a2, v3);
}



================================================================================
Function: _ZSt12construct_atISt6localeJEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S1_pispcl7declvalIT0_EEEEEPS1_S4_DpOS3_ at 0x120a3
================================================================================

std::locale *__fastcall ZSt12construct_atISt6localeJEQaant20is_unbounded_array_vIT_ErqXgsnwcvPvLi0E_S1_pispcl7declvalIT0_EEEEEPS1_S4_DpOS3_(
        void *a1)
{
  std::locale *v1; // rbx

  v1 = (std::locale *)operator new(8u, a1);
  std::locale::locale(v1);
  return v1;
}



================================================================================
Function: _ZNOSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE3getEv at 0x120fa
================================================================================

_QWORD *__fastcall std::__format::_Seq_sink<std::string>::get(_QWORD *a1, __int64 a2)
{
  __int64 v2; // rdx
  __int64 v3; // rdx
  _QWORD v5[2]; // [rsp+10h] [rbp-50h] BYREF
  _QWORD v6[7]; // [rsp+20h] [rbp-40h] BYREF

  v6[5] = a2;
  v6[0] = std::span<char,18446744073709551615ul>::begin(a2 + 8);
  v6[4] = a2 + 24;
  v6[3] = a2 + 24;
  v2 = *(_QWORD *)(a2 + 24);
  v6[2] = v6;
  v5[0] = std::span<char,18446744073709551615ul>::first(a2 + 8, v2 - v6[0]);
  v5[1] = v3;
  if ( std::span<char,18446744073709551615ul>::size(v5) )
    std::__format::_Seq_sink<std::string>::_M_overflow(a2);
  v6[1] = a2 + 288;
  std::string::basic_string(a1, a2 + 288);
  return a1;
}



================================================================================
Function: _ZSt6formatIJPcS0_S0_EENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt19basic_format_stringIcJDpNSt13type_identityIT_E4typeEEEDpOS9_ at 0x121c4
================================================================================

__int64 __fastcall std::format<char *,char *,char *>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  __int64 v6; // rdx
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v11[2]; // [rsp+30h] [rbp-70h] BYREF
  _QWORD v12[6]; // [rsp+40h] [rbp-60h] BYREF
  __int64 v13; // [rsp+70h] [rbp-30h]
  __int64 v14; // [rsp+78h] [rbp-28h]
  __int64 v15; // [rsp+80h] [rbp-20h]
  __int64 v16; // [rsp+88h] [rbp-18h]
  __int64 v17; // [rsp+90h] [rbp-10h]
  __int64 v18; // [rsp+98h] [rbp-8h]

  v18 = a4;
  v17 = a5;
  v16 = a6;
  v15 = a4;
  v14 = a5;
  v13 = a6;
  v12[0] = std::__format::_Arg_store<std::basic_format_context<std::__format::_Sink_iter<char>,char>,char const*,char const*,char const*>::_S_make_elt<char *>(a4);
  v12[1] = v6;
  v12[2] = std::__format::_Arg_store<std::basic_format_context<std::__format::_Sink_iter<char>,char>,char const*,char const*,char const*>::_S_make_elt<char *>(v14);
  v12[3] = v7;
  v12[4] = std::__format::_Arg_store<std::basic_format_context<std::__format::_Sink_iter<char>,char>,char const*,char const*,char const*>::_S_make_elt<char *>(v13);
  v12[5] = v8;
  std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::basic_format_args<char const*,char const*,char const*>(
    v11,
    v12);
  std::vformat[abi:cxx11](a1, a2, a3, v11[0], v11[1]);
  return a1;
}



================================================================================
Function: _ZNSt8__format14__parse_arg_idIcEESt4pairItPKT_ES4_S4_ at 0x122c3
================================================================================

__int64 __fastcall std::__format::__parse_arg_id<char>(char *a1, char *a2)
{
  __int64 result; // rax
  char *v3; // [rsp+10h] [rbp-60h] BYREF
  __int16 v4; // [rsp+1Eh] [rbp-52h] BYREF
  __int64 v5; // [rsp+20h] [rbp-50h] BYREF
  int v6; // [rsp+34h] [rbp-3Ch] BYREF
  char *v7; // [rsp+38h] [rbp-38h] BYREF
  __int64 v8; // [rsp+40h] [rbp-30h] BYREF
  __int64 v9; // [rsp+50h] [rbp-20h] BYREF
  int v10; // [rsp+64h] [rbp-Ch] BYREF
  __int64 v11; // [rsp+68h] [rbp-8h] BYREF

  if ( *a1 == 48 )
  {
    v6 = 0;
    v7 = a1 + 1;
    std::pair<unsigned short,char const*>::pair<int,char const*>(&v5, &v6, &v7);
    LODWORD(result) = v5;
  }
  else if ( *a1 <= 48 || *a1 > 57 )
  {
    v10 = 0;
    v11 = 0;
    std::pair<unsigned short,char const*>::pair<int,decltype(nullptr)>(&v9, &v10, &v11);
    LODWORD(result) = v9;
  }
  else
  {
    v4 = *a1 - 48;
    v3 = a1 + 1;
    if ( a2 == a1 + 1 || *v3 <= 47 || *v3 > 57 )
    {
      std::pair<unsigned short,char const*>::pair(&v8, &v4, &v3);
      LODWORD(result) = v8;
    }
    else
    {
      LODWORD(result) = std::__format::__parse_integer<char>(a1, a2);
    }
  }
  return (unsigned int)result;
}



================================================================================
Function: _ZNSt26basic_format_parse_contextIcE12check_arg_idEm at 0x123e8
================================================================================

unsigned __int64 __fastcall std::basic_format_parse_context<char>::check_arg_id(__int64 a1, unsigned __int64 a2)
{
  unsigned __int64 result; // rax

  if ( *(_DWORD *)(a1 + 16) == 2 )
    std::__format::__conflicting_indexing_in_format_string((std::__format *)a1);
  *(_DWORD *)(a1 + 16) = 1;
  result = std::is_constant_evaluated();
  if ( (_BYTE)result )
  {
    result = *(_QWORD *)(a1 + 32);
    if ( a2 >= result )
      std::__format::__invalid_arg_id_in_format_string((std::__format *)a1);
  }
  return result;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE23_M_parse_fill_and_alignEPKcS3_ at 0x12438
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_M_parse_fill_and_align(__int64 a1, __int64 a2, __int64 a3)
{
  size_t v5[2]; // [rsp+20h] [rbp-10h] BYREF

  std::string_view::basic_string_view(v5, "{");
  return std::__format::_Spec<char>::_M_parse_fill_and_align(a1, a2, a3, v5[0], v5[1]);
}



================================================================================
Function: _ZNSt8__format5_SpecIcE14_M_parse_widthEPKcS3_RSt26basic_format_parse_contextIcE at 0x12488
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_M_parse_width(_WORD *a1, _BYTE *a2, __int64 a3, __int64 a4)
{
  char v4; // dl
  char v6; // [rsp+27h] [rbp-9h] BYREF
  __int64 v7; // [rsp+28h] [rbp-8h]

  v6 = 0;
  if ( *a2 == 48 )
    std::__throw_format_error("format error: width must be non-zero in format string");
  v7 = std::__format::_Spec<char>::_S_parse_width_or_precision(a2, a3, a1 + 2, &v6, a4);
  if ( (_BYTE *)v7 != a2 )
  {
    if ( v6 )
      v4 = 2;
    else
      v4 = 1;
    *a1 = ((v4 & 3) << 7) | *a1 & 0xFE7F;
  }
  return v7;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE18_M_parse_precisionEPKcS3_RSt26basic_format_parse_contextIcE at 0x12530
================================================================================

_BYTE *__fastcall std::__format::_Spec<char>::_M_parse_precision(__int64 a1, _BYTE *a2, _BYTE *a3, __int64 a4)
{
  char v5; // dl
  _BYTE *v6; // [rsp+10h] [rbp-20h]
  char v7; // [rsp+27h] [rbp-9h] BYREF
  __int64 v8; // [rsp+28h] [rbp-8h]

  if ( *a2 != 46 )
    return a2;
  v6 = a2 + 1;
  v8 = (__int64)(a2 + 1);
  v7 = 0;
  if ( a2 + 1 != a3 )
    v8 = std::__format::_Spec<char>::_S_parse_width_or_precision(v6, a3, a1 + 6, &v7, a4);
  if ( (_BYTE *)v8 == v6 )
    std::__throw_format_error("format error: missing precision after '.' in format string");
  if ( v7 )
    v5 = 2;
  else
    v5 = 1;
  *(_BYTE *)(a1 + 1) = (2 * (v5 & 3)) | *(_BYTE *)(a1 + 1) & 0xF9;
  return (_BYTE *)v8;
}



================================================================================
Function: _ZN4pqxx11transactionILNS_15isolation_levelE0ELNS_12write_policyE1EEC2ERNS_10connectionE at 0x125f2
================================================================================

_QWORD *__fastcall pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::transaction(_QWORD *a1)
{
  _QWORD *result; // rax

  pqxx::internal::basic_transaction::basic_transaction();
  result = a1;
  *a1 = off_378A0;
  return result;
}



================================================================================
Function: _ZN4pqxx11transactionILNS_15isolation_levelE0ELNS_12write_policyE1EED2Ev at 0x12638
================================================================================

void __fastcall pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(
        pqxx::transaction_base *a1)
{
  *(_QWORD *)a1 = off_378A0;
  pqxx::transaction_base::close(a1);
  pqxx::internal::basic_transaction::~basic_transaction(a1);
}



================================================================================
Function: _ZN4pqxx11transactionILNS_15isolation_levelE0ELNS_12write_policyE1EED0Ev at 0x12672
================================================================================

void __fastcall pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(
        pqxx::transaction_base *a1)
{
  pqxx::transaction<(pqxx::isolation_level)0,(pqxx::write_policy)1>::~transaction(a1);
  operator delete(a1, 0x70u);
}



================================================================================
Function: _ZN4pqxx6paramsC2IJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEDpOT_ at 0x126a2
================================================================================

__int64 __fastcall pqxx::params::params<std::string &>(__int64 a1, __int64 a2)
{
  std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::vector(a1);
  pqxx::params::reserve();
  return pqxx::params::append_pack<std::string &>(a1, a2);
}



================================================================================
Function: _ZN4pqxx6paramsC2IJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_EEEDpOT_ at 0x12716
================================================================================

__int64 __fastcall pqxx::params::params<std::string &,std::string &>(__int64 a1, __int64 a2, __int64 a3)
{
  std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::vector(a1);
  pqxx::params::reserve();
  return pqxx::params::append_pack<std::string &,std::string &>(a1, a2, a3);
}



================================================================================
Function: _ZN4pqxx6paramsC2IJRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_EEEDpOT_ at 0x1279a
================================================================================

__int64 __fastcall pqxx::params::params<std::string &,std::string &,std::string &>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  std::vector<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::vector(a1);
  pqxx::params::reserve();
  return pqxx::params::append_pack<std::string &,std::string &,std::string &>(a1, a2, a3, a4);
}



================================================================================
Function: _ZNK4pqxx5field2asINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v at 0x1282a
================================================================================

__int64 __fastcall pqxx::field::as<std::string>(__int64 a1, pqxx::field *a2)
{
  __int64 v2; // rax
  __int64 v3; // rdx

  if ( (unsigned __int8)pqxx::field::is_null(a2) )
    pqxx::internal::throw_null_conversion();
  v2 = pqxx::field::view(a2);
  pqxx::from_string<std::string>(a1, v2, v3);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6insertEmPKc at 0x12884
================================================================================

__int64 __fastcall std::string::insert(__int64 a1, __int64 a2, const char *a3)
{
  size_t v3; // rax

  v3 = std::char_traits<char>::length(a3);
  return std::string::replace(a1, a2, 0, a3, v3);
}



================================================================================
Function: _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE19_M_release_last_useEv at 0x128cc
================================================================================

char __fastcall std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use(volatile signed __int32 *a1)
{
  signed __int32 v1; // eax
  char result; // al
  signed __int32 v3; // [rsp+20h] [rbp-20h]
  volatile signed __int32 *v4; // [rsp+38h] [rbp-8h]

  (*(void (__fastcall **)(volatile signed __int32 *))(*(_QWORD *)a1 + 16LL))(a1);
  v4 = a1 + 3;
  if ( _libc_single_threaded )
  {
    v3 = (*v4)--;
    v1 = v3;
  }
  else
  {
    v1 = _InterlockedExchangeAdd(v4, 0xFFFFFFFF);
  }
  result = v1 == 1;
  if ( result )
    return (*(__int64 (__fastcall **)(volatile signed __int32 *))(*(_QWORD *)a1 + 24LL))(a1);
  return result;
}



================================================================================
Function: _ZNSt8__detail16__to_chars_len_2IjEEjT_ at 0x12983
================================================================================

__int64 __fastcall std::__detail::__to_chars_len_2<unsigned int>(unsigned int a1)
{
  return std::__bit_width<unsigned int>(a1);
}



================================================================================
Function: _ZNSt8__detail13__to_chars_16IjEESt15to_chars_resultPcS2_T_ at 0x1299e
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_16<unsigned int>(_BYTE *a1, __int64 a2, unsigned int a3)
{
  unsigned int v4; // [rsp+Ch] [rbp-44h]
  unsigned int v5; // [rsp+Ch] [rbp-44h]
  _QWORD v6[3]; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+38h] [rbp-18h]
  unsigned int v8; // [rsp+40h] [rbp-10h]
  unsigned int v9; // [rsp+44h] [rbp-Ch]
  unsigned int v10; // [rsp+48h] [rbp-8h]
  unsigned int v11; // [rsp+4Ch] [rbp-4h]

  v4 = a3;
  v10 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned int>(a3) + 3) >> 2;
  if ( a2 - (__int64)a1 >= (unsigned __int64)v10 )
  {
    qmemcpy(v6, "0123456789abcdef", 16);
    v11 = v10 - 1;
    while ( v4 > 0xFF )
    {
      v8 = v4 & 0xF;
      v5 = v4 >> 4;
      a1[v11] = *((_BYTE *)v6 + v8);
      v8 = v5 & 0xF;
      v4 = v5 >> 4;
      a1[v11 - 1] = *((_BYTE *)v6 + v8);
      v11 -= 2;
    }
    if ( v4 > 0xF )
    {
      v9 = v4 & 0xF;
      v4 >>= 4;
      a1[1] = *((_BYTE *)v6 + v9);
    }
    *a1 = *((_BYTE *)v6 + v4);
    return &a1[v10];
  }
  else
  {
    v6[2] = a2;
    LODWORD(v7) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt8__detail13__to_chars_10IjEESt15to_chars_resultPcS2_T_ at 0x12add
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10<unsigned int>(_BYTE *a1, __int64 a2, unsigned int a3)
{
  unsigned int v5; // [rsp+3Ch] [rbp-4h]

  v5 = std::__detail::__to_chars_len<unsigned int>(a3, 0xAu);
  if ( a2 - (__int64)a1 < (unsigned __int64)v5 )
    return (_BYTE *)a2;
  std::__detail::__to_chars_10_impl<unsigned int>(a1, v5, a3);
  return &a1[v5];
}



================================================================================
Function: _ZNSt8__detail12__to_chars_8IjEESt15to_chars_resultPcS2_T_ at 0x12b6e
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_8<unsigned int>(_BYTE *a1, __int64 a2, unsigned int a3)
{
  unsigned int v4; // [rsp+Ch] [rbp-34h]
  unsigned int v5; // [rsp+Ch] [rbp-34h]
  char v6; // [rsp+30h] [rbp-10h]
  char v7; // [rsp+30h] [rbp-10h]
  char v8; // [rsp+34h] [rbp-Ch]
  unsigned int v9; // [rsp+38h] [rbp-8h]
  unsigned int v10; // [rsp+3Ch] [rbp-4h]

  v4 = a3;
  v9 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned int>(a3) + 2) / 3;
  if ( a2 - (__int64)a1 < (unsigned __int64)v9 )
    return (_BYTE *)a2;
  v10 = v9 - 1;
  while ( v4 > 0x3F )
  {
    v6 = v4 & 7;
    v5 = v4 >> 3;
    a1[v10] = v6 + 48;
    v7 = v5 & 7;
    v4 = v5 >> 3;
    a1[v10 - 1] = v7 + 48;
    v10 -= 2;
  }
  if ( v4 > 7 )
  {
    v8 = v4 & 7;
    v4 >>= 3;
    a1[1] = v8 + 48;
  }
  *a1 = v4 + 48;
  return &a1[v9];
}



================================================================================
Function: _ZNSt8__detail12__to_chars_2IjEESt15to_chars_resultPcS2_T_ at 0x12c9f
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_2<unsigned int>(_BYTE *a1, __int64 a2, unsigned int a3)
{
  unsigned int v4; // eax
  unsigned int v5; // [rsp+Ch] [rbp-34h]
  unsigned int v6; // [rsp+38h] [rbp-8h]
  unsigned int i; // [rsp+3Ch] [rbp-4h]

  v5 = a3;
  v6 = std::__detail::__to_chars_len_2<unsigned int>(a3);
  if ( a2 - (__int64)a1 < (unsigned __int64)v6 )
    return (_BYTE *)a2;
  for ( i = v6 - 1; i; --i )
  {
    v4 = i;
    a1[v4] = (v5 & 1) + 48;
    v5 >>= 1;
  }
  *a1 = 49;
  return &a1[v6];
}



================================================================================
Function: _ZNSt8__detail10__to_charsIjEESt15to_chars_resultPcS2_T_i at 0x12d52
================================================================================

_BYTE *__fastcall std::__detail::__to_chars<unsigned int>(_BYTE *a1, __int64 a2, unsigned int a3, unsigned int a4)
{
  char v5; // dl
  int v6; // eax
  unsigned int v8; // [rsp+Ch] [rbp-64h]
  _QWORD v9[7]; // [rsp+20h] [rbp-50h] BYREF
  __int64 v10; // [rsp+58h] [rbp-18h]
  int v11; // [rsp+60h] [rbp-10h]
  int v12; // [rsp+64h] [rbp-Ch]
  unsigned int v13; // [rsp+68h] [rbp-8h]
  unsigned int v14; // [rsp+6Ch] [rbp-4h]

  v8 = a3;
  v13 = std::__detail::__to_chars_len<unsigned int>(a3, a4);
  if ( a2 - (__int64)a1 >= (unsigned __int64)v13 )
  {
    v14 = v13 - 1;
    qmemcpy(v9, "0123456789abcdefghijklmnopqrstuvwxyz", 36);
    while ( v8 >= a4 )
    {
      v12 = v8 / a4;
      v11 = v8 % a4;
      v5 = *((_BYTE *)v9 + v8 % a4);
      v6 = v14--;
      a1[v6] = v5;
      v8 = v12;
    }
    *a1 = *((_BYTE *)v9 + v8);
    return &a1[v13];
  }
  else
  {
    v9[6] = a2;
    LODWORD(v10) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt8__detail16__to_chars_len_2ImEEjT_ at 0x12e77
================================================================================

__int64 __fastcall std::__detail::__to_chars_len_2<unsigned long>(__int64 a1)
{
  return std::__bit_width<unsigned long>(a1);
}



================================================================================
Function: _ZNSt8__detail13__to_chars_16ImEESt15to_chars_resultPcS2_T_ at 0x12e95
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_16<unsigned long>(_BYTE *a1, __int64 a2, __int64 a3)
{
  unsigned __int64 v4; // [rsp+8h] [rbp-58h]
  unsigned __int64 v5; // [rsp+8h] [rbp-58h]
  _QWORD v6[3]; // [rsp+20h] [rbp-40h] BYREF
  __int64 v7; // [rsp+38h] [rbp-28h]
  unsigned __int64 v8; // [rsp+48h] [rbp-18h]
  unsigned __int64 v9; // [rsp+50h] [rbp-10h]
  unsigned int v10; // [rsp+58h] [rbp-8h]
  unsigned int v11; // [rsp+5Ch] [rbp-4h]

  v4 = a3;
  v10 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned long>(a3) + 3) >> 2;
  if ( a2 - (__int64)a1 >= (unsigned __int64)v10 )
  {
    qmemcpy(v6, "0123456789abcdef", 16);
    v11 = v10 - 1;
    while ( v4 > 0xFF )
    {
      v8 = v4 & 0xF;
      v5 = v4 >> 4;
      a1[v11] = *((_BYTE *)v6 + v8);
      v8 = v5 & 0xF;
      v4 = v5 >> 4;
      a1[v11 - 1] = *((_BYTE *)v6 + v8);
      v11 -= 2;
    }
    if ( v4 > 0xF )
    {
      v9 = v4 & 0xF;
      v4 >>= 4;
      a1[1] = *((_BYTE *)v6 + v9);
    }
    *a1 = *((_BYTE *)v6 + v4);
    return &a1[v10];
  }
  else
  {
    v6[2] = a2;
    LODWORD(v7) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt8__detail13__to_chars_10ImEESt15to_chars_resultPcS2_T_ at 0x13000
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10<unsigned long>(_BYTE *a1, __int64 a2, unsigned __int64 a3)
{
  unsigned int v5; // [rsp+3Ch] [rbp-4h]

  v5 = std::__detail::__to_chars_len<unsigned long>(a3, 0xAu);
  if ( a2 - (__int64)a1 < (unsigned __int64)v5 )
    return (_BYTE *)a2;
  std::__detail::__to_chars_10_impl<unsigned long>(a1, v5, a3);
  return &a1[v5];
}



================================================================================
Function: _ZNSt8__detail12__to_chars_8ImEESt15to_chars_resultPcS2_T_ at 0x13095
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_8<unsigned long>(_BYTE *a1, __int64 a2, __int64 a3)
{
  unsigned __int64 v4; // [rsp+8h] [rbp-48h]
  unsigned __int64 v5; // [rsp+8h] [rbp-48h]
  char v6; // [rsp+38h] [rbp-18h]
  char v7; // [rsp+38h] [rbp-18h]
  char v8; // [rsp+40h] [rbp-10h]
  unsigned int v9; // [rsp+48h] [rbp-8h]
  unsigned int v10; // [rsp+4Ch] [rbp-4h]

  v4 = a3;
  v9 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned long>(a3) + 2) / 3;
  if ( a2 - (__int64)a1 < (unsigned __int64)v9 )
    return (_BYTE *)a2;
  v10 = v9 - 1;
  while ( v4 > 0x3F )
  {
    v6 = v4 & 7;
    v5 = v4 >> 3;
    a1[v10] = v6 + 48;
    v7 = v5 & 7;
    v4 = v5 >> 3;
    a1[v10 - 1] = v7 + 48;
    v10 -= 2;
  }
  if ( v4 > 7 )
  {
    v8 = v4 & 7;
    v4 >>= 3;
    a1[1] = v8 + 48;
  }
  *a1 = v4 + 48;
  return &a1[v9];
}



================================================================================
Function: _ZNSt8__detail12__to_chars_2ImEESt15to_chars_resultPcS2_T_ at 0x131d9
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_2<unsigned long>(_BYTE *a1, __int64 a2, __int64 a3)
{
  unsigned int v4; // eax
  unsigned __int64 v5; // [rsp+8h] [rbp-38h]
  unsigned int v6; // [rsp+38h] [rbp-8h]
  unsigned int i; // [rsp+3Ch] [rbp-4h]

  v5 = a3;
  v6 = std::__detail::__to_chars_len_2<unsigned long>(a3);
  if ( a2 - (__int64)a1 < (unsigned __int64)v6 )
    return (_BYTE *)a2;
  for ( i = v6 - 1; i; --i )
  {
    v4 = i;
    a1[v4] = (v5 & 1) + 48;
    v5 >>= 1;
  }
  *a1 = 49;
  return &a1[v6];
}



================================================================================
Function: _ZNSt8__detail10__to_charsImEESt15to_chars_resultPcS2_T_i at 0x13291
================================================================================

_BYTE *__fastcall std::__detail::__to_chars<unsigned long>(_BYTE *a1, __int64 a2, unsigned __int64 a3, signed int a4)
{
  char v5; // dl
  int v6; // eax
  unsigned __int64 v8; // [rsp+8h] [rbp-78h]
  _QWORD v9[7]; // [rsp+20h] [rbp-60h] BYREF
  __int64 v10; // [rsp+58h] [rbp-28h]
  unsigned __int64 v11; // [rsp+68h] [rbp-18h]
  unsigned __int64 v12; // [rsp+70h] [rbp-10h]
  unsigned int v13; // [rsp+78h] [rbp-8h]
  unsigned int v14; // [rsp+7Ch] [rbp-4h]

  v8 = a3;
  v13 = std::__detail::__to_chars_len<unsigned long>(a3, a4);
  if ( a2 - (__int64)a1 >= (unsigned __int64)v13 )
  {
    v14 = v13 - 1;
    qmemcpy(v9, "0123456789abcdefghijklmnopqrstuvwxyz", 36);
    while ( v8 >= (unsigned int)a4 )
    {
      v12 = v8 / a4;
      v11 = v8 % a4;
      v5 = *((_BYTE *)v9 + v11);
      v6 = v14--;
      a1[v6] = v5;
      v8 = v12;
    }
    *a1 = *((_BYTE *)v9 + v8);
    return &a1[v13];
  }
  else
  {
    v9[6] = a2;
    LODWORD(v10) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc at 0x133d6
================================================================================

_BYTE *__fastcall std::string::resize(__int64 a1, unsigned __int64 a2, char a3)
{
  _BYTE *result; // rax
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]

  v5 = std::string::size(a1);
  if ( v5 < a2 )
    return (_BYTE *)std::string::append(a1, a2 - v5, (unsigned int)a3);
  result = (_BYTE *)a2;
  if ( a2 < v5 )
    return std::string::_M_set_length(a1, a2);
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE17_S_to_string_viewESt17basic_string_viewIcS2_E at 0x13449
================================================================================

__int64 __fastcall std::string::_S_to_string_view(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12__sv_wrapperC2ESt17basic_string_viewIcS2_E at 0x13474
================================================================================

__int64 __fastcall std::string::__sv_wrapper::__sv_wrapper(_QWORD *a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  result = a2;
  *a1 = a2;
  a1[1] = a3;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ENS4_12__sv_wrapperERKS3_ at 0x134b0
================================================================================

__int64 __fastcall std::string::basic_string(_QWORD *a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 v4; // rbx
  __int64 v5; // rax
  _QWORD v7[3]; // [rsp+0h] [rbp-30h] BYREF
  _QWORD *v8; // [rsp+18h] [rbp-18h]

  v8 = a1;
  v7[0] = a2;
  v7[1] = a3;
  v7[2] = a4;
  v4 = std::string_view::size((__int64)v7);
  v5 = std::string_view::data((__int64)v7);
  return std::string::basic_string(v8, v5, v4);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8_M_checkEmPKc at 0x1351a
================================================================================

unsigned __int64 __fastcall std::string::_M_check(__int64 a1, unsigned __int64 a2)
{
  if ( std::string::size(a1) < a2 )
  {
    std::string::size(a1);
    std::__throw_out_of_range_fmt("%s: __pos (which is %zu) > this->size() (which is %zu)");
  }
  return a2;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE8_M_limitEmm at 0x1357a
================================================================================

unsigned __int64 __fastcall std::string::_M_limit(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  if ( a3 >= std::string::size(a1) - a2 )
    return std::string::size(a1) - a2;
  else
    return a3;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE7_M_dataEv at 0x135ca
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_M_data(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE10_M_disposeEv at 0x135e0
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_M_dispose(__int64 a1)
{
  __int64 result; // rax

  result = (unsigned int)std::basic_string<std::byte>::_M_is_local(a1) ^ 1;
  if ( (_BYTE)result )
    return std::basic_string<std::byte>::_M_destroy(a1, *(_QWORD *)(a1 + 16));
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE16_M_get_allocatorEv at 0x1361e
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_M_get_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE11_M_is_localEv at 0x13630
================================================================================

_BOOL8 __fastcall std::basic_string<std::byte>::_M_is_local(__int64 a1)
{
  __int64 v1; // rbx

  v1 = std::basic_string<std::byte>::_M_data(a1);
  return v1 == std::basic_string<std::byte>::_M_local_data(a1);
}



================================================================================
Function: _ZNSt12__shared_ptrIN4pqxx8internal14notice_waitersELN9__gnu_cxx12_Lock_policyE2EEC2Ev at 0x13684
================================================================================

__int64 __fastcall std::__shared_ptr<pqxx::internal::notice_waiters,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(
        _QWORD *a1)
{
  *a1 = 0;
  return std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count(a1 + 1);
}



================================================================================
Function: _ZNSt20_Rb_tree_key_compareISt4lessINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEC2Ev at 0x136b2
================================================================================

void std::_Rb_tree_key_compare<std::less<std::string>>::_Rb_tree_key_compare()
{
  ;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE8_M_eraseEPSt13_Rb_tree_nodeISB_E at 0x136c2
================================================================================

void __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_erase(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax
  __int64 v4; // [rsp+18h] [rbp-8h]

  while ( a2 )
  {
    v2 = std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_S_right(a2);
    std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_erase(
      a1,
      v2);
    v4 = std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_S_left(a2);
    std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_drop_node(
      a1,
      a2);
    a2 = v4;
  }
}



================================================================================
Function: _ZNKSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE13_M_begin_nodeEv at 0x1372c
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_begin_node(
        __int64 a1)
{
  __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = *(_QWORD *)(a1 + 16);
  if ( v2 )
    return std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_node_ptr(v2);
  else
    return 0;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE8_M_eraseEPSt13_Rb_tree_nodeISD_E at 0x13764
================================================================================

void __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_erase(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax
  __int64 v4; // [rsp+18h] [rbp-8h]

  while ( a2 )
  {
    v2 = std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_S_right(a2);
    std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_erase(
      a1,
      v2);
    v4 = std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_S_left(a2);
    std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_drop_node(
      a1,
      a2);
    a2 = v4;
  }
}



================================================================================
Function: _ZNKSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE13_M_begin_nodeEv at 0x137ce
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_begin_node(
        __int64 a1)
{
  __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = *(_QWORD *)(a1 + 16);
  if ( v2 )
    return std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_node_ptr(v2);
  else
    return 0;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEpLEc at 0x13806
================================================================================

__int64 __fastcall std::string::operator+=(__int64 a1, char a2)
{
  std::string::push_back(a1, (unsigned int)a2);
  return a1;
}



================================================================================
Function: _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2Ev at 0x13834
================================================================================

_QWORD *__fastcall std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count(_QWORD *a1)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = 0;
  return result;
}



================================================================================
Function: _ZNSt12_Vector_baseIPKcSaIS1_EE12_Vector_implD2Ev at 0x1384e
================================================================================

__int64 __fastcall std::_Vector_base<char const*>::_Vector_impl::~_Vector_impl(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseIPKcSaIS1_EED2Ev at 0x13866
================================================================================

__int64 __fastcall std::_Vector_base<char const*>::~_Vector_base(_QWORD *a1)
{
  std::_Vector_base<char const*>::_M_deallocate(a1, *a1, (__int64)(a1[2] - *a1) >> 3);
  return std::_Vector_base<char const*>::_Vector_impl::~_Vector_impl((__int64)a1);
}



================================================================================
Function: _ZNSt12_Vector_baseIPKcSaIS1_EE19_M_get_Tp_allocatorEv at 0x138b8
================================================================================

__int64 __fastcall std::_Vector_base<char const*>::_M_get_Tp_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseIiSaIiEE12_Vector_implD2Ev at 0x138ca
================================================================================

__int64 __fastcall std::_Vector_base<int>::_Vector_impl::~_Vector_impl(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseIiSaIiEED2Ev at 0x138e2
================================================================================

__int64 __fastcall std::_Vector_base<int>::~_Vector_base(_QWORD *a1)
{
  std::_Vector_base<int>::_M_deallocate(a1, *a1, (__int64)(a1[2] - *a1) >> 2);
  return std::_Vector_base<int>::_Vector_impl::~_Vector_impl((__int64)a1);
}



================================================================================
Function: _ZNSt12_Vector_baseIiSaIiEE19_M_get_Tp_allocatorEv at 0x13934
================================================================================

__int64 __fastcall std::_Vector_base<int>::_M_get_Tp_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseIN4pqxx6formatESaIS1_EE12_Vector_implD2Ev at 0x13946
================================================================================

__int64 __fastcall std::_Vector_base<pqxx::format>::_Vector_impl::~_Vector_impl(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseIN4pqxx6formatESaIS1_EED2Ev at 0x1395e
================================================================================

__int64 __fastcall std::_Vector_base<pqxx::format>::~_Vector_base(_QWORD *a1)
{
  std::_Vector_base<pqxx::format>::_M_deallocate(a1, *a1, (__int64)(a1[2] - *a1) >> 2);
  return std::_Vector_base<pqxx::format>::_Vector_impl::~_Vector_impl((__int64)a1);
}



================================================================================
Function: _ZNSt12_Vector_baseIN4pqxx6formatESaIS1_EE19_M_get_Tp_allocatorEv at 0x139b0
================================================================================

__int64 __fastcall std::_Vector_base<pqxx::format>::_M_get_Tp_allocator(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EE13_M_deallocateEPSF_m at 0x139c2
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_M_deallocate(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  __int64 result; // rax

  if ( a2 )
    return std::__new_allocator<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::deallocate(
             a1,
             a2,
             a3);
  return result;
}



================================================================================
Function: _ZNSt12_Vector_baseISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEESaISF_EE19_M_get_Tp_allocatorEv at 0x13a44
================================================================================

__int64 __fastcall std::_Vector_base<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::_M_get_Tp_allocator(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE7compareES2_ at 0x13a56
================================================================================

__int64 __fastcall std::string_view::compare(_QWORD *a1, __int64 a2, const void *a3)
{
  __int64 v4; // [rsp+0h] [rbp-30h] BYREF
  const void *v5; // [rsp+8h] [rbp-28h]
  _QWORD *v6; // [rsp+18h] [rbp-18h]
  size_t v7; // [rsp+20h] [rbp-10h]
  unsigned int v8; // [rsp+2Ch] [rbp-4h]

  v6 = a1;
  v4 = a2;
  v5 = a3;
  v7 = *std::min<unsigned long>(a1, &v4);
  v8 = std::char_traits<char>::compare((const void *)v6[1], v5, v7);
  if ( !v8 )
    return (unsigned int)std::string_view::_S_compare(*v6, v4);
  return v8;
}



================================================================================
Function: _ZSt13__upper_boundIPKDiDiN9__gnu_cxx5__ops14_Val_less_iterEET_S5_S5_RKT0_T1_ at 0x13adb
================================================================================

__int64 __fastcall std::__upper_bound<char32_t const*,char32_t,__gnu_cxx::__ops::_Val_less_iter>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  char v4; // [rsp+7h] [rbp-79h] BYREF
  __int64 v5; // [rsp+8h] [rbp-78h]
  __int64 v6; // [rsp+10h] [rbp-70h]
  __int64 v7; // [rsp+18h] [rbp-68h]
  _QWORD v8[9]; // [rsp+28h] [rbp-58h] BYREF
  __int64 v9; // [rsp+70h] [rbp-10h]
  __int64 v10; // [rsp+78h] [rbp-8h]

  v7 = a1;
  v6 = a2;
  v5 = a3;
  v8[2] = a1;
  v8[8] = a2;
  v8[7] = a1;
  v8[6] = a2;
  v10 = (a2 - a1) >> 2;
  while ( v10 > 0 )
  {
    v9 = v10 >> 1;
    v8[0] = v7;
    v8[5] = v10 >> 1;
    v8[4] = v10 >> 1;
    v8[3] = v8;
    std::__advance<char32_t const*,long>(v8, v10 >> 1);
    if ( (unsigned __int8)__gnu_cxx::__ops::_Val_less_iter::operator()<char32_t const,char32_t const*>(&v4, v5, v8[0]) )
    {
      v10 = v9;
    }
    else
    {
      v7 = v8[0] + 4LL;
      v10 = v10 - v9 - 1;
    }
  }
  return v7;
}



================================================================================
Function: _ZSt13__lower_boundIPKjjN9__gnu_cxx5__ops14_Iter_less_valEET_S5_S5_RKT0_T1_ at 0x13bbd
================================================================================

__int64 __fastcall std::__lower_bound<unsigned int const*,unsigned int,__gnu_cxx::__ops::_Iter_less_val>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  char v4; // [rsp+7h] [rbp-79h] BYREF
  __int64 v5; // [rsp+8h] [rbp-78h]
  __int64 v6; // [rsp+10h] [rbp-70h]
  __int64 v7; // [rsp+18h] [rbp-68h]
  _QWORD v8[9]; // [rsp+28h] [rbp-58h] BYREF
  __int64 v9; // [rsp+70h] [rbp-10h]
  __int64 v10; // [rsp+78h] [rbp-8h]

  v7 = a1;
  v6 = a2;
  v5 = a3;
  v8[2] = a1;
  v8[8] = a2;
  v8[7] = a1;
  v8[6] = a2;
  v10 = (a2 - a1) >> 2;
  while ( v10 > 0 )
  {
    v9 = v10 >> 1;
    v8[0] = v7;
    v8[5] = v10 >> 1;
    v8[4] = v10 >> 1;
    v8[3] = v8;
    std::__advance<unsigned int const*,long>(v8, v10 >> 1);
    if ( (unsigned __int8)__gnu_cxx::__ops::_Iter_less_val::operator()<unsigned int const*,unsigned int const>(
                            &v4,
                            v8[0],
                            v5) )
    {
      v7 = v8[0] + 4LL;
      v10 = v10 - v9 - 1;
    }
    else
    {
      v10 = v9;
    }
  }
  return v7;
}



================================================================================
Function: _ZN9__gnu_cxx5__ops17__iter_equals_valIKDiEENS0_16_Iter_equals_valIT_EERS4_ at 0x13c9f
================================================================================

__int64 __fastcall __gnu_cxx::__ops::__iter_equals_val<char32_t const>(__int64 a1)
{
  __int64 v2; // [rsp+18h] [rbp-8h] BYREF

  __gnu_cxx::__ops::_Iter_equals_val<char32_t const>::_Iter_equals_val(&v2, a1);
  return v2;
}



================================================================================
Function: _ZSt9__find_ifIPKDiN9__gnu_cxx5__ops16_Iter_equals_valIS0_EEET_S6_S6_T0_ at 0x13cc8
================================================================================

__int64 __fastcall std::__find_if<char32_t const*,__gnu_cxx::__ops::_Iter_equals_val<char32_t const>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  __int64 v5; // [rsp+8h] [rbp-18h] BYREF
  __int64 v6; // [rsp+10h] [rbp-10h]
  __int64 v7; // [rsp+18h] [rbp-8h]

  v7 = a1;
  v6 = a2;
  v5 = a3;
  while ( v7 != v6
       && (unsigned __int8)__gnu_cxx::__ops::_Iter_equals_val<char32_t const>::operator()<char32_t const*>(&v5, v7) != 1 )
    v7 += 4;
  return v7;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clISt9monostateEEDaSJ_ at 0x13d22
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::monostate>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIbEEDaSJ_ at 0x13d36
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<bool>(
        _QWORD *a1,
        _BYTE *a2)
{
  _BYTE *result; // rax
  const void *v3; // rbx
  void *v4; // rax
  __int64 v5; // [rsp+18h] [rbp-38h] BYREF
  void *src[3]; // [rsp+20h] [rbp-30h]
  size_t n; // [rsp+38h] [rbp-18h]

  n = (*a2 ^ 1) + 4;
  src[0] = (void *)"false";
  src[1] = "true";
  v5 = std::__format::_Sink_iter<char>::_M_reserve(*a1, n);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v5);
  if ( (_BYTE)result )
  {
    v3 = src[(unsigned __int8)*a2];
    v4 = (void *)std::__format::_Sink<char>::_Reservation::get(&v5);
    memcpy(v4, v3, n);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v5, n);
    result = (_BYTE *)a1[1];
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZNKSt8__format10_Sink_iterIcE10_M_reserveEm at 0x13df8
================================================================================

__int64 __fastcall std::__format::_Sink_iter<char>::_M_reserve(_QWORD *a1, __int64 a2)
{
  return (*(__int64 (__fastcall **)(_QWORD, __int64))(*(_QWORD *)*a1 + 8LL))(*a1, a2);
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIcEEDaSJ_ at 0x13e32
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<char>(
        __int64 a1,
        char *a2)
{
  _BYTE *result; // rax
  char v3; // bl
  _QWORD v4[2]; // [rsp+18h] [rbp-18h] BYREF

  v4[0] = std::__format::_Sink_iter<char>::_M_reserve(*(_QWORD **)a1, 1);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(v4);
  if ( (_BYTE)result )
  {
    v3 = *a2;
    *(_BYTE *)std::__format::_Sink<char>::_Reservation::get(v4) = v3;
    std::__format::_Sink<char>::_Reservation::_M_bump(v4, 1);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIiEEDaSJ_ at 0x13ea8
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<int>(
        __int64 a1,
        int *a2)
{
  _BYTE *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h] BYREF
  _BYTE *v4; // [rsp+18h] [rbp-18h]
  int v5; // [rsp+24h] [rbp-Ch]
  bool v6; // [rsp+2Bh] [rbp-5h]
  unsigned int v7; // [rsp+2Ch] [rbp-4h]

  v6 = *a2 < 0;
  if ( v6 )
    v7 = -*a2;
  else
    v7 = *a2;
  v5 = std::__detail::__to_chars_len<unsigned int>(v7, 0xAu);
  v3 = std::__format::_Sink_iter<char>::_M_reserve(*(_QWORD **)a1, (unsigned int)v6 + v5);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v3);
  if ( (_BYTE)result )
  {
    v4 = (_BYTE *)std::__format::_Sink<char>::_Reservation::get(&v3);
    *v4 = 45;
    std::__detail::__to_chars_10_impl<unsigned int>(&v4[v6], v5, v7);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v3, (unsigned int)v6 + v5);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIjEEDaSJ_ at 0x13f82
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned int>(
        __int64 a1,
        unsigned int *a2)
{
  _BYTE *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h] BYREF
  _BYTE *v4; // [rsp+18h] [rbp-18h]
  unsigned int v5; // [rsp+24h] [rbp-Ch]
  unsigned int v6; // [rsp+28h] [rbp-8h]
  char v7; // [rsp+2Fh] [rbp-1h]

  v7 = 0;
  v6 = *a2;
  v5 = std::__detail::__to_chars_len<unsigned int>(v6, 0xAu);
  v3 = std::__format::_Sink_iter<char>::_M_reserve(*(_QWORD **)a1, v5);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v3);
  if ( (_BYTE)result )
  {
    v4 = (_BYTE *)std::__format::_Sink<char>::_Reservation::get(&v3);
    *v4 = 45;
    std::__detail::__to_chars_10_impl<unsigned int>(v4, v5, v6);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v3, v5);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIxEEDaSJ_ at 0x1402a
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<long long>(
        __int64 a1,
        __int64 *a2)
{
  _BYTE *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h] BYREF
  _BYTE *v4; // [rsp+18h] [rbp-18h]
  int v5; // [rsp+20h] [rbp-10h]
  bool v6; // [rsp+27h] [rbp-9h]
  unsigned __int64 v7; // [rsp+28h] [rbp-8h]

  v6 = *a2 < 0;
  if ( v6 )
    v7 = -*a2;
  else
    v7 = *a2;
  v5 = std::__detail::__to_chars_len<unsigned long long>(v7, 0xAu);
  v3 = std::__format::_Sink_iter<char>::_M_reserve(*(_QWORD **)a1, (unsigned int)v6 + v5);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v3);
  if ( (_BYTE)result )
  {
    v4 = (_BYTE *)std::__format::_Sink<char>::_Reservation::get(&v3);
    *v4 = 45;
    std::__detail::__to_chars_10_impl<unsigned long long>(&v4[v6], v5, v7);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v3, (unsigned int)v6 + v5);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIyEEDaSJ_ at 0x1410e
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned long long>(
        __int64 a1,
        unsigned __int64 *a2)
{
  _BYTE *result; // rax
  __int64 v3; // [rsp+18h] [rbp-28h] BYREF
  _BYTE *v4; // [rsp+20h] [rbp-20h]
  unsigned int v5; // [rsp+2Ch] [rbp-14h]
  unsigned __int64 v6; // [rsp+30h] [rbp-10h]
  char v7; // [rsp+3Fh] [rbp-1h]

  v7 = 0;
  v6 = *a2;
  v5 = std::__detail::__to_chars_len<unsigned long long>(v6, 0xAu);
  v3 = std::__format::_Sink_iter<char>::_M_reserve(*(_QWORD **)a1, v5);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v3);
  if ( (_BYTE)result )
  {
    v4 = (_BYTE *)std::__format::_Sink<char>::_Reservation::get(&v3);
    *v4 = 45;
    std::__detail::__to_chars_10_impl<unsigned long long>(v4, v5, v6);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v3, v5);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIfEEDaSJ_ at 0x141ba
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<float>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIdEEDaSJ_ at 0x141ce
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<double>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIeEEDaSJ_ at 0x141e2
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<long double>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIPKcEEDaSJ_ at 0x141f6
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<char const*>(
        __int64 a1,
        const char **a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  _BYTE *result; // rax
  size_t v5; // rbx
  const void *v6; // r12
  void *v7; // rax
  __int64 v8; // rax
  __int64 v9; // [rsp+18h] [rbp-28h] BYREF
  size_t v10[4]; // [rsp+20h] [rbp-20h] BYREF

  std::string_view::basic_string_view(v10, *a2);
  v2 = *(_QWORD **)a1;
  v3 = std::string_view::size((__int64)v10);
  v9 = std::__format::_Sink_iter<char>::_M_reserve(v2, v3);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v9);
  if ( (_BYTE)result )
  {
    v5 = std::string_view::size((__int64)v10);
    v6 = (const void *)std::string_view::data((__int64)v10);
    v7 = (void *)std::__format::_Sink<char>::_Reservation::get(&v9);
    memcpy(v7, v6, v5);
    v8 = std::string_view::size((__int64)v10);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v9, v8);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIS6_IcS8_IcEEEEDaSJ_ at 0x142c4
================================================================================

_BYTE *__fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::string_view>(
        __int64 a1,
        _QWORD *a2)
{
  __int64 v2; // rdx
  _QWORD *v3; // rbx
  __int64 v4; // rax
  _BYTE *result; // rax
  size_t v6; // rbx
  const void *v7; // r12
  void *v8; // rax
  __int64 v9; // rax
  __int64 v10; // [rsp+18h] [rbp-28h] BYREF
  _QWORD v11[4]; // [rsp+20h] [rbp-20h] BYREF

  v2 = a2[1];
  v11[0] = *a2;
  v11[1] = v2;
  v3 = *(_QWORD **)a1;
  v4 = std::string_view::size((__int64)v11);
  v10 = std::__format::_Sink_iter<char>::_M_reserve(v3, v4);
  result = (_BYTE *)std::__format::_Sink<char>::_Reservation::operator bool(&v10);
  if ( (_BYTE)result )
  {
    v6 = std::string_view::size((__int64)v11);
    v7 = (const void *)std::string_view::data((__int64)v11);
    v8 = (void *)std::__format::_Sink<char>::_Reservation::get(&v10);
    memcpy(v8, v7, v6);
    v9 = std::string_view::size((__int64)v11);
    std::__format::_Sink<char>::_Reservation::_M_bump(&v10, v9);
    result = *(_BYTE **)(a1 + 8);
    *result = 1;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIPKvEEDaSJ_ at 0x1438e
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<void const*>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clINSt16basic_format_argIS4_E6handleEEEDaSJ_ at 0x143a2
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clInEEDaSJ_ at 0x143b6
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<__int128>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIoEEDaSJ_ at 0x143ca
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned __int128>()
{
  ;
}



================================================================================
Function: _ZZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6localeENKUlRS5_E_clIDF128_EEDaSJ_ at 0x143de
================================================================================

void std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<_Float128>()
{
  ;
}



================================================================================
Function: _ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE8_M_visitIZNS1_15__do_vformat_toIS3_cS4_EET_S8_St17basic_string_viewIT0_St11char_traitsISA_EERKSt17basic_format_argsIT1_EPKSt6localeEUlRS8_E_EEDcOS8_NS1_6_Arg_tE at 0x143f2
================================================================================

void __fastcall std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_visit<std::__format::_Sink_iter<char> std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}>(
        const char **a1,
        _QWORD *a2,
        unsigned __int8 a3)
{
  if ( a3 == 20 )
  {
    std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<_Float128>();
  }
  else if ( a3 <= 0x14u )
  {
    if ( a3 == 15 )
    {
      std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned __int128>();
    }
    else if ( a3 <= 0xFu )
    {
      switch ( a3 )
      {
        case 0xEu:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<__int128>();
          break;
        case 0xDu:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>();
          break;
        case 0xCu:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<void const*>();
          break;
        case 0xBu:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::string_view>(
            (__int64)a2,
            a1);
          break;
        case 0xAu:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<char const*>(
            (__int64)a2,
            a1);
          break;
        case 9u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<long double>();
          break;
        case 8u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<double>();
          break;
        case 7u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<float>();
          break;
        case 6u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned long long>(
            (__int64)a2,
            (unsigned __int64 *)a1);
          break;
        case 5u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<long long>(
            (__int64)a2,
            (__int64 *)a1);
          break;
        case 4u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<unsigned int>(
            (__int64)a2,
            (unsigned int *)a1);
          break;
        case 3u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<int>(
            (__int64)a2,
            (int *)a1);
          break;
        case 2u:
          std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<char>(
            (__int64)a2,
            (char *)a1);
          break;
        default:
          if ( a3 )
            std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<bool>(
              a2,
              a1);
          else
            std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}::operator()<std::monostate>();
          break;
      }
    }
  }
}



================================================================================
Function: _ZNSt8__format18__visit_format_argIZNS_15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS3_cEEET_S6_St17basic_string_viewIT0_St11char_traitsIS8_EERKSt17basic_format_argsIT1_EPKSt6localeEUlRS6_E_S5_EEDcOS6_St16basic_format_argIS8_E at 0x147c6
================================================================================

void __fastcall std::__format::__visit_format_arg<std::__format::_Sink_iter<char> std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1},std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        const char *a7,
        int a8,
        unsigned __int8 a9)
{
  std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_visit<std::__format::_Sink_iter<char> std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1}>(
    &a7,
    a1,
    a9);
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcED2Ev at 0x147f8
================================================================================

void __fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::~basic_format_context(__int64 a1)
{
  std::__format::_Optional_locale::~_Optional_locale((std::__format::_Optional_locale *)(a1 + 24));
}



================================================================================
Function: _ZNSt8__format15__do_vformat_toINS_10_Sink_iterIcEEcSt20basic_format_contextIS2_cEEET_S5_St17basic_string_viewIT0_St11char_traitsIS7_EERKSt17basic_format_argsIT1_EPKSt6locale at 0x1481b
================================================================================

__int64 __fastcall std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        __int64 a1,
        unsigned __int64 a2,
        __int64 a3,
        _QWORD *a4,
        __int64 a5)
{
  __int64 v5; // r8
  __int64 v6; // r9
  __int64 v8; // rax
  __int64 v9; // rdx
  __int64 v10; // rcx
  __int64 v11; // rdx
  __int64 v12; // rbx
  _QWORD v14[5]; // [rsp-20h] [rbp-2B0h] BYREF
  __int64 v15; // [rsp+8h] [rbp-288h]
  unsigned __int64 v16; // [rsp+10h] [rbp-280h] BYREF
  __int64 v17; // [rsp+18h] [rbp-278h]
  _QWORD *v18; // [rsp+20h] [rbp-270h]
  __int64 v19; // [rsp+28h] [rbp-268h]
  char v20; // [rsp+3Fh] [rbp-251h] BYREF
  _QWORD v21[3]; // [rsp+40h] [rbp-250h] BYREF
  __int64 v22; // [rsp+58h] [rbp-238h]
  void (__fastcall **v23[8])(_QWORD, unsigned __int64); // [rsp+60h] [rbp-230h] BYREF
  _BYTE v24[40]; // [rsp+A0h] [rbp-1F0h] BYREF
  __int64 v25; // [rsp+C8h] [rbp-1C8h] BYREF
  _QWORD v26[4]; // [rsp+D0h] [rbp-1C0h] BYREF
  _QWORD v27[36]; // [rsp+F0h] [rbp-1A0h] BYREF
  const char *v28; // [rsp+210h] [rbp-80h] BYREF
  __int64 v29; // [rsp+218h] [rbp-78h]
  __int64 v30; // [rsp+220h] [rbp-70h]
  __int64 v31; // [rsp+228h] [rbp-68h]
  _QWORD v32[2]; // [rsp+230h] [rbp-60h] BYREF
  __int64 v33; // [rsp+240h] [rbp-50h] BYREF
  __int64 v34; // [rsp+248h] [rbp-48h]
  const char **v35; // [rsp+250h] [rbp-40h]
  unsigned __int64 v36; // [rsp+258h] [rbp-38h]
  _QWORD *v37; // [rsp+260h] [rbp-30h]
  _QWORD *v38; // [rsp+268h] [rbp-28h]
  _QWORD *v39; // [rsp+270h] [rbp-20h]
  __int64 v40; // [rsp+278h] [rbp-18h]

  v19 = a1;
  v16 = a2;
  v17 = a3;
  v18 = a4;
  v15 = a5;
  v22 = a1;
  v40 = -1;
  v39 = v26;
  std::span<char,18446744073709551615ul>::span<256ul>(&v33, v27);
  v38 = v26;
  v21[0] = v33;
  v21[1] = v34;
  v26[0] = &off_37918;
  v26[1] = v33;
  v26[2] = v34;
  v26[3] = std::span<char,18446744073709551615ul>::begin(v21);
  *v39 = &off_378F0;
  v26[0] = off_37790;
  v27[32] = v22;
  v27[33] = v40;
  v27[34] = 0;
  v25 = v19;
  if ( std::string_view::size((__int64)&v16) != 2
    || *(_BYTE *)std::string_view::operator[](&v16, 0) != 123
    || *(_BYTE *)std::string_view::operator[](&v16, 1u) != 125 )
  {
    goto LABEL_13;
  }
  v20 = 0;
  v37 = v18;
  v36 = 0;
  v35 = &v28;
  LOBYTE(v30) = 0;
  if ( (*(_BYTE *)v18 & 0xF) != 0 )
  {
    LOBYTE(v30) = std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_type(
                    v37,
                    v36);
    v8 = 16 * v36 + v37[1];
    v9 = *(_QWORD *)(v8 + 8);
    v28 = *(const char **)v8;
    v29 = v9;
  }
  else if ( v36 < *v37 >> 4 )
  {
    v10 = v37[1] + 32 * v36;
    v11 = *(_QWORD *)(v10 + 8);
    v28 = *(const char **)v10;
    v29 = v11;
    LOBYTE(v30) = *(_BYTE *)(v10 + 16);
  }
  v32[0] = &v25;
  v32[1] = &v20;
  v14[3] = v31;
  std::__format::__visit_format_arg<std::__format::_Sink_iter<char> std::__format::__do_vformat_to<std::__format::_Sink_iter<char>,char,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(std::__format::_Sink_iter<char>,std::string_view,std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>> const&,std::locale const*)::{lambda(std::__format::_Sink_iter<char>&)#1},std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
    v32,
    (__int64)v32,
    v31,
    (__int64)v14,
    v5,
    v6,
    v28,
    v29,
    v30);
  if ( v20 )
    return v25;
LABEL_13:
  if ( v15 )
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::basic_format_context(v24, *v18, v18[1], v25, v15);
  else
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::basic_format_context(v24, *v18, v18[1], v25);
  std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_Formatting_scanner(v23, v24, v16, v17);
  std::__format::_Scanner<char>::_M_scan(v23);
  v12 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(v24);
  std::basic_format_context<std::__format::_Sink_iter<char>,char>::~basic_format_context((__int64)v24);
  return v12;
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE4sizeEv at 0x14bba
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::size(__int64 a1)
{
  return *(_QWORD *)(a1 + 8);
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE5emptyEv at 0x14bdc
================================================================================

bool __fastcall std::span<char,18446744073709551615ul>::empty(__int64 a1)
{
  return std::span<char,18446744073709551615ul>::size(a1) == 0;
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE4dataEv at 0x14c00
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::data(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE11_M_overflowEv at 0x14c16
================================================================================

char __fastcall std::__format::_Seq_sink<std::string>::_M_overflow(__int64 a1)
{
  __int64 v1; // rdx
  __int64 v2; // rdx
  __int64 v3; // rax
  __int64 v4; // r12
  __int64 v5; // rax
  _QWORD v7[2]; // [rsp+10h] [rbp-50h] BYREF
  _QWORD v8[8]; // [rsp+20h] [rbp-40h] BYREF

  v8[5] = a1;
  v8[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v8[4] = a1 + 24;
  v8[3] = a1 + 24;
  v1 = *(_QWORD *)(a1 + 24);
  v8[2] = v8;
  v7[0] = std::span<char,18446744073709551615ul>::first(a1 + 8, v1 - v8[0]);
  v7[1] = v2;
  LOBYTE(v3) = std::span<char,18446744073709551615ul>::empty((__int64)v7);
  if ( !(_BYTE)v3 )
  {
    v4 = std::span<char,18446744073709551615ul>::size((__int64)v7);
    v5 = std::span<char,18446744073709551615ul>::data((__int64)v7);
    std::string::append(a1 + 288, v5, v4);
    v8[1] = a1;
    v3 = std::span<char,18446744073709551615ul>::begin(a1 + 8);
    *(_QWORD *)(a1 + 24) = v3;
  }
  return v3;
}



================================================================================
Function: _ZNKSt16reverse_iteratorIPKNSt8__format6_Arg_tEEdeEv at 0x14d02
================================================================================

__int64 __fastcall std::reverse_iterator<std::__format::_Arg_t const*>::operator*(_QWORD *a1)
{
  return *a1 - 1LL;
}



================================================================================
Function: _ZNSt8__format16__pack_arg_typesILi5ELm3EEEDaRKSt5arrayINS_6_Arg_tEXT0_EE at 0x14d24
================================================================================

__int64 __fastcall std::__format::__pack_arg_types<5,3ul>(__int64 a1)
{
  __int64 v1; // rbx
  __int64 v3; // [rsp+18h] [rbp-28h] BYREF
  char v4[8]; // [rsp+20h] [rbp-20h] BYREF
  __int64 v5; // [rsp+28h] [rbp-18h]

  v5 = 0;
  std::array<std::__format::_Arg_t,3ul>::rbegin(&v3, a1);
  while ( 1 )
  {
    std::array<std::__format::_Arg_t,3ul>::rend(v4, a1);
    if ( (unsigned __int8)std::operator==<std::__format::_Arg_t const*>(&v3, v4) == 1 )
      break;
    v1 = 32 * v5;
    v5 = v1 | *(unsigned __int8 *)std::reverse_iterator<std::__format::_Arg_t const*>::operator*(&v3);
    std::reverse_iterator<std::__format::_Arg_t const*>::operator++(&v3);
  }
  return v5;
}



================================================================================
Function: _ZNKSt5arrayINSt8__format6_Arg_tELm3EE6rbeginEv at 0x14dba
================================================================================

__int64 __fastcall std::array<std::__format::_Arg_t,3ul>::rbegin(__int64 a1, __int64 a2)
{
  __int64 v2; // rax

  v2 = std::array<std::__format::_Arg_t,3ul>::end(a2);
  std::reverse_iterator<std::__format::_Arg_t const*>::reverse_iterator(a1, v2);
  return a1;
}



================================================================================
Function: _ZNKSt5arrayINSt8__format6_Arg_tELm3EE3endEv at 0x14df2
================================================================================

__int64 __fastcall std::array<std::__format::_Arg_t,3ul>::end(__int64 a1)
{
  return std::array<std::__format::_Arg_t,3ul>::data(a1) + 3;
}



================================================================================
Function: _ZNKSt5arrayINSt8__format6_Arg_tELm3EE4dataEv at 0x14e14
================================================================================

__int64 __fastcall std::array<std::__format::_Arg_t,3ul>::data(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt16reverse_iteratorIPKNSt8__format6_Arg_tEEC2ES3_ at 0x14e26
================================================================================

_QWORD *__fastcall std::reverse_iterator<std::__format::_Arg_t const*>::reverse_iterator(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZNKSt5arrayINSt8__format6_Arg_tELm3EE4rendEv at 0x14e44
================================================================================

_QWORD *__fastcall std::array<std::__format::_Arg_t,3ul>::rend(_QWORD *a1, __int64 a2)
{
  __int64 v2; // rax

  v2 = std::array<std::__format::_Arg_t,3ul>::begin(a2);
  std::reverse_iterator<std::__format::_Arg_t const*>::reverse_iterator(a1, v2);
  return a1;
}



================================================================================
Function: _ZNKSt5arrayINSt8__format6_Arg_tELm3EE5beginEv at 0x14e7c
================================================================================

__int64 __fastcall std::array<std::__format::_Arg_t,3ul>::begin(__int64 a1)
{
  return std::array<std::__format::_Arg_t,3ul>::data(a1);
}



================================================================================
Function: _ZSteqIPKNSt8__format6_Arg_tEEbRKSt16reverse_iteratorIT_ES8_QrqXeqcldtfL0p_4baseEcldtfL0p0_4baseERSt14convertible_toIbEE at 0x14e9a
================================================================================

bool __fastcall std::operator==<std::__format::_Arg_t const*>(__int64 a1, __int64 a2)
{
  __int64 v2; // rbx

  v2 = std::reverse_iterator<std::__format::_Arg_t const*>::base(a1);
  return v2 == std::reverse_iterator<std::__format::_Arg_t const*>::base(a2);
}



================================================================================
Function: _ZNKSt16reverse_iteratorIPKNSt8__format6_Arg_tEE4baseEv at 0x14ed6
================================================================================

__int64 __fastcall std::reverse_iterator<std::__format::_Arg_t const*>::base(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNSt16reverse_iteratorIPKNSt8__format6_Arg_tEEppEv at 0x14eec
================================================================================

_QWORD *__fastcall std::reverse_iterator<std::__format::_Arg_t const*>::operator++(_QWORD *a1)
{
  --*a1;
  return a1;
}



================================================================================
Function: _ZNSt17basic_format_argsISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEEC2IJPKcS8_S8_EEERKNS1_10_Arg_storeIS4_JDpT_EEE at 0x14f10
================================================================================

__int64 __fastcall std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::basic_format_args<char const*,char const*,char const*>(
        __int64 a1,
        __int64 a2)
{
  __int64 result; // rax
  _BYTE v3[3]; // [rsp+1Dh] [rbp-3h] BYREF

  *(_BYTE *)a1 = *(_BYTE *)a1 & 0xF0 | 3;
  memset(v3, 10, sizeof(v3));
  *(_QWORD *)a1 = (16 * std::__format::__pack_arg_types<5,3ul>((__int64)v3)) | *(_QWORD *)a1 & 0xFLL;
  result = a1;
  *(_QWORD *)(a1 + 8) = a2;
  return result;
}



================================================================================
Function: _ZNSt4pairItPKcEC2IiS1_EEOT_OT0_ at 0x14f7e
================================================================================

__int64 __fastcall std::pair<unsigned short,char const*>::pair<int,char const*>(__int64 a1, _DWORD *a2, _QWORD *a3)
{
  __int64 result; // rax

  *(_WORD *)a1 = *a2;
  result = a1;
  *(_QWORD *)(a1 + 8) = *a3;
  return result;
}



================================================================================
Function: _ZNSt4pairItPKcEC2ERKtRKS1_Qcl16_S_constructibleIRKT_RKT0_EE at 0x14fc4
================================================================================

__int64 __fastcall std::pair<unsigned short,char const*>::pair(__int64 a1, _WORD *a2, _QWORD *a3)
{
  __int64 result; // rax

  *(_WORD *)a1 = *a2;
  result = a1;
  *(_QWORD *)(a1 + 8) = *a3;
  return result;
}



================================================================================
Function: _ZNSt8__format15__parse_integerIcEESt4pairItPKT_ES4_S4_ at 0x14ff8
================================================================================

__int64 __fastcall std::__format::__parse_integer<char>(__int64 a1, __int64 a2)
{
  __int64 result; // rax
  _QWORD v4[2]; // [rsp+8h] [rbp-58h] BYREF
  __int16 v5; // [rsp+1Eh] [rbp-42h] BYREF
  __int64 v6; // [rsp+20h] [rbp-40h] BYREF
  __int64 v7; // [rsp+30h] [rbp-30h] BYREF
  int v8; // [rsp+4Ch] [rbp-14h] BYREF
  __int64 v9; // [rsp+50h] [rbp-10h] BYREF
  __int64 v10; // [rsp+58h] [rbp-8h]

  v4[0] = a1;
  v10 = a1;
  v5 = 0;
  if ( (unsigned __int8)std::__detail::__from_chars_alnum<true,unsigned short>(v4, a2, &v5, 10) && v10 != v4[0] )
  {
    std::pair<unsigned short,char const*>::pair<unsigned short &,char const*&>(&v6, &v5, v4);
    LODWORD(result) = v6;
  }
  else
  {
    v8 = 0;
    v9 = 0;
    std::pair<unsigned short,char const*>::pair<int,decltype(nullptr)>(&v7, &v8, &v9);
    LODWORD(result) = v7;
  }
  return (unsigned int)result;
}



================================================================================
Function: _ZNSt4pairItPKcEC2IiDnEEOT_OT0_ at 0x150ae
================================================================================

__int64 __fastcall std::pair<unsigned short,char const*>::pair<int,decltype(nullptr)>(__int64 a1, _DWORD *a2)
{
  __int64 result; // rax

  *(_WORD *)a1 = *a2;
  result = a1;
  *(_QWORD *)(a1 + 8) = 0;
  return result;
}



================================================================================
Function: _ZNKSt6ranges8__access6_BeginclIRNS_8subrangeIPKcS5_LNS_13subrange_kindE1EEEEEDaOT_ at 0x150f0
================================================================================

__int64 __fastcall std::ranges::__access::_Begin::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> &>(
        __int64 a1,
        __int64 a2)
{
  return std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::begin(a2);
}



================================================================================
Function: _ZNKSt6ranges8__access4_EndclIRNS_8subrangeIPKcS5_LNS_13subrange_kindE1EEEEEDaOT_ at 0x15112
================================================================================

__int64 __fastcall std::ranges::__access::_End::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> &>(
        __int64 a1,
        __int64 a2)
{
  return std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::end(a2);
}



================================================================================
Function: _ZNKSt9__unicode9_Utf_viewIDiNSt6ranges8subrangeIPKcS4_LNS1_13subrange_kindE1EEEE5emptyEv at 0x15134
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::empty(
        __int64 a1)
{
  return std::ranges::__access::_Empty::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> const&>(
           &std::ranges::_Cpo::empty,
           a1);
}



================================================================================
Function: _ZNKSt6ranges8__access6_EmptyclIRKNS_8subrangeIPKcS5_LNS_13subrange_kindE1EEEEEbOT_ at 0x1515c
================================================================================

__int64 __fastcall std::ranges::__access::_Empty::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> const&>(
        __int64 a1,
        __int64 a2)
{
  return std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::empty(a2);
}



================================================================================
Function: _ZNKSt6ranges8subrangeIPKcS2_LNS_13subrange_kindE1EE5emptyEv at 0x1517e
================================================================================

bool __fastcall std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::empty(_QWORD *a1)
{
  return *a1 == a1[1];
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiNSt6ranges8subrangeIPKcS4_LNS1_13subrange_kindE1EEEE8_M_beginIS4_S4_EEDaT_T0_ at 0x151a2
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::_M_begin<char const*,char const*>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Utf_iterator(
    a1,
    a3,
    a3,
    a4,
    a5,
    a6,
    a4,
    a3,
    a2);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiNSt6ranges8subrangeIPKcS4_LNS1_13subrange_kindE1EEEE5beginEv at 0x151dc
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::begin(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  __int64 v4; // r8
  __int64 v5; // r9

  v2 = std::ranges::__access::_End::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> &>(
         (__int64)&std::ranges::_Cpo::end,
         a2);
  v3 = std::ranges::__access::_Begin::operator()<std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1> &>(
         (__int64)&std::ranges::_Cpo::begin,
         a2);
  std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::_M_begin<char const*,char const*>(
    a1,
    a2,
    v3,
    v2,
    v4,
    v5);
  return a1;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE23_M_parse_fill_and_alignEPKcS3_St17basic_string_viewIcSt11char_traitsIcEE at 0x15242
================================================================================

char *__fastcall std::__format::_Spec<char>::_M_parse_fill_and_align(
        __int64 a1,
        _BYTE *a2,
        char *a3,
        __int64 a4,
        __int64 a5)
{
  _QWORD v6[3]; // [rsp+0h] [rbp-E0h] BYREF
  char *v7; // [rsp+18h] [rbp-C8h]
  _BYTE *v8; // [rsp+20h] [rbp-C0h]
  __int64 v9; // [rsp+28h] [rbp-B8h]
  char32_t v10[12]; // [rsp+30h] [rbp-B0h] BYREF
  _BYTE v11[16]; // [rsp+60h] [rbp-80h] BYREF
  _BYTE v12[16]; // [rsp+70h] [rbp-70h] BYREF
  _BYTE v13[47]; // [rsp+80h] [rbp-60h] BYREF
  char v14; // [rsp+AFh] [rbp-31h]
  int v15; // [rsp+B0h] [rbp-30h]
  int v16; // [rsp+B4h] [rbp-2Ch]
  char *v17; // [rsp+B8h] [rbp-28h]
  _DWORD v18[3]; // [rsp+C4h] [rbp-1Ch]
  _QWORD *v19; // [rsp+D0h] [rbp-10h]
  char *v20; // [rsp+D8h] [rbp-8h]

  v9 = a1;
  v8 = a2;
  v7 = a3;
  v6[0] = a4;
  v6[1] = a5;
  v19 = v6;
  v20 = (char *)std::string_view::begin((__int64)v6);
  *(_QWORD *)&v18[1] = std::string_view::end(v19);
  while ( v20 != *(char **)&v18[1] )
  {
    v14 = *v20;
    if ( v14 == *v8 )
      return v8;
    ++v20;
  }
  std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::subrange<char const*>(v12, v8, v7);
  std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::_Utf_view(
    v11,
    v12);
  if ( (unsigned __int8)std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::empty((__int64)v11) != 1
    && (std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::begin(
          (__int64)v10,
          (__int64)v11),
        std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++(
          v13,
          v10,
          0),
        v18[0] = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*(v13),
        std::__unicode::__is_scalar_value((std::__unicode *)v18[0]))
    && (v17 = (char *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base(v10),
        v17 != v7)
    && (v16 = std::__format::_Spec<char>::_S_align((unsigned int)*v17)) != 0 )
  {
    *(_DWORD *)(v9 + 8) = v18[0];
    *(_BYTE *)v9 = v16 & 3 | *(_BYTE *)v9 & 0xFC;
    return v17 + 1;
  }
  else
  {
    v15 = std::__format::_Spec<char>::_S_align((unsigned int)(char)*v8);
    if ( v15 )
    {
      *(_DWORD *)(v9 + 8) = 32;
      *(_BYTE *)v9 = v15 & 3 | *(_BYTE *)v9 & 0xFC;
      return v8 + 1;
    }
    else
    {
      return v8;
    }
  }
}



================================================================================
Function: _ZNSt8__format5_SpecIcE27_S_parse_width_or_precisionEPKcS3_RtRbRSt26basic_format_parse_contextIcE at 0x15446
================================================================================

char *__fastcall std::__format::_Spec<char>::_S_parse_width_or_precision(
        char *a1,
        char *a2,
        _WORD *a3,
        _BYTE *a4,
        __int64 a5)
{
  std::__format *v5; // rdi
  __int64 v6; // rdx
  __int64 v7; // rdx
  _BYTE *v12; // [rsp+28h] [rbp-48h]
  char *v13; // [rsp+28h] [rbp-48h]
  int v14; // [rsp+30h] [rbp-40h] BYREF
  __int64 v15; // [rsp+38h] [rbp-38h]
  int v16; // [rsp+40h] [rbp-30h] BYREF
  __int64 v17; // [rsp+48h] [rbp-28h]
  _QWORD *v18; // [rsp+50h] [rbp-20h]
  _WORD *v19; // [rsp+58h] [rbp-18h]
  char **v20; // [rsp+60h] [rbp-10h]
  _WORD *v21; // [rsp+68h] [rbp-8h]

  v12 = a1;
  v5 = (std::__format *)(unsigned int)*a1;
  if ( std::__format::__is_digit(v5) )
  {
    v16 = std::__format::__parse_integer<char>((__int64)v12, (__int64)a2);
    v17 = v6;
    v19 = (_WORD *)std::get<0ul,unsigned short,char const*>((__int64)&v16);
    v18 = (_QWORD *)std::get<1ul,unsigned short,char const*>((__int64)&v16);
    if ( !*v18 )
      std::__throw_format_error("format error: invalid width or precision in format-spec");
    v12 = (_BYTE *)*v18;
    *a3 = *v19;
  }
  else if ( *v12 == 123 )
  {
    *a4 = 1;
    v13 = v12 + 1;
    if ( v13 == a2 )
      std::__format::__unmatched_left_brace_in_format_string(v5);
    if ( *v13 == 125 )
    {
      *a3 = std::basic_format_parse_context<char>::next_arg_id(a5);
    }
    else
    {
      v14 = std::__format::__parse_arg_id<char>(v13, a2);
      v15 = v7;
      v21 = (_WORD *)std::get<0ul,unsigned short,char const*>((__int64)&v14);
      v20 = (char **)std::get<1ul,unsigned short,char const*>((__int64)&v14);
      if ( !*v20 || a2 == *v20 || **v20 != 125 )
        std::__format::__invalid_arg_id_in_format_string((std::__format *)&v14);
      v13 = *v20;
      std::basic_format_parse_context<char>::check_arg_id(a5, (unsigned __int16)*v21);
      *a3 = *v21;
    }
    return v13 + 1;
  }
  return v12;
}



================================================================================
Function: _ZN4pqxx6params11append_packIRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJEEEvOT_DpOT0_ at 0x155ea
================================================================================

void __fastcall pqxx::params::append_pack<std::string &>(pqxx::params *a1)
{
  pqxx::params::append();
  pqxx::params::append_pack(a1);
}



================================================================================
Function: _ZN4pqxx6params11append_packIRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_EEEvOT_DpOT0_ at 0x15628
================================================================================

void __fastcall pqxx::params::append_pack<std::string &,std::string &>(pqxx::params *a1)
{
  pqxx::params::append();
  pqxx::params::append_pack<std::string &>(a1);
}



================================================================================
Function: _ZN4pqxx6params11append_packIRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJS8_S8_EEEvOT_DpOT0_ at 0x1567a
================================================================================

void __fastcall pqxx::params::append_pack<std::string &,std::string &,std::string &>(pqxx::params *a1)
{
  pqxx::params::append();
  pqxx::params::append_pack<std::string &,std::string &>(a1);
}



================================================================================
Function: _ZN4pqxx11from_stringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_St17basic_string_viewIcS4_E at 0x156db
================================================================================

__int64 __fastcall pqxx::from_string<std::string>(__int64 a1, __int64 a2, __int64 a3)
{
  pqxx::string_traits<std::string>::from_string(a1, a2, a3);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm at 0x15722
================================================================================

_QWORD *__fastcall std::string::replace(
        _QWORD *a1,
        unsigned __int64 a2,
        unsigned __int64 a3,
        _BYTE *a4,
        unsigned __int64 a5)
{
  unsigned __int64 v5; // rbx
  size_t v6; // rax

  v5 = std::string::_M_limit((__int64)a1, a2, a3);
  v6 = std::string::_M_check((__int64)a1, a2);
  return std::string::_M_replace(a1, v6, v5, a4, a5);
}



================================================================================
Function: _ZSt11__bit_widthImEiT_ at 0x1579d
================================================================================

__int64 __fastcall std::__bit_width<unsigned long>(__int64 a1)
{
  return 64 - (unsigned int)std::__countl_zero<unsigned long>(a1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEmc at 0x157cc
================================================================================

__int64 __fastcall std::string::append(__int64 a1, __int64 a2, char a3)
{
  unsigned int v3; // ebx
  __int64 v4; // rax

  v3 = a3;
  v4 = std::string::size(a1);
  return std::string::_M_replace_aux(a1, v4, 0, a2, v3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE10_M_destroyEm at 0x1581a
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_M_destroy(__int64 a1, __int64 a2)
{
  __int64 allocator; // [rsp+20h] [rbp-30h]
  __int64 v4; // [rsp+30h] [rbp-20h]

  v4 = std::basic_string<std::byte>::_M_data(a1);
  allocator = std::basic_string<std::byte>::_M_get_allocator(a1);
  return std::__new_allocator<std::byte>::deallocate(allocator, v4, a2 + 1);
}



================================================================================
Function: _ZNKSt7__cxx1112basic_stringISt4byteSt11char_traitsIS1_ESaIS1_EE13_M_local_dataEv at 0x158b2
================================================================================

__int64 __fastcall std::basic_string<std::byte>::_M_local_data(__int64 a1)
{
  return std::__ptr_traits_ptr_to<std::byte const*,std::byte const,false>::pointer_to(a1 + 16);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE8_S_rightEPSt13_Rb_tree_nodeISB_E at 0x158d4
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_S_right(
        __int64 a1)
{
  if ( *(_QWORD *)(a1 + 24) )
    return std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_node_ptr(*(_QWORD *)(a1 + 24));
  else
    return 0;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE7_S_leftEPSt13_Rb_tree_nodeISB_E at 0x1590a
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_S_left(
        __int64 a1)
{
  if ( *(_QWORD *)(a1 + 16) )
    return std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_node_ptr(*(_QWORD *)(a1 + 16));
  else
    return 0;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE12_M_drop_nodeEPSt13_Rb_tree_nodeISB_E at 0x15940
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_drop_node(
        __int64 a1,
        __int64 a2)
{
  std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_destroy_node(
    a1,
    a2);
  return std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_put_node(
           a1,
           a2);
}



================================================================================
Function: _ZNSt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEE11_M_node_ptrEv at 0x1597e
================================================================================

__int64 __fastcall std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_node_ptr(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE8_S_rightEPSt13_Rb_tree_nodeISD_E at 0x15990
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_S_right(
        __int64 a1)
{
  if ( *(_QWORD *)(a1 + 24) )
    return std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_node_ptr(*(_QWORD *)(a1 + 24));
  else
    return 0;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE7_S_leftEPSt13_Rb_tree_nodeISD_E at 0x159c6
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_S_left(
        __int64 a1)
{
  if ( *(_QWORD *)(a1 + 16) )
    return std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_node_ptr(*(_QWORD *)(a1 + 16));
  else
    return 0;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE12_M_drop_nodeEPSt13_Rb_tree_nodeISD_E at 0x159fc
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_drop_node(
        __int64 a1,
        __int64 a2)
{
  std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_destroy_node(
    a1,
    a2);
  return std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_put_node(
           a1,
           a2);
}



================================================================================
Function: _ZNSt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEE11_M_node_ptrEv at 0x15a3a
================================================================================

__int64 __fastcall std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_node_ptr(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc at 0x15a4c
================================================================================

_QWORD *__fastcall std::string::_M_replace_aux(_QWORD *a1, size_t a2, __int64 a3, unsigned __int64 a4, char a5)
{
  __int64 v5; // rax
  size_t v10; // [rsp+38h] [rbp-28h]
  unsigned __int64 v11; // [rsp+40h] [rbp-20h]
  __int64 v12; // [rsp+48h] [rbp-18h]

  std::string::_M_check_length((__int64)a1, a3, a4, "basic_string::_M_replace_aux");
  v12 = std::string::size((__int64)a1);
  v11 = v12 + a4 - a3;
  if ( std::string::capacity((__int64)a1) < v11 )
  {
    std::string::_M_mutate(a1, a2, a3, 0, a4);
  }
  else
  {
    v10 = a2 + std::string::_M_data((__int64)a1);
    if ( v12 - a2 != a3 && a3 != a4 )
      std::string::_S_move((_BYTE *)(v10 + a4), (_BYTE *)(v10 + a3), v12 - a2 - a3);
  }
  if ( a4 )
  {
    v5 = std::string::_M_data((__int64)a1);
    std::string::_S_assign((_BYTE *)(v5 + a2), a4, a5);
  }
  std::string::_M_set_length((__int64)a1, v11);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc at 0x15b92
================================================================================

_BYTE *__fastcall std::string::push_back(_QWORD *a1, char a2)
{
  __int64 v2; // rax
  _BYTE v4[4]; // [rsp+4h] [rbp-2Ch] BYREF
  _QWORD *v5; // [rsp+8h] [rbp-28h]
  size_t v6; // [rsp+18h] [rbp-18h]

  v5 = a1;
  v4[0] = a2;
  v6 = std::string::size((__int64)a1);
  if ( std::string::capacity((__int64)a1) < v6 + 1 )
    std::string::_M_mutate(v5, v6, 0, 0, 1u);
  v2 = std::string::_M_data((__int64)v5);
  std::char_traits<char>::assign((_BYTE *)(v2 + v6), v4);
  return std::string::_M_set_length((__int64)v5, v6 + 1);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendISt17basic_string_viewIcS2_EEENSt9enable_ifIXsrSt6__and_IJSt14is_convertibleIRKT_S7_ESt6__not_ISA_IPSC_PKS4_EESF_ISA_ISD_PKcEEEE5valueERS4_E4typeESD_ at 0x15c36
================================================================================

__int64 __fastcall std::string::append<std::string_view>(__int64 a1, _QWORD *a2)
{
  __int64 v2; // rdx
  __int64 v3; // rbx
  __int64 v4; // rax
  _QWORD v6[3]; // [rsp+10h] [rbp-20h] BYREF

  v2 = a2[1];
  v6[0] = *a2;
  v6[1] = v2;
  v3 = std::string_view::size((__int64)v6);
  v4 = std::string_view::data((__int64)v6);
  return std::string::append(a1, v4, v3);
}



================================================================================
Function: _ZNSt12_Vector_baseIPKcSaIS1_EE13_M_deallocateEPS1_m at 0x15c94
================================================================================

__int64 __fastcall std::_Vector_base<char const*>::_M_deallocate(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  if ( a2 )
    return std::__new_allocator<char const*>::deallocate(a1, a2, a3);
  return result;
}



================================================================================
Function: _ZSt8_DestroyIPPKcEvT_S3_ at 0x15d15
================================================================================

__int64 std::_Destroy<char const**>()
{
  return 0;
}



================================================================================
Function: _ZNSt12_Vector_baseIiSaIiEE13_M_deallocateEPim at 0x15d5a
================================================================================

__int64 __fastcall std::_Vector_base<int>::_M_deallocate(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  if ( a2 )
    return std::__new_allocator<int>::deallocate(a1, a2, a3);
  return result;
}



================================================================================
Function: _ZSt8_DestroyIPiEvT_S1_ at 0x15ddb
================================================================================

__int64 std::_Destroy<int *>()
{
  return 0;
}



================================================================================
Function: _ZNSt12_Vector_baseIN4pqxx6formatESaIS1_EE13_M_deallocateEPS1_m at 0x15e20
================================================================================

__int64 __fastcall std::_Vector_base<pqxx::format>::_M_deallocate(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 result; // rax

  if ( a2 )
    return std::__new_allocator<pqxx::format>::deallocate(a1, a2, a3);
  return result;
}



================================================================================
Function: _ZSt8_DestroyIPN4pqxx6formatEEvT_S3_ at 0x15ea1
================================================================================

__int64 std::_Destroy<pqxx::format *>()
{
  return 0;
}



================================================================================
Function: _ZSt8_DestroyIPSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEEEvT_SH_ at 0x15ee6
================================================================================

__int64 __fastcall std::_Destroy<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> *>(
        __int64 a1,
        __int64 a2)
{
  __int64 result; // rax

  while ( 1 )
  {
    result = a1;
    if ( a1 == a2 )
      break;
    std::_Destroy<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>(a1);
    a1 += 40;
  }
  return result;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEE10_S_compareEmm at 0x15f23
================================================================================

__int64 __fastcall std::string_view::_S_compare(__int64 a1, __int64 a2)
{
  if ( a1 - a2 > 0x7FFFFFFF )
    return 0x7FFFFFFF;
  if ( a1 - a2 >= (__int64)0xFFFFFFFF80000000LL )
    return a1 - a2;
  return 0x80000000LL;
}



================================================================================
Function: _ZNK9__gnu_cxx5__ops14_Val_less_iterclIKDiPS3_EEbRT_T0_ at 0x15f68
================================================================================

bool __fastcall __gnu_cxx::__ops::_Val_less_iter::operator()<char32_t const,char32_t const*>(
        __int64 a1,
        _DWORD *a2,
        _DWORD *a3)
{
  return *a2 < *a3;
}



================================================================================
Function: _ZNK9__gnu_cxx5__ops14_Iter_less_valclIPKjS3_EEbT_RT0_ at 0x15f90
================================================================================

bool __fastcall __gnu_cxx::__ops::_Iter_less_val::operator()<unsigned int const*,unsigned int const>(
        __int64 a1,
        _DWORD *a2,
        _DWORD *a3)
{
  return *a2 < *a3;
}



================================================================================
Function: _ZN9__gnu_cxx5__ops16_Iter_equals_valIKDiEC2ERS2_ at 0x15fb8
================================================================================

_QWORD *__fastcall __gnu_cxx::__ops::_Iter_equals_val<char32_t const>::_Iter_equals_val(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZN9__gnu_cxx5__ops16_Iter_equals_valIKDiEclIPS2_EEbT_ at 0x15fd6
================================================================================

bool __fastcall __gnu_cxx::__ops::_Iter_equals_val<char32_t const>::operator()<char32_t const*>(
        _DWORD **a1,
        _DWORD *a2)
{
  return *a2 == **a1;
}



================================================================================
Function: _ZNSt4spanIcLm18446744073709551615EEC2ILm256EEERAT__c at 0x15ffc
================================================================================

_QWORD *__fastcall std::span<char,18446744073709551615ul>::span<256ul>(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h]

  *a1 = a2;
  v3 = std::integral_constant<unsigned long,256ul>::operator unsigned long(&std::span<char,18446744073709551615ul>::__v<256ul>);
  result = a1 + 1;
  a1[1] = v3;
  return result;
}



================================================================================
Function: _ZNSt8__format5_SinkIcE10_M_reserveEm at 0x1604e
================================================================================

__int64 __fastcall std::__format::_Sink<char>::_M_reserve(__int64 a1, unsigned __int64 a2)
{
  __int64 v2; // rdx
  __int64 v3; // rdx
  __int64 v5; // rdx
  __int64 v6; // rdx
  _QWORD v7[2]; // [rsp+10h] [rbp-80h] BYREF
  _QWORD v8[2]; // [rsp+20h] [rbp-70h] BYREF
  __int64 v9; // [rsp+30h] [rbp-60h] BYREF
  _QWORD v10[4]; // [rsp+38h] [rbp-58h] BYREF
  __int64 v11; // [rsp+58h] [rbp-38h]
  __int64 *v12; // [rsp+60h] [rbp-30h]
  __int64 v13; // [rsp+68h] [rbp-28h]
  __int64 v14; // [rsp+70h] [rbp-20h]
  __int64 v15; // [rsp+78h] [rbp-18h]

  v15 = a1;
  v9 = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v14 = a1 + 24;
  v13 = a1 + 24;
  v2 = *(_QWORD *)(a1 + 24);
  v12 = &v9;
  v7[0] = std::span<char,18446744073709551615ul>::subspan(a1 + 8, v2 - v9, -1);
  v7[1] = v3;
  if ( std::span<char,18446744073709551615ul>::size((__int64)v7) >= a2 )
    return a1;
  if ( std::span<char,18446744073709551615ul>::size(a1 + 8) < a2 )
    return 0;
  (**(void (__fastcall ***)(__int64))a1)(a1);
  v11 = a1;
  v10[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v10[3] = v11 + 24;
  v10[2] = v11 + 24;
  v5 = *(_QWORD *)(v11 + 24);
  v10[1] = v10;
  v8[0] = std::span<char,18446744073709551615ul>::subspan(a1 + 8, v5 - v10[0], -1);
  v8[1] = v6;
  if ( std::span<char,18446744073709551615ul>::size((__int64)v8) < a2 )
    return 0;
  return a1;
}



================================================================================
Function: _ZNKSt8__format5_SinkIcE12_ReservationcvbEv at 0x161e2
================================================================================

bool __fastcall std::__format::_Sink<char>::_Reservation::operator bool(_QWORD *a1)
{
  return *a1 != 0;
}



================================================================================
Function: _ZNKSt8__format5_SinkIcE12_Reservation3getEv at 0x161fe
================================================================================

__int64 __fastcall std::__format::_Sink<char>::_Reservation::get(__int64 a1)
{
  return *(_QWORD *)(*(_QWORD *)a1 + 24LL);
}



================================================================================
Function: _ZNSt8__format5_SinkIcE12_Reservation7_M_bumpEm at 0x16222
================================================================================

__int64 __fastcall std::__format::_Sink<char>::_Reservation::_M_bump(_QWORD *a1, __int64 a2)
{
  return (*(__int64 (__fastcall **)(_QWORD, __int64))(*(_QWORD *)*a1 + 16LL))(*a1, a2);
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcEC2ESt17basic_format_argsIS3_ES2_ at 0x1625e
================================================================================

__int64 __fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::basic_format_context(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 result; // rax

  *(_QWORD *)a1 = a2;
  *(_QWORD *)(a1 + 8) = a3;
  *(_QWORD *)(a1 + 16) = a4;
  *(_BYTE *)(a1 + 24) = 0;
  result = a1 + 24;
  *(_BYTE *)(a1 + 32) = 0;
  return result;
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcEC2ESt17basic_format_argsIS3_ES2_RKSt6locale at 0x162c8
================================================================================

std::__format::_Optional_locale *__fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::basic_format_context(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        const std::locale *a5)
{
  *a1 = a2;
  a1[1] = a3;
  a1[2] = a4;
  return std::__format::_Optional_locale::_Optional_locale((std::__format::_Optional_locale *)(a1 + 3), a5);
}



================================================================================
Function: _ZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcEC2ERSt20basic_format_contextIS2_cESt17basic_string_viewIcSt11char_traitsIcEE at 0x16336
================================================================================

_QWORD *__fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_Formatting_scanner(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  _QWORD *result; // rax

  std::__format::_Scanner<char>::_Scanner(a1, a3, a4, -1, a5, a6);
  *a1 = off_37770;
  result = a1;
  a1[7] = a2;
  return result;
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcE3outEv at 0x1638a
================================================================================

__int64 __fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(__int64 a1)
{
  return *(_QWORD *)(a1 + 16);
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE5beginEv at 0x163ac
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::begin(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE5firstEm at 0x163d2
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::first(__int64 a1, unsigned __int64 a2)
{
  __int64 v2; // rax
  __int64 v4; // [rsp+10h] [rbp-10h] BYREF

  if ( std::span<char,18446744073709551615ul>::size(a1) < a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/span",
      386,
      "constexpr std::span<_Type, 18446744073709551615> std::span<_Type, _Extent>::first(size_type) const [with _Type = c"
      "har; long unsigned int _Extent = 18446744073709551615; size_type = long unsigned int]",
      "__count <= size()");
  v2 = std::span<char,18446744073709551615ul>::data(a1);
  std::span<char,18446744073709551615ul>::span<char *>(&v4, v2, a2);
  return v4;
}



================================================================================
Function: _ZNSt8__format10_Arg_storeISt20basic_format_contextINS_10_Sink_iterIcEEcEJPKcS6_S6_EE11_S_make_eltIPcEENS_10_Arg_valueIS4_EERT_ at 0x16454
================================================================================

__int64 __fastcall std::__format::_Arg_store<std::basic_format_context<std::__format::_Sink_iter<char>,char>,char const*,char const*,char const*>::_S_make_elt<char *>(
        __int64 a1)
{
  __int64 v2; // [rsp+20h] [rbp-30h] BYREF

  std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::basic_format_arg<char *>(
    &v2,
    a1);
  return v2;
}



================================================================================
Function: _ZNSt8__detail25__from_chars_alnum_to_valILb1EEEhh at 0x16491
================================================================================

__int64 __fastcall std::__detail::__from_chars_alnum_to_val<true>(unsigned __int8 a1)
{
  return (unsigned int)a1 - 48;
}



================================================================================
Function: _ZNSt8__detail18__from_chars_alnumILb1EtEEbRPKcS2_RT0_i at 0x164a7
================================================================================

__int64 __fastcall std::__detail::__from_chars_alnum<true,unsigned short>(
        unsigned __int8 **a1,
        unsigned __int8 *a2,
        _WORD *a3,
        int a4)
{
  unsigned __int8 v8; // [rsp+27h] [rbp-9h]
  int v9; // [rsp+28h] [rbp-8h]
  int v10; // [rsp+2Ch] [rbp-4h]

  v9 = std::__bit_width<unsigned int>(a4 & 0x3F);
  v10 = 16;
  while ( 1 )
  {
    if ( a2 == *a1 )
      return 1;
    v8 = std::__detail::__from_chars_alnum_to_val<true>(**a1);
    if ( a4 <= v8 )
      return 1;
    v10 -= v9;
    if ( v10 >= 0 )
    {
      *a3 = v8 + *a3 * a4;
      goto LABEL_13;
    }
    if ( (unsigned __int8)std::__detail::__raise_and_add<unsigned short>(a3, (unsigned int)a4, v8) != 1 )
      break;
LABEL_13:
    ++*a1;
  }
  while ( a2 != ++*a1 && a4 > (unsigned __int8)std::__detail::__from_chars_alnum_to_val<true>(**a1) )
    ;
  return 0;
}



================================================================================
Function: _ZNSt4pairItPKcEC2IRtRS1_EEOT_OT0_ at 0x165ca
================================================================================

__int64 __fastcall std::pair<unsigned short,char const*>::pair<unsigned short &,char const*&>(
        __int64 a1,
        _WORD *a2,
        _QWORD *a3)
{
  __int64 result; // rax

  *(_WORD *)a1 = *a2;
  result = a1;
  *(_QWORD *)(a1 + 8) = *a3;
  return result;
}



================================================================================
Function: _ZNKSt6ranges8subrangeIPKcS2_LNS_13subrange_kindE1EE5beginEvQ8copyableIT_E at 0x1660e
================================================================================

__int64 __fastcall std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::begin(__int64 a1)
{
  return *(_QWORD *)a1;
}



================================================================================
Function: _ZNKSt6ranges8subrangeIPKcS2_LNS_13subrange_kindE1EE3endEv at 0x16624
================================================================================

__int64 __fastcall std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::end(__int64 a1)
{
  return *(_QWORD *)(a1 + 8);
}



================================================================================
Function: _ZNSt6ranges8subrangeIPKcS2_LNS_13subrange_kindE1EEC2IS2_EET_S2_QntL_ZNS0_IS6_T0_XT1_EE13_S_store_sizeEE at 0x1663a
================================================================================

_QWORD *__fastcall std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>::subrange<char const*>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3)
{
  *a1 = a2;
  a1[1] = a3;
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiNSt6ranges8subrangeIPKcS4_LNS1_13subrange_kindE1EEEEC2EOS6_ at 0x1667c
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::ranges::subrange<char const*,char const*,(std::ranges::subrange_kind)1>>::_Utf_view(
        __int64 *a1,
        __int64 *a2)
{
  __int64 v2; // rdx
  __int64 result; // rax

  v2 = a2[1];
  result = *a2;
  *a1 = *a2;
  a1[1] = v2;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEC2ES2_S2_S2_Q22bidirectional_iteratorIT1_E at 0x166ae
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Utf_iterator(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 result; // rax

  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_First_and_curr<char const*>::_First_and_curr(
    a1 + 8,
    a2,
    a3);
  *(_BYTE *)(a1 + 24) = 0;
  *(_BYTE *)(a1 + 25) = 0;
  *(_BYTE *)(a1 + 26) = 0;
  *(_QWORD *)(a1 + 32) = a4;
  if ( *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1) != *(_QWORD *)(a1 + 32) )
    return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read(a1);
  result = a1;
  *(_DWORD *)a1 = 0;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEppEi at 0x16746
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++(
        _QWORD *a1,
        _QWORD *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rbx

  v2 = a2[1];
  *a1 = *a2;
  a1[1] = v2;
  v3 = a2[3];
  a1[2] = a2[2];
  a1[3] = v3;
  a1[4] = a2[4];
  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++(a2);
  return a1;
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEdeEv at 0x167a4
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*(
        __int64 a1)
{
  return *(unsigned int *)std::array<char32_t,1ul>::operator[](a1, *(unsigned __int8 *)(a1 + 24));
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE4baseEvQ16forward_iteratorIT1_E at 0x167d2
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base(
        __int64 a1)
{
  return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
}



================================================================================
Function: _ZNSt8__format5_SpecIcE8_S_alignEc at 0x167f0
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_S_align(char a1)
{
  if ( a1 == 94 )
    return 3;
  if ( a1 > 94 )
    return 0;
  if ( a1 == 60 )
    return 1;
  if ( a1 == 62 )
    return 2;
  else
    return 0;
}



================================================================================
Function: _ZSt13__countl_zeroImEiT_ at 0x16833
================================================================================

unsigned __int64 __fastcall std::__countl_zero<unsigned long>(unsigned __int64 a1)
{
  unsigned __int64 v1; // rax

  if ( !a1 )
    return 64;
  _BitScanReverse64(&v1, a1);
  return v1 ^ 0x3F;
}



================================================================================
Function: _ZNSt19__ptr_traits_ptr_toIPKSt4byteS1_Lb0EE10pointer_toERS1_ at 0x16860
================================================================================

__int64 __fastcall std::__ptr_traits_ptr_to<std::byte const*,std::byte const,false>::pointer_to(__int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeISB_E at 0x16884
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_destroy_node(
        __int64 a1,
        __int64 a2)
{
  __int64 v3; // [rsp+18h] [rbp-18h]

  v3 = std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_valptr(a2);
  std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_get_Node_allocator(a1);
  return std::destroy_at<std::pair<std::string const,pqxx::notification_receiver *>>(v3);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE11_M_put_nodeEPSt13_Rb_tree_nodeISB_E at 0x168d0
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_put_node(
        __int64 a1,
        __int64 a2)
{
  __int64 Node_allocator; // [rsp+20h] [rbp-20h]

  Node_allocator = std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_get_Node_allocator(a1);
  return std::__new_allocator<std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>>::deallocate(
           Node_allocator,
           a2,
           1);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE15_M_destroy_nodeEPSt13_Rb_tree_nodeISD_E at 0x1694e
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_destroy_node(
        __int64 a1,
        __int64 a2)
{
  __int64 v3; // [rsp+18h] [rbp-18h]

  v3 = std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_valptr(a2);
  std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_get_Node_allocator(a1);
  return std::destroy_at<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>(v3);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE11_M_put_nodeEPSt13_Rb_tree_nodeISD_E at 0x1699a
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_put_node(
        __int64 a1,
        __int64 a2)
{
  __int64 Node_allocator; // [rsp+20h] [rbp-20h]

  Node_allocator = std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_get_Node_allocator(a1);
  return std::__new_allocator<std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::deallocate(
           Node_allocator,
           a2,
           1);
}



================================================================================
Function: _ZSt10destroy_atIPKcEvPT_ at 0x16a18
================================================================================

void std::destroy_at<char const*>()
{
  ;
}



================================================================================
Function: _ZSt10destroy_atIiEvPT_ at 0x16a27
================================================================================

void std::destroy_at<int>()
{
  ;
}



================================================================================
Function: _ZSt10destroy_atIN4pqxx6formatEEvPT_ at 0x16a36
================================================================================

void std::destroy_at<pqxx::format>()
{
  ;
}



================================================================================
Function: _ZSt8_DestroyISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEEEvPT_ at 0x16a45
================================================================================

__int64 __fastcall std::_Destroy<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>(
        __int64 a1)
{
  return std::destroy_at<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>(a1);
}



================================================================================
Function: _ZSt9__advanceIPKDilEvRT_T0_St26random_access_iterator_tag at 0x16a64
================================================================================

_QWORD *__fastcall std::__advance<char32_t const*,long>(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 += 4 * a2;
  return result;
}



================================================================================
Function: _ZSt9__advanceIPKjlEvRT_T0_St26random_access_iterator_tag at 0x16a90
================================================================================

_QWORD *__fastcall std::__advance<unsigned int const*,long>(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 += 4 * a2;
  return result;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEE13remove_suffixEm at 0x16abc
================================================================================

unsigned __int64 *__fastcall std::string_view::remove_suffix(unsigned __int64 *a1, unsigned __int64 a2)
{
  unsigned __int64 *result; // rax

  if ( *a1 < a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/string_view",
      309,
      "constexpr void std::basic_string_view<_CharT, _Traits>::remove_suffix(size_type) [with _CharT = char; _Traits = st"
      "d::char_traits<char>; size_type = long unsigned int]",
      "this->_M_len >= __n");
  result = a1;
  *a1 -= a2;
  return result;
}



================================================================================
Function: _ZNKSt17integral_constantImLm256EEcvmEv at 0x16b20
================================================================================

__int64 std::integral_constant<unsigned long,256ul>::operator unsigned long()
{
  return 256;
}



================================================================================
Function: _ZNKSt17basic_format_argsISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE7_M_typeEm at 0x16b34
================================================================================

__int64 __fastcall std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_type(
        _QWORD *a1,
        char a2)
{
  return (*a1 >> 4 >> (5 * a2)) & 0x1FLL;
}



================================================================================
Function: _ZNSt8__format5_SinkIcE7_M_bumpEm at 0x16b76
================================================================================

__int64 __fastcall std::__format::_Sink<char>::_M_bump(__int64 a1, __int64 a2)
{
  __int64 result; // rax

  result = a1 + 24;
  *(_QWORD *)(a1 + 24) += a2;
  return result;
}



================================================================================
Function: _ZNSt4spanIcLm18446744073709551615EEC2IPcEET_m at 0x16bb2
================================================================================

_QWORD *__fastcall std::span<char,18446744073709551615ul>::span<char *>(_QWORD *a1, __int64 a2, __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a2;
  result = a1 + 1;
  a1[1] = a3;
  return result;
}



================================================================================
Function: _ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEEC2IPcEERT_ at 0x16bfc
================================================================================

__int64 __fastcall std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::basic_format_arg<char *>(
        __int64 a1,
        _QWORD *a2)
{
  return std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_set<char const*>(
           a1,
           *a2);
}



================================================================================
Function: _ZNSt8__detail15__raise_and_addItEEbRT_ih at 0x16c32
================================================================================

_BOOL8 __fastcall std::__detail::__raise_and_add<unsigned short>(unsigned __int16 *a1, int a2, unsigned __int8 a3)
{
  unsigned __int64 v3; // rax
  bool v4; // cl
  bool v5; // al

  v3 = a2 * (unsigned __int64)*a1;
  *a1 = v3;
  v5 = 1;
  if ( v3 == (unsigned __int16)v3 )
  {
    v4 = __CFADD__(*a1, a3);
    *a1 += a3;
    if ( !v4 )
      v5 = 0;
  }
  return !v5;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE15_First_and_currIS2_EC2ES2_S2_ at 0x16cc8
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_First_and_curr<char const*>::_First_and_curr(
        _QWORD *a1,
        __int64 a2,
        __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a2;
  result = a1;
  a1[1] = a3;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE7_M_currEv at 0x16cf6
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(
        __int64 a1)
{
  return a1 + 16;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE7_M_readEv at 0x16d0c
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read(
        __int64 a1)
{
  return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(a1);
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEppEv at 0x16d2c
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++(
        __int64 a1)
{
  __int64 v3; // [rsp+10h] [rbp-30h]
  __int64 v4; // [rsp+18h] [rbp-28h]

  if ( *(unsigned __int8 *)(a1 + 24) + 1 == *(unsigned __int8 *)(a1 + 25)
    && *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1) != *(_QWORD *)(a1 + 32) )
  {
    v4 = *(unsigned __int8 *)(a1 + 26);
    v3 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
    std::__advance<char const*,long>(v3, v4);
    if ( *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1) == *(_QWORD *)(a1 + 32) )
      *(_BYTE *)(a1 + 24) = 0;
    else
      std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read(a1);
  }
  else if ( *(unsigned __int8 *)(a1 + 24) + 1 < *(unsigned __int8 *)(a1 + 25) )
  {
    ++*(_BYTE *)(a1 + 24);
  }
  return a1;
}



================================================================================
Function: _ZNKSt5arrayIDiLm1EEixEm at 0x16e3c
================================================================================

__int64 __fastcall std::array<char32_t,1ul>::operator[](__int64 a1, __int64 a2)
{
  if ( a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/array",
      219,
      "constexpr const std::array<_Tp, _Nm>::value_type& std::array<_Tp, _Nm>::operator[](size_type) const [with _Tp = ch"
      "ar32_t; long unsigned int _Nm = 1; const_reference = const char32_t&; size_type = long unsigned int]",
      "__n < this->size()");
  return 4 * a2 + a1;
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE7_M_currEv at 0x16ea4
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(
        __int64 a1)
{
  return *(_QWORD *)(a1 + 16);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_PN4pqxx21notification_receiverEESt10_Select1stISB_ESt4lessIS5_ESaISB_EE21_M_get_Node_allocatorEv at 0x16eba
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,pqxx::notification_receiver *>,std::_Select1st<std::pair<std::string const,pqxx::notification_receiver *>>,std::less<std::string>,std::allocator<std::pair<std::string const,pqxx::notification_receiver *>>>::_M_get_Node_allocator(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEE9_M_valptrEv at 0x16ecc
================================================================================

__int64 __fastcall std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>::_M_valptr(
        __int64 a1)
{
  return __gnu_cxx::__aligned_membuf<std::pair<std::string const,pqxx::notification_receiver *>>::_M_ptr(a1 + 32);
}



================================================================================
Function: _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_St8functionIFvN4pqxx12notificationEEEESt10_Select1stISD_ESt4lessIS5_ESaISD_EE21_M_get_Node_allocatorEv at 0x16eee
================================================================================

__int64 __fastcall std::_Rb_tree<std::string,std::pair<std::string const,std::function<void ()(pqxx::notification)>>,std::_Select1st<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::_M_get_Node_allocator(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEE9_M_valptrEv at 0x16f00
================================================================================

__int64 __fastcall std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_valptr(
        __int64 a1)
{
  return __gnu_cxx::__aligned_membuf<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_ptr(a1 + 32);
}



================================================================================
Function: _ZNSt15__new_allocatorISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEEE10deallocateEPSF_m at 0x16f22
================================================================================

void __fastcall std::__new_allocator<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>::deallocate(
        __int64 a1,
        void *a2,
        __int64 a3)
{
  operator delete(a2, 40 * a3);
}



================================================================================
Function: _ZNSt8__detail9__variant15_Copy_ctor_baseILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x16f60
================================================================================

__int64 __fastcall std::__detail::__variant::_Copy_ctor_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Copy_ctor_base(
        __int64 a1)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variant_storage(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant15_Move_ctor_baseILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x16f80
================================================================================

__int64 __fastcall std::__detail::__variant::_Move_ctor_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Move_ctor_base(
        __int64 a1)
{
  return std::__detail::__variant::_Copy_ctor_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Copy_ctor_base(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant17_Copy_assign_baseILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x16fa0
================================================================================

__int64 __fastcall std::__detail::__variant::_Copy_assign_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Copy_assign_base(
        __int64 a1)
{
  return std::__detail::__variant::_Move_ctor_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Move_ctor_base(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant17_Move_assign_baseILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x16fc0
================================================================================

__int64 __fastcall std::__detail::__variant::_Move_assign_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Move_assign_base(
        __int64 a1)
{
  return std::__detail::__variant::_Copy_assign_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Copy_assign_base(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant13_Variant_baseIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x16fe0
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_base<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variant_base(
        __int64 a1)
{
  return std::__detail::__variant::_Move_assign_base<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Move_assign_base(a1);
}



================================================================================
Function: _ZNSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS4_IS9_EENS3_IS9_SA_SaIS9_EEEEED2Ev at 0x17000
================================================================================

__int64 __fastcall std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~variant(
        __int64 a1)
{
  return std::__detail::__variant::_Variant_base<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variant_base(a1);
}



================================================================================
Function: _ZSt10destroy_atISt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS5_ISA_EENS4_ISA_SB_SaISA_EEEEEEvPT_ at 0x1701f
================================================================================

__int64 __fastcall std::destroy_at<std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>>(
        __int64 a1)
{
  return std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~variant(a1);
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE7subspanEmm at 0x1703e
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::subspan(
        __int64 a1,
        unsigned __int64 a2,
        unsigned __int64 a3)
{
  __int64 v3; // rax
  __int64 v6; // [rsp+20h] [rbp-20h] BYREF

  if ( std::span<char,18446744073709551615ul>::size(a1) < a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/span",
      450,
      "constexpr std::span<_Type, 18446744073709551615> std::span<_Type, _Extent>::subspan(size_type, size_type) const [w"
      "ith _Type = char; long unsigned int _Extent = 18446744073709551615; size_type = long unsigned int]",
      "__offset <= size()");
  if ( a3 == -1 )
  {
    a3 = std::span<char,18446744073709551615ul>::size(a1) - a2;
  }
  else
  {
    if ( std::span<char,18446744073709551615ul>::size(a1) < a3 )
      std::__glibcxx_assert_fail(
        "/usr/include/c++/15/span",
        455,
        "constexpr std::span<_Type, 18446744073709551615> std::span<_Type, _Extent>::subspan(size_type, size_type) const "
        "[with _Type = char; long unsigned int _Extent = 18446744073709551615; size_type = long unsigned int]",
        "__count <= size()");
    if ( std::span<char,18446744073709551615ul>::size(a1) < a2 + a3 )
      std::__glibcxx_assert_fail(
        "/usr/include/c++/15/span",
        456,
        "constexpr std::span<_Type, 18446744073709551615> std::span<_Type, _Extent>::subspan(size_type, size_type) const "
        "[with _Type = char; long unsigned int _Extent = 18446744073709551615; size_type = long unsigned int]",
        "__offset + __count <= size()");
  }
  v3 = std::span<char,18446744073709551615ul>::data(a1);
  std::span<char,18446744073709551615ul>::span<char *>(&v6, v3 + a2, a3);
  return v6;
}



================================================================================
Function: _ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE6_M_setIPKcEEvT_ at 0x1717e
================================================================================

__int64 __fastcall std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_set<char const*>(
        __int64 a1,
        __int64 a2)
{
  __int64 result; // rax

  *(_BYTE *)(a1 + 16) = 10;
  result = a1;
  *(_QWORD *)a1 = a2;
  return result;
}



================================================================================
Function: _ZZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE12_M_read_utf8EvENKUlvE_clEv at 0x171be
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(void)::{lambda(void)#1}::operator()(
        __int64 a1)
{
  _QWORD *v1; // rax

  ++**(_BYTE **)(a1 + 8);
  v1 = (_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(*(_QWORD *)a1);
  return ++*v1;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE12_M_read_utf8Ev at 0x171fc
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(
        __int64 a1)
{
  _QWORD *v1; // rax
  char *v2; // rdx
  _QWORD v4[3]; // [rsp+10h] [rbp-40h] BYREF
  unsigned __int8 v5; // [rsp+2Fh] [rbp-21h] BYREF
  _QWORD v6[2]; // [rsp+30h] [rbp-20h] BYREF
  char v7; // [rsp+45h] [rbp-Bh]
  char v8; // [rsp+46h] [rbp-Ah]
  char v9; // [rsp+47h] [rbp-9h]
  unsigned __int8 v10; // [rsp+48h] [rbp-8h]
  unsigned __int8 v11; // [rsp+49h] [rbp-7h]
  unsigned __int8 v12; // [rsp+4Ah] [rbp-6h]
  unsigned __int8 v13; // [rsp+4Bh] [rbp-5h]
  unsigned int v14; // [rsp+4Ch] [rbp-4h]

  v6[0] = a1;
  v6[1] = *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
  v14 = 0;
  v9 = 0x80;
  v8 = -65;
  v1 = (_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
  v2 = (char *)(*v1)++;
  v7 = *v2;
  v5 = 1;
  v4[0] = a1;
  v4[1] = &v5;
  if ( v7 < 0 )
  {
    if ( (unsigned __int8)v7 > 0xC1u
      && *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1) != *(_QWORD *)(a1 + 32) )
    {
      if ( (unsigned __int8)v7 > 0xDFu )
      {
        if ( (unsigned __int8)v7 > 0xEFu )
        {
          if ( (unsigned __int8)v7 > 0xF4u )
            goto LABEL_39;
          v11 = v7 == -16 ? -112 : 0x80;
          v10 = v7 == -12 ? -113 : -65;
          v14 = v7 & 7;
          v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
          if ( (unsigned __int8)v7 < v11 || v10 < (unsigned __int8)v7 )
            goto LABEL_39;
          if ( std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(void)::{lambda(void)#1}::operator()((__int64)v4) != *(_QWORD *)(a1 + 32) )
          {
            v14 = (v14 << 6) | v7 & 0x3F;
            v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
            if ( v7 < -64
              && std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(void)::{lambda(void)#1}::operator()((__int64)v4) != *(_QWORD *)(a1 + 32) )
            {
              v14 = (v14 << 6) | v7 & 0x3F;
              v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
              if ( v7 < -64 )
                goto LABEL_38;
            }
          }
        }
        else
        {
          if ( v7 == -32 )
            v13 = -96;
          else
            v13 = 0x80;
          if ( v7 == -19 )
            v12 = -97;
          else
            v12 = -65;
          v14 = v7 & 0xF;
          v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
          if ( (unsigned __int8)v7 < v13 || v12 < (unsigned __int8)v7 )
            goto LABEL_39;
          if ( std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(void)::{lambda(void)#1}::operator()((__int64)v4) != *(_QWORD *)(a1 + 32) )
          {
            v14 = (v14 << 6) | v7 & 0x3F;
            v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
            if ( v7 < -64 )
              goto LABEL_38;
          }
        }
        v14 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_S_error(a1);
        goto LABEL_40;
      }
      v14 = v7 & 0x1F;
      v7 = **(_BYTE **)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(a1);
      if ( v7 < -64 )
      {
LABEL_38:
        v14 = (v14 << 6) | v7 & 0x3F;
        std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_read_utf8(void)::{lambda(void)#1}::operator()((__int64)v4);
        goto LABEL_40;
      }
    }
LABEL_39:
    v14 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_S_error(a1);
    goto LABEL_40;
  }
  v14 = (unsigned __int8)v7;
LABEL_40:
  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_update(a1, v14, v5);
  return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Guard<char const*>::~_Guard(v6);
}



================================================================================
Function: _ZNSt15__new_allocatorISt4byteE10deallocateEPS0_m at 0x1760a
================================================================================

void __fastcall std::__new_allocator<std::byte>::deallocate(__int64 a1, void *a2, unsigned __int64 a3)
{
  operator delete(a2, a3);
}



================================================================================
Function: _ZN9__gnu_cxx16__aligned_membufISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEE6_M_ptrEv at 0x17638
================================================================================

__int64 __fastcall __gnu_cxx::__aligned_membuf<std::pair<std::string const,pqxx::notification_receiver *>>::_M_ptr(
        __int64 a1)
{
  return __gnu_cxx::__aligned_membuf<std::pair<std::string const,pqxx::notification_receiver *>>::_M_addr(a1);
}



================================================================================
Function: _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEED2Ev at 0x17656
================================================================================

void __fastcall std::pair<std::string const,pqxx::notification_receiver *>::~pair(__int64 a1)
{
  std::string::~string(a1);
}



================================================================================
Function: _ZSt10destroy_atISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEEvPT_ at 0x17675
================================================================================

void __fastcall std::destroy_at<std::pair<std::string const,pqxx::notification_receiver *>>(__int64 a1)
{
  std::pair<std::string const,pqxx::notification_receiver *>::~pair(a1);
}



================================================================================
Function: _ZN9__gnu_cxx16__aligned_membufISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEE6_M_ptrEv at 0x17694
================================================================================

__int64 __fastcall __gnu_cxx::__aligned_membuf<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_ptr(
        __int64 a1)
{
  return __gnu_cxx::__aligned_membuf<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_addr(a1);
}



================================================================================
Function: _ZNSt8functionIFvN4pqxx12notificationEEED2Ev at 0x176b2
================================================================================

void __fastcall std::function<void ()(pqxx::notification)>::~function(std::_Function_base *a1)
{
  std::_Function_base::~_Function_base(a1);
}



================================================================================
Function: _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEED2Ev at 0x176d2
================================================================================

void __fastcall std::pair<std::string const,std::function<void ()(pqxx::notification)>>::~pair(__int64 a1)
{
  std::function<void ()(pqxx::notification)>::~function((std::_Function_base *)(a1 + 32));
  std::string::~string(a1);
}



================================================================================
Function: _ZSt10destroy_atISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEEvPT_ at 0x17701
================================================================================

void __fastcall std::destroy_at<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>(__int64 a1)
{
  std::pair<std::string const,std::function<void ()(pqxx::notification)>>::~pair(a1);
}



================================================================================
Function: _ZNSt15__new_allocatorIPKcE10deallocateEPS1_m at 0x17720
================================================================================

void __fastcall std::__new_allocator<char const*>::deallocate(__int64 a1, void *a2, __int64 a3)
{
  operator delete(a2, 8 * a3);
}



================================================================================
Function: _ZNSt15__new_allocatorIiE10deallocateEPim at 0x17756
================================================================================

void __fastcall std::__new_allocator<int>::deallocate(__int64 a1, void *a2, __int64 a3)
{
  operator delete(a2, 4 * a3);
}



================================================================================
Function: _ZNSt15__new_allocatorIN4pqxx6formatEE10deallocateEPS1_m at 0x1778c
================================================================================

void __fastcall std::__new_allocator<pqxx::format>::deallocate(__int64 a1, void *a2, __int64 a3)
{
  operator delete(a2, 4 * a3);
}



================================================================================
Function: _ZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2Ev at 0x177c2
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variant_storage(
        __int64 a1)
{
  std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(a1);
  return std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variadic_union(a1);
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE6_GuardIS2_ED2Ev at 0x177ee
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Guard<char const*>::~_Guard(
        __int64 *a1)
{
  __int64 v1; // rbx
  _QWORD *result; // rax

  v1 = a1[1];
  result = (_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr(*a1);
  *result = v1;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE8_S_errorEv at 0x1782c
================================================================================

__int64 std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_S_error()
{
  char v1; // [rsp+1Bh] [rbp-5h] BYREF
  std::__unicode *var4; // [rsp+1Ch] [rbp-4h]

  LODWORD(var4) = std::__unicode::_Repl::operator()(&v1);
  if ( !std::__unicode::__is_scalar_value((std::__unicode *)(unsigned int)var4) )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/bits/unicode.h",
      476,
      "constexpr char32_t std::__unicode::_Utf_iterator<_FromFmt, _ToFmt, _Iter, _Sent, _ErrorHandler>::_S_error() [with "
      "_FromFmt = char; _ToFmt = char32_t; _Iter = const char*; _Sent = const char*; _ErrorHandler = std::__unicode::_Repl]",
      "__is_scalar_value(__c)");
  return (unsigned int)var4;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE9_M_updateEDih at 0x1788c
================================================================================

_BYTE *__fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_update(
        _BYTE *a1,
        int a2,
        char a3)
{
  _BYTE *result; // rax

  a1[26] = a3;
  a1[24] = 0;
  *(_DWORD *)std::array<char32_t,1ul>::operator[](a1, 0) = a2;
  result = a1;
  a1[25] = 1;
  return result;
}



================================================================================
Function: _ZSt9__advanceIPKclEvRT_T0_St26random_access_iterator_tag at 0x178dd
================================================================================

_QWORD *__fastcall std::__advance<char const*,long>(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 += a2;
  return result;
}



================================================================================
Function: _ZN9__gnu_cxx16__aligned_membufISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEE7_M_addrEv at 0x17906
================================================================================

__int64 __fastcall __gnu_cxx::__aligned_membuf<std::pair<std::string const,pqxx::notification_receiver *>>::_M_addr(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt15__new_allocatorISt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPN4pqxx21notification_receiverEEEE10deallocateEPSD_m at 0x17918
================================================================================

void __fastcall std::__new_allocator<std::_Rb_tree_node<std::pair<std::string const,pqxx::notification_receiver *>>>::deallocate(
        __int64 a1,
        void *a2,
        __int64 a3)
{
  operator delete(a2, 72 * a3);
}



================================================================================
Function: _ZN9__gnu_cxx16__aligned_membufISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEE7_M_addrEv at 0x17956
================================================================================

__int64 __fastcall __gnu_cxx::__aligned_membuf<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>::_M_addr(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt15__new_allocatorISt13_Rb_tree_nodeISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt8functionIFvN4pqxx12notificationEEEEEE10deallocateEPSF_m at 0x17968
================================================================================

void __fastcall std::__new_allocator<std::_Rb_tree_node<std::pair<std::string const,std::function<void ()(pqxx::notification)>>>>::deallocate(
        __int64 a1,
        void *a2,
        __int64 a3)
{
  operator delete(a2, 96 * a3);
}



================================================================================
Function: _ZNSt8__detail9__variant15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEED2EvQntT_ at 0x179a6
================================================================================

void std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::~_Variadic_union()
{
  ;
}



================================================================================
Function: _ZSt14__variant_castIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS4_IS9_EENS3_IS9_SA_SaIS9_EEEERNSt8__detail9__variant16_Variant_storageILb0EJDnS1_S7_SB_SD_EEEEDcOT0_ at 0x179b5
================================================================================

__int64 __fastcall std::__variant_cast<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZZSt10__do_visitIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSt7variantIJDnS4_SA_SE_SG_EEEEDcOT0_DpOT1_ENKUlSN_zE_clESN_z at 0x179c8
================================================================================

__int64 __fastcall ZZSt10__do_visitIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSt7variantIJDnS4_SA_SE_SG_EEEEDcOT0_DpOT1_ENKUlSN_zE_clESN_z(
        __int64 a1,
        __int64 a2)
{
  return a2;
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm0ERNS0_15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEEODaOT0_ at 0x17a2b
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<0ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail9__variant5__getILm0ERSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEDcOT0_ at 0x17a45
================================================================================

__int64 __fastcall std::__detail::__variant::__get<0ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<0ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEvENUlOT_E_clIRDnEEDaSI_ at 0x17a6c
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<decltype(nullptr) &>(
        __int64 a1,
        __int64 a2)
{
  return std::_Destroy<decltype(nullptr)>(a2);
}



================================================================================
Function: _ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm0EEEE14__visit_invokeESM_SP_ at 0x17a97
================================================================================

__int64 __fastcall ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm0EEEE14__visit_invokeESM_SP_(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax

  v2 = std::__detail::__variant::__get<0ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a2);
  return std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},decltype(nullptr) &>(
           a1,
           v2);
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm1ERNS0_15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEEODaOT0_ at 0x17adc
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<1ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail9__variant5__getILm1ERSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEDcOT0_ at 0x17af6
================================================================================

__int64 __fastcall std::__detail::__variant::__get<1ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<1ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEvENUlOT_E_clIRS3_EEDaSI_ at 0x17b1c
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<pqxx::zview&>(
        __int64 a1,
        __int64 a2)
{
  return std::_Destroy<pqxx::zview>(a2);
}



================================================================================
Function: _ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm1EEEE14__visit_invokeESM_SP_ at 0x17b47
================================================================================

__int64 __fastcall ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm1EEEE14__visit_invokeESM_SP_(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax

  v2 = std::__detail::__variant::__get<1ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a2);
  return std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},pqxx::zview&>(
           a1,
           v2);
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm2ERNS0_15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEEODaOT0_ at 0x17b8c
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<2ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail9__variant5__getILm2ERSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEDcOT0_ at 0x17ba6
================================================================================

__int64 __fastcall std::__detail::__variant::__get<2ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<2ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEvENUlOT_E_clIRS9_EEDaSI_ at 0x17bcc
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::string&>(
        __int64 a1,
        __int64 a2)
{
  return std::_Destroy<std::string>(a2);
}



================================================================================
Function: _ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm2EEEE14__visit_invokeESM_SP_ at 0x17bf7
================================================================================

__int64 __fastcall ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm2EEEE14__visit_invokeESM_SP_(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax

  v2 = std::__detail::__variant::__get<2ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a2);
  return std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::string&>(
           a1,
           v2);
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm0ERNS0_15_Variadic_unionILb0EJSt17basic_string_viewISt4byteSt11char_traitsIS4_EENSt7__cxx1112basic_stringIS4_S6_SaIS4_EEEEEEEEODaOT0_ at 0x17c3c
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<0ul,std::__detail::__variant::_Variadic_union<false,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm3ERNS0_15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEEODaOT0_ at 0x17c56
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<3ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<0ul,std::__detail::__variant::_Variadic_union<false,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant5__getILm3ERSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEDcOT0_ at 0x17c7c
================================================================================

__int64 __fastcall std::__detail::__variant::__get<3ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<3ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEvENUlOT_E_clIRSD_EEDaSI_ at 0x17ca2
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::basic_string_view<std::byte>&>(
        __int64 a1,
        __int64 a2)
{
  return std::_Destroy<std::basic_string_view<std::byte>>(a2);
}



================================================================================
Function: _ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm3EEEE14__visit_invokeESM_SP_ at 0x17ccd
================================================================================

__int64 __fastcall ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm3EEEE14__visit_invokeESM_SP_(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax

  v2 = std::__detail::__variant::__get<3ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a2);
  return std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string_view<std::byte>&>(
           a1,
           v2);
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm1ERNS0_15_Variadic_unionILb0EJSt17basic_string_viewISt4byteSt11char_traitsIS4_EENSt7__cxx1112basic_stringIS4_S6_SaIS4_EEEEEEEEODaOT0_ at 0x17d12
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<1ul,std::__detail::__variant::_Variadic_union<false,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return a1;
}



================================================================================
Function: _ZNSt8__detail9__variant7__get_nILm4ERNS0_15_Variadic_unionILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEEODaOT0_ at 0x17d2c
================================================================================

__int64 __fastcall std::__detail::__variant::__get_n<4ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<1ul,std::__detail::__variant::_Variadic_union<false,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZNSt8__detail9__variant5__getILm4ERSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEEEEDcOT0_ at 0x17d52
================================================================================

__int64 __fastcall std::__detail::__variant::__get<4ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1)
{
  return std::__detail::__variant::__get_n<4ul,std::__detail::__variant::_Variadic_union<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
}



================================================================================
Function: _ZZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEvENUlOT_E_clIRSF_EEDaSI_ at 0x17d78
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::basic_string<std::byte>&>(
        __int64 a1,
        __int64 a2)
{
  return std::_Destroy<std::basic_string<std::byte>>(a2);
}



================================================================================
Function: _ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm4EEEE14__visit_invokeESM_SP_ at 0x17da3
================================================================================

__int64 __fastcall ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm4EEEE14__visit_invokeESM_SP_(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax

  v2 = std::__detail::__variant::__get<4ul,std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a2);
  return std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string<std::byte>&>(
           a1,
           v2);
}



================================================================================
Function: _ZSt10__do_visitIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSt7variantIJDnS4_SA_SE_SG_EEEEDcOT0_DpOT1_ at 0x17de8
================================================================================

unsigned __int64 __fastcall std::__do_visit<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
        __int64 a1,
        __int64 a2)
{
  unsigned __int64 result; // rax
  char v3; // [rsp+17h] [rbp-69h] BYREF
  __int64 v4; // [rsp+18h] [rbp-68h]
  __int64 v5; // [rsp+20h] [rbp-60h]
  __int64 v6; // [rsp+28h] [rbp-58h]
  __int64 v7; // [rsp+30h] [rbp-50h]
  __int64 v8; // [rsp+38h] [rbp-48h]
  __int64 v9; // [rsp+40h] [rbp-40h]
  __int64 v10; // [rsp+48h] [rbp-38h]
  __int64 v11; // [rsp+50h] [rbp-30h]
  __int64 v12; // [rsp+58h] [rbp-28h]
  __int64 v13; // [rsp+60h] [rbp-20h]
  __int64 v14; // [rsp+68h] [rbp-18h]
  __int64 v15; // [rsp+70h] [rbp-10h]
  __int64 v16; // [rsp+78h] [rbp-8h]

  v16 = 11;
  v15 = 5;
  v14 = ZZSt10__do_visitIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSt7variantIJDnS4_SA_SE_SG_EEEEDcOT0_DpOT1_ENKUlSN_zE_clESN_z(
          (__int64)&v3,
          a2);
  result = std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::index(v14);
  if ( result == 4 )
  {
    v4 = v14;
    v5 = a1;
    return ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm4EEEE14__visit_invokeESM_SP_(
             a1,
             v14);
  }
  else if ( result <= 4 )
  {
    if ( result == 3 )
    {
      v6 = v14;
      v7 = a1;
      return ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm3EEEE14__visit_invokeESM_SP_(
               a1,
               v14);
    }
    else if ( result == 2 )
    {
      v8 = v14;
      v9 = a1;
      return ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm2EEEE14__visit_invokeESM_SP_(
               a1,
               v14);
    }
    else if ( result )
    {
      v10 = v14;
      v11 = a1;
      return ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm1EEEE14__visit_invokeESM_SP_(
               a1,
               v14);
    }
    else
    {
      v12 = v14;
      v13 = a1;
      return ZNSt8__detail9__variant17__gen_vtable_implINS0_12_Multi_arrayIPFvOZNS0_16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS8_ISD_EENS7_ISD_SE_SaISD_EEEEE8_M_resetEvEUlOT_E_RSt7variantIJDnS5_SB_SF_SH_EEEJEEESt16integer_sequenceImJLm0EEEE14__visit_invokeESM_SP_(
               a1,
               v14);
    }
  }
  return result;
}



================================================================================
Function: _ZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_resetEv at 0x17f3a
================================================================================

__int64 __fastcall std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(
        __int64 a1)
{
  __int64 result; // rax
  __int64 v2; // rax
  char v3; // [rsp+1Fh] [rbp-1h] BYREF

  result = (unsigned int)std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_valid(a1)
         ^ 1;
  if ( !(_BYTE)result )
  {
    v2 = std::__variant_cast<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(a1);
    std::__do_visit<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>> &>(
      (__int64)&v3,
      v2);
    result = a1;
    *(_BYTE *)(a1 + 32) = -1;
  }
  return result;
}



================================================================================
Function: _ZNSt5arrayIDiLm1EEixEm at 0x17f88
================================================================================

__int64 __fastcall std::array<char32_t,1ul>::operator[](__int64 a1, __int64 a2)
{
  if ( a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/array",
      210,
      "constexpr std::array<_Tp, _Nm>::value_type& std::array<_Tp, _Nm>::operator[](size_type) [with _Tp = char32_t; long"
      " unsigned int _Nm = 1; reference = char32_t&; size_type = long unsigned int]",
      "__n < this->size()");
  return 4 * a2 + a1;
}



================================================================================
Function: _ZNKSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS6_ISB_EENS5_ISB_SC_SaISB_EEEEE8_M_validEv at 0x17ff0
================================================================================

__int64 std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_valid()
{
  return 1;
}



================================================================================
Function: _ZNKSt7variantIJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS4_IS9_EENS3_IS9_SA_SaIS9_EEEEE5indexEv at 0x18004
================================================================================

__int64 __fastcall std::variant<decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::index(
        __int64 a1)
{
  return *(unsigned __int8 *)(a1 + 32);
}



================================================================================
Function: _ZSt8_DestroyIDnEvPT_ at 0x1801d
================================================================================

__int64 __fastcall std::_Destroy<decltype(nullptr)>(__int64 a1)
{
  return std::destroy_at<decltype(nullptr)>(a1);
}



================================================================================
Function: _ZSt10__invoke_rIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRDnEENSt9enable_ifIX16is_invocable_r_vISI_T0_JDpT1_EEESI_E4typeEOSN_DpOSO_ at 0x1803c
================================================================================

__int64 __fastcall std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},decltype(nullptr) &>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},decltype(nullptr) &>(
           a1,
           a2,
           a2,
           a4,
           a5,
           a6,
           a2,
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZSt8_DestroyIN4pqxx5zviewEEvPT_ at 0x18076
================================================================================

__int64 __fastcall std::_Destroy<pqxx::zview>(__int64 a1)
{
  return std::destroy_at<pqxx::zview>(a1);
}



================================================================================
Function: _ZSt10__invoke_rIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRS4_EENSt9enable_ifIX16is_invocable_r_vISI_T0_JDpT1_EEESI_E4typeEOSN_DpOSO_ at 0x18095
================================================================================

__int64 __fastcall std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},pqxx::zview&>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},pqxx::zview&>(
           a1,
           a2,
           a2,
           a4,
           a5,
           a6,
           a2,
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZSt8_DestroyINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEvPT_ at 0x180cf
================================================================================

__int64 __fastcall std::_Destroy<std::string>(__int64 a1)
{
  return std::destroy_at<std::string>(a1);
}



================================================================================
Function: _ZSt10__invoke_rIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSA_EENSt9enable_ifIX16is_invocable_r_vISI_T0_JDpT1_EEESI_E4typeEOSN_DpOSO_ at 0x180ee
================================================================================

__int64 __fastcall std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::string&>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::string&>(
           a1,
           a2,
           a2,
           a4,
           a5,
           a6,
           a2,
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZSt8_DestroyISt17basic_string_viewISt4byteSt11char_traitsIS1_EEEvPT_ at 0x18128
================================================================================

__int64 __fastcall std::_Destroy<std::basic_string_view<std::byte>>(__int64 a1)
{
  return std::destroy_at<std::basic_string_view<std::byte>>(a1);
}



================================================================================
Function: _ZSt10__invoke_rIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSE_EENSt9enable_ifIX16is_invocable_r_vISI_T0_JDpT1_EEESI_E4typeEOSN_DpOSO_ at 0x18147
================================================================================

__int64 __fastcall std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string_view<std::byte>&>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string_view<std::byte>&>(
           a1,
           a2,
           a2,
           a4,
           a5,
           a6,
           a2,
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZSt8_DestroyINSt7__cxx1112basic_stringISt4byteSt11char_traitsIS2_ESaIS2_EEEEvPT_ at 0x18181
================================================================================

__int64 __fastcall std::_Destroy<std::basic_string<std::byte>>(__int64 a1)
{
  return std::destroy_at<std::basic_string<std::byte>>(a1);
}



================================================================================
Function: _ZSt10__invoke_rIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSG_EENSt9enable_ifIX16is_invocable_r_vISI_T0_JDpT1_EEESI_E4typeEOSN_DpOSO_ at 0x181a0
================================================================================

__int64 __fastcall std::__invoke_r<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string<std::byte>&>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string<std::byte>&>(
           a1,
           a2,
           a2,
           a4,
           a5,
           a6,
           a2,
           a1,
           a2,
           a1);
}



================================================================================
Function: _ZSt10destroy_atIDnEvPT_ at 0x181da
================================================================================

void std::destroy_at<decltype(nullptr)>()
{
  ;
}



================================================================================
Function: _ZSt13__invoke_implIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRDnEESI_St14__invoke_otherOT0_DpOT1_ at 0x181e9
================================================================================

__int64 __fastcall std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},decltype(nullptr) &>(
        __int64 a1,
        __int64 a2)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<decltype(nullptr) &>(
           a1,
           a2);
}



================================================================================
Function: _ZSt10destroy_atIN4pqxx5zviewEEvPT_ at 0x18223
================================================================================

void std::destroy_at<pqxx::zview>()
{
  ;
}



================================================================================
Function: _ZSt13__invoke_implIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRS4_EESI_St14__invoke_otherOT0_DpOT1_ at 0x18232
================================================================================

__int64 __fastcall std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},pqxx::zview&>(
        __int64 a1,
        __int64 a2)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<pqxx::zview&>(
           a1,
           a2);
}



================================================================================
Function: _ZSt10destroy_atINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEvPT_ at 0x1826c
================================================================================

void __fastcall std::destroy_at<std::string>(__int64 a1)
{
  std::string::~string(a1);
}



================================================================================
Function: _ZSt13__invoke_implIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSA_EESI_St14__invoke_otherOT0_DpOT1_ at 0x1828b
================================================================================

__int64 __fastcall std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::string&>(
        __int64 a1,
        __int64 a2)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::string&>(
           a1,
           a2);
}



================================================================================
Function: _ZSt10destroy_atISt17basic_string_viewISt4byteSt11char_traitsIS1_EEEvPT_ at 0x182c5
================================================================================

void std::destroy_at<std::basic_string_view<std::byte>>()
{
  ;
}



================================================================================
Function: _ZSt13__invoke_implIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSE_EESI_St14__invoke_otherOT0_DpOT1_ at 0x182d4
================================================================================

__int64 __fastcall std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string_view<std::byte>&>(
        __int64 a1,
        __int64 a2)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::basic_string_view<std::byte>&>(
           a1,
           a2);
}



================================================================================
Function: _ZSt10destroy_atINSt7__cxx1112basic_stringISt4byteSt11char_traitsIS2_ESaIS2_EEEEvPT_ at 0x1830e
================================================================================

__int64 __fastcall std::destroy_at<std::basic_string<std::byte>>(__int64 a1)
{
  return std::basic_string<std::byte>::~basic_string(a1);
}



================================================================================
Function: _ZSt13__invoke_implIvZNSt8__detail9__variant16_Variant_storageILb0EJDnN4pqxx5zviewENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt17basic_string_viewISt4byteS7_ISC_EENS6_ISC_SD_SaISC_EEEEE8_M_resetEvEUlOT_E_JRSG_EESI_St14__invoke_otherOT0_DpOT1_ at 0x1832d
================================================================================

__int64 __fastcall std::__invoke_impl<void,std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(void &&)#1},std::basic_string<std::byte>&>(
        __int64 a1,
        __int64 a2)
{
  return std::__detail::__variant::_Variant_storage<false,decltype(nullptr),pqxx::zview,std::string,std::basic_string_view<std::byte>,std::basic_string<std::byte>>::_M_reset(void)::{lambda(false &&)#1}::operator()<std::basic_string<std::byte>&>(
           a1,
           a2);
}



================================================================================
Function: _ZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE11_M_on_charsEPKc at 0x18368
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_on_chars(
        __int64 a1,
        __int64 a2)
{
  __int64 v2; // rax
  __int64 v3; // rbx
  __int64 v4; // rax
  __int64 v5; // rax
  _QWORD v7[3]; // [rsp+10h] [rbp-20h] BYREF

  v2 = std::__format::_Scanner<char>::begin(a1);
  std::string_view::basic_string_view<char const*,char const*>(v7, v2, a2);
  v3 = *(_QWORD *)(a1 + 56);
  v4 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(v3);
  v5 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v4, v7[0], v7[1]);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v3, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clISt9monostateEEDaS5_ at 0x183e2
================================================================================

void __fastcall __noreturn std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::monostate>(
        std::__format *a1)
{
  std::__format::__invalid_arg_id_in_format_string(a1);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIbEEDaS5_ at 0x183fc
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<bool>(
        __int64 a1,
        unsigned __int8 *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<bool>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<bool,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIcEEDaS5_ at 0x184a0
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<char>(
        __int64 a1,
        char *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+14h] [rbp-1Ch] BYREF
  int v8; // [rsp+1Ch] [rbp-14h]

  v7 = 0;
  v8 = 32;
  v2 = (_QWORD *)(*(_QWORD *)a1 + 8LL);
  v3 = std::formatter<char,char>::parse(&v7, v2);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<char,char>::format<std::__format::_Sink_iter<char>>(&v7, (unsigned int)*a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIiEEDaS5_ at 0x1853c
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<int>(
        __int64 a1,
        unsigned int *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<int>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<int,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIjEEDaS5_ at 0x185dc
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned int>(
        __int64 a1,
        unsigned int *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<unsigned int>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<unsigned int,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIxEEDaS5_ at 0x1867c
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<long long>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<long long>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<long long,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIyEEDaS5_ at 0x1871e
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned long long>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<unsigned long long>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<unsigned long long,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIfEEDaS5_ at 0x187c0
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<float>(
        __int64 a1,
        unsigned int *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_fp<char>::parse(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<float,char>::format<std::__format::_Sink_iter<char>>(
         &v7,
         v4,
         *(double *)_mm_cvtsi32_si128(*a2).m128i_i64);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIdEEDaS5_ at 0x18866
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<double>(
        __int64 a1,
        double *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_fp<char>::parse(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<double,char>::format<std::__format::_Sink_iter<char>>(&v7, v4, *a2);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIeEEDaS5_ at 0x1890e
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<long double>(
        __int64 a1,
        long double *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  long double v7; // [rsp+0h] [rbp-50h]
  __int64 v8; // [rsp+2Ch] [rbp-24h] BYREF
  int v9; // [rsp+34h] [rbp-1Ch]
  __int64 v10; // [rsp+38h] [rbp-18h]

  v8 = 0;
  v9 = 32;
  v10 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v10;
  v3 = std::__format::__formatter_fp<char>::parse(&v8, v10);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v7 = *a2;
  v5 = std::formatter<long double,char>::format<std::__format::_Sink_iter<char>>(*(_TBYTE *)&v7);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIPKcEEDaS5_ at 0x189bc
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<char const*>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  _BYTE *v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  _QWORD *v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = (_QWORD *)(*(_QWORD *)a1 + 8LL);
  v2 = v9;
  v3 = std::__format::__formatter_str<char>::parse((__int64)&v7, (__int64)v9);
  std::basic_format_parse_context<char>::advance_to(v2, (__int64)v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<char const*,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clISt17basic_string_viewIcSt11char_traitsIcEEEEDaS5_ at 0x18a5e
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::string_view>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  _BYTE *v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  _QWORD *v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = (_QWORD *)(*(_QWORD *)a1 + 8LL);
  v2 = v9;
  v3 = std::__format::__formatter_str<char>::parse((__int64)&v7, (__int64)v9);
  std::basic_format_parse_context<char>::advance_to(v2, (__int64)v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<std::string_view,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, a2[1], v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIPKvEEDaS5_ at 0x18b02
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<void const*>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+14h] [rbp-1Ch] BYREF
  int v8; // [rsp+1Ch] [rbp-14h]

  v7 = 0;
  v8 = 32;
  v2 = (_QWORD *)(*(_QWORD *)a1 + 8LL);
  v3 = std::formatter<void const*,char>::parse(&v7, v2);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<void const*,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clINSt16basic_format_argISt20basic_format_contextIS2_cEE6handleEEEDaS5_ at 0x18b9c
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>(
        __int64 a1,
        __int64 a2)
{
  return (*(__int64 (__fastcall **)(__int64, _QWORD, _QWORD))(a2 + 8))(
           *(_QWORD *)a1 + 8LL,
           *(_QWORD *)(*(_QWORD *)a1 + 56LL),
           *(_QWORD *)a2);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clInEEDaS5_ at 0x18c02
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<__int128>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<__int128>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<__int128,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, a2[1], v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIoEEDaS5_ at 0x18ca8
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned __int128>(
        __int64 a1,
        _QWORD *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_int<char>::_M_parse<unsigned __int128>(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<unsigned __int128,char>::format<std::__format::_Sink_iter<char>>(&v7, *a2, a2[1], v4);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmENKUlRT_E_clIDF128_EEDaS5_ at 0x18d4e
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<_Float128>(
        __int64 a1,
        const __m128i *a2)
{
  _QWORD *v2; // rbx
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  __int64 v7; // [rsp+1Ch] [rbp-24h] BYREF
  int v8; // [rsp+24h] [rbp-1Ch]
  __int64 v9; // [rsp+28h] [rbp-18h]

  v7 = 0;
  v8 = 32;
  v9 = *(_QWORD *)a1 + 8LL;
  v2 = (_QWORD *)v9;
  v3 = std::__format::__formatter_fp<char>::parse(&v7, v9);
  std::basic_format_parse_context<char>::advance_to(v2, v3);
  v4 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
  v5 = std::formatter<_Float128,char>::format<std::__format::_Sink_iter<char>>(
         &v7,
         v4,
         *(double *)_mm_load_si128(a2).m128i_i64);
  return std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(v4, v5);
}



================================================================================
Function: _ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE8_M_visitIZNS1_19_Formatting_scannerIS3_cE13_M_format_argEmEUlRT_E_EEDcOS9_NS1_6_Arg_tE at 0x18df2
================================================================================

__int64 __fastcall ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE8_M_visitIZNS1_19_Formatting_scannerIS3_cE13_M_format_argEmEUlRT_E_EEDcOS9_NS1_6_Arg_tE(
        __m128i *a1,
        std::__format *a2,
        unsigned __int8 a3)
{
  __int64 result; // rax

  result = a3;
  if ( a3 == 20 )
    return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<_Float128>(
             (__int64)a2,
             a1);
  if ( a3 <= 0x14u )
  {
    if ( a3 == 15 )
    {
      return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned __int128>(
               (__int64)a2,
               a1);
    }
    else if ( a3 <= 0xFu )
    {
      switch ( a3 )
      {
        case 0xEu:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<__int128>(
                   (__int64)a2,
                   a1);
        case 0xDu:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>(
                   (__int64)a2,
                   (__int64)a1);
        case 0xCu:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<void const*>(
                   (__int64)a2,
                   a1);
        case 0xBu:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::string_view>(
                   (__int64)a2,
                   a1);
        case 0xAu:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<char const*>(
                   (__int64)a2,
                   a1);
        case 9u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<long double>(
                   (__int64)a2,
                   (long double *)a1->m128i_i8);
        case 8u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<double>(
                   (__int64)a2,
                   (double *)a1->m128i_i64);
        case 7u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<float>(
                   (__int64)a2,
                   (unsigned int *)a1);
        case 6u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned long long>(
                   (__int64)a2,
                   a1);
        case 5u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<long long>(
                   (__int64)a2,
                   a1);
        case 4u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<unsigned int>(
                   (__int64)a2,
                   (unsigned int *)a1);
        case 3u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<int>(
                   (__int64)a2,
                   (unsigned int *)a1);
        case 2u:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<char>(
                   (__int64)a2,
                   a1->m128i_i8);
        case 0u:
          std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<std::monostate>(a2);
        default:
          return std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(unsigned long)::{lambda(std::__format::_Sink_iter<char> &)#1}::operator()<bool>(
                   (__int64)a2,
                   (unsigned __int8 *)a1);
      }
    }
  }
  return result;
}



================================================================================
Function: _ZNSt8__format18__visit_format_argIZNS_19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmEUlRT_E_St20basic_format_contextIS3_cEEEDcOS5_St16basic_format_argIT0_E at 0x191c6
================================================================================

__int64 __fastcall ZNSt8__format18__visit_format_argIZNS_19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmEUlRT_E_St20basic_format_contextIS3_cEEEDcOS5_St16basic_format_argIT0_E(
        std::__format *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __m128i a7,
        unsigned __int8 a8)
{
  return ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE8_M_visitIZNS1_19_Formatting_scannerIS3_cE13_M_format_argEmEUlRT_E_EEDcOS9_NS1_6_Arg_tE(
           &a7,
           a1,
           a8);
}



================================================================================
Function: _ZNSt8__format19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEm at 0x191f8
================================================================================

__int64 __fastcall std::__format::_Formatting_scanner<std::__format::_Sink_iter<char>,char>::_M_format_arg(
        __int64 a1,
        __int64 a2,
        __m128i a3)
{
  __int64 v3; // r8
  __int64 v4; // r9
  _QWORD v6[6]; // [rsp-20h] [rbp-60h] BYREF
  _QWORD v7[3]; // [rsp+10h] [rbp-30h] BYREF
  __int64 v8; // [rsp+28h] [rbp-18h]
  __int64 v9; // [rsp+38h] [rbp-8h] BYREF

  v6[5] = a1;
  v6[4] = a2;
  *(double *)a3.m128i_i64 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::arg(
                              v7,
                              *(_QWORD *)(a1 + 56),
                              a2);
  v9 = a1;
  v6[1] = v7[1];
  v6[2] = v7[2];
  v6[3] = v8;
  return ZNSt8__format18__visit_format_argIZNS_19_Formatting_scannerINS_10_Sink_iterIcEEcE13_M_format_argEmEUlRT_E_St20basic_format_contextIS3_cEEEDcOS5_St16basic_format_argIT0_E(
           (std::__format *)&v9,
           (__int64)&v9,
           v8,
           (__int64)v6,
           v3,
           v4,
           a3,
           v7[0]);
}



================================================================================
Function: _ZNKSt6ranges8__access6_BeginclIRSt4spanIcLm18446744073709551615EEEEDaOT_ at 0x19268
================================================================================

__int64 __fastcall std::ranges::__access::_Begin::operator()<std::span<char,18446744073709551615ul> &>(
        __int64 a1,
        __int64 a2)
{
  return std::span<char,18446744073709551615ul>::begin(a2);
}



================================================================================
Function: _ZNKSt6ranges8__access4_EndclIRSt4spanIcLm18446744073709551615EEEEDaOT_ at 0x1928a
================================================================================

__int64 __fastcall std::ranges::__access::_End::operator()<std::span<char,18446744073709551615ul> &>(
        __int64 a1,
        __int64 a2)
{
  return std::span<char,18446744073709551615ul>::end(a2);
}



================================================================================
Function: _ZNSt8__format10_Iter_sinkIcNS_10_Sink_iterIcEEE11_M_overflowEv at 0x192ac
================================================================================

_QWORD *__fastcall std::__format::_Iter_sink<char,std::__format::_Sink_iter<char>>::_M_overflow(_QWORD *a1)
{
  __int64 v1; // rdx
  __int64 v2; // rdx
  __int64 v3; // rdx
  unsigned __int64 v4; // rax
  __int64 v5; // rdx
  __int64 v6; // rdx
  __int64 v7; // rdx
  _QWORD *result; // rax
  __int64 v9; // [rsp+10h] [rbp-A0h] BYREF
  __int64 v10; // [rsp+18h] [rbp-98h]
  __int64 v11; // [rsp+20h] [rbp-90h] BYREF
  __int64 v12; // [rsp+28h] [rbp-88h]
  __int64 v13; // [rsp+30h] [rbp-80h]
  __int64 v14; // [rsp+38h] [rbp-78h]
  __int64 v15; // [rsp+40h] [rbp-70h]
  __int64 v16; // [rsp+48h] [rbp-68h]
  _QWORD v17[8]; // [rsp+58h] [rbp-58h] BYREF
  unsigned __int64 v18; // [rsp+98h] [rbp-18h]

  v17[7] = a1;
  v17[0] = std::span<char,18446744073709551615ul>::begin((__int64)(a1 + 1));
  v17[6] = a1 + 3;
  v17[5] = a1 + 3;
  v1 = a1[3];
  v17[4] = v17;
  v11 = std::span<char,18446744073709551615ul>::first((__int64)(a1 + 1), v1 - v17[0]);
  v12 = v2;
  if ( (__int64)a1[37] >= 0 )
  {
    if ( a1[38] < a1[37] )
    {
      v18 = a1[37] - a1[38];
      v9 = 0;
      v10 = 0;
      v4 = std::span<char,18446744073709551615ul>::size((__int64)&v11);
      if ( v18 >= v4 )
      {
        v9 = v11;
        v10 = v12;
      }
      else
      {
        v9 = std::span<char,18446744073709551615ul>::first((__int64)&v11, v18);
        v10 = v5;
      }
      v17[2] = a1 + 36;
      v15 = std::ranges::__copy_fn::operator()<std::span<char,18446744073709551615ul> &,std::__format::_Sink_iter<char>>(
              &std::ranges::copy,
              &v9,
              a1[36]);
      v16 = v6;
      a1[36] = v6;
    }
  }
  else
  {
    v17[3] = a1 + 36;
    v13 = std::ranges::__copy_fn::operator()<std::span<char,18446744073709551615ul> &,std::__format::_Sink_iter<char>>(
            &std::ranges::copy,
            &v11,
            a1[36]);
    v14 = v3;
    a1[36] = v3;
  }
  v17[1] = a1;
  a1[3] = std::span<char,18446744073709551615ul>::begin((__int64)(a1 + 1));
  v7 = std::span<char,18446744073709551615ul>::size((__int64)&v11) + a1[38];
  result = a1;
  a1[38] = v7;
  return result;
}



================================================================================
Function: _ZNKSt6ranges8__access5_DataclIRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEDaOT_ at 0x194f8
================================================================================

__int64 __fastcall std::ranges::__access::_Data::operator()<std::string &>(__int64 a1, __int64 a2)
{
  return std::string::data(a2);
}



================================================================================
Function: _ZNKSt6ranges8__access5_SizeclIRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEDaOT_ at 0x1951a
================================================================================

__int64 __fastcall std::ranges::__access::_Size::operator()<std::string &>(__int64 a1, __int64 a2)
{
  return std::string::size(a2);
}



================================================================================
Function: _ZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE10_M_reserveEm at 0x1953c
================================================================================

__int64 __fastcall std::__format::_Seq_sink<std::string>::_M_reserve(__int64 a1, __int64 a2)
{
  __int64 v2; // rdx
  __int64 v3; // rdx
  _QWORD v5[2]; // [rsp+10h] [rbp-60h] BYREF
  _QWORD v6[2]; // [rsp+20h] [rbp-50h] BYREF
  _QWORD v7[5]; // [rsp+30h] [rbp-40h] BYREF
  __int64 v8; // [rsp+58h] [rbp-18h]

  v7[4] = a1;
  v7[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v7[3] = a1 + 24;
  v7[2] = a1 + 24;
  v2 = *(_QWORD *)(a1 + 24);
  v7[1] = v7;
  v5[0] = std::span<char,18446744073709551615ul>::first(a1 + 8, v2 - v7[0]);
  v5[1] = v3;
  if ( std::span<char,18446744073709551615ul>::size((__int64)v5) )
    std::__format::_Seq_sink<std::string>::_M_overflow(a1);
  v8 = std::string::size(a1 + 288);
  ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_(
    a1 + 288,
    v8 + a2);
  std::span<char,18446744073709551615ul>::span<std::string &>(v6, a1 + 288);
  std::__format::_Sink<char>::_M_reset(a1, v6[0], v6[1], v8);
  return a1;
}



================================================================================
Function: _ZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE7_M_bumpEm at 0x19654
================================================================================

__int64 __fastcall std::__format::_Seq_sink<std::string>::_M_bump(__int64 a1, __int64 a2)
{
  __int64 v2; // rdx
  __int64 v3; // rdx
  __int64 v4; // rax
  _QWORD v6[2]; // [rsp+10h] [rbp-60h] BYREF
  _QWORD v7[3]; // [rsp+20h] [rbp-50h] BYREF
  _QWORD v8[6]; // [rsp+38h] [rbp-38h] BYREF

  v8[4] = a1;
  v8[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v8[3] = a1 + 24;
  v8[2] = a1 + 24;
  v2 = *(_QWORD *)(a1 + 24);
  v8[1] = v8;
  v6[0] = std::span<char,18446744073709551615ul>::first(a1 + 8, v2 - v8[0]);
  v6[1] = v3;
  v4 = std::span<char,18446744073709551615ul>::size((__int64)v6);
  std::string::resize(a1 + 288, a2 + v4);
  std::span<char,18446744073709551615ul>::span<256ul>(v7, a1 + 32);
  return std::__format::_Sink<char>::_M_reset(a1, v7[0], v7[1], 0);
}



================================================================================
Function: _ZNSt8__format7__writeINS_10_Sink_iterIcEEcEET_S3_St17basic_string_viewIT0_St11char_traitsIS5_EE at 0x19737
================================================================================

__int64 __fastcall std::__format::__write<std::__format::_Sink_iter<char>,char>(__int64 a1, __int64 a2, __int64 a3)
{
  __int64 v4; // [rsp+0h] [rbp-30h] BYREF
  __int64 v5; // [rsp+8h] [rbp-28h]
  __int64 v6; // [rsp+18h] [rbp-18h]
  __int64 v7; // [rsp+20h] [rbp-10h]
  __int64 v8; // [rsp+28h] [rbp-8h]

  v6 = a1;
  v4 = a2;
  v5 = a3;
  if ( std::string_view::size((__int64)&v4) )
  {
    v7 = v4;
    v8 = v5;
    std::__format::_Sink<char>::_M_write(v6, v4, v5);
  }
  return v6;
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcE10advance_toES2_ at 0x197a4
================================================================================

__int64 __fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::advance_to(__int64 a1, __int64 a2)
{
  __int64 result; // rax

  result = a1;
  *(_QWORD *)(a1 + 16) = a2;
  return result;
}



================================================================================
Function: _ZNKSt20basic_format_contextINSt8__format10_Sink_iterIcEEcE3argEm at 0x197c6
================================================================================

__int64 __fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::arg(
        __int64 a1,
        _QWORD *a2,
        unsigned __int64 a3)
{
  _QWORD *v3; // rax
  __int64 v4; // rdx
  __int64 v5; // rsi
  __int64 v6; // rdx

  *(_BYTE *)(a1 + 16) = 0;
  if ( a3 >= (*(_BYTE *)a2 & 0xFu) )
  {
    if ( (*(_BYTE *)a2 & 0xF) == 0 && a3 < *a2 >> 4 )
    {
      v5 = a2[1] + 32 * a3;
      v6 = *(_QWORD *)(v5 + 8);
      *(_QWORD *)a1 = *(_QWORD *)v5;
      *(_QWORD *)(a1 + 8) = v6;
      *(_BYTE *)(a1 + 16) = *(_BYTE *)(v5 + 16);
    }
  }
  else
  {
    *(_BYTE *)(a1 + 16) = std::basic_format_args<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_type(
                            a2,
                            a3);
    v3 = (_QWORD *)(16 * a3 + a2[1]);
    v4 = v3[1];
    *(_QWORD *)a1 = *v3;
    *(_QWORD *)(a1 + 8) = v4;
  }
  return a1;
}



================================================================================
Function: _ZNKSt9formatterIbcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEbRS7_ at 0x198aa
================================================================================

__int64 __fastcall std::formatter<bool,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        unsigned __int8 a2,
        __int64 a3)
{
  return std::__format::__formatter_int<char>::format<std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNSt9formatterIccE5parseERSt26basic_format_parse_contextIcE at 0x198dc
================================================================================

__int64 __fastcall std::formatter<char,char>::parse(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_parse<char>(a1, a2);
}



================================================================================
Function: _ZNKSt9formatterIccE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEcRS7_ at 0x19906
================================================================================

__int64 __fastcall std::formatter<char,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        unsigned __int8 a2,
        __int64 a3)
{
  if ( (*(_BYTE *)(a1 + 1) & 0x78) == 0 || (*(_BYTE *)(a1 + 1) & 0x78) == 0x38 )
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             a1,
             (unsigned int)(char)a2,
             a3);
  if ( (*(_BYTE *)(a1 + 1) & 0x78) == 0x78 )
    return std::__format::__formatter_int<char>::_M_format_character_escaped<std::__format::_Sink_iter<char>>(
             a1,
             (unsigned int)(char)a2,
             a3);
  return std::__format::__formatter_int<char>::format<unsigned char,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIicE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEiRS7_ at 0x19998
================================================================================

__int64 __fastcall std::formatter<int,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        unsigned int a2,
        __int64 a3)
{
  return std::__format::__formatter_int<char>::format<int,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIjcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEjRS7_ at 0x199c6
================================================================================

__int64 __fastcall std::formatter<unsigned int,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        unsigned int a2,
        __int64 a3)
{
  return std::__format::__formatter_int<char>::format<unsigned int,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIxcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorExRS7_ at 0x199f4
================================================================================

__int64 __fastcall std::formatter<long long,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  return std::__format::__formatter_int<char>::format<long long,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIycE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEyRS7_ at 0x19a26
================================================================================

__int64 __fastcall std::formatter<unsigned long long,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  return std::__format::__formatter_int<char>::format<unsigned long long,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIfcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEfRS7_ at 0x19a58
================================================================================

__int64 __fastcall std::formatter<float,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        float a3)
{
  return std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(
           a1,
           a2,
           *(double *)_mm_cvtsi32_si128(LODWORD(a3)).m128i_i64);
}



================================================================================
Function: _ZNKSt9formatterIdcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEdRS7_ at 0x19a8e
================================================================================

__int64 __fastcall std::formatter<double,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        double a3)
{
  return std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNKSt9formatterIecE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEeRS7_ at 0x19ac6
================================================================================

__int64 __fastcall std::formatter<long double,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int128 a7)
{
  return std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(*(_TBYTE *)&a7);
}



================================================================================
Function: _ZNKSt9formatterIPKccE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorES1_RS9_ at 0x19afa
================================================================================

__int64 __fastcall std::formatter<char const*,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        const char *a2,
        __int64 a3)
{
  size_t v5[3]; // [rsp+20h] [rbp-20h] BYREF

  std::string_view::basic_string_view(v5, a2);
  return std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(a1, v5[0], v5[1], a3);
}



================================================================================
Function: _ZNKSt9formatterISt17basic_string_viewIcSt11char_traitsIcEEcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorES3_RSB_ at 0x19b4a
================================================================================

__int64 __fastcall std::formatter<std::string_view,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  return std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(a1, a2, a3, a4);
}



================================================================================
Function: _ZZNSt9formatterIPKvcE5parseERSt26basic_format_parse_contextIcEENKUlvE_clEv at 0x19b92
================================================================================

__int64 __fastcall std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(
        __int64 *a1)
{
  __int64 v1; // rdx
  __int64 result; // rax

  v1 = a1[1];
  result = *a1;
  *(_QWORD *)result = *(_QWORD *)v1;
  *(_DWORD *)(result + 8) = *(_DWORD *)(v1 + 8);
  return result;
}



================================================================================
Function: _ZZNSt9formatterIPKvcE5parseERSt26basic_format_parse_contextIcEENKUlvE0_clEv at 0x19bbc
================================================================================

__int64 __fastcall std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(
        _QWORD **a1)
{
  if ( **a1 != *a1[1] && *(_BYTE *)**a1 != 125 )
    return 0;
  std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(a1[2]);
  return 1;
}



================================================================================
Function: _ZNSt9formatterIPKvcE5parseERSt26basic_format_parse_contextIcE at 0x19c16
================================================================================

_BYTE *__fastcall std::formatter<void const*,char>::parse(__int64 a1, __int64 a2)
{
  _QWORD *v3[4]; // [rsp+10h] [rbp-50h] BYREF
  _QWORD v4[2]; // [rsp+30h] [rbp-30h] BYREF
  _BYTE *v5; // [rsp+40h] [rbp-20h] BYREF
  _BYTE *v6; // [rsp+48h] [rbp-18h] BYREF
  __int64 v7; // [rsp+54h] [rbp-Ch] BYREF
  int v8; // [rsp+5Ch] [rbp-4h]

  v7 = 0;
  v8 = 32;
  v6 = (_BYTE *)std::basic_format_parse_context<char>::end(a2);
  v5 = (_BYTE *)std::basic_format_parse_context<char>::begin(a2);
  v4[0] = a1;
  v4[1] = &v7;
  v3[0] = &v5;
  v3[1] = &v6;
  v3[2] = v4;
  if ( (unsigned __int8)std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v5;
  v5 = (_BYTE *)std::__format::_Spec<char>::_M_parse_fill_and_align((__int64)&v7, (__int64)v5, (__int64)v6);
  if ( (unsigned __int8)std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v5;
  v5 = (_BYTE *)std::__format::_Spec<char>::_M_parse_zero_fill(&v7, v5, v6);
  if ( (unsigned __int8)std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    return v5;
  v5 = (_BYTE *)std::__format::_Spec<char>::_M_parse_width(&v7, v5, (__int64)v6, a2);
  if ( v5 != v6 )
  {
    if ( *v5 == 112 )
    {
      ++v5;
    }
    else if ( *v5 == 80 )
    {
      BYTE1(v7) = BYTE1(v7) & 0x87 | 8;
      ++v5;
    }
  }
  if ( !(unsigned __int8)std::formatter<void const*,char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v3) )
    std::__format::__failed_to_parse_format_spec((std::__format *)v3);
  return v5;
}



================================================================================
Function: _ZNKSt9formatterIPKvcE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorES1_RS9_ at 0x19d8c
================================================================================

__int64 __fastcall std::formatter<void const*,char>::format<std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        unsigned __int64 a2,
        __int64 a3)
{
  __int64 v3; // rdx
  unsigned __int64 v4; // rax
  __int64 v5; // rax
  __int64 v7; // rax
  __int64 v8; // rdx
  __int64 v10; // [rsp+28h] [rbp-88h]
  __int64 v11; // [rsp+28h] [rbp-88h]
  __int64 v12; // [rsp+30h] [rbp-80h] BYREF
  __int64 v13; // [rsp+38h] [rbp-78h]
  __int64 v14; // [rsp+40h] [rbp-70h]
  __int64 v15; // [rsp+48h] [rbp-68h]
  char v16; // [rsp+50h] [rbp-60h] BYREF
  char v17; // [rsp+51h] [rbp-5Fh]
  char v18[16]; // [rsp+52h] [rbp-5Eh] BYREF
  char v19[14]; // [rsp+62h] [rbp-4Eh] BYREF
  _QWORD v20[3]; // [rsp+70h] [rbp-40h] BYREF
  unsigned __int64 v21; // [rsp+88h] [rbp-28h]
  unsigned __int64 v22; // [rsp+90h] [rbp-20h]
  int v23; // [rsp+9Ch] [rbp-14h]
  unsigned __int64 v24; // [rsp+A0h] [rbp-10h]
  char *i; // [rsp+A8h] [rbp-8h]

  v24 = a2;
  v14 = std::to_chars(v18, v19, a2, 0x10u);
  v15 = v3;
  v23 = v14 - (_QWORD)&v16;
  v16 = 48;
  v17 = 120;
  if ( (a1[1] & 0x78) == 8 )
  {
    v17 = 88;
    for ( i = v18; i != (char *)v14; ++i )
      *i = toupper(*i);
  }
  std::string_view::basic_string_view(v20, (__int64)&v16, v23);
  v12 = v20[0];
  v13 = v20[1];
  if ( (*a1 & 0x40) == 0 )
    return std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v12, v13, v23, a3, a1, 2);
  v22 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          a1,
          a3);
  v4 = std::string_view::size((__int64)&v12);
  if ( v4 < v22 )
  {
    v10 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a3);
    v7 = std::string_view::substr(&v12, 0, 2);
    v11 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v10, v7, v8);
    std::string_view::remove_prefix(&v12, 2);
    v21 = v22 - v23;
    return std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v11, v12, v13, 2, v21, 48);
  }
  else
  {
    v5 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a3);
    return std::__format::__write<std::__format::_Sink_iter<char>,char>(v5, v12, v13);
  }
}



================================================================================
Function: _ZNKSt9formatterIncE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEnRS7_ at 0x19fc0
================================================================================

__int64 __fastcall std::formatter<__int128,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__format::__formatter_int<char>::format<__int128,std::__format::_Sink_iter<char>>(
           a1,
           a2,
           a3,
           a4,
           a5,
           a6,
           a2,
           a3,
           a4,
           a1);
}



================================================================================
Function: _ZNKSt9formatterIocE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEoRS7_ at 0x1a008
================================================================================

__int64 __fastcall std::formatter<unsigned __int128,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::__format::__formatter_int<char>::format<unsigned __int128,std::__format::_Sink_iter<char>>(
           a1,
           a2,
           a3,
           a4,
           a5,
           a6,
           a2,
           a3,
           a4,
           a1);
}



================================================================================
Function: _ZNKSt9formatterIDF128_cE6formatINSt8__format10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEDF128_RS7_ at 0x1a050
================================================================================

__int64 __fastcall std::formatter<_Float128,char>::format<std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __m128 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int64 a7)
{
  __m128i v8; // [rsp+0h] [rbp-20h] BYREF
  __int64 v9; // [rsp+10h] [rbp-10h]
  __int64 v10; // [rsp+18h] [rbp-8h]

  v10 = a1;
  v9 = a2;
  return std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(
           a1,
           a2,
           a2,
           a5,
           a6,
           a7,
           *(double *)_mm_load_si128(&v8).m128i_i64,
           a3.m128_u64[0],
           a3.m128_u64[1],
           a2,
           a1);
}



================================================================================
Function: _ZNKSt4spanIcLm18446744073709551615EE3endEv at 0x1a082
================================================================================

__int64 __fastcall std::span<char,18446744073709551615ul>::end(__int64 *a1)
{
  __int64 v1; // rbx

  v1 = *a1;
  return v1 + std::span<char,18446744073709551615ul>::size((__int64)a1);
}



================================================================================
Function: _ZNKSt6ranges9__copy_fnclIRSt4spanIcLm18446744073709551615EENSt8__format10_Sink_iterIcEEEENS_13in_out_resultINSt13__conditionalIX14borrowed_rangeIT_EEE4typeIDTcl7__begincl7declvalIRSA_EEEENS_8danglingEEET0_EEOSA_SH_ at 0x1a0c0
================================================================================

__int64 __fastcall std::ranges::__copy_fn::operator()<std::span<char,18446744073709551615ul> &,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  __int64 v3; // r12
  __int64 v4; // rax

  v3 = std::ranges::__access::_End::operator()<std::span<char,18446744073709551615ul> &>(
         (__int64)&std::ranges::_Cpo::end,
         a2);
  v4 = std::ranges::__access::_Begin::operator()<std::span<char,18446744073709551615ul> &>(
         (__int64)&std::ranges::_Cpo::begin,
         a2);
  return std::ranges::__copy_fn::operator()<__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,std::__format::_Sink_iter<char>>(
           a1,
           v4,
           v3,
           a3);
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_EN11_TerminatorD2Ev at 0x1a130
================================================================================

_BYTE *__fastcall ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_EN11_TerminatorD2Ev(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE10_M_reserveEmENKUlT_T0_E_clIPcmEEDaS8_S9_ at 0x1a15e
================================================================================

__int64 __fastcall ZZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE10_M_reserveEmENKUlT_T0_E_clIPcmEEDaS8_S9_(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  return a3;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_ at 0x1a178
================================================================================

_BYTE *__fastcall ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_(
        _QWORD *a1,
        unsigned __int64 a2)
{
  char v3; // [rsp+Fh] [rbp-41h] BYREF
  unsigned __int64 v4; // [rsp+10h] [rbp-40h]
  _QWORD *v5; // [rsp+18h] [rbp-38h]
  __int128 v6; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+30h] [rbp-20h]
  __int64 v8; // [rsp+38h] [rbp-18h]

  v5 = a1;
  v4 = a2;
  std::string::reserve(a1, a2);
  v8 = std::string::_M_data((__int64)a1);
  v6 = (unsigned __int64)a1;
  v7 = ZZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE10_M_reserveEmENKUlT_T0_E_clIPcmEEDaS8_S9_(
         (__int64)&v3,
         v8,
         a2);
  *((_QWORD *)&v6 + 1) = v7;
  return ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNSt8__format9_Seq_sinkIS4_E10_M_reserveEmEUlT_T0_E_EEvmS9_EN11_TerminatorD2Ev((__int64 *)&v6);
}



================================================================================
Function: _ZNSt4spanIcLm18446744073709551615EEC2IRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEOT_ at 0x1a262
================================================================================

_QWORD *__fastcall std::span<char,18446744073709551615ul>::span<std::string &>(__int64 *a1, __int64 a2)
{
  _QWORD *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h]

  *a1 = std::ranges::__access::_Data::operator()<std::string &>((__int64)&std::ranges::_Cpo::data, a2);
  v3 = std::ranges::__access::_Size::operator()<std::string &>((__int64)&std::ranges::_Cpo::size, a2);
  result = a1 + 1;
  a1[1] = v3;
  return result;
}



================================================================================
Function: _ZNSt8__format5_SinkIcE8_M_resetESt4spanIcLm18446744073709551615EEm at 0x1a2ce
================================================================================

__int64 __fastcall std::__format::_Sink<char>::_M_reset(__int64 a1, __int64 a2, __int64 a3, __int64 a4)
{
  __int64 v4; // rbx
  __int64 result; // rax
  _QWORD v6[2]; // [rsp+0h] [rbp-50h] BYREF
  __int64 v7; // [rsp+10h] [rbp-40h]
  __int64 v8; // [rsp+18h] [rbp-38h]
  __int64 v9; // [rsp+20h] [rbp-30h]

  v8 = a1;
  v6[0] = a2;
  v6[1] = a3;
  v7 = a4;
  *(_QWORD *)(a1 + 8) = a2;
  *(_QWORD *)(a1 + 16) = a3;
  v4 = v7;
  v9 = std::span<char,18446744073709551615ul>::begin((__int64)v6);
  result = v8;
  *(_QWORD *)(v8 + 24) = v9 + v4;
  return result;
}



================================================================================
Function: _ZNKSt17integral_constantImLm12EEcvmEv at 0x1a356
================================================================================

__int64 std::integral_constant<unsigned long,12ul>::operator unsigned long()
{
  return 12;
}



================================================================================
Function: _ZNKSt6ranges8__access6_BeginclIRA1_KDiEEDaOT_ at 0x1a36a
================================================================================

__int64 __fastcall std::ranges::__access::_Begin::operator()<char32_t const(&)[1]>(__int64 a1, __int64 a2)
{
  return a2;
}



================================================================================
Function: _ZNKSt6ranges8__access4_EndclIRA1_KDiEEDaOT_ at 0x1a380
================================================================================

__int64 __fastcall std::ranges::__access::_End::operator()<char32_t const(&)[1]>(__int64 a1, __int64 a2)
{
  return a2 + 4;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIbEEPKcRSt26basic_format_parse_contextIcE at 0x1a39a
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<bool>(_BYTE *a1, __int64 a2)
{
  __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 0);
  if ( (a1[1] & 0x78) == 0 && ((*a1 & 0xC) != 0 || (*a1 & 0x10) != 0 || (*a1 & 0x40) != 0) )
    std::__throw_format_error("format error: format-spec contains invalid formatting options for 'bool'");
  return v3;
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatINS_10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEbRS7_ at 0x1a418
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        unsigned __int8 a2,
        __int64 a3)
{
  __int64 v3; // rbx
  const char *v4; // rax
  __int64 v5; // rax
  __int64 v6; // rdx
  _QWORD v9[5]; // [rsp+20h] [rbp-70h] BYREF
  _BYTE v10[8]; // [rsp+48h] [rbp-48h] BYREF
  _QWORD v11[5]; // [rsp+50h] [rbp-40h] BYREF
  __int64 v12; // [rsp+78h] [rbp-18h]

  if ( (a1[1] & 0x78) == 0x38 )
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(a1, a2, a3);
  if ( (a1[1] & 0x78) != 0 )
    return std::__format::__formatter_int<char>::format<unsigned char,std::__format::_Sink_iter<char>>(a1, a2, a3);
  std::string::basic_string(v9);
  if ( (*a1 & 0x20) != 0 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(v10, a3);
    v11[4] = std::use_facet<std::numpunct<char>>();
    std::locale::~locale((std::locale *)v10);
    if ( a2 )
      std::numpunct<char>::truename();
    else
      std::numpunct<char>::falsename();
    std::string::operator=(v9, v11);
    std::string::~string((__int64)v11);
    v12 = std::string::size((__int64)v9);
  }
  else
  {
    if ( a2 )
      v4 = "true";
    else
      v4 = "false";
    std::string::operator=(v9, v4);
    v12 = std::string::size((__int64)v9);
  }
  v5 = std::string::operator std::string_view((__int64)v9);
  v3 = std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v5, v6, v12, a3, a1, 1);
  std::string::~string((__int64)v9);
  return v3;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIcEEPKcRSt26basic_format_parse_contextIcE at 0x1a600
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<char>(_BYTE *a1, __int64 a2)
{
  __int64 v3; // [rsp+18h] [rbp-8h]

  v3 = std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 7);
  if ( ((a1[1] & 0x78) == 0x38 || (a1[1] & 0x78) == 0x78)
    && ((*a1 & 0xC) != 0 || (*a1 & 0x10) != 0 || (*a1 & 0x40) != 0) )
  {
    std::__throw_format_error("format error: format-spec contains invalid formatting options for 'charT'");
  }
  return v3;
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE19_M_format_characterINS_10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEcRS7_ at 0x1a68e
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
        __int64 a1,
        char a2,
        __int64 a3)
{
  _BYTE v5[4]; // [rsp+14h] [rbp-3Ch] BYREF
  __int64 v6; // [rsp+18h] [rbp-38h]
  _QWORD v7[3]; // [rsp+20h] [rbp-30h] BYREF
  char v8; // [rsp+3Fh] [rbp-11h]

  v6 = a1;
  v5[0] = a2;
  v8 = a2;
  std::string_view::basic_string_view(v7, (__int64)v5, 1);
  return std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v7[0], v7[1], 1, a3, a1, 1);
}



================================================================================
Function: _ZNSt4spanIcLm18446744073709551615EEC2ILm12EEERAT__c at 0x1a706
================================================================================

_QWORD *__fastcall std::span<char,18446744073709551615ul>::span<12ul>(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax
  __int64 v3; // [rsp+10h] [rbp-20h]

  *a1 = a2;
  v3 = std::integral_constant<unsigned long,12ul>::operator unsigned long(&std::span<char,18446744073709551615ul>::__v<12ul>);
  result = a1 + 1;
  a1[1] = v3;
  return result;
}



================================================================================
Function: _ZNKSt8__format14_Fixedbuf_sinkIcE4viewEv at 0x1a758
================================================================================

__int64 __fastcall std::__format::_Fixedbuf_sink<char>::view(__int64 a1)
{
  __int64 v1; // rdx
  __int64 v2; // rdx
  __int64 v3; // rbx
  __int64 v4; // rax
  _QWORD v6[2]; // [rsp+10h] [rbp-60h] BYREF
  __int64 v7; // [rsp+20h] [rbp-50h] BYREF
  _QWORD v8[6]; // [rsp+38h] [rbp-38h] BYREF

  v8[4] = a1;
  v8[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v8[3] = a1 + 24;
  v8[2] = a1 + 24;
  v1 = *(_QWORD *)(a1 + 24);
  v8[1] = v8;
  v6[0] = std::span<char,18446744073709551615ul>::first(a1 + 8, v1 - v8[0]);
  v6[1] = v2;
  v3 = std::span<char,18446744073709551615ul>::size((__int64)v6);
  v4 = std::span<char,18446744073709551615ul>::data((__int64)v6);
  std::string_view::basic_string_view(&v7, v4, v3);
  return v7;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE6substrEmm at 0x1a810
================================================================================

__int64 __fastcall std::string_view::substr(_QWORD *a1, unsigned __int64 a2, __int64 a3)
{
  unsigned __int64 v3; // rax
  __int64 v5; // [rsp+8h] [rbp-48h] BYREF
  unsigned __int64 v6; // [rsp+10h] [rbp-40h]
  _QWORD *v7; // [rsp+18h] [rbp-38h]
  unsigned __int64 v8; // [rsp+28h] [rbp-28h] BYREF
  __int64 v9; // [rsp+30h] [rbp-20h] BYREF
  __int64 v10; // [rsp+48h] [rbp-8h]

  v7 = a1;
  v5 = a3;
  v3 = std::string_view::size((__int64)a1);
  v6 = std::__sv_check(v3, a2, "basic_string_view::substr");
  v8 = *a1 - v6;
  v10 = *std::min<unsigned long>(&v5, &v8);
  std::string_view::basic_string_view(&v9, v7[1] + v6, v10);
  return v9;
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE27_M_format_character_escapedINS_10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorEcRS7_ at 0x1a8a8
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_format_character_escaped<std::__format::_Sink_iter<char>>(
        __int64 a1,
        char a2,
        __int64 a3)
{
  __int64 v3; // rax
  __int64 v5; // rdx
  char v6; // bl
  _BYTE v8[4]; // [rsp+14h] [rbp-ECh] BYREF
  __int64 v9; // [rsp+18h] [rbp-E8h]
  _QWORD v10[4]; // [rsp+20h] [rbp-E0h] BYREF
  __int64 v11; // [rsp+40h] [rbp-C0h] BYREF
  __int64 v12; // [rsp+48h] [rbp-B8h]
  _QWORD v13[4]; // [rsp+50h] [rbp-B0h] BYREF
  _BYTE v14[12]; // [rsp+74h] [rbp-8Ch] BYREF
  __int64 v15; // [rsp+80h] [rbp-80h] BYREF
  __int64 v16; // [rsp+88h] [rbp-78h]
  __int64 v17; // [rsp+90h] [rbp-70h] BYREF
  __int64 v18; // [rsp+98h] [rbp-68h]
  unsigned __int64 v19[3]; // [rsp+A0h] [rbp-60h] BYREF
  char v20; // [rsp+BFh] [rbp-41h]
  _QWORD *v21; // [rsp+C0h] [rbp-40h]
  _QWORD *v22; // [rsp+C8h] [rbp-38h]
  _QWORD *v23; // [rsp+D0h] [rbp-30h]
  _QWORD *v24; // [rsp+D8h] [rbp-28h]
  char v25; // [rsp+E7h] [rbp-19h]
  __int64 v26; // [rsp+E8h] [rbp-18h]

  v9 = a1;
  v8[0] = a2;
  v25 = 15;
  std::string_view::basic_string_view(&v15, (__int64)v8, 1);
  if ( (unsigned __int64)std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
                           v9,
                           a3) > 3 )
  {
    std::span<char,18446744073709551615ul>::span<12ul>(&v17, (__int64)v14);
    v10[2] = v17;
    v10[3] = v18;
    v21 = v13;
    v10[0] = v17;
    v10[1] = v18;
    v13[0] = &off_37918;
    v13[1] = v17;
    v13[2] = v18;
    v13[3] = std::span<char,18446744073709551615ul>::begin((__int64)v10);
    v13[0] = off_377F0;
    v24 = v13;
    v23 = v13;
    v22 = v13;
    v19[2] = (unsigned __int64)v13;
    std::__format::__write_escaped<char,std::__format::_Sink_iter<char>>(v13, v15, v16, 15);
    v11 = std::__format::_Fixedbuf_sink<char>::view((__int64)v13);
    v12 = v5;
    v6 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v11, 1u);
    v19[0] = 3;
    v19[1] = (unsigned __int64)"\\\\\\\"\\\"'\\'\\u\\x";
    if ( v6 == *(_BYTE *)std::string_view::operator[](v19, 0) )
    {
      v26 = std::string_view::size((__int64)&v11);
    }
    else
    {
      v20 = v8[0];
      v26 = 3;
    }
    return std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v11, v12, v26, a3, v9, 1);
  }
  else
  {
    v3 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a3);
    return std::__format::__write_escaped<char,std::__format::_Sink_iter<char>>(v3, v15, v16, 15);
  }
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIhNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1aaf4
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<unsigned char,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        unsigned __int8 a2,
        __int64 a3)
{
  char v3; // al
  unsigned int v5; // eax
  const char *v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v9; // rdx
  const char *v10; // rax
  __int64 v11; // rdx
  __int64 v13; // rax
  size_t v14; // rbx
  const void *v15; // rax
  signed __int64 v16; // rbx
  size_t v18; // [rsp+20h] [rbp-B0h] BYREF
  size_t v19; // [rsp+28h] [rbp-A8h]
  __int64 v20; // [rsp+30h] [rbp-A0h]
  __int64 v21; // [rsp+38h] [rbp-98h]
  __int64 v22; // [rsp+48h] [rbp-88h] BYREF
  size_t v23[2]; // [rsp+50h] [rbp-80h] BYREF
  size_t v24[2]; // [rsp+60h] [rbp-70h] BYREF
  size_t v25[2]; // [rsp+70h] [rbp-60h] BYREF
  _QWORD v26[3]; // [rsp+80h] [rbp-50h] BYREF
  char *v27; // [rsp+98h] [rbp-38h]
  size_t *v28; // [rsp+A0h] [rbp-30h]
  unsigned __int8 v29; // [rsp+AFh] [rbp-21h]
  _BYTE *i; // [rsp+B0h] [rbp-20h]
  void *dest; // [rsp+B8h] [rbp-18h]

  if ( (a1[1] & 0x78) == 0x38 )
  {
    v3 = std::__format::__formatter_int<char>::_S_to_character<unsigned char>(a2);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v3,
             a3);
  }
  else
  {
    v20 = 0;
    v21 = 0;
    v18 = 0;
    v19 = 0;
    v29 = a2;
    dest = &v22;
    v28 = v23;
    v27 = (char *)&v22;
    v5 = (a1[1] >> 3) & 0xF;
    if ( v5 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v10 = "0x";
        else
          v10 = "0X";
        std::string_view::basic_string_view(v25, v10);
        v18 = v25[0];
        v19 = v25[1];
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned char>(dest, v28, v29, 16);
        v21 = v11;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v20; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v5 == 4 )
      {
        if ( a2 )
        {
          std::string_view::basic_string_view(v24, "0");
          v18 = v24[0];
          v19 = v24[1];
        }
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned char>(dest, v28, v29, 8);
        v21 = v9;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v5 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v6 = "0b";
          else
            v6 = "0B";
          std::string_view::basic_string_view(v23, v6);
          v18 = v23[0];
          v19 = v23[1];
          v20 = std::__format::__formatter_int<char>::to_chars<unsigned char>(dest, v28, v29, 2);
          v21 = v7;
        }
      }
      else
      {
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned char>(dest, v28, v29, 10);
        v21 = v8;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v18) )
    {
      v13 = std::string_view::size((__int64)&v18);
      dest = (char *)dest - v13;
      v14 = std::string_view::size((__int64)&v18);
      v15 = (const void *)std::string_view::data((__int64)&v18);
      memcpy(dest, v15, v14);
    }
    dest = (void *)std::__format::__put_sign<unsigned char>(a2, (*a1 >> 2) & 3, (char *)dest - 1);
    v16 = v27 - (_BYTE *)dest;
    std::string_view::basic_string_view(v26, (__int64)dest, v20 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v26[0],
             v26[1],
             v16,
             a3);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIiEEPKcRSt26basic_format_parse_contextIcE at 0x1aecc
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<int>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIiNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1aefa
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<int,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        int a2,
        __int64 a3)
{
  char v3; // al
  unsigned int v5; // eax
  const char *v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v9; // rdx
  const char *v10; // rax
  __int64 v11; // rdx
  __int64 v13; // rax
  size_t v14; // rbx
  const void *v15; // rax
  __int64 v16; // rbx
  size_t v18; // [rsp+20h] [rbp-D0h] BYREF
  size_t v19; // [rsp+28h] [rbp-C8h]
  __int64 v20; // [rsp+30h] [rbp-C0h]
  __int64 v21; // [rsp+38h] [rbp-B8h]
  _BYTE v22[32]; // [rsp+43h] [rbp-ADh] BYREF
  _BYTE v23[5]; // [rsp+63h] [rbp-8Dh] BYREF
  size_t v24[2]; // [rsp+70h] [rbp-80h] BYREF
  size_t v25[2]; // [rsp+80h] [rbp-70h] BYREF
  size_t v26[2]; // [rsp+90h] [rbp-60h] BYREF
  _QWORD v27[3]; // [rsp+A0h] [rbp-50h] BYREF
  _BYTE *v28; // [rsp+B8h] [rbp-38h]
  _BYTE *v29; // [rsp+C0h] [rbp-30h]
  _BYTE *i; // [rsp+C8h] [rbp-28h]
  void *dest; // [rsp+D0h] [rbp-20h]
  unsigned int v32; // [rsp+DCh] [rbp-14h]

  if ( (a1[1] & 0x78) == 0x38 )
  {
    v3 = std::__format::__formatter_int<char>::_S_to_character<int>((unsigned int)a2);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v3,
             a3);
  }
  else
  {
    v20 = 0;
    v21 = 0;
    v18 = 0;
    v19 = 0;
    if ( a2 >= 0 )
      v32 = a2;
    else
      v32 = -a2;
    dest = v22;
    v29 = v23;
    v28 = v22;
    v5 = (a1[1] >> 3) & 0xF;
    if ( v5 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v10 = "0x";
        else
          v10 = "0X";
        std::string_view::basic_string_view(v26, v10);
        v18 = v26[0];
        v19 = v26[1];
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v32, 16);
        v21 = v11;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v20; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v5 == 4 )
      {
        if ( a2 )
        {
          std::string_view::basic_string_view(v25, "0");
          v18 = v25[0];
          v19 = v25[1];
        }
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v32, 8);
        v21 = v9;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v5 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v6 = "0b";
          else
            v6 = "0B";
          std::string_view::basic_string_view(v24, v6);
          v18 = v24[0];
          v19 = v24[1];
          v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v32, 2);
          v21 = v7;
        }
      }
      else
      {
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v32, 10);
        v21 = v8;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v18) )
    {
      v13 = std::string_view::size((__int64)&v18);
      dest = (char *)dest - v13;
      v14 = std::string_view::size((__int64)&v18);
      v15 = (const void *)std::string_view::data((__int64)&v18);
      memcpy(dest, v15, v14);
    }
    dest = (void *)std::__format::__put_sign<int>((unsigned int)a2, (*a1 >> 2) & 3, (char *)dest - 1);
    v16 = v28 - (_BYTE *)dest;
    std::string_view::basic_string_view(v27, (__int64)dest, v20 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v27[0],
             v27[1],
             v16,
             a3);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIjEEPKcRSt26basic_format_parse_contextIcE at 0x1b2de
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<unsigned int>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIjNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1b30c
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<unsigned int,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        unsigned int a2,
        __int64 a3)
{
  char v3; // al
  unsigned int v5; // eax
  const char *v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v9; // rdx
  const char *v10; // rax
  __int64 v11; // rdx
  __int64 v13; // rax
  size_t v14; // rbx
  const void *v15; // rax
  __int64 v16; // rbx
  size_t v18; // [rsp+20h] [rbp-D0h] BYREF
  size_t v19; // [rsp+28h] [rbp-C8h]
  __int64 v20; // [rsp+30h] [rbp-C0h]
  __int64 v21; // [rsp+38h] [rbp-B8h]
  _BYTE v22[32]; // [rsp+43h] [rbp-ADh] BYREF
  _BYTE v23[5]; // [rsp+63h] [rbp-8Dh] BYREF
  size_t v24[2]; // [rsp+70h] [rbp-80h] BYREF
  size_t v25[2]; // [rsp+80h] [rbp-70h] BYREF
  size_t v26[2]; // [rsp+90h] [rbp-60h] BYREF
  _QWORD v27[3]; // [rsp+A0h] [rbp-50h] BYREF
  _BYTE *v28; // [rsp+B8h] [rbp-38h]
  _BYTE *v29; // [rsp+C0h] [rbp-30h]
  unsigned int v30; // [rsp+CCh] [rbp-24h]
  _BYTE *i; // [rsp+D0h] [rbp-20h]
  void *dest; // [rsp+D8h] [rbp-18h]

  if ( (a1[1] & 0x78) == 0x38 )
  {
    v3 = std::__format::__formatter_int<char>::_S_to_character<unsigned int>(a2);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v3,
             a3);
  }
  else
  {
    v20 = 0;
    v21 = 0;
    v18 = 0;
    v19 = 0;
    v30 = a2;
    dest = v22;
    v29 = v23;
    v28 = v22;
    v5 = (a1[1] >> 3) & 0xF;
    if ( v5 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v10 = "0x";
        else
          v10 = "0X";
        std::string_view::basic_string_view(v26, v10);
        v18 = v26[0];
        v19 = v26[1];
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v30, 16);
        v21 = v11;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v20; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v5 == 4 )
      {
        if ( a2 )
        {
          std::string_view::basic_string_view(v25, "0");
          v18 = v25[0];
          v19 = v25[1];
        }
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v30, 8);
        v21 = v9;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v5 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v6 = "0b";
          else
            v6 = "0B";
          std::string_view::basic_string_view(v24, v6);
          v18 = v24[0];
          v19 = v24[1];
          v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v30, 2);
          v21 = v7;
        }
      }
      else
      {
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned int>(dest, v29, v30, 10);
        v21 = v8;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v18) )
    {
      v13 = std::string_view::size((__int64)&v18);
      dest = (char *)dest - v13;
      v14 = std::string_view::size((__int64)&v18);
      v15 = (const void *)std::string_view::data((__int64)&v18);
      memcpy(dest, v15, v14);
    }
    dest = (void *)std::__format::__put_sign<unsigned int>(a2, (*a1 >> 2) & 3, (char *)dest - 1);
    v16 = v28 - (_BYTE *)dest;
    std::string_view::basic_string_view(v27, (__int64)dest, v20 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v27[0],
             v27[1],
             v16,
             a3);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIxEEPKcRSt26basic_format_parse_contextIcE at 0x1b6da
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<long long>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIxNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1b708
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<long long,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        __int64 a2,
        __int64 a3)
{
  char v3; // al
  unsigned int v5; // eax
  const char *v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v9; // rdx
  const char *v10; // rax
  __int64 v11; // rdx
  __int64 v13; // rax
  size_t v14; // rbx
  const void *v15; // rax
  __int64 v16; // rbx
  size_t v18; // [rsp+20h] [rbp-F0h] BYREF
  size_t v19; // [rsp+28h] [rbp-E8h]
  __int64 v20; // [rsp+30h] [rbp-E0h]
  __int64 v21; // [rsp+38h] [rbp-D8h]
  _BYTE v22[64]; // [rsp+43h] [rbp-CDh] BYREF
  _BYTE v23[5]; // [rsp+83h] [rbp-8Dh] BYREF
  size_t v24[2]; // [rsp+90h] [rbp-80h] BYREF
  size_t v25[2]; // [rsp+A0h] [rbp-70h] BYREF
  size_t v26[2]; // [rsp+B0h] [rbp-60h] BYREF
  _QWORD v27[3]; // [rsp+C0h] [rbp-50h] BYREF
  _BYTE *v28; // [rsp+D8h] [rbp-38h]
  _BYTE *v29; // [rsp+E0h] [rbp-30h]
  _BYTE *i; // [rsp+E8h] [rbp-28h]
  void *dest; // [rsp+F0h] [rbp-20h]
  __int64 v32; // [rsp+F8h] [rbp-18h]

  if ( (a1[1] & 0x78) == 0x38 )
  {
    v3 = std::__format::__formatter_int<char>::_S_to_character<long long>(a2);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v3,
             a3);
  }
  else
  {
    v20 = 0;
    v21 = 0;
    v18 = 0;
    v19 = 0;
    if ( a2 >= 0 )
      v32 = a2;
    else
      v32 = -a2;
    dest = v22;
    v29 = v23;
    v28 = v22;
    v5 = (a1[1] >> 3) & 0xF;
    if ( v5 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v10 = "0x";
        else
          v10 = "0X";
        std::string_view::basic_string_view(v26, v10);
        v18 = v26[0];
        v19 = v26[1];
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v32, 16);
        v21 = v11;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v20; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v5 == 4 )
      {
        if ( a2 )
        {
          std::string_view::basic_string_view(v25, "0");
          v18 = v25[0];
          v19 = v25[1];
        }
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v32, 8);
        v21 = v9;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v5 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v6 = "0b";
          else
            v6 = "0B";
          std::string_view::basic_string_view(v24, v6);
          v18 = v24[0];
          v19 = v24[1];
          v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v32, 2);
          v21 = v7;
        }
      }
      else
      {
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v32, 10);
        v21 = v8;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v18) )
    {
      v13 = std::string_view::size((__int64)&v18);
      dest = (char *)dest - v13;
      v14 = std::string_view::size((__int64)&v18);
      v15 = (const void *)std::string_view::data((__int64)&v18);
      memcpy(dest, v15, v14);
    }
    dest = (void *)std::__format::__put_sign<long long>(a2, (*a1 >> 2) & 3, (char *)dest - 1);
    v16 = v28 - (_BYTE *)dest;
    std::string_view::basic_string_view(v27, (__int64)dest, v20 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v27[0],
             v27[1],
             v16,
             a3);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIyEEPKcRSt26basic_format_parse_contextIcE at 0x1bafc
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<unsigned long long>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIyNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1bb2a
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<unsigned long long,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        __int64 a2,
        __int64 a3)
{
  char v3; // al
  unsigned int v5; // eax
  const char *v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rdx
  __int64 v9; // rdx
  const char *v10; // rax
  __int64 v11; // rdx
  __int64 v13; // rax
  size_t v14; // rbx
  const void *v15; // rax
  __int64 v16; // rbx
  size_t v18; // [rsp+20h] [rbp-F0h] BYREF
  size_t v19; // [rsp+28h] [rbp-E8h]
  __int64 v20; // [rsp+30h] [rbp-E0h]
  __int64 v21; // [rsp+38h] [rbp-D8h]
  _BYTE v22[64]; // [rsp+43h] [rbp-CDh] BYREF
  _BYTE v23[5]; // [rsp+83h] [rbp-8Dh] BYREF
  size_t v24[2]; // [rsp+90h] [rbp-80h] BYREF
  size_t v25[2]; // [rsp+A0h] [rbp-70h] BYREF
  size_t v26[2]; // [rsp+B0h] [rbp-60h] BYREF
  _QWORD v27[3]; // [rsp+C0h] [rbp-50h] BYREF
  _BYTE *v28; // [rsp+D8h] [rbp-38h]
  _BYTE *v29; // [rsp+E0h] [rbp-30h]
  __int64 v30; // [rsp+E8h] [rbp-28h]
  _BYTE *i; // [rsp+F0h] [rbp-20h]
  void *dest; // [rsp+F8h] [rbp-18h]

  if ( (a1[1] & 0x78) == 0x38 )
  {
    v3 = std::__format::__formatter_int<char>::_S_to_character<unsigned long long>(a2);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v3,
             a3);
  }
  else
  {
    v20 = 0;
    v21 = 0;
    v18 = 0;
    v19 = 0;
    v30 = a2;
    dest = v22;
    v29 = v23;
    v28 = v22;
    v5 = (a1[1] >> 3) & 0xF;
    if ( v5 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v10 = "0x";
        else
          v10 = "0X";
        std::string_view::basic_string_view(v26, v10);
        v18 = v26[0];
        v19 = v26[1];
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v30, 16);
        v21 = v11;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v20; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v5 == 4 )
      {
        if ( a2 )
        {
          std::string_view::basic_string_view(v25, "0");
          v18 = v25[0];
          v19 = v25[1];
        }
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v30, 8);
        v21 = v9;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v5 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v6 = "0b";
          else
            v6 = "0B";
          std::string_view::basic_string_view(v24, v6);
          v18 = v24[0];
          v19 = v24[1];
          v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v30, 2);
          v21 = v7;
        }
      }
      else
      {
        v20 = std::__format::__formatter_int<char>::to_chars<unsigned long long>(dest, v29, v30, 10);
        v21 = v8;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v18) )
    {
      v13 = std::string_view::size((__int64)&v18);
      dest = (char *)dest - v13;
      v14 = std::string_view::size((__int64)&v18);
      v15 = (const void *)std::string_view::data((__int64)&v18);
      memcpy(dest, v15, v14);
    }
    dest = (void *)std::__format::__put_sign<unsigned long long>(a2, (*a1 >> 2) & 3, (char *)dest - 1);
    v16 = v28 - (_BYTE *)dest;
    std::string_view::basic_string_view(v27, (__int64)dest, v20 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v27[0],
             v27[1],
             v16,
             a3);
  }
}



================================================================================
Function: _ZZNSt8__format14__formatter_fpIcE5parseERSt26basic_format_parse_contextIcEENKUlvE_clEv at 0x1bf04
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(
        __int64 *a1)
{
  __int64 v1; // rdx
  __int64 result; // rax

  v1 = a1[1];
  result = *a1;
  *(_QWORD *)result = *(_QWORD *)v1;
  *(_DWORD *)(result + 8) = *(_DWORD *)(v1 + 8);
  return result;
}



================================================================================
Function: _ZZNSt8__format14__formatter_fpIcE5parseERSt26basic_format_parse_contextIcEENKUlvE0_clEv at 0x1bf2e
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(
        _QWORD **a1)
{
  if ( **a1 != *a1[1] && *(_BYTE *)**a1 != 125 )
    return 0;
  std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#1}::operator()(a1[2]);
  return 1;
}



================================================================================
Function: _ZNSt8__format14__formatter_fpIcE5parseERSt26basic_format_parse_contextIcE at 0x1bf88
================================================================================

_BYTE *__fastcall std::__format::__formatter_fp<char>::parse(__int64 a1, __int64 a2)
{
  int v3; // eax
  _QWORD *v4[4]; // [rsp+10h] [rbp-50h] BYREF
  _QWORD v5[2]; // [rsp+30h] [rbp-30h] BYREF
  _BYTE *v6; // [rsp+40h] [rbp-20h] BYREF
  _BYTE *v7; // [rsp+48h] [rbp-18h] BYREF
  __int64 v8; // [rsp+54h] [rbp-Ch] BYREF
  int v9; // [rsp+5Ch] [rbp-4h]

  v8 = 0;
  v9 = 32;
  v7 = (_BYTE *)std::basic_format_parse_context<char>::end(a2);
  v6 = (_BYTE *)std::basic_format_parse_context<char>::begin(a2);
  v5[0] = a1;
  v5[1] = &v8;
  v4[0] = &v6;
  v4[1] = &v7;
  v4[2] = v5;
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_fill_and_align((__int64)&v8, (__int64)v6, (__int64)v7);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_sign(&v8, v6, v7);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_alternate_form(&v8, v6, v7);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_zero_fill(&v8, v6, v7);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  if ( *v6 != 46 )
  {
    v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_width(&v8, v6, (__int64)v7, a2);
    if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
      return v6;
  }
  v6 = std::__format::_Spec<char>::_M_parse_precision((__int64)&v8, v6, v7, a2);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v6 = (_BYTE *)std::__format::_Spec<char>::_M_parse_locale(&v8, v6, v7);
  if ( (unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    return v6;
  v3 = (char)*v6;
  if ( v3 == 103 )
  {
    BYTE1(v8) = BYTE1(v8) & 0x87 | 0x38;
    ++v6;
  }
  else if ( v3 <= 103 )
  {
    switch ( v3 )
    {
      case 'f':
        BYTE1(v8) = BYTE1(v8) & 0x87 | 0x28;
        ++v6;
        break;
      case 'e':
        BYTE1(v8) = BYTE1(v8) & 0x87 | 0x18;
        ++v6;
        break;
      case 'a':
        BYTE1(v8) = BYTE1(v8) & 0x87 | 8;
        ++v6;
        break;
      default:
        if ( v3 <= 97 )
        {
          if ( v3 == 71 )
          {
            BYTE1(v8) = BYTE1(v8) & 0x87 | 0x40;
            ++v6;
          }
          else if ( v3 <= 71 )
          {
            switch ( v3 )
            {
              case 'F':
                BYTE1(v8) = BYTE1(v8) & 0x87 | 0x30;
                ++v6;
                break;
              case 'A':
                BYTE1(v8) = BYTE1(v8) & 0x87 | 0x10;
                ++v6;
                break;
              case 'E':
                BYTE1(v8) = BYTE1(v8) & 0x87 | 0x20;
                ++v6;
                break;
            }
          }
        }
        break;
    }
  }
  if ( !(unsigned __int8)std::__format::__formatter_fp<char>::parse(std::basic_format_parse_context<char> &)::{lambda(void)#2}::operator()(v4) )
    std::__format::__failed_to_parse_format_spec((std::__format *)v4);
  return v6;
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIfNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcSB_E_clESB_SB_ at 0x1c30a
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
        __int64 a1,
        char *a2,
        char *a3)
{
  if ( **(_BYTE **)a1 )
    return std::to_chars();
  if ( **(_DWORD **)(a1 + 16) )
    return std::to_chars();
  return std::to_chars(a2, a3, **(float **)(a1 + 8));
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIfNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcmE_clESB_m at 0x1c3c6
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
        __int64 *a1,
        __int64 a2,
        __int64 a3)
{
  __int64 *v3; // rbx
  __int64 v4; // rdx

  v3 = (__int64 *)a1[1];
  *v3 = std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          *a1,
          (char *)(a2 + 1),
          (char *)(a3 - 1 + a2));
  v3[1] = v4;
  if ( *(_DWORD *)(a1[1] + 8) )
    return 0;
  else
    return *(_QWORD *)a1[1] - a2;
}



================================================================================
Function: _ZNKSt8__format14__formatter_fpIcE6formatIfNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1c442
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        float a3)
{
  int v3; // eax
  __int64 v4; // rdx
  unsigned __int64 v5; // rax
  __int64 v6; // rbx
  __int64 first_not_of; // rax
  __int64 v9; // rax
  __int64 v10; // rax
  __int64 v11; // rbx
  __int64 v12; // rax
  __int64 v13; // rax
  __int64 v14; // rdx
  __int64 v15; // rdx
  unsigned __int64 v16; // rdx
  _QWORD *v17; // rax
  __int64 v18; // rdx
  unsigned __int64 v19; // rax
  __int64 v20; // rax
  __int64 v21; // rbx
  __int64 v22; // rax
  char *v23; // rax
  char v24; // al
  float x; // [rsp+14h] [rbp-24Ch] BYREF
  __int64 v27; // [rsp+18h] [rbp-248h]
  _QWORD v28[4]; // [rsp+20h] [rbp-240h] BYREF
  unsigned __int64 v29[2]; // [rsp+40h] [rbp-220h] BYREF
  _QWORD *v30; // [rsp+50h] [rbp-210h]
  __int64 *v31; // [rsp+58h] [rbp-208h]
  int exponent; // [rsp+64h] [rbp-1FCh] BYREF
  __int64 v33; // [rsp+68h] [rbp-1F8h]
  __int64 v34; // [rsp+70h] [rbp-1F0h] BYREF
  __int64 v35; // [rsp+78h] [rbp-1E8h]
  _QWORD v36[4]; // [rsp+80h] [rbp-1E0h] BYREF
  __int64 v37; // [rsp+A0h] [rbp-1C0h] BYREF
  unsigned __int64 v38; // [rsp+A8h] [rbp-1B8h]
  _QWORD v39[4]; // [rsp+B0h] [rbp-1B0h] BYREF
  int v40; // [rsp+D0h] [rbp-190h] BYREF
  bool v41; // [rsp+D7h] [rbp-189h] BYREF
  __int64 v42; // [rsp+D8h] [rbp-188h] BYREF
  __int64 v43; // [rsp+E0h] [rbp-180h] BYREF
  __int64 v44; // [rsp+E8h] [rbp-178h]
  _BYTE v45[7]; // [rsp+F1h] [rbp-16Fh] BYREF
  _QWORD v46[4]; // [rsp+170h] [rbp-F0h] BYREF
  _QWORD v47[2]; // [rsp+190h] [rbp-D0h] BYREF
  _QWORD v48[2]; // [rsp+1A0h] [rbp-C0h] BYREF
  _QWORD v49[2]; // [rsp+1B0h] [rbp-B0h] BYREF
  char v50[8]; // [rsp+1C0h] [rbp-A0h] BYREF
  __int64 v51; // [rsp+1C8h] [rbp-98h] BYREF
  int v52; // [rsp+1D0h] [rbp-90h]
  char v53; // [rsp+1D7h] [rbp-89h]
  __int64 *v54; // [rsp+1D8h] [rbp-88h]
  unsigned __int64 v55; // [rsp+1E0h] [rbp-80h]
  unsigned __int64 v56; // [rsp+1E8h] [rbp-78h]
  size_t v57; // [rsp+1F0h] [rbp-70h]
  unsigned int v58; // [rsp+1F8h] [rbp-68h]
  unsigned int v59; // [rsp+1FCh] [rbp-64h]
  char *v60; // [rsp+200h] [rbp-60h]
  unsigned __int64 v61; // [rsp+208h] [rbp-58h]
  size_t n; // [rsp+210h] [rbp-50h]
  __int64 v63; // [rsp+218h] [rbp-48h]
  unsigned __int8 v64; // [rsp+227h] [rbp-39h]
  char *i; // [rsp+228h] [rbp-38h]
  unsigned __int64 v66; // [rsp+230h] [rbp-30h]
  char v67; // [rsp+23Dh] [rbp-23h]
  char v68; // [rsp+23Eh] [rbp-22h]
  char v69; // [rsp+23Fh] [rbp-21h]
  char *v70; // [rsp+240h] [rbp-20h]
  char *v71; // [rsp+248h] [rbp-18h]

  v27 = a1;
  x = a3;
  std::string::basic_string(v46);
  v43 = 0;
  v44 = 0;
  v42 = 6;
  v41 = (*(_BYTE *)(a1 + 1) & 6) != 0;
  if ( v41 )
    v42 = std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
            v27,
            a2);
  v71 = v45;
  v70 = (char *)v46;
  v40 = 0;
  v69 = 0;
  v68 = 0;
  v67 = 101;
  v3 = (*(_BYTE *)(v27 + 1) >> 3) & 0xF;
  if ( v3 == 8 )
  {
    v69 = 1;
    v67 = 69;
LABEL_22:
    v68 = 1;
    v41 = 1;
    v40 = 3;
    goto LABEL_25;
  }
  if ( ((*(_BYTE *)(v27 + 1) >> 3) & 0xFu) > 8 )
    goto LABEL_25;
  switch ( v3 )
  {
    case 7:
      goto LABEL_22;
    case 6:
      v69 = 1;
      goto LABEL_20;
    case 5:
LABEL_20:
      v41 = 1;
      v40 = 2;
      goto LABEL_25;
    case 4:
      v69 = 1;
      v67 = 69;
      goto LABEL_18;
    case 3:
LABEL_18:
      v41 = 1;
      v40 = 1;
      goto LABEL_25;
    case 2:
      v69 = 1;
      v67 = 80;
LABEL_14:
      if ( (*(_BYTE *)(v27 + 1) & 0x78) != 0x10 )
        v67 = 112;
      v40 = 4;
      goto LABEL_25;
  }
  if ( ((*(_BYTE *)(v27 + 1) >> 3) & 0xF) != 0 )
    goto LABEL_14;
  if ( v41 )
    v40 = 3;
LABEL_25:
  v39[0] = &v41;
  v39[1] = &x;
  v39[2] = &v40;
  v39[3] = &v42;
  v43 = std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          (__int64)v39,
          v71,
          v70);
  v44 = v4;
  if ( (_DWORD)v4 == 75 )
  {
    v66 = v42 + 8;
    if ( v40 == 2 )
    {
      exponent = 0;
      frexpf(x, &exponent);
      if ( exponent > 0 )
        v66 += 4004 * exponent / 0x33F5u + 1;
    }
    if ( v66 <= 0x80 )
      v66 = 256;
    std::string::reserve(v46, v66);
    do
    {
      v30 = v39;
      v31 = &v43;
      v5 = std::string::capacity((__int64)v46);
      std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        v46,
        2 * v5,
        v30,
        v31);
      v71 = (char *)(std::string::data((__int64)v46) + 1);
      v6 = std::string::data((__int64)v46);
      v70 = (char *)(v6 + std::string::size((__int64)v46));
    }
    while ( (_DWORD)v44 == 75 );
  }
  if ( v69 )
  {
    for ( i = v71; i != (char *)v43; ++i )
      *i = toupper(*i);
  }
  v64 = 1;
  if ( x >= 0.0 )
  {
    if ( (*(_BYTE *)v27 & 0xC) == 4 )
    {
      *--v71 = 43;
    }
    else if ( (*(_BYTE *)v27 & 0xC) == 0xC )
    {
      *--v71 = 32;
    }
    else
    {
      v64 = 0;
    }
  }
  std::string_view::basic_string_view(&v37, (__int64)v71, v43 - (_QWORD)v71);
  if ( (*(_BYTE *)v27 & 0x10) != 0 && fabs(x) <= 3.4028235e38 )
  {
    v29[0] = v37;
    v29[1] = v38;
    n = 0;
    v60 = std::string_view::find(v29, 46, 0);
    if ( v60 == (char *)-1LL )
    {
      v61 = (unsigned __int64)std::string_view::find(v29, v67, 0);
      if ( v61 == -1 )
        v61 = std::string_view::size((__int64)v29);
      v60 = (char *)v61;
      v63 = v61 - v64;
    }
    else
    {
      v61 = (unsigned __int64)std::string_view::find(v29, v67, (unsigned __int64)(v60 + 1));
      if ( v61 == -1 )
        v61 = std::string_view::size((__int64)v29);
      if ( v68 )
      {
        if ( *(_BYTE *)std::string_view::operator[](v29, v64) == 48 )
        {
          first_not_of = std::string_view::find_first_not_of(v29, 48, v60 + 1);
          v63 = v61 - first_not_of;
        }
        else
        {
          v63 = v61 - v64 - 1;
        }
      }
    }
    if ( v68 && v42 )
      n = v42 - v63;
    v57 = (v60 == (char *)v61) + n;
    if ( v57 )
    {
      if ( std::string::empty((__int64)v46) && (unsigned __int64)&v70[-v43] >= v57 )
      {
        v9 = std::string_view::size((__int64)v29);
        memmove(&v71[v57 + v61], &v71[v61], v9 - v61);
        if ( v60 == (char *)v61 )
        {
          v10 = v61++;
          v71[v10] = 46;
        }
        memset(&v71[v61], 48, n);
        v11 = std::string_view::data((__int64)v29);
        v12 = std::string_view::size((__int64)v29);
        std::string_view::basic_string_view(v47, v11, v12 + v57);
        v37 = v47[0];
        v38 = v47[1];
      }
      else
      {
        v13 = std::string_view::size((__int64)v29);
        std::string::reserve(v46, v13 + v57);
        if ( std::string::empty((__int64)v46) )
        {
          v48[0] = std::string_view::substr(v29, 0, v61);
          v48[1] = v14;
          std::string::operator=<std::string_view>(v46, v48);
          if ( v60 == (char *)v61 )
            std::string::operator+=((__int64)v46, 46);
          if ( n )
            std::string::append((__int64)v46, n, 48);
          v49[0] = std::string_view::substr(v29, v61, -1);
          v49[1] = v15;
          std::string::append<std::string_view>((__int64)v46, v49);
        }
        else
        {
          std::string::insert(v46, v61, v57, 48);
          if ( v60 == (char *)v61 )
            *(_BYTE *)std::string::operator[](v46, v61) = 46;
        }
        v37 = std::string::operator std::string_view((__int64)v46);
        v38 = v16;
      }
    }
  }
  std::string::basic_string(v36);
  v34 = v37;
  v35 = v38;
  if ( (*(_BYTE *)v27 & 0x20) != 0 && fabs(x) <= 3.4028235e38 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(v50, a2);
    std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](v28, v27, v34, v35, (unsigned int)v67, v50);
    std::locale::~locale((std::locale *)v50);
    if ( !std::string::empty((__int64)v28) )
    {
      v17 = std::string::operator=(v36, v28);
      v34 = std::string::operator std::string_view((__int64)v17);
      v35 = v18;
    }
    std::string::~string((__int64)v28);
  }
  v56 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          v27,
          a2);
  v19 = std::string_view::size((__int64)&v34);
  if ( v19 < v56 )
  {
    v59 = *(_DWORD *)(v27 + 8);
    v58 = *(_BYTE *)v27 & 3;
    v22 = std::string_view::size((__int64)&v34);
    v55 = v56 - v22;
    v33 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    if ( !v58 )
    {
      v58 = 2;
      if ( (*(_BYTE *)v27 & 0x40) != 0 && fabs(x) <= 3.4028235e38 )
      {
        v59 = 48;
        v23 = (char *)std::string_view::operator[]((unsigned __int64 *)&v37, 0);
        if ( !std::__format::__is_xdigit((std::__format *)(unsigned int)*v23) )
        {
          v24 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v34, 0);
          v52 = 0;
          v51 = v33;
          v54 = &v51;
          v53 = v24;
          std::__format::_Sink<char>::_M_write(v33, (unsigned int)v24);
          std::string_view::remove_prefix(&v34, 1);
        }
      }
      else
      {
        v59 = 32;
      }
    }
    v21 = std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v33, v34, v35, v58, v55, v59);
  }
  else
  {
    v20 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    v21 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v20, v34, v35);
  }
  std::string::~string((__int64)v36);
  std::string::~string((__int64)v46);
  return v21;
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIdNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcSB_E_clESB_SB_ at 0x1d08c
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
        __int64 a1,
        char *a2,
        char *a3)
{
  if ( **(_BYTE **)a1 )
    return std::to_chars();
  if ( **(_DWORD **)(a1 + 16) )
    return std::to_chars();
  return std::to_chars(a2, a3, **(double **)(a1 + 8));
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIdNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcmE_clESB_m at 0x1d14e
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
        __int64 *a1,
        __int64 a2,
        __int64 a3)
{
  __int64 *v3; // rbx
  __int64 v4; // rdx

  v3 = (__int64 *)a1[1];
  *v3 = std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          *a1,
          (char *)(a2 + 1),
          (char *)(a3 - 1 + a2));
  v3[1] = v4;
  if ( *(_DWORD *)(a1[1] + 8) )
    return 0;
  else
    return *(_QWORD *)a1[1] - a2;
}



================================================================================
Function: _ZNKSt8__format14__formatter_fpIcE6formatIdNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1d1ca
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        double a3)
{
  int v3; // eax
  __int64 v4; // rdx
  unsigned __int64 v5; // rax
  __int64 v6; // rbx
  __int64 first_not_of; // rax
  __int64 v9; // rax
  __int64 v10; // rax
  __int64 v11; // rbx
  __int64 v12; // rax
  __int64 v13; // rax
  __int64 v14; // rdx
  __int64 v15; // rdx
  unsigned __int64 v16; // rdx
  _QWORD *v17; // rax
  __int64 v18; // rdx
  unsigned __int64 v19; // rax
  __int64 v20; // rax
  __int64 v21; // rbx
  __int64 v22; // rax
  char *v23; // rax
  char v24; // al
  double x; // [rsp+10h] [rbp-250h] BYREF
  __int64 v27; // [rsp+18h] [rbp-248h]
  _QWORD v28[4]; // [rsp+20h] [rbp-240h] BYREF
  unsigned __int64 v29[2]; // [rsp+40h] [rbp-220h] BYREF
  _QWORD *v30; // [rsp+50h] [rbp-210h]
  __int64 *v31; // [rsp+58h] [rbp-208h]
  int exponent; // [rsp+64h] [rbp-1FCh] BYREF
  __int64 v33; // [rsp+68h] [rbp-1F8h]
  __int64 v34; // [rsp+70h] [rbp-1F0h] BYREF
  __int64 v35; // [rsp+78h] [rbp-1E8h]
  _QWORD v36[4]; // [rsp+80h] [rbp-1E0h] BYREF
  __int64 v37; // [rsp+A0h] [rbp-1C0h] BYREF
  unsigned __int64 v38; // [rsp+A8h] [rbp-1B8h]
  _QWORD v39[4]; // [rsp+B0h] [rbp-1B0h] BYREF
  int v40; // [rsp+D0h] [rbp-190h] BYREF
  bool v41; // [rsp+D7h] [rbp-189h] BYREF
  __int64 v42; // [rsp+D8h] [rbp-188h] BYREF
  __int64 v43; // [rsp+E0h] [rbp-180h] BYREF
  __int64 v44; // [rsp+E8h] [rbp-178h]
  _BYTE v45[7]; // [rsp+F1h] [rbp-16Fh] BYREF
  _QWORD v46[4]; // [rsp+170h] [rbp-F0h] BYREF
  _QWORD v47[2]; // [rsp+190h] [rbp-D0h] BYREF
  _QWORD v48[2]; // [rsp+1A0h] [rbp-C0h] BYREF
  _QWORD v49[2]; // [rsp+1B0h] [rbp-B0h] BYREF
  char v50[8]; // [rsp+1C0h] [rbp-A0h] BYREF
  __int64 v51; // [rsp+1C8h] [rbp-98h] BYREF
  int v52; // [rsp+1D0h] [rbp-90h]
  char v53; // [rsp+1D7h] [rbp-89h]
  __int64 *v54; // [rsp+1D8h] [rbp-88h]
  unsigned __int64 v55; // [rsp+1E0h] [rbp-80h]
  unsigned __int64 v56; // [rsp+1E8h] [rbp-78h]
  size_t v57; // [rsp+1F0h] [rbp-70h]
  unsigned int v58; // [rsp+1F8h] [rbp-68h]
  unsigned int v59; // [rsp+1FCh] [rbp-64h]
  char *v60; // [rsp+200h] [rbp-60h]
  unsigned __int64 v61; // [rsp+208h] [rbp-58h]
  size_t n; // [rsp+210h] [rbp-50h]
  __int64 v63; // [rsp+218h] [rbp-48h]
  unsigned __int8 v64; // [rsp+227h] [rbp-39h]
  char *i; // [rsp+228h] [rbp-38h]
  unsigned __int64 v66; // [rsp+230h] [rbp-30h]
  char v67; // [rsp+23Dh] [rbp-23h]
  char v68; // [rsp+23Eh] [rbp-22h]
  char v69; // [rsp+23Fh] [rbp-21h]
  char *v70; // [rsp+240h] [rbp-20h]
  char *v71; // [rsp+248h] [rbp-18h]

  v27 = a1;
  x = a3;
  std::string::basic_string(v46);
  v43 = 0;
  v44 = 0;
  v42 = 6;
  v41 = (*(_BYTE *)(a1 + 1) & 6) != 0;
  if ( v41 )
    v42 = std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
            v27,
            a2);
  v71 = v45;
  v70 = (char *)v46;
  v40 = 0;
  v69 = 0;
  v68 = 0;
  v67 = 101;
  v3 = (*(_BYTE *)(v27 + 1) >> 3) & 0xF;
  if ( v3 == 8 )
  {
    v69 = 1;
    v67 = 69;
LABEL_22:
    v68 = 1;
    v41 = 1;
    v40 = 3;
    goto LABEL_25;
  }
  if ( ((*(_BYTE *)(v27 + 1) >> 3) & 0xFu) > 8 )
    goto LABEL_25;
  switch ( v3 )
  {
    case 7:
      goto LABEL_22;
    case 6:
      v69 = 1;
      goto LABEL_20;
    case 5:
LABEL_20:
      v41 = 1;
      v40 = 2;
      goto LABEL_25;
    case 4:
      v69 = 1;
      v67 = 69;
      goto LABEL_18;
    case 3:
LABEL_18:
      v41 = 1;
      v40 = 1;
      goto LABEL_25;
    case 2:
      v69 = 1;
      v67 = 80;
LABEL_14:
      if ( (*(_BYTE *)(v27 + 1) & 0x78) != 0x10 )
        v67 = 112;
      v40 = 4;
      goto LABEL_25;
  }
  if ( ((*(_BYTE *)(v27 + 1) >> 3) & 0xF) != 0 )
    goto LABEL_14;
  if ( v41 )
    v40 = 3;
LABEL_25:
  v39[0] = &v41;
  v39[1] = &x;
  v39[2] = &v40;
  v39[3] = &v42;
  v43 = std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          (__int64)v39,
          v71,
          v70);
  v44 = v4;
  if ( (_DWORD)v4 == 75 )
  {
    v66 = v42 + 8;
    if ( v40 == 2 )
    {
      exponent = 0;
      frexp(x, &exponent);
      if ( exponent > 0 )
        v66 += 4004 * exponent / 0x33F5u + 1;
    }
    if ( v66 <= 0x80 )
      v66 = 256;
    std::string::reserve(v46, v66);
    do
    {
      v30 = v39;
      v31 = &v43;
      v5 = std::string::capacity((__int64)v46);
      std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        v46,
        2 * v5,
        v30,
        v31);
      v71 = (char *)(std::string::data((__int64)v46) + 1);
      v6 = std::string::data((__int64)v46);
      v70 = (char *)(v6 + std::string::size((__int64)v46));
    }
    while ( (_DWORD)v44 == 75 );
  }
  if ( v69 )
  {
    for ( i = v71; i != (char *)v43; ++i )
      *i = toupper(*i);
  }
  v64 = 1;
  if ( (_mm_movemask_pd((__m128d)*(unsigned __int64 *)&x) & 1) == 0 )
  {
    if ( (*(_BYTE *)v27 & 0xC) == 4 )
    {
      *--v71 = 43;
    }
    else if ( (*(_BYTE *)v27 & 0xC) == 0xC )
    {
      *--v71 = 32;
    }
    else
    {
      v64 = 0;
    }
  }
  std::string_view::basic_string_view(&v37, (__int64)v71, v43 - (_QWORD)v71);
  if ( (*(_BYTE *)v27 & 0x10) != 0 && fabs(x) <= 1.797693134862316e308 )
  {
    v29[0] = v37;
    v29[1] = v38;
    n = 0;
    v60 = std::string_view::find(v29, 46, 0);
    if ( v60 == (char *)-1LL )
    {
      v61 = (unsigned __int64)std::string_view::find(v29, v67, 0);
      if ( v61 == -1 )
        v61 = std::string_view::size((__int64)v29);
      v60 = (char *)v61;
      v63 = v61 - v64;
    }
    else
    {
      v61 = (unsigned __int64)std::string_view::find(v29, v67, (unsigned __int64)(v60 + 1));
      if ( v61 == -1 )
        v61 = std::string_view::size((__int64)v29);
      if ( v68 )
      {
        if ( *(_BYTE *)std::string_view::operator[](v29, v64) == 48 )
        {
          first_not_of = std::string_view::find_first_not_of(v29, 48, v60 + 1);
          v63 = v61 - first_not_of;
        }
        else
        {
          v63 = v61 - v64 - 1;
        }
      }
    }
    if ( v68 && v42 )
      n = v42 - v63;
    v57 = (v60 == (char *)v61) + n;
    if ( v57 )
    {
      if ( std::string::empty((__int64)v46) && (unsigned __int64)&v70[-v43] >= v57 )
      {
        v9 = std::string_view::size((__int64)v29);
        memmove(&v71[v57 + v61], &v71[v61], v9 - v61);
        if ( v60 == (char *)v61 )
        {
          v10 = v61++;
          v71[v10] = 46;
        }
        memset(&v71[v61], 48, n);
        v11 = std::string_view::data((__int64)v29);
        v12 = std::string_view::size((__int64)v29);
        std::string_view::basic_string_view(v47, v11, v12 + v57);
        v37 = v47[0];
        v38 = v47[1];
      }
      else
      {
        v13 = std::string_view::size((__int64)v29);
        std::string::reserve(v46, v13 + v57);
        if ( std::string::empty((__int64)v46) )
        {
          v48[0] = std::string_view::substr(v29, 0, v61);
          v48[1] = v14;
          std::string::operator=<std::string_view>(v46, v48);
          if ( v60 == (char *)v61 )
            std::string::operator+=((__int64)v46, 46);
          if ( n )
            std::string::append((__int64)v46, n, 48);
          v49[0] = std::string_view::substr(v29, v61, -1);
          v49[1] = v15;
          std::string::append<std::string_view>((__int64)v46, v49);
        }
        else
        {
          std::string::insert(v46, v61, v57, 48);
          if ( v60 == (char *)v61 )
            *(_BYTE *)std::string::operator[](v46, v61) = 46;
        }
        v37 = std::string::operator std::string_view((__int64)v46);
        v38 = v16;
      }
    }
  }
  std::string::basic_string(v36);
  v34 = v37;
  v35 = v38;
  if ( (*(_BYTE *)v27 & 0x20) != 0 && fabs(x) <= 1.797693134862316e308 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(v50, a2);
    std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](v28, v27, v34, v35, (unsigned int)v67, v50);
    std::locale::~locale((std::locale *)v50);
    if ( !std::string::empty((__int64)v28) )
    {
      v17 = std::string::operator=(v36, v28);
      v34 = std::string::operator std::string_view((__int64)v17);
      v35 = v18;
    }
    std::string::~string((__int64)v28);
  }
  v56 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          v27,
          a2);
  v19 = std::string_view::size((__int64)&v34);
  if ( v19 < v56 )
  {
    v59 = *(_DWORD *)(v27 + 8);
    v58 = *(_BYTE *)v27 & 3;
    v22 = std::string_view::size((__int64)&v34);
    v55 = v56 - v22;
    v33 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    if ( !v58 )
    {
      v58 = 2;
      if ( (*(_BYTE *)v27 & 0x40) != 0 && fabs(x) <= 1.797693134862316e308 )
      {
        v59 = 48;
        v23 = (char *)std::string_view::operator[]((unsigned __int64 *)&v37, 0);
        if ( !std::__format::__is_xdigit((std::__format *)(unsigned int)*v23) )
        {
          v24 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v34, 0);
          v52 = 0;
          v51 = v33;
          v54 = &v51;
          v53 = v24;
          std::__format::_Sink<char>::_M_write(v33, (unsigned int)v24);
          std::string_view::remove_prefix(&v34, 1);
        }
      }
      else
      {
        v59 = 32;
      }
    }
    v21 = std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v33, v34, v35, v58, v55, v59);
  }
  else
  {
    v20 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    v21 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v20, v34, v35);
  }
  std::string::~string((__int64)v36);
  std::string::~string((__int64)v46);
  return v21;
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIeNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcSB_E_clESB_SB_ at 0x1de20
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
        __int64 a1,
        char *a2,
        char *a3)
{
  if ( **(_BYTE **)a1 )
    return std::to_chars();
  if ( **(_DWORD **)(a1 + 16) )
    return std::to_chars();
  return std::to_chars(a2, a3, *(long double *)*(_QWORD *)(a1 + 8));
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIeNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcmE_clESB_m at 0x1def4
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
        __int64 *a1,
        __int64 a2,
        __int64 a3)
{
  __int64 *v3; // rbx
  __int64 v4; // rdx

  v3 = (__int64 *)a1[1];
  *v3 = std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          *a1,
          (char *)(a2 + 1),
          (char *)(a3 - 1 + a2));
  v3[1] = v4;
  if ( *(_DWORD *)(a1[1] + 8) )
    return 0;
  else
    return *(_QWORD *)a1[1] - a2;
}



================================================================================
Function: _ZNKSt8__format14__formatter_fpIcE6formatIeNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1df70
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        long double x)
{
  int v7; // eax
  __int64 v8; // rdx
  unsigned __int64 v9; // rax
  __int64 v10; // rbx
  __int16 v11; // fps
  __int64 first_not_of; // rax
  __int64 v15; // rax
  __int64 v16; // rax
  __int64 v17; // rbx
  __int64 v18; // rax
  __int64 v19; // rax
  __int64 v20; // rdx
  __int64 v21; // rdx
  unsigned __int64 v22; // rdx
  _QWORD *v23; // rax
  __int64 v24; // rdx
  unsigned __int64 v25; // rax
  __int64 v26; // rax
  __int64 v27; // rbx
  __int64 v28; // rax
  char *v29; // rax
  char v30; // al
  _QWORD v32[4]; // [rsp+20h] [rbp-240h] BYREF
  unsigned __int64 v33[4]; // [rsp+40h] [rbp-220h] BYREF
  int exponent; // [rsp+64h] [rbp-1FCh] BYREF
  __int64 v35; // [rsp+68h] [rbp-1F8h]
  __int64 v36; // [rsp+70h] [rbp-1F0h] BYREF
  __int64 v37; // [rsp+78h] [rbp-1E8h]
  _QWORD v38[4]; // [rsp+80h] [rbp-1E0h] BYREF
  __int64 v39; // [rsp+A0h] [rbp-1C0h] BYREF
  unsigned __int64 v40; // [rsp+A8h] [rbp-1B8h]
  _QWORD v41[4]; // [rsp+B0h] [rbp-1B0h] BYREF
  int v42; // [rsp+D0h] [rbp-190h] BYREF
  bool v43; // [rsp+D7h] [rbp-189h] BYREF
  __int64 v44; // [rsp+D8h] [rbp-188h] BYREF
  __int64 v45; // [rsp+E0h] [rbp-180h] BYREF
  __int64 v46; // [rsp+E8h] [rbp-178h]
  _BYTE v47[7]; // [rsp+F1h] [rbp-16Fh] BYREF
  _QWORD v48[4]; // [rsp+170h] [rbp-F0h] BYREF
  _QWORD v49[2]; // [rsp+190h] [rbp-D0h] BYREF
  _QWORD v50[2]; // [rsp+1A0h] [rbp-C0h] BYREF
  _QWORD v51[2]; // [rsp+1B0h] [rbp-B0h] BYREF
  char v52[8]; // [rsp+1C0h] [rbp-A0h] BYREF
  __int64 v53; // [rsp+1C8h] [rbp-98h] BYREF
  int v54; // [rsp+1D0h] [rbp-90h]
  char v55; // [rsp+1D7h] [rbp-89h]
  __int64 *v56; // [rsp+1D8h] [rbp-88h]
  unsigned __int64 v57; // [rsp+1E0h] [rbp-80h]
  unsigned __int64 v58; // [rsp+1E8h] [rbp-78h]
  size_t v59; // [rsp+1F0h] [rbp-70h]
  unsigned int v60; // [rsp+1F8h] [rbp-68h]
  unsigned int v61; // [rsp+1FCh] [rbp-64h]
  char *v62; // [rsp+200h] [rbp-60h]
  unsigned __int64 v63; // [rsp+208h] [rbp-58h]
  size_t n; // [rsp+210h] [rbp-50h]
  __int64 v65; // [rsp+218h] [rbp-48h]
  unsigned __int8 v66; // [rsp+227h] [rbp-39h]
  char *i; // [rsp+228h] [rbp-38h]
  unsigned __int64 v68; // [rsp+230h] [rbp-30h]
  char v69; // [rsp+23Dh] [rbp-23h]
  char v70; // [rsp+23Eh] [rbp-22h]
  char v71; // [rsp+23Fh] [rbp-21h]
  char *v72; // [rsp+240h] [rbp-20h]
  char *v73; // [rsp+248h] [rbp-18h]

  std::string::basic_string(v48);
  v45 = 0;
  v46 = 0;
  v44 = 6;
  v43 = (*(_BYTE *)(a1 + 1) & 6) != 0;
  if ( v43 )
    v44 = std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
            a1,
            a2);
  v73 = v47;
  v72 = (char *)v48;
  v42 = 0;
  v71 = 0;
  v70 = 0;
  v69 = 101;
  v7 = (*(_BYTE *)(a1 + 1) >> 3) & 0xF;
  if ( v7 == 8 )
  {
    v71 = 1;
    v69 = 69;
LABEL_22:
    v70 = 1;
    v43 = 1;
    v42 = 3;
    goto LABEL_25;
  }
  if ( ((*(_BYTE *)(a1 + 1) >> 3) & 0xFu) > 8 )
    goto LABEL_25;
  switch ( v7 )
  {
    case 7:
      goto LABEL_22;
    case 6:
      v71 = 1;
      goto LABEL_20;
    case 5:
LABEL_20:
      v43 = 1;
      v42 = 2;
      goto LABEL_25;
    case 4:
      v71 = 1;
      v69 = 69;
      goto LABEL_18;
    case 3:
LABEL_18:
      v43 = 1;
      v42 = 1;
      goto LABEL_25;
    case 2:
      v71 = 1;
      v69 = 80;
LABEL_14:
      if ( (*(_BYTE *)(a1 + 1) & 0x78) != 0x10 )
        v69 = 112;
      v42 = 4;
      goto LABEL_25;
  }
  if ( ((*(_BYTE *)(a1 + 1) >> 3) & 0xF) != 0 )
    goto LABEL_14;
  if ( v43 )
    v42 = 3;
LABEL_25:
  v41[0] = &v43;
  v41[1] = &x;
  v41[2] = &v42;
  v41[3] = &v44;
  v45 = std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,char *)#1}::operator()(
          (__int64)v41,
          v73,
          v72);
  v46 = v8;
  if ( (_DWORD)v8 == 75 )
  {
    v68 = v44 + 8;
    if ( v42 == 2 )
    {
      exponent = 0;
      frexpl(x, &exponent);
      if ( exponent > 0 )
        v68 += 4004 * exponent / 0x33F5u + 1;
    }
    if ( v68 <= 0x80 )
      v68 = 256;
    std::string::reserve(v48, v68);
    do
    {
      v33[2] = (unsigned __int64)v41;
      v33[3] = (unsigned __int64)&v45;
      v9 = std::string::capacity((__int64)v48);
      std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        v48,
        2 * v9,
        v41,
        &v45);
      v73 = (char *)(std::string::data((__int64)v48) + 1);
      v10 = std::string::data((__int64)v48);
      v72 = (char *)(v10 + std::string::size((__int64)v48));
    }
    while ( (_DWORD)v46 == 75 );
  }
  if ( v71 )
  {
    for ( i = v73; i != (char *)v45; ++i )
      *i = toupper(*i);
  }
  v66 = 1;
  _FST7 = x;
  __asm { fxam }
  if ( (v11 & 0x200) == 0 )
  {
    if ( (*(_BYTE *)a1 & 0xC) == 4 )
    {
      *--v73 = 43;
    }
    else if ( (*(_BYTE *)a1 & 0xC) == 0xC )
    {
      *--v73 = 32;
    }
    else
    {
      v66 = 0;
    }
  }
  std::string_view::basic_string_view(&v39, (__int64)v73, v45 - (_QWORD)v73);
  if ( (*(_BYTE *)a1 & 0x10) != 0 && fabs(x) <= 1.189731495357231765e4932 )
  {
    v33[0] = v39;
    v33[1] = v40;
    n = 0;
    v62 = std::string_view::find(v33, 46, 0);
    if ( v62 == (char *)-1LL )
    {
      v63 = (unsigned __int64)std::string_view::find(v33, v69, 0);
      if ( v63 == -1 )
        v63 = std::string_view::size((__int64)v33);
      v62 = (char *)v63;
      v65 = v63 - v66;
    }
    else
    {
      v63 = (unsigned __int64)std::string_view::find(v33, v69, (unsigned __int64)(v62 + 1));
      if ( v63 == -1 )
        v63 = std::string_view::size((__int64)v33);
      if ( v70 )
      {
        if ( *(_BYTE *)std::string_view::operator[](v33, v66) == 48 )
        {
          first_not_of = std::string_view::find_first_not_of(v33, 48, v62 + 1);
          v65 = v63 - first_not_of;
        }
        else
        {
          v65 = v63 - v66 - 1;
        }
      }
    }
    if ( v70 && v44 )
      n = v44 - v65;
    v59 = (v62 == (char *)v63) + n;
    if ( v59 )
    {
      if ( std::string::empty((__int64)v48) && (unsigned __int64)&v72[-v45] >= v59 )
      {
        v15 = std::string_view::size((__int64)v33);
        memmove(&v73[v59 + v63], &v73[v63], v15 - v63);
        if ( v62 == (char *)v63 )
        {
          v16 = v63++;
          v73[v16] = 46;
        }
        memset(&v73[v63], 48, n);
        v17 = std::string_view::data((__int64)v33);
        v18 = std::string_view::size((__int64)v33);
        std::string_view::basic_string_view(v49, v17, v18 + v59);
        v39 = v49[0];
        v40 = v49[1];
      }
      else
      {
        v19 = std::string_view::size((__int64)v33);
        std::string::reserve(v48, v19 + v59);
        if ( std::string::empty((__int64)v48) )
        {
          v50[0] = std::string_view::substr(v33, 0, v63);
          v50[1] = v20;
          std::string::operator=<std::string_view>(v48, v50);
          if ( v62 == (char *)v63 )
            std::string::operator+=((__int64)v48, 46);
          if ( n )
            std::string::append((__int64)v48, n, 48);
          v51[0] = std::string_view::substr(v33, v63, -1);
          v51[1] = v21;
          std::string::append<std::string_view>((__int64)v48, v51);
        }
        else
        {
          std::string::insert(v48, v63, v59, 48);
          if ( v62 == (char *)v63 )
            *(_BYTE *)std::string::operator[](v48, v63) = 46;
        }
        v39 = std::string::operator std::string_view((__int64)v48);
        v40 = v22;
      }
    }
  }
  std::string::basic_string(v38);
  v36 = v39;
  v37 = v40;
  if ( (*(_BYTE *)a1 & 0x20) != 0 && fabs(x) <= 1.189731495357231765e4932 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(v52, a2);
    std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](v32, a1, v36, v37, (unsigned int)v69, v52);
    std::locale::~locale((std::locale *)v52);
    if ( !std::string::empty((__int64)v32) )
    {
      v23 = std::string::operator=(v38, v32);
      v36 = std::string::operator std::string_view((__int64)v23);
      v37 = v24;
    }
    std::string::~string((__int64)v32);
  }
  v58 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          a1,
          a2);
  v25 = std::string_view::size((__int64)&v36);
  if ( v25 < v58 )
  {
    v61 = *(_DWORD *)(a1 + 8);
    v60 = *(_BYTE *)a1 & 3;
    v28 = std::string_view::size((__int64)&v36);
    v57 = v58 - v28;
    v35 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    if ( !v60 )
    {
      v60 = 2;
      if ( (*(_BYTE *)a1 & 0x40) != 0 && fabs(x) <= 1.189731495357231765e4932 )
      {
        v61 = 48;
        v29 = (char *)std::string_view::operator[]((unsigned __int64 *)&v39, 0);
        if ( !std::__format::__is_xdigit((std::__format *)(unsigned int)*v29) )
        {
          v30 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v36, 0);
          v54 = 0;
          v53 = v35;
          v56 = &v53;
          v55 = v30;
          std::__format::_Sink<char>::_M_write(v35, (unsigned int)v30);
          std::string_view::remove_prefix(&v36, 1);
        }
      }
      else
      {
        v61 = 32;
      }
    }
    v27 = std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v35, v36, v37, v60, v57, v61);
  }
  else
  {
    v26 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a2);
    v27 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v26, v36, v37);
  }
  std::string::~string((__int64)v38);
  std::string::~string((__int64)v48);
  return v27;
}



================================================================================
Function: _ZZNKSt8__format15__formatter_strIcE6formatINS_10_Sink_iterIcEEEET_St17basic_string_viewIcSt11char_traitsIcEERSt20basic_format_contextIS5_cEENKUlvE_clEv at 0x1eb8c
================================================================================

__int64 __fastcall std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(std::string_view,std::basic_format_context<std::__format::_Sink_iter<char>,char> &)const::{lambda(void)#1}::operator()(
        __int64 *a1)
{
  __int64 *v1; // rbx
  __int64 v2; // rax
  __int64 v4; // rax

  v1 = (__int64 *)a1[2];
  if ( (*(_BYTE *)(*a1 + 1) & 0x78) == 0x78 )
  {
    v2 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a1[1]);
    return std::__format::__write_escaped<char,std::__format::_Sink_iter<char>>(v2, *v1, v1[1], 12);
  }
  else
  {
    v4 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out(a1[1]);
    return std::__format::__write<std::__format::_Sink_iter<char>,char>(v4, *v1, v1[1]);
  }
}



================================================================================
Function: _ZNKSt8__format15__formatter_strIcE6formatINS_10_Sink_iterIcEEEET_St17basic_string_viewIcSt11char_traitsIcEERSt20basic_format_contextIS5_cE at 0x1ec1a
================================================================================

__int64 __fastcall std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(
        _WORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v4; // rbx
  unsigned __int64 v5; // rax
  __int64 v7; // rdx
  __int64 v8; // rbx
  __int64 v9; // rdx
  __int64 v10; // rax
  __int64 v12; // [rsp+0h] [rbp-240h] BYREF
  __int64 v13; // [rsp+8h] [rbp-238h]
  __int64 v14; // [rsp+10h] [rbp-230h]
  _WORD *v15; // [rsp+18h] [rbp-228h]
  _QWORD v16[2]; // [rsp+20h] [rbp-220h] BYREF
  _QWORD v17[2]; // [rsp+30h] [rbp-210h] BYREF
  _QWORD v18[4]; // [rsp+40h] [rbp-200h] BYREF
  __int64 v19; // [rsp+60h] [rbp-1E0h] BYREF
  _QWORD v20[4]; // [rsp+160h] [rbp-E0h] BYREF
  __int64 v21[4]; // [rsp+180h] [rbp-C0h] BYREF
  _QWORD v22[2]; // [rsp+1A0h] [rbp-A0h] BYREF
  _QWORD v23[4]; // [rsp+1B0h] [rbp-90h] BYREF
  __int64 v24; // [rsp+1D0h] [rbp-70h] BYREF
  __int64 v25; // [rsp+1D8h] [rbp-68h]
  _QWORD *v26; // [rsp+1E8h] [rbp-58h]
  _QWORD *v27; // [rsp+1F0h] [rbp-50h]
  _QWORD *v28; // [rsp+1F8h] [rbp-48h]
  _QWORD *v29; // [rsp+200h] [rbp-40h]
  _QWORD *v30; // [rsp+208h] [rbp-38h]
  __int64 v31; // [rsp+210h] [rbp-30h]
  unsigned __int64 v32; // [rsp+218h] [rbp-28h]
  char v33; // [rsp+227h] [rbp-19h]
  __int64 v34; // [rsp+228h] [rbp-18h]

  v15 = a1;
  v12 = a2;
  v13 = a3;
  v14 = a4;
  v33 = 12;
  v21[0] = (__int64)a1;
  v21[1] = a4;
  v21[2] = (__int64)&v12;
  if ( (*a1 & 0x180) == 0 && (*((_BYTE *)v15 + 1) & 6) == 0 )
    return std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(std::string_view,std::basic_format_context<std::__format::_Sink_iter<char>,char> &)const::{lambda(void)#1}::operator()(v21);
  v34 = (*((_BYTE *)v15 + 1) & 6) != 0
      ? std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          v15,
          v14)
      : -1LL;
  v32 = std::__format::__formatter_str<char>::_S_trunc(&v12, v34);
  v5 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
         v15,
         v14);
  if ( v32 >= v5 && (*((_BYTE *)v15 + 1) & 6) == 0 )
    return std::__format::__formatter_str<char>::format<std::__format::_Sink_iter<char>>(std::string_view,std::basic_format_context<std::__format::_Sink_iter<char>,char> &)const::{lambda(void)#1}::operator()(v21);
  if ( (*((_BYTE *)v15 + 1) & 0x78) != 0x78 )
    return std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v12, v13, v32, v14, v15, 1);
  v27 = v18;
  std::span<char,18446744073709551615ul>::span<256ul>(&v24, (__int64)&v19);
  v26 = v18;
  v16[0] = v24;
  v16[1] = v25;
  v18[0] = &off_37918;
  v18[1] = v24;
  v18[2] = v25;
  v18[3] = std::span<char,18446744073709551615ul>::begin((__int64)v16);
  *v27 = &off_378F0;
  v18[0] = off_377B8;
  std::string::basic_string(v20);
  v30 = v18;
  v29 = v18;
  v28 = v18;
  v23[3] = v18;
  std::__format::__write_escaped<char,std::__format::_Sink_iter<char>>(v18, v12, v13, 12);
  v22[0] = std::__format::_Seq_sink<std::string>::view(v18);
  v22[1] = v7;
  v8 = std::span<char,18446744073709551615ul>::size((__int64)v22);
  v23[0] = std::__format::_Seq_sink<std::string>::view(v18);
  v23[1] = v9;
  v10 = std::span<char,18446744073709551615ul>::data((__int64)v23);
  std::string_view::basic_string_view(v17, v10, v8);
  v31 = std::__format::__formatter_str<char>::_S_trunc(v17, v34);
  v4 = std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(v17[0], v17[1], v31, v14, v15, 1);
  std::__format::_Seq_sink<std::string>::~_Seq_sink(v18);
  return v4;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE18_M_parse_zero_fillEPKcS3_ at 0x1efb8
================================================================================

_BYTE *__fastcall std::__format::_Spec<char>::_M_parse_zero_fill(_BYTE *a1, _BYTE *a2)
{
  _BYTE *v3; // [rsp+8h] [rbp-10h]

  v3 = a2;
  if ( *a2 == 48 )
  {
    *a1 |= 0x40u;
    return a2 + 1;
  }
  return v3;
}



================================================================================
Function: _ZNKSt8__format5_SpecIcE12_M_get_widthISt20basic_format_contextINS_10_Sink_iterIcEEcEEEmRT_ at 0x1efee
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        _WORD *a1,
        _QWORD *a2)
{
  _BYTE v3[40]; // [rsp+10h] [rbp-30h] BYREF
  __int64 v4; // [rsp+38h] [rbp-8h]

  v4 = 0;
  if ( (*a1 & 0x180) == 0x80 )
    return (unsigned __int16)a1[2];
  if ( (*a1 & 0x180) == 0x100 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::arg((__int64)v3, a2, (unsigned __int16)a1[2]);
    return std::__format::__int_from_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(v3);
  }
  return v4;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEE13remove_prefixEm at 0x1f072
================================================================================

unsigned __int64 *__fastcall std::string_view::remove_prefix(unsigned __int64 *a1, unsigned __int64 a2)
{
  unsigned __int64 *result; // rax

  if ( *a1 < a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/string_view",
      301,
      "constexpr void std::basic_string_view<_CharT, _Traits>::remove_prefix(size_type) [with _CharT = char; _Traits = st"
      "d::char_traits<char>; size_type = long unsigned int]",
      "this->_M_len >= __n");
  a1[1] += a2;
  result = a1;
  *a1 -= a2;
  return result;
}



================================================================================
Function: _ZZNSt8__format14__write_paddedINS_10_Sink_iterIcEEcEET_S3_St17basic_string_viewIT0_St11char_traitsIS5_EENS_6_AlignEmDiENKUlmRS2_E_clEmSA_ at 0x1f0ee
================================================================================

void __fastcall std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(std::__format::_Sink_iter<char>,std::string_view,std::__format::_Align,unsigned long,char32_t)::{lambda(unsigned long,std::__format::_Sink_iter<char>&)#1}::operator()(
        __int64 **a1,
        unsigned __int64 a2,
        __int64 *a3)
{
  __int64 v3; // rax
  __int64 v4; // rdx
  unsigned __int64 v6; // [rsp+10h] [rbp-20h]

  v6 = a2;
  if ( a2 )
  {
    while ( std::string_view::size((__int64)*a1) < v6 )
    {
      *a3 = std::__format::__write<std::__format::_Sink_iter<char>,char>(*a3, **a1, (*a1)[1]);
      v6 -= std::string_view::size((__int64)*a1);
    }
    if ( v6 )
    {
      v3 = std::string_view::substr(*a1, 0, v6);
      *a3 = std::__format::__write<std::__format::_Sink_iter<char>,char>(*a3, v3, v4);
    }
  }
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIcRA1_KDiEC2ES3_ at 0x1f1ba
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_Utf_view(_QWORD *a1, __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIcRA1_KDiE8_M_beginIPS1_S6_EEDaT_T0_ at 0x1f1e0
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_M_begin<char32_t const*,char32_t const*>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_Utf_iterator(
    a1,
    a3,
    a3,
    a4,
    a5,
    a6,
    a4,
    a3,
    a2);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIcRA1_KDiE5beginEv at 0x1f21a
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char,char32_t const(&)[1]>::begin(__int64 a1, __int64 *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  __int64 v4; // r8
  __int64 v5; // r9

  v2 = std::ranges::__access::_End::operator()<char32_t const(&)[1]>((__int64)&std::ranges::_Cpo::end, *a2);
  v3 = std::ranges::__access::_Begin::operator()<char32_t const(&)[1]>((__int64)&std::ranges::_Cpo::begin, *a2);
  std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_M_begin<char32_t const*,char32_t const*>(
    a1,
    (__int64)a2,
    v3,
    v2,
    v4,
    v5);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIcRA1_KDiE6_M_endIPS1_S6_EEDaT_T0_ at 0x1f286
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_M_end<char32_t const*,char32_t const*>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_Utf_iterator(
    a1,
    a3,
    a4,
    a4,
    a5,
    a6,
    a4,
    a3,
    a2);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIcRA1_KDiE3endEv at 0x1f2c0
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char,char32_t const(&)[1]>::end(__int64 a1, __int64 *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax
  __int64 v4; // r8
  __int64 v5; // r9

  v2 = std::ranges::__access::_End::operator()<char32_t const(&)[1]>((__int64)&std::ranges::_Cpo::end, *a2);
  v3 = std::ranges::__access::_Begin::operator()<char32_t const(&)[1]>((__int64)&std::ranges::_Cpo::begin, *a2);
  std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_M_end<char32_t const*,char32_t const*>(
    a1,
    (__int64)a2,
    v3,
    v2,
    v4,
    v5);
  return a1;
}



================================================================================
Function: _ZNSt8__format14__write_paddedINS_10_Sink_iterIcEEcEET_S3_St17basic_string_viewIT0_St11char_traitsIS5_EENS_6_AlignEmDi at 0x1f32b
================================================================================

__int64 __fastcall std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        int a4,
        unsigned __int64 a5,
        unsigned int a6)
{
  int v6; // r8d
  int v7; // r9d
  __int64 v8; // rdx
  __int64 v11; // rbx
  __int64 j; // [rsp+28h] [rbp-118h] BYREF
  _BYTE v18[40]; // [rsp+30h] [rbp-110h] BYREF
  __int64 v19; // [rsp+58h] [rbp-E8h] BYREF
  unsigned int v20; // [rsp+64h] [rbp-DCh] BYREF
  __int64 *v21; // [rsp+68h] [rbp-D8h] BYREF
  __int64 v22; // [rsp+70h] [rbp-D0h] BYREF
  __int64 i; // [rsp+78h] [rbp-C8h]
  _BYTE v24[47]; // [rsp+80h] [rbp-C0h] BYREF
  char v25; // [rsp+AFh] [rbp-91h] BYREF
  __int64 v26[6]; // [rsp+B0h] [rbp-90h] BYREF
  __int64 v27[4]; // [rsp+E0h] [rbp-60h] BYREF
  __int64 v28; // [rsp+100h] [rbp-40h]
  char *v29; // [rsp+108h] [rbp-38h]
  __int64 v30; // [rsp+110h] [rbp-30h]
  size_t v31; // [rsp+118h] [rbp-28h]
  unsigned __int64 v32; // [rsp+120h] [rbp-20h]
  unsigned __int64 v33; // [rsp+128h] [rbp-18h]

  j = a1;
  v30 = 32;
  v24[0] = 0;
  std::string_view::basic_string_view(&v22, (__int64)v24, 32);
  v21 = &v22;
  if ( a4 == 3 )
  {
    v33 = a5 >> 1;
    v32 = (a5 & 1) + (a5 >> 1);
    v31 = v32;
  }
  else
  {
    if ( a4 == 2 )
    {
      v33 = a5;
      v32 = 0;
    }
    else
    {
      v33 = 0;
      v32 = a5;
    }
    v31 = a5;
  }
  if ( (unsigned __int8)std::__unicode::__is_single_code_unit<char>(a6) != 1 )
  {
    v20 = a6;
    std::__unicode::_Utf_view<char,char32_t const(&)[1]>::_Utf_view(&v19, (__int64)&v20);
    v29 = &v25;
    std::__unicode::_Utf_view<char,char32_t const(&)[1]>::end((__int64)v26, &v19);
    std::__unicode::_Utf_view<char,char32_t const(&)[1]>::begin((__int64)v27, &v19);
    std::string::basic_string<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,void>(
      (unsigned int)v18,
      (unsigned int)&v25,
      (unsigned int)v18,
      v28,
      v6,
      v7,
      v27[0],
      v27[1],
      v27[2],
      v27[3],
      v28,
      v26[0],
      v26[1],
      v26[2],
      v26[3],
      v26[4]);
    v22 = std::string::operator std::string_view((__int64)v18);
    for ( i = v8; v33--; j = std::__format::__write<std::__format::_Sink_iter<char>,char>(j, v22, i) )
      ;
    for ( j = std::__format::__write<std::__format::_Sink_iter<char>,char>(j, a2, a3);
          v32--;
          j = std::__format::__write<std::__format::_Sink_iter<char>,char>(j, v22, i) )
    {
      ;
    }
    v11 = j;
    std::string::~string((__int64)v18);
  }
  else
  {
    if ( v31 > 0x1F )
      v31 = 32;
    else
      std::string_view::remove_suffix((unsigned __int64 *)&v22, 32 - v31);
    std::char_traits<char>::assign(v24, v31, a6);
    std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(std::__format::_Sink_iter<char>,std::string_view,std::__format::_Align,unsigned long,char32_t)::{lambda(unsigned long,std::__format::_Sink_iter<char>&)#1}::operator()(
      &v21,
      v33,
      &j);
    j = std::__format::__write<std::__format::_Sink_iter<char>,char>(j, a2, a3);
    std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(std::__format::_Sink_iter<char>,std::string_view,std::__format::_Align,unsigned long,char32_t)::{lambda(unsigned long,std::__format::_Sink_iter<char>&)#1}::operator()(
      &v21,
      v32,
      &j);
    return j;
  }
  return v11;
}



================================================================================
Function: _ZNSt8__format22__write_padded_as_specIcNS_10_Sink_iterIcEEEET0_St17basic_string_viewINSt13type_identityIT_E4typeESt11char_traitsIS8_EEmRSt20basic_format_contextIS3_S6_ERKNS_5_SpecIS6_EENS_6_AlignE at 0x1f6f8
================================================================================

__int64 __fastcall std::__format::__write_padded_as_spec<char,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        unsigned __int64 a3,
        _QWORD *a4,
        __int64 a5,
        int a6)
{
  __int64 v6; // rax
  unsigned int v8; // ebx
  __int64 v9; // rax
  unsigned __int64 v14; // [rsp+38h] [rbp-18h]

  v14 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          (_WORD *)a5,
          a4);
  if ( a3 < v14 )
  {
    if ( (*(_BYTE *)a5 & 3) != 0 )
      a6 = *(_BYTE *)a5 & 3;
    v8 = *(_DWORD *)(a5 + 8);
    v9 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)a4);
    return std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v9, a1, a2, a6, v14 - a3, v8);
  }
  else
  {
    v6 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)a4);
    return std::__format::__write<std::__format::_Sink_iter<char>,char>(v6, a1, a2);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseInEEPKcRSt26basic_format_parse_contextIcE at 0x1f7de
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<__int128>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatInNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1f80c
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<__int128,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  char v4; // al
  unsigned int v6; // eax
  const char *v7; // rax
  __int64 v8; // rdx
  __int64 v9; // rdx
  __int64 v10; // rdx
  const char *v11; // rax
  __int64 v12; // rdx
  __int64 v14; // rax
  size_t v15; // rbx
  const void *v16; // rax
  __int64 v17; // rbx
  __int128 v18; // [rsp+0h] [rbp-150h]
  size_t v20; // [rsp+20h] [rbp-130h] BYREF
  size_t v21; // [rsp+28h] [rbp-128h]
  __int64 v22; // [rsp+30h] [rbp-120h]
  __int64 v23; // [rsp+38h] [rbp-118h]
  _BYTE v24[128]; // [rsp+43h] [rbp-10Dh] BYREF
  _BYTE v25[5]; // [rsp+C3h] [rbp-8Dh] BYREF
  size_t v26[2]; // [rsp+D0h] [rbp-80h] BYREF
  size_t v27[2]; // [rsp+E0h] [rbp-70h] BYREF
  size_t v28[2]; // [rsp+F0h] [rbp-60h] BYREF
  _QWORD v29[2]; // [rsp+100h] [rbp-50h] BYREF
  _BYTE *v30; // [rsp+110h] [rbp-40h]
  _BYTE *v31; // [rsp+118h] [rbp-38h]
  _BYTE *i; // [rsp+120h] [rbp-30h]
  void *dest; // [rsp+128h] [rbp-28h]
  __int128 v34; // [rsp+130h] [rbp-20h]

  *(_QWORD *)&v18 = a2;
  *((_QWORD *)&v18 + 1) = a3;
  if ( (a1[1] & 0x78) == 0x38 )
  {
    v4 = std::__format::__formatter_int<char>::_S_to_character<__int128>(a2, a3);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v4,
             a4);
  }
  else
  {
    v22 = 0;
    v23 = 0;
    v20 = 0;
    v21 = 0;
    if ( a3 >= 0 )
      v34 = v18;
    else
      v34 = -v18;
    dest = v24;
    v31 = v25;
    v30 = v24;
    v6 = (a1[1] >> 3) & 0xF;
    if ( v6 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v11 = "0x";
        else
          v11 = "0X";
        std::string_view::basic_string_view(v28, v11);
        v20 = v28[0];
        v21 = v28[1];
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(
                dest,
                v31,
                v34,
                *((_QWORD *)&v34 + 1),
                16);
        v23 = v12;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v22; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v6 == 4 )
      {
        if ( v18 != 0 )
        {
          std::string_view::basic_string_view(v27, "0");
          v20 = v27[0];
          v21 = v27[1];
        }
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(
                dest,
                v31,
                v34,
                *((_QWORD *)&v34 + 1),
                8);
        v23 = v10;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v6 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v7 = "0b";
          else
            v7 = "0B";
          std::string_view::basic_string_view(v26, v7);
          v20 = v26[0];
          v21 = v26[1];
          v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(
                  dest,
                  v31,
                  v34,
                  *((_QWORD *)&v34 + 1),
                  2);
          v23 = v8;
        }
      }
      else
      {
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(
                dest,
                v31,
                v34,
                *((_QWORD *)&v34 + 1),
                10);
        v23 = v9;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v20) )
    {
      v14 = std::string_view::size((__int64)&v20);
      dest = (char *)dest - v14;
      v15 = std::string_view::size((__int64)&v20);
      v16 = (const void *)std::string_view::data((__int64)&v20);
      memcpy(dest, v16, v15);
    }
    dest = (void *)std::__format::__put_sign<__int128>(a2, *((_QWORD *)&v18 + 1), (*a1 >> 2) & 3, (char *)dest - 1);
    v17 = v30 - (_BYTE *)dest;
    std::string_view::basic_string_view(v29, (__int64)dest, v22 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v29[0],
             v29[1],
             v17,
             a4);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8_M_parseIoEEPKcRSt26basic_format_parse_contextIcE at 0x1fc70
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_parse<unsigned __int128>(__int64 a1, __int64 a2)
{
  return std::__format::__formatter_int<char>::_M_do_parse(a1, a2, 1);
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE6formatIoNS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x1fc9e
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::format<unsigned __int128,std::__format::_Sink_iter<char>>(
        _BYTE *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  char v4; // al
  unsigned int v6; // eax
  const char *v7; // rax
  __int64 v8; // rdx
  __int64 v9; // rdx
  __int64 v10; // rdx
  const char *v11; // rax
  __int64 v12; // rdx
  __int64 v14; // rax
  size_t v15; // rbx
  const void *v16; // rax
  __int64 v17; // rbx
  __int128 v18; // [rsp+0h] [rbp-150h]
  size_t v20; // [rsp+20h] [rbp-130h] BYREF
  size_t v21; // [rsp+28h] [rbp-128h]
  __int64 v22; // [rsp+30h] [rbp-120h]
  __int64 v23; // [rsp+38h] [rbp-118h]
  _BYTE v24[128]; // [rsp+43h] [rbp-10Dh] BYREF
  _BYTE v25[5]; // [rsp+C3h] [rbp-8Dh] BYREF
  size_t v26[2]; // [rsp+D0h] [rbp-80h] BYREF
  size_t v27[2]; // [rsp+E0h] [rbp-70h] BYREF
  size_t v28[2]; // [rsp+F0h] [rbp-60h] BYREF
  _QWORD v29[2]; // [rsp+100h] [rbp-50h] BYREF
  _BYTE *v30; // [rsp+110h] [rbp-40h]
  _BYTE *v31; // [rsp+118h] [rbp-38h]
  __int64 v32; // [rsp+120h] [rbp-30h]
  __int64 v33; // [rsp+128h] [rbp-28h]
  _BYTE *i; // [rsp+130h] [rbp-20h]
  void *dest; // [rsp+138h] [rbp-18h]

  *(_QWORD *)&v18 = a2;
  *((_QWORD *)&v18 + 1) = a3;
  if ( (a1[1] & 0x78) == 0x38 )
  {
    v4 = std::__format::__formatter_int<char>::_S_to_character<unsigned __int128>(a2, a3);
    return std::__format::__formatter_int<char>::_M_format_character<std::__format::_Sink_iter<char>>(
             (__int64)a1,
             v4,
             a4);
  }
  else
  {
    v22 = 0;
    v23 = 0;
    v20 = 0;
    v21 = 0;
    v32 = a2;
    v33 = a3;
    dest = v24;
    v31 = v25;
    v30 = v24;
    v6 = (a1[1] >> 3) & 0xF;
    if ( v6 <= 6 )
    {
      if ( ((a1[1] >> 3) & 0xFu) >= 5 )
      {
        if ( (a1[1] & 0x78) == 0x28 )
          v11 = "0x";
        else
          v11 = "0X";
        std::string_view::basic_string_view(v28, v11);
        v20 = v28[0];
        v21 = v28[1];
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(dest, v31, v32, v33, 16);
        v23 = v12;
        if ( (a1[1] & 0x78) == 0x30 )
        {
          for ( i = dest; i != (_BYTE *)v22; ++i )
            *i = toupper((char)*i);
        }
      }
      else if ( v6 == 4 )
      {
        if ( v18 != 0 )
        {
          std::string_view::basic_string_view(v27, "0");
          v20 = v27[0];
          v21 = v27[1];
        }
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(dest, v31, v32, v33, 8);
        v23 = v10;
      }
      else if ( ((a1[1] >> 3) & 0xFu) > 1 )
      {
        if ( v6 - 2 <= 1 )
        {
          if ( (a1[1] & 0x78) == 0x10 )
            v7 = "0b";
          else
            v7 = "0B";
          std::string_view::basic_string_view(v26, v7);
          v20 = v26[0];
          v21 = v26[1];
          v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(dest, v31, v32, v33, 2);
          v23 = v8;
        }
      }
      else
      {
        v22 = std::__format::__formatter_int<char>::to_chars<unsigned __int128>(dest, v31, v32, v33, 10);
        v23 = v9;
      }
    }
    if ( (*a1 & 0x10) != 0 && std::string_view::size((__int64)&v20) )
    {
      v14 = std::string_view::size((__int64)&v20);
      dest = (char *)dest - v14;
      v15 = std::string_view::size((__int64)&v20);
      v16 = (const void *)std::string_view::data((__int64)&v20);
      memcpy(dest, v16, v15);
    }
    dest = (void *)std::__format::__put_sign<unsigned __int128>(
                     a2,
                     *((_QWORD *)&v18 + 1),
                     (*a1 >> 2) & 3,
                     (char *)dest - 1);
    v17 = v30 - (_BYTE *)dest;
    std::string_view::basic_string_view(v29, (__int64)dest, v22 - (_QWORD)dest);
    return std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
             a1,
             v29[0],
             v29[1],
             v17,
             a4);
  }
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIDF128_NS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcSB_E_clESB_SB_ at 0x200d6
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)const::{lambda(char *,std::__format::_Sink_iter<char>&)#1}::operator()(
        __int64 a1)
{
  if ( **(_BYTE **)a1 )
    return std::to_chars();
  if ( **(_DWORD **)(a1 + 16) )
    return std::to_chars();
  return std::to_chars();
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE6formatIDF128_NS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ENKUlPcmE_clESB_m at 0x2018c
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)const::{lambda(char *,unsigned long)#1}::operator()(
        __int64 *a1,
        __int64 a2)
{
  __int64 *v2; // rbx
  __int64 v3; // rdx

  v2 = (__int64 *)a1[1];
  *v2 = std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)const::{lambda(char *,std::__format::_Sink_iter<char>&)#1}::operator()(*a1);
  v2[1] = v3;
  if ( *(_DWORD *)(a1[1] + 8) )
    return 0;
  else
    return *(_QWORD *)a1[1] - a2;
}



================================================================================
Function: _ZNKSt8__format14__formatter_fpIcE6formatIDF128_NS_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RS7_ at 0x20208
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(
        __int64 a1,
        _QWORD *a2,
        __m128i a3)
{
  int v3; // eax
  __int64 v4; // rdx
  unsigned __int64 v5; // rax
  __int64 v6; // rbx
  bool v7; // bl
  __int64 first_not_of; // rax
  __int64 v10; // rax
  __int64 v11; // rax
  __int64 v12; // rbx
  __int64 v13; // rax
  __int64 v14; // rax
  __int64 v15; // rdx
  __int64 v16; // rdx
  unsigned __int64 v17; // rdx
  bool v18; // bl
  _QWORD *v19; // rax
  __int64 v20; // rdx
  unsigned __int64 v21; // rax
  __int64 v22; // rax
  __int64 v23; // rbx
  __int64 v24; // rax
  bool v25; // bl
  char *v26; // rax
  char v27; // al
  __m128i v29; // [rsp+10h] [rbp-260h] BYREF
  _QWORD *v30; // [rsp+20h] [rbp-250h]
  _WORD *v31; // [rsp+28h] [rbp-248h]
  _QWORD v32[4]; // [rsp+30h] [rbp-240h] BYREF
  unsigned __int64 v33[2]; // [rsp+50h] [rbp-220h] BYREF
  _QWORD *v34; // [rsp+60h] [rbp-210h]
  __int64 *v35; // [rsp+68h] [rbp-208h]
  __int64 v36; // [rsp+78h] [rbp-1F8h]
  __int64 v37; // [rsp+80h] [rbp-1F0h] BYREF
  __int64 v38; // [rsp+88h] [rbp-1E8h]
  _QWORD v39[4]; // [rsp+90h] [rbp-1E0h] BYREF
  __int64 v40; // [rsp+B0h] [rbp-1C0h] BYREF
  unsigned __int64 v41; // [rsp+B8h] [rbp-1B8h]
  _QWORD v42[4]; // [rsp+C0h] [rbp-1B0h] BYREF
  int v43; // [rsp+E0h] [rbp-190h] BYREF
  bool v44; // [rsp+E7h] [rbp-189h] BYREF
  __int64 v45; // [rsp+E8h] [rbp-188h] BYREF
  __int64 v46; // [rsp+F0h] [rbp-180h] BYREF
  __int64 v47; // [rsp+F8h] [rbp-178h]
  _BYTE v48[7]; // [rsp+101h] [rbp-16Fh] BYREF
  _QWORD v49[4]; // [rsp+180h] [rbp-F0h] BYREF
  _QWORD v50[2]; // [rsp+1A0h] [rbp-D0h] BYREF
  _QWORD v51[2]; // [rsp+1B0h] [rbp-C0h] BYREF
  _QWORD v52[2]; // [rsp+1C0h] [rbp-B0h] BYREF
  _BYTE v53[8]; // [rsp+1D0h] [rbp-A0h] BYREF
  __int64 v54; // [rsp+1D8h] [rbp-98h] BYREF
  int v55; // [rsp+1E0h] [rbp-90h]
  char v56; // [rsp+1E7h] [rbp-89h]
  __int64 *v57; // [rsp+1E8h] [rbp-88h]
  unsigned __int64 v58; // [rsp+1F0h] [rbp-80h]
  unsigned __int64 v59; // [rsp+1F8h] [rbp-78h]
  size_t v60; // [rsp+200h] [rbp-70h]
  int v61; // [rsp+208h] [rbp-68h]
  unsigned int v62; // [rsp+20Ch] [rbp-64h]
  char *v63; // [rsp+210h] [rbp-60h]
  unsigned __int64 v64; // [rsp+218h] [rbp-58h]
  size_t n; // [rsp+220h] [rbp-50h]
  __int64 v66; // [rsp+228h] [rbp-48h]
  unsigned __int8 v67; // [rsp+237h] [rbp-39h]
  _BYTE *i; // [rsp+238h] [rbp-38h]
  unsigned __int64 v69; // [rsp+240h] [rbp-30h]
  char v70; // [rsp+24Dh] [rbp-23h]
  char v71; // [rsp+24Eh] [rbp-22h]
  char v72; // [rsp+24Fh] [rbp-21h]
  _QWORD *v73; // [rsp+250h] [rbp-20h]
  _BYTE *v74; // [rsp+258h] [rbp-18h]

  v31 = (_WORD *)a1;
  v29 = a3;
  v30 = a2;
  std::string::basic_string(v49);
  v46 = 0;
  v47 = 0;
  v45 = 6;
  v44 = (*(_BYTE *)(a1 + 1) & 6) != 0;
  if ( v44 )
    v45 = std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
            v31,
            v30);
  v74 = v48;
  v73 = v49;
  v43 = 0;
  v72 = 0;
  v71 = 0;
  v70 = 101;
  v3 = (*((_BYTE *)v31 + 1) >> 3) & 0xF;
  if ( v3 == 8 )
  {
    v72 = 1;
    v70 = 69;
LABEL_22:
    v71 = 1;
    v44 = 1;
    v43 = 3;
    goto LABEL_25;
  }
  if ( ((*((_BYTE *)v31 + 1) >> 3) & 0xFu) > 8 )
    goto LABEL_25;
  switch ( v3 )
  {
    case 7:
      goto LABEL_22;
    case 6:
      v72 = 1;
      goto LABEL_20;
    case 5:
LABEL_20:
      v44 = 1;
      v43 = 2;
      goto LABEL_25;
    case 4:
      v72 = 1;
      v70 = 69;
      goto LABEL_18;
    case 3:
LABEL_18:
      v44 = 1;
      v43 = 1;
      goto LABEL_25;
    case 2:
      v72 = 1;
      v70 = 80;
LABEL_14:
      if ( (*((_BYTE *)v31 + 1) & 0x78) != 0x10 )
        v70 = 112;
      v43 = 4;
      goto LABEL_25;
  }
  if ( ((*((_BYTE *)v31 + 1) >> 3) & 0xF) != 0 )
    goto LABEL_14;
  if ( v44 )
    v43 = 3;
LABEL_25:
  v42[0] = &v44;
  v42[1] = &v29;
  v42[2] = &v43;
  v42[3] = &v45;
  v46 = std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)const::{lambda(char *,std::__format::_Sink_iter<char>&)#1}::operator()((__int64)v42);
  v47 = v4;
  if ( (_DWORD)v4 == 75 )
  {
    v69 = v45 + 8;
    if ( v43 == 2 )
      v69 += 4932LL;
    if ( v69 <= 0x80 )
      v69 = 256;
    std::string::reserve(v49, v69);
    do
    {
      v34 = v42;
      v35 = &v46;
      v5 = std::string::capacity((__int64)v49);
      std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)::{lambda(char *,unsigned long)#1}>(
        v49,
        2 * v5,
        v34,
        v35);
      v74 = (_BYTE *)(std::string::data((__int64)v49) + 1);
      v6 = std::string::data((__int64)v49);
      v73 = (_QWORD *)(v6 + std::string::size((__int64)v49));
    }
    while ( (_DWORD)v47 == 75 );
  }
  if ( v72 )
  {
    for ( i = v74; i != (_BYTE *)v46; ++i )
      *i = toupper((char)*i);
  }
  v67 = 1;
  if ( (_mm_movemask_ps((__m128)_mm_load_si128(&v29)) & 8) == 0 )
  {
    if ( (*(_BYTE *)v31 & 0xC) == 4 )
    {
      *--v74 = 43;
    }
    else if ( (*(_BYTE *)v31 & 0xC) == 0xC )
    {
      *--v74 = 32;
    }
    else
    {
      v67 = 0;
    }
  }
  std::string_view::basic_string_view(&v40, (__int64)v74, v46 - (_QWORD)v74);
  if ( (*(_BYTE *)v31 & 0x10) != 0 )
  {
    v7 = 1;
    if ( !__unordtf2() )
      v7 = __gttf2() > 0;
    if ( !v7 )
    {
      v33[0] = v40;
      v33[1] = v41;
      n = 0;
      v63 = std::string_view::find(v33, 46, 0);
      if ( v63 == (char *)-1LL )
      {
        v64 = (unsigned __int64)std::string_view::find(v33, v70, 0);
        if ( v64 == -1 )
          v64 = std::string_view::size((__int64)v33);
        v63 = (char *)v64;
        v66 = v64 - v67;
      }
      else
      {
        v64 = (unsigned __int64)std::string_view::find(v33, v70, (unsigned __int64)(v63 + 1));
        if ( v64 == -1 )
          v64 = std::string_view::size((__int64)v33);
        if ( v71 )
        {
          if ( *(_BYTE *)std::string_view::operator[](v33, v67) == 48 )
          {
            first_not_of = std::string_view::find_first_not_of(v33, 48, v63 + 1);
            v66 = v64 - first_not_of;
          }
          else
          {
            v66 = v64 - v67 - 1;
          }
        }
      }
      if ( v71 && v45 )
        n = v45 - v66;
      v60 = (v63 == (char *)v64) + n;
      if ( v60 )
      {
        if ( std::string::empty((__int64)v49) && (unsigned __int64)v73 - v46 >= v60 )
        {
          v10 = std::string_view::size((__int64)v33);
          memmove(&v74[v60 + v64], &v74[v64], v10 - v64);
          if ( v63 == (char *)v64 )
          {
            v11 = v64++;
            v74[v11] = 46;
          }
          memset(&v74[v64], 48, n);
          v12 = std::string_view::data((__int64)v33);
          v13 = std::string_view::size((__int64)v33);
          std::string_view::basic_string_view(v50, v12, v13 + v60);
          v40 = v50[0];
          v41 = v50[1];
        }
        else
        {
          v14 = std::string_view::size((__int64)v33);
          std::string::reserve(v49, v14 + v60);
          if ( std::string::empty((__int64)v49) )
          {
            v51[0] = std::string_view::substr(v33, 0, v64);
            v51[1] = v15;
            std::string::operator=<std::string_view>(v49, v51);
            if ( v63 == (char *)v64 )
              std::string::operator+=((__int64)v49, 46);
            if ( n )
              std::string::append((__int64)v49, n, 48);
            v52[0] = std::string_view::substr(v33, v64, -1);
            v52[1] = v16;
            std::string::append<std::string_view>((__int64)v49, v52);
          }
          else
          {
            std::string::insert(v49, v64, v60, 48);
            if ( v63 == (char *)v64 )
              *(_BYTE *)std::string::operator[](v49, v64) = 46;
          }
          v40 = std::string::operator std::string_view((__int64)v49);
          v41 = v17;
        }
      }
    }
  }
  std::string::basic_string(v39);
  v37 = v40;
  v38 = v41;
  if ( (*(_BYTE *)v31 & 0x20) != 0 )
  {
    v18 = 1;
    if ( !__unordtf2() )
      v18 = __gttf2() > 0;
    if ( !v18 )
    {
      std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(v53, v30);
      std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](v32, v31, v37, v38, (unsigned int)v70, v53);
      std::locale::~locale((std::locale *)v53);
      if ( !std::string::empty((__int64)v32) )
      {
        v19 = std::string::operator=(v39, v32);
        v37 = std::string::operator std::string_view((__int64)v19);
        v38 = v20;
      }
      std::string::~string((__int64)v32);
    }
  }
  v59 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          v31,
          v30);
  v21 = std::string_view::size((__int64)&v37);
  if ( v21 < v59 )
  {
    v62 = *((_DWORD *)v31 + 2);
    v61 = *(_BYTE *)v31 & 3;
    v24 = std::string_view::size((__int64)&v37);
    v58 = v59 - v24;
    v36 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)v30);
    if ( !v61 )
    {
      v61 = 2;
      if ( (*(_BYTE *)v31 & 0x40) == 0 )
        goto LABEL_93;
      v25 = 1;
      if ( !__unordtf2() )
        v25 = __gttf2() > 0;
      if ( !v25 )
      {
        v62 = 48;
        v26 = (char *)std::string_view::operator[]((unsigned __int64 *)&v40, 0);
        if ( !std::__format::__is_xdigit((std::__format *)(unsigned int)*v26) )
        {
          v27 = *(_BYTE *)std::string_view::operator[]((unsigned __int64 *)&v37, 0);
          v55 = 0;
          v54 = v36;
          v57 = &v54;
          v56 = v27;
          std::__format::_Sink<char>::_M_write(v36, (unsigned int)v27);
          std::string_view::remove_prefix((unsigned __int64 *)&v37, 1u);
        }
      }
      else
      {
LABEL_93:
        v62 = 32;
      }
    }
    v23 = std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v36, v37, v38, v61, v58, v62);
  }
  else
  {
    v22 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)v30);
    v23 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v22, v37, v38);
  }
  std::string::~string((__int64)v39);
  std::string::~string((__int64)v49);
  return v23;
}



================================================================================
Function: _ZNKSt6ranges9__copy_fnclIN9__gnu_cxx17__normal_iteratorIPcNSt4spanIcLm18446744073709551615EE10__iter_tagEEES8_NSt8__format10_Sink_iterIcEEEENS_13in_out_resultIT_T1_EESD_T0_SE_ at 0x20eb2
================================================================================

__int64 __fastcall std::ranges::__copy_fn::operator()<__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  return std::ranges::__copy_or_move<false,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,std::__format::_Sink_iter<char>>(
           a2,
           a3,
           a4,
           a3,
           a5,
           a6,
           a4,
           a3,
           a2,
           a1);
}



================================================================================
Function: _ZNSt8__format10__put_signIjEEPcT_NS_5_SignES1_ at 0x20ef0
================================================================================

_BYTE *__fastcall std::__format::__put_sign<unsigned int>(__int64 a1, int a2, _BYTE *a3)
{
  _BYTE *v4; // [rsp+0h] [rbp-10h]

  v4 = a3;
  if ( a2 == 1 )
  {
    *a3 = 43;
  }
  else if ( a2 == 3 )
  {
    *a3 = 32;
  }
  else
  {
    return a3 + 1;
  }
  return v4;
}



================================================================================
Function: _ZNSt8__format10__put_signIiEEPcT_NS_5_SignES1_ at 0x20f2b
================================================================================

_BYTE *__fastcall std::__format::__put_sign<int>(int a1, int a2, _BYTE *a3)
{
  _BYTE *v4; // [rsp+0h] [rbp-10h]

  v4 = a3;
  if ( a1 >= 0 )
  {
    if ( a2 == 1 )
    {
      *a3 = 43;
    }
    else if ( a2 == 3 )
    {
      *a3 = 32;
    }
    else
    {
      return a3 + 1;
    }
  }
  else
  {
    *a3 = 45;
  }
  return v4;
}



================================================================================
Function: _ZNSt8__format10__put_signIxEEPcT_NS_5_SignES1_ at 0x20f75
================================================================================

_BYTE *__fastcall std::__format::__put_sign<long long>(__int64 a1, int a2, _BYTE *a3)
{
  _BYTE *v4; // [rsp+0h] [rbp-18h]

  v4 = a3;
  if ( a1 >= 0 )
  {
    if ( a2 == 1 )
    {
      *a3 = 43;
    }
    else if ( a2 == 3 )
    {
      *a3 = 32;
    }
    else
    {
      return a3 + 1;
    }
  }
  else
  {
    *a3 = 45;
  }
  return v4;
}



================================================================================
Function: _ZNSt8__format10__put_signIyEEPcT_NS_5_SignES1_ at 0x20fc1
================================================================================

_BYTE *__fastcall std::__format::__put_sign<unsigned long long>(__int64 a1, int a2, _BYTE *a3)
{
  _BYTE *v4; // [rsp+0h] [rbp-18h]

  v4 = a3;
  if ( a2 == 1 )
  {
    *a3 = 43;
  }
  else if ( a2 == 3 )
  {
    *a3 = 32;
  }
  else
  {
    return a3 + 1;
  }
  return v4;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE17find_first_not_ofEcm at 0x20ffe
================================================================================

__int64 __fastcall std::string_view::find_first_not_of(unsigned __int64 *a1, char a2, unsigned __int64 a3)
{
  _BYTE v5[4]; // [rsp+14h] [rbp-Ch] BYREF
  unsigned __int64 *v6; // [rsp+18h] [rbp-8h]

  v6 = a1;
  v5[0] = a2;
  while ( a3 < *v6 )
  {
    if ( !std::char_traits<char>::eq((_BYTE *)(a3 + v6[1]), v5) )
      return a3;
    ++a3;
  }
  return -1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSISt17basic_string_viewIcS2_EEENSt9enable_ifIXsrSt6__and_IJSt14is_convertibleIRKT_S7_ESt6__not_ISA_IPSC_PKS4_EESF_ISA_ISD_PKcEEEE5valueERS4_E4typeESD_ at 0x21060
================================================================================

__int64 __fastcall std::string::operator=<std::string_view>(__int64 a1, __int64 a2)
{
  return std::string::assign<std::string_view>(a1, a2);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6insertEmmc at 0x2108a
================================================================================

_QWORD *__fastcall std::string::insert(_QWORD *a1, unsigned __int64 a2, unsigned __int64 a3, char a4)
{
  size_t v5; // rax

  v5 = std::string::_M_check((__int64)a1, a2);
  return std::string::_M_replace_aux(a1, v5, 0, a3, a4);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm at 0x210ea
================================================================================

unsigned __int64 __fastcall std::string::operator[](__int64 a1, unsigned __int64 a2)
{
  if ( std::string::size(a1) < a2 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/bits/basic_string.h",
      1369,
      "constexpr std::__cxx11::basic_string<_CharT, _Traits, _Alloc>::reference std::__cxx11::basic_string<_CharT, _Trait"
      "s, _Alloc>::operator[](size_type) [with _CharT = char; _Traits = std::char_traits<char>; _Alloc = std::allocator<c"
      "har>; reference = char&; size_type = long unsigned int]",
      "__pos <= size()");
  return a2 + std::string::_M_data(a1);
}



================================================================================
Function: _ZNSt8__format10__put_signInEEPcT_NS_5_SignES1_ at 0x21155
================================================================================

_BYTE *__fastcall std::__format::__put_sign<__int128>(__int64 a1, __int64 a2, int a3, _BYTE *a4)
{
  _BYTE *v5; // [rsp+0h] [rbp-20h]

  v5 = a4;
  if ( a2 >= 0 )
  {
    if ( a3 == 1 )
    {
      *a4 = 43;
    }
    else if ( a3 == 3 )
    {
      *a4 = 32;
    }
    else
    {
      return a4 + 1;
    }
  }
  else
  {
    *a4 = 45;
  }
  return v5;
}



================================================================================
Function: _ZNSt8__format10__put_signIoEEPcT_NS_5_SignES1_ at 0x211b6
================================================================================

_BYTE *__fastcall std::__format::__put_sign<unsigned __int128>(__int64 a1, __int64 a2, int a3, _BYTE *a4)
{
  _BYTE *v5; // [rsp+0h] [rbp-20h]

  v5 = a4;
  if ( a3 == 1 )
  {
    *a4 = 43;
  }
  else if ( a3 == 3 )
  {
    *a4 = 32;
  }
  else
  {
    return a4 + 1;
  }
  return v5;
}



================================================================================
Function: _ZNSt8__format5_SinkIcE8_M_writeESt17basic_string_viewIcSt11char_traitsIcEE at 0x21208
================================================================================

char __fastcall std::__format::_Sink<char>::_M_write(__int64 a1, unsigned __int64 a2, unsigned __int64 a3)
{
  __int64 v3; // rdx
  __int64 v4; // rdx
  __int64 v5; // rbx
  void *v6; // rax
  __int64 v7; // rax
  unsigned __int64 v8; // rsi
  __int64 v9; // rbx
  __int64 v10; // rdx
  __int64 v11; // rdx
  unsigned __int64 v12; // rbx
  char result; // al
  __int64 v14; // rbx
  void *v15; // rax
  __int64 v16; // rax
  __int64 v17; // rdx
  unsigned __int64 v18[3]; // [rsp+0h] [rbp-B0h] BYREF
  __int64 v19; // [rsp+18h] [rbp-98h]
  __int64 v20; // [rsp+20h] [rbp-90h] BYREF
  __int64 i; // [rsp+28h] [rbp-88h]
  __int64 v22; // [rsp+30h] [rbp-80h] BYREF
  _QWORD v23[6]; // [rsp+38h] [rbp-78h] BYREF
  __int64 v24; // [rsp+68h] [rbp-48h]
  __int64 v25; // [rsp+70h] [rbp-40h]
  __int64 v26; // [rsp+78h] [rbp-38h]
  __int64 *v27; // [rsp+80h] [rbp-30h]
  __int64 v28; // [rsp+88h] [rbp-28h]
  __int64 v29; // [rsp+90h] [rbp-20h]
  __int64 v30; // [rsp+98h] [rbp-18h]

  v19 = a1;
  v18[0] = a2;
  v18[1] = a3;
  v30 = a1;
  v22 = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v29 = a1 + 24;
  v28 = a1 + 24;
  v3 = *(_QWORD *)(a1 + 24);
  v27 = &v22;
  v20 = std::span<char,18446744073709551615ul>::subspan(a1 + 8, v3 - v22, 0xFFFFFFFFFFFFFFFFLL);
  for ( i = v4; ; i = v11 )
  {
    v12 = std::span<char,18446744073709551615ul>::size((__int64)&v20);
    if ( std::string_view::size((__int64)v18) < v12 )
      break;
    v5 = std::span<char,18446744073709551615ul>::size((__int64)&v20);
    v6 = (void *)std::span<char,18446744073709551615ul>::data((__int64)&v20);
    std::string_view::copy(v18, v6, v5, 0);
    v7 = std::span<char,18446744073709551615ul>::size((__int64)&v20);
    v26 = v19 + 24;
    v25 = v7;
    *(_QWORD *)(v19 + 24) += v7;
    v8 = std::span<char,18446744073709551615ul>::size((__int64)&v20);
    std::string_view::remove_prefix(v18, v8);
    (**(void (__fastcall ***)(__int64))v19)(v19);
    v24 = v19;
    v9 = v19 + 8;
    v23[0] = std::span<char,18446744073709551615ul>::begin(v19 + 8);
    v23[5] = v24 + 24;
    v23[4] = v24 + 24;
    v10 = *(_QWORD *)(v24 + 24);
    v23[3] = v23;
    v20 = std::span<char,18446744073709551615ul>::subspan(v9, v10 - v23[0], 0xFFFFFFFFFFFFFFFFLL);
  }
  result = std::string_view::size((__int64)v18) != 0;
  if ( result )
  {
    v14 = std::string_view::size((__int64)v18);
    v15 = (void *)std::span<char,18446744073709551615ul>::data((__int64)&v20);
    std::string_view::copy(v18, v15, v14, 0);
    v16 = std::string_view::size((__int64)v18);
    v23[2] = v19 + 24;
    v23[1] = v16;
    v17 = v16 + *(_QWORD *)(v19 + 24);
    result = v19 + 24;
    *(_QWORD *)(v19 + 24) = v17;
  }
  return result;
}



================================================================================
Function: _ZZNSt8__format15__formatter_intIcE11_M_do_parseERSt26basic_format_parse_contextIcENS_10_Pres_typeEENKUlvE_clEv at 0x214aa
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#1}::operator()(
        __int64 *a1)
{
  __int64 v1; // rdx
  __int64 result; // rax

  v1 = a1[1];
  result = *a1;
  *(_QWORD *)result = *(_QWORD *)v1;
  *(_DWORD *)(result + 8) = *(_DWORD *)(v1 + 8);
  return result;
}



================================================================================
Function: _ZZNSt8__format15__formatter_intIcE11_M_do_parseERSt26basic_format_parse_contextIcENS_10_Pres_typeEENKUlvE0_clEv at 0x214d4
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(
        _QWORD **a1)
{
  if ( **a1 != *a1[1] && *(_BYTE *)**a1 != 125 )
    return 0;
  std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#1}::operator()(a1[2]);
  return 1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE11_M_do_parseERSt26basic_format_parse_contextIcENS_10_Pres_typeE at 0x2152e
================================================================================

_BYTE *__fastcall std::__format::__formatter_int<char>::_M_do_parse(__int64 a1, __int64 a2, int a3)
{
  int v4; // eax
  _QWORD *v6[4]; // [rsp+20h] [rbp-50h] BYREF
  _QWORD v7[2]; // [rsp+40h] [rbp-30h] BYREF
  _BYTE *v8; // [rsp+50h] [rbp-20h] BYREF
  __int64 v9; // [rsp+58h] [rbp-18h] BYREF
  __int64 v10; // [rsp+64h] [rbp-Ch] BYREF
  int v11; // [rsp+6Ch] [rbp-4h]

  v10 = 0;
  v11 = 32;
  *(_DWORD *)((char *)&v10 + 1) = (unsigned __int8)(8 * (a3 & 0xF));
  v9 = std::basic_format_parse_context<char>::end(a2);
  v8 = (_BYTE *)std::basic_format_parse_context<char>::begin(a2);
  v7[0] = a1;
  v7[1] = &v10;
  v6[0] = &v8;
  v6[1] = &v9;
  v6[2] = v7;
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_fill_and_align((__int64)&v10, (__int64)v8, v9);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_sign(&v10, v8, v9);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_alternate_form(&v10, v8, v9);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = std::__format::_Spec<char>::_M_parse_zero_fill(&v10, v8);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_width(&v10, v8, v9, a2);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v8 = (_BYTE *)std::__format::_Spec<char>::_M_parse_locale(&v10, v8, v9);
  if ( (unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    return v8;
  v4 = (char)*v8;
  if ( v4 == 120 )
  {
    BYTE1(v10) = BYTE1(v10) & 0x87 | 0x28;
    ++v8;
  }
  else if ( v4 <= 120 )
  {
    if ( v4 == 115 )
    {
      if ( !a3 )
      {
        BYTE1(v10) &= 0x87u;
        ++v8;
      }
    }
    else if ( v4 <= 115 )
    {
      if ( v4 == 111 )
      {
        BYTE1(v10) = BYTE1(v10) & 0x87 | 0x20;
        ++v8;
      }
      else if ( v4 <= 111 )
      {
        if ( v4 == 100 )
        {
          BYTE1(v10) = BYTE1(v10) & 0x87 | 8;
          ++v8;
        }
        else if ( v4 <= 100 )
        {
          switch ( v4 )
          {
            case 'c':
              if ( a3 )
              {
                BYTE1(v10) = BYTE1(v10) & 0x87 | 0x38;
                ++v8;
              }
              break;
            case 'b':
              BYTE1(v10) = BYTE1(v10) & 0x87 | 0x10;
              ++v8;
              break;
            case 'B':
              BYTE1(v10) = BYTE1(v10) & 0x87 | 0x18;
              ++v8;
              break;
            case 'X':
              BYTE1(v10) = BYTE1(v10) & 0x87 | 0x30;
              ++v8;
              break;
          }
        }
      }
    }
  }
  if ( !(unsigned __int8)std::__format::__formatter_int<char>::_M_do_parse(std::basic_format_parse_context<char> &,std::__format::_Pres_type)::{lambda(void)#2}::operator()(v6) )
    std::__format::__failed_to_parse_format_spec((std::__format *)v6);
  return v8;
}



================================================================================
Function: _ZNSt20basic_format_contextINSt8__format10_Sink_iterIcEEcE6localeEv at 0x218a2
================================================================================

std::locale *__fastcall std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale(
        std::locale *a1,
        __int64 a2)
{
  std::__format::_Optional_locale *v2; // rax

  v2 = std::__format::_Optional_locale::value((std::__format::_Optional_locale *)(a2 + 24));
  std::locale::locale(a1, v2);
  return a1;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc at 0x218de
================================================================================

__int64 __fastcall std::string::operator=(__int64 a1, const char *a2)
{
  return std::string::assign(a1, a2);
}



================================================================================
Function: _ZNSt8__format15__write_escapedIcNS_10_Sink_iterIcEEEET0_S3_St17basic_string_viewIT_St11char_traitsIS5_EENS_10_Term_charE at 0x21907
================================================================================

__int64 __fastcall std::__format::__write_escaped<char,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        unsigned __int8 a4)
{
  char v4; // al
  __int64 v8; // [rsp+18h] [rbp-28h] BYREF
  char v9; // [rsp+27h] [rbp-19h]
  __int64 *v10; // [rsp+28h] [rbp-18h]
  char v11; // [rsp+37h] [rbp-9h]
  __int64 *v12; // [rsp+38h] [rbp-8h]

  v8 = a1;
  v10 = &v8;
  v9 = std::__format::_Escapes<char>::_S_term(a4);
  std::__format::_Sink<char>::_M_write(a1, (unsigned int)v9);
  v8 = std::__format::__write_escaped_unicode<char,std::__format::_Sink_iter<char>>(v8, a2, a3, a4);
  v4 = std::__format::_Escapes<char>::_S_term(a4);
  v12 = &v8;
  v11 = v4;
  std::__format::_Sink<char>::_M_write(v8, (unsigned int)v4);
  return v8;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIhEEcT_ at 0x219b6
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<unsigned char>(char a1)
{
  if ( a1 < 0 )
    std::__throw_format_error("format error: integer not representable as character");
  return (unsigned __int8)a1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8to_charsIhEESt15to_chars_resultPcS4_T_i at 0x219e6
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::to_chars<unsigned char>(
        _BYTE *a1,
        unsigned __int64 a2,
        unsigned __int8 a3,
        int a4)
{
  return std::__to_chars_i<unsigned char>(a1, a2, a3, a4);
}



================================================================================
Function: _ZNSt8__format10__put_signIhEEPcT_NS_5_SignES1_ at 0x21a1b
================================================================================

_BYTE *__fastcall std::__format::__put_sign<unsigned char>(__int64 a1, int a2, _BYTE *a3)
{
  _BYTE *v4; // [rsp+0h] [rbp-10h]

  v4 = a3;
  if ( a2 == 1 )
  {
    *a3 = 43;
  }
  else if ( a2 == 3 )
  {
    *a3 = 32;
  }
  else
  {
    return a3 + 1;
  }
  return v4;
}



================================================================================
Function: _ZNKSt8__format15__formatter_intIcE13_M_format_intINS_10_Sink_iterIcEEEENSt20basic_format_contextIT_cE8iteratorESt17basic_string_viewIcSt11char_traitsIcEEmRS7_ at 0x21a58
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_M_format_int<std::__format::_Sink_iter<char>>(
        _WORD *a1,
        __int64 a2,
        __int64 a3,
        size_t a4,
        _QWORD *a5)
{
  bool v5; // bl
  __int64 v6; // rax
  unsigned __int64 v7; // rax
  void *v8; // rsp
  char *v9; // r13
  __int64 v10; // r12
  __int64 v11; // rbx
  char v12; // al
  unsigned __int64 v13; // rax
  __int64 v14; // rax
  __int64 v16; // rax
  __int64 v17; // rax
  __int64 v18; // rdx
  _BYTE v19[8]; // [rsp+8h] [rbp-110h] BYREF
  _QWORD *v20; // [rsp+10h] [rbp-108h]
  __int64 v21; // [rsp+18h] [rbp-100h]
  __int64 v22; // [rsp+20h] [rbp-F8h]
  size_t v23; // [rsp+28h] [rbp-F0h]
  _WORD *v24; // [rsp+30h] [rbp-E8h]
  _BYTE v25[32]; // [rsp+38h] [rbp-E0h] BYREF
  _BYTE v26[8]; // [rsp+58h] [rbp-C0h] BYREF
  __int64 v27; // [rsp+60h] [rbp-B8h]
  __int64 v28; // [rsp+68h] [rbp-B0h] BYREF
  __int64 v29; // [rsp+70h] [rbp-A8h]
  _BYTE v30[32]; // [rsp+78h] [rbp-A0h] BYREF
  _QWORD v31[3]; // [rsp+98h] [rbp-80h] BYREF
  unsigned __int64 v32; // [rsp+B0h] [rbp-68h]
  __int64 v33; // [rsp+B8h] [rbp-60h]
  char *v34; // [rsp+C0h] [rbp-58h]
  char *v35; // [rsp+C8h] [rbp-50h]
  size_t v36; // [rsp+D0h] [rbp-48h]
  __int64 v37; // [rsp+D8h] [rbp-40h]
  _BYTE *v38; // [rsp+E0h] [rbp-38h]
  unsigned __int64 v39; // [rsp+E8h] [rbp-30h]
  int v40; // [rsp+F0h] [rbp-28h]
  unsigned int v41; // [rsp+F4h] [rbp-24h]

  v24 = a1;
  v21 = a2;
  v22 = a3;
  v23 = a4;
  v20 = a5;
  v39 = std::__format::_Spec<char>::_M_get_width<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
          a1,
          a5);
  v28 = a2;
  v29 = v22;
  if ( (*(_BYTE *)a1 & 0x20) != 0 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::locale((std::locale *)v26, (__int64)v20);
    v38 = v26;
    std::locale::name[abi:cxx11]();
    v5 = !std::operator==<char>((__int64)v30, "C");
    std::string::~string((__int64)v30);
    if ( v5 )
    {
      v37 = std::use_facet<std::numpunct<char>>();
      std::numpunct<char>::grouping();
      if ( !std::string::empty((__int64)v25) )
      {
        v6 = std::string_view::size((__int64)&v28);
        v36 = v6 - v23;
        v7 = 16 * ((2 * (v6 - v23) + v23 + 23) / 0x10);
        while ( v19 != &v19[-(v7 & 0xFFFFFFFFFFFFF000LL)] )
          ;
        v8 = alloca(v7 & 0xFFF);
        if ( (v7 & 0xFFF) != 0 )
          *(_QWORD *)&v19[(v7 & 0xFFF) - 8] = *(_QWORD *)&v19[(v7 & 0xFFF) - 8];
        v35 = v19;
        v34 = (char *)std::string_view::data((__int64)&v28);
        std::char_traits<char>::copy(v35, v34, v23);
        v34 += v23;
        v9 = &v34[v36];
        v10 = std::string::size((__int64)v25);
        v11 = std::string::data((__int64)v25);
        v12 = std::numpunct<char>::thousands_sep();
        v33 = std::__add_grouping<char>(&v35[v23], (unsigned int)v12, v11, v10, v34, v9);
        std::string_view::basic_string_view(v31, (__int64)v35, v33 - (_QWORD)v35);
        v28 = v31[0];
        v29 = v31[1];
      }
      std::string::~string((__int64)v25);
    }
    std::locale::~locale((std::locale *)v26);
  }
  v13 = std::string_view::size((__int64)&v28);
  if ( v13 < v39 )
  {
    v41 = *((_DWORD *)v24 + 2);
    v40 = *(_BYTE *)v24 & 3;
    v16 = std::string_view::size((__int64)&v28);
    v32 = v39 - v16;
    v27 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)v20);
    if ( !v40 )
    {
      v40 = 2;
      if ( (*(_BYTE *)v24 & 0x40) != 0 )
      {
        v41 = 48;
        if ( v23 )
        {
          v17 = std::string_view::substr(&v28, 0, v23);
          v27 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v27, v17, v18);
          std::string_view::remove_prefix((unsigned __int64 *)&v28, v23);
        }
      }
      else
      {
        v41 = 32;
      }
    }
    return std::__format::__write_padded<std::__format::_Sink_iter<char>,char>(v27, v28, v29, v40, v32, v41);
  }
  else
  {
    v14 = std::basic_format_context<std::__format::_Sink_iter<char>,char>::out((__int64)v20);
    return std::__format::__write<std::__format::_Sink_iter<char>,char>(v14, v28, v29);
  }
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIiEEcT_ at 0x21f10
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<int>(int a1)
{
  if ( a1 < -128 || a1 > 127 )
    std::__throw_format_error("format error: integer not representable as character");
  return (unsigned int)a1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8to_charsIjEESt15to_chars_resultPcS4_T_i at 0x21f41
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::to_chars<unsigned int>(
        _BYTE *a1,
        unsigned __int64 a2,
        unsigned int a3,
        int a4)
{
  return std::__to_chars_i<unsigned int>(a1, a2, a3, a4);
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIjEEcT_ at 0x21f73
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<unsigned int>(unsigned int a1)
{
  if ( a1 > 0x7F )
    std::__throw_format_error("format error: integer not representable as character");
  return a1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIxEEcT_ at 0x21f9e
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<long long>(__int64 a1)
{
  if ( a1 < -128 || a1 > 127 )
    std::__throw_format_error("format error: integer not representable as character");
  return a1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8to_charsIyEESt15to_chars_resultPcS4_T_i at 0x21fd3
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::to_chars<unsigned long long>(
        _BYTE *a1,
        unsigned __int64 a2,
        __int64 a3,
        int a4)
{
  return std::__to_chars_i<unsigned long long>(a1, a2, a3, a4);
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIyEEcT_ at 0x22007
================================================================================

unsigned __int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<unsigned long long>(
        unsigned __int64 a1)
{
  if ( a1 > 0x7F )
    std::__throw_format_error("format error: integer not representable as character");
  return a1;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE13_M_parse_signEPKcS3_ at 0x22036
================================================================================

char *__fastcall std::__format::_Spec<char>::_M_parse_sign(_BYTE *a1, char *a2)
{
  int v3; // [rsp+2Ch] [rbp-4h]

  v3 = std::__format::_Spec<char>::_S_sign((unsigned int)*a2);
  if ( !v3 )
    return a2;
  *a1 = (4 * (v3 & 3)) | *a1 & 0xF3;
  return a2 + 1;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE23_M_parse_alternate_formEPKcS3_ at 0x22096
================================================================================

_BYTE *__fastcall std::__format::_Spec<char>::_M_parse_alternate_form(_BYTE *a1, _BYTE *a2)
{
  _BYTE *v3; // [rsp+8h] [rbp-10h]

  v3 = a2;
  if ( *a2 == 35 )
  {
    *a1 |= 0x10u;
    return a2 + 1;
  }
  return v3;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE15_M_parse_localeEPKcS3_ at 0x220cc
================================================================================

_BYTE *__fastcall std::__format::_Spec<char>::_M_parse_locale(_BYTE *a1, _BYTE *a2)
{
  _BYTE *v3; // [rsp+8h] [rbp-10h]

  v3 = a2;
  if ( *a2 == 76 )
  {
    *a1 |= 0x20u;
    return a2 + 1;
  }
  return v3;
}



================================================================================
Function: _ZNKSt8__format5_SpecIcE16_M_get_precisionISt20basic_format_contextINS_10_Sink_iterIcEEcEEEmRT_ at 0x22102
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_M_get_precision<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        __int64 a1,
        _QWORD *a2)
{
  _BYTE v3[40]; // [rsp+10h] [rbp-30h] BYREF
  __int64 v4; // [rsp+38h] [rbp-8h]

  v4 = -1;
  if ( (*(_BYTE *)(a1 + 1) & 6) == 2 )
    return *(unsigned __int16 *)(a1 + 6);
  if ( (*(_BYTE *)(a1 + 1) & 6) == 4 )
  {
    std::basic_format_context<std::__format::_Sink_iter<char>,char>::arg((__int64)v3, a2, *(unsigned __int16 *)(a1 + 6));
    return std::__format::__int_from_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(v3);
  }
  return v4;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIfNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_EN11_TerminatorD2Ev at 0x22182
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,float)::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIfNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_ at 0x221b0
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v5[4]; // [rsp+0h] [rbp-50h] BYREF
  __int128 v6; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+30h] [rbp-20h]
  __int64 v8; // [rsp+38h] [rbp-18h]

  v5[3] = (__int64)a1;
  v5[2] = a2;
  v5[0] = a3;
  v5[1] = a4;
  std::string::reserve(a1, a2);
  v8 = std::string::_M_data((__int64)a1);
  v6 = (unsigned __int64)a1;
  v7 = std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
         v5,
         v8,
         a2);
  *((_QWORD *)&v6 + 1) = v7;
  return std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<float,std::__format::_Sink_iter<char>>(float,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,float)::_Terminator::~_Terminator((__int64 *)&v6);
}



================================================================================
Function: _ZZNKSt8__format14__formatter_fpIcE11_M_localizeB5cxx11ESt17basic_string_viewIcSt11char_traitsIcEEcRKSt6localeENKUlPcmE_clES9_m at 0x222a2
================================================================================

__int64 __fastcall std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](std::string_view,char,std::locale const&)const::{lambda(char *,unsigned long)#1}::operator()(
        __int64 *a1,
        _BYTE *a2)
{
  __int64 v2; // r14
  __int64 v3; // r13
  __int64 v4; // r12
  __int64 v5; // rbx
  char v6; // al
  __int64 v7; // rax
  size_t v9; // [rsp+20h] [rbp-40h]
  char v10; // [rsp+2Fh] [rbp-31h]
  _BYTE *v11; // [rsp+30h] [rbp-30h]
  int v12; // [rsp+3Ch] [rbp-24h]

  v12 = 0;
  v10 = *(_BYTE *)std::string_view::front(*a1);
  if ( v10 == 45 || v10 == 43 || v10 == 32 )
  {
    *a2 = v10;
    v12 = 1;
  }
  v2 = std::string_view::data(*a1) + *(_QWORD *)a1[3];
  v3 = std::string_view::data(*a1) + v12;
  v4 = std::string::size(a1[2]);
  v5 = std::string::data(a1[2]);
  v6 = std::numpunct<char>::thousands_sep();
  v11 = (_BYTE *)std::__add_grouping<char>(&a2[v12], (unsigned int)v6, v5, v4, v3, v2);
  if ( *(_QWORD *)a1[4] )
  {
    if ( *(_QWORD *)a1[5] != -1 )
    {
      *v11++ = *(_BYTE *)a1[6];
      ++*(_QWORD *)a1[3];
    }
    v9 = std::string_view::size(*a1) - *(_QWORD *)a1[3];
    v7 = std::string_view::data(*a1);
    std::char_traits<char>::copy(v11, (const void *)(v7 + *(_QWORD *)a1[3]), v9);
    v11 += v9;
  }
  return v11 - a2;
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5frontEv at 0x22454
================================================================================

__int64 __fastcall std::string_view::front(_QWORD *a1)
{
  if ( !*a1 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/string_view",
      279,
      "constexpr const std::basic_string_view<_CharT, _Traits>::value_type& std::basic_string_view<_CharT, _Traits>::fron"
      "t() const [with _CharT = char; _Traits = std::char_traits<char>; const_reference = const char&]",
      "this->_M_len > 0");
  return a1[1];
}



================================================================================
Function: _ZNKSt8__format14__formatter_fpIcE11_M_localizeB5cxx11ESt17basic_string_viewIcSt11char_traitsIcEEcRKSt6locale at 0x224a6
================================================================================

std::locale *__fastcall std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](
        std::locale *a1,
        unsigned __int64 a2,
        unsigned __int64 a3,
        unsigned __int64 a4,
        char a5)
{
  __int64 v6; // rax
  int v7; // r8d
  int v8; // r9d
  unsigned __int64 v11[3]; // [rsp+10h] [rbp-C0h] BYREF
  std::locale *v12; // [rsp+28h] [rbp-A8h]
  unsigned __int64 *v13; // [rsp+30h] [rbp-A0h]
  __int64 v14; // [rsp+38h] [rbp-98h]
  _BYTE *v15; // [rsp+40h] [rbp-90h]
  __int64 *v16; // [rsp+48h] [rbp-88h]
  __int64 *v17; // [rsp+50h] [rbp-80h]
  char **v18; // [rsp+58h] [rbp-78h]
  char *v19; // [rsp+60h] [rbp-70h]
  __int64 v20; // [rsp+68h] [rbp-68h] BYREF
  __int64 v21; // [rsp+70h] [rbp-60h] BYREF
  char *v22; // [rsp+78h] [rbp-58h] BYREF
  _BYTE v23[39]; // [rsp+80h] [rbp-50h] BYREF
  char v24; // [rsp+A7h] [rbp-29h] BYREF
  char *v25; // [rsp+A8h] [rbp-28h] BYREF
  char v26; // [rsp+B6h] [rbp-1Ah]
  char v27; // [rsp+B7h] [rbp-19h]
  __int64 v28; // [rsp+B8h] [rbp-18h]

  v12 = a1;
  v11[2] = a2;
  v11[0] = a3;
  v11[1] = a4;
  std::string::basic_string(a1);
  std::locale::classic(a1);
  if ( !(unsigned __int8)std::locale::operator==() )
  {
    v28 = std::use_facet<std::numpunct<char>>();
    v24 = std::numpunct<char>::decimal_point();
    std::numpunct<char>::grouping();
    v27 = 46;
    v26 = a5;
    if ( !std::string::empty((__int64)v23) || v27 != v24 )
    {
      v22 = std::string_view::find(v11, v27, 0);
      v25 = std::string_view::find(v11, v26, 0);
      v21 = *std::min<unsigned long>(&v22, &v25);
      if ( v21 == -1 )
        v21 = std::string_view::size((__int64)v11);
      v6 = std::string_view::size((__int64)v11);
      v20 = v6 - v21;
      v13 = v11;
      v14 = v28;
      v15 = v23;
      v16 = &v21;
      v17 = &v20;
      v18 = &v22;
      v19 = &v24;
      std::string::__resize_and_overwrite<std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1}>(
        (_DWORD)v12,
        2 * v21 + v6 - v21,
        (_DWORD)v12,
        (unsigned int)&v24,
        v7,
        v8,
        v11,
        v28,
        v23,
        &v21,
        &v20,
        &v22,
        &v24);
    }
    std::string::~string((__int64)v23);
  }
  return v12;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIdNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_EN11_TerminatorD2Ev at 0x22720
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,double)::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIdNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_ at 0x2274e
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v5[4]; // [rsp+0h] [rbp-50h] BYREF
  __int128 v6; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+30h] [rbp-20h]
  __int64 v8; // [rsp+38h] [rbp-18h]

  v5[3] = (__int64)a1;
  v5[2] = a2;
  v5[0] = a3;
  v5[1] = a4;
  std::string::reserve(a1, a2);
  v8 = std::string::_M_data((__int64)a1);
  v6 = (unsigned __int64)a1;
  v7 = std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
         v5,
         v8,
         a2);
  *((_QWORD *)&v6 + 1) = v7;
  return std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<double,std::__format::_Sink_iter<char>>(double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,double)::_Terminator::~_Terminator((__int64 *)&v6);
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIeNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_EN11_TerminatorD2Ev at 0x22840
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,long double)::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIeNS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_ at 0x2286e
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v5[4]; // [rsp+0h] [rbp-50h] BYREF
  __int128 v6; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+30h] [rbp-20h]
  __int64 v8; // [rsp+38h] [rbp-18h]

  v5[3] = (__int64)a1;
  v5[2] = a2;
  v5[0] = a3;
  v5[1] = a4;
  std::string::reserve(a1, a2);
  v8 = std::string::_M_data((__int64)a1);
  v6 = (unsigned __int64)a1;
  v7 = std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)const::{lambda(char *,unsigned long)#1}::operator()(
         v5,
         v8,
         a2);
  *((_QWORD *)&v6 + 1) = v7;
  return std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<long double,std::__format::_Sink_iter<char>>(long double,std::basic_format_context<std::__format::_Sink_iter<char>,char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,long double)::_Terminator::~_Terminator((__int64 *)&v6);
}



================================================================================
Function: _ZNSt8__format15__formatter_strIcE8_S_truncERSt17basic_string_viewIcSt11char_traitsIcEEm at 0x2295f
================================================================================

__int64 __fastcall std::__format::__formatter_str<char>::_S_trunc(_QWORD *a1, __int64 a2)
{
  if ( a2 == -1 )
    return std::__unicode::__field_width<char>(*a1, a1[1]);
  else
    return std::__unicode::__truncate<char>(a1, a2);
}



================================================================================
Function: _ZNSt8__format9_Seq_sinkINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE4viewEv at 0x229a8
================================================================================

__int64 __fastcall std::__format::_Seq_sink<std::string>::view(__int64 a1)
{
  __int64 v1; // rdx
  __int64 v2; // rdx
  _QWORD v4[2]; // [rsp+10h] [rbp-60h] BYREF
  __int64 v5; // [rsp+20h] [rbp-50h] BYREF
  _QWORD v6[6]; // [rsp+38h] [rbp-38h] BYREF

  v6[4] = a1;
  v6[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v6[3] = a1 + 24;
  v6[2] = a1 + 24;
  v1 = *(_QWORD *)(a1 + 24);
  v6[1] = v6;
  v4[0] = std::span<char,18446744073709551615ul>::first(a1 + 8, v1 - v6[0]);
  v4[1] = v2;
  if ( !std::string::size(a1 + 288) )
    return v4[0];
  if ( std::span<char,18446744073709551615ul>::size((__int64)v4) )
    std::__format::_Seq_sink<std::string>::_M_overflow(a1);
  std::span<char,18446744073709551615ul>::span<std::string &>(&v5, a1 + 288);
  return v5;
}



================================================================================
Function: _ZNSt16basic_format_argISt20basic_format_contextINSt8__format10_Sink_iterIcEEcEE8_M_visitINS1_17_WidthPrecVisitorEEEDcOT_NS1_6_Arg_tE at 0x22a92
================================================================================

__int64 __fastcall std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_visit<std::__format::_WidthPrecVisitor>(
        __int64 a1,
        __int64 a2,
        unsigned __int8 a3)
{
  __int64 result; // rax

  result = a3;
  if ( a3 == 20 )
    std::__format::_WidthPrecVisitor::operator()<_Float128>(a2, a1);
  if ( a3 <= 0x14u )
  {
    if ( a3 == 15 )
      std::__format::_WidthPrecVisitor::operator()<unsigned __int128>(a2, a1);
    if ( a3 <= 0xFu )
    {
      switch ( a3 )
      {
        case 0xEu:
          std::__format::_WidthPrecVisitor::operator()<__int128>(a2, a1);
        case 0xDu:
          std::__format::_WidthPrecVisitor::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>(
            a2,
            a1);
        case 0xCu:
          std::__format::_WidthPrecVisitor::operator()<void const*>(a2, a1);
        case 0xBu:
          std::__format::_WidthPrecVisitor::operator()<std::string_view>(a2, a1);
        case 0xAu:
          std::__format::_WidthPrecVisitor::operator()<char const*>(a2, a1);
        case 9u:
          std::__format::_WidthPrecVisitor::operator()<long double>(a2, a1);
        case 8u:
          std::__format::_WidthPrecVisitor::operator()<double>(a2, a1);
        case 7u:
          std::__format::_WidthPrecVisitor::operator()<float>(a2, a1);
        case 6u:
          return std::__format::_WidthPrecVisitor::operator()<unsigned long long>(a2, a1);
        case 5u:
          return std::__format::_WidthPrecVisitor::operator()<long long>(a2, a1);
        case 4u:
          return std::__format::_WidthPrecVisitor::operator()<unsigned int>(a2, a1);
        case 3u:
          return std::__format::_WidthPrecVisitor::operator()<int>(a2, a1);
        case 2u:
          std::__format::_WidthPrecVisitor::operator()<char>(a2, a1);
        default:
          if ( a3 )
            std::__format::_WidthPrecVisitor::operator()<bool>(a2, a1);
          std::__format::_WidthPrecVisitor::operator()<std::monostate>(a2, a1);
      }
    }
  }
  return result;
}



================================================================================
Function: _ZNSt8__format18__visit_format_argINS_17_WidthPrecVisitorESt20basic_format_contextINS_10_Sink_iterIcEEcEEEDcOT_St16basic_format_argIT0_E at 0x22e66
================================================================================

__int64 __fastcall std::__format::__visit_format_arg<std::__format::_WidthPrecVisitor,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        char a7,
        int a8,
        unsigned __int8 a9)
{
  return std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::_M_visit<std::__format::_WidthPrecVisitor>(
           (__int64)&a7,
           a1,
           a9);
}



================================================================================
Function: _ZNSt8__format14__int_from_argISt20basic_format_contextINS_10_Sink_iterIcEEcEEEmRKSt16basic_format_argIT_E at 0x22e97
================================================================================

__int64 __fastcall std::__format::__int_from_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6)
{
  __int64 v6; // rdx
  __int64 v7; // rdx
  __int64 v9; // [rsp+0h] [rbp-40h] BYREF
  __int64 v10; // [rsp+8h] [rbp-38h]
  __int64 v11; // [rsp+10h] [rbp-30h]
  __int64 v12; // [rsp+18h] [rbp-28h]
  _QWORD *v13; // [rsp+28h] [rbp-18h]
  char v14; // [rsp+3Fh] [rbp-1h] BYREF

  v13 = a1;
  v6 = a1[1];
  v9 = *a1;
  v10 = v6;
  v7 = a1[3];
  v11 = a1[2];
  v12 = v7;
  return std::__format::__visit_format_arg<std::__format::_WidthPrecVisitor,std::basic_format_context<std::__format::_Sink_iter<char>,char>>(
           (__int64)&v14,
           (__int64)&v9,
           v7,
           (__int64)a1,
           a5,
           a6,
           v9,
           v10,
           v11);
}



================================================================================
Function: _ZNSt9__unicode21__is_single_code_unitIcEEbDi at 0x22edf
================================================================================

bool __fastcall std::__unicode::__is_single_code_unit<char>(unsigned int a1)
{
  return a1 <= 0x7E;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEC2ES2_S2_S2_Q22bidirectional_iteratorIT1_E at 0x22ef4
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_Utf_iterator(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 result; // rax

  std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_First_and_curr<char32_t const*>::_First_and_curr(
    a1 + 8,
    a2,
    a3);
  *(_BYTE *)(a1 + 24) = 0;
  *(_BYTE *)(a1 + 25) = 0;
  *(_BYTE *)(a1 + 26) = 0;
  *(_QWORD *)(a1 + 32) = a4;
  if ( *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1) != *(_QWORD *)(a1 + 32) )
    return std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_read(a1);
  result = a1;
  *(_DWORD *)a1 = 0;
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2INSt9__unicode13_Utf_iteratorIDicPKDiS9_NS6_5_ReplEEEvEET_SC_RKS3_ at 0x22f8c
================================================================================

__int64 __fastcall std::string::basic_string<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,void>(
        _QWORD *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int64 a7,
        __int64 a8,
        __int64 a9,
        __int64 a10,
        __int64 a11,
        __int64 a12,
        __int64 a13,
        __int64 a14,
        __int64 a15,
        __int64 a16)
{
  __int64 v16; // rax
  int v17; // esi
  int v18; // r8d
  int v19; // r9d

  v16 = std::string::_M_local_data((__int64)a1);
  v17 = v16;
  std::string::_Alloc_hider::_Alloc_hider(a1, v16);
  a1[1] = 0;
  return std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(
           (_DWORD)a1,
           v17,
           (_DWORD)a1,
           a11,
           v18,
           v19,
           a7,
           a8,
           a9,
           a10,
           a11,
           a12,
           a13,
           a14,
           a15,
           a16);
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterInEEcT_ at 0x23065
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<__int128>(__int128 a1)
{
  if ( 0x7F < a1 )
    std::__throw_format_error("format error: integer not representable as character");
  return a1;
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE8to_charsIoEESt15to_chars_resultPcS4_T_i at 0x230b5
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::to_chars<unsigned __int128>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        unsigned int a5)
{
  return std::__to_chars_i<unsigned __int128>(a1, a2, a3, a4, a5);
}



================================================================================
Function: _ZNSt8__format15__formatter_intIcE15_S_to_characterIoEEcT_ at 0x230f8
================================================================================

__int64 __fastcall std::__format::__formatter_int<char>::_S_to_character<unsigned __int128>(unsigned __int128 a1)
{
  if ( 0x7F < a1 )
    std::__throw_format_error("format error: integer not representable as character");
  return a1;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIDF128_NS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_EN11_TerminatorD2Ev at 0x23148
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator)::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE6formatIDF128_NS6_10_Sink_iterIcEEEENSt20basic_format_contextIT0_cE8iteratorET_RSE_EUlPcmE_EEvmSG_ at 0x23176
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        unsigned __int64 a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v5[4]; // [rsp+0h] [rbp-50h] BYREF
  __int128 v6; // [rsp+20h] [rbp-30h] BYREF
  __int64 v7; // [rsp+30h] [rbp-20h]
  __int64 v8; // [rsp+38h] [rbp-18h]

  v5[3] = (__int64)a1;
  v5[2] = a2;
  v5[0] = a3;
  v5[1] = a4;
  std::string::reserve(a1, a2);
  v8 = std::string::_M_data((__int64)a1);
  v6 = (unsigned __int64)a1;
  v7 = std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)const::{lambda(char *,unsigned long)#1}::operator()(
         v5,
         v8);
  *((_QWORD *)&v6 + 1) = v7;
  return std::string::__resize_and_overwrite<std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator std::__format::__formatter_fp<char>::format<_Float128,std::__format::_Sink_iter<char>>(_Float128,std::__format::_Sink_iter<char>&)::{lambda(char *,unsigned long)#1}>(unsigned long,std::basic_format_context<std::__format::_Sink_iter<char>,char>::iterator)::_Terminator::~_Terminator((__int64 *)&v6);
}



================================================================================
Function: _ZNSt6ranges14__copy_or_moveILb0EN9__gnu_cxx17__normal_iteratorIPcNSt4spanIcLm18446744073709551615EE10__iter_tagEEES7_NSt8__format10_Sink_iterIcEEEENSt13__conditionalIXT_EE4typeINS_13in_out_resultIT0_T2_EESH_EESF_T1_SG_ at 0x23267
================================================================================

__int64 __fastcall std::ranges::__copy_or_move<false,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,__gnu_cxx::__normal_iterator<char *,std::span<char,18446744073709551615ul>::__iter_tag>,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  return std::ranges::__copy_or_move<false,char *,char *,std::__format::_Sink_iter<char>>(a1, a2, a3);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignISt17basic_string_viewIcS2_EEENSt9enable_ifIXsrSt6__and_IJSt14is_convertibleIRKT_S7_ESt6__not_ISA_IPSC_PKS4_EESF_ISA_ISD_PKcEEEE5valueERS4_E4typeESD_ at 0x232ca
================================================================================

__int64 __fastcall std::string::assign<std::string_view>(__int64 a1, _QWORD *a2)
{
  __int64 v2; // rdx
  __int64 v3; // rbx
  __int64 v4; // rax
  _QWORD v6[3]; // [rsp+10h] [rbp-20h] BYREF

  v2 = a2[1];
  v6[0] = *a2;
  v6[1] = v2;
  v3 = std::string_view::size((__int64)v6);
  v4 = std::string_view::data((__int64)v6);
  return std::string::assign(a1, v4, v3);
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclISt9monostateEEmRT_ at 0x23328
================================================================================

void __fastcall __noreturn std::__format::_WidthPrecVisitor::operator()<std::monostate>(std::__format *a1)
{
  std::__format::__invalid_arg_id_in_format_string(a1);
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIbEEmRT_ at 0x23342
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<bool>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIiEEmRT_ at 0x23366
================================================================================

__int64 __fastcall std::__format::_WidthPrecVisitor::operator()<int>(__int64 a1, int *a2)
{
  if ( *a2 < 0 )
    std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
  return *a2;
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIjEEmRT_ at 0x233a0
================================================================================

__int64 __fastcall std::__format::_WidthPrecVisitor::operator()<unsigned int>(__int64 a1, unsigned int *a2)
{
  return *a2;
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIxEEmRT_ at 0x233ba
================================================================================

__int64 __fastcall std::__format::_WidthPrecVisitor::operator()<long long>(__int64 a1, __int64 a2)
{
  if ( *(__int64 *)a2 < 0 )
    std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
  return *(_QWORD *)a2;
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIyEEmRT_ at 0x233f4
================================================================================

__int64 __fastcall std::__format::_WidthPrecVisitor::operator()<unsigned long long>(__int64 a1, __int64 a2)
{
  return *(_QWORD *)a2;
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIfEEmRT_ at 0x2340e
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<float>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIdEEmRT_ at 0x23432
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<double>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIeEEmRT_ at 0x23456
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<long double>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIPKvEEmRT_ at 0x2347a
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<void const*>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclInEEmRT_ at 0x2349e
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<__int128>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIoEEmRT_ at 0x234c2
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<unsigned __int128>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIDF128_EEmRT_ at 0x234e6
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<_Float128>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZSt12__to_chars_iIoESt15to_chars_resultPcS1_T_i at 0x23509
================================================================================

__int64 __fastcall std::__to_chars_i<unsigned __int128>(
        _BYTE *a1,
        unsigned __int64 a2,
        unsigned __int64 a3,
        unsigned __int64 a4,
        int a5)
{
  unsigned __int128 v8; // [rsp+10h] [rbp-30h]

  v8 = __PAIR128__(a4, a3);
  if ( a5 <= 1 || a5 > 36 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/charconv",
      326,
      "constexpr std::to_chars_result std::__to_chars_i(char*, char*, _Tp, int) [with _Tp = __int128 unsigned]",
      "2 <= __base && __base <= 36");
  if ( (unsigned __int64)a1 >= a2 )
    return a2;
  if ( v8 == 0 )
  {
    *a1 = 48;
    return (__int64)(a1 + 1);
  }
  if ( a5 == 16 )
    return std::__detail::__to_chars_16<unsigned __int128>(a1, a2, v8, *((_QWORD *)&v8 + 1));
  if ( a5 <= 16 )
  {
    if ( a5 == 10 )
      return std::__detail::__to_chars_10<unsigned __int128>(a1, a2, v8, *((_QWORD *)&v8 + 1));
    if ( a5 <= 10 )
    {
      if ( a5 == 2 )
        return std::__detail::__to_chars_2<unsigned __int128>(a1, a2, v8, *((_QWORD *)&v8 + 1));
      if ( a5 == 8 )
        return std::__detail::__to_chars_8<unsigned __int128>(a1, a2, v8, *((_QWORD *)&v8 + 1));
    }
  }
  return std::__detail::__to_chars<unsigned __int128>(a1, a2, v8, *((_QWORD *)&v8 + 1), (unsigned int)a5);
}



================================================================================
Function: _ZNSt8__format8_EscapesIcE7_S_termENS_10_Term_charE at 0x236b2
================================================================================

__int64 __fastcall std::__format::_Escapes<char>::_S_term(unsigned __int8 a1)
{
  unsigned __int64 v2[2]; // [rsp+10h] [rbp-10h] BYREF

  v2[0] = 22;
  v2[1] = (unsigned __int64)"\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x";
  return *(unsigned __int8 *)std::string_view::operator[](v2, a1);
}



================================================================================
Function: _ZNKSt6ranges8__access6_BeginclIRSt17basic_string_viewIcSt11char_traitsIcEEEEDaOT_ at 0x236ee
================================================================================

__int64 __fastcall std::ranges::__access::_Begin::operator()<std::string_view &>(__int64 a1, __int64 a2)
{
  return std::string_view::begin(a2);
}



================================================================================
Function: _ZNKSt6ranges8__access4_EndclIRSt17basic_string_viewIcSt11char_traitsIcEEEEDaOT_ at 0x23710
================================================================================

__int64 __fastcall std::ranges::__access::_End::operator()<std::string_view &>(__int64 a1, _QWORD *a2)
{
  return std::string_view::end(a2);
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiSt17basic_string_viewIcSt11char_traitsIcEEEC2EOS4_ at 0x23732
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::string_view>::_Utf_view(__int64 *a1, __int64 *a2)
{
  __int64 v2; // rdx
  __int64 result; // rax

  v2 = a2[1];
  result = *a2;
  *a1 = *a2;
  a1[1] = v2;
  return result;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiSt17basic_string_viewIcSt11char_traitsIcEEE8_M_beginIPKcS8_EEDaT_T0_ at 0x23764
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::string_view>::_M_begin<char const*,char const*>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Utf_iterator(
    a1,
    a3,
    a3,
    a4);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiSt17basic_string_viewIcSt11char_traitsIcEEE5beginEv at 0x2379e
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::string_view>::begin(__int64 a1, _QWORD *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax

  v2 = std::ranges::__access::_End::operator()<std::string_view &>((__int64)&std::ranges::_Cpo::end, a2);
  v3 = std::ranges::__access::_Begin::operator()<std::string_view &>((__int64)&std::ranges::_Cpo::begin, (__int64)a2);
  std::__unicode::_Utf_view<char32_t,std::string_view>::_M_begin<char const*,char const*>(a1, (__int64)a2, v3, v2);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiSt17basic_string_viewIcSt11char_traitsIcEEE6_M_endIPKcS8_EEDaT_T0_ at 0x23804
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::string_view>::_M_end<char const*,char const*>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        __int64 a4)
{
  std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_Utf_iterator(
    a1,
    a3,
    a4,
    a4);
  return a1;
}



================================================================================
Function: _ZNSt9__unicode9_Utf_viewIDiSt17basic_string_viewIcSt11char_traitsIcEEE3endEv at 0x2383e
================================================================================

__int64 __fastcall std::__unicode::_Utf_view<char32_t,std::string_view>::end(__int64 a1, _QWORD *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rax

  v2 = std::ranges::__access::_End::operator()<std::string_view &>((__int64)&std::ranges::_Cpo::end, a2);
  v3 = std::ranges::__access::_Begin::operator()<std::string_view &>((__int64)&std::ranges::_Cpo::begin, (__int64)a2);
  std::__unicode::_Utf_view<char32_t,std::string_view>::_M_end<char const*,char const*>(a1, (__int64)a2, v3, v2);
  return a1;
}



================================================================================
Function: _ZZNSt8__format23__write_escaped_unicodeIcNS_10_Sink_iterIcEEEET0_S3_St17basic_string_viewIT_St11char_traitsIS5_EENS_10_Term_charEENKUlRKS5_E_clINSt9__unicode13_Utf_iteratorIcDiPKcSH_NSE_5_ReplEEEEEDaSB_ at 0x238a4
================================================================================

__int64 __fastcall std::__format::__write_escaped_unicode<char,std::__format::_Sink_iter<char>>(std::__format::_Sink_iter<char>,std::string_view,std::__format::_Term_char)::{lambda(char const&)#1}::operator()<std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>>(
        unsigned __int8 **a1,
        __int64 a2)
{
  unsigned int v2; // r12d
  char *v3; // rax
  unsigned __int8 *v4; // rbx
  char v6; // bl
  unsigned int v7; // eax
  unsigned __int8 *v8; // rax
  __int64 v9; // rbx
  __int64 v10; // rax
  bool v11; // dl
  bool *v12; // rax
  __int64 v13[4]; // [rsp+10h] [rbp-20h] BYREF

  if ( (unsigned int)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*(a2) > 0x7F )
  {
    v6 = *a1[2];
    v7 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*(a2);
    if ( std::__format::__should_escape_unicode((std::__format *)v7, v6) )
    {
      v8 = a1[3];
      *v8 = 1;
      return *v8;
    }
    else if ( (unsigned int)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*(a2) == 65533 )
    {
      v9 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_units(a2);
      v10 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base(a2);
      std::string_view::basic_string_view(v13, v10, v9);
      v11 = std::operator==<char,std::char_traits<char>>(v13[0], v13[1], (__int64)&dword_0 + 3, (__int64)&unk_28E30);
      v12 = (bool *)a1[4];
      *v12 = !v11;
      return *v12;
    }
    else
    {
      return 0;
    }
  }
  else
  {
    v2 = *a1[1];
    v3 = (char *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base(a2);
    v4 = *a1;
    *v4 = std::__format::__should_escape_ascii<char>((unsigned int)*v3, v2);
    return *v4;
  }
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE8_M_unitsEvQ16forward_iteratorIT1_E at 0x239d0
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_units(
        __int64 a1)
{
  return *(unsigned __int8 *)(a1 + 26);
}



================================================================================
Function: _ZNSt8__format23__write_escaped_unicodeIcNS_10_Sink_iterIcEEEET0_S3_St17basic_string_viewIT_St11char_traitsIS5_EENS_10_Term_charE at 0x239e9
================================================================================

__int64 __fastcall std::__format::__write_escaped_unicode<char,std::__format::_Sink_iter<char>>(
        __int64 a1,
        __int64 a2,
        __int64 a3,
        char a4)
{
  unsigned __int64 v4; // rsi
  unsigned __int8 **v5; // rdi
  int v6; // r8d
  int v7; // r9d
  int v8; // r8d
  int v9; // r9d
  int v10; // r8d
  int v11; // r9d
  int v13; // r8d
  int v14; // r9d
  __int64 v15; // rbx
  __int64 v16; // rax
  __int64 v18; // rbx
  __int64 v19; // rax
  __int64 v20[2]; // [rsp+0h] [rbp-170h] BYREF
  char v21; // [rsp+14h] [rbp-15Ch] BYREF
  __int64 v22; // [rsp+18h] [rbp-158h]
  unsigned __int8 *v23[6]; // [rsp+20h] [rbp-150h] BYREF
  __int64 v24; // [rsp+50h] [rbp-120h] BYREF
  __int64 v25; // [rsp+58h] [rbp-118h]
  __int64 v26; // [rsp+60h] [rbp-110h]
  __int64 v27; // [rsp+68h] [rbp-108h]
  __int64 v28; // [rsp+70h] [rbp-100h]
  _QWORD v29[3]; // [rsp+80h] [rbp-F0h] BYREF
  char v30; // [rsp+9Ch] [rbp-D4h] BYREF
  char v31; // [rsp+9Dh] [rbp-D3h] BYREF
  char v32; // [rsp+9Eh] [rbp-D2h] BYREF
  char v33; // [rsp+9Fh] [rbp-D1h] BYREF
  __int64 v34; // [rsp+A0h] [rbp-D0h] BYREF
  __int64 v35; // [rsp+A8h] [rbp-C8h]
  __int64 v36; // [rsp+B0h] [rbp-C0h]
  __int64 v37; // [rsp+B8h] [rbp-B8h]
  __int64 v38; // [rsp+C0h] [rbp-B0h]
  __int64 v39; // [rsp+D0h] [rbp-A0h] BYREF
  __int64 v40; // [rsp+D8h] [rbp-98h]
  __int64 v41; // [rsp+E0h] [rbp-90h]
  __int64 v42; // [rsp+E8h] [rbp-88h]
  __int64 v43; // [rsp+F0h] [rbp-80h]
  __int64 v44[2]; // [rsp+100h] [rbp-70h] BYREF
  __int64 v45[2]; // [rsp+110h] [rbp-60h] BYREF
  unsigned __int8 v46; // [rsp+127h] [rbp-49h]
  __int64 v47; // [rsp+128h] [rbp-48h]
  _QWORD *v48; // [rsp+130h] [rbp-40h]
  unsigned __int8 *v49; // [rsp+138h] [rbp-38h]

  v22 = a1;
  v20[0] = a2;
  v20[1] = a3;
  v21 = a4;
  std::__unicode::_Utf_view<char32_t,std::string_view>::_Utf_view(v44, v20);
  std::__unicode::_Utf_view<char32_t,std::string_view>::begin((__int64)&v39, v44);
  v4 = (unsigned __int64)v44;
  v5 = (unsigned __int8 **)&v34;
  std::__unicode::_Utf_view<char32_t,std::string_view>::end((__int64)&v34, v44);
  v33 = 1;
  while ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                             (_DWORD)v5,
                             v4,
                             v43,
                             v41,
                             v6,
                             v7,
                             v39,
                             v40,
                             v41,
                             v42,
                             v43,
                             v34,
                             v35,
                             v36,
                             v37,
                             v38) != 1 )
  {
    v32 = 0;
    v31 = 0;
    v30 = 0;
    v23[0] = (unsigned __int8 *)&v32;
    v23[1] = (unsigned __int8 *)&v21;
    v23[2] = (unsigned __int8 *)&v33;
    v23[3] = (unsigned __int8 *)&v31;
    v23[4] = (unsigned __int8 *)&v30;
    v24 = v39;
    v25 = v40;
    v26 = v41;
    v27 = v42;
    v28 = v43;
    while ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                               (_DWORD)v5,
                               v4,
                               v28,
                               v26,
                               v8,
                               v9,
                               v24,
                               v25,
                               v26,
                               v27,
                               v28,
                               v34,
                               v35,
                               v36,
                               v37) != 1 )
    {
      v4 = (unsigned __int64)&v24;
      v5 = v23;
      if ( (unsigned __int8)std::__format::__write_escaped_unicode<char,std::__format::_Sink_iter<char>>(std::__format::_Sink_iter<char>,std::string_view,std::__format::_Term_char)::{lambda(char const&)#1}::operator()<std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>>(
                              v23,
                              (__int64)&v24) == 1 )
        break;
      v33 = 0;
      v5 = (unsigned __int8 **)&v24;
      std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++((__int64)&v24);
    }
    if ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                            (_DWORD)v5,
                            v4,
                            v28,
                            v26,
                            v10,
                            v11,
                            v24,
                            v25,
                            v26,
                            v27,
                            v28,
                            v39,
                            v40,
                            v41,
                            v42) != 1 )
    {
      v15 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base((__int64)&v24);
      v16 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base((__int64)&v39);
      std::string_view::basic_string_view<char const*,char const*>(v45, v16, v15);
      LODWORD(v4) = v45[0];
      LODWORD(v5) = v22;
      v22 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v22, v45[0], v45[1]);
    }
    if ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                            (_DWORD)v5,
                            v4,
                            v28,
                            v26,
                            v13,
                            v14,
                            v24,
                            v25,
                            v26,
                            v27,
                            v28,
                            v34,
                            v35,
                            v36,
                            v37) )
      return v22;
    v39 = v24;
    v40 = v25;
    v41 = v26;
    v42 = v27;
    v43 = v28;
    if ( v32 )
    {
      v4 = (unsigned int)*(char *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base((__int64)&v39);
      v22 = std::__format::__write_escaped_char<std::__format::_Sink_iter<char>,char>(v22, v4);
    }
    else if ( v31 )
    {
      v4 = (unsigned int)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&v39);
      v22 = std::__format::__write_escape_seq<std::__format::_Sink_iter<char>,char>(v22, v4, 2, "\\u\\x");
    }
    else
    {
      v18 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_units((__int64)&v39);
      v19 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base((__int64)&v39);
      LODWORD(v4) = v19;
      std::string_view::basic_string_view(v29, v19, v18);
      v48 = v29;
      v49 = (unsigned __int8 *)std::string_view::begin((__int64)v29);
      v47 = std::string_view::end(v48);
      while ( v49 != (unsigned __int8 *)v47 )
      {
        v46 = *v49;
        LODWORD(v4) = v46;
        v22 = std::__format::__write_escape_seq<std::__format::_Sink_iter<char>,char>(v22, v46, 2, "\\x");
        ++v49;
      }
    }
    v33 = 1;
    v5 = (unsigned __int8 **)&v39;
    std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++((__int64)&v39);
  }
  return v22;
}



================================================================================
Function: _ZSt14__add_groupingIcEPT_S1_S0_PKcmPKS0_S5_ at 0x23f98
================================================================================

_BYTE *__fastcall std::__add_grouping<char>(_BYTE *a1, char a2, __int64 a3, __int64 a4, char *a5, char *a6)
{
  char *v6; // rax
  char v7; // dl
  _BYTE *v8; // rax
  _BYTE *v9; // rax
  char *v10; // rax
  char v11; // dl
  _BYTE *v12; // rax
  _BYTE *v14; // rax
  char *v15; // rax
  char v16; // dl
  _BYTE *v17; // rax
  char *v21; // [rsp+8h] [rbp-48h]
  char j; // [rsp+3Eh] [rbp-12h]
  char i; // [rsp+3Fh] [rbp-11h]
  __int64 v26; // [rsp+40h] [rbp-10h]
  unsigned __int64 v27; // [rsp+48h] [rbp-8h]

  v21 = a5;
  v27 = 0;
  v26 = 0;
  while ( a6 - a5 > *(char *)(a3 + v27) && *(char *)(a3 + v27) > 0 && *(_BYTE *)(a3 + v27) != 127 )
  {
    a6 -= *(char *)(a3 + v27);
    if ( v27 >= a4 - 1 )
      ++v26;
    else
      ++v27;
  }
  while ( v21 != a6 )
  {
    v6 = v21++;
    v7 = *v6;
    v8 = a1++;
    *v8 = v7;
  }
  while ( v26-- )
  {
    v9 = a1++;
    *v9 = a2;
    for ( i = *(_BYTE *)(a3 + v27); i > 0; --i )
    {
      v10 = v21++;
      v11 = *v10;
      v12 = a1++;
      *v12 = v11;
    }
  }
  while ( v27-- )
  {
    v14 = a1++;
    *v14 = a2;
    for ( j = *(_BYTE *)(a3 + v27); j > 0; --j )
    {
      v15 = v21++;
      v16 = *v15;
      v17 = a1++;
      *v17 = v16;
    }
  }
  return a1;
}



================================================================================
Function: _ZNSt8__format5_SpecIcE7_S_signEc at 0x24147
================================================================================

__int64 __fastcall std::__format::_Spec<char>::_S_sign(char a1)
{
  if ( a1 == 45 )
    return 2;
  if ( a1 <= 45 )
  {
    if ( a1 == 32 )
      return 3;
    if ( a1 == 43 )
      return 1;
  }
  return 0;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE11_M_localizeESt17basic_string_viewIcS2_EcRKSt6localeEUlPcmE_EEvmT_EN11_TerminatorD2Ev at 0x24188
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1}>(unsigned long,std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1})::_Terminator::~_Terminator(
        __int64 *a1)
{
  return std::string::_M_set_length(*a1, a1[1]);
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE22__resize_and_overwriteIZNKSt8__format14__formatter_fpIcE11_M_localizeESt17basic_string_viewIcS2_EcRKSt6localeEUlPcmE_EEvmT_ at 0x241b6
================================================================================

_BYTE *__fastcall std::string::__resize_and_overwrite<std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1}>(
        _QWORD *a1,
        unsigned __int64 a2,
        _DWORD a3,
        _DWORD a4,
        _DWORD a5,
        _DWORD a6,
        __int64 a7)
{
  __int64 v8[2]; // [rsp+10h] [rbp-30h] BYREF
  __int64 v9; // [rsp+20h] [rbp-20h]
  _BYTE *v10; // [rsp+28h] [rbp-18h]

  std::string::reserve(a1, a2);
  v10 = (_BYTE *)std::string::_M_data((__int64)a1);
  v8[0] = (__int64)a1;
  v9 = std::__format::__formatter_fp<char>::_M_localize[abi:cxx11](std::string_view,char,std::locale const&)const::{lambda(char *,unsigned long)#1}::operator()(
         &a7,
         v10);
  v8[1] = v9;
  return std::string::__resize_and_overwrite<std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1}>(unsigned long,std::__format::__formatter_fp<char>::_M_localize(std::string_view,char,std::locale const&)::{lambda(char *,unsigned long)#1})::_Terminator::~_Terminator(v8);
}



================================================================================
Function: _ZNSt8__format5_SinkIcE8_M_writeEc at 0x242c0
================================================================================

char __fastcall std::__format::_Sink<char>::_M_write(__int64 a1, char a2)
{
  _BYTE *v2; // rax
  __int64 v3; // rdx
  __int64 v4; // rbx
  char result; // al
  _QWORD v6[3]; // [rsp+18h] [rbp-58h] BYREF
  int v7; // [rsp+34h] [rbp-3Ch]
  __int64 v8; // [rsp+38h] [rbp-38h]
  _QWORD *v9; // [rsp+40h] [rbp-30h]
  __int64 v10; // [rsp+48h] [rbp-28h]
  __int64 v11; // [rsp+50h] [rbp-20h]
  __int64 v12; // [rsp+58h] [rbp-18h]

  v8 = a1 + 24;
  v7 = 0;
  v2 = *(_BYTE **)(a1 + 24);
  *(_QWORD *)(a1 + 24) = v2 + 1;
  v6[1] = v2;
  v6[2] = v2;
  *v2 = a2;
  v6[0] = std::span<char,18446744073709551615ul>::begin(a1 + 8);
  v11 = a1 + 24;
  v10 = a1 + 24;
  v3 = *(_QWORD *)(a1 + 24);
  v9 = v6;
  v4 = v3 - v6[0];
  v12 = a1 + 8;
  result = v4 == std::span<char,18446744073709551615ul>::size(a1 + 8);
  if ( result )
    return (**(__int64 (__fastcall ***)(__int64))a1)(a1);
  return result;
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE5beginEv at 0x2439a
================================================================================

_QWORD *__fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::begin(_QWORD *a1, _QWORD *a2)
{
  __int64 v2; // rbx
  __int64 v3; // rbx
  __int64 v4; // rbx

  v2 = a2[1];
  *a1 = *a2;
  a1[1] = v2;
  v3 = a2[3];
  a1[2] = a2[2];
  a1[3] = v3;
  v4 = a2[5];
  a1[4] = a2[4];
  a1[5] = v4;
  a1[6] = a2[6];
  return a1;
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_Iterator3endEv at 0x243f4
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::end(__int64 a1)
{
  return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::end(a1 + 16);
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE3endEv at 0x24416
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::end(__int64 a1)
{
  return std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::end(a1);
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_Iterator5widthEv at 0x24434
================================================================================

unsigned __int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::width(
        unsigned int *a1)
{
  return std::__unicode::__v16_0_0::__field_width((std::__unicode::__v16_0_0 *)*a1);
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_Iterator4baseEv at 0x24454
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::base(__int64 a1)
{
  return std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::base(a1 + 16);
}



================================================================================
Function: _ZNSt9__unicode10__truncateIcEEmRSt17basic_string_viewIT_St11char_traitsIS2_EEm at 0x24476
================================================================================

unsigned __int64 __fastcall std::__unicode::__truncate<char>(_QWORD *a1, unsigned __int64 a2)
{
  __int64 v3; // rdx
  __int64 v4; // rdx
  __int64 v5; // rbx
  __int64 v6; // rax
  __int64 v7; // rdx
  __int64 v8; // rax
  __int64 v9; // [rsp+18h] [rbp-C8h] BYREF
  unsigned int v10[16]; // [rsp+20h] [rbp-C0h] BYREF
  _QWORD v11[8]; // [rsp+60h] [rbp-80h] BYREF
  _QWORD v12[2]; // [rsp+A0h] [rbp-40h] BYREF
  _QWORD v13[2]; // [rsp+B0h] [rbp-30h] BYREF
  unsigned __int64 v14; // [rsp+C0h] [rbp-20h]
  unsigned __int64 v15; // [rsp+C8h] [rbp-18h]

  if ( (unsigned __int8)std::string_view::empty(a1) )
    return 0;
  std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Grapheme_cluster_view(v11, *a1, a1[1]);
  std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::begin(v10, v11);
  v9 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::end((__int64)v11);
  v15 = (int)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::width(v10);
  if ( a2 >= v15 )
  {
    while ( 1 )
    {
      v8 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator++(v10);
      if ( (unsigned __int8)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator==(
                              v8,
                              &v9) == 1 )
        break;
      v4 = (int)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::width(v10);
      v14 = v4 + v15;
      if ( a2 < v4 + v15 )
      {
        v5 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::base((__int64)v10);
        v6 = std::string_view::begin((__int64)a1);
        std::string_view::basic_string_view<char const*,char const*>(v13, v6, v5);
        v7 = v13[1];
        *a1 = v13[0];
        a1[1] = v7;
        return v15;
      }
      v15 = v14;
    }
    return v15;
  }
  else
  {
    std::string_view::basic_string_view(v12);
    v3 = v12[1];
    *a1 = v12[0];
    a1[1] = v3;
    return 0;
  }
}



================================================================================
Function: _ZNKSt17basic_string_viewIcSt11char_traitsIcEE5emptyEv at 0x24606
================================================================================

bool __fastcall std::string_view::empty(_QWORD *a1)
{
  return *a1 == 0;
}



================================================================================
Function: _ZNSt9__unicode13__field_widthIcEEmSt17basic_string_viewIT_St11char_traitsIS2_EE at 0x24621
================================================================================

__int64 __fastcall std::__unicode::__field_width<char>(__int64 a1, __int64 a2)
{
  int v3; // eax
  __int64 v4; // rax
  __int64 v5; // [rsp+0h] [rbp-A0h] BYREF
  __int64 v6; // [rsp+8h] [rbp-98h]
  __int64 v7; // [rsp+18h] [rbp-88h] BYREF
  unsigned int v8[16]; // [rsp+20h] [rbp-80h] BYREF
  _QWORD v9[7]; // [rsp+60h] [rbp-40h] BYREF
  __int64 i; // [rsp+98h] [rbp-8h]

  v5 = a1;
  v6 = a2;
  if ( std::string_view::empty(&v5) )
    return 0;
  std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Grapheme_cluster_view(v9, v5, v6);
  std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::begin(v8, v9);
  v7 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::end((__int64)v9);
  for ( i = (int)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::width(v8); ; i += v3 )
  {
    v4 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator++(v8);
    if ( (unsigned __int8)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator==(
                            v4,
                            &v7) == 1 )
      break;
    v3 = std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::width(v8);
  }
  return i;
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIcEEmRT_ at 0x24704
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<char>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclIPKcEEmRT_ at 0x24728
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<char const*>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclISt17basic_string_viewIcSt11char_traitsIcEEEEmRT_ at 0x2474c
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<std::string_view>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNKSt8__format17_WidthPrecVisitorclINSt16basic_format_argISt20basic_format_contextINS_10_Sink_iterIcEEcEE6handleEEEmRT_ at 0x24770
================================================================================

void __noreturn std::__format::_WidthPrecVisitor::operator()<std::basic_format_arg<std::basic_format_context<std::__format::_Sink_iter<char>,char>>::handle>()
{
  std::__throw_format_error("format error: argument used for width or precision must be a non-negative integer");
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE15_First_and_currIS2_EC2ES2_S2_ at 0x24794
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_First_and_curr<char32_t const*>::_First_and_curr(
        _QWORD *a1,
        __int64 a2,
        __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a2;
  result = a1;
  a1[1] = a3;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE7_M_currEv at 0x247c2
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(
        __int64 a1)
{
  return a1 + 16;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE7_M_readEv at 0x247d8
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_read(
        __int64 a1)
{
  return std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_read_utf32(a1);
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructINSt9__unicode13_Utf_iteratorIDicPKDiS9_NS6_5_ReplEEEEEvT_SC_St18input_iterator_tagEN6_GuardC2EPS4_ at 0x247f8
================================================================================

_QWORD *__fastcall std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::input_iterator_tag)::_Guard::_Guard(
        _QWORD *a1,
        __int64 a2)
{
  _QWORD *result; // rax

  result = a1;
  *a1 = a2;
  return result;
}



================================================================================
Function: _ZZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructINSt9__unicode13_Utf_iteratorIDicPKDiS9_NS6_5_ReplEEEEEvT_SC_St18input_iterator_tagEN6_GuardD2Ev at 0x24816
================================================================================

__int64 __fastcall std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::input_iterator_tag)::_Guard::~_Guard(
        __int64 *a1)
{
  __int64 result; // rax

  result = *a1;
  if ( *a1 )
    return std::string::_M_dispose(*a1);
  return result;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructINSt9__unicode13_Utf_iteratorIDicPKDiS9_NS6_5_ReplEEEEEvT_SC_St18input_iterator_tag at 0x24844
================================================================================

__int64 __fastcall std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(
        __int64 *a1,
        int a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int64 a7,
        __int64 a8,
        __int64 a9,
        __int64 a10,
        __int64 a11,
        __int64 a12,
        __int64 a13,
        __int64 a14,
        __int64 a15,
        __int64 a16)
{
  int v16; // r8d
  int v17; // r9d
  char v18; // dl
  __int64 v19; // rax
  char *v21; // rsi
  __int64 *v22; // rdi
  int v23; // r8d
  int v24; // r9d
  _BYTE *v25; // rax
  __int64 v26; // rdx
  __int64 v27; // rax
  __int64 *v29; // [rsp+8h] [rbp-58h]
  __int64 v30; // [rsp+18h] [rbp-48h] BYREF
  unsigned __int64 v31; // [rsp+20h] [rbp-40h] BYREF
  char v32; // [rsp+2Fh] [rbp-31h] BYREF
  unsigned __int64 i; // [rsp+30h] [rbp-30h]
  __int64 *v34; // [rsp+38h] [rbp-28h]
  _BYTE *v35; // [rsp+40h] [rbp-20h]
  unsigned __int64 v36; // [rsp+48h] [rbp-18h]

  v29 = a1;
  v36 = 0;
  v31 = 15;
  v34 = a1;
  if ( (unsigned __int8)std::is_constant_evaluated() )
  {
    for ( i = 0; i <= 0xF; ++i )
      *((_BYTE *)v34 + i + 16) = 0;
  }
  while ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                             (_DWORD)a1,
                             a2,
                             a11,
                             a9,
                             v16,
                             v17,
                             a7,
                             a8,
                             a9,
                             a10,
                             a11,
                             a12,
                             a13,
                             a14,
                             a15,
                             a16) != 1
       && v36 < v31 )
  {
    v18 = std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator*(&a7);
    v19 = v36++;
    *((_BYTE *)v29 + v19 + 16) = v18;
    a1 = &a7;
    std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator++(&a7);
  }
  LODWORD(v21) = (_DWORD)v29;
  v22 = &v30;
  std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::input_iterator_tag)::_Guard::_Guard(
    &v30,
    (__int64)v29);
  while ( (unsigned __int8)ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
                             (_DWORD)v22,
                             (_DWORD)v21,
                             a11,
                             a9,
                             v23,
                             v24,
                             a7,
                             a8,
                             a9,
                             a10,
                             a11,
                             a12,
                             a13,
                             a14,
                             a15,
                             a16) != 1 )
  {
    if ( v36 == v31 )
    {
      v31 = v36 + 1;
      v35 = (_BYTE *)std::string::_M_create((__int64)v29, (__int64 *)&v31, v36);
      v25 = (_BYTE *)std::string::_M_data((__int64)v29);
      std::string::_S_copy(v35, v25, v36);
      std::string::_M_dispose((__int64)v29);
      std::string::_M_data(v29, (__int64)v35);
      std::string::_M_capacity((__int64)v29, v31);
    }
    v32 = std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator*(&a7);
    v26 = std::string::_M_data((__int64)v29);
    v27 = v36++;
    v21 = &v32;
    std::char_traits<char>::assign((_BYTE *)(v27 + v26), &v32);
    v22 = &a7;
    std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator++(&a7);
  }
  v30 = 0;
  std::string::_M_set_length((__int64)v29, v36);
  return std::string::_M_construct<std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>>(std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>,std::input_iterator_tag)::_Guard::~_Guard(&v30);
}



================================================================================
Function: _ZNSt6ranges14__copy_or_moveILb0EPcS1_NSt8__format10_Sink_iterIcEEEENSt13__conditionalIXT_EE4typeINS_13in_out_resultIT0_T2_EESB_EES9_T1_SA_ at 0x24aef
================================================================================

char *__fastcall std::ranges::__copy_or_move<false,char *,char *,std::__format::_Sink_iter<char>>(
        char *a1,
        __int64 a2,
        __int64 a3)
{
  char v3; // al
  __int64 v5[2]; // [rsp+8h] [rbp-48h] BYREF
  char *v6; // [rsp+18h] [rbp-38h]
  char v7; // [rsp+27h] [rbp-29h]
  __int64 *v8; // [rsp+28h] [rbp-28h]
  __int64 *v9; // [rsp+30h] [rbp-20h]
  __int64 i; // [rsp+38h] [rbp-18h]

  v6 = a1;
  v5[1] = a2;
  v5[0] = a3;
  for ( i = a2 - (_QWORD)a1; i > 0; --i )
  {
    v3 = *v6;
    v9 = v5;
    v8 = v5;
    v7 = v3;
    std::__format::_Sink<char>::_M_write(v5[0], v3);
    ++v6;
  }
  return v6;
}



================================================================================
Function: _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKcm at 0x24b8a
================================================================================

_QWORD *__fastcall std::string::assign(_QWORD *a1, _BYTE *a2, unsigned __int64 a3)
{
  __int64 v3; // rax

  v3 = std::string::size((__int64)a1);
  return std::string::_M_replace(a1, 0, v3, a2, a3);
}



================================================================================
Function: _ZNSt8__detail16__to_chars_len_2IoEEjT_ at 0x24bd5
================================================================================

__int64 __fastcall std::__detail::__to_chars_len_2<unsigned __int128>(__int64 a1, __int64 a2)
{
  return std::__bit_width<unsigned __int128>(a1, a2);
}



================================================================================
Function: _ZNSt8__detail13__to_chars_16IoEESt15to_chars_resultPcS2_T_ at 0x24c0f
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_16<unsigned __int128>(_BYTE *a1, __int64 a2, __int64 a3, __int64 a4)
{
  unsigned __int128 v5; // [rsp+0h] [rbp-70h]
  unsigned __int128 v6; // [rsp+0h] [rbp-70h]
  _QWORD v7[3]; // [rsp+20h] [rbp-50h] BYREF
  __int64 v8; // [rsp+38h] [rbp-38h]
  __int64 v9; // [rsp+40h] [rbp-30h]
  __int64 v10; // [rsp+48h] [rbp-28h]
  __int64 v11; // [rsp+50h] [rbp-20h]
  __int64 v12; // [rsp+58h] [rbp-18h]
  unsigned int v13; // [rsp+68h] [rbp-8h]
  unsigned int v14; // [rsp+6Ch] [rbp-4h]

  v5 = __PAIR128__(a4, a3);
  v13 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned __int128>(a3, a4) + 3) >> 2;
  if ( a2 - (__int64)a1 >= (unsigned __int64)v13 )
  {
    qmemcpy(v7, "0123456789abcdef", 16);
    v14 = v13 - 1;
    while ( 0xFF < v5 )
    {
      v9 = v5 & 0xF;
      v10 = 0;
      v6 = v5 >> 4;
      a1[v14] = *((_BYTE *)v7 + v9);
      v9 = v6 & 0xF;
      v10 = 0;
      v5 = v6 >> 4;
      a1[v14 - 1] = *((_BYTE *)v7 + v9);
      v14 -= 2;
    }
    if ( 0xF < v5 )
    {
      v11 = v5 & 0xF;
      v12 = 0;
      v5 >>= 4;
      a1[1] = *((_BYTE *)v7 + v11);
    }
    *a1 = *((_BYTE *)v7 + v5);
    return &a1[v13];
  }
  else
  {
    v7[2] = a2;
    LODWORD(v8) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt8__detail14__to_chars_lenIoEEjT_i at 0x24e06
================================================================================

__int64 __fastcall std::__detail::__to_chars_len<unsigned __int128>(unsigned __int128 a1, unsigned int a2)
{
  unsigned __int128 v3; // rax
  unsigned __int64 v6; // [rsp+28h] [rbp-28h]
  unsigned int v7; // [rsp+34h] [rbp-1Ch]
  unsigned int v8; // [rsp+38h] [rbp-18h]
  unsigned int v9; // [rsp+3Ch] [rbp-14h]

  v9 = 1;
  v8 = a2 * a2;
  v7 = a2 * a2 * a2;
  v6 = v7 * a2;
  while ( 1 )
  {
    if ( a1 < a2 )
      return v9;
    if ( a1 < v8 )
      return v9 + 1;
    if ( a1 < v7 )
      return v9 + 2;
    if ( a1 < v6 )
      break;
    *(_QWORD *)&v3 = __udivti3();
    a1 = v3;
    v9 += 4;
  }
  return v9 + 3;
}



================================================================================
Function: _ZNSt8__detail13__to_chars_10IoEESt15to_chars_resultPcS2_T_ at 0x24f08
================================================================================

__int64 __fastcall std::__detail::__to_chars_10<unsigned __int128>(
        __int64 a1,
        __int64 a2,
        unsigned __int64 a3,
        unsigned __int64 a4)
{
  unsigned int v7; // [rsp+3Ch] [rbp-4h]

  v7 = std::__detail::__to_chars_len<unsigned __int128>(__PAIR128__(a4, a3), 0xAu);
  if ( a2 - a1 < (unsigned __int64)v7 )
    return a2;
  std::__detail::__to_chars_10_impl<unsigned __int128>(a1, v7, a3, a4);
  return v7 + a1;
}



================================================================================
Function: _ZNSt8__detail12__to_chars_8IoEESt15to_chars_resultPcS2_T_ at 0x24fad
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_8<unsigned __int128>(_BYTE *a1, __int64 a2, __int64 a3, __int64 a4)
{
  unsigned __int128 v5; // [rsp+0h] [rbp-60h]
  unsigned __int128 v6; // [rsp+0h] [rbp-60h]
  char v7; // [rsp+30h] [rbp-30h]
  char v8; // [rsp+30h] [rbp-30h]
  char v9; // [rsp+40h] [rbp-20h]
  unsigned int v10; // [rsp+58h] [rbp-8h]
  unsigned int v11; // [rsp+5Ch] [rbp-4h]

  v5 = __PAIR128__(a4, a3);
  v10 = ((unsigned int)std::__detail::__to_chars_len_2<unsigned __int128>(a3, a4) + 2) / 3;
  if ( a2 - (__int64)a1 < (unsigned __int64)v10 )
    return (_BYTE *)a2;
  v11 = v10 - 1;
  while ( 0x3F < v5 )
  {
    v7 = v5 & 7;
    v6 = v5 >> 3;
    a1[v11] = v7 + 48;
    v8 = v6 & 7;
    v5 = v6 >> 3;
    a1[v11 - 1] = v8 + 48;
    v11 -= 2;
  }
  if ( 7 < v5 )
  {
    v9 = v5 & 7;
    v5 >>= 3;
    a1[1] = v9 + 48;
  }
  *a1 = v5 + 48;
  return &a1[v10];
}



================================================================================
Function: _ZNSt8__detail12__to_chars_2IoEESt15to_chars_resultPcS2_T_ at 0x25180
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_2<unsigned __int128>(_BYTE *a1, __int64 a2, __int64 a3, __int64 a4)
{
  unsigned int v5; // eax
  unsigned __int128 v6; // [rsp+0h] [rbp-40h]
  unsigned int v7; // [rsp+38h] [rbp-8h]
  unsigned int i; // [rsp+3Ch] [rbp-4h]

  v6 = __PAIR128__(a4, a3);
  v7 = std::__detail::__to_chars_len_2<unsigned __int128>(a3, a4);
  if ( a2 - (__int64)a1 < (unsigned __int64)v7 )
    return (_BYTE *)a2;
  for ( i = v7 - 1; i; --i )
  {
    v5 = i;
    a1[v5] = (v6 & 1) + 48;
    v6 >>= 1;
  }
  *a1 = 49;
  return &a1[v7];
}



================================================================================
Function: _ZNSt8__detail10__to_charsIoEESt15to_chars_resultPcS2_T_i at 0x25257
================================================================================

_BYTE *__fastcall std::__detail::__to_chars<unsigned __int128>(
        _BYTE *a1,
        __int64 a2,
        unsigned __int64 a3,
        unsigned __int64 a4,
        unsigned int a5)
{
  __int64 v6; // rdx
  __int64 v7; // rdx
  int v8; // eax
  unsigned __int128 v10; // [rsp+10h] [rbp-A0h]
  _QWORD v11[7]; // [rsp+30h] [rbp-80h] BYREF
  __int64 v12; // [rsp+68h] [rbp-48h]
  __int64 v13; // [rsp+70h] [rbp-40h]
  __int64 v14; // [rsp+78h] [rbp-38h]
  unsigned __int128 v15; // [rsp+80h] [rbp-30h]
  unsigned int v16; // [rsp+98h] [rbp-18h]
  unsigned int v17; // [rsp+9Ch] [rbp-14h]

  v10 = __PAIR128__(a4, a3);
  v16 = std::__detail::__to_chars_len<unsigned __int128>(__PAIR128__(a4, a3), a5);
  if ( a2 - (__int64)a1 >= (unsigned __int64)v16 )
  {
    v17 = v16 - 1;
    qmemcpy(v11, "0123456789abcdefghijklmnopqrstuvwxyz", 36);
    while ( v10 >= a5 )
    {
      *(_QWORD *)&v15 = __udivti3();
      *((_QWORD *)&v15 + 1) = v6;
      v13 = __umodti3();
      v14 = v7;
      LOBYTE(v7) = *((_BYTE *)v11 + v13);
      v8 = v17--;
      a1[v8] = v7;
      v10 = v15;
    }
    *a1 = *((_BYTE *)v11 + v10);
    return &a1[v16];
  }
  else
  {
    v11[6] = a2;
    LODWORD(v12) = 75;
    return (_BYTE *)a2;
  }
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E at 0x25438
================================================================================

_BOOL8 __fastcall ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
        _DWORD a1,
        _DWORD a2,
        _DWORD a3,
        _DWORD a4,
        _DWORD a5,
        _DWORD a6,
        char a7,
        int a8,
        int a9,
        char a10,
        int a11,
        char a12,
        int a13,
        int a14,
        char a15)
{
  __int64 v15; // rbx

  v15 = *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr((__int64)&a7);
  return v15 == *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr((__int64)&a12)
      && a10 == a15;
}



================================================================================
Function: _ZNSt8__format21__should_escape_asciiIcEEbT_NS_10_Term_charE at 0x25483
================================================================================

char __fastcall std::__format::__should_escape_ascii<char>(unsigned __int8 a1, char a2)
{
  if ( a1 == 92 )
    return 1;
  if ( (char)a1 <= 92 )
  {
    if ( a1 == 39 )
      return a2 == 15;
    if ( (char)a1 <= 39 )
    {
      if ( a1 == 34 )
        return a2 == 12;
      if ( (char)a1 <= 34 )
      {
        if ( (char)a1 <= 10 )
        {
          if ( (char)a1 < 9 )
            return a1 < 0x20u || a1 == 127;
          return 1;
        }
        if ( a1 == 13 )
          return 1;
      }
    }
  }
  return a1 < 0x20u || a1 == 127;
}



================================================================================
Function: _ZNSt8__format20__write_escaped_charINS_10_Sink_iterIcEEcEET_S3_T0_ at 0x25502
================================================================================

__int64 __fastcall std::__format::__write_escaped_char<std::__format::_Sink_iter<char>,char>(
        __int64 a1,
        unsigned __int8 a2)
{
  __int64 v2; // rax
  __int64 v3; // rdx
  __int64 v5; // rax
  __int64 v6; // rdx
  __int64 v7; // rax
  __int64 v8; // rdx
  __int64 v9; // rax
  __int64 v10; // rdx
  __int64 v11; // rax
  __int64 v12; // rdx
  __int64 v13; // rax
  __int64 v14; // rdx
  _QWORD v15[2]; // [rsp+10h] [rbp-70h] BYREF
  _QWORD v16[2]; // [rsp+20h] [rbp-60h] BYREF
  _QWORD v17[2]; // [rsp+30h] [rbp-50h] BYREF
  _QWORD v18[2]; // [rsp+40h] [rbp-40h] BYREF
  _QWORD v19[2]; // [rsp+50h] [rbp-30h] BYREF
  _QWORD v20[3]; // [rsp+60h] [rbp-20h] BYREF

  if ( a2 == 92 )
  {
    v18[0] = 3;
    v18[1] = "\\\\\\\"\\\"'\\'\\u\\x";
    v9 = std::string_view::substr(v18, 1u, 2);
    return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v9, v10);
  }
  if ( (char)a2 <= 92 )
  {
    if ( a2 == 39 )
    {
      v20[0] = 3;
      v20[1] = "'\\'\\u\\x";
      v13 = std::string_view::substr(v20, 1u, 2);
      return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v13, v14);
    }
    if ( (char)a2 <= 39 )
    {
      if ( a2 == 34 )
      {
        v19[0] = 3;
        v19[1] = "\"\\\"'\\'\\u\\x";
        v11 = std::string_view::substr(v19, 1u, 2);
        return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v11, v12);
      }
      if ( (char)a2 <= 34 )
      {
        if ( a2 == 13 )
        {
          v17[0] = 3;
          v17[1] = "\r\\r\\\\\\\"\\\"'\\'\\u\\x";
          v7 = std::string_view::substr(v17, 1u, 2);
          return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v7, v8);
        }
        if ( (char)a2 <= 13 )
        {
          if ( a2 == 9 )
          {
            v15[0] = 3;
            v15[1] = "\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x";
            v2 = std::string_view::substr(v15, 1u, 2);
            return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v2, v3);
          }
          if ( a2 == 10 )
          {
            v16[0] = 3;
            v16[1] = "\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x";
            v5 = std::string_view::substr(v16, 1u, 2);
            return std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, v5, v6);
          }
        }
      }
    }
  }
  return std::__format::__write_escape_seq<std::__format::_Sink_iter<char>,char>(a1, a2, 2, "\\u\\x");
}



================================================================================
Function: _ZNSt8__format18__write_escape_seqINS_10_Sink_iterIcEEcEET_S3_jSt17basic_string_viewIT0_St11char_traitsIS5_EE at 0x2571c
================================================================================

__int64 __fastcall std::__format::__write_escape_seq<std::__format::_Sink_iter<char>,char>(
        __int64 a1,
        unsigned int a2,
        __int64 a3,
        __int64 a4)
{
  __int64 v4; // rax
  char v5; // al
  char v6; // al
  __int64 v10; // [rsp+18h] [rbp-78h] BYREF
  __int64 v11[3]; // [rsp+20h] [rbp-70h] BYREF
  _BYTE v12[8]; // [rsp+38h] [rbp-58h] BYREF
  unsigned __int64 v13[2]; // [rsp+40h] [rbp-50h] BYREF
  unsigned __int64 v14[3]; // [rsp+50h] [rbp-40h] BYREF
  char v15; // [rsp+6Fh] [rbp-21h]
  __int64 *v16; // [rsp+70h] [rbp-20h]
  char v17; // [rsp+7Fh] [rbp-11h]
  __int64 *v18; // [rsp+80h] [rbp-10h]
  __int64 v19; // [rsp+88h] [rbp-8h]

  v19 = 8;
  v4 = std::__to_chars_i<unsigned int>(v12, (unsigned __int64)v13, a2, 16);
  std::string_view::basic_string_view<char *,char *>(v11, v12, v4);
  v10 = std::__format::__write<std::__format::_Sink_iter<char>,char>(a1, a3, a4);
  v13[0] = 2;
  v13[1] = (unsigned __int64)"{}(), : ";
  v5 = *(_BYTE *)std::string_view::operator[](v13, 0);
  v18 = &v10;
  v17 = v5;
  std::__format::_Sink<char>::_M_write(v10, v5);
  v10 = std::__format::__write<std::__format::_Sink_iter<char>,char>(v10, v11[0], v11[1]);
  v14[0] = 2;
  v14[1] = (unsigned __int64)"{}(), : ";
  v6 = *(_BYTE *)std::string_view::operator[](v14, 1u);
  v16 = &v10;
  v15 = v6;
  std::__format::_Sink<char>::_M_write(v10, v6);
  return v10;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEEC2ES5_ at 0x25854
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Grapheme_cluster_view(
        __int64 a1,
        __int64 a2,
        __int64 a3)
{
  int v3; // r8d
  int v4; // r9d
  __int64 v6[4]; // [rsp+0h] [rbp-70h] BYREF
  __int64 v7[2]; // [rsp+20h] [rbp-50h] BYREF
  __int64 v8[2]; // [rsp+30h] [rbp-40h] BYREF
  __int64 v9; // [rsp+40h] [rbp-30h]
  __int64 v10; // [rsp+48h] [rbp-28h]
  __int64 v11; // [rsp+50h] [rbp-20h]

  v6[3] = a1;
  v6[0] = a2;
  v6[1] = a3;
  std::__unicode::_Utf_view<char32_t,std::string_view>::_Utf_view(v7, v6);
  std::__unicode::_Utf_view<char32_t,std::string_view>::begin((__int64)v8, v7);
  return std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::_Iterator(
           a1,
           (unsigned int)v7,
           v11,
           v9,
           v3,
           v4,
           v8[0],
           v8[1],
           v9,
           v10,
           v11);
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEE3endEv at 0x258f2
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::end(
        __int64 a1)
{
  return *(_QWORD *)(a1 + 32);
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_IteratorppEv at 0x25908
================================================================================

unsigned int *__fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator++(
        unsigned int *a1)
{
  int v1; // r8d
  int v2; // r9d
  __int64 v3; // rbx
  __int64 v4; // rbx
  unsigned int v5; // eax
  int v6; // r8d
  int v7; // r9d
  _QWORD *v8; // rax
  int v9; // r8d
  int v10; // r9d
  unsigned int *v11; // rax
  __int64 v12; // rbx
  __int64 v13; // rbx
  _BYTE v15[56]; // [rsp-30h] [rbp-90h] BYREF
  unsigned int *v16; // [rsp+8h] [rbp-58h]
  __int64 v17; // [rsp+10h] [rbp-50h] BYREF
  __int64 v18; // [rsp+18h] [rbp-48h]
  __int64 v19; // [rsp+20h] [rbp-40h]
  __int64 v20; // [rsp+28h] [rbp-38h]
  __int64 v21; // [rsp+30h] [rbp-30h]
  unsigned int v22; // [rsp+38h] [rbp-28h]
  unsigned int v23; // [rsp+3Ch] [rbp-24h]
  char32_t v24[3]; // [rsp+40h] [rbp-20h]
  unsigned int v25; // [rsp+4Ch] [rbp-14h]

  v16 = a1;
  *(_QWORD *)v24 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::end((__int64)(a1 + 4));
  if ( (unsigned __int8)std::__unicode::operator==(
                          v24[0],
                          v24[0],
                          (unsigned int)v15,
                          *((_QWORD *)v16 + 4),
                          v1,
                          v2,
                          *((_QWORD *)v16 + 2),
                          *((_QWORD *)v16 + 3),
                          *((_QWORD *)v16 + 4),
                          *((_QWORD *)v16 + 5),
                          *((_QWORD *)v16 + 6)) != 1 )
  {
    v25 = v16[1];
    v3 = *((_QWORD *)v16 + 3);
    v17 = *((_QWORD *)v16 + 2);
    v18 = v3;
    v4 = *((_QWORD *)v16 + 5);
    v19 = *((_QWORD *)v16 + 4);
    v20 = v4;
    v21 = *((_QWORD *)v16 + 6);
    while ( 1 )
    {
      v8 = (_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++((__int64)&v17);
      if ( (unsigned __int8)std::__unicode::operator==(
                              v24[0],
                              v24[0],
                              (unsigned int)v15,
                              v8[2],
                              v9,
                              v10,
                              *v8,
                              v8[1],
                              v8[2],
                              v8[3],
                              v8[4]) == 1 )
        break;
      v23 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&v17);
      v5 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&v17);
      v22 = std::__unicode::__v16_0_0::__grapheme_cluster_break_property((std::__unicode::__v16_0_0 *)v5);
      std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_xpicto_seq_state(v16, v23, v22);
      std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_ri_count((__int64)v16, v22);
      std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_update_incb_state((__int64)v16, v23);
      if ( (unsigned __int8)std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::_M_is_break(
                              (_DWORD)v16,
                              v25,
                              v22,
                              v21,
                              v6,
                              v7,
                              v17,
                              v18,
                              v19,
                              v20,
                              v21) )
      {
        std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_M_reset((__int64)v16, v23, v22);
        break;
      }
      v25 = v22;
    }
    v11 = v16;
    v12 = v18;
    *((_QWORD *)v16 + 2) = v17;
    *((_QWORD *)v11 + 3) = v12;
    v13 = v20;
    *((_QWORD *)v11 + 4) = v19;
    *((_QWORD *)v11 + 5) = v13;
    *((_QWORD *)v11 + 6) = v21;
  }
  return v16;
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_IteratoreqERKPKc at 0x25b0a
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::operator==(
        _QWORD *a1,
        _QWORD *a2,
        __int64 a3,
        __int64 a4,
        int a5,
        int a6)
{
  _QWORD v7[9]; // [rsp+0h] [rbp-50h] BYREF

  v7[7] = a1;
  v7[6] = a2;
  return std::__unicode::operator==(*a2, *a2, (unsigned int)v7, a1[4], a5, a6, a1[2], a1[3], a1[4], a1[5], a1[6]);
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE13_M_read_utf32Ev at 0x25b6e
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_read_utf32(
        __int64 a1)
{
  _DWORD **v1; // rax
  _DWORD *v2; // rdx
  _QWORD v4[3]; // [rsp+10h] [rbp-20h] BYREF
  std::__unicode *var4; // [rsp+2Ch] [rbp-4h]

  v4[0] = a1;
  v4[1] = *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1);
  v1 = (_DWORD **)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1);
  v2 = (*v1)++;
  LODWORD(var4) = *v2;
  if ( !std::__unicode::__is_scalar_value((std::__unicode *)(unsigned int)var4) )
    LODWORD(var4) = std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_S_error(a1);
  std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_update(
    a1,
    (unsigned int)var4,
    1);
  return std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_Guard<char32_t const*>::~_Guard(v4);
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E at 0x25bf8
================================================================================

_BOOL8 __fastcall ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
        _DWORD a1,
        _DWORD a2,
        _DWORD a3,
        _DWORD a4,
        _DWORD a5,
        _DWORD a6,
        char a7,
        int a8,
        int a9,
        char a10,
        int a11,
        char a12,
        int a13,
        int a14,
        char a15)
{
  __int64 v15; // rbx

  v15 = *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr((__int64)&a7);
  return v15 == *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr((__int64)&a12)
      && a10 == a15;
}



================================================================================
Function: _ZNKSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEdeEv at 0x25c44
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator*(
        __int64 a1)
{
  return *(unsigned __int8 *)std::array<char,4ul>::operator[](a1, *(unsigned __int8 *)(a1 + 24));
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEEppEv at 0x25c74
================================================================================

__int64 __fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::operator++(
        __int64 a1)
{
  _QWORD *v3; // [rsp+10h] [rbp-30h]
  __int64 v4; // [rsp+18h] [rbp-28h]

  if ( *(unsigned __int8 *)(a1 + 24) + 1 == *(unsigned __int8 *)(a1 + 25)
    && *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1) != *(_QWORD *)(a1 + 32) )
  {
    v4 = *(unsigned __int8 *)(a1 + 26);
    v3 = (_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1);
    std::__advance<char32_t const*,long>(v3, v4);
    if ( *(_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(a1) == *(_QWORD *)(a1 + 32) )
      *(_BYTE *)(a1 + 24) = 0;
    else
      std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_read(a1);
  }
  else if ( *(unsigned __int8 *)(a1 + 24) + 1 < *(unsigned __int8 *)(a1 + 25) )
  {
    ++*(_BYTE *)(a1 + 24);
  }
  return a1;
}



================================================================================
Function: _ZNSt17basic_string_viewIcSt11char_traitsIcEEC2IPcS4_EET_T0_ at 0x25d84
================================================================================

_QWORD *__fastcall std::string_view::basic_string_view<char *,char *>(_QWORD *a1, __int64 a2, __int64 a3)
{
  _QWORD *result; // rax

  *a1 = a3 - a2;
  result = a1;
  a1[1] = a2;
  return result;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_031_Grapheme_cluster_iterator_baseC2Ev at 0x25dc2
================================================================================

std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base *__fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_Grapheme_cluster_iterator_base(
        std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base *this)
{
  std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base *result; // rax

  *((_BYTE *)this + 8) = 0;
  *((_BYTE *)this + 9) = 0;
  result = this;
  *((_BYTE *)this + 10) = 0;
  return result;
}



================================================================================
Function: _ZSt11__bit_widthIoEiT_ at 0x25de9
================================================================================

__int64 __fastcall std::__bit_width<unsigned __int128>(__int64 a1, __int64 a2)
{
  return 128 - (unsigned int)std::__countl_zero<unsigned __int128>(a1, a2);
}



================================================================================
Function: _ZNSt8__detail18__to_chars_10_implIoEEvPcjT_ at 0x25e33
================================================================================

_BYTE *__fastcall std::__detail::__to_chars_10_impl<unsigned __int128>(
        _BYTE *a1,
        int a2,
        unsigned __int64 a3,
        unsigned __int64 a4)
{
  __int128 v4; // rax
  unsigned __int64 v5; // rtt
  unsigned __int128 v6; // rax
  __int128 v7; // rax
  _BYTE *result; // rax
  unsigned __int128 v9; // [rsp+0h] [rbp-120h]
  char v10[208]; // [rsp+20h] [rbp-100h] BYREF
  __int128 v11; // [rsp+F0h] [rbp-30h]
  __int128 v12; // [rsp+100h] [rbp-20h]
  int v13; // [rsp+11Ch] [rbp-4h]

  v9 = __PAIR128__(a4, a3);
  strcpy(
    v10,
    "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657"
    "585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
  v13 = a2 - 1;
  while ( 0x63 < v9 )
  {
    *(_QWORD *)&v4 = __umodti3();
    v5 = (v4 + (unsigned __int128)(unsigned __int64)v4) >> 64;
    *(_QWORD *)&v4 = 2 * v4;
    *((_QWORD *)&v4 + 1) += v5;
    v11 = v4;
    *(_QWORD *)&v6 = __udivti3();
    v9 = v6;
    a1[v13] = v10[(_QWORD)v11 + 1];
    a1[v13 - 1] = v10[v11];
    v13 -= 2;
  }
  if ( 9 >= v9 )
  {
    result = a1;
    *a1 = v9 + 48;
  }
  else
  {
    *(_QWORD *)&v7 = 2 * v9;
    *((_QWORD *)&v7 + 1) = *((_QWORD *)&v9 + 1) + ((v9 + (unsigned __int64)v9) >> 64);
    v12 = v7;
    a1[1] = v10[2 * (_QWORD)v9 + 1];
    result = a1;
    *a1 = v10[v12];
  }
  return result;
}



================================================================================
Function: _ZNSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_IteratorC2ENS_13_Utf_iteratorIcDiPKcSA_NS_5_ReplEEE at 0x26180
================================================================================

__int64 __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::_Iterator(
        std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base *a1,
        __int64 a2,
        __int64 a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int64 a7,
        __int64 a8,
        __int64 a9,
        __int64 a10,
        __int64 a11)
{
  __int64 v11; // rbx
  __int64 v12; // rbx
  int v13; // eax
  int v14; // r8d
  int v15; // r9d
  __int64 result; // rax

  std::__unicode::__v16_0_0::_Grapheme_cluster_iterator_base::_Grapheme_cluster_iterator_base(a1);
  v11 = a8;
  *((_QWORD *)a1 + 2) = a7;
  *((_QWORD *)a1 + 3) = v11;
  v12 = a10;
  *((_QWORD *)a1 + 4) = a9;
  *((_QWORD *)a1 + 5) = v12;
  *((_QWORD *)a1 + 6) = a11;
  v13 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::end((__int64)&a7);
  result = (unsigned int)std::__unicode::operator==(v13, v13, a11, a9, v14, v15, a7, a8, a9, a10, a11) ^ 1;
  if ( (_BYTE)result )
  {
    *(_DWORD *)a1 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&a7);
    result = std::__unicode::__v16_0_0::__grapheme_cluster_break_property((std::__unicode::__v16_0_0 *)*(unsigned int *)a1);
    *((_DWORD *)a1 + 1) = result;
  }
  return result;
}



================================================================================
Function: _ZNSt9__unicodeeqENS_13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEES2_ at 0x26244
================================================================================

bool __fastcall std::__unicode::operator==(__int64 a1, _DWORD a2, _DWORD a3, _DWORD a4, _DWORD a5, _DWORD a6, char a7)
{
  return a1 == *(_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::_M_curr((__int64)&a7);
}



================================================================================
Function: _ZNKSt9__unicode9__v16_0_022_Grapheme_cluster_viewISt17basic_string_viewIcSt11char_traitsIcEEE9_Iterator11_M_is_breakENS0_13_Gcb_propertyES8_NS_13_Utf_iteratorIcDiPKcSB_NS_5_ReplEEE at 0x2626a
================================================================================

bool __fastcall std::__unicode::__v16_0_0::_Grapheme_cluster_view<std::string_view>::_Iterator::_M_is_break(
        unsigned int *a1,
        int a2,
        int a3,
        __int64 a4,
        __int64 a5,
        __int64 a6,
        __int64 a7,
        __int64 a8,
        __int64 a9,
        __int64 a10,
        __int64 a11)
{
  unsigned int v12; // eax
  __int64 v14; // rbx
  __int64 v15; // rbx
  unsigned int v16; // eax
  __int64 *v17; // rdi
  int v18; // r8d
  int v19; // r9d
  _QWORD *v20; // rax
  int v21; // r8d
  int v22; // r9d
  _QWORD v24[9]; // [rsp-50h] [rbp-A0h] BYREF
  __int64 v25; // [rsp-8h] [rbp-58h]
  int v26; // [rsp+0h] [rbp-50h]
  int v27; // [rsp+4h] [rbp-4Ch]
  unsigned int *v28; // [rsp+8h] [rbp-48h]
  __int64 v29; // [rsp+10h] [rbp-40h] BYREF
  __int64 v30; // [rsp+18h] [rbp-38h]
  __int64 v31; // [rsp+20h] [rbp-30h]
  __int64 v32; // [rsp+28h] [rbp-28h]
  __int64 v33; // [rsp+30h] [rbp-20h]
  int v34; // [rsp+38h] [rbp-18h]
  char v35; // [rsp+3Fh] [rbp-11h]

  v28 = a1;
  v27 = a2;
  v26 = a3;
  if ( a2 == 1 || v27 == 2 )
    return 1;
  if ( v27 == 3 )
    return v26 != 2;
  if ( v26 == 1 || v26 == 3 || v26 == 2 )
    return 1;
  switch ( v27 )
  {
    case 7:
      if ( v26 > 8 )
      {
        if ( (unsigned int)(v26 - 11) > 1 )
          return 1;
      }
      else if ( v26 < 7 )
      {
        return 1;
      }
      return 0;
    case 11:
    case 8:
      return (unsigned int)(v26 - 8) > 1;
    case 12:
    case 9:
      return v26 != 9;
  }
  if ( v26 == 4 || v26 == 10 )
    return 0;
  if ( v26 == 6 )
    return 0;
  if ( v27 == 5 )
    return 0;
  if ( !*((_BYTE *)v28 + 10) )
    goto LABEL_50;
  if ( (unsigned int)std::__unicode::__v16_0_0::__incb_property((std::__unicode::__v16_0_0 *)*v28) != 1 )
    goto LABEL_50;
  v12 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&a7);
  if ( (unsigned int)std::__unicode::__v16_0_0::__incb_property((std::__unicode::__v16_0_0 *)v12) != 1 )
    goto LABEL_50;
  v35 = 0;
  v14 = *((_QWORD *)v28 + 3);
  v29 = *((_QWORD *)v28 + 2);
  v30 = v14;
  v15 = *((_QWORD *)v28 + 5);
  v31 = *((_QWORD *)v28 + 4);
  v32 = v15;
  v33 = *((_QWORD *)v28 + 6);
  while ( 1 )
  {
    v17 = &v29;
    v20 = (_QWORD *)std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator++((__int64)&v29);
    v24[5] = a7;
    v24[6] = a8;
    v24[7] = a9;
    v24[8] = a10;
    v25 = a11;
    if ( ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
           (unsigned int)&v29,
           a2,
           (unsigned int)v24,
           v20[2],
           v21,
           v22,
           *v20,
           v20[1],
           v20[2],
           v20[3],
           v20[4],
           a7,
           a8,
           a9,
           a10) )
    {
      break;
    }
    v16 = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&v29);
    if ( std::__unicode::__v16_0_0::__is_incb_linker((std::__unicode::__v16_0_0 *)v16) )
    {
      v35 = 1;
    }
    else
    {
      LODWORD(v17) = std::__unicode::_Utf_iterator<char,char32_t,char const*,char const*,std::__unicode::_Repl>::operator*((__int64)&v29);
      v34 = std::__unicode::__v16_0_0::__incb_property((std::__unicode::__v16_0_0 *)(unsigned int)v17);
      if ( v34 == 1 )
      {
        v35 = 0;
      }
      else if ( v34 != 2 )
      {
        break;
      }
    }
  }
  v25 = a11;
  if ( ZNSt9__unicode13_Utf_iteratorIcDiPKcS2_NS_5_ReplEEFeqES4_S4_Qoo16forward_iteratorIT1_ErQS5__Xnefp_fp_E(
         (_DWORD)v17,
         a2,
         v33,
         v31,
         v18,
         v19,
         v29,
         v30,
         v31,
         v32,
         v33,
         a7,
         a8,
         a9,
         a10)
    && v35 )
  {
    return 0;
  }
LABEL_50:
  if ( v27 == 10 && *((_BYTE *)v28 + 8) == 2 )
    return 0;
  return v27 != 13 || v26 != 13 || !(*((_BYTE *)v28 + 9) & 1);
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE6_GuardIS2_ED2Ev at 0x2657c
================================================================================

_QWORD *__fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_Guard<char32_t const*>::~_Guard(
        __int64 *a1)
{
  __int64 v1; // rbx
  _QWORD *result; // rax

  v1 = a1[1];
  result = (_QWORD *)std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_curr(*a1);
  *result = v1;
  return result;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE8_S_errorEv at 0x265ba
================================================================================

__int64 std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_S_error()
{
  char v1; // [rsp+1Bh] [rbp-5h] BYREF
  std::__unicode *var4; // [rsp+1Ch] [rbp-4h]

  LODWORD(var4) = std::__unicode::_Repl::operator()(&v1);
  if ( !std::__unicode::__is_scalar_value((std::__unicode *)(unsigned int)var4) )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/bits/unicode.h",
      476,
      "constexpr char32_t std::__unicode::_Utf_iterator<_FromFmt, _ToFmt, _Iter, _Sent, _ErrorHandler>::_S_error() [with "
      "_FromFmt = char32_t; _ToFmt = char; _Iter = const char32_t*; _Sent = const char32_t*; _ErrorHandler = std::__unicode::_Repl]",
      "__is_scalar_value(__c)");
  return (unsigned int)var4;
}



================================================================================
Function: _ZNSt9__unicode13_Utf_iteratorIDicPKDiS2_NS_5_ReplEE9_M_updateEDih at 0x2661a
================================================================================

_BYTE *__fastcall std::__unicode::_Utf_iterator<char32_t,char,char32_t const*,char32_t const*,std::__unicode::_Repl>::_M_update(
        _BYTE *a1,
        unsigned int a2,
        char a3)
{
  char *v3; // rax
  char v4; // bl
  char *v5; // rax
  char v6; // bl
  _BYTE *result; // rax
  char *v8; // rax
  char v9; // bl
  int v10; // [rsp+1Ch] [rbp-14h]

  a1[26] = a3;
  a1[24] = 0;
  v10 = std::bit_width<unsigned int>(a2);
  if ( v10 > 7 )
  {
    if ( v10 > 11 )
    {
      if ( v10 > 16 )
      {
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 0) = (a2 >> 18) & 7 | 0xF0;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 1) = (a2 >> 12) & 0x3F | 0x80;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 2) = (a2 >> 6) & 0x3F | 0x80;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 3) = a2 & 0x3F | 0x80;
        result = a1;
        a1[25] = 4;
      }
      else
      {
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 0) = (a2 >> 12) | 0xE0;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 1) = (a2 >> 6) & 0x3F | 0x80;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 2) = a2 & 0x3F | 0x80;
        *(_BYTE *)std::array<char,4ul>::operator[](a1, 3) = 0;
        result = a1;
        a1[25] = 3;
      }
    }
    else
    {
      *(_BYTE *)std::array<char,4ul>::operator[](a1, 0) = (a2 >> 6) | 0xC0;
      *(_BYTE *)std::array<char,4ul>::operator[](a1, 1) = a2 & 0x3F | 0x80;
      v8 = (char *)std::array<char,4ul>::operator[](a1, 3);
      *v8 = 0;
      v9 = *v8;
      *(_BYTE *)std::array<char,4ul>::operator[](a1, 2) = v9;
      result = a1;
      a1[25] = 2;
    }
  }
  else
  {
    *(_BYTE *)std::array<char,4ul>::operator[](a1, 0) = a2;
    v3 = (char *)std::array<char,4ul>::operator[](a1, 3);
    *v3 = 0;
    v4 = *v3;
    v5 = (char *)std::array<char,4ul>::operator[](a1, 2);
    *v5 = v4;
    v6 = *v5;
    *(_BYTE *)std::array<char,4ul>::operator[](a1, 1) = v6;
    result = a1;
    a1[25] = 1;
  }
  return result;
}



================================================================================
Function: _ZNKSt5arrayIcLm4EEixEm at 0x2684c
================================================================================

__int64 __fastcall std::array<char,4ul>::operator[](__int64 a1, unsigned __int64 a2)
{
  if ( a2 >= 4 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/array",
      219,
      "constexpr const std::array<_Tp, _Nm>::value_type& std::array<_Tp, _Nm>::operator[](size_type) const [with _Tp = ch"
      "ar; long unsigned int _Nm = 4; const_reference = const char&; size_type = long unsigned int]",
      "__n < this->size()");
  return a1 + a2;
}



================================================================================
Function: _ZSt13__countl_zeroIoEiT_ at 0x268ab
================================================================================

unsigned __int64 __fastcall std::__countl_zero<unsigned __int128>(unsigned __int64 a1, unsigned __int64 a2)
{
  unsigned __int64 v2; // rax
  unsigned __int64 v4; // rax

  if ( a2 )
  {
    _BitScanReverse64(&v2, a2);
    return v2 ^ 0x3F;
  }
  else if ( a1 )
  {
    _BitScanReverse64(&v4, a1);
    return ((unsigned int)v4 ^ 0x3F) + 64;
  }
  else
  {
    return 128;
  }
}



================================================================================
Function: _ZSt9bit_widthIjEiT_ at 0x2691b
================================================================================

__int64 __fastcall std::bit_width<unsigned int>(unsigned int a1)
{
  return std::__bit_width<unsigned int>(a1);
}



================================================================================
Function: _ZNSt5arrayIcLm4EEixEm at 0x26936
================================================================================

__int64 __fastcall std::array<char,4ul>::operator[](__int64 a1, unsigned __int64 a2)
{
  if ( a2 >= 4 )
    std::__glibcxx_assert_fail(
      "/usr/include/c++/15/array",
      210,
      "constexpr std::array<_Tp, _Nm>::value_type& std::array<_Tp, _Nm>::operator[](size_type) [with _Tp = char; long uns"
      "igned int _Nm = 4; reference = char&; size_type = long unsigned int]",
      "__n < this->size()");
  return a1 + a2;
}



================================================================================
Function: _ZNSt8__format14_Fixedbuf_sinkIcE11_M_overflowEv at 0x26996
================================================================================

__int64 std::__format::_Fixedbuf_sink<char>::_M_overflow()
{
  unsigned __int64 v0; // rdx

  std::__glibcxx_assert_fail(
    "/usr/include/c++/15/format",
    3247,
    "void std::__format::_Fixedbuf_sink<_CharT>::_M_overflow() [with _CharT = char]",
    "false");
  return pqxx::internal::`anonymous namespace'::get_byte(
           (pqxx::internal::_anonymous_namespace_ *)"/usr/include/c++/15/format",
           (_BYTE *)&stru_C98.st_size + 7,
           v0);
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L8get_byteEPKcm_4 at 0x269c8
================================================================================

__int64 __fastcall pqxx::internal::`anonymous namespace'::get_byte(
        pqxx::internal::_anonymous_namespace_ *this,
        const char *a2)
{
  return (unsigned __int8)a2[(_QWORD)this];
}



================================================================================
Function: _ZN4pqxx8internal12_GLOBAL__N_1L24throw_for_encoding_errorEPKcS3_mm_4 at 0x269e4
================================================================================

void __fastcall __noreturn pqxx::internal::`anonymous namespace'::throw_for_encoding_error(
        pqxx::internal::_anonymous_namespace_ *this,
        pqxx::internal::_anonymous_namespace_ *a2,
        const char *a3,
        unsigned __int64 a4)
{
  void *exception; // rbx
  _BYTE v7[40]; // [rsp+1B0h] [rbp-40h] BYREF
  unsigned __int64 i; // [rsp+1D8h] [rbp-18h]

  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::operator<<<std::char_traits<char>>();
  std::ostream::operator<<();
  std::setw(2u);
  std::operator<<<char,std::char_traits<char>>();
  std::setfill<char>(0x30u);
  std::operator<<<char,std::char_traits<char>>();
  for ( i = 0; i < a4; ++i )
  {
    std::operator<<<std::char_traits<char>>();
    pqxx::internal::`anonymous namespace'::get_byte(a2, &a3[i]);
    std::ostream::operator<<();
    if ( i + 1 < a4 )
      std::operator<<<std::char_traits<char>>();
  }
  exception = __cxa_allocate_exception(0x10u);
  std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str();
  pqxx::argument_error::argument_error();
  std::string::~string((__int64)v7);
  __cxa_throw(
    exception,
    (struct type_info *)&`typeinfo for'pqxx::argument_error,
    (void (*)(void *))pqxx::argument_error::~argument_error);
}



================================================================================
Function: main at 0x26c14
================================================================================

int __fastcall main(int argc, const char **argv, const char **envp)
{
  printSystemData("Configuring network interfaces... done", 1);
  if ( !(unsigned __int8)initDb() )
  {
    printSystemData("Mounting /dev/sda1... failed", 1);
    exit(1);
  }
  printSystemData("Mounting /dev/sda1... done", 1);
  if ( !initSodiumLib() )
  {
    printSystemData("Starting random number generator daemon... failed", 1);
    exit(1);
  }
  printSystemData("Starting random number generator daemon... done", 1);
  startupMenu();
  return 0;
}



================================================================================
Function: _Z41__static_initialization_and_destruction_0v_4 at 0x26cb6
================================================================================

int __static_initialization_and_destruction_0(void)
{
  int result; // eax

  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<std::string_view> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string_view);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<std::string_view>, &_dso_handle);
  }
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<pqxx::zview> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'pqxx::zview);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<pqxx::zview>, &_dso_handle);
  }
  __cxa_atexit((void (*)(void *))std::string::~string, &USERNAME[abi:cxx11], &_dso_handle);
  if ( !`guard variable for'pqxx::type_name[abi:cxx11]<bool> )
  {
    `guard variable for'pqxx::type_name[abi:cxx11]<bool> = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'bool);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name[abi:cxx11]<bool>, &_dso_handle);
  }
  result = `guard variable for'pqxx::type_name<std::string>[0];
  if ( !`guard variable for'pqxx::type_name<std::string>[0] )
  {
    `guard variable for'pqxx::type_name<std::string>[0] = 1;
    std::type_info::name((std::type_info *)&`typeinfo for'std::string);
    pqxx::internal::demangle_type_name[abi:cxx11]();
    return __cxa_atexit((void (*)(void *))std::string::~string, &pqxx::type_name<std::string>, &_dso_handle);
  }
  return result;
}



================================================================================
Function: _GLOBAL__sub_I__Z8USERNAMEB5cxx11 at 0x26e51
================================================================================

int GLOBAL__sub_I__Z8USERNAMEB5cxx11()
{
  return __static_initialization_and_destruction_0();
}



================================================================================
Function: .term_proc at 0x26e60
================================================================================

void term_proc()
{
  ;
}



================================================================================
Function: _ZSt24__throw_out_of_range_fmtPKcz at 0x3d1e0
================================================================================

Failed to decompile


================================================================================
Function: _ZSt19__throw_logic_errorPKc at 0x3d1e8
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal23check_pqxx_version_7_10Ev at 0x3d1f0
================================================================================

Failed to decompile


================================================================================
Function: printf at 0x3d1f8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_fSt12chars_formati at 0x3d200
================================================================================

Failed to decompile


================================================================================
Function: memcpy at 0x3d208
================================================================================

Failed to decompile


================================================================================
Function: _ZSt17__throw_bad_allocv at 0x3d210
================================================================================

Failed to decompile


================================================================================
Function: _ZdlPvm at 0x3d218
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt6locale7classicEv at 0x3d220
================================================================================

Failed to decompile


================================================================================
Function: frexpl at 0x3d228
================================================================================

Failed to decompile


================================================================================
Function: sodium_init at 0x3d230
================================================================================

Failed to decompile


================================================================================
Function: _Znwm at 0x3d238
================================================================================

Failed to decompile


================================================================================
Function: memmove at 0x3d240
================================================================================

Failed to decompile


================================================================================
Function: crypto_hash_sha256 at 0x3d248
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal17basic_transactionD2Ev at 0x3d250
================================================================================

Failed to decompile


================================================================================
Function: toupper at 0x3d258
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt13random_device7_M_finiEv at 0x3d260
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx14argument_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x3d268
================================================================================

Failed to decompile


================================================================================
Function: _ZSt21__glibcxx_assert_failPKciS0_S0_ at 0x3d270
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt13runtime_error4whatEv at 0x3d280
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx3rowixEi at 0x3d288
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx16transaction_base6commitEv at 0x3d290
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx16transaction_base8do_abortEv at 0x3d298
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_DF128_St12chars_formati at 0x3d2a0
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt13random_device9_M_getvalEv at 0x3d2a8
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt6localeeqERKS_ at 0x3d2b0
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx6result4sizeEv at 0x3d2b8
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal18demangle_type_nameB5cxx11EPKc at 0x3d2c0
================================================================================

Failed to decompile


================================================================================
Function: _ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE at 0x3d2c8
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev at 0x3d2d0
================================================================================

Failed to decompile


================================================================================
Function: memset at 0x3d2d8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_fSt12chars_format at 0x3d2e0
================================================================================

Failed to decompile


================================================================================
Function: __cxa_guard_acquire at 0x3d2e8
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev at 0x3d2f8
================================================================================

Failed to decompile


================================================================================
Function: _ZNR4pqxx6params6appendERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x3d308
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt16invalid_argumentD2Ev at 0x3d310
================================================================================

Failed to decompile


================================================================================
Function: __cxa_allocate_exception at 0x3d318
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx5field7is_nullEv at 0x3d320
================================================================================

Failed to decompile


================================================================================
Function: strlen at 0x3d328
================================================================================

Failed to decompile


================================================================================
Function: __cxa_guard_abort at 0x3d330
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt13runtime_errorD2Ev at 0x3d338
================================================================================

Failed to decompile


================================================================================
Function: memchr at 0x3d340
================================================================================

Failed to decompile


================================================================================
Function: _ZStrsIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EE at 0x3d348
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_d at 0x3d350
================================================================================

Failed to decompile


================================================================================
Function: _ZSt28__throw_bad_array_new_lengthv at 0x3d358
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_dSt12chars_format at 0x3d360
================================================================================

Failed to decompile


================================================================================
Function: _ZNKR4pqxx5field5c_strEv at 0x3d368
================================================================================

Failed to decompile


================================================================================
Function: fflush at 0x3d370
================================================================================

Failed to decompile


================================================================================
Function: __gttf2 at 0x3d378
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx10connection4initEPKc at 0x3d380
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx5field4sizeEv at 0x3d388
================================================================================

Failed to decompile


================================================================================
Function: _ZNSi6ignoreEli at 0x3d390
================================================================================

Failed to decompile


================================================================================
Function: _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw at 0x3d398
================================================================================

Failed to decompile


================================================================================
Function: _ZNKRSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv at 0x3d3a0
================================================================================

Failed to decompile


================================================================================
Function: _ZdlPv at 0x3d3a8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_eSt12chars_formati at 0x3d3b0
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx16transaction_base5closeEv at 0x3d3b8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_DF128_ at 0x3d3c0
================================================================================

Failed to decompile


================================================================================
Function: __cxa_guard_release at 0x3d3c8
================================================================================

Failed to decompile


================================================================================
Function: _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc at 0x3d3d0
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt7__cxx118numpunctIcE8truenameEv at 0x3d3d8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_f at 0x3d3e0
================================================================================

Failed to decompile


================================================================================
Function: __isoc23_scanf at 0x3d3e8
================================================================================

Failed to decompile


================================================================================
Function: __udivti3 at 0x3d3f0
================================================================================

Failed to decompile


================================================================================
Function: __gxx_personality_v0 at 0x3d3f8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt20__throw_length_errorPKc at 0x3d400
================================================================================

Failed to decompile


================================================================================
Function: __cxa_throw at 0x3d408
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal21throw_null_conversionERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x3d410
================================================================================

Failed to decompile


================================================================================
Function: _Unwind_Resume at 0x3d418
================================================================================

Failed to decompile


================================================================================
Function: exit at 0x3d420
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt7__cxx118numpunctIcE13decimal_pointEv at 0x3d428
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_eSt12chars_format at 0x3d430
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt6locale4nameB5cxx11Ev at 0x3d438
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_DF128_St12chars_format at 0x3d440
================================================================================

Failed to decompile


================================================================================
Function: _ZNKRSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv at 0x3d448
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt6localeC1ERKS_ at 0x3d450
================================================================================

Failed to decompile


================================================================================
Function: _ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St8_SetfillIS3_E at 0x3d458
================================================================================

Failed to decompile


================================================================================
Function: _ZSt9use_facetINSt7__cxx118numpunctIcEEERKT_RKSt6locale at 0x3d460
================================================================================

Failed to decompile


================================================================================
Function: getenv at 0x3d468
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx16transaction_base20internal_exec_paramsESt17basic_string_viewIcSt11char_traitsIcEERKNS_8internal8c_paramsE at 0x3d470
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt6localeC1Ev at 0x3d478
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_dSt12chars_formati at 0x3d480
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt7__cxx118numpunctIcE8groupingEv at 0x3d488
================================================================================

Failed to decompile


================================================================================
Function: __unordtf2 at 0x3d490
================================================================================

Failed to decompile


================================================================================
Function: _ZNSolsEj at 0x3d498
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal17basic_transaction9do_commitEv at 0x3d4a0
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt13random_device7_M_initERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE at 0x3d4a8
================================================================================

Failed to decompile


================================================================================
Function: _ZSt21ios_base_library_initv at 0x3d4b8
================================================================================

Failed to decompile


================================================================================
Function: __cxa_atexit at 0x3d4c0
================================================================================

Failed to decompile


================================================================================
Function: __cxa_free_exception at 0x3d4c8
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev at 0x3d4d0
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx8internal17basic_transactionC2ERNS_10connectionENS_5zviewE at 0x3d4d8
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt7__cxx118numpunctIcE13thousands_sepEv at 0x3d4e0
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx6params13make_c_paramsEv at 0x3d4e8
================================================================================

Failed to decompile


================================================================================
Function: __cxa_pure_virtual at 0x3d4f0
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev at 0x3d4f8
================================================================================

Failed to decompile


================================================================================
Function: _ZNSi3getEv at 0x3d500
================================================================================

Failed to decompile


================================================================================
Function: frexp at 0x3d508
================================================================================

Failed to decompile


================================================================================
Function: frexpf at 0x3d510
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt6localeD1Ev at 0x3d520
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt11logic_error4whatEv at 0x3d528
================================================================================

Failed to decompile


================================================================================
Function: _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_ at 0x3d530
================================================================================

Failed to decompile


================================================================================
Function: puts at 0x3d538
================================================================================

Failed to decompile


================================================================================
Function: _ZNSolsEPFRSoS_E at 0x3d540
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt13runtime_errorC2EPKc at 0x3d548
================================================================================

Failed to decompile


================================================================================
Function: _ZNSolsEm at 0x3d550
================================================================================

Failed to decompile


================================================================================
Function: memcmp at 0x3d558
================================================================================

Failed to decompile


================================================================================
Function: _ZNK4pqxx6resultixEi at 0x3d560
================================================================================

Failed to decompile


================================================================================
Function: _ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate at 0x3d568
================================================================================

Failed to decompile


================================================================================
Function: __umodti3 at 0x3d570
================================================================================

Failed to decompile


================================================================================
Function: _ZNR4pqxx6params7reserveEm at 0x3d578
================================================================================

Failed to decompile


================================================================================
Function: _ZSt8to_charsPcS_e at 0x3d580
================================================================================

Failed to decompile


================================================================================
Function: _ZNKSt7__cxx118numpunctIcE9falsenameEv at 0x3d588
================================================================================

Failed to decompile


================================================================================
Function: __libc_start_main at 0x3d590
================================================================================

Failed to decompile


================================================================================
Function: _ZN4pqxx16transaction_base4execESt17basic_string_viewIcSt11char_traitsIcEES4_ at 0x3d598
================================================================================

Failed to decompile


================================================================================
Function: _ZNSolsEPFRSt8ios_baseS0_E at 0x3d5a0
================================================================================

Failed to decompile


================================================================================
Function: __imp___cxa_finalize at 0x3d5a8
================================================================================

Failed to decompile


================================================================================
Function: __gmon_start__ at 0x3d5b8
================================================================================

Failed to decompile