; assembly                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                         | /* balb_filecleanerutil.t/assume @ 0x40c150 */
                                                                                                                                                                         | #include <stdint.h>
                                                                                                                                                                         |  
    ; (fcn) method.BloombergLP::bdlma::SequentialPool.SequentialPool_unsigned_long__BloombergLP::bsls::BlockGrowth::Strategy__BloombergLP::bslma::Allocator_ ()          | int64_t method_BloombergLP::bdlma::SequentialPool_SequentialPool_unsigned_long_BloombergLP::bsls::BlockGrowth::Strategy_BloombergLP::bslma::Allocator_ (int64_t arg4, int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                                                         |     rcx = arg4;
                                                                                                                                                                         |     rdx = arg3;
                                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                                         |     rdi = arg1;
                                                                                                                                                                         |     /* BloombergLP::bdlma::SequentialPool::SequentialPool(unsigned long, BloombergLP::bsls::BlockGrowth::Strategy, BloombergLP::bslma::Allocator*) */
    0x0040c150 push r14                                                                                                                                                  |     
    0x0040c152 push rbx                                                                                                                                                  |     
    0x0040c153 push rax                                                                                                                                                  |     
    0x0040c154 mov rax, rcx                                                                                                                                              |     rax = rcx;
    0x0040c157 mov r14, rsi                                                                                                                                              |     r14 = rsi;
    0x0040c15a mov rbx, rdi                                                                                                                                              |     rbx = rdi;
    0x0040c15d xorps xmm0, xmm0                                                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0040c160 movups xmmword [rdi], xmm0                                                                                                                                |     __asm ("movups xmmword [rdi], xmm0");
    0x0040c163 mov qword [rdi + 0x10], 0                                                                                                                                 |     *((rdi + 0x10)) = 0;
    0x0040c16b mov word [rdi + 0x18], 0x100f                                                                                                                             |     *((rdi + 0x18)) = 0x100f;
    0x0040c171 lea rcx, [rdi + 0x20]                                                                                                                                     |     rcx = rdi + 0x20;
    0x0040c175 mov qword [rdi + 0x20], 0                                                                                                                                 |     *((rdi + 0x20)) = 0;
    0x0040c17d mov qword [rdi + 0x28], rcx                                                                                                                               |     *((rdi + 0x28)) = rcx;
    0x0040c181 lea rcx, [rsi - 1]                                                                                                                                        |     rcx = rsi - 1;
    0x0040c185 mov rsi, rcx                                                                                                                                              |     rsi = rcx;
    0x0040c188 or rsi, 1                                                                                                                                                 |     rsi |= 1;
    0x0040c18c bsr rdi, rsi                                                                                                                                              |     __asm ("bsr rdi, rsi");
    0x0040c190 xor edi, 0x3f                                                                                                                                             |     edi ^= 0x3f;
    0x0040c193 cmp rcx, 1                                                                                                                                                |     
    0x0040c197 adc edi, 0                                                                                                                                                |     edi += 0;
    0x0040c19a mov ecx, edi                                                                                                                                              |     ecx = edi;
    0x0040c19c neg cl                                                                                                                                                    |     cl = -cl;
    0x0040c19e mov esi, 1                                                                                                                                                |     esi = 1;
    0x0040c1a3 shl rsi, cl                                                                                                                                               |     rsi <<= cl;
    0x0040c1a6 test edi, edi                                                                                                                                             |     
                                                                                                                                                                         |     if (edi == 0) {
    0x0040c1a8 je 0x40c20e                                                                                                                                               |         goto label_0;
                                                                                                                                                                         |     }
    0x0040c1aa dec rsi                                                                                                                                                   |     rsi--;
    0x0040c1ad movabs rcx, 0xff00000000000000                                                                                                                            |     rcx = 0xff00000000000000;
    0x0040c1b7 or rcx, rsi                                                                                                                                               |     rcx |= rsi;
                                                                                                                                                                         |     do {
    0x0040c1ba xor esi, esi                                                                                                                                              |         esi = 0;
    0x0040c1bc test edx, edx                                                                                                                                             |         
    0x0040c1be mov qword [rbx + 0x1f0], rcx                                                                                                                              |         *((rbx + 0x1f0)) = rcx;
                                                                                                                                                                         |         if (edx != 0) {
    0x0040c1c5 cmovne rsi, r14                                                                                                                                           |             rsi = r14;
                                                                                                                                                                         |         }
    0x0040c1c9 mov qword [rbx + 0x1f8], rcx                                                                                                                              |         *((rbx + 0x1f8)) = rcx;
    0x0040c1d0 movups xmmword [rbx + 0x200], xmm0                                                                                                                        |         __asm ("movups xmmword [rbx + 0x200], xmm0");
    0x0040c1d7 mov qword [rbx + 0x210], rsi                                                                                                                              |         *((rbx + 0x210)) = rsi;
    0x0040c1de test rax, rax                                                                                                                                             |         
                                                                                                                                                                         |         if (rax == 0) {
    0x0040c1e1 jne 0x40c1f4                                                                                                                                              |             
    0x0040c1e3 mov rax, qword [rip + 0x261ae6]                                                                                                                           |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x0040c1ea test rax, rax                                                                                                                                             |             
                                                                                                                                                                         |             if (rax != 0) {
    0x0040c1ed jne 0x40c1f4                                                                                                                                              |                 goto label_1;
                                                                                                                                                                         |             }
    0x0040c1ef call 0x4171b0                                                                                                                                             |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                         |         }
                                                                                                                                                                         | label_1:
    0x0040c1f4 mov qword [rbx + 0x218], rax                                                                                                                              |         *((rbx + 0x218)) = rax;
    0x0040c1fb mov rdi, rbx                                                                                                                                              |         
    0x0040c1fe mov rsi, r14                                                                                                                                              |         
    0x0040c201 call 0x40bf00                                                                                                                                             |         BloombergLP::bdlma::SequentialPool::reserveCapacity(unsigned long) (rbx, r14);
    0x0040c206 add rsp, 8                                                                                                                                                |         
    0x0040c20a pop rbx                                                                                                                                                   |         
    0x0040c20b pop r14                                                                                                                                                   |         
    0x0040c20d ret                                                                                                                                                       |         return rax;
                                                                                                                                                                         | label_0:
    0x0040c20e mov rcx, 0xffffffffffffffff                                                                                                                               |         rcx = 0xffffffffffffffff;
    0x0040c215 jmp 0x40c1ba                                                                                                                                              |         
                                                                                                                                                                         |     } while (1);
                                                                                                                                                                         | }