; assembly                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                     | /* balb_filecleanerutil.t/none @ 0x40c7b0 */
                                                                                                                                                                                                                                     | #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*) */
    0x0040c7b0 push rbp                                                                                                                                                                                                              |     
    0x0040c7b1 push r15                                                                                                                                                                                                              |     
    0x0040c7b3 push r14                                                                                                                                                                                                              |     
    0x0040c7b5 push rbx                                                                                                                                                                                                              |     
    0x0040c7b6 push rax                                                                                                                                                                                                              |     
    0x0040c7b7 mov r14d, r9d                                                                                                                                                                                                         |     r14d = r9d;
    0x0040c7ba mov r9d, ecx                                                                                                                                                                                                          |     r9d = ecx;
    0x0040c7bd mov r15, rsi                                                                                                                                                                                                          |     r15 = rsi;
    0x0040c7c0 mov rbp, rdi                                                                                                                                                                                                          |     
    0x0040c7c3 mov rax, qword [rsp + 0x30]                                                                                                                                                                                           |     rax = *((rsp + 0x30));
    0x0040c7c8 movabs rsi, 0xffffffffffffff                                                                                                                                                                                          |     rsi = 0xffffffffffffff;
    0x0040c7d2 test r8d, r8d                                                                                                                                                                                                         |     
    0x0040c7d5 mov ecx, 0xf                                                                                                                                                                                                          |     ecx = 0xf;
                                                                                                                                                                                                                                     |     if (r8d == 0) {
    0x0040c7da cmove ecx, r8d                                                                                                                                                                                                        |         ecx = r8d;
                                                                                                                                                                                                                                     |     }
    0x0040c7de xorps xmm0, xmm0                                                                                                                                                                                                      |     __asm ("xorps xmm0, xmm0");
    0x0040c7e1 movups xmmword [rdi], xmm0                                                                                                                                                                                            |     __asm ("movups xmmword [rdi], xmm0");
    0x0040c7e4 mov qword [rdi + 0x10], 0                                                                                                                                                                                             |     *((rdi + 0x10)) = 0;
    0x0040c7ec mov byte [rdi + 0x18], cl                                                                                                                                                                                             |     *((rdi + 0x18)) = cl;
    0x0040c7ef cmp r8d, 2                                                                                                                                                                                                            |     
    0x0040c7f3 mov ecx, 1                                                                                                                                                                                                            |     ecx = 1;
    0x0040c7f8 mov edi, 0x10                                                                                                                                                                                                         |     edi = 0x10;
                                                                                                                                                                                                                                     |     if (r8d == 2) {
    0x0040c7fd cmove edi, ecx                                                                                                                                                                                                        |         edi = ecx;
                                                                                                                                                                                                                                     |     }
    0x0040c800 mov byte [rbp + 0x19], dil                                                                                                                                                                                            |     *((rbp + 0x19)) = dil;
    0x0040c804 lea rcx, [rbp + 0x20]                                                                                                                                                                                                 |     rcx = rbp + 0x20;
    0x0040c808 mov qword [rbp + 0x20], 0                                                                                                                                                                                             |     *((rbp + 0x20)) = 0;
    0x0040c810 mov qword [rbp + 0x28], rcx                                                                                                                                                                                           |     *((rbp + 0x28)) = rcx;
    0x0040c814 lea rcx, [r15 - 1]                                                                                                                                                                                                    |     rcx = r15 - 1;
    0x0040c818 mov rdi, rcx                                                                                                                                                                                                          |     rdi = rcx;
    0x0040c81b or rdi, 1                                                                                                                                                                                                             |     rdi |= 1;
    0x0040c81f bsr rbx, rdi                                                                                                                                                                                                          |     __asm ("bsr rbx, rdi");
    0x0040c823 xor ebx, 0x3f                                                                                                                                                                                                         |     ebx ^= 0x3f;
    0x0040c826 cmp rcx, 1                                                                                                                                                                                                            |     
    0x0040c82a adc ebx, 0                                                                                                                                                                                                            |     ebx += 0;
    0x0040c82d mov ecx, ebx                                                                                                                                                                                                          |     ecx = ebx;
    0x0040c82f neg cl                                                                                                                                                                                                                |     cl = -cl;
    0x0040c831 mov edi, 1                                                                                                                                                                                                            |     edi = 1;
    0x0040c836 shl rdi, cl                                                                                                                                                                                                           |     rdi <<= cl;
    0x0040c839 test ebx, ebx                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (ebx != 0) {
    0x0040c83b je 0x40c840                                                                                                                                                                                                           |         
    0x0040c83d add rsi, rdi                                                                                                                                                                                                          |         rsi += rdi;
                                                                                                                                                                                                                                     |     }
    0x0040c840 movabs rcx, 0x7ffffffffffffffe                                                                                                                                                                                        |     rcx = 0x7ffffffffffffffe;
    0x0040c84a and rdx, rcx                                                                                                                                                                                                          |     rdx &= rcx;
    0x0040c84d lea rcx, [rdx + 1]                                                                                                                                                                                                    |     rcx = rdx + 1;
    0x0040c851 bsr rdi, rcx                                                                                                                                                                                                          |     __asm ("bsr rdi, rcx");
    0x0040c855 xor edi, 0x3f                                                                                                                                                                                                         |     edi ^= 0x3f;
    0x0040c858 cmp rdx, 1                                                                                                                                                                                                            |     
    0x0040c85c sbb ecx, ecx                                                                                                                                                                                                          |     ecx -= ecx;
    0x0040c85e sub ecx, edi                                                                                                                                                                                                          |     ecx -= edi;
    0x0040c860 mov rdx, 0xffffffffffffffff                                                                                                                                                                                           |     rdx = 0xffffffffffffffff;
    0x0040c867 shl rdx, cl                                                                                                                                                                                                           |     rdx <<= cl;
    0x0040c86a movabs rcx, 0xff00000000000000                                                                                                                                                                                        |     rcx = 0xff00000000000000;
    0x0040c874 or rcx, rsi                                                                                                                                                                                                           |     rcx |= rsi;
    0x0040c877 or rcx, rdx                                                                                                                                                                                                           |     rcx |= rdx;
    0x0040c87a mov qword [rbp + 0x1f0], rcx                                                                                                                                                                                          |     *((rbp + 0x1f0)) = rcx;
    0x0040c881 xor edx, edx                                                                                                                                                                                                          |     edx = 0;
    0x0040c883 test r9d, r9d                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (r9d != 0) {
    0x0040c886 cmovne rdx, r15                                                                                                                                                                                                       |         rdx = r15;
                                                                                                                                                                                                                                     |     }
    0x0040c88a mov qword [rbp + 0x1f8], rcx                                                                                                                                                                                          |     *((rbp + 0x1f8)) = rcx;
    0x0040c891 movups xmmword [rbp + 0x200], xmm0                                                                                                                                                                                    |     __asm ("movups xmmword [rbp + 0x200], xmm0");
    0x0040c898 mov qword [rbp + 0x210], rdx                                                                                                                                                                                          |     *((rbp + 0x210)) = rdx;
    0x0040c89f test rax, rax                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                     |     if (rax == 0) {
    0x0040c8a2 jne 0x40c8b5                                                                                                                                                                                                          |         
    0x0040c8a4 mov rax, qword [rip + 0x261425]                                                                                                                                                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0040c8ab test rax, rax                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                     |         if (rax != 0) {
    0x0040c8ae jne 0x40c8b5                                                                                                                                                                                                          |             goto label_0;
                                                                                                                                                                                                                                     |         }
    0x0040c8b0 call 0x4173a0                                                                                                                                                                                                         |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                     | label_0:
    0x0040c8b5 mov qword [rbp + 0x218], rax                                                                                                                                                                                          |     *((rbp + 0x218)) = rax;
    0x0040c8bc test r14b, r14b                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                     |     if (r14b != 0) {
    0x0040c8bf je 0x40c8d6                                                                                                                                                                                                           |         
    0x0040c8c1 mov rdi, rbp                                                                                                                                                                                                          |         rdi = rbp;
    0x0040c8c4 mov rsi, r15                                                                                                                                                                                                          |         rsi = r15;
    0x0040c8c7 add rsp, 8                                                                                                                                                                                                            |         
    0x0040c8cb pop rbx                                                                                                                                                                                                               |         
    0x0040c8cc pop r14                                                                                                                                                                                                               |         
    0x0040c8ce pop r15                                                                                                                                                                                                               |         
    0x0040c8d0 pop rbp                                                                                                                                                                                                               |         
    0x0040c8d1 jmp 0x40bea0                                                                                                                                                                                                          |         void (*0x40bea0)() ();
                                                                                                                                                                                                                                     |     }
    0x0040c8d6 add rsp, 8                                                                                                                                                                                                            |     
    0x0040c8da pop rbx                                                                                                                                                                                                               |     
    0x0040c8db pop r14                                                                                                                                                                                                               |     
    0x0040c8dd pop r15                                                                                                                                                                                                               |     
    0x0040c8df pop rbp                                                                                                                                                                                                               |     
    0x0040c8e0 ret                                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                                     | }