; assembly                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                         | /* bdlc_flathashset.t/none @ 0x44dc40 */
                                                                                                                                                                                         | #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) */
    0x0044dc40 push rbp                                                                                                                                                                  |     
    0x0044dc41 push r15                                                                                                                                                                  |     
    0x0044dc43 push r14                                                                                                                                                                  |     
    0x0044dc45 push r13                                                                                                                                                                  |     
    0x0044dc47 push r12                                                                                                                                                                  |     
    0x0044dc49 push rbx                                                                                                                                                                  |     
    0x0044dc4a sub rsp, 0x18                                                                                                                                                             |     
    0x0044dc4e mov rbx, rsi                                                                                                                                                              |     rbx = rsi;
    0x0044dc51 mov r15, rdi                                                                                                                                                              |     r15 = rdi;
    0x0044dc54 mov r14, qword [rdi + 0x28]                                                                                                                                               |     r14 = *((rdi + 0x28));
    0x0044dc58 mov rdi, qword [rdi + 0x38]                                                                                                                                               |     rdi = *((rdi + 0x38));
    0x0044dc5c test rdi, rdi                                                                                                                                                             |     
                                                                                                                                                                                         |     if (rdi == 0) {
    0x0044dc5f jne 0x44dc75                                                                                                                                                              |         
    0x0044dc61 mov rdi, qword [rip + 0x254e20]                                                                                                                                           |         rdi = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0044dc68 test rdi, rdi                                                                                                                                                             |         
                                                                                                                                                                                         |         if (rdi != 0) {
    0x0044dc6b jne 0x44dc75                                                                                                                                                              |             goto label_4;
                                                                                                                                                                                         |         }
    0x0044dc6d call 0x457f90                                                                                                                                                             |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x0044dc72 mov rdi, rax                                                                                                                                                              |         rdi = rax;
                                                                                                                                                                                         |     }
                                                                                                                                                                                         | label_4:
    0x0044dc75 test rbx, rbx                                                                                                                                                             |     
    0x0044dc78 mov qword [rsp], rdi                                                                                                                                                      |     *(rsp) = rdi;
                                                                                                                                                                                         |     if (rbx != 0) {
    0x0044dc7c je 0x44dd07                                                                                                                                                               |         
    0x0044dc82 mov r13d, 0x20                                                                                                                                                            |         r13d = 0x20;
    0x0044dc88 cmp rbx, 0x21                                                                                                                                                             |         
                                                                                                                                                                                         |         if (rbx >= 0x21) {
    0x0044dc8c jb 0x44dcb3                                                                                                                                                               |             
    0x0044dc8e dec rbx                                                                                                                                                                   |             rbx--;
    0x0044dc91 or rbx, 1                                                                                                                                                                 |             rbx |= 1;
    0x0044dc95 bsr rax, rbx                                                                                                                                                              |             __asm ("bsr rax, rbx");
    0x0044dc99 xor rax, 0x3f                                                                                                                                                             |             rax ^= 0x3f;
    0x0044dc9d mov ecx, eax                                                                                                                                                              |             ecx = eax;
    0x0044dc9f neg cl                                                                                                                                                                    |             cl = -cl;
    0x0044dca1 mov r13d, 1                                                                                                                                                               |             r13d = 1;
    0x0044dca7 shl r13, cl                                                                                                                                                               |             r13 <<= cl;
    0x0044dcaa test rax, rax                                                                                                                                                             |             
                                                                                                                                                                                         |             if (rax == 0) {
    0x0044dcad je 0x44de50                                                                                                                                                               |                 goto label_5;
                                                                                                                                                                                         |             }
                                                                                                                                                                                         |         }
                                                                                                                                                                                         | label_3:
    0x0044dcb3 lea rsi, [r13*4]                                                                                                                                                          |         rsi = r13*4;
    0x0044dcbb mov rax, qword [rdi]                                                                                                                                                      |         rax = *(rdi);
    0x0044dcbe mov rbx, rdi                                                                                                                                                              |         rbx = rdi;
    0x0044dcc1 call qword [rax + 0x10]                                                                                                                                                   |         rax = uint64_t (*rax + 0x10)() ();
    0x0044dcc4 mov r12, rax                                                                                                                                                              |         r12 = rax;
    0x0044dcc7 mov rax, qword [rbx]                                                                                                                                                      |         rax = *(rbx);
    0x0044dcca mov rdi, rbx                                                                                                                                                              |         rdi = rbx;
    0x0044dccd mov rsi, r13                                                                                                                                                              |         rsi = r13;
    0x0044dcd0 call qword [rax + 0x10]                                                                                                                                                   |         rax = uint64_t (*rax + 0x10)() ();
    0x0044dcd3 mov rbx, rax                                                                                                                                                              |         rbx = rax;
    0x0044dcd6 mov rax, r13                                                                                                                                                              |         rax = r13;
    0x0044dcd9 shr rax, 4                                                                                                                                                                |         rax >>= 4;
    0x0044dcdd dec rax                                                                                                                                                                   |         rax--;
    0x0044dce0 mov rcx, rax                                                                                                                                                              |         rcx = rax;
    0x0044dce3 or rcx, 1                                                                                                                                                                 |         rcx |= 1;
    0x0044dce7 bsr rbp, rcx                                                                                                                                                              |         __asm ("bsr rbp, rcx");
    0x0044dceb xor ebp, 0x3f                                                                                                                                                             |         ebp ^= 0x3f;
    0x0044dcee cmp rax, 1                                                                                                                                                                |         
    0x0044dcf2 adc ebp, 0                                                                                                                                                                |         ebp += 0;
    0x0044dcf5 mov rdi, rbx                                                                                                                                                              |         
    0x0044dcf8 mov esi, 0x80                                                                                                                                                             |         
    0x0044dcfd mov rdx, r13                                                                                                                                                              |         
    0x0044dd00 call 0x403820                                                                                                                                                             |         memset (rbx, 0x80, r13);
    0x0044dd05 jmp 0x44dd11                                                                                                                                                              |         
                                                                                                                                                                                         |     } else {
    0x0044dd07 xor ebp, ebp                                                                                                                                                              |         ebp = 0;
    0x0044dd09 xor r13d, r13d                                                                                                                                                            |         r13d = 0;
    0x0044dd0c xor ebx, ebx                                                                                                                                                              |         ebx = 0;
    0x0044dd0e xor r12d, r12d                                                                                                                                                            |         r12d = 0;
                                                                                                                                                                                         |     }
    0x0044dd11 mov rax, qword [r15 + 0x18]                                                                                                                                               |     rax = *((r15 + 0x18));
    0x0044dd15 test rax, rax                                                                                                                                                             |     
    0x0044dd18 mov qword [rsp + 8], rbp                                                                                                                                                  |     *((rsp + 8)) = rbp;
                                                                                                                                                                                         |     if (rax == 0) {
    0x0044dd1d je 0x44de0c                                                                                                                                                               |         goto label_6;
                                                                                                                                                                                         |     }
    0x0044dd23 mov r9, r14                                                                                                                                                               |     r9 = r14;
    0x0044dd26 mov ecx, ebp                                                                                                                                                              |     ecx = ebp;
    0x0044dd28 shr r9, cl                                                                                                                                                                |     r9 >>= cl;
    0x0044dd2b shl r9, 4                                                                                                                                                                 |     r9 <<= 4;
    0x0044dd2f lea rdx, [r13 - 1]                                                                                                                                                        |     rdx = r13 - 1;
    0x0044dd33 and r14b, 0x7f                                                                                                                                                            |     r14b &= 0x7f;
    0x0044dd37 xor esi, esi                                                                                                                                                              |     esi = 0;
    0x0044dd39 xor ebp, ebp                                                                                                                                                              |     ebp = 0;
    0x0044dd3b jmp 0x44dd56                                                                                                                                                              |     goto label_7;
                                                                                                                                                                                         | label_0:
    0x0044dd40 mov rax, qword [r15 + 0x18]                                                                                                                                               |     rax = *((r15 + 0x18));
    0x0044dd44 mov rsi, qword [rsp + 0x10]                                                                                                                                               |     rsi = *((rsp + 0x10));
                                                                                                                                                                                         |     do {
    0x0044dd49 add rsi, 0x10                                                                                                                                                             |         rsi += 0x10;
    0x0044dd4d cmp rsi, rax                                                                                                                                                              |         
                                                                                                                                                                                         |         if (rsi >= rax) {
    0x0044dd50 jae 0x44de0e                                                                                                                                                              |             goto label_8;
                                                                                                                                                                                         |         }
                                                                                                                                                                                         | label_7:
    0x0044dd56 mov r10, qword [r15 + 8]                                                                                                                                                  |         r10 = *((r15 + 8));
    0x0044dd5a movdqu xmm0, xmmword [r10 + rsi]                                                                                                                                          |         __asm ("movdqu xmm0, xmmword [r10 + rsi]");
    0x0044dd60 pmovmskb ecx, xmm0                                                                                                                                                        |         __asm ("pmovmskb ecx, xmm0");
    0x0044dd64 cmp cx, 0xffff                                                                                                                                                            |         
    0x0044dd68 je 0x44dd49                                                                                                                                                               |         
                                                                                                                                                                                         |     } while (cx == 0xffff);
    0x0044dd6a add r10, rsi                                                                                                                                                              |     r10 += rsi;
    0x0044dd6d mov qword [rsp + 0x10], rsi                                                                                                                                               |     *((rsp + 0x10)) = rsi;
    0x0044dd72 lea r11, [rsi*4]                                                                                                                                                          |     r11 = rsi*4;
    0x0044dd7a add r11, qword [r15]                                                                                                                                                      |     r11 += *(r15);
    0x0044dd7d not ecx                                                                                                                                                                   |     ecx = ~ecx;
    0x0044dd7f movzx eax, cx                                                                                                                                                             |     eax = (int32_t) cx;
    0x0044dd82 jmp 0x44ddac                                                                                                                                                              |     goto label_9;
                                                                                                                                                                                         | label_1:
    0x0044dd90 xor edi, edi                                                                                                                                                              |     edi = 0;
                                                                                                                                                                                         | label_2:
    0x0044dd92 mov esi, dword [r11 + rcx*4]                                                                                                                                              |     esi = *((r11 + rcx*4));
    0x0044dd96 mov dword [r12 + rdi*4], esi                                                                                                                                              |     *((r12 + rdi*4)) = esi;
    0x0044dd9a mov byte [rbx + rdi], r14b                                                                                                                                                |     *((rbx + rdi)) = r14b;
    0x0044dd9e inc rbp                                                                                                                                                                   |     rbp++;
    0x0044dda1 mov esi, 0xfffffffe                                                                                                                                                       |     esi = 0xfffffffe;
    0x0044dda6 rol esi, cl                                                                                                                                                               |     esi = rotate_left32 (esi, cl);
    0x0044dda8 and eax, esi                                                                                                                                                              |     eax &= esi;
                                                                                                                                                                                         |     if (eax == 0) {
    0x0044ddaa je 0x44dd40                                                                                                                                                               |         goto label_0;
                                                                                                                                                                                         |     }
                                                                                                                                                                                         | label_9:
    0x0044ddac bsf ecx, eax                                                                                                                                                              |     __asm ("bsf ecx, eax");
    0x0044ddaf mov byte [r10 + rcx], 0xc0                                                                                                                                                |     *((r10 + rcx)) = 0xc0;
    0x0044ddb4 dec qword [r15 + 0x10]                                                                                                                                                    |     *((r15 + 0x10))--;
    0x0044ddb8 test r13, r13                                                                                                                                                             |     
                                                                                                                                                                                         |     if (r13 == 0) {
    0x0044ddbb je 0x44dd90                                                                                                                                                               |         goto label_1;
                                                                                                                                                                                         |     }
    0x0044ddbd mov rdi, r9                                                                                                                                                               |     rdi = r9;
    0x0044ddc0 xor esi, esi                                                                                                                                                              |     esi = 0;
    0x0044ddc2 nop word cs:[rax + rax]                                                                                                                                                   |     
    0x0044ddcc nop dword [rax]                                                                                                                                                           |     
                                                                                                                                                                                         |     do {
    0x0044ddd0 movdqu xmm0, xmmword [rbx + rdi]                                                                                                                                          |         __asm ("movdqu xmm0, xmmword [rbx + rdi]");
    0x0044ddd5 pmovmskb r8d, xmm0                                                                                                                                                        |         __asm ("pmovmskb r8d, xmm0");
    0x0044ddda test r8w, r8w                                                                                                                                                             |         
                                                                                                                                                                                         |         if (r8w != 0) {
    0x0044ddde jne 0x44de00                                                                                                                                                              |             goto label_10;
                                                                                                                                                                                         |         }
    0x0044dde0 add rdi, 0x10                                                                                                                                                             |         rdi += 0x10;
    0x0044dde4 and rdi, rdx                                                                                                                                                              |         rdi &= rdx;
    0x0044dde7 add rsi, 0x10                                                                                                                                                             |         rsi += 0x10;
    0x0044ddeb cmp rsi, r13                                                                                                                                                              |         
    0x0044ddee jb 0x44ddd0                                                                                                                                                               |         
                                                                                                                                                                                         |     } while (rsi < r13);
    0x0044ddf0 mov rdi, r13                                                                                                                                                              |     rdi = r13;
    0x0044ddf3 jmp 0x44dd92                                                                                                                                                              |     goto label_2;
                                                                                                                                                                                         | label_10:
    0x0044de00 movzx esi, r8w                                                                                                                                                            |     esi = (int32_t) r8w;
    0x0044de04 bsf esi, esi                                                                                                                                                              |     __asm ("bsf esi, esi");
    0x0044de07 add rdi, rsi                                                                                                                                                              |     rdi += rsi;
    0x0044de0a jmp 0x44dd92                                                                                                                                                              |     goto label_2;
                                                                                                                                                                                         | label_6:
    0x0044de0c xor ebp, ebp                                                                                                                                                              |     ebp = 0;
                                                                                                                                                                                         | label_8:
    0x0044de0e mov rsi, qword [r15]                                                                                                                                                      |     rsi = *(r15);
    0x0044de11 mov rdi, qword [r15 + 0x38]                                                                                                                                               |     rdi = *((r15 + 0x38));
    0x0044de15 mov rax, qword [rdi]                                                                                                                                                      |     rax = *(rdi);
    0x0044de18 call qword [rax + 0x18]                                                                                                                                                   |     uint64_t (*rax + 0x18)() ();
    0x0044de1b mov rsi, qword [r15 + 8]                                                                                                                                                  |     rsi = *((r15 + 8));
    0x0044de1f mov rdi, qword [r15 + 0x38]                                                                                                                                               |     rdi = *((r15 + 0x38));
    0x0044de23 mov rax, qword [rdi]                                                                                                                                                      |     rax = *(rdi);
    0x0044de26 call qword [rax + 0x18]                                                                                                                                                   |     uint64_t (*rax + 0x18)() ();
    0x0044de29 mov qword [r15], r12                                                                                                                                                      |     *(r15) = r12;
    0x0044de2c mov qword [r15 + 8], rbx                                                                                                                                                  |     *((r15 + 8)) = rbx;
    0x0044de30 mov qword [r15 + 0x10], rbp                                                                                                                                               |     *((r15 + 0x10)) = rbp;
    0x0044de34 mov qword [r15 + 0x18], r13                                                                                                                                               |     *((r15 + 0x18)) = r13;
    0x0044de38 mov rax, qword [rsp + 8]                                                                                                                                                  |     rax = *((rsp + 8));
    0x0044de3d mov dword [r15 + 0x20], eax                                                                                                                                               |     *((r15 + 0x20)) = eax;
    0x0044de41 add rsp, 0x18                                                                                                                                                             |     
    0x0044de45 pop rbx                                                                                                                                                                   |     
    0x0044de46 pop r12                                                                                                                                                                   |     
    0x0044de48 pop r13                                                                                                                                                                   |     
    0x0044de4a pop r14                                                                                                                                                                   |     
    0x0044de4c pop r15                                                                                                                                                                   |     
    0x0044de4e pop rbp                                                                                                                                                                   |     
    0x0044de4f ret                                                                                                                                                                       |     return rax;
                                                                                                                                                                                         | label_5:
    0x0044de50 xor r13d, r13d                                                                                                                                                            |     r13d = 0;
    0x0044de53 jmp 0x44dcb3                                                                                                                                                              |     goto label_3;
                                                                                                                                                                                         | }