; assembly                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                     | /* bblb_schedulegenerationutil.t/assume @ 0x41b6e0 */
                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlc::PackedIntArrayImp_BloombergLP::bdlc::PackedIntArrayImp_Signed_.PackedIntArrayImp_unsigned_long__long__BloombergLP::bslma::Allocator_ ()        | uint64_t method_BloombergLP::bdlc::PackedIntArrayImp_BloombergLP::bdlc::PackedIntArrayImp_Signed_PackedIntArrayImp_unsigned_long_long_BloombergLP::bslma::Allocator_ (int64_t arg4, int64_t arg3, uint32_t arg2, int64_t arg1) {
                                                                                                                                                                                     |     rcx = arg4;
                                                                                                                                                                                     |     rdx = arg3;
                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                     |     /* BloombergLP::bdlc::PackedIntArrayImp<BloombergLP::bdlc::PackedIntArrayImp_Signed>::PackedIntArrayImp(unsigned long, long, BloombergLP::bslma::Allocator*) */
    0x0041b6e0 push r14                                                                                                                                                              |     
    0x0041b6e2 push rbx                                                                                                                                                              |     
    0x0041b6e3 push rax                                                                                                                                                              |     
    0x0041b6e4 mov r14, rdx                                                                                                                                                          |     r14 = rdx;
    0x0041b6e7 mov rbx, rdi                                                                                                                                                          |     rbx = rdi;
    0x0041b6ea mov qword [rdi], 0                                                                                                                                                    |     *(rdi) = 0;
    0x0041b6f1 mov qword [rdi + 8], rsi                                                                                                                                              |     *((rdi + 8)) = rsi;
    0x0041b6f5 mov dword [rdi + 0x10], 1                                                                                                                                             |     *((rdi + 0x10)) = 1;
    0x0041b6fc mov qword [rdi + 0x18], 0                                                                                                                                             |     *((rdi + 0x18)) = 0;
    0x0041b704 test rcx, rcx                                                                                                                                                         |     
                                                                                                                                                                                     |     if (rcx == 0) {
    0x0041b707 jne 0x41b721                                                                                                                                                          |         
    0x0041b709 mov rcx, qword [rip + 0x261788]                                                                                                                                       |         rcx = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0041b710 test rcx, rcx                                                                                                                                                         |         
                                                                                                                                                                                     |         if (rcx != 0) {
    0x0041b713 jne 0x41b721                                                                                                                                                          |             goto label_0;
                                                                                                                                                                                     |         }
    0x0041b715 call 0x421290                                                                                                                                                         |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x0041b71a mov rcx, rax                                                                                                                                                          |         rcx = rax;
    0x0041b71d mov rsi, qword [rbx + 8]                                                                                                                                              |         rsi = *((rbx + 8));
                                                                                                                                                                                     |     }
                                                                                                                                                                                     | label_0:
    0x0041b721 mov qword [rbx + 0x20], rcx                                                                                                                                           |     *((rbx + 0x20)) = rcx;
    0x0041b725 test rsi, rsi                                                                                                                                                         |     
                                                                                                                                                                                     |     if (rsi == 0) {
    0x0041b728 je 0x41b84d                                                                                                                                                           |         goto label_1;
                                                                                                                                                                                     |     }
    0x0041b72e cmp r14, 0xffffffffffffff80                                                                                                                                           |     
                                                                                                                                                                                     |     if (r14 < 0xffffffffffffff80) {
    0x0041b732 jge 0x41b750                                                                                                                                                          |         
    0x0041b734 mov eax, 2                                                                                                                                                            |         eax = 2;
    0x0041b739 cmp r14, 0xffffffffffff7fff                                                                                                                                           |         
                                                                                                                                                                                     |         if (r14 > 0xffffffffffff7fff) {
    0x0041b740 jg 0x41b779                                                                                                                                                           |             goto label_2;
                                                                                                                                                                                     |         }
    0x0041b742 xor eax, eax                                                                                                                                                          |         eax = 0;
    0x0041b744 cmp r14, 0xffffffff80000000                                                                                                                                           |         
    0x0041b74b setl al                                                                                                                                                               |         al = (r14 < 0xffffffff80000000) ? 1 : 0;
    0x0041b74e jmp 0x41b765                                                                                                                                                          |         
                                                                                                                                                                                     |     } else {
    0x0041b750 cmp r14, 0x8000                                                                                                                                                       |         
                                                                                                                                                                                     |         if (r14 < 0x8000) {
    0x0041b757 jl 0x41b76e                                                                                                                                                           |             goto label_3;
                                                                                                                                                                                     |         }
    0x0041b759 xor eax, eax                                                                                                                                                          |         eax = 0;
    0x0041b75b cmp r14, 0x7fffffff                                                                                                                                                   |         
    0x0041b762 setg al                                                                                                                                                               |         al = (r14 > 0x7fffffff) ? 1 : 0;
                                                                                                                                                                                     |     }
    0x0041b765 lea eax, [rax*4 + 4]                                                                                                                                                  |     eax = rax*4 + 4;
    0x0041b76c jmp 0x41b779                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                     | label_3:
    0x0041b76e xor eax, eax                                                                                                                                                          |     eax = 0;
    0x0041b770 cmp r14, 0x7f                                                                                                                                                         |     
    0x0041b774 setg al                                                                                                                                                               |     al = (r14 > 0x7f) ? 1 : 0;
    0x0041b777 inc eax                                                                                                                                                               |     eax++;
                                                                                                                                                                                     | label_2:
    0x0041b779 mov dword [rbx + 0x10], eax                                                                                                                                           |     *((rbx + 0x10)) = eax;
    0x0041b77c mov eax, eax                                                                                                                                                          |     
    0x0041b77e imul rsi, rax                                                                                                                                                         |     rsi *= rax;
    0x0041b782 cmp rsi, 0x55555550                                                                                                                                                   |     
                                                                                                                                                                                     |     if (rsi > 0x55555550) {
    0x0041b789 ja 0x41b855                                                                                                                                                           |         goto label_4;
                                                                                                                                                                                     |     }
    0x0041b78f xor eax, eax                                                                                                                                                          |     eax = 0;
    0x0041b791 nop word cs:[rax + rax]                                                                                                                                               |     
    0x0041b79b nop dword [rax + rax]                                                                                                                                                 |     
                                                                                                                                                                                     |     do {
    0x0041b7a0 lea rdx, [rax + 3]                                                                                                                                                    |         rdx = rax + 3;
    0x0041b7a4 shr rdx, 1                                                                                                                                                            |         rdx >>= 1;
    0x0041b7a7 add rax, rdx                                                                                                                                                          |         rax += rdx;
    0x0041b7aa cmp rax, rsi                                                                                                                                                          |         
    0x0041b7ad jb 0x41b7a0                                                                                                                                                           |         
                                                                                                                                                                                     |     } while (rax < rsi);
                                                                                                                                                                                     |     do {
    0x0041b7af mov qword [rbx + 0x18], rax                                                                                                                                           |         *((rbx + 0x18)) = rax;
    0x0041b7b3 mov rdx, qword [rcx]                                                                                                                                                  |         rdx = *(rcx);
    0x0041b7b6 mov rdi, rcx                                                                                                                                                          |         rdi = rcx;
    0x0041b7b9 mov rsi, rax                                                                                                                                                          |         rsi = rax;
    0x0041b7bc call qword [rdx + 0x10]                                                                                                                                               |         rax = uint64_t (*rdx + 0x10)() ();
    0x0041b7bf mov qword [rbx], rax                                                                                                                                                  |         *(rbx) = rax;
    0x0041b7c2 mov ecx, dword [rbx + 0x10]                                                                                                                                           |         ecx = *((rbx + 0x10));
    0x0041b7c5 dec ecx                                                                                                                                                               |         ecx--;
    0x0041b7c7 jmp qword [rcx*8 + 0x45fd20]                                                                                                                                          |         
                                                                                                                                                                                     | label_1:
    0x0041b84d add rsp, 8                                                                                                                                                            |         
    0x0041b851 pop rbx                                                                                                                                                               |         
    0x0041b852 pop r14                                                                                                                                                               |         
    0x0041b854 ret                                                                                                                                                                   |         return rax;
                                                                                                                                                                                     | label_4:
    0x0041b855 mov rax, rsi                                                                                                                                                          |         rax = rsi;
    0x0041b858 jmp 0x41b7af                                                                                                                                                          |         
                                                                                                                                                                                     |     } while (1);
                                                                                                                                                                                     | }