; assembly                                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                     | /* bdlcc_objectpool.t/none @ 0x4114c0 */
                                                                                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlcc.ObjectPool__anonymous_namespace_::Case13Type__bsl::function_void__void__BloombergLP::bslma::Allocator____BloombergLP::bdlcc::ObjectPoolFunctors::Nil__anonymous_namespace_::Case13Type___::getObject__ ()      | int64_t method_BloombergLP::bdlcc_ObjectPool_anonymous_namespace_::Case13Type_bsl::function_void_void_BloombergLP::bslma::Allocator_BloombergLP::bdlcc::ObjectPoolFunctors::Nil_anonymous_namespace_::Case13Type_::getObject_ (int64_t arg1) {
                                                                                                                                                                                                                                                     |     int64_t var_4h;
                                                                                                                                                                                                                                                     |     uint32_t var_8h;
                                                                                                                                                                                                                                                     |     int64_t var_10h;
                                                                                                                                                                                                                                                     |     int64_t var_18h;
                                                                                                                                                                                                                                                     |     int64_t var_20h;
                                                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                                                     |     /* BloombergLP::bdlcc::ObjectPool<(anonymous namespace)::Case13Type, bsl::function<void (void*, BloombergLP::bslma::Allocator*)>, BloombergLP::bdlcc::ObjectPoolFunctors::Nil<(anonymous namespace)::Case13Type> >::getObject() */
    0x004114c0 push rbp                                                                                                                                                                                                                              |     
    0x004114c1 push r15                                                                                                                                                                                                                              |     
    0x004114c3 push r14                                                                                                                                                                                                                              |     
    0x004114c5 push r13                                                                                                                                                                                                                              |     
    0x004114c7 push r12                                                                                                                                                                                                                              |     
    0x004114c9 push rbx                                                                                                                                                                                                                              |     
    0x004114ca sub rsp, 0x28                                                                                                                                                                                                                         |     
    0x004114ce mov rbp, rdi                                                                                                                                                                                                                          |     
    0x004114d1 lea r14, [rdi + 0x90]                                                                                                                                                                                                                 |     r14 = rdi + 0x90;
    0x004114d8 lea r15, [rdi + 0x78]                                                                                                                                                                                                                 |     r15 = rdi + 0x78;
    0x004114dc lea r12, [rdi + 0x10]                                                                                                                                                                                                                 |     r12 = rdi + 0x10;
                                                                                                                                                                                                                                                     | label_1:
    0x004114e0 mov rbx, qword [rbp + 8]                                                                                                                                                                                                              |     rbx = *((rbp + 8));
    0x004114e4 test rbx, rbx                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                     |     if (rbx == 0) {
    0x004114e7 je 0x411552                                                                                                                                                                                                                           |         goto label_4;
                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                     | label_2:
    0x004114e9 mov eax, 2                                                                                                                                                                                                                            |     eax = 2;
    0x004114ee lock xadd dword [rbx + 8], eax                                                                                                                                                                                                        |     __asm ("lock xadd dword [rbx + 8], eax");
    0x004114f3 test eax, eax                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                     |     if (eax != 0) {
    0x004114f5 jne 0x411570                                                                                                                                                                                                                          |         goto label_5;
                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                     | label_3:
    0x004114f7 mov rax, qword [rbp + 8]                                                                                                                                                                                                              |     rax = *((rbp + 8));
    0x004114fb mov qword [rsp + 0x18], rax                                                                                                                                                                                                           |     *((rsp + 0x18)) = rax;
    0x00411500 mov rax, qword [rsp + 0x18]                                                                                                                                                                                                           |     rax = *((rsp + 0x18));
    0x00411505 cmp rax, rbx                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     if (rax != rbx) {
    0x00411508 jne 0x41153a                                                                                                                                                                                                                          |         goto label_0;
                                                                                                                                                                                                                                                     |     }
    0x0041150a mov rax, qword [rsp + 0x18]                                                                                                                                                                                                           |     rax = *((rsp + 0x18));
    0x0041150f mov rcx, qword [rax]                                                                                                                                                                                                                  |     rcx = *(rax);
    0x00411512 mov rax, rbx                                                                                                                                                                                                                          |     rax = rbx;
    0x00411515 lock cmpxchg qword [rbp + 8], rcx                                                                                                                                                                                                     |     __asm ("lock cmpxchg qword [rbp + 8], rcx");
    0x0041151b cmp rbx, rax                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     if (rbx == rax) {
    0x0041151e je 0x41169f                                                                                                                                                                                                                           |         goto label_6;
                                                                                                                                                                                                                                                     |     }
    0x00411524 jmp 0x41153a                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     while ((cl & 1) != 0) {
    0x00411526 mov edx, ecx                                                                                                                                                                                                                          |         edx = ecx;
    0x00411528 xor edx, 1                                                                                                                                                                                                                            |         edx ^= 1;
    0x0041152b mov eax, ecx                                                                                                                                                                                                                          |         eax = ecx;
    0x0041152d lock cmpxchg dword [rbx + 8], edx                                                                                                                                                                                                     |         __asm ("lock cmpxchg dword [rbx + 8], edx");
    0x00411532 cmp ecx, eax                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                     |         if (ecx == eax) {
    0x00411534 je 0x41169f                                                                                                                                                                                                                           |             goto label_6;
                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                     | label_0:
    0x0041153a mov ecx, dword [rbx + 8]                                                                                                                                                                                                              |         ecx = *((rbx + 8));
    0x0041153d test cl, 1                                                                                                                                                                                                                            |         
    0x00411540 jne 0x411526                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                     |     }
    0x00411542 lea edx, [rcx - 2]                                                                                                                                                                                                                    |     edx = rcx - 2;
    0x00411545 mov eax, ecx                                                                                                                                                                                                                          |     eax = ecx;
    0x00411547 lock cmpxchg dword [rbx + 8], edx                                                                                                                                                                                                     |     __asm ("lock cmpxchg dword [rbx + 8], edx");
    0x0041154c cmp ecx, eax                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     if (ecx != eax) {
    0x0041154e jne 0x41153a                                                                                                                                                                                                                          |         goto label_0;
                                                                                                                                                                                                                                                     |     }
    0x00411550 jmp 0x4114e0                                                                                                                                                                                                                          |     goto label_1;
                                                                                                                                                                                                                                                     | label_4:
    0x00411552 mov rdi, r14                                                                                                                                                                                                                          |     rdi = r14;
    0x00411555 call 0x4042b0                                                                                                                                                                                                                         |     pthread_mutex_lock ();
    0x0041155a mov rbx, qword [rbp + 8]                                                                                                                                                                                                              |     rbx = *((rbp + 8));
    0x0041155e test rbx, rbx                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                     |     if (rbx == 0) {
    0x00411561 je 0x411593                                                                                                                                                                                                                           |         goto label_7;
                                                                                                                                                                                                                                                     |     }
    0x00411563 mov rdi, r14                                                                                                                                                                                                                          |     rdi = r14;
    0x00411566 call 0x404380                                                                                                                                                                                                                         |     pthread_mutex_unlock ();
    0x0041156b jmp 0x4114e9                                                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                                                     | label_5:
    0x00411570 mov rax, qword [rbp + 8]                                                                                                                                                                                                              |     rax = *((rbp + 8));
    0x00411574 cmp rbx, rax                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     if (rbx != rax) {
    0x00411577 jne 0x4114f7                                                                                                                                                                                                                          |         goto label_3;
                                                                                                                                                                                                                                                     |     }
    0x0041157d mov rax, qword [rbp + 8]                                                                                                                                                                                                              |     rax = *((rbp + 8));
    0x00411581 cmp rbx, rax                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                     |     if (rbx != rax) {
    0x00411584 jne 0x4114f7                                                                                                                                                                                                                          |         goto label_3;
                                                                                                                                                                                                                                                     |     }
    0x0041158a mov rax, qword [rbp + 8]                                                                                                                                                                                                              |     rax = *((rbp + 8));
    0x0041158e jmp 0x4114f7                                                                                                                                                                                                                          |     goto label_3;
                                                                                                                                                                                                                                                     | label_7:
    0x00411593 mov eax, dword [rbp + 0x64]                                                                                                                                                                                                           |     eax = *((rbp + 0x64));
    0x00411596 mov ebx, eax                                                                                                                                                                                                                          |     ebx = *((rbp + 0x64));
    0x00411598 neg ebx                                                                                                                                                                                                                               |     ebx = -ebx;
    0x0041159a mov dword [rsp + 8], eax                                                                                                                                                                                                              |     *((rsp + 8)) = eax;
                                                                                                                                                                                                                                                     |     if (rbx < rax) {
    0x0041159e cmovl ebx, eax                                                                                                                                                                                                                        |         ebx = eax;
                                                                                                                                                                                                                                                     |     }
    0x004115a1 imul eax, ebx, 0xb0                                                                                                                                                                                                                   |     eax = ebx * 0xb0;
    0x004115a7 add eax, 0x10                                                                                                                                                                                                                         |     eax += 0x10;
    0x004115aa movsxd rsi, eax                                                                                                                                                                                                                       |     rsi = (int64_t) eax;
    0x004115ad mov rdi, r15                                                                                                                                                                                                                          |     
    0x004115b0 call 0x416a30                                                                                                                                                                                                                         |     BloombergLP::bdlma::InfrequentDeleteBlockList::allocate(unsigned long) (r15, rsi);
    0x004115b5 mov rcx, qword [rbp + 0x70]                                                                                                                                                                                                           |     rcx = *((rbp + 0x70));
    0x004115b9 mov qword [rax], rcx                                                                                                                                                                                                                  |     *(rax) = rcx;
    0x004115bc mov dword [rsp + 4], ebx                                                                                                                                                                                                              |     *((rsp + 4)) = ebx;
    0x004115c0 mov dword [rax + 8], ebx                                                                                                                                                                                                              |     *((rax + 8)) = ebx;
    0x004115c3 lea rdx, [rax + 0x10]                                                                                                                                                                                                                 |     rdx = rax + 0x10;
    0x004115c7 mov r13, rdx                                                                                                                                                                                                                          |     r13 = rdx;
    0x004115ca cmp dword [rsp + 8], 0                                                                                                                                                                                                                |     
                                                                                                                                                                                                                                                     |     if (*((rsp + 8)) == 0) {
    0x004115cf je 0x411647                                                                                                                                                                                                                           |         goto label_8;
                                                                                                                                                                                                                                                     |     }
    0x004115d1 mov qword [rsp + 0x20], rdx                                                                                                                                                                                                           |     *((rsp + 0x20)) = rdx;
    0x004115d6 mov ecx, dword [rsp + 4]                                                                                                                                                                                                              |     ecx = *((rsp + 4));
    0x004115da neg ecx                                                                                                                                                                                                                               |     ecx = -ecx;
    0x004115dc mov qword [rsp + 8], rcx                                                                                                                                                                                                              |     *((rsp + 8)) = rcx;
    0x004115e1 mov ebx, 1                                                                                                                                                                                                                            |     ebx = 1;
    0x004115e6 mov qword [rsp + 0x10], rax                                                                                                                                                                                                           |     *((rsp + 0x10)) = rax;
    0x004115eb mov r13, rax                                                                                                                                                                                                                          |     r13 = rax;
                                                                                                                                                                                                                                                     |     do {
    0x004115ee lea rax, [r13 + 0xc0]                                                                                                                                                                                                                 |         rax = r13 + 0xc0;
    0x004115f5 mov qword [r13 + 0x10], rax                                                                                                                                                                                                           |         *((r13 + 0x10)) = rax;
    0x004115f9 mov dword [r13 + 0x18], 0                                                                                                                                                                                                             |         *((r13 + 0x18)) = 0;
    0x00411601 mov rax, qword [rbp + 0x50]                                                                                                                                                                                                           |         rax = *((rbp + 0x50));
    0x00411605 test rax, rax                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                     |         if (rax == 0) {
    0x00411608 je 0x4116c0                                                                                                                                                                                                                           |             goto label_9;
                                                                                                                                                                                                                                                     |         }
    0x0041160e mov rdx, qword [rbp + 0x88]                                                                                                                                                                                                           |         rdx = *((rbp + 0x88));
    0x00411615 lea rsi, [r13 + 0x20]                                                                                                                                                                                                                 |         rsi = r13 + 0x20;
    0x00411619 mov rdi, r12                                                                                                                                                                                                                          |         rdi = r12;
    0x0041161c call rax                                                                                                                                                                                                                              |         void (*rax)() ();
    0x0041161e mov rax, qword [rsp + 8]                                                                                                                                                                                                              |         rax = *((rsp + 8));
    0x00411623 lea eax, [rax + rbx + 1]                                                                                                                                                                                                              |         eax = rax + rbx + 1;
    0x00411627 mov ecx, ebx                                                                                                                                                                                                                          |         ecx = ebx;
    0x00411629 inc ecx                                                                                                                                                                                                                               |         ecx++;
    0x0041162b add r13, 0xb0                                                                                                                                                                                                                         |         r13 += 0xb0;
    0x00411632 mov ebx, ecx                                                                                                                                                                                                                          |         ebx = ecx;
    0x00411634 cmp eax, 1                                                                                                                                                                                                                            |         
    0x00411637 jne 0x4115ee                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                     |     } while (eax != 1);
    0x00411639 add r13, 0x10                                                                                                                                                                                                                         |     r13 += 0x10;
    0x0041163d mov rax, qword [rsp + 0x10]                                                                                                                                                                                                           |     rax = *((rsp + 0x10));
    0x00411642 mov rdx, qword [rsp + 0x20]                                                                                                                                                                                                           |     rdx = *((rsp + 0x20));
                                                                                                                                                                                                                                                     | label_8:
    0x00411647 mov dword [r13 - 0xa8], 0                                                                                                                                                                                                             |     *((r13 - 0xa8)) = 0;
    0x00411652 mov qword [rbp + 0x70], rax                                                                                                                                                                                                           |     *((rbp + 0x70)) = rax;
                                                                                                                                                                                                                                                     |     do {
    0x00411656 mov rcx, qword [rbp + 8]                                                                                                                                                                                                              |         rcx = *((rbp + 8));
    0x0041165a mov qword [r13 - 0xb0], rcx                                                                                                                                                                                                           |         *((r13 - 0xb0)) = rcx;
    0x00411661 mov rax, rcx                                                                                                                                                                                                                          |         rax = rcx;
    0x00411664 lock cmpxchg qword [rbp + 8], rdx                                                                                                                                                                                                     |         __asm ("lock cmpxchg qword [rbp + 8], rdx");
    0x0041166a cmp rcx, rax                                                                                                                                                                                                                          |         
    0x0041166d jne 0x411656                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                     |     } while (rcx != rax);
    0x0041166f mov eax, dword [rsp + 4]                                                                                                                                                                                                              |     eax = *((rsp + 4));
    0x00411673 lock add dword [rbp + 0x6c], eax                                                                                                                                                                                                      |     *((rbp + 0x6c)) += eax;
    0x00411677 lock add dword [rbp + 0x68], eax                                                                                                                                                                                                      |     *((rbp + 0x68)) += eax;
    0x0041167b mov eax, dword [rbp + 0x64]                                                                                                                                                                                                           |     eax = *((rbp + 0x64));
    0x0041167e test eax, eax                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                     |     if (eax < 0) {
    0x00411680 jns 0x411692                                                                                                                                                                                                                          |         
    0x00411682 mov ecx, eax                                                                                                                                                                                                                          |         ecx = eax;
    0x00411684 neg ecx                                                                                                                                                                                                                               |         ecx = -ecx;
    0x00411686 lea edx, [rax + rax]                                                                                                                                                                                                                  |         edx = rax + rax;
    0x00411689 cmp eax, 0xffffffe0                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                                     |         if (eax <= 0xffffffe0) {
    0x0041168c cmovle edx, ecx                                                                                                                                                                                                                       |             edx = ecx;
                                                                                                                                                                                                                                                     |         }
    0x0041168f mov dword [rbp + 0x64], edx                                                                                                                                                                                                           |         *((rbp + 0x64)) = edx;
                                                                                                                                                                                                                                                     |     }
    0x00411692 mov rdi, r14                                                                                                                                                                                                                          |     rdi = r14;
    0x00411695 call 0x404380                                                                                                                                                                                                                         |     pthread_mutex_unlock ();
    0x0041169a jmp 0x4114e0                                                                                                                                                                                                                          |     goto label_1;
                                                                                                                                                                                                                                                     | label_6:
    0x0041169f mov qword [rbx], 0                                                                                                                                                                                                                    |     *(rbx) = 0;
    0x004116a6 lock dec dword [rbp + 0x68]                                                                                                                                                                                                           |     *((rbp + 0x68))--;
    0x004116aa add rbx, 0x10                                                                                                                                                                                                                         |     rbx += 0x10;
    0x004116ae mov rax, rbx                                                                                                                                                                                                                          |     rax = rbx;
    0x004116b1 add rsp, 0x28                                                                                                                                                                                                                         |     
    0x004116b5 pop rbx                                                                                                                                                                                                                               |     
    0x004116b6 pop r12                                                                                                                                                                                                                               |     
    0x004116b8 pop r13                                                                                                                                                                                                                               |     
    0x004116ba pop r14                                                                                                                                                                                                                               |     
    0x004116bc pop r15                                                                                                                                                                                                                               |     
    0x004116be pop rbp                                                                                                                                                                                                                               |     
    0x004116bf ret                                                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                                                     | label_9:
    0x004116c0 mov edi, 8                                                                                                                                                                                                                            |     edi = 8;
    0x004116c5 call 0x403e40                                                                                                                                                                                                                         |     cxa_allocate_exception ();
    0x004116ca mov qword [rax], 0x4417f0                                                                                                                                                                                                             |     *(rax) = fcn.004041c0;
    0x004116d1 mov esi, 0x4417c8                                                                                                                                                                                                                     |     
    0x004116d6 mov edx, 0x4041c0                                                                                                                                                                                                                     |     
    0x004116db mov rdi, rax                                                                                                                                                                                                                          |     
    0x004116de call 0x403f10                                                                                                                                                                                                                         |     return cxa_throw (rax, obj.typeinfo_for_std::__1::bad_function_call, fcn.004041c0);
                                                                                                                                                                                                                                                     | }