; assembly                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                     | /* balb_filecleanerutil.t/assume @ 0x40c850 */
                                                                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlma::SequentialPool.SequentialPool_unsigned_long__unsigned_long__BloombergLP::bsls::BlockGrowth::Strategy__BloombergLP::bsls::Alignment::Strategy__bool__BloombergLP::bslma::Allocator_ ()         | int64_t method_BloombergLP::bdlma::SequentialPool_SequentialPool_unsigned_long_unsigned_long_BloombergLP::bsls::BlockGrowth::Strategy_BloombergLP::bsls::Alignment::Strategy_bool_BloombergLP::bslma::Allocator_ (int64_t arg_30h, int64_t arg6, uint32_t arg5, int64_t arg4, uint32_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                     |     r9 = arg6;
                                                                                                                                                                                                                                     |     r8 = arg5;
                                                                                                                                                                                                                                     |     rcx = arg4;
                                                                                                                                                                                                                                     |     rdx = arg3;
                                                                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                                     |     /* BloombergLP::bdlma::SequentialPool::SequentialPool(unsigned long, unsigned long, BloombergLP::bsls::BlockGrowth::Strategy, BloombergLP::bsls::Alignment::Strategy, bool, BloombergLP::bslma::Allocator*) */
    0x0040c850 push rbp                                                                                                                                                                                                              |     
    0x0040c851 push r15                                                                                                                                                                                                              |     
    0x0040c853 push r14                                                                                                                                                                                                              |     
    0x0040c855 push rbx                                                                                                                                                                                                              |     
    0x0040c856 push rax                                                                                                                                                                                                              |     
    0x0040c857 mov r15d, r9d                                                                                                                                                                                                         |     r15d = r9d;
    0x0040c85a mov r9d, ecx                                                                                                                                                                                                          |     r9d = ecx;
    0x0040c85d mov r14, rsi                                                                                                                                                                                                          |     r14 = rsi;
    0x0040c860 mov rbx, rdi                                                                                                                                                                                                          |     rbx = rdi;
    0x0040c863 mov rax, qword [rsp + 0x30]                                                                                                                                                                                           |     rax = *((rsp + 0x30));
    0x0040c868 movabs rsi, 0xffffffffffffff                                                                                                                                                                                          |     rsi = 0xffffffffffffff;
    0x0040c872 test r8d, r8d                                                                                                                                                                                                         |     
    0x0040c875 mov ecx, 0xf                                                                                                                                                                                                          |     ecx = 0xf;
                                                                                                                                                                                                                                     |     if (r8d == 0) {
    0x0040c87a cmove ecx, r8d                                                                                                                                                                                                        |         ecx = r8d;
                                                                                                                                                                                                                                     |     }
    0x0040c87e xorps xmm0, xmm0                                                                                                                                                                                                      |     __asm ("xorps xmm0, xmm0");
    0x0040c881 movups xmmword [rdi], xmm0                                                                                                                                                                                            |     __asm ("movups xmmword [rdi], xmm0");
    0x0040c884 mov qword [rdi + 0x10], 0                                                                                                                                                                                             |     *((rdi + 0x10)) = 0;
    0x0040c88c mov byte [rdi + 0x18], cl                                                                                                                                                                                             |     *((rdi + 0x18)) = cl;
    0x0040c88f cmp r8d, 2                                                                                                                                                                                                            |     
    0x0040c893 mov ecx, 1                                                                                                                                                                                                            |     ecx = 1;
    0x0040c898 mov edi, 0x10                                                                                                                                                                                                         |     edi = 0x10;
                                                                                                                                                                                                                                     |     if (r8d == 2) {
    0x0040c89d cmove edi, ecx                                                                                                                                                                                                        |         edi = ecx;
                                                                                                                                                                                                                                     |     }
    0x0040c8a0 mov byte [rbx + 0x19], dil                                                                                                                                                                                            |     *((rbx + 0x19)) = dil;
    0x0040c8a4 lea rcx, [rbx + 0x20]                                                                                                                                                                                                 |     rcx = rbx + 0x20;
    0x0040c8a8 mov qword [rbx + 0x20], 0                                                                                                                                                                                             |     *((rbx + 0x20)) = 0;
    0x0040c8b0 mov qword [rbx + 0x28], rcx                                                                                                                                                                                           |     *((rbx + 0x28)) = rcx;
    0x0040c8b4 lea rcx, [r14 - 1]                                                                                                                                                                                                    |     rcx = r14 - 1;
    0x0040c8b8 mov rdi, rcx                                                                                                                                                                                                          |     rdi = rcx;
    0x0040c8bb or rdi, 1                                                                                                                                                                                                             |     rdi |= 1;
    0x0040c8bf bsr rbp, rdi                                                                                                                                                                                                          |     __asm ("bsr rbp, rdi");
    0x0040c8c3 xor ebp, 0x3f                                                                                                                                                                                                         |     ebp ^= 0x3f;
    0x0040c8c6 cmp rcx, 1                                                                                                                                                                                                            |     
    0x0040c8ca adc ebp, 0                                                                                                                                                                                                            |     ebp += 0;
    0x0040c8cd mov ecx, ebp                                                                                                                                                                                                          |     ecx = ebp;
    0x0040c8cf neg cl                                                                                                                                                                                                                |     cl = -cl;
    0x0040c8d1 mov edi, 1                                                                                                                                                                                                            |     edi = 1;
    0x0040c8d6 shl rdi, cl                                                                                                                                                                                                           |     rdi <<= cl;
    0x0040c8d9 test ebp, ebp                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (ebp != 0) {
    0x0040c8db je 0x40c8e0                                                                                                                                                                                                           |         
    0x0040c8dd add rsi, rdi                                                                                                                                                                                                          |         rsi += rdi;
                                                                                                                                                                                                                                     |     }
    0x0040c8e0 movabs rcx, 0x7ffffffffffffffe                                                                                                                                                                                        |     rcx = 0x7ffffffffffffffe;
    0x0040c8ea and rdx, rcx                                                                                                                                                                                                          |     rdx &= rcx;
    0x0040c8ed lea rcx, [rdx + 1]                                                                                                                                                                                                    |     rcx = rdx + 1;
    0x0040c8f1 bsr rdi, rcx                                                                                                                                                                                                          |     __asm ("bsr rdi, rcx");
    0x0040c8f5 xor edi, 0x3f                                                                                                                                                                                                         |     edi ^= 0x3f;
    0x0040c8f8 cmp rdx, 1                                                                                                                                                                                                            |     
    0x0040c8fc sbb ecx, ecx                                                                                                                                                                                                          |     ecx -= ecx;
    0x0040c8fe sub ecx, edi                                                                                                                                                                                                          |     ecx -= edi;
    0x0040c900 mov rdx, 0xffffffffffffffff                                                                                                                                                                                           |     rdx = 0xffffffffffffffff;
    0x0040c907 shl rdx, cl                                                                                                                                                                                                           |     rdx <<= cl;
    0x0040c90a movabs rcx, 0xff00000000000000                                                                                                                                                                                        |     rcx = 0xff00000000000000;
    0x0040c914 or rcx, rsi                                                                                                                                                                                                           |     rcx |= rsi;
    0x0040c917 or rcx, rdx                                                                                                                                                                                                           |     rcx |= rdx;
    0x0040c91a mov qword [rbx + 0x1f0], rcx                                                                                                                                                                                          |     *((rbx + 0x1f0)) = rcx;
    0x0040c921 xor edx, edx                                                                                                                                                                                                          |     edx = 0;
    0x0040c923 test r9d, r9d                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (r9d != 0) {
    0x0040c926 cmovne rdx, r14                                                                                                                                                                                                       |         rdx = r14;
                                                                                                                                                                                                                                     |     }
    0x0040c92a mov qword [rbx + 0x1f8], rcx                                                                                                                                                                                          |     *((rbx + 0x1f8)) = rcx;
    0x0040c931 movups xmmword [rbx + 0x200], xmm0                                                                                                                                                                                    |     __asm ("movups xmmword [rbx + 0x200], xmm0");
    0x0040c938 mov qword [rbx + 0x210], rdx                                                                                                                                                                                          |     *((rbx + 0x210)) = rdx;
    0x0040c93f test rax, rax                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (rax == 0) {
    0x0040c942 jne 0x40c955                                                                                                                                                                                                          |         
    0x0040c944 mov rax, qword [rip + 0x261385]                                                                                                                                                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0040c94b test rax, rax                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                     |         if (rax != 0) {
    0x0040c94e jne 0x40c955                                                                                                                                                                                                          |             goto label_0;
                                                                                                                                                                                                                                     |         }
    0x0040c950 call 0x4171b0                                                                                                                                                                                                         |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                     | label_0:
    0x0040c955 mov qword [rbx + 0x218], rax                                                                                                                                                                                          |     *((rbx + 0x218)) = rax;
    0x0040c95c test r15b, r15b                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                     |     if (r15b != 0) {
    0x0040c95f je 0x40c96c                                                                                                                                                                                                           |         
    0x0040c961 mov rdi, rbx                                                                                                                                                                                                          |         
    0x0040c964 mov rsi, r14                                                                                                                                                                                                          |         
    0x0040c967 call 0x40bf00                                                                                                                                                                                                         |         BloombergLP::bdlma::SequentialPool::reserveCapacity(unsigned long) (rbx, r14);
                                                                                                                                                                                                                                     |     }
    0x0040c96c add rsp, 8                                                                                                                                                                                                            |     
    0x0040c970 pop rbx                                                                                                                                                                                                               |     
    0x0040c971 pop r14                                                                                                                                                                                                               |     
    0x0040c973 pop r15                                                                                                                                                                                                               |     
    0x0040c975 pop rbp                                                                                                                                                                                                               |     
    0x0040c976 ret                                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                                     | }