; assembly                                                                                                                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                         | /* bdlc_compactedarray.t/none @ 0x4301b0 */
                                                                                                                                                                                                                                                                                         | #include <stdint.h>
                                                                                                                                                                                                                                                                                         |  
    ; (fcn) sym.BloombergLP::bdlc::CompactedArray_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____::insert_unsigned_long__BloombergLP::bdlc::CompactedArray_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char______const_ ()         | int64_t BloombergLP::bdlc::CompactedArray_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_::insert_unsigned_long_BloombergLP::bdlc::CompactedArray_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_const_ (int64_t arg3, int64_t arg2, uint32_t arg1) {
                                                                                                                                                                                                                                                                                         |     rdx = arg3;
                                                                                                                                                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                                                                                                                                                         |     rdi = arg1;
                                                                                                                                                                                                                                                                                         |     /* BloombergLP::bdlc::CompactedArray<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > >::insert(unsigned long, BloombergLP::bdlc::CompactedArray<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > const&) */
    0x004301b0 push rbp                                                                                                                                                                                                                                                                  |     
    0x004301b1 push r15                                                                                                                                                                                                                                                                  |     
    0x004301b3 push r14                                                                                                                                                                                                                                                                  |     
    0x004301b5 push r13                                                                                                                                                                                                                                                                  |     
    0x004301b7 push r12                                                                                                                                                                                                                                                                  |     
    0x004301b9 push rbx                                                                                                                                                                                                                                                                  |     
    0x004301ba push rax                                                                                                                                                                                                                                                                  |     
    0x004301bb mov rbx, rdx                                                                                                                                                                                                                                                              |     rbx = rdx;
    0x004301be mov r14, rsi                                                                                                                                                                                                                                                              |     r14 = rsi;
    0x004301c1 cmp rdx, rdi                                                                                                                                                                                                                                                              |     
                                                                                                                                                                                                                                                                                         |     if (rdx == rdi) {
    0x004301c4 je 0x430286                                                                                                                                                                                                                                                               |         goto label_0;
                                                                                                                                                                                                                                                                                         |     }
    0x004301ca mov r15, rdi                                                                                                                                                                                                                                                              |     r15 = rdi;
    0x004301cd mov rax, qword [rdi + 8]                                                                                                                                                                                                                                                  |     rax = *((rdi + 8));
    0x004301d1 mov rcx, qword [rdi + 0x28]                                                                                                                                                                                                                                               |     rcx = *((rdi + 0x28));
    0x004301d5 mov qword [rsp], rcx                                                                                                                                                                                                                                                      |     *(rsp) = rcx;
    0x004301d9 mov rdi, qword [rbx + 8]                                                                                                                                                                                                                                                  |     
    0x004301dd mov rbp, qword [rbx + 0x28]                                                                                                                                                                                                                                               |     rbp = *((rbx + 0x28));
    0x004301e1 sub rax, qword [r15]                                                                                                                                                                                                                                                      |     rax -= *(r15);
    0x004301e4 sar rax, 3                                                                                                                                                                                                                                                                |     rax >>= 3;
    0x004301e8 movabs rcx, 0x6db6db6db6db6db7                                                                                                                                                                                                                                            |     rcx = 0x6db6db6db6db6db7;
    0x004301f2 imul rax, rcx                                                                                                                                                                                                                                                             |     rax *= rcx;
    0x004301f6 sub rdi, qword [rbx]                                                                                                                                                                                                                                                      |     rdi -= *(rbx);
    0x004301f9 sar rdi, 3                                                                                                                                                                                                                                                                |     rdi >>= 3;
    0x004301fd imul rdi, rcx                                                                                                                                                                                                                                                             |     rdi *= rcx;
    0x00430201 add rdi, rax                                                                                                                                                                                                                                                              |     rdi += rax;
    0x00430204 mov r13d, dword [r15 + 0x30]                                                                                                                                                                                                                                              |     r13d = *((r15 + 0x30));
    0x00430208 call 0x434690                                                                                                                                                                                                                                                             |     eax = BloombergLP::bdlc::PackedIntArrayImp_Unsigned::requiredBytesPerElement(unsigned long) (*((rbx + 8)));
    0x0043020d lea r12, [r15 + 0x20]                                                                                                                                                                                                                                                     |     r12 = r15 + 0x20;
    0x00430211 add rbp, qword [rsp]                                                                                                                                                                                                                                                      |     rbp += *(rsp);
    0x00430215 cmp eax, r13d                                                                                                                                                                                                                                                             |     
                                                                                                                                                                                                                                                                                         |     if (eax > r13d) {
    0x00430218 cmovg r13d, eax                                                                                                                                                                                                                                                           |         r13d = eax;
                                                                                                                                                                                                                                                                                         |     }
    0x0043021c movsxd rsi, r13d                                                                                                                                                                                                                                                          |     rsi = (int64_t) r13d;
    0x0043021f imul rsi, rbp                                                                                                                                                                                                                                                             |     rsi *= rbp;
    0x00430223 cmp rsi, qword [r15 + 0x38]                                                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                                                                         |     if (rsi > *((r15 + 0x38))) {
    0x00430227 jbe 0x430231                                                                                                                                                                                                                                                              |         
    0x00430229 mov rdi, r12                                                                                                                                                                                                                                                              |         
    0x0043022c call 0x439a60                                                                                                                                                                                                                                                             |         BloombergLP::bdlc::PackedIntArrayImp<BloombergLP::bdlc::PackedIntArrayImp_Unsigned>::reserveCapacityImp(unsigned long) (r12, rsi);
                                                                                                                                                                                                                                                                                         |     }
    0x00430231 cmp qword [rbx + 0x28], 0                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                                         |     if (*((rbx + 0x28)) == 0) {
    0x00430236 je 0x430277                                                                                                                                                                                                                                                               |         goto label_1;
                                                                                                                                                                                                                                                                                         |     }
    0x00430238 lea r13, [rbx + 0x20]                                                                                                                                                                                                                                                     |     r13 = rbx + 0x20;
    0x0043023c xor ebp, ebp                                                                                                                                                                                                                                                              |     ebp = 0;
    0x0043023e nop                                                                                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                                                                         |     do {
    0x00430240 mov rdi, r13                                                                                                                                                                                                                                                              |         
    0x00430243 mov rsi, rbp                                                                                                                                                                                                                                                              |         rsi = rbp;
    0x00430246 call 0x43adf0                                                                                                                                                                                                                                                             |         rax = BloombergLP::bdlc::PackedIntArrayImp<BloombergLP::bdlc::PackedIntArrayImp_Unsigned>::operator [] (unsigned long)const (r13);
    0x0043024b imul rsi, rax, 0x38                                                                                                                                                                                                                                                       |         rsi = rax * 0x38;
    0x0043024f add rsi, qword [rbx]                                                                                                                                                                                                                                                      |         rsi += *(rbx);
    0x00430252 mov edx, 1                                                                                                                                                                                                                                                                |         
    0x00430257 mov rdi, r15                                                                                                                                                                                                                                                              |         
    0x0043025a call 0x4317b0                                                                                                                                                                                                                                                             |         rax = BloombergLP::bdlc::CompactedArray<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>::increment(bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,unsigned long) (r15, rsi, 1);
    0x0043025f lea rsi, [r14 + rbp]                                                                                                                                                                                                                                                      |         
    0x00430263 mov rdi, r12                                                                                                                                                                                                                                                              |         
    0x00430266 mov rdx, rax                                                                                                                                                                                                                                                              |         
    0x00430269 call 0x439e40                                                                                                                                                                                                                                                             |         BloombergLP::bdlc::PackedIntArrayImp<BloombergLP::bdlc::PackedIntArrayImp_Unsigned>::insert(unsigned long,unsigned long) (r12, r14 + rbp, rax);
    0x0043026e inc rbp                                                                                                                                                                                                                                                                   |         rbp++;
    0x00430271 cmp rbp, qword [rbx + 0x28]                                                                                                                                                                                                                                               |         
    0x00430275 jb 0x430240                                                                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                                                                         |     } while (rbp < *((rbx + 0x28)));
                                                                                                                                                                                                                                                                                         | label_1:
    0x00430277 add rsp, 8                                                                                                                                                                                                                                                                |     
    0x0043027b pop rbx                                                                                                                                                                                                                                                                   |     
    0x0043027c pop r12                                                                                                                                                                                                                                                                   |     
    0x0043027e pop r13                                                                                                                                                                                                                                                                   |     
    0x00430280 pop r14                                                                                                                                                                                                                                                                   |     
    0x00430282 pop r15                                                                                                                                                                                                                                                                   |     
    0x00430284 pop rbp                                                                                                                                                                                                                                                                   |     
    0x00430285 ret                                                                                                                                                                                                                                                                       |     return rax;
                                                                                                                                                                                                                                                                                         | label_0:
    0x00430286 lea r15, [rbx + 0x20]                                                                                                                                                                                                                                                     |     r15 = rbx + 0x20;
    0x0043028a mov rsi, qword [rbx + 0x28]                                                                                                                                                                                                                                               |     
    0x0043028e shl rsi, 4                                                                                                                                                                                                                                                                |     rsi <<= 4;
    0x00430292 mov rdi, r15                                                                                                                                                                                                                                                              |     
    0x00430295 call 0x439a60                                                                                                                                                                                                                                                             |     BloombergLP::bdlc::PackedIntArrayImp<BloombergLP::bdlc::PackedIntArrayImp_Unsigned>::reserveCapacityImp(unsigned long) (r15, *((rbx + 0x28)));
    0x0043029a mov rax, qword [rbx]                                                                                                                                                                                                                                                      |     rax = *(rbx);
    0x0043029d cmp qword [rbx + 8], rax                                                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == rax) {
    0x004302a1 je 0x4302e2                                                                                                                                                                                                                                                               |         goto label_2;
                                                                                                                                                                                                                                                                                         |     }
    0x004302a3 mov ecx, 0x30                                                                                                                                                                                                                                                             |     ecx = 0x30;
    0x004302a8 xor edx, edx                                                                                                                                                                                                                                                              |     edx = 0;
    0x004302aa movabs rsi, 0x6db6db6db6db6db7                                                                                                                                                                                                                                            |     rsi = 0x6db6db6db6db6db7;
    0x004302b4 nop word cs:[rax + rax]                                                                                                                                                                                                                                                   |     
    0x004302be nop                                                                                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                                                                         |     do {
    0x004302c0 shl qword [rax + rcx], 1                                                                                                                                                                                                                                                  |         *((rax + rcx)) <<= 1;
    0x004302c4 inc rdx                                                                                                                                                                                                                                                                   |         rdx++;
    0x004302c7 mov rax, qword [rbx]                                                                                                                                                                                                                                                      |         rax = *(rbx);
    0x004302ca mov rdi, qword [rbx + 8]                                                                                                                                                                                                                                                  |         rdi = *((rbx + 8));
    0x004302ce sub rdi, rax                                                                                                                                                                                                                                                              |         rdi -= rax;
    0x004302d1 sar rdi, 3                                                                                                                                                                                                                                                                |         rdi >>= 3;
    0x004302d5 imul rdi, rsi                                                                                                                                                                                                                                                             |         rdi *= rsi;
    0x004302d9 add rcx, 0x38                                                                                                                                                                                                                                                             |         rcx += 0x38;
    0x004302dd cmp rdx, rdi                                                                                                                                                                                                                                                              |         
    0x004302e0 jb 0x4302c0                                                                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                                                                         |     } while (rdx < rdi);
                                                                                                                                                                                                                                                                                         | label_2:
    0x004302e2 mov r8, qword [rbx + 0x28]                                                                                                                                                                                                                                                |     r8 = *((rbx + 0x28));
    0x004302e6 mov rdi, r15                                                                                                                                                                                                                                                              |     rdi = r15;
    0x004302e9 mov rsi, r14                                                                                                                                                                                                                                                              |     rsi = r14;
    0x004302ec mov rdx, r15                                                                                                                                                                                                                                                              |     rdx = r15;
    0x004302ef xor ecx, ecx                                                                                                                                                                                                                                                              |     ecx = 0;
    0x004302f1 add rsp, 8                                                                                                                                                                                                                                                                |     
    0x004302f5 pop rbx                                                                                                                                                                                                                                                                   |     
    0x004302f6 pop r12                                                                                                                                                                                                                                                                   |     
    0x004302f8 pop r13                                                                                                                                                                                                                                                                   |     
    0x004302fa pop r14                                                                                                                                                                                                                                                                   |     
    0x004302fc pop r15                                                                                                                                                                                                                                                                   |     
    0x004302fe pop rbp                                                                                                                                                                                                                                                                   |     
    0x004302ff jmp 0x43a060                                                                                                                                                                                                                                                              |     return void (*0x43a060)() ();
                                                                                                                                                                                                                                                                                         | }