; assembly                                                                               | /* r2dec pseudo code output */
                                                                                             | /* bslalg_arrayprimitives.t/none @ 0x4ca3d0 */
                                                                                             | #include <stdint.h>
                                                                                             |  
    ; (fcn) sym.void_testCopyConstructWithIterators_int_const__bool__bool__bool_ ()          | uint64_t void_testCopyConstructWithIterators_int_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<int const*>(bool, bool, bool) */
    0x004ca3d0 push rbp                                                                      |     
    0x004ca3d1 push r15                                                                      |     
    0x004ca3d3 push r14                                                                      |     
    0x004ca3d5 push r13                                                                      |     
    0x004ca3d7 push r12                                                                      |     
    0x004ca3d9 push rbx                                                                      |     
    0x004ca3da sub rsp, 0x68                                                                 |     
    0x004ca3de mov dword [rsp + 0x54], edx                                                   |     *((rsp + 0x54)) = edx;
    0x004ca3e2 mov dword [rsp + 0x40], esi                                                   |     *((rsp + 0x40)) = esi;
    0x004ca3e6 cmp byte [rip + 0x24e5a9], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004ca3ed je 0x4ca3f9                                                                   |         
    0x004ca3ef mov edi, 0x4f6973                                                             |         
    0x004ca3f4 call 0x401710                                                                 |         eax = puts ("\t\tfrom same type.");
                                                                                             |     }
    0x004ca3f9 xor eax, eax                                                                  |     eax = 0;
    0x004ca3fb jmp 0x4ca42c                                                                  |     goto label_4;
                                                                                             | label_1:
    0x004ca400 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca405 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca408 call 0x4e2fb0                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca40d mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca412 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca415 call 0x4e31f0                                                                 |     voidcleanup<intconst*>(intconst**,char const*) ();
    0x004ca41a mov rax, qword [rsp + 0x48]                                                   |     rax = *((rsp + 0x48));
    0x004ca41f inc rax                                                                       |     rax++;
    0x004ca422 cmp rax, 0x1e                                                                 |     
                                                                                             |     if (rax == 0x1e) {
    0x004ca426 je 0x4ca976                                                                   |         goto label_5;
                                                                                             |     }
                                                                                             | label_4:
    0x004ca42c mov qword [rsp + 0x48], rax                                                   |     *((rsp + 0x48)) = rax;
    0x004ca431 lea rbp, [rax*8]                                                              |     rbp = rax*8;
    0x004ca439 mov r12, qword [rbp + rbp*4 + 0x4f3c98]                                       |     r12 = *((rbp + rbp*4 + 0x4f3c98));
    0x004ca441 mov rdi, r12                                                                  |     
    0x004ca444 call 0x401790                                                                 |     eax = strlen (*((rbp + rbp*4 + 0x4f3c98)));
    0x004ca449 cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004ca44c jl 0x4ca477                                                                   |         
    0x004ca44e mov edi, 0x4f4e04                                                             |         
    0x004ca453 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004ca458 mov esi, 0xfe6                                                                |         esi = 0xfe6;
    0x004ca45d xor eax, eax                                                                  |         eax = 0;
    0x004ca45f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca464 mov eax, dword [rip + 0x24e52e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca46a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca46d ja 0x4ca477                                                                   |             goto label_6;
                                                                                             |         }
    0x004ca46f inc eax                                                                       |         eax++;
    0x004ca471 mov dword [rip + 0x24e521], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_6:
    0x004ca477 mov r14d, dword [rbp + rbp*4 + 0x4f3c90]                                      |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004ca47f movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0]                                    |     r15 = *((rbp + rbp*4 + 0x4f3ca0));
    0x004ca487 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4]                                       |     ebx = *((rbp + rbp*4 + 0x4f3ca4));
    0x004ca48e movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8]                                    |     r13 = *((rbp + rbp*4 + 0x4f3ca8));
    0x004ca496 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0]                                       |     rbp = *((rbp + rbp*4 + 0x4f3cb0));
    0x004ca49e cmp byte [rip + 0x24e4eb], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca4a5 je 0x4ca4c6                                                                   |         
    0x004ca4a7 mov qword [rsp], rbp                                                          |         *(rsp) = rbp;
    0x004ca4ab mov edi, 0x4f5c41                                                             |         
    0x004ca4b0 mov esi, r14d                                                                 |         esi = r14d;
    0x004ca4b3 mov rdx, r12                                                                  |         rdx = r12;
    0x004ca4b6 mov ecx, r15d                                                                 |         ecx = r15d;
    0x004ca4b9 mov r8d, ebx                                                                  |         r8d = ebx;
    0x004ca4bc mov r9d, r13d                                                                 |         r9d = r13d;
    0x004ca4bf xor eax, eax                                                                  |         eax = 0;
    0x004ca4c1 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004ca4c6 mov dword [rsp + 0x14], r14d                                                  |     *((rsp + 0x14)) = r14d;
    0x004ca4cb mov qword [rsp + 0x18], rbx                                                   |     *((rsp + 0x18)) = rbx;
    0x004ca4d0 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca4d5 mov rsi, r12                                                                  |     rsi = r12;
    0x004ca4d8 call 0x4e2ed0                                                                 |     intconst*&gg<intconst*>(intconst**,char const*) ();
    0x004ca4dd mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca4e2 mov rsi, r12                                                                  |     rsi = r12;
    0x004ca4e5 call 0x4e2fb0                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca4ea mov r12d, dword [rip + 0x24e4b3]                                              |     r12d = numCopyCtorCalls;
    0x004ca4f1 mov r14d, dword [rip + 0x24e4b4]                                              |     r14d = numCharCtorCalls;
    0x004ca4f8 cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004ca4fd je 0x4ca5e0                                                                   |         goto label_7;
                                                                                             |     }
    0x004ca503 cmp byte [rip + 0x24e486], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca50a je 0x4ca51f                                                                   |         
    0x004ca50c cmp dword [rip + 0x24e08d], 0                                                 |         
                                                                                             |         if (*(0x007185a0) == 0) {
    0x004ca513 je 0x4ca51f                                                                   |             goto label_8;
                                                                                             |         }
    0x004ca515 mov edi, 0x4f43ea                                                             |         
    0x004ca51a call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_8:
    0x004ca51f mov dword [rip + 0x24e077], 0                                                 |     *(0x007185a0) = 0;
    0x004ca529 cmp byte [rip + 0x24e465], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004ca530 je 0x4ca53c                                                                   |         
    0x004ca532 mov edi, 0x4f4411                                                             |         
    0x004ca537 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004ca53c mov rax, qword [rip + 0x24e2dd]                                               |     rax = Z;
    0x004ca543 mov qword [rsp + 0x20], 0x4f69e0                                              |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004ca54c mov qword [rsp + 0x28], rax                                                   |     *((rsp + 0x28)) = rax;
    0x004ca551 mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004ca559 test rax, rax                                                                 |     
    0x004ca55c je 0x4ca6a5                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_0:
    0x004ca562 lea rsi, [r15*8 + 0x74f8e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca56a mov rax, qword [rsp + 0x18]                                                   |         rax = *((rsp + 0x18));
    0x004ca56f add eax, r15d                                                                 |         eax += r15d;
    0x004ca572 cdqe                                                                          |         rax = (int64_t) eax;
    0x004ca574 lea rdx, [rax*8 + 0x74f8e0]                                                   |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca57c sub rdx, rsi                                                                  |         rdx -= rsi;
                                                                                             |         if (rdx != 0) {
    0x004ca57f je 0x4ca58e                                                                   |             
    0x004ca581 lea rdi, [r13*8 + 0x74f8e0]                                                   |             
    0x004ca589 call 0x401930                                                                 |             memcpy (r13*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u, rsi, rdx);
                                                                                             |         }
    0x004ca58e mov rax, qword [rsp + 0x20]                                                   |         rax = *((rsp + 0x20));
    0x004ca593 lea rdi, [rsp + 0x20]                                                         |         rdi = rsp + 0x20;
    0x004ca598 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004ca59f call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004ca5a2 cmp byte [rip + 0x24e3ec], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004ca5a9 je 0x4ca5b5                                                                   |             
    0x004ca5ab mov edi, 0x4f4571                                                             |             
    0x004ca5b0 call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004ca5b5 cmp byte [rip + 0x24e3d4], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004ca5bc je 0x4ca89a                                                                   |             goto label_9;
                                                                                             |         }
    0x004ca5c2 mov edi, 0xa                                                                  |         
    0x004ca5c7 call 0x401720                                                                 |         putchar (0xa);
    0x004ca5cc mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
    0x004ca5d0 jmp 0x4ca871                                                                  |         goto label_10;
                                                                                             | label_7:
    0x004ca5e0 cmp qword [rip + 0x24e238], 0                                                 |         
                                                                                             |         if (*(obj.Z) == 0) {
    0x004ca5e8 jne 0x4ca600                                                                  |             
    0x004ca5ea mov rax, qword [rip + 0x286cc7]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004ca5f1 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004ca5f4 jne 0x4ca600                                                                  |                 goto label_11;
                                                                                             |             }
    0x004ca5f6 call 0x4eede0                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004ca5fb nop dword [rax + rax]                                                         |             
                                                                                             |         }
                                                                                             | label_11:
    0x004ca600 cmp qword [rsp + 0x48], 6                                                     |         
    0x004ca606 mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
                                                                                             |         if (*((rsp + 0x48)) < 6) {
    0x004ca60a jb 0x4ca871                                                                   |             goto label_10;
                                                                                             |         }
    0x004ca610 lea rax, [r15*8 + 0x74f8e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca618 lea rcx, [r13*8 + 0x74f8e0]                                                   |         rcx = r13*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca620 mov rsi, qword [rsp + 0x18]                                                   |         rsi = *((rsp + 0x18));
    0x004ca625 lea edx, [rsi + r15]                                                          |         edx = rsi + r15;
    0x004ca629 movsxd r9, edx                                                                |         r9 = (int64_t) edx;
    0x004ca62c shl r9, 3                                                                     |         r9 <<= 3;
    0x004ca630 lea rdi, [r15*8]                                                              |         rdi = r15*8;
    0x004ca638 mov r10, r9                                                                   |         r10 = r9;
    0x004ca63b sub r10, rdi                                                                  |         r10 -= rdi;
    0x004ca63e add r10, 0xfffffffffffffff8                                                   |         r10 += 0xfffffffffffffff8;
    0x004ca642 cmp r10, 0x18                                                                 |         
                                                                                             |         if (r10 < 0x18) {
    0x004ca646 jb 0x4ca850                                                                   |             goto label_12;
                                                                                             |         }
    0x004ca64c mov dword [rsp + 0x50], r14d                                                  |         *((rsp + 0x50)) = r14d;
    0x004ca651 mov r11, rbp                                                                  |         r11 = rbp;
    0x004ca654 lea rbp, [r13*8 + 0x74f8e0]                                                   |         rbp = r13*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca65c lea edx, [rsi + r15]                                                          |         edx = rsi + r15;
    0x004ca660 movsxd rdx, edx                                                               |         rdx = (int64_t) edx;
    0x004ca663 lea rbx, [rdx*8 + 0x74f8e0]                                                   |         rbx = rdx*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca66b cmp rbp, rbx                                                                  |         
                                                                                             |         if (rbp >= rbx) {
    0x004ca66e jae 0x4ca717                                                                  |             goto label_13;
                                                                                             |         }
    0x004ca674 shl rdx, 3                                                                    |         rdx <<= 3;
    0x004ca678 sub rdx, rdi                                                                  |         rdx -= rdi;
    0x004ca67b lea rdx, [rdx + r13*8 + 0x74f8e0]                                             |         rdx = rdx + r13*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca683 lea rbp, [r15*8 + 0x74f8e0]                                                   |         rbp = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca68b cmp rbp, rdx                                                                  |         
                                                                                             |         if (rbp >= rdx) {
    0x004ca68e jae 0x4ca717                                                                  |             goto label_13;
                                                                                             |         }
    0x004ca694 mov rbp, r11                                                                  |         
    0x004ca697 mov r14d, dword [rsp + 0x50]                                                  |         r14d = *((rsp + 0x50));
    0x004ca69c mov ebx, dword [rsp + 0x14]                                                   |         ebx = *((rsp + 0x14));
    0x004ca6a0 jmp 0x4ca850                                                                  |         goto label_12;
    0x004ca6a5 mov ebx, 1                                                                    |         ebx = 1;
    0x004ca6aa mov rax, qword [rip + 0x286c07]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004ca6b1 test rax, rax                                                                 |         
    0x004ca6b4 jne 0x4ca562                                                                  |         
                                                                                             |     }
    0x004ca6ba call 0x4eede0                                                                 |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004ca6bf jmp 0x4ca562                                                                  |     goto label_0;
                                                                                             | label_13:
    0x004ca717 shr r10, 3                                                                    |     r10 >>= 3;
    0x004ca71b inc r10                                                                       |     r10++;
    0x004ca71e mov r8, r10                                                                   |     r8 = r10;
    0x004ca721 and r8, 0xfffffffffffffffc                                                    |     r8 &= 0xfffffffffffffffc;
    0x004ca725 lea rdx, [r8 - 4]                                                             |     rdx = r8 - 4;
    0x004ca729 mov rbp, rdx                                                                  |     
    0x004ca72c shr rbp, 2                                                                    |     rbp >>= 2;
    0x004ca730 inc rbp                                                                       |     rbp++;
    0x004ca733 mov ebx, ebp                                                                  |     ebx = ebp;
    0x004ca735 and ebx, 3                                                                    |     ebx &= 3;
    0x004ca738 cmp rdx, 0xc                                                                  |     
                                                                                             |     if (rdx < 0xc) {
    0x004ca73c jae 0x4ca745                                                                  |         
    0x004ca73e xor edx, edx                                                                  |         edx = 0;
    0x004ca740 jmp 0x4ca7ea                                                                  |         goto label_14;
                                                                                             |     }
    0x004ca745 and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004ca749 neg rbp                                                                       |     rbp = -rbp;
    0x004ca74c xor edx, edx                                                                  |     edx = 0;
    0x004ca74e nop                                                                           |     
                                                                                             |     do {
    0x004ca750 movups xmm0, xmmword [rdi + rdx*8 + 0x74f8e0]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u]");
    0x004ca758 movups xmm1, xmmword [rdi + rdx*8 + 0x74f8f0]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f8f0]");
    0x004ca760 lea rsi, [r13*8]                                                              |         rsi = r13*8;
    0x004ca768 movups xmmword [rsi + rdx*8 + 0x74f8e0], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004ca770 movups xmmword [rsi + rdx*8 + 0x74f8f0], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f8f0], xmm1");
    0x004ca778 movups xmm0, xmmword [rdi + rdx*8 + 0x74f900]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f900]");
    0x004ca780 movups xmm1, xmmword [rdi + rdx*8 + 0x74f910]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f910]");
    0x004ca788 movups xmmword [rsi + rdx*8 + 0x74f900], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f900], xmm0");
    0x004ca790 movups xmmword [rsi + rdx*8 + 0x74f910], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f910], xmm1");
    0x004ca798 movups xmm0, xmmword [rdi + rdx*8 + 0x74f920]                                 |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f920]");
    0x004ca7a0 movups xmm1, xmmword [rdi + rdx*8 + 0x74f930]                                 |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f930]");
    0x004ca7a8 movups xmmword [rsi + rdx*8 + 0x74f920], xmm0                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f920], xmm0");
    0x004ca7b0 movups xmmword [rsi + rdx*8 + 0x74f930], xmm1                                 |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f930], xmm1");
    0x004ca7b8 movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f940]                                 |         __asm ("movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f940]");
    0x004ca7c1 movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f950]                                 |         __asm ("movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f950]");
    0x004ca7ca movdqu xmmword [rsi + rdx*8 + 0x74f940], xmm0                                 |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f940], xmm0");
    0x004ca7d3 movdqu xmmword [rsi + rdx*8 + 0x74f950], xmm1                                 |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f950], xmm1");
    0x004ca7dc add rdx, 0x10                                                                 |         rdx += 0x10;
    0x004ca7e0 add rbp, 4                                                                    |         rbp += 4;
    0x004ca7e4 jne 0x4ca750                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_14:
    0x004ca7ea test rbx, rbx                                                                 |     
                                                                                             |     if (rbx == 0) {
    0x004ca7ed je 0x4ca830                                                                   |         goto label_15;
                                                                                             |     }
    0x004ca7ef shl r13, 3                                                                    |     r13 <<= 3;
    0x004ca7f3 lea rbp, [r13 + rdx*8 + 0x74f8f0]                                             |     rbp = r13 + rdx*8 + 0x74f8f0;
    0x004ca7fb lea rdx, [rdi + rdx*8 + 0x74f8f0]                                             |     rdx = rdi + rdx*8 + 0x74f8f0;
    0x004ca803 shl rbx, 5                                                                    |     rbx <<= 5;
    0x004ca807 xor edi, edi                                                                  |     edi = 0;
    0x004ca809 nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004ca810 movdqu xmm0, xmmword [rdx + rdi - 0x10]                                       |         __asm ("movdqu xmm0, xmmword [rdx + rdi - 0x10]");
    0x004ca816 movdqu xmm1, xmmword [rdx + rdi]                                              |         __asm ("movdqu xmm1, xmmword [rdx + rdi]");
    0x004ca81b movdqu xmmword [rbp + rdi - 0x10], xmm0                                       |         __asm ("movdqu xmmword [rbp + rdi - 0x10], xmm0");
    0x004ca821 movdqu xmmword [rbp + rdi], xmm1                                              |         __asm ("movdqu xmmword [rbp + rdi], xmm1");
    0x004ca827 add rdi, 0x20                                                                 |         rdi += 0x20;
    0x004ca82b cmp rbx, rdi                                                                  |         
    0x004ca82e jne 0x4ca810                                                                  |         
                                                                                             |     } while (rbx != rdi);
                                                                                             | label_15:
    0x004ca830 cmp r10, r8                                                                   |     
    0x004ca833 mov rbp, r11                                                                  |     
    0x004ca836 mov r14d, dword [rsp + 0x50]                                                  |     r14d = *((rsp + 0x50));
    0x004ca83b mov ebx, dword [rsp + 0x14]                                                   |     ebx = *((rsp + 0x14));
                                                                                             |     if (r10 == r8) {
    0x004ca83f je 0x4ca871                                                                   |         goto label_10;
                                                                                             |     }
    0x004ca841 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
    0x004ca845 lea rcx, [rcx + r8*8]                                                         |     rcx = rcx + r8*8;
    0x004ca849 nop dword [rax]                                                               |     
                                                                                             | label_12:
    0x004ca850 sub r9, rax                                                                   |     r9 -= rax;
    0x004ca853 lea rdx, [r9 + 0x74f8e0]                                                      |     rdx = r9 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca85a xor esi, esi                                                                  |     esi = 0;
    0x004ca85c nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004ca860 mov rdi, qword [rax + rsi]                                                    |         rdi = *((rax + rsi));
    0x004ca864 mov qword [rcx + rsi], rdi                                                    |         *((rcx + rsi)) = rdi;
    0x004ca868 add rsi, 8                                                                    |         rsi += 8;
    0x004ca86c cmp rdx, rsi                                                                  |         
    0x004ca86f jne 0x4ca860                                                                  |         
                                                                                             |     } while (rdx != rsi);
                                                                                             | label_10:
    0x004ca871 cmp byte [rip + 0x24e118], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca878 je 0x4ca89a                                                                   |         
    0x004ca87a mov edx, dword [rip + 0x24e124]                                               |         edx = numCopyCtorCalls;
    0x004ca880 sub edx, r12d                                                                 |         edx -= r12d;
    0x004ca883 mov ecx, dword [rip + 0x24e123]                                               |         ecx = numCharCtorCalls;
    0x004ca889 sub ecx, r14d                                                                 |         ecx -= r14d;
    0x004ca88c mov edi, 0x4f5db4                                                             |         
    0x004ca891 mov esi, ebx                                                                  |         esi = ebx;
    0x004ca893 xor eax, eax                                                                  |         eax = 0;
    0x004ca895 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_9:
    0x004ca89a cmp byte [rsp + 0x40], 0                                                      |     
                                                                                             |     if (*((rsp + 0x40)) == 0) {
    0x004ca89f je 0x4ca900                                                                   |         goto label_16;
                                                                                             |     }
    0x004ca8a1 cmp r12d, dword [rip + 0x24e0fc]                                              |     
                                                                                             |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004ca8a8 je 0x4ca8d3                                                                   |         
    0x004ca8aa mov edi, 0x4f4e04                                                             |         
    0x004ca8af mov edx, 0x4f5176                                                             |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004ca8b4 mov esi, 0x1005                                                               |         esi = 0x1005;
    0x004ca8b9 xor eax, eax                                                                  |         eax = 0;
    0x004ca8bb call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca8c0 mov eax, dword [rip + 0x24e0d2]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca8c6 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca8c9 ja 0x4ca8d3                                                                   |             goto label_17;
                                                                                             |         }
    0x004ca8cb inc eax                                                                       |         eax++;
    0x004ca8cd mov dword [rip + 0x24e0c5], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_17:
    0x004ca8d3 cmp r14d, dword [rip + 0x24e0d2]                                              |     
                                                                                             |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004ca8da je 0x4ca400                                                                   |         goto label_1;
                                                                                             |     }
    0x004ca8e0 mov edi, 0x4f4e04                                                             |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004ca8e5 mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004ca8ea mov esi, 0x1006                                                               |     esi = 0x1006;
    0x004ca8ef jmp 0x4ca953                                                                  |     goto label_18;
                                                                                             | label_16:
    0x004ca900 add r12d, dword [rsp + 0x18]                                                  |     r12d += *((rsp + 0x18));
    0x004ca905 cmp r12d, dword [rip + 0x24e098]                                              |     
                                                                                             |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004ca90c jle 0x4ca937                                                                  |         
    0x004ca90e mov edi, 0x4f4e04                                                             |         
    0x004ca913 mov edx, 0x4f5e02                                                             |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004ca918 mov esi, 0x1009                                                               |         esi = 0x1009;
    0x004ca91d xor eax, eax                                                                  |         eax = 0;
    0x004ca91f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca924 mov eax, dword [rip + 0x24e06e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca92a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca92d ja 0x4ca937                                                                   |             goto label_19;
                                                                                             |         }
    0x004ca92f inc eax                                                                       |         eax++;
    0x004ca931 mov dword [rip + 0x24e061], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_19:
    0x004ca937 cmp r14d, dword [rip + 0x24e06e]                                              |     
                                                                                             |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004ca93e je 0x4ca400                                                                   |         goto label_1;
                                                                                             |     }
    0x004ca944 mov edi, 0x4f4e04                                                             |     
    0x004ca949 mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004ca94e mov esi, 0x100a                                                               |     esi = 0x100a;
                                                                                             | label_18:
    0x004ca953 xor eax, eax                                                                  |     eax = 0;
    0x004ca955 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca95a mov eax, dword [rip + 0x24e038]                                               |     eax = (anonymous namespace)::testStatus;
    0x004ca960 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004ca963 ja 0x4ca400                                                                   |         goto label_1;
                                                                                             |     }
    0x004ca969 inc eax                                                                       |     eax++;
    0x004ca96b mov dword [rip + 0x24e027], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004ca971 jmp 0x4ca400                                                                  |     goto label_1;
                                                                                             | label_5:
    0x004ca976 cmp byte [rip + 0x24e019], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004ca97d je 0x4ca989                                                                   |         
    0x004ca97f mov edi, 0x4f695c                                                             |         
    0x004ca984 call 0x401710                                                                 |         puts ("\t\tfrom different type.");
                                                                                             |     }
    0x004ca989 xor r12d, r12d                                                                |     r12d = 0;
    0x004ca98c jmp 0x4ca9b7                                                                  |     goto label_20;
                                                                                             | label_3:
    0x004ca990 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca995 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004ca998 call 0x4e2fb0                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca99d mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca9a2 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004ca9a5 call 0x4e31f0                                                                 |     voidcleanup<intconst*>(intconst**,char const*) ();
    0x004ca9aa inc r12                                                                       |     r12++;
    0x004ca9ad cmp r12, 0x1e                                                                 |     
                                                                                             |     if (r12 == 0x1e) {
    0x004ca9b1 je 0x4cafdd                                                                   |         goto label_21;
                                                                                             |     }
                                                                                             | label_20:
    0x004ca9b7 lea rbx, [r12*8]                                                              |     rbx = r12*8;
    0x004ca9bf mov rbp, qword [rbx + rbx*4 + 0x4f3c98]                                       |     rbp = *((rbx + rbx*4 + 0x4f3c98));
    0x004ca9c7 mov rdi, rbp                                                                  |     
    0x004ca9ca call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004ca9cf cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004ca9d2 jl 0x4ca9fd                                                                   |         
    0x004ca9d4 mov edi, 0x4f4e04                                                             |         
    0x004ca9d9 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004ca9de mov esi, 0x1019                                                               |         esi = 0x1019;
    0x004ca9e3 xor eax, eax                                                                  |         eax = 0;
    0x004ca9e5 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca9ea mov eax, dword [rip + 0x24dfa8]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca9f0 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca9f3 ja 0x4ca9fd                                                                   |             goto label_22;
                                                                                             |         }
    0x004ca9f5 inc eax                                                                       |         eax++;
    0x004ca9f7 mov dword [rip + 0x24df9b], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_22:
    0x004ca9fd mov rdi, rbp                                                                  |     
    0x004caa00 call 0x401790                                                                 |     rax = strlen (rbp);
    0x004caa05 cmp rax, 0x14                                                                 |     
                                                                                             |     if (rax >= 0x14) {
    0x004caa09 jb 0x4caa34                                                                   |         
    0x004caa0b mov edi, 0x4f4e04                                                             |         
    0x004caa10 mov edx, 0x4f5e26                                                             |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004caa15 mov esi, 0x101c                                                               |         esi = 0x101c;
    0x004caa1a xor eax, eax                                                                  |         eax = 0;
    0x004caa1c call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004caa21 mov eax, dword [rip + 0x24df71]                                               |         eax = (anonymous namespace)::testStatus;
    0x004caa27 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004caa2a ja 0x4caa34                                                                   |             goto label_23;
                                                                                             |         }
    0x004caa2c inc eax                                                                       |         eax++;
    0x004caa2e mov dword [rip + 0x24df64], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_23:
    0x004caa34 mov qword [rsp + 0x18], r12                                                   |     *((rsp + 0x18)) = r12;
    0x004caa39 pxor xmm0, xmm0                                                               |     xmm0 = 0;
    0x004caa3d movdqa xmmword [rsp + 0x20], xmm0                                             |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004caa43 mov dword [rsp + 0x30], 0                                                     |     *((rsp + 0x30)) = 0;
    0x004caa4b mov al, byte [rbp]                                                            |     al = *(rbp);
    0x004caa4e test al, al                                                                   |     
                                                                                             |     if (al == 0) {
    0x004caa50 je 0x4caa70                                                                   |         goto label_24;
                                                                                             |     }
    0x004caa52 xor ecx, ecx                                                                  |     ecx = 0;
    0x004caa54 nop word cs:[rax + rax]                                                       |     
    0x004caa5e nop                                                                           |     
                                                                                             |     do {
    0x004caa60 mov byte [rsp + rcx + 0x20], al                                               |         *((rsp + rcx + 0x20)) = al;
    0x004caa64 movzx eax, byte [rbp + rcx + 1]                                               |         eax = *((rbp + rcx + 1));
    0x004caa69 inc rcx                                                                       |         rcx++;
    0x004caa6c test al, al                                                                   |         
    0x004caa6e jne 0x4caa60                                                                  |         
                                                                                             |     } while (al != 0);
                                                                                             | label_24:
    0x004caa70 mov r14d, dword [rbx + rbx*4 + 0x4f3c90]                                      |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004caa78 movsxd r13, dword [rbx + rbx*4 + 0x4f3ca0]                                    |     r13 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004caa80 movsxd r12, dword [rbx + rbx*4 + 0x4f3ca4]                                    |     r12 = *((rbx + rbx*4 + 0x4f3ca4));
    0x004caa88 movsxd r15, dword [rbx + rbx*4 + 0x4f3ca8]                                    |     r15 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004caa90 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                       |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004caa98 cmp byte [rip + 0x24def1], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004caa9f je 0x4caac0                                                                   |         
    0x004caaa1 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004caaa5 mov edi, 0x4f5c41                                                             |         
    0x004caaaa mov esi, r14d                                                                 |         esi = r14d;
    0x004caaad mov rdx, rbp                                                                  |         rdx = rbp;
    0x004caab0 mov ecx, r13d                                                                 |         ecx = r13d;
    0x004caab3 mov r8d, r12d                                                                 |         r8d = r12d;
    0x004caab6 mov r9d, r15d                                                                 |         r9d = r15d;
    0x004caab9 xor eax, eax                                                                  |         eax = 0;
    0x004caabb call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004caac0 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004caac5 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004caac8 call 0x4e2ed0                                                                 |     intconst*&gg<intconst*>(intconst**,char const*) ();
    0x004caacd mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004caad2 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004caad5 call 0x4e2fb0                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004caada mov eax, dword [rip + 0x24dec4]                                               |     eax = numCopyCtorCalls;
    0x004caae0 mov dword [rsp + 0x48], eax                                                   |     *((rsp + 0x48)) = eax;
    0x004caae4 mov eax, dword [rip + 0x24dec2]                                               |     eax = numCharCtorCalls;
    0x004caaea mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004caaee cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004caaf3 je 0x4cabc0                                                                   |         goto label_25;
                                                                                             |     }
    0x004caaf9 cmp byte [rip + 0x24de90], 0                                                  |     
    0x004cab00 mov ebp, r14d                                                                 |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004cab03 je 0x4cab18                                                                   |         
    0x004cab05 cmp dword [rip + 0x24da98], 0                                                 |         
                                                                                             |         if (*(obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::firstTime) == 0) {
    0x004cab0c je 0x4cab18                                                                   |             goto label_26;
                                                                                             |         }
    0x004cab0e mov edi, 0x4f43ea                                                             |         
    0x004cab13 call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_26:
    0x004cab18 mov dword [rip + 0x24da82], 0                                                 |     *(obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::firstTime) = 0;
    0x004cab22 cmp byte [rip + 0x24de6c], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cab29 je 0x4cab35                                                                   |         
    0x004cab2b mov edi, 0x4f4411                                                             |         
    0x004cab30 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004cab35 mov rax, qword [rip + 0x24dce4]                                               |     rax = Z;
    0x004cab3c mov qword [rsp + 0x58], 0x4f69e0                                              |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cab45 mov qword [rsp + 0x60], rax                                                   |     *((rsp + 0x60)) = rax;
    0x004cab4a mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004cab52 test rax, rax                                                                 |     
    0x004cab55 je 0x4cac4d                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_2:
    0x004cab5b cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004cab61 jb 0x4caf31                                                                   |             goto label_27;
                                                                                             |         }
    0x004cab67 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004cab6c lea rsi, [r15*8 + 0x74f8e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004cab74 lea eax, [r13 + r12]                                                          |         eax = r13 + r12;
    0x004cab79 movsxd r9, eax                                                                |         r9 = (int64_t) eax;
    0x004cab7c mov r10, r9                                                                   |         r10 = r9;
    0x004cab7f sub r10, r13                                                                  |         r10 -= r13;
    0x004cab82 cmp r10, 4                                                                    |         
                                                                                             |         if (r10 < 4) {
    0x004cab86 jb 0x4caf16                                                                   |             goto label_28;
                                                                                             |         }
    0x004cab8c mov r11, rbx                                                                  |         r11 = rbx;
    0x004cab8f mov r8, r10                                                                   |         r8 = r10;
    0x004cab92 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004cab96 lea rax, [r8 - 4]                                                             |         rax = r8 - 4;
    0x004cab9a mov rbp, rax                                                                  |         
    0x004cab9d shr rbp, 2                                                                    |         rbp >>= 2;
    0x004caba1 inc rbp                                                                       |         rbp++;
    0x004caba4 mov edi, ebp                                                                  |         edi = ebp;
    0x004caba6 and edi, 3                                                                    |         edi &= 3;
    0x004caba9 cmp rax, 0xc                                                                  |         
                                                                                             |         if (rax >= 0xc) {
    0x004cabad jae 0x4cae06                                                                  |             goto label_29;
                                                                                             |         }
    0x004cabb3 xor ebx, ebx                                                                  |         ebx = 0;
    0x004cabb5 jmp 0x4caeb5                                                                  |         goto label_30;
                                                                                             | label_25:
    0x004cabc0 cmp qword [rip + 0x24dc58], 0                                                 |         
    0x004cabc8 mov ebp, r14d                                                                 |         
    0x004cabcb mov r11, r12                                                                  |         r11 = r12;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004cabce jne 0x4cabf0                                                                  |             
    0x004cabd0 mov rax, qword [rip + 0x2866e1]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cabd7 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004cabda jne 0x4cabf0                                                                  |                 goto label_31;
                                                                                             |             }
    0x004cabdc call 0x4eede0                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cabe1 mov r11, r12                                                                  |             r11 = r12;
    0x004cabe4 nop word cs:[rax + rax]                                                       |             
    0x004cabee nop                                                                           |             
                                                                                             |         }
                                                                                             | label_31:
    0x004cabf0 mov r12, qword [rsp + 0x18]                                                   |         r12 = *((rsp + 0x18));
    0x004cabf5 cmp r12, 6                                                                    |         
                                                                                             |         if (r12 < 6) {
    0x004cabf9 jb 0x4caf70                                                                   |             goto label_32;
                                                                                             |         }
    0x004cabff lea rax, [r15*8 + 0x74f8e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004cac07 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004cac0c add r11, r13                                                                  |         r11 += r13;
    0x004cac0f mov r9, r11                                                                   |         r9 = r11;
    0x004cac12 sub r9, r13                                                                   |         r9 -= r13;
    0x004cac15 cmp r9, 4                                                                     |         
                                                                                             |         if (r9 < 4) {
    0x004cac19 jb 0x4cadda                                                                   |             goto label_33;
                                                                                             |         }
    0x004cac1f mov r10, rbx                                                                  |         r10 = rbx;
    0x004cac22 mov r8, r9                                                                    |         r8 = r9;
    0x004cac25 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004cac29 lea rsi, [r8 - 4]                                                             |         rsi = r8 - 4;
    0x004cac2d mov rdi, rsi                                                                  |         rdi = rsi;
    0x004cac30 shr rdi, 2                                                                    |         rdi >>= 2;
    0x004cac34 inc rdi                                                                       |         rdi++;
    0x004cac37 mov ebp, edi                                                                  |         
    0x004cac39 and ebp, 3                                                                    |         ebp &= 3;
    0x004cac3c cmp rsi, 0xc                                                                  |         
                                                                                             |         if (rsi >= 0xc) {
    0x004cac40 jae 0x4caccd                                                                  |             goto label_34;
                                                                                             |         }
    0x004cac46 xor ebx, ebx                                                                  |         ebx = 0;
    0x004cac48 jmp 0x4cad75                                                                  |         goto label_35;
    0x004cac4d mov eax, 1                                                                    |         eax = 1;
    0x004cac52 mov qword [rsp + 0x40], rax                                                   |         *((rsp + 0x40)) = rax;
    0x004cac57 mov rax, qword [rip + 0x28665a]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cac5e test rax, rax                                                                 |         
    0x004cac61 jne 0x4cab5b                                                                  |         
                                                                                             |     }
    0x004cac67 call 0x4eede0                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cac6c jmp 0x4cab5b                                                                  |     goto label_2;
                                                                                             | label_34:
    0x004caccd lea rdx, [rsp + 0x2e]                                                         |     rdx = rsp + 0x2e;
    0x004cacd2 lea rsi, [rdx + r13]                                                          |     rsi = rdx + r13;
    0x004cacd6 and rdi, 0xfffffffffffffffc                                                   |     rdi &= 0xfffffffffffffffc;
    0x004cacda neg rdi                                                                       |     rdi = -rdi;
    0x004cacdd xor ebx, ebx                                                                  |     ebx = 0;
    0x004cacdf nop                                                                           |     
                                                                                             |     do {
    0x004cace0 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cace7 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cacee lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004cacf6 movdqu xmmword [rdx + rbx*8 + 0x74f8e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004cacff movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1");
    0x004cad08 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cad0f pmovsxbq xmm1, word [rsi + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cad16 movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0");
    0x004cad1f movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1");
    0x004cad28 pmovsxbq xmm0, word [rsi + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cad2f pmovsxbq xmm1, word [rsi + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cad36 movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0");
    0x004cad3f movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1");
    0x004cad48 pmovsxbq xmm0, word [rsi + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cad4f pmovsxbq xmm1, word [rsi + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cad55 movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0");
    0x004cad5e movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1");
    0x004cad67 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004cad6b add rdi, 4                                                                    |         rdi += 4;
    0x004cad6f jne 0x4cace0                                                                  |         
                                                                                             |     } while (rdi != 0);
                                                                                             | label_35:
    0x004cad75 test rbp, rbp                                                                 |     
                                                                                             |     if (rbp == 0) {
    0x004cad78 je 0x4cadc4                                                                   |         goto label_36;
                                                                                             |     }
    0x004cad7a add r13, rbx                                                                  |     r13 += rbx;
    0x004cad7d lea rdx, [rsp + 0x22]                                                         |     rdx = rsp + 0x22;
    0x004cad82 add r13, rdx                                                                  |     r13 += rdx;
    0x004cad85 shl r15, 3                                                                    |     r15 <<= 3;
    0x004cad89 lea rsi, [r15 + rbx*8 + 0x74f8f0]                                             |     rsi = r15 + rbx*8 + 0x74f8f0;
    0x004cad91 shl rbp, 2                                                                    |     rbp <<= 2;
    0x004cad95 xor edi, edi                                                                  |     edi = 0;
    0x004cad97 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004cada0 pmovsxbq xmm0, word [r13 + rdi - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cada8 pmovsxbq xmm1, word [r13 + rdi]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cadb0 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cadb6 movdqu xmmword [rsi + rdi*8], xmm1                                            |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cadbb add rdi, 4                                                                    |         rdi += 4;
    0x004cadbf cmp rbp, rdi                                                                  |         
    0x004cadc2 jne 0x4cada0                                                                  |         
                                                                                             |     } while (rbp != rdi);
                                                                                             | label_36:
    0x004cadc4 cmp r9, r8                                                                    |     
    0x004cadc7 mov rbx, r10                                                                  |     rbx = r10;
    0x004cadca mov ebp, r14d                                                                 |     
                                                                                             |     if (r9 == r8) {
    0x004cadcd je 0x4caf70                                                                   |         goto label_32;
                                                                                             |     }
    0x004cadd3 add rcx, r8                                                                   |     rcx += r8;
    0x004cadd6 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
                                                                                             | label_33:
    0x004cadda sub r11, rcx                                                                  |     r11 -= rcx;
    0x004caddd lea rdx, [rsp + r11 + 0x20]                                                   |     rdx = rsp + r11 + 0x20;
    0x004cade2 xor esi, esi                                                                  |     esi = 0;
    0x004cade4 nop word cs:[rax + rax]                                                       |     
    0x004cadee nop                                                                           |     
                                                                                             |     do {
    0x004cadf0 movsx rdi, byte [rcx + rsi]                                                   |         rdi = *((rcx + rsi));
    0x004cadf5 mov qword [rax + rsi*8], rdi                                                  |         *((rax + rsi*8)) = rdi;
    0x004cadf9 inc rsi                                                                       |         rsi++;
    0x004cadfc cmp rdx, rsi                                                                  |         
    0x004cadff jne 0x4cadf0                                                                  |         
                                                                                             |     } while (rdx != rsi);
    0x004cae01 jmp 0x4caf70                                                                  |     goto label_32;
                                                                                             | label_29:
    0x004cae06 lea rax, [rsp + 0x2e]                                                         |     rax = rsp + 0x2e;
    0x004cae0b add rax, r13                                                                  |     rax += r13;
    0x004cae0e and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004cae12 neg rbp                                                                       |     rbp = -rbp;
    0x004cae15 xor ebx, ebx                                                                  |     ebx = 0;
    0x004cae17 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004cae20 pmovsxbq xmm0, word [rax + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cae27 pmovsxbq xmm1, word [rax + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cae2e lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004cae36 movdqu xmmword [rdx + rbx*8 + 0x74f8e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004cae3f movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1");
    0x004cae48 pmovsxbq xmm0, word [rax + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cae4f pmovsxbq xmm1, word [rax + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cae56 movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0");
    0x004cae5f movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1");
    0x004cae68 pmovsxbq xmm0, word [rax + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cae6f pmovsxbq xmm1, word [rax + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cae76 movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0");
    0x004cae7f movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1");
    0x004cae88 pmovsxbq xmm0, word [rax + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cae8f pmovsxbq xmm1, word [rax + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cae95 movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0");
    0x004cae9e movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1");
    0x004caea7 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004caeab add rbp, 4                                                                    |         rbp += 4;
    0x004caeaf jne 0x4cae20                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_30:
    0x004caeb5 test rdi, rdi                                                                 |     
                                                                                             |     if (rdi == 0) {
    0x004caeb8 je 0x4caf04                                                                   |         goto label_37;
                                                                                             |     }
    0x004caeba add r13, rbx                                                                  |     r13 += rbx;
    0x004caebd lea rax, [rsp + 0x22]                                                         |     rax = rsp + 0x22;
    0x004caec2 add r13, rax                                                                  |     r13 += rax;
    0x004caec5 shl r15, 3                                                                    |     r15 <<= 3;
    0x004caec9 lea rax, [r15 + rbx*8 + 0x74f8f0]                                             |     rax = r15 + rbx*8 + 0x74f8f0;
    0x004caed1 shl rdi, 2                                                                    |     rdi <<= 2;
    0x004caed5 xor ebp, ebp                                                                  |     ebp = 0;
    0x004caed7 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004caee0 pmovsxbq xmm0, word [r13 + rbp - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004caee8 pmovsxbq xmm1, word [r13 + rbp]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004caef0 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004caef6 movdqu xmmword [rax + rbp*8], xmm1                                            |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004caefb add rbp, 4                                                                    |         rbp += 4;
    0x004caeff cmp rdi, rbp                                                                  |         
    0x004caf02 jne 0x4caee0                                                                  |         
                                                                                             |     } while (rdi != rbp);
                                                                                             | label_37:
    0x004caf04 cmp r10, r8                                                                   |     
    0x004caf07 mov rbx, r11                                                                  |     rbx = r11;
    0x004caf0a mov ebp, r14d                                                                 |     
                                                                                             |     if (r10 == r8) {
    0x004caf0d je 0x4caf31                                                                   |         goto label_27;
                                                                                             |     }
    0x004caf0f add rcx, r8                                                                   |     rcx += r8;
    0x004caf12 lea rsi, [rsi + r8*8]                                                         |     rsi = rsi + r8*8;
                                                                                             | label_28:
    0x004caf16 sub r9, rcx                                                                   |     r9 -= rcx;
    0x004caf19 lea rax, [rsp + r9 + 0x20]                                                    |     rax = rsp + r9 + 0x20;
    0x004caf1e xor edi, edi                                                                  |     edi = 0;
                                                                                             |     do {
    0x004caf20 movsx rdx, byte [rcx + rdi]                                                   |         rdx = *((rcx + rdi));
    0x004caf25 mov qword [rsi + rdi*8], rdx                                                  |         *((rsi + rdi*8)) = rdx;
    0x004caf29 inc rdi                                                                       |         rdi++;
    0x004caf2c cmp rax, rdi                                                                  |         
    0x004caf2f jne 0x4caf20                                                                  |         
                                                                                             |     } while (rax != rdi);
                                                                                             | label_27:
    0x004caf31 mov rax, qword [rsp + 0x58]                                                   |     rax = *((rsp + 0x58));
    0x004caf36 lea rdi, [rsp + 0x58]                                                         |     rdi = rsp + 0x58;
    0x004caf3b mov rsi, 0xffffffffffffffff                                                   |     rsi = 0xffffffffffffffff;
    0x004caf42 call qword [rax + 0x10]                                                       |     uint64_t (*rax + 0x10)() ();
    0x004caf45 cmp byte [rip + 0x24da49], 0                                                  |     
    0x004caf4c mov r12, qword [rsp + 0x18]                                                   |     r12 = *((rsp + 0x18));
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004caf51 je 0x4caf5d                                                                   |         
    0x004caf53 mov edi, 0x4f4571                                                             |         
    0x004caf58 call 0x401710                                                                 |         puts ("\t\tEnd bslma exception test.");
                                                                                             |     }
    0x004caf5d cmp byte [rip + 0x24da2c], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004caf64 je 0x4caf9b                                                                   |         
    0x004caf66 mov edi, 0xa                                                                  |         
    0x004caf6b call 0x401720                                                                 |         eax = putchar (0xa);
                                                                                             | label_32:
    0x004caf70 cmp byte [rip + 0x24da19], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004caf77 je 0x4caf9b                                                                   |             goto label_38;
                                                                                             |         }
    0x004caf79 mov edx, dword [rip + 0x24da25]                                               |         edx = numCopyCtorCalls;
    0x004caf7f sub edx, dword [rsp + 0x48]                                                   |         edx -= *((rsp + 0x48));
    0x004caf83 mov ecx, dword [rip + 0x24da23]                                               |         ecx = numCharCtorCalls;
    0x004caf89 sub ecx, dword [rsp + 0x14]                                                   |         ecx -= *((rsp + 0x14));
    0x004caf8d mov edi, 0x4f5db4                                                             |         
    0x004caf92 mov esi, ebp                                                                  |         esi = ebp;
    0x004caf94 xor eax, eax                                                                  |         eax = 0;
    0x004caf96 call 0x401680                                                                 |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_38:
    0x004caf9b mov eax, dword [rsp + 0x48]                                                   |     eax = *((rsp + 0x48));
    0x004caf9f cmp eax, dword [rip + 0x24d9ff]                                               |     
                                                                                             |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cafa5 je 0x4ca990                                                                   |         goto label_3;
                                                                                             |     }
    0x004cafab mov edi, 0x4f4e04                                                             |     
    0x004cafb0 mov edx, 0x4f5176                                                             |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cafb5 mov esi, 0x103f                                                               |     esi = 0x103f;
    0x004cafba xor eax, eax                                                                  |     eax = 0;
    0x004cafbc call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cafc1 mov eax, dword [rip + 0x24d9d1]                                               |     eax = (anonymous namespace)::testStatus;
    0x004cafc7 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004cafca ja 0x4ca990                                                                   |         goto label_3;
                                                                                             |     }
    0x004cafd0 inc eax                                                                       |     eax++;
    0x004cafd2 mov dword [rip + 0x24d9c0], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cafd8 jmp 0x4ca990                                                                  |     goto label_3;
                                                                                             | label_21:
    0x004cafdd add rsp, 0x68                                                                 |     
    0x004cafe1 pop rbx                                                                       |     
    0x004cafe2 pop r12                                                                       |     
    0x004cafe4 pop r13                                                                       |     
    0x004cafe6 pop r14                                                                       |     
    0x004cafe8 pop r15                                                                       |     
    0x004cafea pop rbp                                                                       |     
    0x004cafeb ret                                                                           |     return rax;
                                                                                             | }