; assembly                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | /* bdlc_flathashset.t/none @ 0x44e520 */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |  
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | uint32_t rotate_left32 (uint32_t value, uint32_t count) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     const uint32_t mask = (CHAR_BIT * sizeof (value)) - 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     count &= mask;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     return (value << count) | (value >> (-count & mask));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |  
    ; (fcn) sym.BloombergLP::bdlc::FlatHashTable_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____BloombergLP::bdlc::FlatHashSet_EntryUtil_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_______SeedIsHash_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_______EqualAndState_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_______::rehashRaw_unsigned_long_ ()      | int64_t BloombergLP::bdlc::FlatHashTable_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_BloombergLP::bdlc::FlatHashSet_EntryUtil_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_SeedIsHash_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_EqualAndState_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_::rehashRaw_unsigned_long_ (int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_8h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_10h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_18h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_20h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_28h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     int64_t var_30h;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     /* BloombergLP::bdlc::FlatHashTable<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, BloombergLP::bdlc::FlatHashSet_EntryUtil<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > >, SeedIsHash<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > >, EqualAndState<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > >::rehashRaw(unsigned long) */
    0x0044e520 push rbp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     
    0x0044e521 push r15                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     
    0x0044e523 push r14                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     
    0x0044e525 push r12                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     
    0x0044e527 push rbx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     
    0x0044e528 sub rsp, 0x70                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     
    0x0044e52c mov r14, rdi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     r14 = rdi;
    0x0044e52f lea rdx, [rdi + 0x28]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |     rdx = rdi + 0x28;
    0x0044e533 lea rcx, [rdi + 0x30]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |     rcx = rdi + 0x30;
    0x0044e537 mov r8, qword [rdi + 0x60]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     r8 = *((rdi + 0x60));
    0x0044e53b lea rdi, [rsp + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |     rdi = rsp + 8;
    0x0044e540 call 0x44deb0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     BloombergLP::bdlc::FlatHashTable<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,BloombergLP::bdlc::FlatHashSet_EntryUtil<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>,SeedIsHash<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>,EqualAndState<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>>::FlatHashTable(unsigned long,SeedIsHash<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>const&,EqualAndState<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>const&,BloombergLP::bslma::Allocator*) ();
    0x0044e545 mov rax, qword [r14 + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rax = *((r14 + 0x18));
    0x0044e549 test rax, rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x0044e54c je 0x44e671                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         goto label_3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     }
    0x0044e552 xor r8d, r8d                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     r8d = 0;
    0x0044e555 jmp 0x44e571                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     goto label_4;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_0:
    0x0044e560 mov rax, qword [r14 + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rax = *((r14 + 0x18));
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     do {
    0x0044e564 add r8, 0x10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         r8 += 0x10;
    0x0044e568 cmp r8, rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         if (r8 >= rax) {
    0x0044e56b jae 0x44e671                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |             goto label_3;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_4:
    0x0044e571 mov r9, qword [r14 + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |         r9 = *((r14 + 8));
    0x0044e575 movdqu xmm0, xmmword [r9 + r8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |         __asm ("movdqu xmm0, xmmword [r9 + r8]");
    0x0044e57b pmovmskb ecx, xmm0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         __asm ("pmovmskb ecx, xmm0");
    0x0044e57f cmp cx, 0xffff                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |         
    0x0044e583 je 0x44e564                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     } while (cx == 0xffff);
    0x0044e585 add r9, r8                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     r9 += r8;
    0x0044e588 lea r10, [r8 + r8*2]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     r10 = r8 * 3;
    0x0044e58c shl r10, 4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     r10 <<= 4;
    0x0044e590 add r10, qword [r14]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     r10 += *(r14);
    0x0044e593 not ecx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     ecx = ~ecx;
    0x0044e595 movzx r12d, cx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |     r12d = (int32_t) cx;
    0x0044e599 jmp 0x44e5ef                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     goto label_5;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_1:
    0x0044e5a0 xor edi, edi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     edi = 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_2:
    0x0044e5a2 mov rax, qword [rsp + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     rax = *((rsp + 8));
    0x0044e5a7 lea rcx, [rdi + rdi*2]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     rcx = rdi * 3;
    0x0044e5ab shl rcx, 4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     rcx <<= 4;
    0x0044e5af movdqu xmm0, xmmword [rsi]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     __asm ("movdqu xmm0, xmmword [rsi]");
    0x0044e5b3 movups xmm1, xmmword [rsi + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     __asm ("movups xmm1, xmmword [rsi + 0x10]");
    0x0044e5b7 movups xmm2, xmmword [rsi + 0x20]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     __asm ("movups xmm2, xmmword [rsi + 0x20]");
    0x0044e5bb movups xmmword [rax + rcx + 0x20], xmm2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     __asm ("movups xmmword [rax + rcx + 0x20], xmm2");
    0x0044e5c0 movups xmmword [rax + rcx + 0x10], xmm1                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     __asm ("movups xmmword [rax + rcx + 0x10], xmm1");
    0x0044e5c5 movdqu xmmword [rax + rcx], xmm0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |     __asm ("movdqu xmmword [rax + rcx], xmm0");
    0x0044e5ca and r15b, 0x7f                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |     r15b &= 0x7f;
    0x0044e5ce mov rax, qword [rsp + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rax = *((rsp + 0x10));
    0x0044e5d3 mov byte [rax + rdi], r15b                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     *((rax + rdi)) = r15b;
    0x0044e5d7 inc qword [rsp + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     *((rsp + 0x18))++;
    0x0044e5dc mov eax, 0xfffffffe                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |     eax = 0xfffffffe;
    0x0044e5e1 mov ecx, r11d                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     ecx = r11d;
    0x0044e5e4 rol eax, cl                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     eax = rotate_left32 (eax, cl);
    0x0044e5e6 and r12d, eax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     r12d &= eax;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     if (r12d == 0) {
    0x0044e5e9 je 0x44e560                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         goto label_0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_5:
    0x0044e5ef bsf r11d, r12d                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |     __asm ("bsf r11d, r12d");
    0x0044e5f3 lea rsi, [r11 + r11*2]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     rsi = r11 * 3;
    0x0044e5f7 shl rsi, 4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     rsi <<= 4;
    0x0044e5fb mov byte [r9 + r11], 0xc0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |     *((r9 + r11)) = 0xc0;
    0x0044e600 dec qword [r14 + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     *((r14 + 0x10))--;
    0x0044e604 add rsi, r10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     rsi += r10;
    0x0044e607 mov r15, qword [rsp + 0x30]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     r15 = *((rsp + 0x30));
    0x0044e60c mov rdi, qword [rsp + 0x20]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rdi = *((rsp + 0x20));
    0x0044e611 test rdi, rdi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     if (rdi == 0) {
    0x0044e614 je 0x44e5a0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         goto label_1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     }
    0x0044e616 mov cl, byte [rsp + 0x28]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |     cl = *((rsp + 0x28));
    0x0044e61a mov rbx, r15                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     rbx = r15;
    0x0044e61d shr rbx, cl                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rbx >>= cl;
    0x0044e620 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rcx = *((rsp + 0x10));
    0x0044e625 shl rbx, 4                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |     rbx <<= 4;
    0x0044e629 lea rax, [rdi - 1]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |     rax = rdi - 1;
    0x0044e62d xor edx, edx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     edx = 0;
    0x0044e62f nop                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     do {
    0x0044e630 movdqu xmm0, xmmword [rcx + rbx]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |         __asm ("movdqu xmm0, xmmword [rcx + rbx]");
    0x0044e635 pmovmskb ebp, xmm0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |         __asm ("pmovmskb ebp, xmm0");
    0x0044e639 test bp, bp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         if (bp != 0) {
    0x0044e63c jne 0x44e660                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |             goto label_6;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |         }
    0x0044e63e add rbx, 0x10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |         rbx += 0x10;
    0x0044e642 and rbx, rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         rbx &= rax;
    0x0044e645 add rdx, 0x10                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |         rdx += 0x10;
    0x0044e649 cmp rdx, rdi                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |         
    0x0044e64c jb 0x44e630                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     } while (rdx < rdi);
    0x0044e64e jmp 0x44e5a2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_6:
    0x0044e660 movzx eax, bp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     eax = (int32_t) bp;
    0x0044e663 bsf eax, eax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     __asm ("bsf eax, eax");
    0x0044e666 add rbx, rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     rbx += rax;
    0x0044e669 mov rdi, rbx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     rdi = rbx;
    0x0044e66c jmp 0x44e5a2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | label_3:
    0x0044e671 mov rsi, qword [r14]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     rsi = *(r14);
    0x0044e674 mov rdi, qword [r14 + 0x60]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rdi = *((r14 + 0x60));
    0x0044e678 mov rax, qword [rdi]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     rax = *(rdi);
    0x0044e67b call qword [rax + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
    0x0044e67e mov rsi, qword [r14 + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     rsi = *((r14 + 8));
    0x0044e682 mov rdi, qword [r14 + 0x60]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rdi = *((r14 + 0x60));
    0x0044e686 mov rax, qword [rdi]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     rax = *(rdi);
    0x0044e689 call qword [rax + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
    0x0044e68c mov rax, qword [rsp + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     rax = *((rsp + 8));
    0x0044e691 mov qword [r14], rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |     *(r14) = rax;
    0x0044e694 mov qword [rsp + 8], 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |     *((rsp + 8)) = 0;
    0x0044e69d mov rax, qword [rsp + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rax = *((rsp + 0x10));
    0x0044e6a2 mov qword [r14 + 8], rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |     *((r14 + 8)) = rax;
    0x0044e6a6 mov qword [rsp + 0x10], 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |     *((rsp + 0x10)) = 0;
    0x0044e6af mov rax, qword [r14 + 0x10]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     rax = *((r14 + 0x10));
    0x0044e6b3 movups xmm0, xmmword [rsp + 0x18]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     __asm ("movups xmm0, xmmword [rsp + 0x18]");
    0x0044e6b8 mov qword [rsp + 0x18], rax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     *((rsp + 0x18)) = rax;
    0x0044e6bd movups xmmword [r14 + 0x10], xmm0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |     __asm ("movups xmmword [r14 + 0x10], xmm0");
    0x0044e6c2 mov qword [rsp + 0x20], 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |     *((rsp + 0x20)) = 0;
    0x0044e6cb mov eax, dword [r14 + 0x20]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     eax = *((r14 + 0x20));
    0x0044e6cf mov ecx, dword [rsp + 0x28]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     ecx = *((rsp + 0x28));
    0x0044e6d3 mov dword [r14 + 0x20], ecx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     *((r14 + 0x20)) = ecx;
    0x0044e6d7 mov dword [rsp + 0x28], eax                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |     *((rsp + 0x28)) = eax;
    0x0044e6db lea rdi, [rsp + 8]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |     rdi = rsp + 8;
    0x0044e6e0 call 0x44e090                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     BloombergLP::bdlc::FlatHashTable<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,BloombergLP::bdlc::FlatHashSet_EntryUtil<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>,SeedIsHash<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>,EqualAndState<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>>::~FlatHashTable() ();
    0x0044e6e5 add rsp, 0x70                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |     
    0x0044e6e9 pop rbx                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     
    0x0044e6ea pop r12                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     
    0x0044e6ec pop r14                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     
    0x0044e6ee pop r15                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     
    0x0044e6f0 pop rbp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |     
    0x0044e6f1 ret                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |     return rax;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | }