; assembly                                                                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                     | /* bdlc_flathashmap.t/none @ 0x44ebe0 */
                                                                                                                                                                                                                                                                                     | #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) method.BloombergLP::bdlc::FlatHashTable_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____bsl::pair_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____int___BloombergLP::bdlc::FlatHashMap_EntryUtil_bsl ()        | uint64_t method_BloombergLP::bdlc::FlatHashTable_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_bsl::pair_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_int_BloombergLP::bdlc::FlatHashMap_EntryUtil_bsl (int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                                                                     |     void * var_8h;
                                                                                                                                                                                                                                                                                     |     int64_t var_10h;
                                                                                                                                                                                                                                                                                     |     int64_t var_1ch;
                                                                                                                                                                                                                                                                                     |     int64_t var_20h;
                                                                                                                                                                                                                                                                                     |     int64_t var_28h;
                                                                                                                                                                                                                                                                                     |     int64_t var_30h;
                                                                                                                                                                                                                                                                                     |     int64_t var_38h;
                                                                                                                                                                                                                                                                                     |     int64_t var_40h;
                                                                                                                                                                                                                                                                                     |     int64_t var_48h;
                                                                                                                                                                                                                                                                                     |     int64_t var_50h;
                                                                                                                                                                                                                                                                                     |     int64_t var_58h;
                                                                                                                                                                                                                                                                                     |     int64_t var_60h;
                                                                                                                                                                                                                                                                                     |     int64_t var_68h;
                                                                                                                                                                                                                                                                                     |     int64_t var_70h;
                                                                                                                                                                                                                                                                                     |     int64_t var_78h;
                                                                                                                                                                                                                                                                                     |     int64_t var_138h;
                                                                                                                                                                                                                                                                                     |     int64_t var_198h;
                                                                                                                                                                                                                                                                                     |     int64_t var_1a0h;
                                                                                                                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                                                                                     |     /* BloombergLP::bdlc::FlatHashTable<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, bsl::pair<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, int>, BloombergLP::bdlc::FlatHashMap_EntryUtil<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, int, bsl::pair<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >, int> >, BloombergLP::bslh::FibonacciBadHashWrapper<bsl::hash<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > >, bsl::equal_to<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > >::rehashRaw(unsigned long) */
    0x0044ebe0 push rbp                                                                                                                                                                                                                                                              |     
    0x0044ebe1 push r15                                                                                                                                                                                                                                                              |     
    0x0044ebe3 push r14                                                                                                                                                                                                                                                              |     
    0x0044ebe5 push r13                                                                                                                                                                                                                                                              |     
    0x0044ebe7 push r12                                                                                                                                                                                                                                                              |     
    0x0044ebe9 push rbx                                                                                                                                                                                                                                                              |     
    0x0044ebea sub rsp, 0x1a8                                                                                                                                                                                                                                                        |     
    0x0044ebf1 mov rbx, rsi                                                                                                                                                                                                                                                          |     rbx = rsi;
    0x0044ebf4 mov r8, rdi                                                                                                                                                                                                                                                           |     r8 = rdi;
    0x0044ebf7 mov rbp, qword [rdi + 0x28]                                                                                                                                                                                                                                           |     rbp = *((rdi + 0x28));
    0x0044ebfb test rbp, rbp                                                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                                                     |     if (rbp == 0) {
    0x0044ebfe jne 0x44ec1a                                                                                                                                                                                                                                                          |         
    0x0044ec00 mov rbp, qword [rip + 0x25e241]                                                                                                                                                                                                                                       |         rbp = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0044ec07 test rbp, rbp                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rbp != 0) {
    0x0044ec0a jne 0x44ec1a                                                                                                                                                                                                                                                          |             goto label_4;
                                                                                                                                                                                                                                                                                     |         }
    0x0044ec0c mov rbp, r8                                                                                                                                                                                                                                                           |         
    0x0044ec0f call 0x460a70                                                                                                                                                                                                                                                         |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x0044ec14 mov r8, rbp                                                                                                                                                                                                                                                           |         r8 = rbp;
    0x0044ec17 mov rbp, rax                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     | label_4:
    0x0044ec1a test rbx, rbx                                                                                                                                                                                                                                                         |     
    0x0044ec1d mov qword [rsp + 0x38], rbp                                                                                                                                                                                                                                           |     *((rsp + 0x38)) = rbp;
                                                                                                                                                                                                                                                                                     |     if (rbx != 0) {
    0x0044ec22 je 0x44ecb5                                                                                                                                                                                                                                                           |         
    0x0044ec28 mov r12d, 0x20                                                                                                                                                                                                                                                        |         r12d = 0x20;
    0x0044ec2e cmp rbx, 0x21                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rbx >= 0x21) {
    0x0044ec32 jb 0x44ec59                                                                                                                                                                                                                                                           |             
    0x0044ec34 dec rbx                                                                                                                                                                                                                                                               |             rbx--;
    0x0044ec37 or rbx, 1                                                                                                                                                                                                                                                             |             rbx |= 1;
    0x0044ec3b bsr rax, rbx                                                                                                                                                                                                                                                          |             __asm ("bsr rax, rbx");
    0x0044ec3f xor rax, 0x3f                                                                                                                                                                                                                                                         |             rax ^= 0x3f;
    0x0044ec43 mov ecx, eax                                                                                                                                                                                                                                                          |             ecx = eax;
    0x0044ec45 neg cl                                                                                                                                                                                                                                                                |             cl = -cl;
    0x0044ec47 mov r12d, 1                                                                                                                                                                                                                                                           |             r12d = 1;
    0x0044ec4d shl r12, cl                                                                                                                                                                                                                                                           |             r12 <<= cl;
    0x0044ec50 test rax, rax                                                                                                                                                                                                                                                         |             
                                                                                                                                                                                                                                                                                     |             if (rax == 0) {
    0x0044ec53 je 0x44ef30                                                                                                                                                                                                                                                           |                 goto label_5;
                                                                                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_3:
    0x0044ec59 mov r15, r8                                                                                                                                                                                                                                                           |         r15 = r8;
    0x0044ec5c imul rsi, r12, 0x38                                                                                                                                                                                                                                                   |         rsi = r12 * 0x38;
    0x0044ec60 mov rax, qword [rbp]                                                                                                                                                                                                                                                  |         rax = *(rbp);
    0x0044ec64 mov rdi, rbp                                                                                                                                                                                                                                                          |         rdi = rbp;
    0x0044ec67 call qword [rax + 0x10]                                                                                                                                                                                                                                               |         rax = uint64_t (*rax + 0x10)() ();
    0x0044ec6a mov qword [rsp + 8], rax                                                                                                                                                                                                                                              |         *((rsp + 8)) = rax;
    0x0044ec6f mov rax, qword [rbp]                                                                                                                                                                                                                                                  |         rax = *(rbp);
    0x0044ec73 mov rdi, rbp                                                                                                                                                                                                                                                          |         rdi = rbp;
    0x0044ec76 mov rsi, r12                                                                                                                                                                                                                                                          |         rsi = r12;
    0x0044ec79 call qword [rax + 0x10]                                                                                                                                                                                                                                               |         rax = uint64_t (*rax + 0x10)() ();
    0x0044ec7c mov rbx, rax                                                                                                                                                                                                                                                          |         rbx = rax;
    0x0044ec7f mov rax, r12                                                                                                                                                                                                                                                          |         rax = r12;
    0x0044ec82 shr rax, 4                                                                                                                                                                                                                                                            |         rax >>= 4;
    0x0044ec86 dec rax                                                                                                                                                                                                                                                               |         rax--;
    0x0044ec89 mov rcx, rax                                                                                                                                                                                                                                                          |         rcx = rax;
    0x0044ec8c or rcx, 1                                                                                                                                                                                                                                                             |         rcx |= 1;
    0x0044ec90 bsr r14, rcx                                                                                                                                                                                                                                                          |         __asm ("bsr r14, rcx");
    0x0044ec94 xor r14d, 0x3f                                                                                                                                                                                                                                                        |         r14d ^= 0x3f;
    0x0044ec98 cmp rax, 1                                                                                                                                                                                                                                                            |         
    0x0044ec9c adc r14d, 0                                                                                                                                                                                                                                                           |         r14d += 0;
    0x0044eca0 mov rdi, rbx                                                                                                                                                                                                                                                          |         
    0x0044eca3 mov esi, 0x80                                                                                                                                                                                                                                                         |         
    0x0044eca8 mov rdx, r12                                                                                                                                                                                                                                                          |         
    0x0044ecab call 0x4038e0                                                                                                                                                                                                                                                         |         eax = memset (rbx, 0x80, r12);
    0x0044ecb0 mov r8, r15                                                                                                                                                                                                                                                           |         r8 = r15;
    0x0044ecb3 jmp 0x44ecc4                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |     } else {
    0x0044ecb5 xor r14d, r14d                                                                                                                                                                                                                                                        |         r14d = 0;
    0x0044ecb8 xor r12d, r12d                                                                                                                                                                                                                                                        |         r12d = 0;
    0x0044ecbb xor ebx, ebx                                                                                                                                                                                                                                                          |         ebx = 0;
    0x0044ecbd xor eax, eax                                                                                                                                                                                                                                                          |         eax = 0;
    0x0044ecbf mov qword [rsp + 8], rax                                                                                                                                                                                                                                              |         *((rsp + 8)) = rax;
                                                                                                                                                                                                                                                                                     |     }
    0x0044ecc4 mov rax, qword [r8 + 0x18]                                                                                                                                                                                                                                            |     rax = *((r8 + 0x18));
    0x0044ecc8 test rax, rax                                                                                                                                                                                                                                                         |     
    0x0044eccb mov qword [rsp + 0x20], rbx                                                                                                                                                                                                                                           |     *((rsp + 0x20)) = rbx;
    0x0044ecd0 mov qword [rsp + 0x10], r12                                                                                                                                                                                                                                           |     *((rsp + 0x10)) = r12;
    0x0044ecd5 mov qword [rsp + 0x50], r14                                                                                                                                                                                                                                           |     *((rsp + 0x50)) = r14;
                                                                                                                                                                                                                                                                                     |     if (rax == 0) {
    0x0044ecda je 0x44eede                                                                                                                                                                                                                                                           |         goto label_6;
                                                                                                                                                                                                                                                                                     |     }
    0x0044ece0 mov ecx, r14d                                                                                                                                                                                                                                                         |     ecx = r14d;
    0x0044ece3 mov qword [rsp + 0x60], rcx                                                                                                                                                                                                                                           |     *((rsp + 0x60)) = rcx;
    0x0044ece8 lea r14, [r12 - 1]                                                                                                                                                                                                                                                    |     r14 = r12 - 1;
    0x0044eced xor edx, edx                                                                                                                                                                                                                                                          |     edx = 0;
    0x0044ecef lea r9, [rsp + 0x78]                                                                                                                                                                                                                                                  |     r9 = rsp + 0x78;
    0x0044ecf4 xor esi, esi                                                                                                                                                                                                                                                          |     esi = 0;
    0x0044ecf6 mov qword [rsp + 0x40], r8                                                                                                                                                                                                                                            |     *((rsp + 0x40)) = r8;
    0x0044ecfb jmp 0x44ed16                                                                                                                                                                                                                                                          |     goto label_7;
                                                                                                                                                                                                                                                                                     | label_0:
    0x0044ed00 mov rax, qword [r8 + 0x18]                                                                                                                                                                                                                                            |     rax = *((r8 + 0x18));
    0x0044ed04 mov rdx, qword [rsp + 0x58]                                                                                                                                                                                                                                           |     rdx = *((rsp + 0x58));
                                                                                                                                                                                                                                                                                     |     do {
    0x0044ed09 add rdx, 0x10                                                                                                                                                                                                                                                         |         rdx += 0x10;
    0x0044ed0d cmp rdx, rax                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (rdx >= rax) {
    0x0044ed10 jae 0x44eee0                                                                                                                                                                                                                                                          |             goto label_8;
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_7:
    0x0044ed16 mov r10, qword [r8 + 8]                                                                                                                                                                                                                                               |         r10 = *((r8 + 8));
    0x0044ed1a movdqu xmm0, xmmword [r10 + rdx]                                                                                                                                                                                                                                      |         __asm ("movdqu xmm0, xmmword [r10 + rdx]");
    0x0044ed20 pmovmskb ecx, xmm0                                                                                                                                                                                                                                                    |         __asm ("pmovmskb ecx, xmm0");
    0x0044ed24 cmp cx, 0xffff                                                                                                                                                                                                                                                        |         
    0x0044ed28 je 0x44ed09                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (cx == 0xffff);
    0x0044ed2a add r10, rdx                                                                                                                                                                                                                                                          |     r10 += rdx;
    0x0044ed2d mov qword [rsp + 0x58], rdx                                                                                                                                                                                                                                           |     *((rsp + 0x58)) = rdx;
    0x0044ed32 imul r11, rdx, 0x38                                                                                                                                                                                                                                                   |     r11 = rdx * 0x38;
    0x0044ed36 add r11, qword [r8]                                                                                                                                                                                                                                                   |     r11 += *(r8);
    0x0044ed39 not ecx                                                                                                                                                                                                                                                               |     ecx = ~ecx;
    0x0044ed3b movzx ebp, cx                                                                                                                                                                                                                                                         |     ebp = (int32_t) cx;
    0x0044ed3e mov qword [rsp + 0x48], r10                                                                                                                                                                                                                                           |     *((rsp + 0x48)) = r10;
    0x0044ed43 jmp 0x44edba                                                                                                                                                                                                                                                          |     goto label_9;
                                                                                                                                                                                                                                                                                     | label_1:
    0x0044ed50 xor edx, edx                                                                                                                                                                                                                                                          |     edx = 0;
    0x0044ed52 mov r8, qword [rsp + 0x40]                                                                                                                                                                                                                                            |     r8 = *((rsp + 0x40));
    0x0044ed57 mov rbx, qword [rsp + 0x20]                                                                                                                                                                                                                                           |     rbx = *((rsp + 0x20));
    0x0044ed5c mov r10, qword [rsp + 0x48]                                                                                                                                                                                                                                           |     r10 = *((rsp + 0x48));
    0x0044ed61 mov r11, r15                                                                                                                                                                                                                                                          |     r11 = r15;
    0x0044ed64 mov ebp, dword [rsp + 0x1c]                                                                                                                                                                                                                                           |     ebp = *((rsp + 0x1c));
                                                                                                                                                                                                                                                                                     | label_2:
    0x0044ed68 imul rcx, rdx, 0x38                                                                                                                                                                                                                                                   |     rcx = rdx * 0x38;
    0x0044ed6c mov rsi, qword [r13 + 0x30]                                                                                                                                                                                                                                           |     rsi = *((r13 + 0x30));
    0x0044ed70 mov rdi, qword [rsp + 8]                                                                                                                                                                                                                                              |     rdi = *((rsp + 8));
    0x0044ed75 mov qword [rdi + rcx + 0x30], rsi                                                                                                                                                                                                                                     |     *((rdi + rcx + 0x30)) = rsi;
    0x0044ed7a movdqu xmm0, xmmword [r13]                                                                                                                                                                                                                                            |     __asm ("movdqu xmm0, xmmword [r13]");
    0x0044ed80 movups xmm1, xmmword [r13 + 0x10]                                                                                                                                                                                                                                     |     __asm ("movups xmm1, xmmword [r13 + 0x10]");
    0x0044ed85 movups xmm2, xmmword [r13 + 0x20]                                                                                                                                                                                                                                     |     __asm ("movups xmm2, xmmword [r13 + 0x20]");
    0x0044ed8a movups xmmword [rdi + rcx + 0x20], xmm2                                                                                                                                                                                                                               |     __asm ("movups xmmword [rdi + rcx + 0x20], xmm2");
    0x0044ed8f movups xmmword [rdi + rcx + 0x10], xmm1                                                                                                                                                                                                                               |     __asm ("movups xmmword [rdi + rcx + 0x10], xmm1");
    0x0044ed94 movdqu xmmword [rdi + rcx], xmm0                                                                                                                                                                                                                                      |     __asm ("movdqu xmmword [rdi + rcx], xmm0");
    0x0044ed99 and al, 0x7f                                                                                                                                                                                                                                                          |     al &= 0x7f;
    0x0044ed9b mov byte [rbx + rdx], al                                                                                                                                                                                                                                              |     *((rbx + rdx)) = al;
    0x0044ed9e mov rsi, qword [rsp + 0x28]                                                                                                                                                                                                                                           |     rsi = *((rsp + 0x28));
    0x0044eda3 inc rsi                                                                                                                                                                                                                                                               |     rsi++;
    0x0044eda6 mov eax, 0xfffffffe                                                                                                                                                                                                                                                   |     eax = 0xfffffffe;
    0x0044edab mov rcx, qword [rsp + 0x68]                                                                                                                                                                                                                                           |     rcx = *((rsp + 0x68));
    0x0044edb0 rol eax, cl                                                                                                                                                                                                                                                           |     eax = rotate_left32 (eax, cl);
    0x0044edb2 and ebp, eax                                                                                                                                                                                                                                                          |     ebp &= eax;
                                                                                                                                                                                                                                                                                     |     if (ebp == 0) {
    0x0044edb4 je 0x44ed00                                                                                                                                                                                                                                                           |         goto label_0;
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     | label_9:
    0x0044edba mov qword [rsp + 0x28], rsi                                                                                                                                                                                                                                           |     *((rsp + 0x28)) = rsi;
    0x0044edbf mov dword [rsp + 0x1c], ebp                                                                                                                                                                                                                                           |     *((rsp + 0x1c)) = ebp;
    0x0044edc3 bsf ebx, ebp                                                                                                                                                                                                                                                          |     __asm ("bsf ebx, ebp");
    0x0044edc6 imul rax, rbx, 0x38                                                                                                                                                                                                                                                   |     rax = rbx * 0x38;
    0x0044edca lea r13, [r11 + rax]                                                                                                                                                                                                                                                  |     r13 = r11 + rax;
    0x0044edce mov byte [r10 + rbx], 0xc0                                                                                                                                                                                                                                            |     *((r10 + rbx)) = 0xc0;
    0x0044edd3 dec qword [r8 + 0x10]                                                                                                                                                                                                                                                 |     *((r8 + 0x10))--;
    0x0044edd7 mov qword [rsp + 0x198], 0                                                                                                                                                                                                                                            |     *((rsp + 0x198)) = 0;
    0x0044ede3 mov byte [rsp + 0x1a0], 0                                                                                                                                                                                                                                             |     *((rsp + 0x1a0)) = 0;
    0x0044edeb movdqa xmm0, xmmword [rip + 0x390ad]                                                                                                                                                                                                                                  |     __asm ("movdqa xmm0, xmmword [0x00487ea0]");
    0x0044edf3 movdqu xmmword [rsp + 0x138], xmm0                                                                                                                                                                                                                                    |     __asm ("movdqu xmmword [rsp + 0x138], xmm0");
    0x0044edfc cmp qword [r11 + rax + 0x20], 0x17                                                                                                                                                                                                                                    |     
    0x0044ee02 mov rsi, r13                                                                                                                                                                                                                                                          |     rsi = r13;
                                                                                                                                                                                                                                                                                     |     if (*((r11 + rax + 0x20)) != 0x17) {
    0x0044ee05 je 0x44ee0b                                                                                                                                                                                                                                                           |         
    0x0044ee07 mov rsi, qword [r11 + rax]                                                                                                                                                                                                                                            |         
                                                                                                                                                                                                                                                                                     |     }
    0x0044ee0b mov r15, r11                                                                                                                                                                                                                                                          |     r15 = r11;
    0x0044ee0e mov rdx, qword [r11 + rax + 0x18]                                                                                                                                                                                                                                     |     
    0x0044ee13 mov rdi, r9                                                                                                                                                                                                                                                           |     rdi = r9;
    0x0044ee16 mov r12, r9                                                                                                                                                                                                                                                           |     r12 = r9;
    0x0044ee19 call 0x45f9d0                                                                                                                                                                                                                                                         |     BloombergLP::bslh::SpookyHashAlgorithmImp::update(voidconst*,unsigned long) (rdi, *((r11 + rax)), *((r11 + rax + 0x18)));
    0x0044ee1e mov rax, qword [r13 + 0x18]                                                                                                                                                                                                                                           |     rax = *((r13 + 0x18));
    0x0044ee22 mov qword [rsp + 0x30], rax                                                                                                                                                                                                                                           |     *((rsp + 0x30)) = rax;
    0x0044ee27 mov edx, 8                                                                                                                                                                                                                                                            |     
    0x0044ee2c mov rdi, r12                                                                                                                                                                                                                                                          |     
    0x0044ee2f lea rsi, [rsp + 0x30]                                                                                                                                                                                                                                                 |     
    0x0044ee34 call 0x45f9d0                                                                                                                                                                                                                                                         |     BloombergLP::bslh::SpookyHashAlgorithmImp::update(voidconst*,unsigned long) (r12, rsp + 0x30, 8);
    0x0044ee39 mov rdi, r12                                                                                                                                                                                                                                                          |     
    0x0044ee3c lea rsi, [rsp + 0x30]                                                                                                                                                                                                                                                 |     
    0x0044ee41 lea rdx, [rsp + 0x70]                                                                                                                                                                                                                                                 |     
    0x0044ee46 call 0x45ef50                                                                                                                                                                                                                                                         |     BloombergLP::bslh::SpookyHashAlgorithmImp::finalize(unsigned long long*,unsigned long long*) (r12, rsp + 0x30, rsp + 0x70);
    0x0044ee4b mov qword [rsp + 0x68], rbx                                                                                                                                                                                                                                           |     *((rsp + 0x68)) = rbx;
    0x0044ee50 mov r9, r12                                                                                                                                                                                                                                                           |     r9 = r12;
    0x0044ee53 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                                                           |     rax = *((rsp + 0x30));
    0x0044ee58 movabs rcx, 0x9e3779b97f4a7c15                                                                                                                                                                                                                                        |     rcx = 0x9e3779b97f4a7c15;
    0x0044ee62 imul rax, rcx                                                                                                                                                                                                                                                         |     rax *= rcx;
    0x0044ee66 mov r12, qword [rsp + 0x10]                                                                                                                                                                                                                                           |     r12 = *((rsp + 0x10));
    0x0044ee6b test r12, r12                                                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                                                     |     if (r12 == 0) {
    0x0044ee6e je 0x44ed50                                                                                                                                                                                                                                                           |         goto label_1;
                                                                                                                                                                                                                                                                                     |     }
    0x0044ee74 mov rdx, rax                                                                                                                                                                                                                                                          |     rdx = rax;
    0x0044ee77 mov rcx, qword [rsp + 0x60]                                                                                                                                                                                                                                           |     rcx = *((rsp + 0x60));
    0x0044ee7c shr rdx, cl                                                                                                                                                                                                                                                           |     rdx >>= cl;
    0x0044ee7f shl rdx, 4                                                                                                                                                                                                                                                            |     rdx <<= 4;
    0x0044ee83 xor ecx, ecx                                                                                                                                                                                                                                                          |     ecx = 0;
    0x0044ee85 mov r8, qword [rsp + 0x40]                                                                                                                                                                                                                                            |     r8 = *((rsp + 0x40));
    0x0044ee8a mov rbx, qword [rsp + 0x20]                                                                                                                                                                                                                                           |     rbx = *((rsp + 0x20));
    0x0044ee8f mov r10, qword [rsp + 0x48]                                                                                                                                                                                                                                           |     r10 = *((rsp + 0x48));
    0x0044ee94 mov r11, r15                                                                                                                                                                                                                                                          |     r11 = r15;
    0x0044ee97 mov ebp, dword [rsp + 0x1c]                                                                                                                                                                                                                                           |     ebp = *((rsp + 0x1c));
    0x0044ee9b nop dword [rax + rax]                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                                     |     do {
    0x0044eea0 movdqu xmm0, xmmword [rbx + rdx]                                                                                                                                                                                                                                      |         __asm ("movdqu xmm0, xmmword [rbx + rdx]");
    0x0044eea5 pmovmskb esi, xmm0                                                                                                                                                                                                                                                    |         __asm ("pmovmskb esi, xmm0");
    0x0044eea9 test si, si                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |         if (si != 0) {
    0x0044eeac jne 0x44eed0                                                                                                                                                                                                                                                          |             goto label_10;
                                                                                                                                                                                                                                                                                     |         }
    0x0044eeae add rdx, 0x10                                                                                                                                                                                                                                                         |         rdx += 0x10;
    0x0044eeb2 and rdx, r14                                                                                                                                                                                                                                                          |         rdx &= r14;
    0x0044eeb5 add rcx, 0x10                                                                                                                                                                                                                                                         |         rcx += 0x10;
    0x0044eeb9 cmp rcx, r12                                                                                                                                                                                                                                                          |         
    0x0044eebc jb 0x44eea0                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (rcx < r12);
    0x0044eebe mov rdx, r12                                                                                                                                                                                                                                                          |     rdx = r12;
    0x0044eec1 jmp 0x44ed68                                                                                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                                                                                     | label_10:
    0x0044eed0 movzx ecx, si                                                                                                                                                                                                                                                         |     ecx = (int32_t) si;
    0x0044eed3 bsf ecx, ecx                                                                                                                                                                                                                                                          |     __asm ("bsf ecx, ecx");
    0x0044eed6 add rdx, rcx                                                                                                                                                                                                                                                          |     rdx += rcx;
    0x0044eed9 jmp 0x44ed68                                                                                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                                                                                     | label_6:
    0x0044eede xor esi, esi                                                                                                                                                                                                                                                          |     esi = 0;
                                                                                                                                                                                                                                                                                     | label_8:
    0x0044eee0 mov r14, rsi                                                                                                                                                                                                                                                          |     r14 = rsi;
    0x0044eee3 mov rsi, qword [r8]                                                                                                                                                                                                                                                   |     rsi = *(r8);
    0x0044eee6 mov rdi, qword [r8 + 0x28]                                                                                                                                                                                                                                            |     rdi = *((r8 + 0x28));
    0x0044eeea mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x0044eeed mov r15, r8                                                                                                                                                                                                                                                           |     r15 = r8;
    0x0044eef0 call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x0044eef3 mov rsi, qword [r15 + 8]                                                                                                                                                                                                                                              |     rsi = *((r15 + 8));
    0x0044eef7 mov rdi, qword [r15 + 0x28]                                                                                                                                                                                                                                           |     rdi = *((r15 + 0x28));
    0x0044eefb mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x0044eefe call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x0044ef01 mov rax, qword [rsp + 8]                                                                                                                                                                                                                                              |     rax = *((rsp + 8));
    0x0044ef06 mov qword [r15], rax                                                                                                                                                                                                                                                  |     *(r15) = rax;
    0x0044ef09 mov qword [r15 + 8], rbx                                                                                                                                                                                                                                              |     *((r15 + 8)) = rbx;
    0x0044ef0d mov qword [r15 + 0x10], r14                                                                                                                                                                                                                                           |     *((r15 + 0x10)) = r14;
    0x0044ef11 mov qword [r15 + 0x18], r12                                                                                                                                                                                                                                           |     *((r15 + 0x18)) = r12;
    0x0044ef15 mov rax, qword [rsp + 0x50]                                                                                                                                                                                                                                           |     rax = *((rsp + 0x50));
    0x0044ef1a mov dword [r15 + 0x20], eax                                                                                                                                                                                                                                           |     *((r15 + 0x20)) = eax;
    0x0044ef1e add rsp, 0x1a8                                                                                                                                                                                                                                                        |     
    0x0044ef25 pop rbx                                                                                                                                                                                                                                                               |     
    0x0044ef26 pop r12                                                                                                                                                                                                                                                               |     
    0x0044ef28 pop r13                                                                                                                                                                                                                                                               |     
    0x0044ef2a pop r14                                                                                                                                                                                                                                                               |     
    0x0044ef2c pop r15                                                                                                                                                                                                                                                               |     
    0x0044ef2e pop rbp                                                                                                                                                                                                                                                               |     
    0x0044ef2f ret                                                                                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                                                                                     | label_5:
    0x0044ef30 xor r12d, r12d                                                                                                                                                                                                                                                        |     r12d = 0;
    0x0044ef33 jmp 0x44ec59                                                                                                                                                                                                                                                          |     goto label_3;
                                                                                                                                                                                                                                                                                     | }