; assembly                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                         | /* bdlc_flathashset.t/assume @ 0x44db00 */
                                                                                                                                                                                         | #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_int__int__BloombergLP::bdlc::FlatHashSet_EntryUtil_int___SeedIsHash_int___EqualAndState_int___.rehashRaw_unsigned_long_ ()           | uint64_t method_BloombergLP::bdlc::FlatHashTable_int_int_BloombergLP::bdlc::FlatHashSet_EntryUtil_int_SeedIsHash_int_EqualAndState_int_rehashRaw_unsigned_long_ (int64_t arg2, void ** s) {
                                                                                                                                                                                         |     int64_t var_8h;
                                                                                                                                                                                         |     int64_t var_10h;
                                                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                                                         |     rdi = s;
                                                                                                                                                                                         |     /* BloombergLP::bdlc::FlatHashTable<int, int, BloombergLP::bdlc::FlatHashSet_EntryUtil<int>, SeedIsHash<int>, EqualAndState<int> >::rehashRaw(unsigned long) */
    0x0044db00 push rbp                                                                                                                                                                  |     
    0x0044db01 push r15                                                                                                                                                                  |     
    0x0044db03 push r14                                                                                                                                                                  |     
    0x0044db05 push r13                                                                                                                                                                  |     
    0x0044db07 push r12                                                                                                                                                                  |     
    0x0044db09 push rbx                                                                                                                                                                  |     
    0x0044db0a sub rsp, 0x18                                                                                                                                                             |     
    0x0044db0e mov rbx, rsi                                                                                                                                                              |     rbx = rsi;
    0x0044db11 mov r15, rdi                                                                                                                                                              |     r15 = rdi;
    0x0044db14 mov r14, qword [rdi + 0x28]                                                                                                                                               |     r14 = *((rdi + 0x28));
    0x0044db18 mov rdi, qword [rdi + 0x38]                                                                                                                                               |     rdi = *((rdi + 0x38));
    0x0044db1c test rdi, rdi                                                                                                                                                             |     
                                                                                                                                                                                         |     if (rdi == 0) {
    0x0044db1f jne 0x44db35                                                                                                                                                              |         
    0x0044db21 mov rdi, qword [rip + 0x254f60]                                                                                                                                           |         rdi = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0044db28 test rdi, rdi                                                                                                                                                             |         
                                                                                                                                                                                         |         if (rdi != 0) {
    0x0044db2b jne 0x44db35                                                                                                                                                              |             goto label_5;
                                                                                                                                                                                         |         }
    0x0044db2d call 0x457e60                                                                                                                                                             |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x0044db32 mov rdi, rax                                                                                                                                                              |         rdi = rax;
                                                                                                                                                                                         |     }
                                                                                                                                                                                         | label_5:
    0x0044db35 test rbx, rbx                                                                                                                                                             |     
    0x0044db38 mov qword [rsp], rdi                                                                                                                                                      |     *(rsp) = rdi;
                                                                                                                                                                                         |     if (rbx != 0) {
    0x0044db3c je 0x44dbc7                                                                                                                                                               |         
    0x0044db42 mov r13d, 0x20                                                                                                                                                            |         r13d = 0x20;
    0x0044db48 cmp rbx, 0x21                                                                                                                                                             |         
                                                                                                                                                                                         |         if (rbx >= 0x21) {
    0x0044db4c jb 0x44db73                                                                                                                                                               |             
    0x0044db4e dec rbx                                                                                                                                                                   |             rbx--;
    0x0044db51 or rbx, 1                                                                                                                                                                 |             rbx |= 1;
    0x0044db55 bsr rax, rbx                                                                                                                                                              |             __asm ("bsr rax, rbx");
    0x0044db59 xor rax, 0x3f                                                                                                                                                             |             rax ^= 0x3f;
    0x0044db5d mov ecx, eax                                                                                                                                                              |             ecx = eax;
    0x0044db5f neg cl                                                                                                                                                                    |             cl = -cl;
    0x0044db61 mov r13d, 1                                                                                                                                                               |             r13d = 1;
    0x0044db67 shl r13, cl                                                                                                                                                               |             r13 <<= cl;
    0x0044db6a test rax, rax                                                                                                                                                             |             
                                                                                                                                                                                         |             if (rax == 0) {
    0x0044db6d je 0x44dcf6                                                                                                                                                               |                 goto label_6;
                                                                                                                                                                                         |             }
                                                                                                                                                                                         |         }
                                                                                                                                                                                         | label_4:
    0x0044db73 lea rsi, [r13*4]                                                                                                                                                          |         rsi = r13*4;
    0x0044db7b mov rax, qword [rdi]                                                                                                                                                      |         rax = *(rdi);
    0x0044db7e mov rbx, rdi                                                                                                                                                              |         rbx = rdi;
    0x0044db81 call qword [rax + 0x10]                                                                                                                                                   |         rax = uint64_t (*rax + 0x10)() ();
    0x0044db84 mov r12, rax                                                                                                                                                              |         r12 = rax;
    0x0044db87 mov rax, qword [rbx]                                                                                                                                                      |         rax = *(rbx);
    0x0044db8a mov rdi, rbx                                                                                                                                                              |         rdi = rbx;
    0x0044db8d mov rsi, r13                                                                                                                                                              |         rsi = r13;
    0x0044db90 call qword [rax + 0x10]                                                                                                                                                   |         rax = uint64_t (*rax + 0x10)() ();
    0x0044db93 mov rbx, rax                                                                                                                                                              |         rbx = rax;
    0x0044db96 mov rax, r13                                                                                                                                                              |         rax = r13;
    0x0044db99 shr rax, 4                                                                                                                                                                |         rax >>= 4;
    0x0044db9d dec rax                                                                                                                                                                   |         rax--;
    0x0044dba0 mov rcx, rax                                                                                                                                                              |         rcx = rax;
    0x0044dba3 or rcx, 1                                                                                                                                                                 |         rcx |= 1;
    0x0044dba7 bsr rbp, rcx                                                                                                                                                              |         __asm ("bsr rbp, rcx");
    0x0044dbab xor ebp, 0x3f                                                                                                                                                             |         ebp ^= 0x3f;
    0x0044dbae cmp rax, 1                                                                                                                                                                |         
    0x0044dbb2 adc ebp, 0                                                                                                                                                                |         ebp += 0;
    0x0044dbb5 mov rdi, rbx                                                                                                                                                              |         
    0x0044dbb8 mov esi, 0x80                                                                                                                                                             |         
    0x0044dbbd mov rdx, r13                                                                                                                                                              |         
    0x0044dbc0 call 0x403820                                                                                                                                                             |         memset (rbx, 0x80, r13);
    0x0044dbc5 jmp 0x44dbd1                                                                                                                                                              |         
                                                                                                                                                                                         |     } else {
    0x0044dbc7 xor ebp, ebp                                                                                                                                                              |         ebp = 0;
    0x0044dbc9 xor r13d, r13d                                                                                                                                                            |         r13d = 0;
    0x0044dbcc xor ebx, ebx                                                                                                                                                              |         ebx = 0;
    0x0044dbce xor r12d, r12d                                                                                                                                                            |         r12d = 0;
                                                                                                                                                                                         |     }
    0x0044dbd1 mov rax, qword [r15 + 0x18]                                                                                                                                               |     rax = *((r15 + 0x18));
    0x0044dbd5 test rax, rax                                                                                                                                                             |     
    0x0044dbd8 mov qword [rsp + 8], rbp                                                                                                                                                  |     *((rsp + 8)) = rbp;
                                                                                                                                                                                         |     if (rax == 0) {
    0x0044dbdd je 0x44dcb2                                                                                                                                                               |         goto label_7;
                                                                                                                                                                                         |     }
    0x0044dbe3 mov r9, r14                                                                                                                                                               |     r9 = r14;
    0x0044dbe6 mov ecx, ebp                                                                                                                                                              |     ecx = ebp;
    0x0044dbe8 shr r9, cl                                                                                                                                                                |     r9 >>= cl;
    0x0044dbeb shl r9, 4                                                                                                                                                                 |     r9 <<= 4;
    0x0044dbef lea rdx, [r13 - 1]                                                                                                                                                        |     rdx = r13 - 1;
    0x0044dbf3 and r14b, 0x7f                                                                                                                                                            |     r14b &= 0x7f;
    0x0044dbf7 xor esi, esi                                                                                                                                                              |     esi = 0;
    0x0044dbf9 xor ebp, ebp                                                                                                                                                              |     ebp = 0;
    0x0044dbfb jmp 0x44dc16                                                                                                                                                              |     goto label_8;
                                                                                                                                                                                         | label_0:
    0x0044dc00 mov rax, qword [r15 + 0x18]                                                                                                                                               |     rax = *((r15 + 0x18));
    0x0044dc04 mov rsi, qword [rsp + 0x10]                                                                                                                                               |     rsi = *((rsp + 0x10));
                                                                                                                                                                                         |     do {
    0x0044dc09 add rsi, 0x10                                                                                                                                                             |         rsi += 0x10;
    0x0044dc0d cmp rsi, rax                                                                                                                                                              |         
                                                                                                                                                                                         |         if (rsi >= rax) {
    0x0044dc10 jae 0x44dcb4                                                                                                                                                              |             goto label_9;
                                                                                                                                                                                         |         }
                                                                                                                                                                                         | label_8:
    0x0044dc16 mov r10, qword [r15 + 8]                                                                                                                                                  |         r10 = *((r15 + 8));
    0x0044dc1a movdqu xmm0, xmmword [r10 + rsi]                                                                                                                                          |         __asm ("movdqu xmm0, xmmword [r10 + rsi]");
    0x0044dc20 pmovmskb ecx, xmm0                                                                                                                                                        |         __asm ("pmovmskb ecx, xmm0");
    0x0044dc24 cmp cx, 0xffff                                                                                                                                                            |         
    0x0044dc28 je 0x44dc09                                                                                                                                                               |         
                                                                                                                                                                                         |     } while (cx == 0xffff);
    0x0044dc2a add r10, rsi                                                                                                                                                              |     r10 += rsi;
    0x0044dc2d mov qword [rsp + 0x10], rsi                                                                                                                                               |     *((rsp + 0x10)) = rsi;
    0x0044dc32 lea r11, [rsi*4]                                                                                                                                                          |     r11 = rsi*4;
    0x0044dc3a add r11, qword [r15]                                                                                                                                                      |     r11 += *(r15);
    0x0044dc3d not ecx                                                                                                                                                                   |     ecx = ~ecx;
    0x0044dc3f movzx eax, cx                                                                                                                                                             |     eax = (int32_t) cx;
    0x0044dc42 jmp 0x44dc74                                                                                                                                                              |     goto label_10;
                                                                                                                                                                                         | label_2:
    0x0044dc50 movzx esi, r8w                                                                                                                                                            |     esi = (int32_t) r8w;
    0x0044dc54 bsf esi, esi                                                                                                                                                              |     __asm ("bsf esi, esi");
    0x0044dc57 add rdi, rsi                                                                                                                                                              |     rdi += rsi;
                                                                                                                                                                                         | label_1:
    0x0044dc5a mov esi, dword [r11 + rcx*4]                                                                                                                                              |     esi = *((r11 + rcx*4));
    0x0044dc5e mov dword [r12 + rdi*4], esi                                                                                                                                              |     *((r12 + rdi*4)) = esi;
    0x0044dc62 mov byte [rbx + rdi], r14b                                                                                                                                                |     *((rbx + rdi)) = r14b;
    0x0044dc66 inc rbp                                                                                                                                                                   |     rbp++;
    0x0044dc69 mov esi, 0xfffffffe                                                                                                                                                       |     esi = 0xfffffffe;
    0x0044dc6e rol esi, cl                                                                                                                                                               |     esi = rotate_left32 (esi, cl);
    0x0044dc70 and eax, esi                                                                                                                                                              |     eax &= esi;
                                                                                                                                                                                         |     if (eax == 0) {
    0x0044dc72 je 0x44dc00                                                                                                                                                               |         goto label_0;
                                                                                                                                                                                         |     }
                                                                                                                                                                                         | label_10:
    0x0044dc74 bsf ecx, eax                                                                                                                                                              |     __asm ("bsf ecx, eax");
    0x0044dc77 mov byte [r10 + rcx], 0xc0                                                                                                                                                |     *((r10 + rcx)) = 0xc0;
    0x0044dc7c dec qword [r15 + 0x10]                                                                                                                                                    |     *((r15 + 0x10))--;
    0x0044dc80 test r13, r13                                                                                                                                                             |     
                                                                                                                                                                                         |     if (r13 == 0) {
    0x0044dc83 je 0x44dc5a                                                                                                                                                               |         goto label_1;
                                                                                                                                                                                         |     }
    0x0044dc85 mov rdi, r9                                                                                                                                                               |     rdi = r9;
    0x0044dc88 xor esi, esi                                                                                                                                                              |     esi = 0;
    0x0044dc8a nop word [rax + rax]                                                                                                                                                      |     
                                                                                                                                                                                         | label_3:
    0x0044dc90 movdqu xmm0, xmmword [rbx + rdi]                                                                                                                                          |     __asm ("movdqu xmm0, xmmword [rbx + rdi]");
    0x0044dc95 pmovmskb r8d, xmm0                                                                                                                                                        |     __asm ("pmovmskb r8d, xmm0");
    0x0044dc9a test r8w, r8w                                                                                                                                                             |     
                                                                                                                                                                                         |     if (r8w != 0) {
    0x0044dc9e jne 0x44dc50                                                                                                                                                              |         goto label_2;
                                                                                                                                                                                         |     }
    0x0044dca0 add rdi, 0x10                                                                                                                                                             |     rdi += 0x10;
    0x0044dca4 and rdi, rdx                                                                                                                                                              |     rdi &= rdx;
    0x0044dca7 add rsi, 0x10                                                                                                                                                             |     rsi += 0x10;
    0x0044dcab cmp rsi, r13                                                                                                                                                              |     
                                                                                                                                                                                         |     if (rsi < r13) {
    0x0044dcae jb 0x44dc90                                                                                                                                                               |         goto label_3;
                                                                                                                                                                                         |     }
    0x0044dcb0 jmp 0x44dc5a                                                                                                                                                              |     goto label_1;
                                                                                                                                                                                         | label_7:
    0x0044dcb2 xor ebp, ebp                                                                                                                                                              |     ebp = 0;
                                                                                                                                                                                         | label_9:
    0x0044dcb4 mov rsi, qword [r15]                                                                                                                                                      |     rsi = *(r15);
    0x0044dcb7 mov rdi, qword [r15 + 0x38]                                                                                                                                               |     rdi = *((r15 + 0x38));
    0x0044dcbb mov rax, qword [rdi]                                                                                                                                                      |     rax = *(rdi);
    0x0044dcbe call qword [rax + 0x18]                                                                                                                                                   |     uint64_t (*rax + 0x18)() ();
    0x0044dcc1 mov rsi, qword [r15 + 8]                                                                                                                                                  |     rsi = *((r15 + 8));
    0x0044dcc5 mov rdi, qword [r15 + 0x38]                                                                                                                                               |     rdi = *((r15 + 0x38));
    0x0044dcc9 mov rax, qword [rdi]                                                                                                                                                      |     rax = *(rdi);
    0x0044dccc call qword [rax + 0x18]                                                                                                                                                   |     uint64_t (*rax + 0x18)() ();
    0x0044dccf mov qword [r15], r12                                                                                                                                                      |     *(r15) = r12;
    0x0044dcd2 mov qword [r15 + 8], rbx                                                                                                                                                  |     *((r15 + 8)) = rbx;
    0x0044dcd6 mov qword [r15 + 0x10], rbp                                                                                                                                               |     *((r15 + 0x10)) = rbp;
    0x0044dcda mov qword [r15 + 0x18], r13                                                                                                                                               |     *((r15 + 0x18)) = r13;
    0x0044dcde mov rax, qword [rsp + 8]                                                                                                                                                  |     rax = *((rsp + 8));
    0x0044dce3 mov dword [r15 + 0x20], eax                                                                                                                                               |     *((r15 + 0x20)) = eax;
    0x0044dce7 add rsp, 0x18                                                                                                                                                             |     
    0x0044dceb pop rbx                                                                                                                                                                   |     
    0x0044dcec pop r12                                                                                                                                                                   |     
    0x0044dcee pop r13                                                                                                                                                                   |     
    0x0044dcf0 pop r14                                                                                                                                                                   |     
    0x0044dcf2 pop r15                                                                                                                                                                   |     
    0x0044dcf4 pop rbp                                                                                                                                                                   |     
    0x0044dcf5 ret                                                                                                                                                                       |     return rax;
                                                                                                                                                                                         | label_6:
    0x0044dcf6 xor r13d, r13d                                                                                                                                                            |     r13d = 0;
    0x0044dcf9 jmp 0x44db73                                                                                                                                                              |     goto label_4;
                                                                                                                                                                                         | }