; assembly                                                                               | /* r2dec pseudo code output */
                                                                                             | /* bslalg_arrayprimitives.t/none @ 0x4c8b30 */
                                                                                             | #include <stdint.h>
                                                                                             |  
    ; (fcn) sym.void_testCopyConstructWithIterators_void_const__bool__bool__bool_ ()         | uint64_t void_testCopyConstructWithIterators_void_const_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                             |     int64_t var_14h;
                                                                                             |     uint32_t var_18h;
                                                                                             |     int64_t var_20h;
                                                                                             |     int64_t var_22h;
                                                                                             |     int64_t var_28h;
                                                                                             |     int64_t var_2eh;
                                                                                             |     int64_t var_30h;
                                                                                             |     uint32_t var_40h;
                                                                                             |     uint32_t var_48h;
                                                                                             |     int64_t var_50h;
                                                                                             |     uint32_t var_54h;
                                                                                             |     int64_t var_58h;
                                                                                             |     int64_t var_60h;
                                                                                             |     rdx = arg3;
                                                                                             |     rsi = arg2;
                                                                                             |     /* void testCopyConstructWithIterators<void const*>(bool, bool, bool) */
    0x004c8b30 push rbp                                                                      |     
    0x004c8b31 push r15                                                                      |     
    0x004c8b33 push r14                                                                      |     
    0x004c8b35 push r13                                                                      |     
    0x004c8b37 push r12                                                                      |     
    0x004c8b39 push rbx                                                                      |     
    0x004c8b3a sub rsp, 0x68                                                                 |     
    0x004c8b3e mov dword [rsp + 0x54], edx                                                   |     *((rsp + 0x54)) = edx;
    0x004c8b42 mov dword [rsp + 0x40], esi                                                   |     *((rsp + 0x40)) = esi;
    0x004c8b46 cmp byte [rip + 0x24fe49], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004c8b4d je 0x4c8b59                                                                   |         
    0x004c8b4f mov edi, 0x4f6973                                                             |         
    0x004c8b54 call 0x401710                                                                 |         eax = puts ("\t\tfrom same type.");
                                                                                             |     }
    0x004c8b59 xor eax, eax                                                                  |     eax = 0;
    0x004c8b5b jmp 0x4c8b8c                                                                  |     goto label_4;
                                                                                             | label_1:
    0x004c8b60 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8b65 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c8b68 call 0x4e25b0                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c8b6d mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8b72 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c8b75 call 0x4e27f0                                                                 |     voidcleanup<voidconst*>(voidconst**,char const*) ();
    0x004c8b7a mov rax, qword [rsp + 0x48]                                                   |     rax = *((rsp + 0x48));
    0x004c8b7f inc rax                                                                       |     rax++;
    0x004c8b82 cmp rax, 0x1e                                                                 |     
                                                                                             |     if (rax == 0x1e) {
    0x004c8b86 je 0x4c90d6                                                                   |         goto label_5;
                                                                                             |     }
                                                                                             | label_4:
    0x004c8b8c mov qword [rsp + 0x48], rax                                                   |     *((rsp + 0x48)) = rax;
    0x004c8b91 lea rbp, [rax*8]                                                              |     rbp = rax*8;
    0x004c8b99 mov r12, qword [rbp + rbp*4 + 0x4f3c98]                                       |     r12 = *((rbp + rbp*4 + 0x4f3c98));
    0x004c8ba1 mov rdi, r12                                                                  |     
    0x004c8ba4 call 0x401790                                                                 |     eax = strlen (*((rbp + rbp*4 + 0x4f3c98)));
    0x004c8ba9 cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004c8bac jl 0x4c8bd7                                                                   |         
    0x004c8bae mov edi, 0x4f4e04                                                             |         
    0x004c8bb3 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c8bb8 mov esi, 0xfe6                                                                |         esi = 0xfe6;
    0x004c8bbd xor eax, eax                                                                  |         eax = 0;
    0x004c8bbf call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c8bc4 mov eax, dword [rip + 0x24fdce]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c8bca cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c8bcd ja 0x4c8bd7                                                                   |             goto label_6;
                                                                                             |         }
    0x004c8bcf inc eax                                                                       |         eax++;
    0x004c8bd1 mov dword [rip + 0x24fdc1], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_6:
    0x004c8bd7 mov r14d, dword [rbp + rbp*4 + 0x4f3c90]                                      |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004c8bdf movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0]                                    |     r15 = *((rbp + rbp*4 + 0x4f3ca0));
    0x004c8be7 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4]                                       |     ebx = *((rbp + rbp*4 + 0x4f3ca4));
    0x004c8bee movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8]                                    |     r13 = *((rbp + rbp*4 + 0x4f3ca8));
    0x004c8bf6 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0]                                       |     rbp = *((rbp + rbp*4 + 0x4f3cb0));
    0x004c8bfe cmp byte [rip + 0x24fd8b], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8c05 je 0x4c8c26                                                                   |         
    0x004c8c07 mov qword [rsp], rbp                                                          |         *(rsp) = rbp;
    0x004c8c0b mov edi, 0x4f5c41                                                             |         
    0x004c8c10 mov esi, r14d                                                                 |         esi = r14d;
    0x004c8c13 mov rdx, r12                                                                  |         rdx = r12;
    0x004c8c16 mov ecx, r15d                                                                 |         ecx = r15d;
    0x004c8c19 mov r8d, ebx                                                                  |         r8d = ebx;
    0x004c8c1c mov r9d, r13d                                                                 |         r9d = r13d;
    0x004c8c1f xor eax, eax                                                                  |         eax = 0;
    0x004c8c21 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004c8c26 mov dword [rsp + 0x14], r14d                                                  |     *((rsp + 0x14)) = r14d;
    0x004c8c2b mov qword [rsp + 0x18], rbx                                                   |     *((rsp + 0x18)) = rbx;
    0x004c8c30 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8c35 mov rsi, r12                                                                  |     rsi = r12;
    0x004c8c38 call 0x4e24d0                                                                 |     voidconst*&gg<voidconst*>(voidconst**,char const*) ();
    0x004c8c3d mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8c42 mov rsi, r12                                                                  |     rsi = r12;
    0x004c8c45 call 0x4e25b0                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c8c4a mov r12d, dword [rip + 0x24fd53]                                              |     r12d = numCopyCtorCalls;
    0x004c8c51 mov r14d, dword [rip + 0x24fd54]                                              |     r14d = numCharCtorCalls;
    0x004c8c58 cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004c8c5d je 0x4c8d40                                                                   |         goto label_7;
                                                                                             |     }
    0x004c8c63 cmp byte [rip + 0x24fd26], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8c6a je 0x4c8c7f                                                                   |         
    0x004c8c6c cmp dword [rip + 0x24f91d], 0                                                 |         
                                                                                             |         if (*(0x00718590) == 0) {
    0x004c8c73 je 0x4c8c7f                                                                   |             goto label_8;
                                                                                             |         }
    0x004c8c75 mov edi, 0x4f43ea                                                             |         
    0x004c8c7a call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_8:
    0x004c8c7f mov dword [rip + 0x24f907], 0                                                 |     *(0x00718590) = 0;
    0x004c8c89 cmp byte [rip + 0x24fd05], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c8c90 je 0x4c8c9c                                                                   |         
    0x004c8c92 mov edi, 0x4f4411                                                             |         
    0x004c8c97 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004c8c9c mov rax, qword [rip + 0x24fb7d]                                               |     rax = Z;
    0x004c8ca3 mov qword [rsp + 0x20], 0x4f69e0                                              |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c8cac mov qword [rsp + 0x28], rax                                                   |     *((rsp + 0x28)) = rax;
    0x004c8cb1 mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004c8cb9 test rax, rax                                                                 |     
    0x004c8cbc je 0x4c8e05                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_0:
    0x004c8cc2 lea rsi, [r15*8 + 0x74f7e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8cca mov rax, qword [rsp + 0x18]                                                   |         rax = *((rsp + 0x18));
    0x004c8ccf add eax, r15d                                                                 |         eax += r15d;
    0x004c8cd2 cdqe                                                                          |         rax = (int64_t) eax;
    0x004c8cd4 lea rdx, [rax*8 + 0x74f7e0]                                                   |         rdx = rax*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8cdc sub rdx, rsi                                                                  |         rdx -= rsi;
                                                                                             |         if (rdx != 0) {
    0x004c8cdf je 0x4c8cee                                                                   |             
    0x004c8ce1 lea rdi, [r13*8 + 0x74f7e0]                                                   |             
    0x004c8ce9 call 0x401930                                                                 |             memcpy (r13*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u, rsi, rdx);
                                                                                             |         }
    0x004c8cee mov rax, qword [rsp + 0x20]                                                   |         rax = *((rsp + 0x20));
    0x004c8cf3 lea rdi, [rsp + 0x20]                                                         |         rdi = rsp + 0x20;
    0x004c8cf8 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004c8cff call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004c8d02 cmp byte [rip + 0x24fc8c], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004c8d09 je 0x4c8d15                                                                   |             
    0x004c8d0b mov edi, 0x4f4571                                                             |             
    0x004c8d10 call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004c8d15 cmp byte [rip + 0x24fc74], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004c8d1c je 0x4c8ffa                                                                   |             goto label_9;
                                                                                             |         }
    0x004c8d22 mov edi, 0xa                                                                  |         
    0x004c8d27 call 0x401720                                                                 |         putchar (0xa);
    0x004c8d2c mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
    0x004c8d30 jmp 0x4c8fd1                                                                  |         goto label_10;
                                                                                             | label_7:
    0x004c8d40 cmp qword [rip + 0x24fad8], 0                                                 |         
                                                                                             |         if (*(obj.Z) == 0) {
    0x004c8d48 jne 0x4c8d60                                                                  |             
    0x004c8d4a mov rax, qword [rip + 0x288567]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c8d51 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004c8d54 jne 0x4c8d60                                                                  |                 goto label_11;
                                                                                             |             }
    0x004c8d56 call 0x4eede0                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c8d5b nop dword [rax + rax]                                                         |             
                                                                                             |         }
                                                                                             | label_11:
    0x004c8d60 cmp qword [rsp + 0x48], 6                                                     |         
    0x004c8d66 mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
                                                                                             |         if (*((rsp + 0x48)) < 6) {
    0x004c8d6a jb 0x4c8fd1                                                                   |             goto label_10;
                                                                                             |         }
    0x004c8d70 lea rax, [r15*8 + 0x74f7e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8d78 lea rcx, [r13*8 + 0x74f7e0]                                                   |         rcx = r13*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8d80 mov rsi, qword [rsp + 0x18]                                                   |         rsi = *((rsp + 0x18));
    0x004c8d85 lea edx, [rsi + r15]                                                          |         edx = rsi + r15;
    0x004c8d89 movsxd r9, edx                                                                |         r9 = (int64_t) edx;
    0x004c8d8c shl r9, 3                                                                     |         r9 <<= 3;
    0x004c8d90 lea rdi, [r15*8]                                                              |         rdi = r15*8;
    0x004c8d98 mov r10, r9                                                                   |         r10 = r9;
    0x004c8d9b sub r10, rdi                                                                  |         r10 -= rdi;
    0x004c8d9e add r10, 0xfffffffffffffff8                                                   |         r10 += 0xfffffffffffffff8;
    0x004c8da2 cmp r10, 0x18                                                                 |         
                                                                                             |         if (r10 < 0x18) {
    0x004c8da6 jb 0x4c8fb0                                                                   |             goto label_12;
                                                                                             |         }
    0x004c8dac mov dword [rsp + 0x50], r14d                                                  |         *((rsp + 0x50)) = r14d;
    0x004c8db1 mov r11, rbp                                                                  |         r11 = rbp;
    0x004c8db4 lea rbp, [r13*8 + 0x74f7e0]                                                   |         rbp = r13*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8dbc lea edx, [rsi + r15]                                                          |         edx = rsi + r15;
    0x004c8dc0 movsxd rdx, edx                                                               |         rdx = (int64_t) edx;
    0x004c8dc3 lea rbx, [rdx*8 + 0x74f7e0]                                                   |         rbx = rdx*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8dcb cmp rbp, rbx                                                                  |         
                                                                                             |         if (rbp >= rbx) {
    0x004c8dce jae 0x4c8e77                                                                  |             goto label_13;
                                                                                             |         }
    0x004c8dd4 shl rdx, 3                                                                    |         rdx <<= 3;
    0x004c8dd8 sub rdx, rdi                                                                  |         rdx -= rdi;
    0x004c8ddb lea rdx, [rdx + r13*8 + 0x74f7e0]                                             |         rdx = rdx + r13*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8de3 lea rbp, [r15*8 + 0x74f7e0]                                                   |         rbp = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8deb cmp rbp, rdx                                                                  |         
                                                                                             |         if (rbp >= rdx) {
    0x004c8dee jae 0x4c8e77                                                                  |             goto label_13;
                                                                                             |         }
    0x004c8df4 mov rbp, r11                                                                  |         
    0x004c8df7 mov r14d, dword [rsp + 0x50]                                                  |         r14d = *((rsp + 0x50));
    0x004c8dfc mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
    0x004c8e00 jmp 0x4c8fb0                                                                  |         goto label_12;
    0x004c8e05 mov ebx, 1                                                                    |         ebx = 1;
    0x004c8e0a mov rax, qword [rip + 0x2884a7]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c8e11 test rax, rax                                                                 |         
    0x004c8e14 jne 0x4c8cc2                                                                  |         
                                                                                             |     }
    0x004c8e1a call 0x4eede0                                                                 |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c8e1f jmp 0x4c8cc2                                                                  |     goto label_0;
                                                                                             | label_13:
    0x004c8e77 shr r10, 3                                                                    |     r10 >>= 3;
    0x004c8e7b inc r10                                                                       |     r10++;
    0x004c8e7e mov r8, r10                                                                   |     r8 = r10;
    0x004c8e81 and r8, 0xfffffffffffffffc                                                    |     r8 &= 0xfffffffffffffffc;
    0x004c8e85 lea rdx, [r8 - 4]                                                             |     rdx = r8 - 4;
    0x004c8e89 mov rbp, rdx                                                                  |     
    0x004c8e8c shr rbp, 2                                                                    |     rbp >>= 2;
    0x004c8e90 inc rbp                                                                       |     rbp++;
    0x004c8e93 mov ebx, ebp                                                                  |     ebx = ebp;
    0x004c8e95 and ebx, 3                                                                    |     ebx &= 3;
    0x004c8e98 cmp rdx, 0xc                                                                  |     
                                                                                             |     if (rdx < 0xc) {
    0x004c8e9c jae 0x4c8ea5                                                                  |         
    0x004c8e9e xor edx, edx                                                                  |         edx = 0;
    0x004c8ea0 jmp 0x4c8f4a                                                                  |         goto label_14;
                                                                                             |     }
    0x004c8ea5 and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004c8ea9 neg rbp                                                                       |     rbp = -rbp;
    0x004c8eac xor edx, edx                                                                  |     edx = 0;
    0x004c8eae nop                                                                           |     
                                                                                             |     do {
    0x004c8eb0 movups xmm0, xmmword [rdi + rdx*8 + 0x74f7e0]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u]");
    0x004c8eb8 movups xmm1, xmmword [rdi + rdx*8 + 0x74f7f0]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f7f0]");
    0x004c8ec0 lea rsi, [r13*8]                                                              |         rsi = r13*8;
    0x004c8ec8 movups xmmword [rsi + rdx*8 + 0x74f7e0], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c8ed0 movups xmmword [rsi + rdx*8 + 0x74f7f0], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f7f0], xmm1");
    0x004c8ed8 movups xmm0, xmmword [rdi + rdx*8 + 0x74f800]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f800]");
    0x004c8ee0 movups xmm1, xmmword [rdi + rdx*8 + 0x74f810]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f810]");
    0x004c8ee8 movups xmmword [rsi + rdx*8 + 0x74f800], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f800], xmm0");
    0x004c8ef0 movups xmmword [rsi + rdx*8 + 0x74f810], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f810], xmm1");
    0x004c8ef8 movups xmm0, xmmword [rdi + rdx*8 + 0x74f820]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f820]");
    0x004c8f00 movups xmm1, xmmword [rdi + rdx*8 + 0x74f830]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f830]");
    0x004c8f08 movups xmmword [rsi + rdx*8 + 0x74f820], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f820], xmm0");
    0x004c8f10 movups xmmword [rsi + rdx*8 + 0x74f830], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f830], xmm1");
    0x004c8f18 movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f840]                                 |         __asm ("movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f840]");
    0x004c8f21 movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f850]                                 |         __asm ("movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f850]");
    0x004c8f2a movdqu xmmword [rsi + rdx*8 + 0x74f840], xmm0                                 |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f840], xmm0");
    0x004c8f33 movdqu xmmword [rsi + rdx*8 + 0x74f850], xmm1                                 |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f850], xmm1");
    0x004c8f3c add rdx, 0x10                                                                 |         rdx += 0x10;
    0x004c8f40 add rbp, 4                                                                    |         rbp += 4;
    0x004c8f44 jne 0x4c8eb0                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_14:
    0x004c8f4a test rbx, rbx                                                                 |     
                                                                                             |     if (rbx == 0) {
    0x004c8f4d je 0x4c8f90                                                                   |         goto label_15;
                                                                                             |     }
    0x004c8f4f shl r13, 3                                                                    |     r13 <<= 3;
    0x004c8f53 lea rbp, [r13 + rdx*8 + 0x74f7f0]                                             |     rbp = r13 + rdx*8 + 0x74f7f0;
    0x004c8f5b lea rdx, [rdi + rdx*8 + 0x74f7f0]                                             |     rdx = rdi + rdx*8 + 0x74f7f0;
    0x004c8f63 shl rbx, 5                                                                    |     rbx <<= 5;
    0x004c8f67 xor edi, edi                                                                  |     edi = 0;
    0x004c8f69 nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004c8f70 movdqu xmm0, xmmword [rdx + rdi - 0x10]                                       |         __asm ("movdqu xmm0, xmmword [rdx + rdi - 0x10]");
    0x004c8f76 movdqu xmm1, xmmword [rdx + rdi]                                              |         __asm ("movdqu xmm1, xmmword [rdx + rdi]");
    0x004c8f7b movdqu xmmword [rbp + rdi - 0x10], xmm0                                       |         __asm ("movdqu xmmword [rbp + rdi - 0x10], xmm0");
    0x004c8f81 movdqu xmmword [rbp + rdi], xmm1                                              |         __asm ("movdqu xmmword [rbp + rdi], xmm1");
    0x004c8f87 add rdi, 0x20                                                                 |         rdi += 0x20;
    0x004c8f8b cmp rbx, rdi                                                                  |         
    0x004c8f8e jne 0x4c8f70                                                                  |         
                                                                                             |     } while (rbx != rdi);
                                                                                             | label_15:
    0x004c8f90 cmp r10, r8                                                                   |     
    0x004c8f93 mov rbp, r11                                                                  |     
    0x004c8f96 mov r14d, dword [rsp + 0x50]                                                  |     r14d = *((rsp + 0x50));
    0x004c8f9b mov ebx, dword [rsp + 0x14]                                                   |     ebx = *((rsp + 0x14));
                                                                                             |     if (r10 == r8) {
    0x004c8f9f je 0x4c8fd1                                                                   |         goto label_10;
                                                                                             |     }
    0x004c8fa1 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
    0x004c8fa5 lea rcx, [rcx + r8*8]                                                         |     rcx = rcx + r8*8;
    0x004c8fa9 nop dword [rax]                                                               |     
                                                                                             | label_12:
    0x004c8fb0 sub r9, rax                                                                   |     r9 -= rax;
    0x004c8fb3 lea rdx, [r9 + 0x74f7e0]                                                      |     rdx = r9 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8fba xor esi, esi                                                                  |     esi = 0;
    0x004c8fbc nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004c8fc0 mov rdi, qword [rax + rsi]                                                    |         rdi = *((rax + rsi));
    0x004c8fc4 mov qword [rcx + rsi], rdi                                                    |         *((rcx + rsi)) = rdi;
    0x004c8fc8 add rsi, 8                                                                    |         rsi += 8;
    0x004c8fcc cmp rdx, rsi                                                                  |         
    0x004c8fcf jne 0x4c8fc0                                                                  |         
                                                                                             |     } while (rdx != rsi);
                                                                                             | label_10:
    0x004c8fd1 cmp byte [rip + 0x24f9b8], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8fd8 je 0x4c8ffa                                                                   |         
    0x004c8fda mov edx, dword [rip + 0x24f9c4]                                               |         edx = numCopyCtorCalls;
    0x004c8fe0 sub edx, r12d                                                                 |         edx -= r12d;
    0x004c8fe3 mov ecx, dword [rip + 0x24f9c3]                                               |         ecx = numCharCtorCalls;
    0x004c8fe9 sub ecx, r14d                                                                 |         ecx -= r14d;
    0x004c8fec mov edi, 0x4f5db4                                                             |         
    0x004c8ff1 mov esi, ebx                                                                  |         esi = ebx;
    0x004c8ff3 xor eax, eax                                                                  |         eax = 0;
    0x004c8ff5 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_9:
    0x004c8ffa cmp byte [rsp + 0x40], 0                                                      |     
                                                                                             |     if (*((rsp + 0x40)) == 0) {
    0x004c8fff je 0x4c9060                                                                   |         goto label_16;
                                                                                             |     }
    0x004c9001 cmp r12d, dword [rip + 0x24f99c]                                              |     
                                                                                             |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004c9008 je 0x4c9033                                                                   |         
    0x004c900a mov edi, 0x4f4e04                                                             |         
    0x004c900f mov edx, 0x4f5176                                                             |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c9014 mov esi, 0x1005                                                               |         esi = 0x1005;
    0x004c9019 xor eax, eax                                                                  |         eax = 0;
    0x004c901b call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c9020 mov eax, dword [rip + 0x24f972]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c9026 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c9029 ja 0x4c9033                                                                   |             goto label_17;
                                                                                             |         }
    0x004c902b inc eax                                                                       |         eax++;
    0x004c902d mov dword [rip + 0x24f965], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_17:
    0x004c9033 cmp r14d, dword [rip + 0x24f972]                                              |     
                                                                                             |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004c903a je 0x4c8b60                                                                   |         goto label_1;
                                                                                             |     }
    0x004c9040 mov edi, 0x4f4e04                                                             |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004c9045 mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c904a mov esi, 0x1006                                                               |     esi = 0x1006;
    0x004c904f jmp 0x4c90b3                                                                  |     goto label_18;
                                                                                             | label_16:
    0x004c9060 add r12d, dword [rsp + 0x18]                                                  |     r12d += *((rsp + 0x18));
    0x004c9065 cmp r12d, dword [rip + 0x24f938]                                              |     
                                                                                             |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004c906c jle 0x4c9097                                                                  |         
    0x004c906e mov edi, 0x4f4e04                                                             |         
    0x004c9073 mov edx, 0x4f5e02                                                             |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004c9078 mov esi, 0x1009                                                               |         esi = 0x1009;
    0x004c907d xor eax, eax                                                                  |         eax = 0;
    0x004c907f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c9084 mov eax, dword [rip + 0x24f90e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c908a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c908d ja 0x4c9097                                                                   |             goto label_19;
                                                                                             |         }
    0x004c908f inc eax                                                                       |         eax++;
    0x004c9091 mov dword [rip + 0x24f901], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_19:
    0x004c9097 cmp r14d, dword [rip + 0x24f90e]                                              |     
                                                                                             |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004c909e je 0x4c8b60                                                                   |         goto label_1;
                                                                                             |     }
    0x004c90a4 mov edi, 0x4f4e04                                                             |     
    0x004c90a9 mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c90ae mov esi, 0x100a                                                               |     esi = 0x100a;
                                                                                             | label_18:
    0x004c90b3 xor eax, eax                                                                  |     eax = 0;
    0x004c90b5 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c90ba mov eax, dword [rip + 0x24f8d8]                                               |     eax = (anonymous namespace)::testStatus;
    0x004c90c0 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004c90c3 ja 0x4c8b60                                                                   |         goto label_1;
                                                                                             |     }
    0x004c90c9 inc eax                                                                       |     eax++;
    0x004c90cb mov dword [rip + 0x24f8c7], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c90d1 jmp 0x4c8b60                                                                  |     goto label_1;
                                                                                             | label_5:
    0x004c90d6 cmp byte [rip + 0x24f8b9], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004c90dd je 0x4c90e9                                                                   |         
    0x004c90df mov edi, 0x4f695c                                                             |         
    0x004c90e4 call 0x401710                                                                 |         puts ("\t\tfrom different type.");
                                                                                             |     }
    0x004c90e9 xor r12d, r12d                                                                |     r12d = 0;
    0x004c90ec jmp 0x4c9117                                                                  |     goto label_20;
                                                                                             | label_3:
    0x004c90f0 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c90f5 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004c90f8 call 0x4e25b0                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c90fd mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c9102 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004c9105 call 0x4e27f0                                                                 |     voidcleanup<voidconst*>(voidconst**,char const*) ();
    0x004c910a inc r12                                                                       |     r12++;
    0x004c910d cmp r12, 0x1e                                                                 |     
                                                                                             |     if (r12 == 0x1e) {
    0x004c9111 je 0x4c973d                                                                   |         goto label_21;
                                                                                             |     }
                                                                                             | label_20:
    0x004c9117 lea rbx, [r12*8]                                                              |     rbx = r12*8;
    0x004c911f mov rbp, qword [rbx + rbx*4 + 0x4f3c98]                                       |     rbp = *((rbx + rbx*4 + 0x4f3c98));
    0x004c9127 mov rdi, rbp                                                                  |     
    0x004c912a call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004c912f cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004c9132 jl 0x4c915d                                                                   |         
    0x004c9134 mov edi, 0x4f4e04                                                             |         
    0x004c9139 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c913e mov esi, 0x1019                                                               |         esi = 0x1019;
    0x004c9143 xor eax, eax                                                                  |         eax = 0;
    0x004c9145 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c914a mov eax, dword [rip + 0x24f848]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c9150 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c9153 ja 0x4c915d                                                                   |             goto label_22;
                                                                                             |         }
    0x004c9155 inc eax                                                                       |         eax++;
    0x004c9157 mov dword [rip + 0x24f83b], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_22:
    0x004c915d mov rdi, rbp                                                                  |     
    0x004c9160 call 0x401790                                                                 |     rax = strlen (rbp);
    0x004c9165 cmp rax, 0x14                                                                 |     
                                                                                             |     if (rax >= 0x14) {
    0x004c9169 jb 0x4c9194                                                                   |         
    0x004c916b mov edi, 0x4f4e04                                                             |         
    0x004c9170 mov edx, 0x4f5e26                                                             |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004c9175 mov esi, 0x101c                                                               |         esi = 0x101c;
    0x004c917a xor eax, eax                                                                  |         eax = 0;
    0x004c917c call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c9181 mov eax, dword [rip + 0x24f811]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c9187 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c918a ja 0x4c9194                                                                   |             goto label_23;
                                                                                             |         }
    0x004c918c inc eax                                                                       |         eax++;
    0x004c918e mov dword [rip + 0x24f804], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_23:
    0x004c9194 mov qword [rsp + 0x18], r12                                                   |     *((rsp + 0x18)) = r12;
    0x004c9199 pxor xmm0, xmm0                                                               |     xmm0 = 0;
    0x004c919d movdqa xmmword [rsp + 0x20], xmm0                                             |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004c91a3 mov dword [rsp + 0x30], 0                                                     |     *((rsp + 0x30)) = 0;
    0x004c91ab mov al, byte [rbp]                                                            |     al = *(rbp);
    0x004c91ae test al, al                                                                   |     
                                                                                             |     if (al == 0) {
    0x004c91b0 je 0x4c91d0                                                                   |         goto label_24;
                                                                                             |     }
    0x004c91b2 xor ecx, ecx                                                                  |     ecx = 0;
    0x004c91b4 nop word cs:[rax + rax]                                                       |     
    0x004c91be nop                                                                           |     
                                                                                             |     do {
    0x004c91c0 mov byte [rsp + rcx + 0x20], al                                               |         *((rsp + rcx + 0x20)) = al;
    0x004c91c4 movzx eax, byte [rbp + rcx + 1]                                               |         eax = *((rbp + rcx + 1));
    0x004c91c9 inc rcx                                                                       |         rcx++;
    0x004c91cc test al, al                                                                   |         
    0x004c91ce jne 0x4c91c0                                                                  |         
                                                                                             |     } while (al != 0);
                                                                                             | label_24:
    0x004c91d0 mov r14d, dword [rbx + rbx*4 + 0x4f3c90]                                      |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004c91d8 movsxd r13, dword [rbx + rbx*4 + 0x4f3ca0]                                    |     r13 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004c91e0 movsxd r12, dword [rbx + rbx*4 + 0x4f3ca4]                                    |     r12 = *((rbx + rbx*4 + 0x4f3ca4));
    0x004c91e8 movsxd r15, dword [rbx + rbx*4 + 0x4f3ca8]                                    |     r15 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004c91f0 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                       |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004c91f8 cmp byte [rip + 0x24f791], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c91ff je 0x4c9220                                                                   |         
    0x004c9201 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004c9205 mov edi, 0x4f5c41                                                             |         
    0x004c920a mov esi, r14d                                                                 |         esi = r14d;
    0x004c920d mov rdx, rbp                                                                  |         rdx = rbp;
    0x004c9210 mov ecx, r13d                                                                 |         ecx = r13d;
    0x004c9213 mov r8d, r12d                                                                 |         r8d = r12d;
    0x004c9216 mov r9d, r15d                                                                 |         r9d = r15d;
    0x004c9219 xor eax, eax                                                                  |         eax = 0;
    0x004c921b call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004c9220 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c9225 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c9228 call 0x4e24d0                                                                 |     voidconst*&gg<voidconst*>(voidconst**,char const*) ();
    0x004c922d mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c9232 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c9235 call 0x4e25b0                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c923a mov eax, dword [rip + 0x24f764]                                               |     eax = numCopyCtorCalls;
    0x004c9240 mov dword [rsp + 0x48], eax                                                   |     *((rsp + 0x48)) = eax;
    0x004c9244 mov eax, dword [rip + 0x24f762]                                               |     eax = numCharCtorCalls;
    0x004c924a mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004c924e cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004c9253 je 0x4c9320                                                                   |         goto label_25;
                                                                                             |     }
    0x004c9259 cmp byte [rip + 0x24f730], 0                                                  |     
    0x004c9260 mov ebp, r14d                                                                 |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c9263 je 0x4c9278                                                                   |         
    0x004c9265 cmp dword [rip + 0x24f328], 0                                                 |         
                                                                                             |         if (*(obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::firstTime) == 0) {
    0x004c926c je 0x4c9278                                                                   |             goto label_26;
                                                                                             |         }
    0x004c926e mov edi, 0x4f43ea                                                             |         
    0x004c9273 call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_26:
    0x004c9278 mov dword [rip + 0x24f312], 0                                                 |     *(obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::firstTime) = 0;
    0x004c9282 cmp byte [rip + 0x24f70c], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c9289 je 0x4c9295                                                                   |         
    0x004c928b mov edi, 0x4f4411                                                             |         
    0x004c9290 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004c9295 mov rax, qword [rip + 0x24f584]                                               |     rax = Z;
    0x004c929c mov qword [rsp + 0x58], 0x4f69e0                                              |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c92a5 mov qword [rsp + 0x60], rax                                                   |     *((rsp + 0x60)) = rax;
    0x004c92aa mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004c92b2 test rax, rax                                                                 |     
    0x004c92b5 je 0x4c93ad                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_2:
    0x004c92bb cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004c92c1 jb 0x4c9691                                                                   |             goto label_27;
                                                                                             |         }
    0x004c92c7 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004c92cc lea rsi, [r15*8 + 0x74f7e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c92d4 lea eax, [r13 + r12]                                                          |         eax = r13 + r12;
    0x004c92d9 movsxd r9, eax                                                                |         r9 = (int64_t) eax;
    0x004c92dc mov r10, r9                                                                   |         r10 = r9;
    0x004c92df sub r10, r13                                                                  |         r10 -= r13;
    0x004c92e2 cmp r10, 4                                                                    |         
                                                                                             |         if (r10 < 4) {
    0x004c92e6 jb 0x4c9676                                                                   |             goto label_28;
                                                                                             |         }
    0x004c92ec mov r11, rbx                                                                  |         r11 = rbx;
    0x004c92ef mov r8, r10                                                                   |         r8 = r10;
    0x004c92f2 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004c92f6 lea rax, [r8 - 4]                                                             |         rax = r8 - 4;
    0x004c92fa mov rbp, rax                                                                  |         
    0x004c92fd shr rbp, 2                                                                    |         rbp >>= 2;
    0x004c9301 inc rbp                                                                       |         rbp++;
    0x004c9304 mov edi, ebp                                                                  |         edi = ebp;
    0x004c9306 and edi, 3                                                                    |         edi &= 3;
    0x004c9309 cmp rax, 0xc                                                                  |         
                                                                                             |         if (rax >= 0xc) {
    0x004c930d jae 0x4c9566                                                                  |             goto label_29;
                                                                                             |         }
    0x004c9313 xor ebx, ebx                                                                  |         ebx = 0;
    0x004c9315 jmp 0x4c9615                                                                  |         goto label_30;
                                                                                             | label_25:
    0x004c9320 cmp qword [rip + 0x24f4f8], 0                                                 |         
    0x004c9328 mov ebp, r14d                                                                 |         
    0x004c932b mov r11, r12                                                                  |         r11 = r12;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004c932e jne 0x4c9350                                                                  |             
    0x004c9330 mov rax, qword [rip + 0x287f81]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c9337 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004c933a jne 0x4c9350                                                                  |                 goto label_31;
                                                                                             |             }
    0x004c933c call 0x4eede0                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c9341 mov r11, r12                                                                  |             r11 = r12;
    0x004c9344 nop word cs:[rax + rax]                                                       |             
    0x004c934e nop                                                                           |             
                                                                                             |         }
                                                                                             | label_31:
    0x004c9350 mov r12, qword [rsp + 0x18]                                                   |         r12 = *((rsp + 0x18));
    0x004c9355 cmp r12, 6                                                                    |         
                                                                                             |         if (r12 < 6) {
    0x004c9359 jb 0x4c96d0                                                                   |             goto label_32;
                                                                                             |         }
    0x004c935f lea rax, [r15*8 + 0x74f7e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c9367 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004c936c add r11, r13                                                                  |         r11 += r13;
    0x004c936f mov r9, r11                                                                   |         r9 = r11;
    0x004c9372 sub r9, r13                                                                   |         r9 -= r13;
    0x004c9375 cmp r9, 4                                                                     |         
                                                                                             |         if (r9 < 4) {
    0x004c9379 jb 0x4c953a                                                                   |             goto label_33;
                                                                                             |         }
    0x004c937f mov r10, rbx                                                                  |         r10 = rbx;
    0x004c9382 mov r8, r9                                                                    |         r8 = r9;
    0x004c9385 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004c9389 lea rsi, [r8 - 4]                                                             |         rsi = r8 - 4;
    0x004c938d mov rdi, rsi                                                                  |         rdi = rsi;
    0x004c9390 shr rdi, 2                                                                    |         rdi >>= 2;
    0x004c9394 inc rdi                                                                       |         rdi++;
    0x004c9397 mov ebp, edi                                                                  |         
    0x004c9399 and ebp, 3                                                                    |         ebp &= 3;
    0x004c939c cmp rsi, 0xc                                                                  |         
                                                                                             |         if (rsi >= 0xc) {
    0x004c93a0 jae 0x4c942d                                                                  |             goto label_34;
                                                                                             |         }
    0x004c93a6 xor ebx, ebx                                                                  |         ebx = 0;
    0x004c93a8 jmp 0x4c94d5                                                                  |         goto label_35;
    0x004c93ad mov eax, 1                                                                    |         eax = 1;
    0x004c93b2 mov qword [rsp + 0x40], rax                                                   |         *((rsp + 0x40)) = rax;
    0x004c93b7 mov rax, qword [rip + 0x287efa]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c93be test rax, rax                                                                 |         
    0x004c93c1 jne 0x4c92bb                                                                  |         
                                                                                             |     }
    0x004c93c7 call 0x4eede0                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c93cc jmp 0x4c92bb                                                                  |     goto label_2;
                                                                                             | label_34:
    0x004c942d lea rdx, [rsp + 0x2e]                                                         |     rdx = rsp + 0x2e;
    0x004c9432 lea rsi, [rdx + r13]                                                          |     rsi = rdx + r13;
    0x004c9436 and rdi, 0xfffffffffffffffc                                                   |     rdi &= 0xfffffffffffffffc;
    0x004c943a neg rdi                                                                       |     rdi = -rdi;
    0x004c943d xor ebx, ebx                                                                  |     ebx = 0;
    0x004c943f nop                                                                           |     
                                                                                             |     do {
    0x004c9440 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004c9447 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004c944e lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004c9456 movdqu xmmword [rdx + rbx*8 + 0x74f7e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c945f movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1");
    0x004c9468 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004c946f pmovsxbq xmm1, word [rsi + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004c9476 movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0");
    0x004c947f movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1");
    0x004c9488 pmovsxbq xmm0, word [rsi + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004c948f pmovsxbq xmm1, word [rsi + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004c9496 movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0");
    0x004c949f movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1");
    0x004c94a8 pmovsxbq xmm0, word [rsi + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004c94af pmovsxbq xmm1, word [rsi + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004c94b5 movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0");
    0x004c94be movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1");
    0x004c94c7 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004c94cb add rdi, 4                                                                    |         rdi += 4;
    0x004c94cf jne 0x4c9440                                                                  |         
                                                                                             |     } while (rdi != 0);
                                                                                             | label_35:
    0x004c94d5 test rbp, rbp                                                                 |     
                                                                                             |     if (rbp == 0) {
    0x004c94d8 je 0x4c9524                                                                   |         goto label_36;
                                                                                             |     }
    0x004c94da add r13, rbx                                                                  |     r13 += rbx;
    0x004c94dd lea rdx, [rsp + 0x22]                                                         |     rdx = rsp + 0x22;
    0x004c94e2 add r13, rdx                                                                  |     r13 += rdx;
    0x004c94e5 shl r15, 3                                                                    |     r15 <<= 3;
    0x004c94e9 lea rsi, [r15 + rbx*8 + 0x74f7f0]                                             |     rsi = r15 + rbx*8 + 0x74f7f0;
    0x004c94f1 shl rbp, 2                                                                    |     rbp <<= 2;
    0x004c94f5 xor edi, edi                                                                  |     edi = 0;
    0x004c94f7 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c9500 pmovsxbq xmm0, word [r13 + rdi - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004c9508 pmovsxbq xmm1, word [r13 + rdi]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004c9510 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004c9516 movdqu xmmword [rsi + rdi*8], xmm1                                            |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004c951b add rdi, 4                                                                    |         rdi += 4;
    0x004c951f cmp rbp, rdi                                                                  |         
    0x004c9522 jne 0x4c9500                                                                  |         
                                                                                             |     } while (rbp != rdi);
                                                                                             | label_36:
    0x004c9524 cmp r9, r8                                                                    |     
    0x004c9527 mov rbx, r10                                                                  |     rbx = r10;
    0x004c952a mov ebp, r14d                                                                 |     
                                                                                             |     if (r9 == r8) {
    0x004c952d je 0x4c96d0                                                                   |         goto label_32;
                                                                                             |     }
    0x004c9533 add rcx, r8                                                                   |     rcx += r8;
    0x004c9536 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
                                                                                             | label_33:
    0x004c953a sub r11, rcx                                                                  |     r11 -= rcx;
    0x004c953d lea rdx, [rsp + r11 + 0x20]                                                   |     rdx = rsp + r11 + 0x20;
    0x004c9542 xor esi, esi                                                                  |     esi = 0;
    0x004c9544 nop word cs:[rax + rax]                                                       |     
    0x004c954e nop                                                                           |     
                                                                                             |     do {
    0x004c9550 movsx rdi, byte [rcx + rsi]                                                   |         rdi = *((rcx + rsi));
    0x004c9555 mov qword [rax + rsi*8], rdi                                                  |         *((rax + rsi*8)) = rdi;
    0x004c9559 inc rsi                                                                       |         rsi++;
    0x004c955c cmp rdx, rsi                                                                  |         
    0x004c955f jne 0x4c9550                                                                  |         
                                                                                             |     } while (rdx != rsi);
    0x004c9561 jmp 0x4c96d0                                                                  |     goto label_32;
                                                                                             | label_29:
    0x004c9566 lea rax, [rsp + 0x2e]                                                         |     rax = rsp + 0x2e;
    0x004c956b add rax, r13                                                                  |     rax += r13;
    0x004c956e and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004c9572 neg rbp                                                                       |     rbp = -rbp;
    0x004c9575 xor ebx, ebx                                                                  |     ebx = 0;
    0x004c9577 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c9580 pmovsxbq xmm0, word [rax + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004c9587 pmovsxbq xmm1, word [rax + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004c958e lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004c9596 movdqu xmmword [rdx + rbx*8 + 0x74f7e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c959f movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1");
    0x004c95a8 pmovsxbq xmm0, word [rax + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004c95af pmovsxbq xmm1, word [rax + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004c95b6 movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0");
    0x004c95bf movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1");
    0x004c95c8 pmovsxbq xmm0, word [rax + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004c95cf pmovsxbq xmm1, word [rax + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004c95d6 movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0");
    0x004c95df movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1");
    0x004c95e8 pmovsxbq xmm0, word [rax + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004c95ef pmovsxbq xmm1, word [rax + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004c95f5 movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0");
    0x004c95fe movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1");
    0x004c9607 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004c960b add rbp, 4                                                                    |         rbp += 4;
    0x004c960f jne 0x4c9580                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_30:
    0x004c9615 test rdi, rdi                                                                 |     
                                                                                             |     if (rdi == 0) {
    0x004c9618 je 0x4c9664                                                                   |         goto label_37;
                                                                                             |     }
    0x004c961a add r13, rbx                                                                  |     r13 += rbx;
    0x004c961d lea rax, [rsp + 0x22]                                                         |     rax = rsp + 0x22;
    0x004c9622 add r13, rax                                                                  |     r13 += rax;
    0x004c9625 shl r15, 3                                                                    |     r15 <<= 3;
    0x004c9629 lea rax, [r15 + rbx*8 + 0x74f7f0]                                             |     rax = r15 + rbx*8 + 0x74f7f0;
    0x004c9631 shl rdi, 2                                                                    |     rdi <<= 2;
    0x004c9635 xor ebp, ebp                                                                  |     ebp = 0;
    0x004c9637 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c9640 pmovsxbq xmm0, word [r13 + rbp - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004c9648 pmovsxbq xmm1, word [r13 + rbp]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004c9650 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004c9656 movdqu xmmword [rax + rbp*8], xmm1                                            |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004c965b add rbp, 4                                                                    |         rbp += 4;
    0x004c965f cmp rdi, rbp                                                                  |         
    0x004c9662 jne 0x4c9640                                                                  |         
                                                                                             |     } while (rdi != rbp);
                                                                                             | label_37:
    0x004c9664 cmp r10, r8                                                                   |     
    0x004c9667 mov rbx, r11                                                                  |     rbx = r11;
    0x004c966a mov ebp, r14d                                                                 |     
                                                                                             |     if (r10 == r8) {
    0x004c966d je 0x4c9691                                                                   |         goto label_27;
                                                                                             |     }
    0x004c966f add rcx, r8                                                                   |     rcx += r8;
    0x004c9672 lea rsi, [rsi + r8*8]                                                         |     rsi = rsi + r8*8;
                                                                                             | label_28:
    0x004c9676 sub r9, rcx                                                                   |     r9 -= rcx;
    0x004c9679 lea rax, [rsp + r9 + 0x20]                                                    |     rax = rsp + r9 + 0x20;
    0x004c967e xor edi, edi                                                                  |     edi = 0;
                                                                                             |     do {
    0x004c9680 movsx rdx, byte [rcx + rdi]                                                   |         rdx = *((rcx + rdi));
    0x004c9685 mov qword [rsi + rdi*8], rdx                                                  |         *((rsi + rdi*8)) = rdx;
    0x004c9689 inc rdi                                                                       |         rdi++;
    0x004c968c cmp rax, rdi                                                                  |         
    0x004c968f jne 0x4c9680                                                                  |         
                                                                                             |     } while (rax != rdi);
                                                                                             | label_27:
    0x004c9691 mov rax, qword [rsp + 0x58]                                                   |     rax = *((rsp + 0x58));
    0x004c9696 lea rdi, [rsp + 0x58]                                                         |     rdi = rsp + 0x58;
    0x004c969b mov rsi, 0xffffffffffffffff                                                   |     rsi = 0xffffffffffffffff;
    0x004c96a2 call qword [rax + 0x10]                                                       |     uint64_t (*rax + 0x10)() ();
    0x004c96a5 cmp byte [rip + 0x24f2e9], 0                                                  |     
    0x004c96ac mov r12, qword [rsp + 0x18]                                                   |     r12 = *((rsp + 0x18));
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c96b1 je 0x4c96bd                                                                   |         
    0x004c96b3 mov edi, 0x4f4571                                                             |         
    0x004c96b8 call 0x401710                                                                 |         puts ("\t\tEnd bslma exception test.");
                                                                                             |     }
    0x004c96bd cmp byte [rip + 0x24f2cc], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c96c4 je 0x4c96fb                                                                   |         
    0x004c96c6 mov edi, 0xa                                                                  |         
    0x004c96cb call 0x401720                                                                 |         eax = putchar (0xa);
                                                                                             | label_32:
    0x004c96d0 cmp byte [rip + 0x24f2b9], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004c96d7 je 0x4c96fb                                                                   |             goto label_38;
                                                                                             |         }
    0x004c96d9 mov edx, dword [rip + 0x24f2c5]                                               |         edx = numCopyCtorCalls;
    0x004c96df sub edx, dword [rsp + 0x48]                                                   |         edx -= *((rsp + 0x48));
    0x004c96e3 mov ecx, dword [rip + 0x24f2c3]                                               |         ecx = numCharCtorCalls;
    0x004c96e9 sub ecx, dword [rsp + 0x14]                                                   |         ecx -= *((rsp + 0x14));
    0x004c96ed mov edi, 0x4f5db4                                                             |         
    0x004c96f2 mov esi, ebp                                                                  |         esi = ebp;
    0x004c96f4 xor eax, eax                                                                  |         eax = 0;
    0x004c96f6 call 0x401680                                                                 |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_38:
    0x004c96fb mov eax, dword [rsp + 0x48]                                                   |     eax = *((rsp + 0x48));
    0x004c96ff cmp eax, dword [rip + 0x24f29f]                                               |     
                                                                                             |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004c9705 je 0x4c90f0                                                                   |         goto label_3;
                                                                                             |     }
    0x004c970b mov edi, 0x4f4e04                                                             |     
    0x004c9710 mov edx, 0x4f5176                                                             |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c9715 mov esi, 0x103f                                                               |     esi = 0x103f;
    0x004c971a xor eax, eax                                                                  |     eax = 0;
    0x004c971c call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c9721 mov eax, dword [rip + 0x24f271]                                               |     eax = (anonymous namespace)::testStatus;
    0x004c9727 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004c972a ja 0x4c90f0                                                                   |         goto label_3;
                                                                                             |     }
    0x004c9730 inc eax                                                                       |     eax++;
    0x004c9732 mov dword [rip + 0x24f260], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c9738 jmp 0x4c90f0                                                                  |     goto label_3;
                                                                                             | label_21:
    0x004c973d add rsp, 0x68                                                                 |     
    0x004c9741 pop rbx                                                                       |     
    0x004c9742 pop r12                                                                       |     
    0x004c9744 pop r13                                                                       |     
    0x004c9746 pop r14                                                                       |     
    0x004c9748 pop r15                                                                       |     
    0x004c974a pop rbp                                                                       |     
    0x004c974b ret                                                                           |     return rax;
                                                                                             | }