; assembly                                                                                       | /* r2dec pseudo code output */
                                                                                                     | /* bslalg_arrayprimitives.t/none @ 0x4cbc70 */
                                                                                                     | #include <stdint.h>
                                                                                                     |  
    ; (fcn) sym.void_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_ ()         | uint64_t void_testCopyConstructWithIterators_int_const_volatile_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 volatile*>(bool, bool, bool) */
    0x004cbc70 push rbp                                                                              |     
    0x004cbc71 push r15                                                                              |     
    0x004cbc73 push r14                                                                              |     
    0x004cbc75 push r13                                                                              |     
    0x004cbc77 push r12                                                                              |     
    0x004cbc79 push rbx                                                                              |     
    0x004cbc7a sub rsp, 0x68                                                                         |     
    0x004cbc7e mov dword [rsp + 0x54], edx                                                           |     *((rsp + 0x54)) = edx;
    0x004cbc82 mov dword [rsp + 0x40], esi                                                           |     *((rsp + 0x40)) = esi;
    0x004cbc86 cmp byte [rip + 0x24cd09], 0                                                          |     
                                                                                                     |     if (*(obj.verbose) != 0) {
    0x004cbc8d je 0x4cbc99                                                                           |         
    0x004cbc8f mov edi, 0x4f6973                                                                     |         
    0x004cbc94 call 0x401710                                                                         |         eax = puts ("\t\tfrom same type.");
                                                                                                     |     }
    0x004cbc99 xor eax, eax                                                                          |     eax = 0;
    0x004cbc9b jmp 0x4cbccc                                                                          |     goto label_4;
                                                                                                     | label_1:
    0x004cbca0 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbca5 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cbca8 call 0x4e39b0                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbcad mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbcb2 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cbcb5 call 0x4e3bf0                                                                         |     voidcleanup<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbcba mov rax, qword [rsp + 0x48]                                                           |     rax = *((rsp + 0x48));
    0x004cbcbf inc rax                                                                               |     rax++;
    0x004cbcc2 cmp rax, 0x1e                                                                         |     
                                                                                                     |     if (rax == 0x1e) {
    0x004cbcc6 je 0x4cc216                                                                           |         goto label_5;
                                                                                                     |     }
                                                                                                     | label_4:
    0x004cbccc mov qword [rsp + 0x48], rax                                                           |     *((rsp + 0x48)) = rax;
    0x004cbcd1 lea rbp, [rax*8]                                                                      |     rbp = rax*8;
    0x004cbcd9 mov r12, qword [rbp + rbp*4 + 0x4f3c98]                                               |     r12 = *((rbp + rbp*4 + 0x4f3c98));
    0x004cbce1 mov rdi, r12                                                                          |     
    0x004cbce4 call 0x401790                                                                         |     eax = strlen (*((rbp + rbp*4 + 0x4f3c98)));
    0x004cbce9 cmp eax, 0x11                                                                         |     
                                                                                                     |     if (eax >= 0x11) {
    0x004cbcec jl 0x4cbd17                                                                           |         
    0x004cbcee mov edi, 0x4f4e04                                                                     |         
    0x004cbcf3 mov edx, 0x4f4393                                                                     |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cbcf8 mov esi, 0xfe6                                                                        |         esi = 0xfe6;
    0x004cbcfd xor eax, eax                                                                          |         eax = 0;
    0x004cbcff call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cbd04 mov eax, dword [rip + 0x24cc8e]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cbd0a cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cbd0d ja 0x4cbd17                                                                           |             goto label_6;
                                                                                                     |         }
    0x004cbd0f inc eax                                                                               |         eax++;
    0x004cbd11 mov dword [rip + 0x24cc81], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_6:
    0x004cbd17 mov r14d, dword [rbp + rbp*4 + 0x4f3c90]                                              |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004cbd1f movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0]                                            |     r15 = *((rbp + rbp*4 + 0x4f3ca0));
    0x004cbd27 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4]                                               |     ebx = *((rbp + rbp*4 + 0x4f3ca4));
    0x004cbd2e movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8]                                            |     r13 = *((rbp + rbp*4 + 0x4f3ca8));
    0x004cbd36 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0]                                               |     rbp = *((rbp + rbp*4 + 0x4f3cb0));
    0x004cbd3e cmp byte [rip + 0x24cc4b], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cbd45 je 0x4cbd66                                                                           |         
    0x004cbd47 mov qword [rsp], rbp                                                                  |         *(rsp) = rbp;
    0x004cbd4b mov edi, 0x4f5c41                                                                     |         
    0x004cbd50 mov esi, r14d                                                                         |         esi = r14d;
    0x004cbd53 mov rdx, r12                                                                          |         rdx = r12;
    0x004cbd56 mov ecx, r15d                                                                         |         ecx = r15d;
    0x004cbd59 mov r8d, ebx                                                                          |         r8d = ebx;
    0x004cbd5c mov r9d, r13d                                                                         |         r9d = r13d;
    0x004cbd5f xor eax, eax                                                                          |         eax = 0;
    0x004cbd61 call 0x401680                                                                         |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                     |     }
    0x004cbd66 mov dword [rsp + 0x14], r14d                                                          |     *((rsp + 0x14)) = r14d;
    0x004cbd6b mov qword [rsp + 0x18], rbx                                                           |     *((rsp + 0x18)) = rbx;
    0x004cbd70 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbd75 mov rsi, r12                                                                          |     rsi = r12;
    0x004cbd78 call 0x4e38d0                                                                         |     intconstvolatile*&gg<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbd7d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbd82 mov rsi, r12                                                                          |     rsi = r12;
    0x004cbd85 call 0x4e39b0                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbd8a mov r12d, dword [rip + 0x24cc13]                                                      |     r12d = numCopyCtorCalls;
    0x004cbd91 mov r14d, dword [rip + 0x24cc14]                                                      |     r14d = numCharCtorCalls;
    0x004cbd98 cmp byte [rsp + 0x54], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x54)) == 0) {
    0x004cbd9d je 0x4cbe80                                                                           |         goto label_7;
                                                                                                     |     }
    0x004cbda3 cmp byte [rip + 0x24cbe6], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cbdaa je 0x4cbdbf                                                                           |         
    0x004cbdac cmp dword [rip + 0x24c7fd], 0                                                         |         
                                                                                                     |         if (*(obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::firstTime) == 0) {
    0x004cbdb3 je 0x4cbdbf                                                                           |             goto label_8;
                                                                                                     |         }
    0x004cbdb5 mov edi, 0x4f43ea                                                                     |         
    0x004cbdba call 0x401710                                                                         |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                     |     }
                                                                                                     | label_8:
    0x004cbdbf mov dword [rip + 0x24c7e7], 0                                                         |     *(obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::firstTime) = 0;
    0x004cbdc9 cmp byte [rip + 0x24cbc5], 0                                                          |     
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cbdd0 je 0x4cbddc                                                                           |         
    0x004cbdd2 mov edi, 0x4f4411                                                                     |         
    0x004cbdd7 call 0x401710                                                                         |         puts ("\t\tBegin bslma exception test.");
                                                                                                     |     }
    0x004cbddc mov rax, qword [rip + 0x24ca3d]                                                       |     rax = Z;
    0x004cbde3 mov qword [rsp + 0x20], 0x4f69e0                                                      |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cbdec mov qword [rsp + 0x28], rax                                                           |     *((rsp + 0x28)) = rax;
    0x004cbdf1 mov qword [rax + 0x20], 0                                                             |     *((rax + 0x20)) = 0;
    0x004cbdf9 test rax, rax                                                                         |     
    0x004cbdfc je 0x4cbf45                                                                           |     
                                                                                                     |     while (rax != 0) {
                                                                                                     | label_0:
    0x004cbe02 lea rsi, [r15*8 + 0x74f9e0]                                                           |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe0a mov rax, qword [rsp + 0x18]                                                           |         rax = *((rsp + 0x18));
    0x004cbe0f add eax, r15d                                                                         |         eax += r15d;
    0x004cbe12 cdqe                                                                                  |         rax = (int64_t) eax;
    0x004cbe14 lea rdx, [rax*8 + 0x74f9e0]                                                           |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe1c sub rdx, rsi                                                                          |         rdx -= rsi;
                                                                                                     |         if (rdx != 0) {
    0x004cbe1f je 0x4cbe2e                                                                           |             
    0x004cbe21 lea rdi, [r13*8 + 0x74f9e0]                                                           |             
    0x004cbe29 call 0x401930                                                                         |             memcpy (r13*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u, rsi, rdx);
                                                                                                     |         }
    0x004cbe2e mov rax, qword [rsp + 0x20]                                                           |         rax = *((rsp + 0x20));
    0x004cbe33 lea rdi, [rsp + 0x20]                                                                 |         rdi = rsp + 0x20;
    0x004cbe38 mov rsi, 0xffffffffffffffff                                                           |         rsi = 0xffffffffffffffff;
    0x004cbe3f call qword [rax + 0x10]                                                               |         uint64_t (*rax + 0x10)() ();
    0x004cbe42 cmp byte [rip + 0x24cb4c], 0                                                          |         
                                                                                                     |         if (*(obj.veryVeryVerbose) != 0) {
    0x004cbe49 je 0x4cbe55                                                                           |             
    0x004cbe4b mov edi, 0x4f4571                                                                     |             
    0x004cbe50 call 0x401710                                                                         |             puts ("\t\tEnd bslma exception test.");
                                                                                                     |         }
    0x004cbe55 cmp byte [rip + 0x24cb34], 0                                                          |         
                                                                                                     |         if (*(obj.veryVerbose) == 0) {
    0x004cbe5c je 0x4cc13a                                                                           |             goto label_9;
                                                                                                     |         }
    0x004cbe62 mov edi, 0xa                                                                          |         
    0x004cbe67 call 0x401720                                                                         |         putchar (0xa);
    0x004cbe6c mov ebx, dword [rsp + 0x14]                                                           |         ebx = *((rsp + 0x14));
    0x004cbe70 jmp 0x4cc111                                                                          |         goto label_10;
                                                                                                     | label_7:
    0x004cbe80 cmp qword [rip + 0x24c998], 0                                                         |         
                                                                                                     |         if (*(obj.Z) == 0) {
    0x004cbe88 jne 0x4cbea0                                                                          |             
    0x004cbe8a mov rax, qword [rip + 0x285427]                                                       |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cbe91 test rax, rax                                                                         |             
                                                                                                     |             if (rax != 0) {
    0x004cbe94 jne 0x4cbea0                                                                          |                 goto label_11;
                                                                                                     |             }
    0x004cbe96 call 0x4eede0                                                                         |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cbe9b nop dword [rax + rax]                                                                 |             
                                                                                                     |         }
                                                                                                     | label_11:
    0x004cbea0 cmp qword [rsp + 0x48], 6                                                             |         
    0x004cbea6 mov ebx, dword [rsp + 0x14]                                                           |         ebx = *((rsp + 0x14));
                                                                                                     |         if (*((rsp + 0x48)) < 6) {
    0x004cbeaa jb 0x4cc111                                                                           |             goto label_10;
                                                                                                     |         }
    0x004cbeb0 lea rax, [r15*8 + 0x74f9e0]                                                           |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbeb8 lea rcx, [r13*8 + 0x74f9e0]                                                           |         rcx = r13*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbec0 mov rsi, qword [rsp + 0x18]                                                           |         rsi = *((rsp + 0x18));
    0x004cbec5 lea edx, [rsi + r15]                                                                  |         edx = rsi + r15;
    0x004cbec9 movsxd r9, edx                                                                        |         r9 = (int64_t) edx;
    0x004cbecc shl r9, 3                                                                             |         r9 <<= 3;
    0x004cbed0 lea rdi, [r15*8]                                                                      |         rdi = r15*8;
    0x004cbed8 mov r10, r9                                                                           |         r10 = r9;
    0x004cbedb sub r10, rdi                                                                          |         r10 -= rdi;
    0x004cbede add r10, 0xfffffffffffffff8                                                           |         r10 += 0xfffffffffffffff8;
    0x004cbee2 cmp r10, 0x18                                                                         |         
                                                                                                     |         if (r10 < 0x18) {
    0x004cbee6 jb 0x4cc0f0                                                                           |             goto label_12;
                                                                                                     |         }
    0x004cbeec mov dword [rsp + 0x50], r14d                                                          |         *((rsp + 0x50)) = r14d;
    0x004cbef1 mov r11, rbp                                                                          |         r11 = rbp;
    0x004cbef4 lea rbp, [r13*8 + 0x74f9e0]                                                           |         rbp = r13*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbefc lea edx, [rsi + r15]                                                                  |         edx = rsi + r15;
    0x004cbf00 movsxd rdx, edx                                                                       |         rdx = (int64_t) edx;
    0x004cbf03 lea rbx, [rdx*8 + 0x74f9e0]                                                           |         rbx = rdx*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbf0b cmp rbp, rbx                                                                          |         
                                                                                                     |         if (rbp >= rbx) {
    0x004cbf0e jae 0x4cbfb7                                                                          |             goto label_13;
                                                                                                     |         }
    0x004cbf14 shl rdx, 3                                                                            |         rdx <<= 3;
    0x004cbf18 sub rdx, rdi                                                                          |         rdx -= rdi;
    0x004cbf1b lea rdx, [rdx + r13*8 + 0x74f9e0]                                                     |         rdx = rdx + r13*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbf23 lea rbp, [r15*8 + 0x74f9e0]                                                           |         rbp = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbf2b cmp rbp, rdx                                                                          |         
                                                                                                     |         if (rbp >= rdx) {
    0x004cbf2e jae 0x4cbfb7                                                                          |             goto label_13;
                                                                                                     |         }
    0x004cbf34 mov rbp, r11                                                                          |         
    0x004cbf37 mov r14d, dword [rsp + 0x50]                                                          |         r14d = *((rsp + 0x50));
    0x004cbf3c mov ebx, dword [rsp + 0x14]                                                           |         ebx = *((rsp + 0x14));
    0x004cbf40 jmp 0x4cc0f0                                                                          |         goto label_12;
    0x004cbf45 mov ebx, 1                                                                            |         ebx = 1;
    0x004cbf4a mov rax, qword [rip + 0x285367]                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cbf51 test rax, rax                                                                         |         
    0x004cbf54 jne 0x4cbe02                                                                          |         
                                                                                                     |     }
    0x004cbf5a call 0x4eede0                                                                         |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cbf5f jmp 0x4cbe02                                                                          |     goto label_0;
                                                                                                     | label_13:
    0x004cbfb7 shr r10, 3                                                                            |     r10 >>= 3;
    0x004cbfbb inc r10                                                                               |     r10++;
    0x004cbfbe mov r8, r10                                                                           |     r8 = r10;
    0x004cbfc1 and r8, 0xfffffffffffffffc                                                            |     r8 &= 0xfffffffffffffffc;
    0x004cbfc5 lea rdx, [r8 - 4]                                                                     |     rdx = r8 - 4;
    0x004cbfc9 mov rbp, rdx                                                                          |     
    0x004cbfcc shr rbp, 2                                                                            |     rbp >>= 2;
    0x004cbfd0 inc rbp                                                                               |     rbp++;
    0x004cbfd3 mov ebx, ebp                                                                          |     ebx = ebp;
    0x004cbfd5 and ebx, 3                                                                            |     ebx &= 3;
    0x004cbfd8 cmp rdx, 0xc                                                                          |     
                                                                                                     |     if (rdx < 0xc) {
    0x004cbfdc jae 0x4cbfe5                                                                          |         
    0x004cbfde xor edx, edx                                                                          |         edx = 0;
    0x004cbfe0 jmp 0x4cc08a                                                                          |         goto label_14;
                                                                                                     |     }
    0x004cbfe5 and rbp, 0xfffffffffffffffc                                                           |     rbp &= 0xfffffffffffffffc;
    0x004cbfe9 neg rbp                                                                               |     rbp = -rbp;
    0x004cbfec xor edx, edx                                                                          |     edx = 0;
    0x004cbfee nop                                                                                   |     
                                                                                                     |     do {
    0x004cbff0 movups xmm0, xmmword [rdi + rdx*8 + 0x74f9e0]                                         |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u]");
    0x004cbff8 movups xmm1, xmmword [rdi + rdx*8 + 0x74f9f0]                                         |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f9f0]");
    0x004cc000 lea rsi, [r13*8]                                                                      |         rsi = r13*8;
    0x004cc008 movups xmmword [rsi + rdx*8 + 0x74f9e0], xmm0                                         |         __asm ("movups xmmword [rsi + rdx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cc010 movups xmmword [rsi + rdx*8 + 0x74f9f0], xmm1                                         |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f9f0], xmm1");
    0x004cc018 movups xmm0, xmmword [rdi + rdx*8 + 0x74fa00]                                         |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74fa00]");
    0x004cc020 movups xmm1, xmmword [rdi + rdx*8 + 0x74fa10]                                         |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74fa10]");
    0x004cc028 movups xmmword [rsi + rdx*8 + 0x74fa00], xmm0                                         |         __asm ("movups xmmword [rsi + rdx*8 + 0x74fa00], xmm0");
    0x004cc030 movups xmmword [rsi + rdx*8 + 0x74fa10], xmm1                                         |         __asm ("movups xmmword [rsi + rdx*8 + 0x74fa10], xmm1");
    0x004cc038 movups xmm0, xmmword [rdi + rdx*8 + 0x74fa20]                                         |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74fa20]");
    0x004cc040 movups xmm1, xmmword [rdi + rdx*8 + 0x74fa30]                                         |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74fa30]");
    0x004cc048 movups xmmword [rsi + rdx*8 + 0x74fa20], xmm0                                         |         __asm ("movups xmmword [rsi + rdx*8 + 0x74fa20], xmm0");
    0x004cc050 movups xmmword [rsi + rdx*8 + 0x74fa30], xmm1                                         |         __asm ("movups xmmword [rsi + rdx*8 + 0x74fa30], xmm1");
    0x004cc058 movdqu xmm0, xmmword [rdi + rdx*8 + 0x74fa40]                                         |         __asm ("movdqu xmm0, xmmword [rdi + rdx*8 + 0x74fa40]");
    0x004cc061 movdqu xmm1, xmmword [rdi + rdx*8 + 0x74fa50]                                         |         __asm ("movdqu xmm1, xmmword [rdi + rdx*8 + 0x74fa50]");
    0x004cc06a movdqu xmmword [rsi + rdx*8 + 0x74fa40], xmm0                                         |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74fa40], xmm0");
    0x004cc073 movdqu xmmword [rsi + rdx*8 + 0x74fa50], xmm1                                         |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74fa50], xmm1");
    0x004cc07c add rdx, 0x10                                                                         |         rdx += 0x10;
    0x004cc080 add rbp, 4                                                                            |         rbp += 4;
    0x004cc084 jne 0x4cbff0                                                                          |         
                                                                                                     |     } while (rbp != 0);
                                                                                                     | label_14:
    0x004cc08a test rbx, rbx                                                                         |     
                                                                                                     |     if (rbx == 0) {
    0x004cc08d je 0x4cc0d0                                                                           |         goto label_15;
                                                                                                     |     }
    0x004cc08f shl r13, 3                                                                            |     r13 <<= 3;
    0x004cc093 lea rbp, [r13 + rdx*8 + 0x74f9f0]                                                     |     rbp = r13 + rdx*8 + 0x74f9f0;
    0x004cc09b lea rdx, [rdi + rdx*8 + 0x74f9f0]                                                     |     rdx = rdi + rdx*8 + 0x74f9f0;
    0x004cc0a3 shl rbx, 5                                                                            |     rbx <<= 5;
    0x004cc0a7 xor edi, edi                                                                          |     edi = 0;
    0x004cc0a9 nop dword [rax]                                                                       |     
                                                                                                     |     do {
    0x004cc0b0 movdqu xmm0, xmmword [rdx + rdi - 0x10]                                               |         __asm ("movdqu xmm0, xmmword [rdx + rdi - 0x10]");
    0x004cc0b6 movdqu xmm1, xmmword [rdx + rdi]                                                      |         __asm ("movdqu xmm1, xmmword [rdx + rdi]");
    0x004cc0bb movdqu xmmword [rbp + rdi - 0x10], xmm0                                               |         __asm ("movdqu xmmword [rbp + rdi - 0x10], xmm0");
    0x004cc0c1 movdqu xmmword [rbp + rdi], xmm1                                                      |         __asm ("movdqu xmmword [rbp + rdi], xmm1");
    0x004cc0c7 add rdi, 0x20                                                                         |         rdi += 0x20;
    0x004cc0cb cmp rbx, rdi                                                                          |         
    0x004cc0ce jne 0x4cc0b0                                                                          |         
                                                                                                     |     } while (rbx != rdi);
                                                                                                     | label_15:
    0x004cc0d0 cmp r10, r8                                                                           |     
    0x004cc0d3 mov rbp, r11                                                                          |     
    0x004cc0d6 mov r14d, dword [rsp + 0x50]                                                          |     r14d = *((rsp + 0x50));
    0x004cc0db mov ebx, dword [rsp + 0x14]                                                           |     ebx = *((rsp + 0x14));
                                                                                                     |     if (r10 == r8) {
    0x004cc0df je 0x4cc111                                                                           |         goto label_10;
                                                                                                     |     }
    0x004cc0e1 lea rax, [rax + r8*8]                                                                 |     rax = rax + r8*8;
    0x004cc0e5 lea rcx, [rcx + r8*8]                                                                 |     rcx = rcx + r8*8;
    0x004cc0e9 nop dword [rax]                                                                       |     
                                                                                                     | label_12:
    0x004cc0f0 sub r9, rax                                                                           |     r9 -= rax;
    0x004cc0f3 lea rdx, [r9 + 0x74f9e0]                                                              |     rdx = r9 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cc0fa xor esi, esi                                                                          |     esi = 0;
    0x004cc0fc nop dword [rax]                                                                       |     
                                                                                                     |     do {
    0x004cc100 mov rdi, qword [rax + rsi]                                                            |         rdi = *((rax + rsi));
    0x004cc104 mov qword [rcx + rsi], rdi                                                            |         *((rcx + rsi)) = rdi;
    0x004cc108 add rsi, 8                                                                            |         rsi += 8;
    0x004cc10c cmp rdx, rsi                                                                          |         
    0x004cc10f jne 0x4cc100                                                                          |         
                                                                                                     |     } while (rdx != rsi);
                                                                                                     | label_10:
    0x004cc111 cmp byte [rip + 0x24c878], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc118 je 0x4cc13a                                                                           |         
    0x004cc11a mov edx, dword [rip + 0x24c884]                                                       |         edx = numCopyCtorCalls;
    0x004cc120 sub edx, r12d                                                                         |         edx -= r12d;
    0x004cc123 mov ecx, dword [rip + 0x24c883]                                                       |         ecx = numCharCtorCalls;
    0x004cc129 sub ecx, r14d                                                                         |         ecx -= r14d;
    0x004cc12c mov edi, 0x4f5db4                                                                     |         
    0x004cc131 mov esi, ebx                                                                          |         esi = ebx;
    0x004cc133 xor eax, eax                                                                          |         eax = 0;
    0x004cc135 call 0x401680                                                                         |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                     |     }
                                                                                                     | label_9:
    0x004cc13a cmp byte [rsp + 0x40], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x40)) == 0) {
    0x004cc13f je 0x4cc1a0                                                                           |         goto label_16;
                                                                                                     |     }
    0x004cc141 cmp r12d, dword [rip + 0x24c85c]                                                      |     
                                                                                                     |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004cc148 je 0x4cc173                                                                           |         
    0x004cc14a mov edi, 0x4f4e04                                                                     |         
    0x004cc14f mov edx, 0x4f5176                                                                     |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cc154 mov esi, 0x1005                                                                       |         esi = 0x1005;
    0x004cc159 xor eax, eax                                                                          |         eax = 0;
    0x004cc15b call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc160 mov eax, dword [rip + 0x24c832]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc166 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc169 ja 0x4cc173                                                                           |             goto label_17;
                                                                                                     |         }
    0x004cc16b inc eax                                                                               |         eax++;
    0x004cc16d mov dword [rip + 0x24c825], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_17:
    0x004cc173 cmp r14d, dword [rip + 0x24c832]                                                      |     
                                                                                                     |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004cc17a je 0x4cbca0                                                                           |         goto label_1;
                                                                                                     |     }
    0x004cc180 mov edi, 0x4f4e04                                                                     |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004cc185 mov edx, 0x4f5de4                                                                     |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cc18a mov esi, 0x1006                                                                       |     esi = 0x1006;
    0x004cc18f jmp 0x4cc1f3                                                                          |     goto label_18;
                                                                                                     | label_16:
    0x004cc1a0 add r12d, dword [rsp + 0x18]                                                          |     r12d += *((rsp + 0x18));
    0x004cc1a5 cmp r12d, dword [rip + 0x24c7f8]                                                      |     
                                                                                                     |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004cc1ac jle 0x4cc1d7                                                                          |         
    0x004cc1ae mov edi, 0x4f4e04                                                                     |         
    0x004cc1b3 mov edx, 0x4f5e02                                                                     |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004cc1b8 mov esi, 0x1009                                                                       |         esi = 0x1009;
    0x004cc1bd xor eax, eax                                                                          |         eax = 0;
    0x004cc1bf call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc1c4 mov eax, dword [rip + 0x24c7ce]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc1ca cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc1cd ja 0x4cc1d7                                                                           |             goto label_19;
                                                                                                     |         }
    0x004cc1cf inc eax                                                                               |         eax++;
    0x004cc1d1 mov dword [rip + 0x24c7c1], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_19:
    0x004cc1d7 cmp r14d, dword [rip + 0x24c7ce]                                                      |     
                                                                                                     |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004cc1de je 0x4cbca0                                                                           |         goto label_1;
                                                                                                     |     }
    0x004cc1e4 mov edi, 0x4f4e04                                                                     |     
    0x004cc1e9 mov edx, 0x4f5de4                                                                     |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cc1ee mov esi, 0x100a                                                                       |     esi = 0x100a;
                                                                                                     | label_18:
    0x004cc1f3 xor eax, eax                                                                          |     eax = 0;
    0x004cc1f5 call 0x401680                                                                         |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc1fa mov eax, dword [rip + 0x24c798]                                                       |     eax = (anonymous namespace)::testStatus;
    0x004cc200 cmp eax, 0x64                                                                         |     
                                                                                                     |     if (eax > 0x64) {
    0x004cc203 ja 0x4cbca0                                                                           |         goto label_1;
                                                                                                     |     }
    0x004cc209 inc eax                                                                               |     eax++;
    0x004cc20b mov dword [rip + 0x24c787], eax                                                       |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cc211 jmp 0x4cbca0                                                                          |     goto label_1;
                                                                                                     | label_5:
    0x004cc216 cmp byte [rip + 0x24c779], 0                                                          |     
                                                                                                     |     if (*(obj.verbose) != 0) {
    0x004cc21d je 0x4cc229                                                                           |         
    0x004cc21f mov edi, 0x4f695c                                                                     |         
    0x004cc224 call 0x401710                                                                         |         puts ("\t\tfrom different type.");
                                                                                                     |     }
    0x004cc229 xor r12d, r12d                                                                        |     r12d = 0;
    0x004cc22c jmp 0x4cc257                                                                          |     goto label_20;
                                                                                                     | label_3:
    0x004cc230 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc235 mov rsi, rbx                                                                          |     rsi = rbx;
    0x004cc238 call 0x4e39b0                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc23d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc242 mov rsi, rbx                                                                          |     rsi = rbx;
    0x004cc245 call 0x4e3bf0                                                                         |     voidcleanup<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc24a inc r12                                                                               |     r12++;
    0x004cc24d cmp r12, 0x1e                                                                         |     
                                                                                                     |     if (r12 == 0x1e) {
    0x004cc251 je 0x4cc87d                                                                           |         goto label_21;
                                                                                                     |     }
                                                                                                     | label_20:
    0x004cc257 lea rbx, [r12*8]                                                                      |     rbx = r12*8;
    0x004cc25f mov rbp, qword [rbx + rbx*4 + 0x4f3c98]                                               |     rbp = *((rbx + rbx*4 + 0x4f3c98));
    0x004cc267 mov rdi, rbp                                                                          |     
    0x004cc26a call 0x401790                                                                         |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004cc26f cmp eax, 0x11                                                                         |     
                                                                                                     |     if (eax >= 0x11) {
    0x004cc272 jl 0x4cc29d                                                                           |         
    0x004cc274 mov edi, 0x4f4e04                                                                     |         
    0x004cc279 mov edx, 0x4f4393                                                                     |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cc27e mov esi, 0x1019                                                                       |         esi = 0x1019;
    0x004cc283 xor eax, eax                                                                          |         eax = 0;
    0x004cc285 call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc28a mov eax, dword [rip + 0x24c708]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc290 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc293 ja 0x4cc29d                                                                           |             goto label_22;
                                                                                                     |         }
    0x004cc295 inc eax                                                                               |         eax++;
    0x004cc297 mov dword [rip + 0x24c6fb], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_22:
    0x004cc29d mov rdi, rbp                                                                          |     
    0x004cc2a0 call 0x401790                                                                         |     rax = strlen (rbp);
    0x004cc2a5 cmp rax, 0x14                                                                         |     
                                                                                                     |     if (rax >= 0x14) {
    0x004cc2a9 jb 0x4cc2d4                                                                           |         
    0x004cc2ab mov edi, 0x4f4e04                                                                     |         
    0x004cc2b0 mov edx, 0x4f5e26                                                                     |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004cc2b5 mov esi, 0x101c                                                                       |         esi = 0x101c;
    0x004cc2ba xor eax, eax                                                                          |         eax = 0;
    0x004cc2bc call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc2c1 mov eax, dword [rip + 0x24c6d1]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc2c7 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc2ca ja 0x4cc2d4                                                                           |             goto label_23;
                                                                                                     |         }
    0x004cc2cc inc eax                                                                               |         eax++;
    0x004cc2ce mov dword [rip + 0x24c6c4], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_23:
    0x004cc2d4 mov qword [rsp + 0x18], r12                                                           |     *((rsp + 0x18)) = r12;
    0x004cc2d9 pxor xmm0, xmm0                                                                       |     xmm0 = 0;
    0x004cc2dd movdqa xmmword [rsp + 0x20], xmm0                                                     |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004cc2e3 mov dword [rsp + 0x30], 0                                                             |     *((rsp + 0x30)) = 0;
    0x004cc2eb mov al, byte [rbp]                                                                    |     al = *(rbp);
    0x004cc2ee test al, al                                                                           |     
                                                                                                     |     if (al == 0) {
    0x004cc2f0 je 0x4cc310                                                                           |         goto label_24;
                                                                                                     |     }
    0x004cc2f2 xor ecx, ecx                                                                          |     ecx = 0;
    0x004cc2f4 nop word cs:[rax + rax]                                                               |     
    0x004cc2fe nop                                                                                   |     
                                                                                                     |     do {
    0x004cc300 mov byte [rsp + rcx + 0x20], al                                                       |         *((rsp + rcx + 0x20)) = al;
    0x004cc304 movzx eax, byte [rbp + rcx + 1]                                                       |         eax = *((rbp + rcx + 1));
    0x004cc309 inc rcx                                                                               |         rcx++;
    0x004cc30c test al, al                                                                           |         
    0x004cc30e jne 0x4cc300                                                                          |         
                                                                                                     |     } while (al != 0);
                                                                                                     | label_24:
    0x004cc310 mov r14d, dword [rbx + rbx*4 + 0x4f3c90]                                              |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004cc318 movsxd r13, dword [rbx + rbx*4 + 0x4f3ca0]                                            |     r13 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004cc320 movsxd r12, dword [rbx + rbx*4 + 0x4f3ca4]                                            |     r12 = *((rbx + rbx*4 + 0x4f3ca4));
    0x004cc328 movsxd r15, dword [rbx + rbx*4 + 0x4f3ca8]                                            |     r15 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004cc330 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                               |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004cc338 cmp byte [rip + 0x24c651], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc33f je 0x4cc360                                                                           |         
    0x004cc341 mov qword [rsp], rbx                                                                  |         *(rsp) = rbx;
    0x004cc345 mov edi, 0x4f5c41                                                                     |         
    0x004cc34a mov esi, r14d                                                                         |         esi = r14d;
    0x004cc34d mov rdx, rbp                                                                          |         rdx = rbp;
    0x004cc350 mov ecx, r13d                                                                         |         ecx = r13d;
    0x004cc353 mov r8d, r12d                                                                         |         r8d = r12d;
    0x004cc356 mov r9d, r15d                                                                         |         r9d = r15d;
    0x004cc359 xor eax, eax                                                                          |         eax = 0;
    0x004cc35b call 0x401680                                                                         |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                     |     }
    0x004cc360 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc365 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cc368 call 0x4e38d0                                                                         |     intconstvolatile*&gg<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc36d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc372 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cc375 call 0x4e39b0                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc37a mov eax, dword [rip + 0x24c624]                                                       |     eax = numCopyCtorCalls;
    0x004cc380 mov dword [rsp + 0x48], eax                                                           |     *((rsp + 0x48)) = eax;
    0x004cc384 mov eax, dword [rip + 0x24c622]                                                       |     eax = numCharCtorCalls;
    0x004cc38a mov dword [rsp + 0x14], eax                                                           |     *((rsp + 0x14)) = eax;
    0x004cc38e cmp byte [rsp + 0x54], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x54)) == 0) {
    0x004cc393 je 0x4cc460                                                                           |         goto label_25;
                                                                                                     |     }
    0x004cc399 cmp byte [rip + 0x24c5f0], 0                                                          |     
    0x004cc3a0 mov ebp, r14d                                                                         |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc3a3 je 0x4cc3b8                                                                           |         
    0x004cc3a5 cmp dword [rip + 0x24c208], 0                                                         |         
                                                                                                     |         if (*(0x007185b4) == 0) {
    0x004cc3ac je 0x4cc3b8                                                                           |             goto label_26;
                                                                                                     |         }
    0x004cc3ae mov edi, 0x4f43ea                                                                     |         
    0x004cc3b3 call 0x401710                                                                         |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                     |     }
                                                                                                     | label_26:
    0x004cc3b8 mov dword [rip + 0x24c1f2], 0                                                         |     *(0x007185b4) = 0;
    0x004cc3c2 cmp byte [rip + 0x24c5cc], 0                                                          |     
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cc3c9 je 0x4cc3d5                                                                           |         
    0x004cc3cb mov edi, 0x4f4411                                                                     |         
    0x004cc3d0 call 0x401710                                                                         |         puts ("\t\tBegin bslma exception test.");
                                                                                                     |     }
    0x004cc3d5 mov rax, qword [rip + 0x24c444]                                                       |     rax = Z;
    0x004cc3dc mov qword [rsp + 0x58], 0x4f69e0                                                      |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cc3e5 mov qword [rsp + 0x60], rax                                                           |     *((rsp + 0x60)) = rax;
    0x004cc3ea mov qword [rax + 0x20], 0                                                             |     *((rax + 0x20)) = 0;
    0x004cc3f2 test rax, rax                                                                         |     
    0x004cc3f5 je 0x4cc4ed                                                                           |     
                                                                                                     |     while (rax != 0) {
                                                                                                     | label_2:
    0x004cc3fb cmp qword [rsp + 0x18], 6                                                             |         
                                                                                                     |         if (*((rsp + 0x18)) < 6) {
    0x004cc401 jb 0x4cc7d1                                                                           |             goto label_27;
                                                                                                     |         }
    0x004cc407 lea rcx, [rsp + r13 + 0x20]                                                           |         rcx = rsp + r13 + 0x20;
    0x004cc40c lea rsi, [r15*8 + 0x74f9e0]                                                           |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cc414 lea eax, [r13 + r12]                                                                  |         eax = r13 + r12;
    0x004cc419 movsxd r9, eax                                                                        |         r9 = (int64_t) eax;
    0x004cc41c mov r10, r9                                                                           |         r10 = r9;
    0x004cc41f sub r10, r13                                                                          |         r10 -= r13;
    0x004cc422 cmp r10, 4                                                                            |         
                                                                                                     |         if (r10 < 4) {
    0x004cc426 jb 0x4cc7b6                                                                           |             goto label_28;
                                                                                                     |         }
    0x004cc42c mov r11, rbx                                                                          |         r11 = rbx;
    0x004cc42f mov r8, r10                                                                           |         r8 = r10;
    0x004cc432 and r8, 0xfffffffffffffffc                                                            |         r8 &= 0xfffffffffffffffc;
    0x004cc436 lea rax, [r8 - 4]                                                                     |         rax = r8 - 4;
    0x004cc43a mov rbp, rax                                                                          |         
    0x004cc43d shr rbp, 2                                                                            |         rbp >>= 2;
    0x004cc441 inc rbp                                                                               |         rbp++;
    0x004cc444 mov edi, ebp                                                                          |         edi = ebp;
    0x004cc446 and edi, 3                                                                            |         edi &= 3;
    0x004cc449 cmp rax, 0xc                                                                          |         
                                                                                                     |         if (rax >= 0xc) {
    0x004cc44d jae 0x4cc6a6                                                                          |             goto label_29;
                                                                                                     |         }
    0x004cc453 xor ebx, ebx                                                                          |         ebx = 0;
    0x004cc455 jmp 0x4cc755                                                                          |         goto label_30;
                                                                                                     | label_25:
    0x004cc460 cmp qword [rip + 0x24c3b8], 0                                                         |         
    0x004cc468 mov ebp, r14d                                                                         |         
    0x004cc46b mov r11, r12                                                                          |         r11 = r12;
                                                                                                     |         if (*(obj.Z) == 0) {
    0x004cc46e jne 0x4cc490                                                                          |             
    0x004cc470 mov rax, qword [rip + 0x284e41]                                                       |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cc477 test rax, rax                                                                         |             
                                                                                                     |             if (rax != 0) {
    0x004cc47a jne 0x4cc490                                                                          |                 goto label_31;
                                                                                                     |             }
    0x004cc47c call 0x4eede0                                                                         |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cc481 mov r11, r12                                                                          |             r11 = r12;
    0x004cc484 nop word cs:[rax + rax]                                                               |             
    0x004cc48e nop                                                                                   |             
                                                                                                     |         }
                                                                                                     | label_31:
    0x004cc490 mov r12, qword [rsp + 0x18]                                                           |         r12 = *((rsp + 0x18));
    0x004cc495 cmp r12, 6                                                                            |         
                                                                                                     |         if (r12 < 6) {
    0x004cc499 jb 0x4cc810                                                                           |             goto label_32;
                                                                                                     |         }
    0x004cc49f lea rax, [r15*8 + 0x74f9e0]                                                           |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cc4a7 lea rcx, [rsp + r13 + 0x20]                                                           |         rcx = rsp + r13 + 0x20;
    0x004cc4ac add r11, r13                                                                          |         r11 += r13;
    0x004cc4af mov r9, r11                                                                           |         r9 = r11;
    0x004cc4b2 sub r9, r13                                                                           |         r9 -= r13;
    0x004cc4b5 cmp r9, 4                                                                             |         
                                                                                                     |         if (r9 < 4) {
    0x004cc4b9 jb 0x4cc67a                                                                           |             goto label_33;
                                                                                                     |         }
    0x004cc4bf mov r10, rbx                                                                          |         r10 = rbx;
    0x004cc4c2 mov r8, r9                                                                            |         r8 = r9;
    0x004cc4c5 and r8, 0xfffffffffffffffc                                                            |         r8 &= 0xfffffffffffffffc;
    0x004cc4c9 lea rsi, [r8 - 4]                                                                     |         rsi = r8 - 4;
    0x004cc4cd mov rdi, rsi                                                                          |         rdi = rsi;
    0x004cc4d0 shr rdi, 2                                                                            |         rdi >>= 2;
    0x004cc4d4 inc rdi                                                                               |         rdi++;
    0x004cc4d7 mov ebp, edi                                                                          |         
    0x004cc4d9 and ebp, 3                                                                            |         ebp &= 3;
    0x004cc4dc cmp rsi, 0xc                                                                          |         
                                                                                                     |         if (rsi >= 0xc) {
    0x004cc4e0 jae 0x4cc56d                                                                          |             goto label_34;
                                                                                                     |         }
    0x004cc4e6 xor ebx, ebx                                                                          |         ebx = 0;
    0x004cc4e8 jmp 0x4cc615                                                                          |         goto label_35;
    0x004cc4ed mov eax, 1                                                                            |         eax = 1;
    0x004cc4f2 mov qword [rsp + 0x40], rax                                                           |         *((rsp + 0x40)) = rax;
    0x004cc4f7 mov rax, qword [rip + 0x284dba]                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cc4fe test rax, rax                                                                         |         
    0x004cc501 jne 0x4cc3fb                                                                          |         
                                                                                                     |     }
    0x004cc507 call 0x4eede0                                                                         |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cc50c jmp 0x4cc3fb                                                                          |     goto label_2;
                                                                                                     | label_34:
    0x004cc56d lea rdx, [rsp + 0x2e]                                                                 |     rdx = rsp + 0x2e;
    0x004cc572 lea rsi, [rdx + r13]                                                                  |     rsi = rdx + r13;
    0x004cc576 and rdi, 0xfffffffffffffffc                                                           |     rdi &= 0xfffffffffffffffc;
    0x004cc57a neg rdi                                                                               |     rdi = -rdi;
    0x004cc57d xor ebx, ebx                                                                          |     ebx = 0;
    0x004cc57f nop                                                                                   |     
                                                                                                     |     do {
    0x004cc580 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                                 |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cc587 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                                 |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cc58e lea rdx, [r15*8]                                                                      |         rdx = r15*8;
    0x004cc596 movdqu xmmword [rdx + rbx*8 + 0x74f9e0], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cc59f movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1");
    0x004cc5a8 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                                 |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cc5af pmovsxbq xmm1, word [rsi + rbx - 8]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cc5b6 movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0");
    0x004cc5bf movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1");
    0x004cc5c8 pmovsxbq xmm0, word [rsi + rbx - 6]                                                   |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cc5cf pmovsxbq xmm1, word [rsi + rbx - 4]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cc5d6 movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0");
    0x004cc5df movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1");
    0x004cc5e8 pmovsxbq xmm0, word [rsi + rbx - 2]                                                   |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cc5ef pmovsxbq xmm1, word [rsi + rbx]                                                       |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cc5f5 movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0");
    0x004cc5fe movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1");
    0x004cc607 add rbx, 0x10                                                                         |         rbx += 0x10;
    0x004cc60b add rdi, 4                                                                            |         rdi += 4;
    0x004cc60f jne 0x4cc580                                                                          |         
                                                                                                     |     } while (rdi != 0);
                                                                                                     | label_35:
    0x004cc615 test rbp, rbp                                                                         |     
                                                                                                     |     if (rbp == 0) {
    0x004cc618 je 0x4cc664                                                                           |         goto label_36;
                                                                                                     |     }
    0x004cc61a add r13, rbx                                                                          |     r13 += rbx;
    0x004cc61d lea rdx, [rsp + 0x22]                                                                 |     rdx = rsp + 0x22;
    0x004cc622 add r13, rdx                                                                          |     r13 += rdx;
    0x004cc625 shl r15, 3                                                                            |     r15 <<= 3;
    0x004cc629 lea rsi, [r15 + rbx*8 + 0x74f9f0]                                                     |     rsi = r15 + rbx*8 + 0x74f9f0;
    0x004cc631 shl rbp, 2                                                                            |     rbp <<= 2;
    0x004cc635 xor edi, edi                                                                          |     edi = 0;
    0x004cc637 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc640 pmovsxbq xmm0, word [r13 + rdi - 2]                                                   |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cc648 pmovsxbq xmm1, word [r13 + rdi]                                                       |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cc650 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                             |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cc656 movdqu xmmword [rsi + rdi*8], xmm1                                                    |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cc65b add rdi, 4                                                                            |         rdi += 4;
    0x004cc65f cmp rbp, rdi                                                                          |         
    0x004cc662 jne 0x4cc640                                                                          |         
                                                                                                     |     } while (rbp != rdi);
                                                                                                     | label_36:
    0x004cc664 cmp r9, r8                                                                            |     
    0x004cc667 mov rbx, r10                                                                          |     rbx = r10;
    0x004cc66a mov ebp, r14d                                                                         |     
                                                                                                     |     if (r9 == r8) {
    0x004cc66d je 0x4cc810                                                                           |         goto label_32;
                                                                                                     |     }
    0x004cc673 add rcx, r8                                                                           |     rcx += r8;
    0x004cc676 lea rax, [rax + r8*8]                                                                 |     rax = rax + r8*8;
                                                                                                     | label_33:
    0x004cc67a sub r11, rcx                                                                          |     r11 -= rcx;
    0x004cc67d lea rdx, [rsp + r11 + 0x20]                                                           |     rdx = rsp + r11 + 0x20;
    0x004cc682 xor esi, esi                                                                          |     esi = 0;
    0x004cc684 nop word cs:[rax + rax]                                                               |     
    0x004cc68e nop                                                                                   |     
                                                                                                     |     do {
    0x004cc690 movsx rdi, byte [rcx + rsi]                                                           |         rdi = *((rcx + rsi));
    0x004cc695 mov qword [rax + rsi*8], rdi                                                          |         *((rax + rsi*8)) = rdi;
    0x004cc699 inc rsi                                                                               |         rsi++;
    0x004cc69c cmp rdx, rsi                                                                          |         
    0x004cc69f jne 0x4cc690                                                                          |         
                                                                                                     |     } while (rdx != rsi);
    0x004cc6a1 jmp 0x4cc810                                                                          |     goto label_32;
                                                                                                     | label_29:
    0x004cc6a6 lea rax, [rsp + 0x2e]                                                                 |     rax = rsp + 0x2e;
    0x004cc6ab add rax, r13                                                                          |     rax += r13;
    0x004cc6ae and rbp, 0xfffffffffffffffc                                                           |     rbp &= 0xfffffffffffffffc;
    0x004cc6b2 neg rbp                                                                               |     rbp = -rbp;
    0x004cc6b5 xor ebx, ebx                                                                          |     ebx = 0;
    0x004cc6b7 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc6c0 pmovsxbq xmm0, word [rax + rbx - 0xe]                                                 |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cc6c7 pmovsxbq xmm1, word [rax + rbx - 0xc]                                                 |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cc6ce lea rdx, [r15*8]                                                                      |         rdx = r15*8;
    0x004cc6d6 movdqu xmmword [rdx + rbx*8 + 0x74f9e0], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cc6df movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1");
    0x004cc6e8 pmovsxbq xmm0, word [rax + rbx - 0xa]                                                 |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cc6ef pmovsxbq xmm1, word [rax + rbx - 8]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cc6f6 movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0");
    0x004cc6ff movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1");
    0x004cc708 pmovsxbq xmm0, word [rax + rbx - 6]                                                   |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cc70f pmovsxbq xmm1, word [rax + rbx - 4]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cc716 movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0");
    0x004cc71f movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1");
    0x004cc728 pmovsxbq xmm0, word [rax + rbx - 2]                                                   |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cc72f pmovsxbq xmm1, word [rax + rbx]                                                       |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cc735 movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0");
    0x004cc73e movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1");
    0x004cc747 add rbx, 0x10                                                                         |         rbx += 0x10;
    0x004cc74b add rbp, 4                                                                            |         rbp += 4;
    0x004cc74f jne 0x4cc6c0                                                                          |         
                                                                                                     |     } while (rbp != 0);
                                                                                                     | label_30:
    0x004cc755 test rdi, rdi                                                                         |     
                                                                                                     |     if (rdi == 0) {
    0x004cc758 je 0x4cc7a4                                                                           |         goto label_37;
                                                                                                     |     }
    0x004cc75a add r13, rbx                                                                          |     r13 += rbx;
    0x004cc75d lea rax, [rsp + 0x22]                                                                 |     rax = rsp + 0x22;
    0x004cc762 add r13, rax                                                                          |     r13 += rax;
    0x004cc765 shl r15, 3                                                                            |     r15 <<= 3;
    0x004cc769 lea rax, [r15 + rbx*8 + 0x74f9f0]                                                     |     rax = r15 + rbx*8 + 0x74f9f0;
    0x004cc771 shl rdi, 2                                                                            |     rdi <<= 2;
    0x004cc775 xor ebp, ebp                                                                          |     ebp = 0;
    0x004cc777 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc780 pmovsxbq xmm0, word [r13 + rbp - 2]                                                   |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004cc788 pmovsxbq xmm1, word [r13 + rbp]                                                       |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004cc790 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                             |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004cc796 movdqu xmmword [rax + rbp*8], xmm1                                                    |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004cc79b add rbp, 4                                                                            |         rbp += 4;
    0x004cc79f cmp rdi, rbp                                                                          |         
    0x004cc7a2 jne 0x4cc780                                                                          |         
                                                                                                     |     } while (rdi != rbp);
                                                                                                     | label_37:
    0x004cc7a4 cmp r10, r8                                                                           |     
    0x004cc7a7 mov rbx, r11                                                                          |     rbx = r11;
    0x004cc7aa mov ebp, r14d                                                                         |     
                                                                                                     |     if (r10 == r8) {
    0x004cc7ad je 0x4cc7d1                                                                           |         goto label_27;
                                                                                                     |     }
    0x004cc7af add rcx, r8                                                                           |     rcx += r8;
    0x004cc7b2 lea rsi, [rsi + r8*8]                                                                 |     rsi = rsi + r8*8;
                                                                                                     | label_28:
    0x004cc7b6 sub r9, rcx                                                                           |     r9 -= rcx;
    0x004cc7b9 lea rax, [rsp + r9 + 0x20]                                                            |     rax = rsp + r9 + 0x20;
    0x004cc7be xor edi, edi                                                                          |     edi = 0;
                                                                                                     |     do {
    0x004cc7c0 movsx rdx, byte [rcx + rdi]                                                           |         rdx = *((rcx + rdi));
    0x004cc7c5 mov qword [rsi + rdi*8], rdx                                                          |         *((rsi + rdi*8)) = rdx;
    0x004cc7c9 inc rdi                                                                               |         rdi++;
    0x004cc7cc cmp rax, rdi                                                                          |         
    0x004cc7cf jne 0x4cc7c0                                                                          |         
                                                                                                     |     } while (rax != rdi);
                                                                                                     | label_27:
    0x004cc7d1 mov rax, qword [rsp + 0x58]                                                           |     rax = *((rsp + 0x58));
    0x004cc7d6 lea rdi, [rsp + 0x58]                                                                 |     rdi = rsp + 0x58;
    0x004cc7db mov rsi, 0xffffffffffffffff                                                           |     rsi = 0xffffffffffffffff;
    0x004cc7e2 call qword [rax + 0x10]                                                               |     uint64_t (*rax + 0x10)() ();
    0x004cc7e5 cmp byte [rip + 0x24c1a9], 0                                                          |     
    0x004cc7ec mov r12, qword [rsp + 0x18]                                                           |     r12 = *((rsp + 0x18));
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cc7f1 je 0x4cc7fd                                                                           |         
    0x004cc7f3 mov edi, 0x4f4571                                                                     |         
    0x004cc7f8 call 0x401710                                                                         |         puts ("\t\tEnd bslma exception test.");
                                                                                                     |     }
    0x004cc7fd cmp byte [rip + 0x24c18c], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc804 je 0x4cc83b                                                                           |         
    0x004cc806 mov edi, 0xa                                                                          |         
    0x004cc80b call 0x401720                                                                         |         eax = putchar (0xa);
                                                                                                     | label_32:
    0x004cc810 cmp byte [rip + 0x24c179], 0                                                          |         
                                                                                                     |         if (*(obj.veryVerbose) == 0) {
    0x004cc817 je 0x4cc83b                                                                           |             goto label_38;
                                                                                                     |         }
    0x004cc819 mov edx, dword [rip + 0x24c185]                                                       |         edx = numCopyCtorCalls;
    0x004cc81f sub edx, dword [rsp + 0x48]                                                           |         edx -= *((rsp + 0x48));
    0x004cc823 mov ecx, dword [rip + 0x24c183]                                                       |         ecx = numCharCtorCalls;
    0x004cc829 sub ecx, dword [rsp + 0x14]                                                           |         ecx -= *((rsp + 0x14));
    0x004cc82d mov edi, 0x4f5db4                                                                     |         
    0x004cc832 mov esi, ebp                                                                          |         esi = ebp;
    0x004cc834 xor eax, eax                                                                          |         eax = 0;
    0x004cc836 call 0x401680                                                                         |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                     |     }
                                                                                                     | label_38:
    0x004cc83b mov eax, dword [rsp + 0x48]                                                           |     eax = *((rsp + 0x48));
    0x004cc83f cmp eax, dword [rip + 0x24c15f]                                                       |     
                                                                                                     |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cc845 je 0x4cc230                                                                           |         goto label_3;
                                                                                                     |     }
    0x004cc84b mov edi, 0x4f4e04                                                                     |     
    0x004cc850 mov edx, 0x4f5176                                                                     |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cc855 mov esi, 0x103f                                                                       |     esi = 0x103f;
    0x004cc85a xor eax, eax                                                                          |     eax = 0;
    0x004cc85c call 0x401680                                                                         |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc861 mov eax, dword [rip + 0x24c131]                                                       |     eax = (anonymous namespace)::testStatus;
    0x004cc867 cmp eax, 0x64                                                                         |     
                                                                                                     |     if (eax > 0x64) {
    0x004cc86a ja 0x4cc230                                                                           |         goto label_3;
                                                                                                     |     }
    0x004cc870 inc eax                                                                               |     eax++;
    0x004cc872 mov dword [rip + 0x24c120], eax                                                       |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cc878 jmp 0x4cc230                                                                          |     goto label_3;
                                                                                                     | label_21:
    0x004cc87d add rsp, 0x68                                                                         |     
    0x004cc881 pop rbx                                                                               |     
    0x004cc882 pop r12                                                                               |     
    0x004cc884 pop r13                                                                               |     
    0x004cc886 pop r14                                                                               |     
    0x004cc888 pop r15                                                                               |     
    0x004cc88a pop rbp                                                                               |     
    0x004cc88b ret                                                                                   |     return rax;
                                                                                                     | }