; assembly                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                             | /* bdlcc_stripedunorderedmap.t/none @ 0x5847d0 */
                                                                                                                                                                                                                                             | #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&) */
    0x005847d0 push rbp                                                                                                                                                                                                                      |     
    0x005847d1 push r15                                                                                                                                                                                                                      |     
    0x005847d3 push r14                                                                                                                                                                                                                      |     
    0x005847d5 push r13                                                                                                                                                                                                                      |     
    0x005847d7 push r12                                                                                                                                                                                                                      |     
    0x005847d9 push rbx                                                                                                                                                                                                                      |     
    0x005847da sub rsp, 0x1d8                                                                                                                                                                                                                |     
    0x005847e1 mov qword [rsp + 0x90], r9                                                                                                                                                                                                    |     *((rsp + 0x90)) = r9;
    0x005847e9 mov r12, r8                                                                                                                                                                                                                   |     r12 = r8;
    0x005847ec mov r15d, ecx                                                                                                                                                                                                                 |     r15d = ecx;
    0x005847ef mov dword [rsp + 0x28], edx                                                                                                                                                                                                   |     *((rsp + 0x28)) = edx;
    0x005847f3 mov qword [rsp + 0xa0], rsi                                                                                                                                                                                                   |     *((rsp + 0xa0)) = rsi;
    0x005847fb mov r13, rdi                                                                                                                                                                                                                  |     r13 = rdi;
    0x005847fe mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x00584801 mov r14, qword [rdi + 8]                                                                                                                                                                                                      |     r14 = *((rdi + 8));
    0x00584805 mov rcx, r14                                                                                                                                                                                                                  |     rcx = *((rdi + 8));
    0x00584808 sub rcx, rax                                                                                                                                                                                                                  |     rcx -= rax;
    0x0058480b shr rcx, 8                                                                                                                                                                                                                    |     rcx >>= 8;
    0x0058480f sub r14, rax                                                                                                                                                                                                                  |     r14 -= rax;
    0x00584812 mov qword [rsp + 0x18], rcx                                                                                                                                                                                                   |     *((rsp + 0x18)) = rcx;
                                                                                                                                                                                                                                             |     if (r14 != 0) {
    0x00584817 je 0x584841                                                                                                                                                                                                                   |         
    0x00584819 mov ebx, dword [rax + 0x50]                                                                                                                                                                                                   |         ebx = *((rax + 0x50));
    0x0058481c cmp ecx, 2                                                                                                                                                                                                                    |         
                                                                                                                                                                                                                                             |         if (ecx < 2) {
    0x0058481f jl 0x5848af                                                                                                                                                                                                                   |             goto label_5;
                                                                                                                                                                                                                                             |         }
    0x00584825 mov edx, ecx                                                                                                                                                                                                                  |         edx = ecx;
    0x00584827 lea rsi, [rdx - 1]                                                                                                                                                                                                            |         rsi = rdx - 1;
    0x0058482b add rdx, 0xfffffffffffffffe                                                                                                                                                                                                   |         rdx += 0xfffffffffffffffe;
    0x0058482f mov ecx, esi                                                                                                                                                                                                                  |         ecx = esi;
    0x00584831 and ecx, 3                                                                                                                                                                                                                    |         ecx &= 3;
    0x00584834 cmp rdx, 3                                                                                                                                                                                                                    |         
                                                                                                                                                                                                                                             |         if (rdx >= 3) {
    0x00584838 jae 0x584845                                                                                                                                                                                                                  |             goto label_6;
                                                                                                                                                                                                                                             |         }
    0x0058483a mov edx, 1                                                                                                                                                                                                                    |         edx = 1;
    0x0058483f jmp 0x58488a                                                                                                                                                                                                                  |         goto label_7;
                                                                                                                                                                                                                                             |     }
    0x00584841 xor ebx, ebx                                                                                                                                                                                                                  |     ebx = 0;
    0x00584843 jmp 0x5848af                                                                                                                                                                                                                  |     goto label_5;
                                                                                                                                                                                                                                             | label_6:
    0x00584845 lea rdi, [rax + 0x450]                                                                                                                                                                                                        |     rdi = rax + 0x450;
    0x0058484c and rsi, 0xfffffffffffffffc                                                                                                                                                                                                   |     rsi &= 0xfffffffffffffffc;
    0x00584850 neg rsi                                                                                                                                                                                                                       |     rsi = -rsi;
    0x00584853 mov edx, 1                                                                                                                                                                                                                    |     edx = 1;
    0x00584858 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             |     do {
    0x00584860 add ebx, dword [rdi - 0x300]                                                                                                                                                                                                  |         ebx += *((rdi - 0x300));
    0x00584866 add ebx, dword [rdi - 0x200]                                                                                                                                                                                                  |         ebx += *((rdi - 0x200));
    0x0058486c add ebx, dword [rdi - 0x100]                                                                                                                                                                                                  |         ebx += *((rdi - 0x100));
    0x00584872 add ebx, dword [rdi]                                                                                                                                                                                                          |         ebx += *(rdi);
    0x00584874 add rdi, 0x400                                                                                                                                                                                                                |         rdi += 0x400;
    0x0058487b lea rbp, [rsi + rdx + 4]                                                                                                                                                                                                      |         rbp = rsi + rdx + 4;
    0x00584880 add rdx, 4                                                                                                                                                                                                                    |         rdx += 4;
    0x00584884 cmp rbp, 1                                                                                                                                                                                                                    |         
    0x00584888 jne 0x584860                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rbp != 1);
                                                                                                                                                                                                                                             | label_7:
    0x0058488a test rcx, rcx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rcx == 0) {
    0x0058488d je 0x5848af                                                                                                                                                                                                                   |         goto label_5;
                                                                                                                                                                                                                                             |     }
    0x0058488f shl rdx, 8                                                                                                                                                                                                                    |     rdx <<= 8;
    0x00584893 lea rax, [rax + rdx + 0x50]                                                                                                                                                                                                   |     rax = rax + rdx + 0x50;
    0x00584898 shl rcx, 8                                                                                                                                                                                                                    |     rcx <<= 8;
    0x0058489c xor edx, edx                                                                                                                                                                                                                  |     edx = 0;
    0x0058489e nop                                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                             |     do {
    0x005848a0 add ebx, dword [rax + rdx]                                                                                                                                                                                                    |         ebx += *((rax + rdx));
    0x005848a3 add rdx, 0x100                                                                                                                                                                                                                |         rdx += 0x100;
    0x005848aa cmp rcx, rdx                                                                                                                                                                                                                  |         
    0x005848ad jne 0x5848a0                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rcx != rdx);
                                                                                                                                                                                                                                             | label_5:
    0x005848af mov qword [rsp + 0x70], rbx                                                                                                                                                                                                   |     *((rsp + 0x70)) = rbx;
    0x005848b4 shr r14, 8                                                                                                                                                                                                                    |     r14 >>= 8;
    0x005848b8 mov rax, qword [rip + 0x29ec21]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x005848bf test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x005848c2 jne 0x5848c9                                                                                                                                                                                                                  |         
    0x005848c4 call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x005848c9 movsxd rbp, r14d                                                                                                                                                                                                              |     rbp = (int64_t) r14d;
    0x005848cc test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x005848cf jne 0x5848e2                                                                                                                                                                                                                  |         
    0x005848d1 mov rax, qword [rip + 0x29ec08]                                                                                                                                                                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x005848d8 test rax, rax                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                             |         if (rax != 0) {
    0x005848db jne 0x5848e2                                                                                                                                                                                                                  |             goto label_8;
                                                                                                                                                                                                                                             |         }
    0x005848dd call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_8:
    0x005848e2 mov qword [rsp + 0x160], rax                                                                                                                                                                                                  |     *((rsp + 0x160)) = rax;
    0x005848ea lea rdi, [rsp + 0xa8]                                                                                                                                                                                                         |     
    0x005848f2 lea rdx, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x005848fa mov rsi, rbp                                                                                                                                                                                                                  |     
    0x005848fd call 0x59db40                                                                                                                                                                                                                 |     bsl::vector<int,bsl::allocator<int>>::vector(unsigned long,bsl::allocator<int>const&) (rsp + 0xa8, rbp, rsp + 0x160);
    0x00584902 cmp dword [rsp + 0x18], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                             |     if (*((rsp + 0x18)) <= 0) {
    0x00584907 jle 0x58498a                                                                                                                                                                                                                  |         goto label_9;
                                                                                                                                                                                                                                             |     }
    0x0058490d mov rax, qword [rsp + 0x18]                                                                                                                                                                                                   |     rax = *((rsp + 0x18));
    0x00584912 mov edx, eax                                                                                                                                                                                                                  |     edx = eax;
    0x00584914 and eax, 1                                                                                                                                                                                                                    |     eax &= 1;
    0x00584917 cmp rdx, 1                                                                                                                                                                                                                    |     
                                                                                                                                                                                                                                             |     if (rdx == 1) {
    0x0058491b jne 0x584921                                                                                                                                                                                                                  |         
    0x0058491d xor ecx, ecx                                                                                                                                                                                                                  |         ecx = 0;
    0x0058491f jmp 0x58496b                                                                                                                                                                                                                  |         goto label_10;
                                                                                                                                                                                                                                             |     }
    0x00584921 sub rdx, rax                                                                                                                                                                                                                  |     rdx -= rax;
    0x00584924 xor esi, esi                                                                                                                                                                                                                  |     esi = 0;
    0x00584926 xor ecx, ecx                                                                                                                                                                                                                  |     ecx = 0;
    0x00584928 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             |     do {
    0x00584930 mov rdi, qword [r13]                                                                                                                                                                                                          |         rdi = *(r13);
    0x00584934 mov edi, dword [rdi + rsi + 0x50]                                                                                                                                                                                             |         edi = *((rdi + rsi + 0x50));
    0x00584938 mov rbp, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rbp = *((rsp + 0xa8));
    0x00584940 mov dword [rbp + rcx*4], edi                                                                                                                                                                                                  |         *((rbp + rcx*4)) = edi;
    0x00584944 mov rdi, qword [r13]                                                                                                                                                                                                          |         rdi = *(r13);
    0x00584948 mov edi, dword [rdi + rsi + 0x150]                                                                                                                                                                                            |         edi = *((rdi + rsi + 0x150));
    0x0058494f mov rbp, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rbp = *((rsp + 0xa8));
    0x00584957 mov dword [rbp + rcx*4 + 4], edi                                                                                                                                                                                              |         *((rbp + rcx*4 + 4)) = edi;
    0x0058495b add rcx, 2                                                                                                                                                                                                                    |         rcx += 2;
    0x0058495f add rsi, 0x200                                                                                                                                                                                                                |         rsi += 0x200;
    0x00584966 cmp rdx, rcx                                                                                                                                                                                                                  |         
    0x00584969 jne 0x584930                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rdx != rcx);
                                                                                                                                                                                                                                             | label_10:
    0x0058496b test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x0058496e je 0x58498a                                                                                                                                                                                                                   |         
    0x00584970 mov rax, qword [r13]                                                                                                                                                                                                          |         rax = *(r13);
    0x00584974 mov rdx, rcx                                                                                                                                                                                                                  |         rdx = rcx;
    0x00584977 shl rdx, 8                                                                                                                                                                                                                    |         rdx <<= 8;
    0x0058497b mov eax, dword [rax + rdx + 0x50]                                                                                                                                                                                             |         eax = *((rax + rdx + 0x50));
    0x0058497f mov rdx, qword [rsp + 0xa8]                                                                                                                                                                                                   |         rdx = *((rsp + 0xa8));
    0x00584987 mov dword [rdx + rcx*4], eax                                                                                                                                                                                                  |         *((rdx + rcx*4)) = eax;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_9:
    0x0058498a lea rdx, [rsp + 0xa8]                                                                                                                                                                                                         |     
    0x00584992 mov rdi, qword [rsp + 0xa0]                                                                                                                                                                                                   |     
    0x0058499a mov esi, r15d                                                                                                                                                                                                                 |     
    0x0058499d call 0x585ff0                                                                                                                                                                                                                 |     BloombergLP::bslmt::ThroughputBenchmarkResult::initialize(int,bsl::vector<int,bsl::allocator<int>>const&) (*((rsp + 0xa0)), r15d, rsp + 0xa8);
    0x005849a2 test r15d, r15d                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                             |     if (r15d <= 0) {
    0x005849a5 jle 0x585090                                                                                                                                                                                                                  |         goto label_11;
                                                                                                                                                                                                                                             |     }
    0x005849ab lea eax, [r15 - 1]                                                                                                                                                                                                            |     eax = r15 - 1;
    0x005849af mov qword [rsp + 0x78], rax                                                                                                                                                                                                   |     *((rsp + 0x78)) = rax;
    0x005849b4 lea rbx, [rsp + 0x188]                                                                                                                                                                                                        |     rbx = rsp + 0x188;
    0x005849bc mov rax, qword [rsp + 0x70]                                                                                                                                                                                                   |     rax = *((rsp + 0x70));
    0x005849c1 lea ecx, [rax + 1]                                                                                                                                                                                                            |     ecx = rax + 1;
    0x005849c4 mov dword [rsp + 0x68], ecx                                                                                                                                                                                                   |     *((rsp + 0x68)) = ecx;
    0x005849c8 cdqe                                                                                                                                                                                                                          |     rax = (int64_t) eax;
    0x005849ca mov qword [rsp + 0xd8], rax                                                                                                                                                                                                   |     *((rsp + 0xd8)) = rax;
    0x005849d2 shl rax, 4                                                                                                                                                                                                                    |     rax <<= 4;
    0x005849d6 mov qword [rsp + 0x80], rax                                                                                                                                                                                                   |     *((rsp + 0x80)) = rax;
    0x005849de imul eax, dword [rsp + 0x28], 0x3e8                                                                                                                                                                                           |     eax = *((rsp + 0x28)) * 0x3e8;
    0x005849e6 mov dword [rsp + 0x64], eax                                                                                                                                                                                                   |     *((rsp + 0x64)) = eax;
    0x005849ea mov eax, r15d                                                                                                                                                                                                                 |     eax = r15d;
    0x005849ed mov qword [rsp + 0xc8], rax                                                                                                                                                                                                   |     *((rsp + 0xc8)) = rax;
    0x005849f5 mov eax, dword [rsp + 0x18]                                                                                                                                                                                                   |     eax = *((rsp + 0x18));
    0x005849f9 mov qword [rsp + 0x98], rax                                                                                                                                                                                                   |     *((rsp + 0x98)) = rax;
    0x00584a01 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584a03 mov qword [rsp + 0x10], rax                                                                                                                                                                                                   |     *((rsp + 0x10)) = rax;
    0x00584a08 mov qword [rsp + 0xd0], r12                                                                                                                                                                                                   |     *((rsp + 0xd0)) = r12;
    0x00584a10 mov qword [rsp + 0x50], r13                                                                                                                                                                                                   |     *((rsp + 0x50)) = r13;
    0x00584a15 jmp 0x584a53                                                                                                                                                                                                                  |     goto label_12;
                                                                                                                                                                                                                                             | label_4:
    0x00584a20 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x00584a28 call 0x5ae130                                                                                                                                                                                                                 |     BloombergLP::bslmt::Barrier::~Barrier() (rsp + 0x160);
    0x00584a2d mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |     rcx = *((rsp + 0x10));
    0x00584a32 inc rcx                                                                                                                                                                                                                       |     rcx++;
    0x00584a35 mov rax, rcx                                                                                                                                                                                                                  |     rax = rcx;
    0x00584a38 mov qword [rsp + 0x10], rcx                                                                                                                                                                                                   |     *((rsp + 0x10)) = rcx;
    0x00584a3d cmp rcx, qword [rsp + 0xc8]                                                                                                                                                                                                   |     
    0x00584a45 lea rbx, [rsp + 0x188]                                                                                                                                                                                                        |     rbx = rsp + 0x188;
                                                                                                                                                                                                                                             |     if (rcx == *((rsp + 0xc8))) {
    0x00584a4d je 0x585090                                                                                                                                                                                                                   |         goto label_11;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_12:
    0x00584a53 mov rax, qword [r12 + 0x40]                                                                                                                                                                                                   |     rax = *((r12 + 0x40));
    0x00584a58 test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00584a5b je 0x584a6e                                                                                                                                                                                                                   |         
    0x00584a5d xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00584a5f cmp qword [rsp + 0x10], 0                                                                                                                                                                                                     |         
    0x00584a65 sete sil                                                                                                                                                                                                                      |         sil = (*((rsp + 0x10)) == 0) ? 1 : 0;
    0x00584a69 mov rdi, r12                                                                                                                                                                                                                  |         rdi = r12;
    0x00584a6c call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x00584a6e mov dword [r13 + 0x20], 0                                                                                                                                                                                                     |     *((r13 + 0x20)) = 0;
    0x00584a76 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     rdi = rsp + 0x160;
    0x00584a7e xor esi, esi                                                                                                                                                                                                                  |     esi = 0;
    0x00584a80 call 0x405060                                                                                                                                                                                                                 |     pthread_mutex_init ();
    0x00584a85 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584a88 xor esi, esi                                                                                                                                                                                                                  |     
    0x00584a8a call 0x5ae300                                                                                                                                                                                                                 |     BloombergLP::bslmt::ConditionImpl<BloombergLP::bslmt::Platform::PosixThreads>::ConditionImpl(BloombergLP::bsls::SystemClockType::Enum) (rbx, 0);
    0x00584a8f mov eax, dword [rsp + 0x68]                                                                                                                                                                                                   |     eax = *((rsp + 0x68));
    0x00584a93 mov dword [rsp + 0x1c0], eax                                                                                                                                                                                                  |     *((rsp + 0x1c0)) = eax;
    0x00584a9a xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584a9e movupd xmmword [rbx + 0x3c], xmm0                                                                                                                                                                                             |     __asm ("movupd xmmword [rbx + 0x3c], xmm0");
    0x00584aa3 mov rax, qword [rip + 0x29ea36]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584aaa test rax, rax                                                                                                                                                                                                                 |     
    0x00584aad mov r14, qword [rsp + 0x18]                                                                                                                                                                                                   |     r14 = *((rsp + 0x18));
    0x00584ab2 mov rbp, qword [rsp + 0x70]                                                                                                                                                                                                   |     rbp = *((rsp + 0x70));
    0x00584ab7 mov rbx, qword [rsp + 0xd8]                                                                                                                                                                                                   |     rbx = *((rsp + 0xd8));
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584abf jne 0x584ac6                                                                                                                                                                                                                  |         
    0x00584ac1 call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x00584ac6 mov qword [rsp + 0xf0], rax                                                                                                                                                                                                   |     *((rsp + 0xf0)) = rax;
    0x00584ace lea rdi, [rsp + 0x140]                                                                                                                                                                                                        |     
    0x00584ad6 mov rsi, rbx                                                                                                                                                                                                                  |     
    0x00584ad9 lea rdx, [rsp + 0xf0]                                                                                                                                                                                                         |     
    0x00584ae1 call 0x5a1640                                                                                                                                                                                                                 |     bsl::vector<unsigned long,bsl::allocator<unsigned long>>::vector(unsigned long,bsl::allocator<unsigned long>const&) (rsp + 0x140, rbx, rsp + 0xf0);
    0x00584ae6 mov rax, qword [rip + 0x29e9f3]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584aed test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584af0 jne 0x584af7                                                                                                                                                                                                                  |         
    0x00584af2 call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                             |     }
    0x00584af7 mov qword [rsp + 0xf0], rax                                                                                                                                                                                                   |     *((rsp + 0xf0)) = rax;
    0x00584aff lea rdi, [rsp + 0x30]                                                                                                                                                                                                         |     
    0x00584b04 mov rsi, rbx                                                                                                                                                                                                                  |     
    0x00584b07 lea rdx, [rsp + 0xf0]                                                                                                                                                                                                         |     
    0x00584b0f call 0x5856f0                                                                                                                                                                                                                 |     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);
    0x00584b14 mov rbx, qword [rip + 0x29e9c5]                                                                                                                                                                                               |     rbx = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584b1b test rbx, rbx                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbx == 0) {
    0x00584b1e jne 0x584b28                                                                                                                                                                                                                  |         
    0x00584b20 call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00584b25 mov rbx, rax                                                                                                                                                                                                                  |         rbx = rax;
                                                                                                                                                                                                                                             |     }
    0x00584b28 test ebp, ebp                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (ebp < 0) {
    0x00584b2a js 0x5850bd                                                                                                                                                                                                                   |         goto label_13;
                                                                                                                                                                                                                                             |     }
    0x00584b30 mov qword [rsp + 0x88], rbx                                                                                                                                                                                                   |     *((rsp + 0x88)) = rbx;
                                                                                                                                                                                                                                             |     if (ebp != 0) {
    0x00584b38 je 0x584b80                                                                                                                                                                                                                   |         
    0x00584b3a mov rax, qword [rbx]                                                                                                                                                                                                          |         rax = *(rbx);
    0x00584b3d mov rdi, rbx                                                                                                                                                                                                                  |         rdi = rbx;
    0x00584b40 mov rsi, qword [rsp + 0x80]                                                                                                                                                                                                   |         rsi = *((rsp + 0x80));
    0x00584b48 call qword [rax + 0x10]                                                                                                                                                                                                       |         rax = uint64_t (*rax + 0x10)() ();
    0x00584b4b mov rbp, rax                                                                                                                                                                                                                  |         
    0x00584b4e mov rdi, rax                                                                                                                                                                                                                  |         
    0x00584b51 xor esi, esi                                                                                                                                                                                                                  |         
    0x00584b53 mov rbx, qword [rsp + 0x80]                                                                                                                                                                                                   |         rbx = *((rsp + 0x80));
    0x00584b5b mov rdx, rbx                                                                                                                                                                                                                  |         
    0x00584b5e call 0x404e00                                                                                                                                                                                                                 |         memset (rax, 0, *((rsp + 0x80)));
    0x00584b63 mov rax, rbp                                                                                                                                                                                                                  |         rax = rbp;
    0x00584b66 mov qword [rsp + 8], rbp                                                                                                                                                                                                      |         *((rsp + 8)) = rbp;
    0x00584b6b add rbp, rbx                                                                                                                                                                                                                  |         rbp += rbx;
    0x00584b6e mov qword [rsp + 0x20], rbp                                                                                                                                                                                                   |         *((rsp + 0x20)) = rbp;
    0x00584b73 jmp 0x584b8e                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } else {
    0x00584b80 xor eax, eax                                                                                                                                                                                                                  |         eax = 0;
    0x00584b82 mov qword [rsp + 0x20], rax                                                                                                                                                                                                   |         *((rsp + 0x20)) = rax;
    0x00584b87 xor eax, eax                                                                                                                                                                                                                  |         eax = 0;
    0x00584b89 mov qword [rsp + 8], rax                                                                                                                                                                                                      |         *((rsp + 8)) = rax;
                                                                                                                                                                                                                                             |     }
    0x00584b8e test r14d, r14d                                                                                                                                                                                                               |     
    0x00584b91 lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x00584b99 lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
                                                                                                                                                                                                                                             |     if (r14d <= 0) {
    0x00584ba1 jle 0x584e70                                                                                                                                                                                                                  |         goto label_14;
                                                                                                                                                                                                                                             |     }
    0x00584ba7 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584ba9 xor ecx, ecx                                                                                                                                                                                                                  |     ecx = 0;
    0x00584bab jmp 0x584be5                                                                                                                                                                                                                  |     goto label_15;
                                                                                                                                                                                                                                             | label_0:
    0x00584bb0 mov rcx, qword [rsp + 0xe0]                                                                                                                                                                                                   |     rcx = *((rsp + 0xe0));
    0x00584bb8 lea ecx, [rcx + rax + 1]                                                                                                                                                                                                      |     ecx = rcx + rax + 1;
    0x00584bbc lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x00584bc4 lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
    0x00584bcc mov rax, qword [rsp + 0xe8]                                                                                                                                                                                                   |     rax = *((rsp + 0xe8));
                                                                                                                                                                                                                                             |     do {
    0x00584bd4 inc rax                                                                                                                                                                                                                       |         rax++;
    0x00584bd7 cmp rax, qword [rsp + 0x98]                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (rax == *((rsp + 0x98))) {
    0x00584bdf je 0x584e70                                                                                                                                                                                                                   |             goto label_14;
                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                             | label_15:
    0x00584be5 mov rsi, qword [r13]                                                                                                                                                                                                          |         rsi = *(r13);
    0x00584be9 mov rdx, rax                                                                                                                                                                                                                  |         rdx = rax;
    0x00584bec shl rdx, 8                                                                                                                                                                                                                    |         rdx <<= 8;
    0x00584bf0 mov qword [rsp + 0x28], rdx                                                                                                                                                                                                   |         *((rsp + 0x28)) = rdx;
    0x00584bf5 mov edx, dword [rsi + rdx + 0x50]                                                                                                                                                                                             |         edx = *((rsi + rdx + 0x50));
    0x00584bf9 test edx, edx                                                                                                                                                                                                                 |         
    0x00584bfb jle 0x584bd4                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (edx <= 0);
    0x00584bfd mov qword [rsp + 0xe8], rax                                                                                                                                                                                                   |     *((rsp + 0xe8)) = rax;
    0x00584c05 mov qword [rsp + 0xe0], rcx                                                                                                                                                                                                   |     *((rsp + 0xe0)) = rcx;
    0x00584c0d movsxd r12, ecx                                                                                                                                                                                                               |     r12 = (int64_t) ecx;
    0x00584c10 imul r15, r12, 0x130                                                                                                                                                                                                          |     r15 = r12 * 0x130;
    0x00584c17 shl r12, 3                                                                                                                                                                                                                    |     r12 <<= 3;
    0x00584c1b dec edx                                                                                                                                                                                                                       |     edx--;
    0x00584c1d mov dword [rsp + 0x6c], edx                                                                                                                                                                                                   |     *((rsp + 0x6c)) = edx;
    0x00584c21 xor eax, eax                                                                                                                                                                                                                  |     eax = 0;
    0x00584c23 mov qword [rsp + 0x58], rax                                                                                                                                                                                                   |     *((rsp + 0x58)) = rax;
    0x00584c28 nop dword [rax + rax]                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                             | label_1:
    0x00584c30 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584c35 mov rax, qword [rbx + r15 + 0x30]                                                                                                                                                                                             |     rax = *((rbx + r15 + 0x30));
    0x00584c3a mov qword [rsp + 0x120], rax                                                                                                                                                                                                  |     *((rsp + 0x120)) = rax;
    0x00584c42 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584c46 movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584c4b add rsi, qword [rsp + 0x28]                                                                                                                                                                                                   |     rsi += *((rsp + 0x28));
    0x00584c50 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584c53 call 0x58a380                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rsi);
    0x00584c58 add rbx, r15                                                                                                                                                                                                                  |     rbx += r15;
    0x00584c5b mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584c5e call 0x58a540                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584c63 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584c66 mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584c69 call 0x58a410                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584c6e mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584c71 call 0x58a2f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584c76 mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584c7a mov rdx, qword [rsp + 0x28]                                                                                                                                                                                                   |     rdx = *((rsp + 0x28));
    0x00584c7f mov rax, qword [rax + rdx + 0x58]                                                                                                                                                                                             |     rax = *((rax + rdx + 0x58));
    0x00584c84 mov rcx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rcx = *((rsp + 0x30));
    0x00584c89 mov qword [rcx + r15 + 0x50], rax                                                                                                                                                                                             |     *((rcx + r15 + 0x50)) = rax;
    0x00584c8e mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584c92 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584c97 mov rcx, qword [rbx + r15 + 0x90]                                                                                                                                                                                             |     rcx = *((rbx + r15 + 0x90));
    0x00584c9f mov qword [rsp + 0x120], rcx                                                                                                                                                                                                  |     *((rsp + 0x120)) = rcx;
    0x00584ca7 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584cab movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584cb0 lea rsi, [rax + rdx + 0x60]                                                                                                                                                                                                   |     
    0x00584cb5 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584cb8 call 0x58a380                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rax + rdx + 0x60);
    0x00584cbd lea rbx, [rbx + r15 + 0x60]                                                                                                                                                                                                   |     rbx = rbx + r15 + 0x60;
    0x00584cc2 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584cc5 call 0x58a540                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584cca mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584ccd mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584cd0 call 0x58a410                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584cd5 mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584cd8 call 0x58a2f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584cdd mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584ce1 mov rbx, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbx = *((rsp + 0x30));
    0x00584ce6 mov rcx, qword [rbx + r15 + 0xe0]                                                                                                                                                                                             |     rcx = *((rbx + r15 + 0xe0));
    0x00584cee mov qword [rsp + 0x120], rcx                                                                                                                                                                                                  |     *((rsp + 0x120)) = rcx;
    0x00584cf6 xorpd xmm0, xmm0                                                                                                                                                                                                              |     __asm ("xorpd xmm0, xmm0");
    0x00584cfa movupd xmmword [r14], xmm0                                                                                                                                                                                                    |     __asm ("movupd xmmword [r14], xmm0");
    0x00584cff mov rcx, qword [rsp + 0x28]                                                                                                                                                                                                   |     rcx = *((rsp + 0x28));
    0x00584d04 lea rsi, [rax + rcx + 0xb0]                                                                                                                                                                                                   |     
    0x00584d0c mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584d0f call 0x58a380                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::copyInit(BloombergLP::bslstl::Function_Repconst&) (rbp, rax + rcx + 0xb0);
    0x00584d14 lea rbx, [rbx + r15 + 0xb0]                                                                                                                                                                                                   |     rbx = rbx + r15 + 0xb0;
    0x00584d1c mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584d1f call 0x58a540                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::makeEmpty() (rbx);
    0x00584d24 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584d27 mov rsi, rbp                                                                                                                                                                                                                  |     
    0x00584d2a call 0x58a410                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::moveInit(BloombergLP::bslstl::Function_Rep*) (rbx, rbp);
    0x00584d2f mov rdi, rbp                                                                                                                                                                                                                  |     
    0x00584d32 call 0x58a2f0                                                                                                                                                                                                                 |     BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x00584d37 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584d3c mov qword [rax + r15 + 0x100], r13                                                                                                                                                                                            |     *((rax + r15 + 0x100)) = r13;
    0x00584d44 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584d49 mov rcx, qword [rsp + 0x58]                                                                                                                                                                                                   |     rcx = *((rsp + 0x58));
    0x00584d4e mov dword [rax + r15 + 0x108], ecx                                                                                                                                                                                            |     *((rax + r15 + 0x108)) = ecx;
    0x00584d56 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584d5b lea rcx, [rsp + 0x160]                                                                                                                                                                                                        |     rcx = rsp + 0x160;
    0x00584d63 mov qword [rax + r15 + 0x110], rcx                                                                                                                                                                                            |     *((rax + r15 + 0x110)) = rcx;
    0x00584d6b mov edi, 8                                                                                                                                                                                                                    |     edi = 8;
    0x00584d70 call 0x404ee0                                                                                                                                                                                                                 |     rax = operatornew(unsigned long) ();
    0x00584d75 mov ebp, dword [rsp + 0x6c]                                                                                                                                                                                                   |     ebp = *((rsp + 0x6c));
    0x00584d79 mov r14, rax                                                                                                                                                                                                                  |     r14 = rax;
    0x00584d7c mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |     rax = *((rsp + 0x30));
    0x00584d81 add rax, r15                                                                                                                                                                                                                  |     rax += r15;
    0x00584d84 mov qword [r14], rax                                                                                                                                                                                                          |     *(r14) = rax;
    0x00584d87 mov r13, qword [rip + 0x29e752]                                                                                                                                                                                               |     r13 = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00584d8e test r13, r13                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (r13 == 0) {
    0x00584d91 jne 0x584d9b                                                                                                                                                                                                                  |         
    0x00584d93 call 0x5827a0                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00584d98 mov r13, rax                                                                                                                                                                                                                  |         r13 = rax;
                                                                                                                                                                                                                                             |     }
    0x00584d9b mov rax, qword [r13]                                                                                                                                                                                                          |     rax = *(r13);
    0x00584d9f mov esi, 0x28                                                                                                                                                                                                                 |     esi = 0x28;
    0x00584da4 mov rdi, r13                                                                                                                                                                                                                  |     rdi = r13;
    0x00584da7 call qword [rax + 0x10]                                                                                                                                                                                                       |     uint64_t (*rax + 0x10)() ();
    0x00584daa movabs rcx, 0x100000002                                                                                                                                                                                                       |     rcx = 0x100000002;
    0x00584db4 mov qword [rax + 8], rcx                                                                                                                                                                                                      |     *((rax + 8)) = rcx;
    0x00584db8 mov qword [rax], 0x5bd790                                                                                                                                                                                                     |     *(rax) = vtable.BloombergLP::bslma::SharedPtrOutofplaceRep_BloombergLP::bslmt::ThroughputBenchmark_WorkFunction__BloombergLP::bslstl::SharedPtr_DefaultDeleter_.0;
    0x00584dbf mov qword [rax + 0x18], r14                                                                                                                                                                                                   |     *((rax + 0x18)) = r14;
    0x00584dc3 mov qword [rax + 0x20], r13                                                                                                                                                                                                   |     *((rax + 0x20)) = r13;
    0x00584dc7 mov rcx, qword [rsp + 8]                                                                                                                                                                                                      |     rcx = *((rsp + 8));
    0x00584dcc mov qword [rcx + r12*2], r14                                                                                                                                                                                                  |     *((rcx + r12*2)) = r14;
    0x00584dd0 mov rdi, qword [rcx + r12*2 + 8]                                                                                                                                                                                              |     rdi = *((rcx + r12*2 + 8));
    0x00584dd5 mov qword [rcx + r12*2 + 8], rax                                                                                                                                                                                              |     *((rcx + r12*2 + 8)) = rax;
    0x00584dda test rdi, rdi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rdi != 0) {
    0x00584ddd je 0x584e00                                                                                                                                                                                                                   |         
    0x00584ddf call 0x5ae0a0                                                                                                                                                                                                                 |         BloombergLP::bslma::SharedPtrRep::releaseRef() (rdi);
    0x00584de4 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
    0x00584de9 mov rax, qword [rsp + 8]                                                                                                                                                                                                      |         rax = *((rsp + 8));
    0x00584dee mov r14, qword [rax + r12*2]                                                                                                                                                                                                  |         r14 = *((rax + r12*2));
    0x00584df2 jmp 0x584e05                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } else {
    0x00584e00 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
                                                                                                                                                                                                                                             |     }
    0x00584e05 mov rbx, qword [rsp + 0x140]                                                                                                                                                                                                  |     rbx = *((rsp + 0x140));
    0x00584e0d add rbx, r12                                                                                                                                                                                                                  |     rbx += r12;
    0x00584e10 mov rax, qword [rip + 0x29e6d1]                                                                                                                                                                                               |     rax = BloombergLP::bslma::Default::s_globalAllocator;
    0x00584e17 test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584e1a jne 0x584e21                                                                                                                                                                                                                  |         
    0x00584e1c call 0x582900                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::NewDeleteAllocator::singleton() ();
                                                                                                                                                                                                                                             |     }
    0x00584e21 mov rdi, rbx                                                                                                                                                                                                                  |     
    0x00584e24 mov rsi, r14                                                                                                                                                                                                                  |     
    0x00584e27 mov rdx, rax                                                                                                                                                                                                                  |     
    0x00584e2a call 0x585ab0                                                                                                                                                                                                                 |     intBloombergLP::bslmt::ThreadUtil::createWithAllocator<BloombergLP::bslmt::ThroughputBenchmark_WorkFunction>(unsigned long*,BloombergLP::bslmt::ThroughputBenchmark_WorkFunctionconst&,BloombergLP::bslma::Allocator*) (rbx, r14, rax);
    0x00584e2f mov rax, qword [rsp + 0x58]                                                                                                                                                                                                   |     rax = *((rsp + 0x58));
    0x00584e34 cmp ebp, eax                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (ebp == eax) {
    0x00584e36 je 0x584bb0                                                                                                                                                                                                                   |         goto label_0;
                                                                                                                                                                                                                                             |     }
    0x00584e3c inc eax                                                                                                                                                                                                                       |     eax++;
    0x00584e3e mov qword [rsp + 0x58], rax                                                                                                                                                                                                   |     *((rsp + 0x58)) = rax;
    0x00584e43 mov rsi, qword [r13]                                                                                                                                                                                                          |     rsi = *(r13);
    0x00584e47 add r12, 8                                                                                                                                                                                                                    |     r12 += 8;
    0x00584e4b add r15, 0x130                                                                                                                                                                                                                |     r15 += 0x130;
    0x00584e52 lea r14, [rsp + 0x128]                                                                                                                                                                                                        |     r14 = rsp + 0x128;
    0x00584e5a lea rbp, [rsp + 0xf0]                                                                                                                                                                                                         |     rbp = rsp + 0xf0;
    0x00584e62 jmp 0x584c30                                                                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                                                                             | label_14:
    0x00584e70 lea rdi, [rsp + 0x160]                                                                                                                                                                                                        |     
    0x00584e78 call 0x5ae270                                                                                                                                                                                                                 |     BloombergLP::bslmt::Barrier::wait() (rsp + 0x160);
    0x00584e7d mov edi, dword [rsp + 0x64]                                                                                                                                                                                                   |     
    0x00584e81 xor esi, esi                                                                                                                                                                                                                  |     
    0x00584e83 xor edx, edx                                                                                                                                                                                                                  |     
    0x00584e85 call 0x583d90                                                                                                                                                                                                                 |     BloombergLP::bslmt::ThreadUtilImpl<BloombergLP::bslmt::Platform::PosixThreads>::microSleep(int,int,BloombergLP::bsls::TimeInterval*) (*((rsp + 0x64)), 0, 0);
    0x00584e8a mov dword [r13 + 0x20], 1                                                                                                                                                                                                     |     *((r13 + 0x20)) = 1;
    0x00584e92 mov rax, qword [rsp + 0x90]                                                                                                                                                                                                   |     rax = *((rsp + 0x90));
    0x00584e9a mov rax, qword [rax + 0x40]                                                                                                                                                                                                   |     rax = *((rax + 0x40));
    0x00584e9e test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00584ea1 je 0x584ebd                                                                                                                                                                                                                   |         
    0x00584ea3 xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00584ea5 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x00584eaa cmp rcx, qword [rsp + 0x78]                                                                                                                                                                                                   |         
    0x00584eaf sete sil                                                                                                                                                                                                                      |         sil = (rcx == *((rsp + 0x78))) ? 1 : 0;
    0x00584eb3 mov rdi, qword [rsp + 0x90]                                                                                                                                                                                                   |         rdi = *((rsp + 0x90));
    0x00584ebb call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x00584ebd cmp dword [rsp + 0x18], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                             |     if (*((rsp + 0x18)) <= 0) {
    0x00584ec2 jle 0x584f90                                                                                                                                                                                                                  |         goto label_16;
                                                                                                                                                                                                                                             |     }
    0x00584ec8 xor r15d, r15d                                                                                                                                                                                                                |     r15d = 0;
    0x00584ecb xor r14d, r14d                                                                                                                                                                                                                |     r14d = 0;
    0x00584ece jmp 0x584eec                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while (r12d <= 0) {
                                                                                                                                                                                                                                             | label_2:
    0x00584ed0 add r12d, r14d                                                                                                                                                                                                                |         r12d += r14d;
    0x00584ed3 inc r15                                                                                                                                                                                                                       |         r15++;
    0x00584ed6 mov r14d, r12d                                                                                                                                                                                                                |         r14d = r12d;
    0x00584ed9 cmp r15, qword [rsp + 0x98]                                                                                                                                                                                                   |         
    0x00584ee1 mov r13, qword [rsp + 0x50]                                                                                                                                                                                                   |         r13 = *((rsp + 0x50));
                                                                                                                                                                                                                                             |         if (r15 == *((rsp + 0x98))) {
    0x00584ee6 je 0x584f90                                                                                                                                                                                                                   |             goto label_16;
                                                                                                                                                                                                                                             |         }
    0x00584eec mov rax, qword [r13]                                                                                                                                                                                                          |         rax = *(r13);
    0x00584ef0 mov rcx, r15                                                                                                                                                                                                                  |         rcx = r15;
    0x00584ef3 shl rcx, 8                                                                                                                                                                                                                    |         rcx <<= 8;
    0x00584ef7 mov r12d, dword [rax + rcx + 0x50]                                                                                                                                                                                            |         r12d = *((rax + rcx + 0x50));
    0x00584efc test r12d, r12d                                                                                                                                                                                                               |         
    0x00584eff jle 0x584ed0                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     }
    0x00584f01 movsxd r13, r14d                                                                                                                                                                                                              |     r13 = (int64_t) r14d;
    0x00584f04 shl r13, 3                                                                                                                                                                                                                    |     r13 <<= 3;
    0x00584f08 mov ebp, 0x24                                                                                                                                                                                                                 |     
    0x00584f0d xor ebx, ebx                                                                                                                                                                                                                  |     ebx = 0;
    0x00584f0f nop                                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                             |     do {
    0x00584f10 mov rax, qword [rsp + 0x140]                                                                                                                                                                                                  |         rax = *((rsp + 0x140));
    0x00584f18 add rax, r13                                                                                                                                                                                                                  |         rax += r13;
    0x00584f1b mov rdi, qword [rax + rbx*8]                                                                                                                                                                                                  |         
    0x00584f1f xor esi, esi                                                                                                                                                                                                                  |         
    0x00584f21 call 0x405230                                                                                                                                                                                                                 |         pthread_join (*((rax + rbx*8)), 0);
    0x00584f26 mov rax, qword [rsp + 0x30]                                                                                                                                                                                                   |         rax = *((rsp + 0x30));
    0x00584f2b xorps xmm0, xmm0                                                                                                                                                                                                              |         __asm ("xorps xmm0, xmm0");
    0x00584f2e cvtsi2sd xmm0, qword [rax + rbp*8]                                                                                                                                                                                            |         __asm ("cvtsi2sd xmm0, qword [rax + rbp*8]");
    0x00584f34 mulsd xmm0, qword [rip + 0x387d4]                                                                                                                                                                                             |         __asm ("mulsd xmm0, qword [0x005bd710]");
    0x00584f3c xorps xmm1, xmm1                                                                                                                                                                                                              |         __asm ("xorps xmm1, xmm1");
    0x00584f3f cvtsi2sd xmm1, qword [rax + rbp*8 - 8]                                                                                                                                                                                        |         __asm ("cvtsi2sd xmm1, qword [rax + rbp*8 - 8]");
    0x00584f46 divsd xmm0, xmm1                                                                                                                                                                                                              |         __asm ("divsd xmm0, xmm1");
    0x00584f4a mov rax, qword [rsp + 0xa0]                                                                                                                                                                                                   |         rax = *((rsp + 0xa0));
    0x00584f52 mov rax, qword [rax]                                                                                                                                                                                                          |         rax = *(rax);
    0x00584f55 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x00584f5a shl rcx, 5                                                                                                                                                                                                                    |         rcx <<= 5;
    0x00584f5e mov rax, qword [rax + rcx]                                                                                                                                                                                                    |         rax = *((rax + rcx));
    0x00584f62 mov rcx, r15                                                                                                                                                                                                                  |         rcx = r15;
    0x00584f65 shl rcx, 5                                                                                                                                                                                                                    |         rcx <<= 5;
    0x00584f69 mov rax, qword [rax + rcx]                                                                                                                                                                                                    |         rax = *((rax + rcx));
    0x00584f6d movsd qword [rax + rbx*8], xmm0                                                                                                                                                                                               |         *((rax + rbx*8)) = xmm0;
    0x00584f72 inc rbx                                                                                                                                                                                                                       |         rbx++;
    0x00584f75 add rbp, 0x26                                                                                                                                                                                                                 |         rbp += 0x26;
    0x00584f79 cmp r12, rbx                                                                                                                                                                                                                  |         
    0x00584f7c jne 0x584f10                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (r12 != rbx);
    0x00584f7e jmp 0x584ed0                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                             | label_16:
    0x00584f90 mov rdi, qword [rsp + 0x210]                                                                                                                                                                                                  |     rdi = *((rsp + 0x210));
    0x00584f98 mov rax, qword [rdi + 0x40]                                                                                                                                                                                                   |     rax = *((rdi + 0x40));
    0x00584f9c test rax, rax                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x00584f9f je 0x584fb3                                                                                                                                                                                                                   |         
    0x00584fa1 xor esi, esi                                                                                                                                                                                                                  |         esi = 0;
    0x00584fa3 mov rcx, qword [rsp + 0x10]                                                                                                                                                                                                   |         rcx = *((rsp + 0x10));
    0x00584fa8 cmp rcx, qword [rsp + 0x78]                                                                                                                                                                                                   |         
    0x00584fad sete sil                                                                                                                                                                                                                      |         sil = (rcx == *((rsp + 0x78))) ? 1 : 0;
    0x00584fb1 call rax                                                                                                                                                                                                                      |         void (*rax)() ();
                                                                                                                                                                                                                                             |     }
    0x00584fb3 mov rax, qword [rsp + 8]                                                                                                                                                                                                      |     rax = *((rsp + 8));
    0x00584fb8 test rax, rax                                                                                                                                                                                                                 |     
    0x00584fbb mov r12, qword [rsp + 0xd0]                                                                                                                                                                                                   |     r12 = *((rsp + 0xd0));
                                                                                                                                                                                                                                             |     if (rax == 0) {
    0x00584fc3 je 0x585013                                                                                                                                                                                                                   |         goto label_17;
                                                                                                                                                                                                                                             |     }
    0x00584fc5 cmp rax, qword [rsp + 0x20]                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (rax == *((rsp + 0x20))) {
    0x00584fca je 0x585000                                                                                                                                                                                                                   |         goto label_18;
                                                                                                                                                                                                                                             |     }
    0x00584fcc mov rbx, qword [rsp + 8]                                                                                                                                                                                                      |     rbx = *((rsp + 8));
    0x00584fd1 jmp 0x584feb                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while (rdi == 0) {
                                                                                                                                                                                                                                             | label_3:
    0x00584fe0 add rbx, 0x10                                                                                                                                                                                                                 |         rbx += 0x10;
    0x00584fe4 cmp qword [rsp + 0x20], rbx                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (*((rsp + 0x20)) == rbx) {
    0x00584fe9 je 0x585000                                                                                                                                                                                                                   |             goto label_18;
                                                                                                                                                                                                                                             |         }
    0x00584feb mov rdi, qword [rbx + 8]                                                                                                                                                                                                      |         rdi = *((rbx + 8));
    0x00584fef test rdi, rdi                                                                                                                                                                                                                 |         
    0x00584ff2 je 0x584fe0                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |     }
    0x00584ff4 call 0x5ae0a0                                                                                                                                                                                                                 |     BloombergLP::bslma::SharedPtrRep::releaseRef() (rdi);
    0x00584ff9 jmp 0x584fe0                                                                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                                                                             | label_18:
    0x00585000 mov rdi, qword [rsp + 0x88]                                                                                                                                                                                                   |     rdi = *((rsp + 0x88));
    0x00585008 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x0058500b mov rsi, qword [rsp + 8]                                                                                                                                                                                                      |     rsi = *((rsp + 8));
    0x00585010 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             | label_17:
    0x00585013 mov rbp, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbp = *((rsp + 0x30));
    0x00585018 test rbp, rbp                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rbp == 0) {
    0x0058501b je 0x58506c                                                                                                                                                                                                                   |         goto label_19;
                                                                                                                                                                                                                                             |     }
    0x0058501d mov rbx, qword [rsp + 0x38]                                                                                                                                                                                                   |     rbx = *((rsp + 0x38));
    0x00585022 cmp rbp, rbx                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (rbp == rbx) {
    0x00585025 je 0x58505e                                                                                                                                                                                                                   |         goto label_20;
                                                                                                                                                                                                                                             |     }
    0x00585027 nop word [rax + rax]                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                             |     do {
    0x00585030 lea rdi, [rbp + 0xb0]                                                                                                                                                                                                         |         
    0x00585037 call 0x58a2f0                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp + 0xb0);
    0x0058503c lea rdi, [rbp + 0x60]                                                                                                                                                                                                         |         
    0x00585040 call 0x58a2f0                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp + 0x60);
    0x00585045 mov rdi, rbp                                                                                                                                                                                                                  |         
    0x00585048 call 0x58a2f0                                                                                                                                                                                                                 |         BloombergLP::bslstl::Function_Rep::~Function_Rep() (rbp);
    0x0058504d add rbp, 0x130                                                                                                                                                                                                                |         rbp += 0x130;
    0x00585054 cmp rbx, rbp                                                                                                                                                                                                                  |         
    0x00585057 jne 0x585030                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (rbx != rbp);
    0x00585059 mov rbp, qword [rsp + 0x30]                                                                                                                                                                                                   |     rbp = *((rsp + 0x30));
                                                                                                                                                                                                                                             | label_20:
    0x0058505e mov rdi, qword [rsp + 0x48]                                                                                                                                                                                                   |     rdi = *((rsp + 0x48));
    0x00585063 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x00585066 mov rsi, rbp                                                                                                                                                                                                                  |     rsi = rbp;
    0x00585069 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             | label_19:
    0x0058506c mov rsi, qword [rsp + 0x140]                                                                                                                                                                                                  |     rsi = *((rsp + 0x140));
    0x00585074 test rsi, rsi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rsi == 0) {
    0x00585077 je 0x584a20                                                                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                                                                             |     }
    0x0058507d mov rdi, qword [rsp + 0x158]                                                                                                                                                                                                  |     rdi = *((rsp + 0x158));
    0x00585085 mov rax, qword [rdi]                                                                                                                                                                                                          |     rax = *(rdi);
    0x00585088 call qword [rax + 0x18]                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
    0x0058508b jmp 0x584a20                                                                                                                                                                                                                  |     goto label_4;
                                                                                                                                                                                                                                             | label_11:
    0x00585090 mov rsi, qword [rsp + 0xa8]                                                                                                                                                                                                   |     rsi = *((rsp + 0xa8));
    0x00585098 test rsi, rsi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rsi != 0) {
    0x0058509b je 0x5850ab                                                                                                                                                                                                                   |         
    0x0058509d mov rdi, qword [rsp + 0xc0]                                                                                                                                                                                                   |         rdi = *((rsp + 0xc0));
    0x005850a5 mov rax, qword [rdi]                                                                                                                                                                                                          |         rax = *(rdi);
    0x005850a8 call qword [rax + 0x18]                                                                                                                                                                                                       |         uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                             |     }
    0x005850ab add rsp, 0x1d8                                                                                                                                                                                                                |     
    0x005850b2 pop rbx                                                                                                                                                                                                                       |     
    0x005850b3 pop r12                                                                                                                                                                                                                       |     
    0x005850b5 pop r13                                                                                                                                                                                                                       |     
    0x005850b7 pop r14                                                                                                                                                                                                                       |     
    0x005850b9 pop r15                                                                                                                                                                                                                       |     
    0x005850bb pop rbp                                                                                                                                                                                                                       |     
    0x005850bc ret                                                                                                                                                                                                                           |     return rax;
                                                                                                                                                                                                                                             | label_13:
    0x005850bd mov edi, 0x5b8db9                                                                                                                                                                                                             |     
    0x005850c2 call 0x58a980                                                                                                                                                                                                                 |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("vector<...>::vector(n,v): vector too long");
                                                                                                                                                                                                                                             | }