; assembly                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                             | /* bdlcc_stripedunorderedmap.t/assume @ 0x5849a0 */
                                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bslmt::ThroughputBenchmark.execute_BloombergLP::bslmt::ThroughputBenchmarkResult__int__int__bsl::function_void__bool___const__bsl::function_void__bool___const__bsl::function_void__bool___const_ ()         | int64_t method_BloombergLP::bslmt::ThroughputBenchmark_execute_BloombergLP::bslmt::ThroughputBenchmarkResult_int_int_bsl::function_void_bool_const_bsl::function_void_bool_const_bsl::function_void_bool_const_ (int64_t arg_210h, uint32_t arg6, int64_t arg5, long arg4, long arg3, int64_t arg2, long arg1) {
                                                                                                                                                                                                                                             |     int64_t var_8h;
                                                                                                                                                                                                                                             |     uint32_t var_10h;
                                                                                                                                                                                                                                             |     signed int64_t var_18h;
                                                                                                                                                                                                                                             |     uint32_t var_20h;
                                                                                                                                                                                                                                             |     long var_28h;
                                                                                                                                                                                                                                             |     int64_t var_30h;
                                                                                                                                                                                                                                             |     int64_t var_38h;
                                                                                                                                                                                                                                             |     int64_t var_48h;
                                                                                                                                                                                                                                             |     int64_t var_50h;
                                                                                                                                                                                                                                             |     int64_t var_58h;
                                                                                                                                                                                                                                             |     int64_t var_64h;
                                                                                                                                                                                                                                             |     int64_t var_68h;
                                                                                                                                                                                                                                             |     int64_t var_6ch;
                                                                                                                                                                                                                                             |     signed int64_t var_70h;
                                                                                                                                                                                                                                             |     uint32_t var_78h;
                                                                                                                                                                                                                                             |     size_t n;
                                                                                                                                                                                                                                             |     int64_t var_88h;
                                                                                                                                                                                                                                             |     uint32_t var_90h;
                                                                                                                                                                                                                                             |     signed int64_t var_98h;
                                                                                                                                                                                                                                             |     int64_t var_a0h;
                                                                                                                                                                                                                                             |     int64_t var_a8h;
                                                                                                                                                                                                                                             |     int64_t var_c0h;
                                                                                                                                                                                                                                             |     uint32_t var_c8h;
                                                                                                                                                                                                                                             |     int64_t var_d0h;
                                                                                                                                                                                                                                             |     signed int64_t var_d8h;
                                                                                                                                                                                                                                             |     int64_t var_e0h;
                                                                                                                                                                                                                                             |     int64_t var_e8h;
                                                                                                                                                                                                                                             |     int64_t var_f0h;
                                                                                                                                                                                                                                             |     int64_t var_120h;
                                                                                                                                                                                                                                             |     int64_t var_128h;
                                                                                                                                                                                                                                             |     int64_t var_140h;
                                                                                                                                                                                                                                             |     int64_t var_158h;
                                                                                                                                                                                                                                             |     int64_t var_160h;
                                                                                                                                                                                                                                             |     int64_t var_188h;
                                                                                                                                                                                                                                             |     int64_t var_1c0h;
                                                                                                                                                                                                                                             |     r9 = arg6;
                                                                                                                                                                                                                                             |     r8 = arg5;
                                                                                                                                                                                                                                             |     rcx = arg4;
                                                                                                                                                                                                                                             |     rdx = arg3;
                                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                                             |     /* BloombergLP::bslmt::ThroughputBenchmark::execute(BloombergLP::bslmt::ThroughputBenchmarkResult*, int, int, bsl::function<void (bool)> const&, bsl::function<void (bool)> const&, bsl::function<void (bool)> const&) */
    0x005849a0 push rbp                                                                                                                                                                                                                      |     
    0x005849a1 push r15                                                                                                                                                                                                                      |     
    0x005849a3 push r14                                                                                                                                                                                                                      |     
    0x005849a5 push r13                                                                                                                                                                                                                      |     
    0x005849a7 push r12                                                                                                                                                                                                                      |     
    0x005849a9 push rbx                                                                                                                                                                                                                      |     
    0x005849aa sub rsp, 0x1d8                                                                                                                                                                                                                |     
    0x005849b1 mov qword [rsp + 0x90], r9                                                                                                                                                                                                    |     *((rsp + 0x90)) = r9;
    0x005849b9 mov r12, r8                                                                                                                                                                                                                   |     r12 = r8;
    0x005849bc mov r15d, ecx                                                                                                                                                                                                                 |     r15d = ecx;
    0x005849bf mov dword [rsp + 0x28], edx                                                                                                                                                                                                   |     *((rsp + 0x28)) = edx;
    0x005849c3 mov qword [rsp + 0xa0], rsi                                                                                                                                                                                                   |     *((rsp + 0xa0)) = rsi;
    0x005849cb mov r13, rdi                                                                                                                                                                                                                  |     r13 = rdi;
    0x005849ce mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x005849d1 mov r14, qword [rdi + 8]                                                                                                                                                                                                      |     r14 = *((rdi + 8));
    0x005849d5 mov rcx, r14                                                                                                                                                                                                                  |     rcx = *((rdi + 8));
    0x005849d8 sub rcx, rax                                                                                                                                                                                                                  |     rcx -= rax;
    0x005849db shr rcx, 8                                                                                                                                                                                                                    |     rcx >>= 8;
    0x005849df sub r14, rax                                                                                                                                                                                                                  |     r14 -= rax;
    0x005849e2 mov qword [rsp + 0x18], rcx                                                                                                                                                                                                   |     *((rsp + 0x18)) = rcx;
                                                                                                                                                                                                                                             |     if (r14 != 0) {
    0x005849e7 je 0x584a11                                                                                                                                                                                                                   |         
    0x005849e9 mov ebx, dword [rax + 0x50]                                                                                                                                                                                                   |         ebx = *((rax + 0x50));
    0x005849ec cmp ecx, 2                                                                                                                                                                                                                    |         
                                                                                                                                                                                                                                             |         if (ecx < 2) {
    0x005849ef jl 0x584a7f                                                                                                                                                                                                                   |             goto label_5;
                                                                                                                                                                                                                                             |         }
    0x005849f5 mov edx, ecx                                                                                                                                                                                                                  |         edx = ecx;
    0x005849f7 lea rsi, [rdx - 1]                                                                                                                                                                                                            |         rsi = rdx - 1;
    0x005849fb add rdx, 0xfffffffffffffffe                                                                                                                                                                                                   |         rdx += 0xfffffffffffffffe;
    0x005849ff mov ecx, esi                                                                                                                                                                                                                  |         ecx = esi;
    0x00584a01 and ecx, 3                                                                                                                                                                                                                    |         ecx &= 3;
    0x00584a04 cmp rdx, 3                                                                                                                                                                                                                    |         
                                                                                                                                                                                                                                             |         if (rdx >= 3) {
    0x00584a08 jae 0x584a15                                                                                                                                                                                                                  |             goto label_6;
                                                                                                                                                                                                                                             |         }
    0x00584a0a mov edx, 1                                                                                                                                                                                                                    |         edx = 1;
    0x00584a0f jmp 0x584a5a                                                                                                                                                                                                                  |         goto label_7;
                                                                                                                                                                                                                                             |     }
    0x00584a11 xor ebx, ebx                                                                                                                                                                                                                  |     ebx = 0;
    0x00584a13 jmp 0x584a7f                                                                                                                                                                                                                  |     goto label_5;
                                                                                                                                                                                                                                             | label_6:
    0x00584a15 lea rdi, [rax + 0x450]                                                                                                                                                                                                        |     rdi = rax + 0x450;
    0x00584a1c and rsi, 0xfffffffffffffffc                                                                                                                                                                                                   |     rsi &= 0xfffffffffffffffc;
    0x00584a20 neg rsi                                                                                                                                                                                                                       |     rsi = -rsi;
    0x00584a23 mov edx, 1                                                                                                                                                                                                                    |     edx = 1;
    0x00584a28 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             |     do {
    0x00584a30 add ebx, dword [rdi - 0x300]                                                                                                                                                                                                  |         ebx += *((rdi - 0x300));
    0x00584a36 add ebx, dword [rdi - 0x200]                                                                                                                                                                                                  |         ebx += *((rdi - 0x200));
    0x00584a3c add ebx, dword [rdi - 0x100]                                                                                                                                                                                                  |         ebx += *((rdi - 0x100));
    0x00584a42 add ebx, dword [rdi]                                                                                                                                                                                                          |         ebx += *(rdi);
    0x00584a44 add rdi, 0x400                                                                                                                                                                                                                |         rdi += 0x400;
    0x00584a4b lea rbp, [rsi + rdx + 4]                                                                                                                                                                                                      |         rbp = rsi + rdx + 4;
    0x00584a50 add rdx, 4                                                                                                                                                                                                                    |         rdx += 4;
    0x00584a54 cmp rbp, 1                                                                                                                                                                                                                    |         
    0x00584a58 jne 0x584a30                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rbp != 1);
                                                                                                                                                                                                                                             | label_7:
    0x00584a5a test rcx, rcx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rcx == 0) {
    0x00584a5d je 0x584a7f                                                                                                                                                                                                                   |         goto label_5;
                                                                                                                                                                                                                                             |     }
    0x00584a5f shl rdx, 8                                                                                                                                                                                                                    |     rdx <<= 8;
    0x00584a63 lea rax, [rax + rdx + 0x50]                                                                                                                                                                                                   |     rax = rax + rdx + 0x50;
    0x00584a68 shl rcx, 8                                                                                                                                                                                                                    |     rcx <<= 8;
    0x00584a6c xor edx, edx                                                                                                                                                                                                                  |     edx = 0;
    0x00584a6e nop                                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                             |     do {
    0x00584a70 add ebx, dword [rax + rdx]                                                                                                                                                                                                    |         ebx += *((rax + rdx));
    0x00584a73 add rdx, 0x100                                                                                                                                                                                                                |         rdx += 0x100;
    0x00584a7a cmp rcx, rdx                                                                                                                                                                                                                  |         
    0x00584a7d jne 0x584a70                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rcx != rdx);
                                                                                                                                                                                                                                             | label_5:
    0x00584a7f mov qword [rsp + 0x70], rbx                                                                                                                                                                                                   |     *((rsp + 0x70)) = rbx;
    0x00584a84 shr r14, 8                                                                                                                                                                                                                    |     r14 >>= 8;
    0x00584a88 mov rax, qword [rip + 0x29ea51]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584a8f test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584a92 jne 0x584a99                                                                                                                                                                                                                  |         
    0x00584a94 call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x00584a99 movsxd rbp, r14d                                                                                                                                                                                                              |     rbp = (int64_t) r14d;
    0x00584a9c test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584a9f jne 0x584ab2                                                                                                                                                                                                                  |         
    0x00584aa1 mov rax, qword [rip + 0x29ea38]                                                                                                                                                                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584aa8 test rax, rax                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                             |         if (rax != 0) {
    0x00584aab jne 0x584ab2                                                                                                                                                                                                                  |             goto label_8;
                                                                                                                                                                                                                                             |         }
    0x00584aad call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_8:
    0x00584ab2 mov qword [rsp + 0x160], rax                                                                                                                                                                                                  |     *((rsp + 0x160)) = rax;
    0x00584aba lea rdi, [rsp + 0xa8]                                                                                                                                                                                                         |     
    0x00584ac2 lea rdx, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x00584aca mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584acd call 0x59dcb0                                                                                                                                                                                                                 |     bsl::vector<int,bsl::allocator<int>>::vector(unsigned long,bsl::allocator<int>const&) (rsp + 0xa8, rbp, rsp + 0x160);
    0x00584ad2 cmp dword [rsp + 0x18], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                             |     if (*((rsp + 0x18)) <= 0) {
    0x00584ad7 jle 0x584b5a                                                                                                                                                                                                                  |         goto label_9;
                                                                                                                                                                                                                                             |     }
    0x00584add mov rax, qword [rsp + 0x18]                                                                                                                                                                                                   |     rax = *((rsp + 0x18));
    0x00584ae2 mov edx, eax                                                                                                                                                                                                                  |     edx = eax;
    0x00584ae4 and eax, 1                                                                                                                                                                                                                    |     eax &= 1;
    0x00584ae7 cmp rdx, 1                                                                                                                                                                                                                    |     
                                                                                                                                                                                                                                             |     if (rdx == 1) {
    0x00584aeb jne 0x584af1                                                                                                                                                                                                                  |         
    0x00584aed xor ecx, ecx                                                                                                                                                                                                                  |         ecx = 0;
    0x00584aef jmp 0x584b3b                                                                                                                                                                                                                  |         goto label_10;
                                                                                                                                                                                                                                             |     }
    0x00584af1 sub rdx, rax                                                                                                                                                                                                                  |     rdx -= rax;
    0x00584af4 xor esi, esi                                                                                                                                                                                                                  |     esi = 0;
    0x00584af6 xor ecx, ecx                                                                                                                                                                                                                  |     ecx = 0;
    0x00584af8 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             |     do {
    0x00584b00 mov rdi, qword [r13]                                                                                                                                                                                                          |         rdi = *(r13);
    0x00584b04 mov edi, dword [rdi + rsi + 0x50]                                                                                                                                                                                             |         edi = *((rdi + rsi + 0x50));
    0x00584b08 mov rbp, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rbp = *((rsp + 0xa8));
    0x00584b10 mov dword [rbp + rcx*4], edi                                                                                                                                                                                                  |         *((rbp + rcx*4)) = edi;
    0x00584b14 mov rdi, qword [r13]                                                                                                                                                                                                          |         rdi = *(r13);
    0x00584b18 mov edi, dword [rdi + rsi + 0x150]                                                                                                                                                                                            |         edi = *((rdi + rsi + 0x150));
    0x00584b1f mov rbp, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rbp = *((rsp + 0xa8));
    0x00584b27 mov dword [rbp + rcx*4 + 4], edi                                                                                                                                                                                              |         *((rbp + rcx*4 + 4)) = edi;
    0x00584b2b add rcx, 2                                                                                                                                                                                                                    |         rcx += 2;
    0x00584b2f add rsi, 0x200                                                                                                                                                                                                                |         rsi += 0x200;
    0x00584b36 cmp rdx, rcx                                                                                                                                                                                                                  |         
    0x00584b39 jne 0x584b00                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rdx != rcx);
                                                                                                                                                                                                                                             | label_10:
    0x00584b3b test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00584b3e je 0x584b5a                                                                                                                                                                                                                   |         
    0x00584b40 mov rax, qword [r13]                                                                                                                                                                                                          |         rax = *(r13);
    0x00584b44 mov rdx, rcx                                                                                                                                                                                                                  |         rdx = rcx;
    0x00584b47 shl rdx, 8                                                                                                                                                                                                                    |         rdx <<= 8;
    0x00584b4b mov eax, dword [rax + rdx + 0x50]                                                                                                                                                                                             |         eax = *((rax + rdx + 0x50));
    0x00584b4f mov rdx, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rdx = *((rsp + 0xa8));
    0x00584b57 mov dword [rdx + rcx*4], eax                                                                                                                                                                                                  |         *((rdx + rcx*4)) = eax;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_9:
    0x00584b5a lea rdx, [rsp + 0xa8]                                                                                                                                                                                                         |     
    0x00584b62 mov rdi, qword [rsp + 0xa0]                                                                                                                                                                                                   |     
    0x00584b6a mov esi, r15d                                                                                                                                                                                                                 |     
    0x00584b6d call 0x586190                                                                                                                                                                                                                 |     BloombergLP::bslmt::ThroughputBenchmarkResult::initialize(int,bsl::vector<int,bsl::allocator<int>>const&) (*((rsp + 0xa0)), r15d, rsp + 0xa8);
    0x00584b72 lea eax, [r15 - 1]                                                                                                                                                                                                            |     eax = r15 - 1;
    0x00584b76 mov qword [rsp + 0x78], rax                                                                                                                                                                                                   |     *((rsp + 0x78)) = rax;
    0x00584b7b lea rbx, [rsp + 0x188]                                                                                                                                                                                                        |     rbx = rsp + 0x188;
    0x00584b83 mov rax, qword [rsp + 0x70]                                                                                                                                                                                                   |     rax = *((rsp + 0x70));
    0x00584b88 lea ecx, [rax + 1]                                                                                                                                                                                                            |     ecx = rax + 1;
    0x00584b8b mov dword [rsp + 0x68], ecx                                                                                                                                                                                                   |     *((rsp + 0x68)) = ecx;
    0x00584b8f cdqe                                                                                                                                                                                                                          |     rax = (int64_t) eax;
    0x00584b91 mov qword [rsp + 0xd8], rax                                                                                                                                                                                                   |     *((rsp + 0xd8)) = rax;
    0x00584b99 shl rax, 4                                                                                                                                                                                                                    |     rax <<= 4;
    0x00584b9d mov qword [rsp + 0x80], rax                                                                                                                                                                                                   |     *((rsp + 0x80)) = rax;
    0x00584ba5 imul eax, dword [rsp + 0x28], 0x3e8                                                                                                                                                                                           |     eax = *((rsp + 0x28)) * 0x3e8;
    0x00584bad mov dword [rsp + 0x64], eax                                                                                                                                                                                                   |     *((rsp + 0x64)) = eax;
    0x00584bb1 mov eax, r15d                                                                                                                                                                                                                 |     eax = r15d;
    0x00584bb4 mov qword [rsp + 0xc8], rax                                                                                                                                                                                                   |     *((rsp + 0xc8)) = rax;
    0x00584bbc mov eax, dword [rsp + 0x18]                                                                                                                                                                                                   |     eax = *((rsp + 0x18));
    0x00584bc0 mov qword [rsp + 0x98], rax                                                                                                                                                                                                   |     *((rsp + 0x98)) = rax;
    0x00584bc8 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584bca mov qword [rsp + 0x10], rax                                                                                                                                                                                                   |     *((rsp + 0x10)) = rax;
    0x00584bcf mov qword [rsp + 0xd0], r12                                                                                                                                                                                                   |     *((rsp + 0xd0)) = r12;
    0x00584bd7 mov qword [rsp + 0x50], r13                                                                                                                                                                                                   |     *((rsp + 0x50)) = r13;
    0x00584bdc jmp 0x584c13                                                                                                                                                                                                                  |     goto label_11;
                                                                                                                                                                                                                                             | label_4:
    0x00584be0 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x00584be8 call 0x5ae2a0                                                                                                                                                                                                                 |     BloombergLP::bslmt::Barrier::~Barrier() (rsp + 0x160);
    0x00584bed mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |     rcx = *((rsp + 0x10));
    0x00584bf2 inc rcx                                                                                                                                                                                                                       |     rcx++;
    0x00584bf5 mov rax, rcx                                                                                                                                                                                                                  |     rax = rcx;
    0x00584bf8 mov qword [rsp + 0x10], rcx                                                                                                                                                                                                   |     *((rsp + 0x10)) = rcx;
    0x00584bfd cmp rcx, qword [rsp + 0xc8]                                                                                                                                                                                                   |     
    0x00584c05 lea rbx, [rsp + 0x188]                                                                                                                                                                                                        |     rbx = rsp + 0x188;
                                                                                                                                                                                                                                             |     if (rcx == *((rsp + 0xc8))) {
    0x00584c0d je 0x585250                                                                                                                                                                                                                   |         goto label_12;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_11:
    0x00584c13 mov rax, qword [r12 + 0x40]                                                                                                                                                                                                   |     rax = *((r12 + 0x40));
    0x00584c18 test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00584c1b je 0x584c2e                                                                                                                                                                                                                   |         
    0x00584c1d xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00584c1f cmp qword [rsp + 0x10], 0                                                                                                                                                                                                     |         
    0x00584c25 sete sil                                                                                                                                                                                                                      |         sil = (*((rsp + 0x10)) == 0) ? 1 : 0;
    0x00584c29 mov rdi, r12                                                                                                                                                                                                                  |         rdi = r12;
    0x00584c2c call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x00584c2e mov dword [r13 + 0x20], 0                                                                                                                                                                                                     |     *((r13 + 0x20)) = 0;
    0x00584c36 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     rdi = rsp + 0x160;
    0x00584c3e xor esi, esi                                                                                                                                                                                                                  |     esi = 0;
    0x00584c40 call 0x405060                                                                                                                                                                                                                 |     pthread_mutex_init ();
    0x00584c45 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584c48 xor esi, esi                                                                                                                                                                                                                  |     
    0x00584c4a call 0x5ae470                                                                                                                                                                                                                 |     BloombergLP::bslmt::ConditionImpl<BloombergLP::bslmt::Platform::PosixThreads>::ConditionImpl(BloombergLP::bsls::SystemClockType::Enum) (rbx, 0);
    0x00584c4f mov eax, dword [rsp + 0x68]                                                                                                                                                                                                   |     eax = *((rsp + 0x68));
    0x00584c53 mov dword [rsp + 0x1c0], eax                                                                                                                                                                                                  |     *((rsp + 0x1c0)) = eax;
    0x00584c5a xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584c5e movupd xmmword [rbx + 0x3c], xmm0                                                                                                                                                                                             |     __asm ("movupd xmmword [rbx + 0x3c], xmm0");
    0x00584c63 mov rax, qword [rip + 0x29e876]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584c6a test rax, rax                                                                                                                                                                                                                 |     
    0x00584c6d mov r14, qword [rsp + 0x18]                                                                                                                                                                                                   |     r14 = *((rsp + 0x18));
    0x00584c72 mov rbp, qword [rsp + 0x70]                                                                                                                                                                                                   |     rbp = *((rsp + 0x70));
    0x00584c77 mov rbx, qword [rsp + 0xd8]                                                                                                                                                                                                   |     rbx = *((rsp + 0xd8));
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584c7f jne 0x584c86                                                                                                                                                                                                                  |         
    0x00584c81 call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x00584c86 mov qword [rsp + 0xf0], rax                                                                                                                                                                                                   |     *((rsp + 0xf0)) = rax;
    0x00584c8e lea rdi, [rsp + 0x140]                                                                                                                                                                                                        |     
    0x00584c96 mov rsi, rbx                                                                                                                                                                                                                  |     
    0x00584c99 lea rdx, [rsp + 0xf0]                                                                                                                                                                                                         |     
    0x00584ca1 call 0x5a17b0                                                                                                                                                                                                                 |     bsl::vector<unsigned long,bsl::allocator<unsigned long>>::vector(unsigned long,bsl::allocator<unsigned long>const&) (rsp + 0x140, rbx, rsp + 0xf0);
    0x00584ca6 mov rax, qword [rip + 0x29e833]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584cad test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584cb0 jne 0x584cb7                                                                                                                                                                                                                  |         
    0x00584cb2 call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x00584cb7 mov qword [rsp + 0xf0], rax                                                                                                                                                                                                   |     *((rsp + 0xf0)) = rax;
    0x00584cbf lea rdi, [rsp + 0x30]                                                                                                                                                                                                         |     
    0x00584cc4 mov rsi, rbx                                                                                                                                                                                                                  |     
    0x00584cc7 lea rdx, [rsp + 0xf0]                                                                                                                                                                                                         |     
    0x00584ccf call 0x5858b0                                                                                                                                                                                                                 |     bsl::vector<BloombergLP::bslmt::ThroughputBenchmark_WorkData,bsl::allocator<BloombergLP::bslmt::ThroughputBenchmark_WorkData>>::vector(unsigned long,bsl::allocator<BloombergLP::bslmt::ThroughputBenchmark_WorkData>const&) (rsp + 0x30, rbx, rsp + 0xf0);
    0x00584cd4 mov rbx, qword [rip + 0x29e805]                                                                                                                                                                                               |     rbx = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584cdb test rbx, rbx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbx == 0) {
    0x00584cde jne 0x584ce8                                                                                                                                                                                                                  |         
    0x00584ce0 call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00584ce5 mov rbx, rax                                                                                                                                                                                                                  |         rbx = rax;
                                                                                                                                                                                                                                             |     }
    0x00584ce8 test ebp, ebp                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (ebp < 0) {
    0x00584cea js 0x58527d                                                                                                                                                                                                                   |         goto label_13;
                                                                                                                                                                                                                                             |     }
    0x00584cf0 mov qword [rsp + 0x88], rbx                                                                                                                                                                                                   |     *((rsp + 0x88)) = rbx;
                                                                                                                                                                                                                                             |     if (ebp != 0) {
    0x00584cf8 je 0x584d40                                                                                                                                                                                                                   |         
    0x00584cfa mov rax, qword [rbx]                                                                                                                                                                                                          |         rax = *(rbx);
    0x00584cfd mov rdi, rbx                                                                                                                                                                                                                  |         rdi = rbx;
    0x00584d00 mov rsi, qword [rsp + 0x80]                                                                                                                                                                                                   |         rsi = *((rsp + 0x80));
    0x00584d08 call qword [rax + 0x10]                                                                                                                                                                                                       |         rax = uint64_t (*rax + 0x10)() ();
    0x00584d0b mov rbp, rax                                                                                                                                                                                                                  |         
    0x00584d0e mov rdi, rax                                                                                                                                                                                                                  |         
    0x00584d11 xor esi, esi                                                                                                                                                                                                                  |         
    0x00584d13 mov rbx, qword [rsp + 0x80]                                                                                                                                                                                                   |         rbx = *((rsp + 0x80));
    0x00584d1b mov rdx, rbx                                                                                                                                                                                                                  |         
    0x00584d1e call 0x404e00                                                                                                                                                                                                                 |         memset (rax, 0, *((rsp + 0x80)));
    0x00584d23 mov rax, rbp                                                                                                                                                                                                                  |         rax = rbp;
    0x00584d26 mov qword [rsp + 8], rbp                                                                                                                                                                                                      |         *((rsp + 8)) = rbp;
    0x00584d2b add rbp, rbx                                                                                                                                                                                                                  |         rbp += rbx;
    0x00584d2e mov qword [rsp + 0x20], rbp                                                                                                                                                                                                   |         *((rsp + 0x20)) = rbp;
    0x00584d33 jmp 0x584d4e                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } else {
    0x00584d40 xor eax, eax                                                                                                                                                                                                                  |         eax = 0;
    0x00584d42 mov qword [rsp + 0x20], rax                                                                                                                                                                                                   |         *((rsp + 0x20)) = rax;
    0x00584d47 xor eax, eax                                                                                                                                                                                                                  |         eax = 0;
    0x00584d49 mov qword [rsp + 8], rax                                                                                                                                                                                                      |         *((rsp + 8)) = rax;
                                                                                                                                                                                                                                             |     }
    0x00584d4e test r14d, r14d                                                                                                                                                                                                               |     
    0x00584d51 lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x00584d59 lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
                                                                                                                                                                                                                                             |     if (r14d <= 0) {
    0x00584d61 jle 0x585030                                                                                                                                                                                                                  |         goto label_14;
                                                                                                                                                                                                                                             |     }
    0x00584d67 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584d69 xor ecx, ecx                                                                                                                                                                                                                  |     ecx = 0;
    0x00584d6b jmp 0x584da5                                                                                                                                                                                                                  |     goto label_15;
                                                                                                                                                                                                                                             | label_0:
    0x00584d70 mov rcx, qword [rsp + 0xe0]                                                                                                                                                                                                   |     rcx = *((rsp + 0xe0));
    0x00584d78 lea ecx, [rcx + rax + 1]                                                                                                                                                                                                      |     ecx = rcx + rax + 1;
    0x00584d7c lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x00584d84 lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
    0x00584d8c mov rax, qword [rsp + 0xe8]                                                                                                                                                                                                   |     rax = *((rsp + 0xe8));
                                                                                                                                                                                                                                             |     do {
    0x00584d94 inc rax                                                                                                                                                                                                                       |         rax++;
    0x00584d97 cmp rax, qword [rsp + 0x98]                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (rax == *((rsp + 0x98))) {
    0x00584d9f je 0x585030                                                                                                                                                                                                                   |             goto label_14;
                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                             | label_15:
    0x00584da5 mov rsi, qword [r13]                                                                                                                                                                                                          |         rsi = *(r13);
    0x00584da9 mov rdx, rax                                                                                                                                                                                                                  |         rdx = rax;
    0x00584dac shl rdx, 8                                                                                                                                                                                                                    |         rdx <<= 8;
    0x00584db0 mov qword [rsp + 0x28], rdx                                                                                                                                                                                                   |         *((rsp + 0x28)) = rdx;
    0x00584db5 mov edx, dword [rsi + rdx + 0x50]                                                                                                                                                                                             |         edx = *((rsi + rdx + 0x50));
    0x00584db9 test edx, edx                                                                                                                                                                                                                 |         
    0x00584dbb jle 0x584d94                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (edx <= 0);
    0x00584dbd mov qword [rsp + 0xe8], rax                                                                                                                                                                                                   |     *((rsp + 0xe8)) = rax;
    0x00584dc5 mov qword [rsp + 0xe0], rcx                                                                                                                                                                                                   |     *((rsp + 0xe0)) = rcx;
    0x00584dcd movsxd r12, ecx                                                                                                                                                                                                               |     r12 = (int64_t) ecx;
    0x00584dd0 imul r15, r12, 0x130                                                                                                                                                                                                          |     r15 = r12 * 0x130;
    0x00584dd7 shl r12, 3                                                                                                                                                                                                                    |     r12 <<= 3;
    0x00584ddb dec edx                                                                                                                                                                                                                       |     edx--;
    0x00584ddd mov dword [rsp + 0x6c], edx                                                                                                                                                                                                   |     *((rsp + 0x6c)) = edx;
    0x00584de1 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584de3 mov qword [rsp + 0x58], rax                                                                                                                                                                                                   |     *((rsp + 0x58)) = rax;
    0x00584de8 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             | label_1:
    0x00584df0 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584df5 mov rax, qword [rbx + r15 + 0x30]                                                                                                                                                                                             |     rax = *((rbx + r15 + 0x30));
    0x00584dfa mov qword [rsp + 0x120], rax                                                                                                                                                                                                  |     *((rsp + 0x120)) = rax;
    0x00584e02 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584e06 movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584e0b add rsi, qword [rsp + 0x28]                                                                                                                                                                                                   |     rsi += *((rsp + 0x28));
    0x00584e10 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584e13 call 0x58a4f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rsi);
    0x00584e18 add rbx, r15                                                                                                                                                                                                                  |     rbx += r15;
    0x00584e1b mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584e1e call 0x58a6b0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584e23 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584e26 mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584e29 call 0x58a580                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584e2e mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584e31 call 0x58a460                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584e36 mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584e3a mov rdx, qword [rsp + 0x28]                                                                                                                                                                                                   |     rdx = *((rsp + 0x28));
    0x00584e3f mov rax, qword [rax + rdx + 0x58]                                                                                                                                                                                             |     rax = *((rax + rdx + 0x58));
    0x00584e44 mov rcx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rcx = *((rsp + 0x30));
    0x00584e49 mov qword [rcx + r15 + 0x50], rax                                                                                                                                                                                             |     *((rcx + r15 + 0x50)) = rax;
    0x00584e4e mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584e52 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584e57 mov rcx, qword [rbx + r15 + 0x90]                                                                                                                                                                                             |     rcx = *((rbx + r15 + 0x90));
    0x00584e5f mov qword [rsp + 0x120], rcx                                                                                                                                                                                                  |     *((rsp + 0x120)) = rcx;
    0x00584e67 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584e6b movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584e70 lea rsi, [rax + rdx + 0x60]                                                                                                                                                                                                   |     
    0x00584e75 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584e78 call 0x58a4f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rax + rdx + 0x60);
    0x00584e7d lea rbx, [rbx + r15 + 0x60]                                                                                                                                                                                                   |     rbx = rbx + r15 + 0x60;
    0x00584e82 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584e85 call 0x58a6b0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584e8a mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584e8d mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584e90 call 0x58a580                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584e95 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584e98 call 0x58a460                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584e9d mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584ea1 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584ea6 mov rcx, qword [rbx + r15 + 0xe0]                                                                                                                                                                                             |     rcx = *((rbx + r15 + 0xe0));
    0x00584eae mov qword [rsp + 0x120], rcx                                                                                                                                                                                                  |     *((rsp + 0x120)) = rcx;
    0x00584eb6 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584eba movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584ebf mov rcx, qword [rsp + 0x28]                                                                                                                                                                                                   |     rcx = *((rsp + 0x28));
    0x00584ec4 lea rsi, [rax + rcx + 0xb0]                                                                                                                                                                                                   |     
    0x00584ecc mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584ecf call 0x58a4f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rax + rcx + 0xb0);
    0x00584ed4 lea rbx, [rbx + r15 + 0xb0]                                                                                                                                                                                                   |     rbx = rbx + r15 + 0xb0;
    0x00584edc mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584edf call 0x58a6b0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584ee4 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584ee7 mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584eea call 0x58a580                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584eef mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584ef2 call 0x58a460                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584ef7 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584efc mov qword [rax + r15 + 0x100], r13                                                                                                                                                                                            |     *((rax + r15 + 0x100)) = r13;
    0x00584f04 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584f09 mov rcx, qword [rsp + 0x58]                                                                                                                                                                                                   |     rcx = *((rsp + 0x58));
    0x00584f0e mov dword [rax + r15 + 0x108], ecx                                                                                                                                                                                            |     *((rax + r15 + 0x108)) = ecx;
    0x00584f16 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584f1b lea rcx, [rsp + 0x160]                                                                                                                                                                                                        |     rcx = rsp + 0x160;
    0x00584f23 mov qword [rax + r15 + 0x110], rcx                                                                                                                                                                                            |     *((rax + r15 + 0x110)) = rcx;
    0x00584f2b mov edi, 8                                                                                                                                                                                                                    |     edi = 8;
    0x00584f30 call 0x404ee0                                                                                                                                                                                                                 |     rax = operatornew(unsigned long) ();
    0x00584f35 mov ebp, dword [rsp + 0x6c]                                                                                                                                                                                                   |     ebp = *((rsp + 0x6c));
    0x00584f39 mov r14, rax                                                                                                                                                                                                                  |     r14 = rax;
    0x00584f3c mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584f41 add rax, r15                                                                                                                                                                                                                  |     rax += r15;
    0x00584f44 mov qword [r14], rax                                                                                                                                                                                                          |     *(r14) = rax;
    0x00584f47 mov r13, qword [rip + 0x29e592]                                                                                                                                                                                               |     r13 = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584f4e test r13, r13                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (r13 == 0) {
    0x00584f51 jne 0x584f5b                                                                                                                                                                                                                  |         
    0x00584f53 call 0x582990                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00584f58 mov r13, rax                                                                                                                                                                                                                  |         r13 = rax;
                                                                                                                                                                                                                                             |     }
    0x00584f5b mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584f5f mov esi, 0x28                                                                                                                                                                                                                 |     esi = 0x28;
    0x00584f64 mov rdi, r13                                                                                                                                                                                                                  |     rdi = r13;
    0x00584f67 call qword [rax + 0x10]                                                                                                                                                                                                       |     uint64_t (*rax + 0x10)() ();
    0x00584f6a movabs rcx, 0x100000002                                                                                                                                                                                                       |     rcx = 0x100000002;
    0x00584f74 mov qword [rax + 8], rcx                                                                                                                                                                                                      |     *((rax + 8)) = rcx;
    0x00584f78 mov qword [rax], 0x5bd900                                                                                                                                                                                                     |     *(rax) = vtable.BloombergLP::bslma::SharedPtrOutofplaceRep_BloombergLP::bslmt::ThroughputBenchmark_WorkFunction__BloombergLP::bslstl::SharedPtr_DefaultDeleter_.0;
    0x00584f7f mov qword [rax + 0x18], r14                                                                                                                                                                                                   |     *((rax + 0x18)) = r14;
    0x00584f83 mov qword [rax + 0x20], r13                                                                                                                                                                                                   |     *((rax + 0x20)) = r13;
    0x00584f87 mov rcx, qword [rsp + 8]                                                                                                                                                                                                      |     rcx = *((rsp + 8));
    0x00584f8c mov qword [rcx + r12*2], r14                                                                                                                                                                                                  |     *((rcx + r12*2)) = r14;
    0x00584f90 mov rdi, qword [rcx + r12*2 + 8]                                                                                                                                                                                              |     rdi = *((rcx + r12*2 + 8));
    0x00584f95 mov qword [rcx + r12*2 + 8], rax                                                                                                                                                                                              |     *((rcx + r12*2 + 8)) = rax;
    0x00584f9a test rdi, rdi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rdi != 0) {
    0x00584f9d je 0x584fc0                                                                                                                                                                                                                   |         
    0x00584f9f call 0x5ae210                                                                                                                                                                                                                 |         BloombergLP::bslma::SharedPtrRep::releaseRef() (rdi);
    0x00584fa4 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
    0x00584fa9 mov rax, qword [rsp + 8]                                                                                                                                                                                                      |         rax = *((rsp + 8));
    0x00584fae mov r14, qword [rax + r12*2]                                                                                                                                                                                                  |         r14 = *((rax + r12*2));
    0x00584fb2 jmp 0x584fc5                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } else {
    0x00584fc0 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
                                                                                                                                                                                                                                             |     }
    0x00584fc5 mov rbx, qword [rsp + 0x140]                                                                                                                                                                                                  |     rbx = *((rsp + 0x140));
    0x00584fcd add rbx, r12                                                                                                                                                                                                                  |     rbx += r12;
    0x00584fd0 mov rax, qword [rip + 0x29e511]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_globalAllocator;
    0x00584fd7 test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584fda jne 0x584fe1                                                                                                                                                                                                                  |         
    0x00584fdc call 0x582af0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::NewDeleteAllocator::singleton() ();
                                                                                                                                                                                                                                             |     }
    0x00584fe1 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584fe4 mov rsi, r14                                                                                                                                                                                                                  |     
    0x00584fe7 mov rdx, rax                                                                                                                                                                                                                  |     
    0x00584fea call 0x585c70                                                                                                                                                                                                                 |     intBloombergLP::bslmt::ThreadUtil::createWithAllocator<BloombergLP::bslmt::ThroughputBenchmark_WorkFunction>(unsigned long*,BloombergLP::bslmt::ThroughputBenchmark_WorkFunctionconst&,BloombergLP::bslma::Allocator*) (rbx, r14, rax);
    0x00584fef mov rax, qword [rsp + 0x58]                                                                                                                                                                                                   |     rax = *((rsp + 0x58));
    0x00584ff4 cmp ebp, eax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (ebp == eax) {
    0x00584ff6 je 0x584d70                                                                                                                                                                                                                   |         goto label_0;
                                                                                                                                                                                                                                             |     }
    0x00584ffc inc eax                                                                                                                                                                                                                       |     eax++;
    0x00584ffe mov qword [rsp + 0x58], rax                                                                                                                                                                                                   |     *((rsp + 0x58)) = rax;
    0x00585003 mov rsi, qword [r13]                                                                                                                                                                                                          |     rsi = *(r13);
    0x00585007 add r12, 8                                                                                                                                                                                                                    |     r12 += 8;
    0x0058500b add r15, 0x130                                                                                                                                                                                                                |     r15 += 0x130;
    0x00585012 lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x0058501a lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
    0x00585022 jmp 0x584df0                                                                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                                                                             | label_14:
    0x00585030 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x00585038 call 0x5ae3e0                                                                                                                                                                                                                 |     BloombergLP::bslmt::Barrier::wait() (rsp + 0x160);
    0x0058503d mov edi, dword [rsp + 0x64]                                                                                                                                                                                                   |     
    0x00585041 xor esi, esi                                                                                                                                                                                                                  |     
    0x00585043 xor edx, edx                                                                                                                                                                                                                  |     
    0x00585045 call 0x583f60                                                                                                                                                                                                                 |     BloombergLP::bslmt::ThreadUtilImpl<BloombergLP::bslmt::Platform::PosixThreads>::microSleep(int,int,BloombergLP::bsls::TimeInterval*) (*((rsp + 0x64)), 0, 0);
    0x0058504a mov dword [r13 + 0x20], 1                                                                                                                                                                                                     |     *((r13 + 0x20)) = 1;
    0x00585052 mov rax, qword [rsp + 0x90]                                                                                                                                                                                                   |     rax = *((rsp + 0x90));
    0x0058505a mov rax, qword [rax + 0x40]                                                                                                                                                                                                   |     rax = *((rax + 0x40));
    0x0058505e test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00585061 je 0x58507d                                                                                                                                                                                                                   |         
    0x00585063 xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00585065 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x0058506a cmp rcx, qword [rsp + 0x78]                                                                                                                                                                                                   |         
    0x0058506f sete sil                                                                                                                                                                                                                      |         sil = (rcx == *((rsp + 0x78))) ? 1 : 0;
    0x00585073 mov rdi, qword [rsp + 0x90]                                                                                                                                                                                                   |         rdi = *((rsp + 0x90));
    0x0058507b call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x0058507d cmp dword [rsp + 0x18], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                             |     if (*((rsp + 0x18)) <= 0) {
    0x00585082 jle 0x585150                                                                                                                                                                                                                  |         goto label_16;
                                                                                                                                                                                                                                             |     }
    0x00585088 xor r15d, r15d                                                                                                                                                                                                                |     r15d = 0;
    0x0058508b xor r14d, r14d                                                                                                                                                                                                                |     r14d = 0;
    0x0058508e jmp 0x5850ac                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while (r12d <= 0) {
                                                                                                                                                                                                                                             | label_2:
    0x00585090 add r12d, r14d                                                                                                                                                                                                                |         r12d += r14d;
    0x00585093 inc r15                                                                                                                                                                                                                       |         r15++;
    0x00585096 mov r14d, r12d                                                                                                                                                                                                                |         r14d = r12d;
    0x00585099 cmp r15, qword [rsp + 0x98]                                                                                                                                                                                                   |         
    0x005850a1 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
                                                                                                                                                                                                                                             |         if (r15 == *((rsp + 0x98))) {
    0x005850a6 je 0x585150                                                                                                                                                                                                                   |             goto label_16;
                                                                                                                                                                                                                                             |         }
    0x005850ac mov rax, qword [r13]                                                                                                                                                                                                          |         rax = *(r13);
    0x005850b0 mov rcx, r15                                                                                                                                                                                                                  |         rcx = r15;
    0x005850b3 shl rcx, 8                                                                                                                                                                                                                    |         rcx <<= 8;
    0x005850b7 mov r12d, dword [rax + rcx + 0x50]                                                                                                                                                                                            |         r12d = *((rax + rcx + 0x50));
    0x005850bc test r12d, r12d                                                                                                                                                                                                               |         
    0x005850bf jle 0x585090                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     }
    0x005850c1 movsxd r13, r14d                                                                                                                                                                                                              |     r13 = (int64_t) r14d;
    0x005850c4 shl r13, 3                                                                                                                                                                                                                    |     r13 <<= 3;
    0x005850c8 mov ebp, 0x24                                                                                                                                                                                                                 |     
    0x005850cd xor ebx, ebx                                                                                                                                                                                                                  |     ebx = 0;
    0x005850cf nop                                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                             |     do {
    0x005850d0 mov rax, qword [rsp + 0x140]                                                                                                                                                                                                  |         rax = *((rsp + 0x140));
    0x005850d8 add rax, r13                                                                                                                                                                                                                  |         rax += r13;
    0x005850db mov rdi, qword [rax + rbx*8]                                                                                                                                                                                                  |         
    0x005850df xor esi, esi                                                                                                                                                                                                                  |         
    0x005850e1 call 0x405230                                                                                                                                                                                                                 |         pthread_join (*((rax + rbx*8)), 0);
    0x005850e6 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |         rax = *((rsp + 0x30));
    0x005850eb xorps xmm0, xmm0                                                                                                                                                                                                              |         __asm ("xorps xmm0, xmm0");
    0x005850ee cvtsi2sd xmm0, qword [rax + rbp*8]                                                                                                                                                                                            |         __asm ("cvtsi2sd xmm0, qword [rax + rbp*8]");
    0x005850f4 mulsd xmm0, qword [rip + 0x38784]                                                                                                                                                                                             |         __asm ("mulsd xmm0, qword [0x005bd880]");
    0x005850fc xorps xmm1, xmm1                                                                                                                                                                                                              |         __asm ("xorps xmm1, xmm1");
    0x005850ff cvtsi2sd xmm1, qword [rax + rbp*8 - 8]                                                                                                                                                                                        |         __asm ("cvtsi2sd xmm1, qword [rax + rbp*8 - 8]");
    0x00585106 divsd xmm0, xmm1                                                                                                                                                                                                              |         __asm ("divsd xmm0, xmm1");
    0x0058510a mov rax, qword [rsp + 0xa0]                                                                                                                                                                                                   |         rax = *((rsp + 0xa0));
    0x00585112 mov rax, qword [rax]                                                                                                                                                                                                          |         rax = *(rax);
    0x00585115 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x0058511a shl rcx, 5                                                                                                                                                                                                                    |         rcx <<= 5;
    0x0058511e mov rax, qword [rax + rcx]                                                                                                                                                                                                    |         rax = *((rax + rcx));
    0x00585122 mov rcx, r15                                                                                                                                                                                                                  |         rcx = r15;
    0x00585125 shl rcx, 5                                                                                                                                                                                                                    |         rcx <<= 5;
    0x00585129 mov rax, qword [rax + rcx]                                                                                                                                                                                                    |         rax = *((rax + rcx));
    0x0058512d movsd qword [rax + rbx*8], xmm0                                                                                                                                                                                               |         *((rax + rbx*8)) = xmm0;
    0x00585132 inc rbx                                                                                                                                                                                                                       |         rbx++;
    0x00585135 add rbp, 0x26                                                                                                                                                                                                                 |         rbp += 0x26;
    0x00585139 cmp r12, rbx                                                                                                                                                                                                                  |         
    0x0058513c jne 0x5850d0                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (r12 != rbx);
    0x0058513e jmp 0x585090                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                             | label_16:
    0x00585150 mov rdi, qword [rsp + 0x210]                                                                                                                                                                                                  |     rdi = *((rsp + 0x210));
    0x00585158 mov rax, qword [rdi + 0x40]                                                                                                                                                                                                   |     rax = *((rdi + 0x40));
    0x0058515c test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x0058515f je 0x585173                                                                                                                                                                                                                   |         
    0x00585161 xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00585163 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x00585168 cmp rcx, qword [rsp + 0x78]                                                                                                                                                                                                   |         
    0x0058516d sete sil                                                                                                                                                                                                                      |         sil = (rcx == *((rsp + 0x78))) ? 1 : 0;
    0x00585171 call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x00585173 mov rax, qword [rsp + 8]                                                                                                                                                                                                      |     rax = *((rsp + 8));
    0x00585178 test rax, rax                                                                                                                                                                                                                 |     
    0x0058517b mov r12, qword [rsp + 0xd0]                                                                                                                                                                                                   |     r12 = *((rsp + 0xd0));
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00585183 je 0x5851d3                                                                                                                                                                                                                   |         goto label_17;
                                                                                                                                                                                                                                             |     }
    0x00585185 cmp rax, qword [rsp + 0x20]                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (rax == *((rsp + 0x20))) {
    0x0058518a je 0x5851c0                                                                                                                                                                                                                   |         goto label_18;
                                                                                                                                                                                                                                             |     }
    0x0058518c mov rbx, qword [rsp + 8]                                                                                                                                                                                                      |     rbx = *((rsp + 8));
    0x00585191 jmp 0x5851ab                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while (rdi == 0) {
                                                                                                                                                                                                                                             | label_3:
    0x005851a0 add rbx, 0x10                                                                                                                                                                                                                 |         rbx += 0x10;
    0x005851a4 cmp qword [rsp + 0x20], rbx                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (*((rsp + 0x20)) == rbx) {
    0x005851a9 je 0x5851c0                                                                                                                                                                                                                   |             goto label_18;
                                                                                                                                                                                                                                             |         }
    0x005851ab mov rdi, qword [rbx + 8]                                                                                                                                                                                                      |         rdi = *((rbx + 8));
    0x005851af test rdi, rdi                                                                                                                                                                                                                 |         
    0x005851b2 je 0x5851a0                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |     }
    0x005851b4 call 0x5ae210                                                                                                                                                                                                                 |     BloombergLP::bslma::SharedPtrRep::releaseRef() (rdi);
    0x005851b9 jmp 0x5851a0                                                                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                                                                             | label_18:
    0x005851c0 mov rdi, qword [rsp + 0x88]                                                                                                                                                                                                   |     rdi = *((rsp + 0x88));
    0x005851c8 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x005851cb mov rsi, qword [rsp + 8]                                                                                                                                                                                                      |     rsi = *((rsp + 8));
    0x005851d0 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             | label_17:
    0x005851d3 mov rbp, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbp = *((rsp + 0x30));
    0x005851d8 test rbp, rbp                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbp == 0) {
    0x005851db je 0x58522c                                                                                                                                                                                                                   |         goto label_19;
                                                                                                                                                                                                                                             |     }
    0x005851dd mov rbx, qword [rsp + 0x38]                                                                                                                                                                                                   |     rbx = *((rsp + 0x38));
    0x005851e2 cmp rbp, rbx                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rbp == rbx) {
    0x005851e5 je 0x58521e                                                                                                                                                                                                                   |         goto label_20;
                                                                                                                                                                                                                                             |     }
    0x005851e7 nop word [rax + rax]                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                             |     do {
    0x005851f0 lea rdi, [rbp + 0xb0]                                                                                                                                                                                                         |         
    0x005851f7 call 0x58a460                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp + 0xb0);
    0x005851fc lea rdi, [rbp + 0x60]                                                                                                                                                                                                         |         
    0x00585200 call 0x58a460                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp + 0x60);
    0x00585205 mov rdi, rbp                                                                                                                                                                                                                  |         
    0x00585208 call 0x58a460                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x0058520d add rbp, 0x130                                                                                                                                                                                                                |         rbp += 0x130;
    0x00585214 cmp rbx, rbp                                                                                                                                                                                                                  |         
    0x00585217 jne 0x5851f0                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rbx != rbp);
    0x00585219 mov rbp, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbp = *((rsp + 0x30));
                                                                                                                                                                                                                                             | label_20:
    0x0058521e mov rdi, qword [rsp + 0x48]                                                                                                                                                                                                   |     rdi = *((rsp + 0x48));
    0x00585223 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x00585226 mov rsi, rbp                                                                                                                                                                                                                  |     rsi = rbp;
    0x00585229 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             | label_19:
    0x0058522c mov rsi, qword [rsp + 0x140]                                                                                                                                                                                                  |     rsi = *((rsp + 0x140));
    0x00585234 test rsi, rsi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rsi == 0) {
    0x00585237 je 0x584be0                                                                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                                                                             |     }
    0x0058523d mov rdi, qword [rsp + 0x158]                                                                                                                                                                                                  |     rdi = *((rsp + 0x158));
    0x00585245 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x00585248 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
    0x0058524b jmp 0x584be0                                                                                                                                                                                                                  |     goto label_4;
                                                                                                                                                                                                                                             | label_12:
    0x00585250 mov rsi, qword [rsp + 0xa8]                                                                                                                                                                                                   |     rsi = *((rsp + 0xa8));
    0x00585258 test rsi, rsi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rsi != 0) {
    0x0058525b je 0x58526b                                                                                                                                                                                                                   |         
    0x0058525d mov rdi, qword [rsp + 0xc0]                                                                                                                                                                                                   |         rdi = *((rsp + 0xc0));
    0x00585265 mov rax, qword [rdi]                                                                                                                                                                                                          |         rax = *(rdi);
    0x00585268 call qword [rax + 0x18]                                                                                                                                                                                                       |         uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             |     }
    0x0058526b add rsp, 0x1d8                                                                                                                                                                                                                |     
    0x00585272 pop rbx                                                                                                                                                                                                                       |     
    0x00585273 pop r12                                                                                                                                                                                                                       |     
    0x00585275 pop r13                                                                                                                                                                                                                       |     
    0x00585277 pop r14                                                                                                                                                                                                                       |     
    0x00585279 pop r15                                                                                                                                                                                                                       |     
    0x0058527b pop rbp                                                                                                                                                                                                                       |     
    0x0058527c ret                                                                                                                                                                                                                           |     return rax;
                                                                                                                                                                                                                                             | label_13:
    0x0058527d mov edi, 0x5b8f2d                                                                                                                                                                                                             |     
    0x00585282 call 0x58aaf0                                                                                                                                                                                                                 |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("vector<...>::vector(n,v): vector too long");
                                                                                                                                                                                                                                             | }