; assembly                                                                                   | /* r2dec pseudo code output */
                                                                                                 | /* bslalg_arrayprimitives.t/none @ 0x4cb020 */
                                                                                                 | #include <stdint.h>
                                                                                                 |  
    ; (fcn) sym.void_testCopyConstructWithIterators_int_volatile__bool__bool__bool_ ()           | uint64_t void_testCopyConstructWithIterators_int_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 volatile*>(bool, bool, bool) */
    0x004cb020 push rbp                                                                          |     
    0x004cb021 push r15                                                                          |     
    0x004cb023 push r14                                                                          |     
    0x004cb025 push r13                                                                          |     
    0x004cb027 push r12                                                                          |     
    0x004cb029 push rbx                                                                          |     
    0x004cb02a sub rsp, 0x68                                                                     |     
    0x004cb02e mov dword [rsp + 0x54], edx                                                       |     *((rsp + 0x54)) = edx;
    0x004cb032 mov dword [rsp + 0x40], esi                                                       |     *((rsp + 0x40)) = esi;
    0x004cb036 cmp byte [rip + 0x24d959], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004cb03d je 0x4cb049                                                                       |         
    0x004cb03f mov edi, 0x4f6973                                                                 |         
    0x004cb044 call 0x401710                                                                     |         eax = puts ("\t\tfrom same type.");
                                                                                                 |     }
    0x004cb049 xor eax, eax                                                                      |     eax = 0;
    0x004cb04b jmp 0x4cb07c                                                                      |     goto label_4;
                                                                                                 | label_1:
    0x004cb050 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb055 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb058 call 0x4e34b0                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb05d mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb062 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb065 call 0x4e36f0                                                                     |     voidcleanup<intvolatile*>(intvolatile**,char const*) ();
    0x004cb06a mov rax, qword [rsp + 0x48]                                                       |     rax = *((rsp + 0x48));
    0x004cb06f inc rax                                                                           |     rax++;
    0x004cb072 cmp rax, 0x1e                                                                     |     
                                                                                                 |     if (rax == 0x1e) {
    0x004cb076 je 0x4cb5c6                                                                       |         goto label_5;
                                                                                                 |     }
                                                                                                 | label_4:
    0x004cb07c mov qword [rsp + 0x48], rax                                                       |     *((rsp + 0x48)) = rax;
    0x004cb081 lea rbp, [rax*8]                                                                  |     rbp = rax*8;
    0x004cb089 mov r12, qword [rbp + rbp*4 + 0x4f3c98]                                           |     r12 = *((rbp + rbp*4 + 0x4f3c98));
    0x004cb091 mov rdi, r12                                                                      |     
    0x004cb094 call 0x401790                                                                     |     eax = strlen (*((rbp + rbp*4 + 0x4f3c98)));
    0x004cb099 cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004cb09c jl 0x4cb0c7                                                                       |         
    0x004cb09e mov edi, 0x4f4e04                                                                 |         
    0x004cb0a3 mov edx, 0x4f4393                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cb0a8 mov esi, 0xfe6                                                                    |         esi = 0xfe6;
    0x004cb0ad xor eax, eax                                                                      |         eax = 0;
    0x004cb0af call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb0b4 mov eax, dword [rip + 0x24d8de]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb0ba cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb0bd ja 0x4cb0c7                                                                       |             goto label_6;
                                                                                                 |         }
    0x004cb0bf inc eax                                                                           |         eax++;
    0x004cb0c1 mov dword [rip + 0x24d8d1], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_6:
    0x004cb0c7 mov r14d, dword [rbp + rbp*4 + 0x4f3c90]                                          |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004cb0cf movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0]                                        |     r15 = *((rbp + rbp*4 + 0x4f3ca0));
    0x004cb0d7 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4]                                           |     ebx = *((rbp + rbp*4 + 0x4f3ca4));
    0x004cb0de movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8]                                        |     r13 = *((rbp + rbp*4 + 0x4f3ca8));
    0x004cb0e6 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0]                                           |     rbp = *((rbp + rbp*4 + 0x4f3cb0));
    0x004cb0ee cmp byte [rip + 0x24d89b], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb0f5 je 0x4cb116                                                                       |         
    0x004cb0f7 mov qword [rsp], rbp                                                              |         *(rsp) = rbp;
    0x004cb0fb mov edi, 0x4f5c41                                                                 |         
    0x004cb100 mov esi, r14d                                                                     |         esi = r14d;
    0x004cb103 mov rdx, r12                                                                      |         rdx = r12;
    0x004cb106 mov ecx, r15d                                                                     |         ecx = r15d;
    0x004cb109 mov r8d, ebx                                                                      |         r8d = ebx;
    0x004cb10c mov r9d, r13d                                                                     |         r9d = r13d;
    0x004cb10f xor eax, eax                                                                      |         eax = 0;
    0x004cb111 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004cb116 mov dword [rsp + 0x14], r14d                                                      |     *((rsp + 0x14)) = r14d;
    0x004cb11b mov qword [rsp + 0x18], rbx                                                       |     *((rsp + 0x18)) = rbx;
    0x004cb120 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb125 mov rsi, r12                                                                      |     rsi = r12;
    0x004cb128 call 0x4e33d0                                                                     |     intvolatile*&gg<intvolatile*>(intvolatile**,char const*) ();
    0x004cb12d mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb132 mov rsi, r12                                                                      |     rsi = r12;
    0x004cb135 call 0x4e34b0                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb13a mov r12d, dword [rip + 0x24d863]                                                  |     r12d = numCopyCtorCalls;
    0x004cb141 mov r14d, dword [rip + 0x24d864]                                                  |     r14d = numCharCtorCalls;
    0x004cb148 cmp byte [rsp + 0x54], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x54)) == 0) {
    0x004cb14d je 0x4cb230                                                                       |         goto label_7;
                                                                                                 |     }
    0x004cb153 cmp byte [rip + 0x24d836], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb15a je 0x4cb16f                                                                       |         
    0x004cb15c cmp dword [rip + 0x24d445], 0                                                     |         
                                                                                                 |         if (*(obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::firstTime) == 0) {
    0x004cb163 je 0x4cb16f                                                                       |             goto label_8;
                                                                                                 |         }
    0x004cb165 mov edi, 0x4f43ea                                                                 |         
    0x004cb16a call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_8:
    0x004cb16f mov dword [rip + 0x24d42f], 0                                                     |     *(obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::firstTime) = 0;
    0x004cb179 cmp byte [rip + 0x24d815], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cb180 je 0x4cb18c                                                                       |         
    0x004cb182 mov edi, 0x4f4411                                                                 |         
    0x004cb187 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004cb18c mov rax, qword [rip + 0x24d68d]                                                   |     rax = Z;
    0x004cb193 mov qword [rsp + 0x20], 0x4f69e0                                                  |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cb19c mov qword [rsp + 0x28], rax                                                       |     *((rsp + 0x28)) = rax;
    0x004cb1a1 mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004cb1a9 test rax, rax                                                                     |     
    0x004cb1ac je 0x4cb2f5                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_0:
    0x004cb1b2 lea rsi, [r15*8 + 0x74f960]                                                       |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb1ba mov rax, qword [rsp + 0x18]                                                       |         rax = *((rsp + 0x18));
    0x004cb1bf add eax, r15d                                                                     |         eax += r15d;
    0x004cb1c2 cdqe                                                                              |         rax = (int64_t) eax;
    0x004cb1c4 lea rdx, [rax*8 + 0x74f960]                                                       |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb1cc sub rdx, rsi                                                                      |         rdx -= rsi;
                                                                                                 |         if (rdx != 0) {
    0x004cb1cf je 0x4cb1de                                                                       |             
    0x004cb1d1 lea rdi, [r13*8 + 0x74f960]                                                       |             
    0x004cb1d9 call 0x401930                                                                     |             memcpy (r13*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u, rsi, rdx);
                                                                                                 |         }
    0x004cb1de mov rax, qword [rsp + 0x20]                                                       |         rax = *((rsp + 0x20));
    0x004cb1e3 lea rdi, [rsp + 0x20]                                                             |         rdi = rsp + 0x20;
    0x004cb1e8 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004cb1ef call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004cb1f2 cmp byte [rip + 0x24d79c], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004cb1f9 je 0x4cb205                                                                       |             
    0x004cb1fb mov edi, 0x4f4571                                                                 |             
    0x004cb200 call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004cb205 cmp byte [rip + 0x24d784], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004cb20c je 0x4cb4ea                                                                       |             goto label_9;
                                                                                                 |         }
    0x004cb212 mov edi, 0xa                                                                      |         
    0x004cb217 call 0x401720                                                                     |         putchar (0xa);
    0x004cb21c mov ebx, dword [rsp + 0x14]                                                       |         ebx = *((rsp + 0x14));
    0x004cb220 jmp 0x4cb4c1                                                                      |         goto label_10;
                                                                                                 | label_7:
    0x004cb230 cmp qword [rip + 0x24d5e8], 0                                                     |         
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004cb238 jne 0x4cb250                                                                      |             
    0x004cb23a mov rax, qword [rip + 0x286077]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb241 test rax, rax                                                                     |             
                                                                                                 |             if (rax != 0) {
    0x004cb244 jne 0x4cb250                                                                      |                 goto label_11;
                                                                                                 |             }
    0x004cb246 call 0x4eede0                                                                     |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb24b nop dword [rax + rax]                                                             |             
                                                                                                 |         }
                                                                                                 | label_11:
    0x004cb250 cmp qword [rsp + 0x48], 6                                                         |         
    0x004cb256 mov ebx, dword [rsp + 0x14]                                                       |         ebx = *((rsp + 0x14));
                                                                                                 |         if (*((rsp + 0x48)) < 6) {
    0x004cb25a jb 0x4cb4c1                                                                       |             goto label_10;
                                                                                                 |         }
    0x004cb260 lea rax, [r15*8 + 0x74f960]                                                       |         rax = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb268 lea rcx, [r13*8 + 0x74f960]                                                       |         rcx = r13*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb270 mov rsi, qword [rsp + 0x18]                                                       |         rsi = *((rsp + 0x18));
    0x004cb275 lea edx, [rsi + r15]                                                              |         edx = rsi + r15;
    0x004cb279 movsxd r9, edx                                                                    |         r9 = (int64_t) edx;
    0x004cb27c shl r9, 3                                                                         |         r9 <<= 3;
    0x004cb280 lea rdi, [r15*8]                                                                  |         rdi = r15*8;
    0x004cb288 mov r10, r9                                                                       |         r10 = r9;
    0x004cb28b sub r10, rdi                                                                      |         r10 -= rdi;
    0x004cb28e add r10, 0xfffffffffffffff8                                                       |         r10 += 0xfffffffffffffff8;
    0x004cb292 cmp r10, 0x18                                                                     |         
                                                                                                 |         if (r10 < 0x18) {
    0x004cb296 jb 0x4cb4a0                                                                       |             goto label_12;
                                                                                                 |         }
    0x004cb29c mov dword [rsp + 0x50], r14d                                                      |         *((rsp + 0x50)) = r14d;
    0x004cb2a1 mov r11, rbp                                                                      |         r11 = rbp;
    0x004cb2a4 lea rbp, [r13*8 + 0x74f960]                                                       |         rbp = r13*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb2ac lea edx, [rsi + r15]                                                              |         edx = rsi + r15;
    0x004cb2b0 movsxd rdx, edx                                                                   |         rdx = (int64_t) edx;
    0x004cb2b3 lea rbx, [rdx*8 + 0x74f960]                                                       |         rbx = rdx*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb2bb cmp rbp, rbx                                                                      |         
                                                                                                 |         if (rbp >= rbx) {
    0x004cb2be jae 0x4cb367                                                                      |             goto label_13;
                                                                                                 |         }
    0x004cb2c4 shl rdx, 3                                                                        |         rdx <<= 3;
    0x004cb2c8 sub rdx, rdi                                                                      |         rdx -= rdi;
    0x004cb2cb lea rdx, [rdx + r13*8 + 0x74f960]                                                 |         rdx = rdx + r13*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb2d3 lea rbp, [r15*8 + 0x74f960]                                                       |         rbp = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb2db cmp rbp, rdx                                                                      |         
                                                                                                 |         if (rbp >= rdx) {
    0x004cb2de jae 0x4cb367                                                                      |             goto label_13;
                                                                                                 |         }
    0x004cb2e4 mov rbp, r11                                                                      |         
    0x004cb2e7 mov r14d, dword [rsp + 0x50]                                                      |         r14d = *((rsp + 0x50));
    0x004cb2ec mov ebx, dword [rsp + 0x14]                                                       |         ebx = *((rsp + 0x14));
    0x004cb2f0 jmp 0x4cb4a0                                                                      |         goto label_12;
    0x004cb2f5 mov ebx, 1                                                                        |         ebx = 1;
    0x004cb2fa mov rax, qword [rip + 0x285fb7]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb301 test rax, rax                                                                     |         
    0x004cb304 jne 0x4cb1b2                                                                      |         
                                                                                                 |     }
    0x004cb30a call 0x4eede0                                                                     |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb30f jmp 0x4cb1b2                                                                      |     goto label_0;
                                                                                                 | label_13:
    0x004cb367 shr r10, 3                                                                        |     r10 >>= 3;
    0x004cb36b inc r10                                                                           |     r10++;
    0x004cb36e mov r8, r10                                                                       |     r8 = r10;
    0x004cb371 and r8, 0xfffffffffffffffc                                                        |     r8 &= 0xfffffffffffffffc;
    0x004cb375 lea rdx, [r8 - 4]                                                                 |     rdx = r8 - 4;
    0x004cb379 mov rbp, rdx                                                                      |     
    0x004cb37c shr rbp, 2                                                                        |     rbp >>= 2;
    0x004cb380 inc rbp                                                                           |     rbp++;
    0x004cb383 mov ebx, ebp                                                                      |     ebx = ebp;
    0x004cb385 and ebx, 3                                                                        |     ebx &= 3;
    0x004cb388 cmp rdx, 0xc                                                                      |     
                                                                                                 |     if (rdx < 0xc) {
    0x004cb38c jae 0x4cb395                                                                      |         
    0x004cb38e xor edx, edx                                                                      |         edx = 0;
    0x004cb390 jmp 0x4cb43a                                                                      |         goto label_14;
                                                                                                 |     }
    0x004cb395 and rbp, 0xfffffffffffffffc                                                       |     rbp &= 0xfffffffffffffffc;
    0x004cb399 neg rbp                                                                           |     rbp = -rbp;
    0x004cb39c xor edx, edx                                                                      |     edx = 0;
    0x004cb39e nop                                                                               |     
                                                                                                 |     do {
    0x004cb3a0 movups xmm0, xmmword [rdi + rdx*8 + 0x74f960]                                     |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u]");
    0x004cb3a8 movups xmm1, xmmword [rdi + rdx*8 + 0x74f970]                                     |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f970]");
    0x004cb3b0 lea rsi, [r13*8]                                                                  |         rsi = r13*8;
    0x004cb3b8 movups xmmword [rsi + rdx*8 + 0x74f960], xmm0                                     |         __asm ("movups xmmword [rsi + rdx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cb3c0 movups xmmword [rsi + rdx*8 + 0x74f970], xmm1                                     |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f970], xmm1");
    0x004cb3c8 movups xmm0, xmmword [rdi + rdx*8 + 0x74f980]                                     |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f980]");
    0x004cb3d0 movups xmm1, xmmword [rdi + rdx*8 + 0x74f990]                                     |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f990]");
    0x004cb3d8 movups xmmword [rsi + rdx*8 + 0x74f980], xmm0                                     |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f980], xmm0");
    0x004cb3e0 movups xmmword [rsi + rdx*8 + 0x74f990], xmm1                                     |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f990], xmm1");
    0x004cb3e8 movups xmm0, xmmword [rdi + rdx*8 + 0x74f9a0]                                     |         __asm ("movups xmm0, xmmword [rdi + rdx*8 + 0x74f9a0]");
    0x004cb3f0 movups xmm1, xmmword [rdi + rdx*8 + 0x74f9b0]                                     |         __asm ("movups xmm1, xmmword [rdi + rdx*8 + 0x74f9b0]");
    0x004cb3f8 movups xmmword [rsi + rdx*8 + 0x74f9a0], xmm0                                     |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f9a0], xmm0");
    0x004cb400 movups xmmword [rsi + rdx*8 + 0x74f9b0], xmm1                                     |         __asm ("movups xmmword [rsi + rdx*8 + 0x74f9b0], xmm1");
    0x004cb408 movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f9c0]                                     |         __asm ("movdqu xmm0, xmmword [rdi + rdx*8 + 0x74f9c0]");
    0x004cb411 movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f9d0]                                     |         __asm ("movdqu xmm1, xmmword [rdi + rdx*8 + 0x74f9d0]");
    0x004cb41a movdqu xmmword [rsi + rdx*8 + 0x74f9c0], xmm0                                     |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f9c0], xmm0");
    0x004cb423 movdqu xmmword [rsi + rdx*8 + 0x74f9d0], xmm1                                     |         __asm ("movdqu xmmword [rsi + rdx*8 + 0x74f9d0], xmm1");
    0x004cb42c add rdx, 0x10                                                                     |         rdx += 0x10;
    0x004cb430 add rbp, 4                                                                        |         rbp += 4;
    0x004cb434 jne 0x4cb3a0                                                                      |         
                                                                                                 |     } while (rbp != 0);
                                                                                                 | label_14:
    0x004cb43a test rbx, rbx                                                                     |     
                                                                                                 |     if (rbx == 0) {
    0x004cb43d je 0x4cb480                                                                       |         goto label_15;
                                                                                                 |     }
    0x004cb43f shl r13, 3                                                                        |     r13 <<= 3;
    0x004cb443 lea rbp, [r13 + rdx*8 + 0x74f970]                                                 |     rbp = r13 + rdx*8 + 0x74f970;
    0x004cb44b lea rdx, [rdi + rdx*8 + 0x74f970]                                                 |     rdx = rdi + rdx*8 + 0x74f970;
    0x004cb453 shl rbx, 5                                                                        |     rbx <<= 5;
    0x004cb457 xor edi, edi                                                                      |     edi = 0;
    0x004cb459 nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004cb460 movdqu xmm0, xmmword [rdx + rdi - 0x10]                                           |         __asm ("movdqu xmm0, xmmword [rdx + rdi - 0x10]");
    0x004cb466 movdqu xmm1, xmmword [rdx + rdi]                                                  |         __asm ("movdqu xmm1, xmmword [rdx + rdi]");
    0x004cb46b movdqu xmmword [rbp + rdi - 0x10], xmm0                                           |         __asm ("movdqu xmmword [rbp + rdi - 0x10], xmm0");
    0x004cb471 movdqu xmmword [rbp + rdi], xmm1                                                  |         __asm ("movdqu xmmword [rbp + rdi], xmm1");
    0x004cb477 add rdi, 0x20                                                                     |         rdi += 0x20;
    0x004cb47b cmp rbx, rdi                                                                      |         
    0x004cb47e jne 0x4cb460                                                                      |         
                                                                                                 |     } while (rbx != rdi);
                                                                                                 | label_15:
    0x004cb480 cmp r10, r8                                                                       |     
    0x004cb483 mov rbp, r11                                                                      |     
    0x004cb486 mov r14d, dword [rsp + 0x50]                                                      |     r14d = *((rsp + 0x50));
    0x004cb48b mov ebx, dword [rsp + 0x14]                                                       |     ebx = *((rsp + 0x14));
                                                                                                 |     if (r10 == r8) {
    0x004cb48f je 0x4cb4c1                                                                       |         goto label_10;
                                                                                                 |     }
    0x004cb491 lea rax, [rax + r8*8]                                                             |     rax = rax + r8*8;
    0x004cb495 lea rcx, [rcx + r8*8]                                                             |     rcx = rcx + r8*8;
    0x004cb499 nop dword [rax]                                                                   |     
                                                                                                 | label_12:
    0x004cb4a0 sub r9, rax                                                                       |     r9 -= rax;
    0x004cb4a3 lea rdx, [r9 + 0x74f960]                                                          |     rdx = r9 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb4aa xor esi, esi                                                                      |     esi = 0;
    0x004cb4ac nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004cb4b0 mov rdi, qword [rax + rsi]                                                        |         rdi = *((rax + rsi));
    0x004cb4b4 mov qword [rcx + rsi], rdi                                                        |         *((rcx + rsi)) = rdi;
    0x004cb4b8 add rsi, 8                                                                        |         rsi += 8;
    0x004cb4bc cmp rdx, rsi                                                                      |         
    0x004cb4bf jne 0x4cb4b0                                                                      |         
                                                                                                 |     } while (rdx != rsi);
                                                                                                 | label_10:
    0x004cb4c1 cmp byte [rip + 0x24d4c8], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb4c8 je 0x4cb4ea                                                                       |         
    0x004cb4ca mov edx, dword [rip + 0x24d4d4]                                                   |         edx = numCopyCtorCalls;
    0x004cb4d0 sub edx, r12d                                                                     |         edx -= r12d;
    0x004cb4d3 mov ecx, dword [rip + 0x24d4d3]                                                   |         ecx = numCharCtorCalls;
    0x004cb4d9 sub ecx, r14d                                                                     |         ecx -= r14d;
    0x004cb4dc mov edi, 0x4f5db4                                                                 |         
    0x004cb4e1 mov esi, ebx                                                                      |         esi = ebx;
    0x004cb4e3 xor eax, eax                                                                      |         eax = 0;
    0x004cb4e5 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_9:
    0x004cb4ea cmp byte [rsp + 0x40], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x40)) == 0) {
    0x004cb4ef je 0x4cb550                                                                       |         goto label_16;
                                                                                                 |     }
    0x004cb4f1 cmp r12d, dword [rip + 0x24d4ac]                                                  |     
                                                                                                 |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004cb4f8 je 0x4cb523                                                                       |         
    0x004cb4fa mov edi, 0x4f4e04                                                                 |         
    0x004cb4ff mov edx, 0x4f5176                                                                 |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cb504 mov esi, 0x1005                                                                   |         esi = 0x1005;
    0x004cb509 xor eax, eax                                                                      |         eax = 0;
    0x004cb50b call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb510 mov eax, dword [rip + 0x24d482]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb516 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb519 ja 0x4cb523                                                                       |             goto label_17;
                                                                                                 |         }
    0x004cb51b inc eax                                                                           |         eax++;
    0x004cb51d mov dword [rip + 0x24d475], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_17:
    0x004cb523 cmp r14d, dword [rip + 0x24d482]                                                  |     
                                                                                                 |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004cb52a je 0x4cb050                                                                       |         goto label_1;
                                                                                                 |     }
    0x004cb530 mov edi, 0x4f4e04                                                                 |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004cb535 mov edx, 0x4f5de4                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cb53a mov esi, 0x1006                                                                   |     esi = 0x1006;
    0x004cb53f jmp 0x4cb5a3                                                                      |     goto label_18;
                                                                                                 | label_16:
    0x004cb550 add r12d, dword [rsp + 0x18]                                                      |     r12d += *((rsp + 0x18));
    0x004cb555 cmp r12d, dword [rip + 0x24d448]                                                  |     
                                                                                                 |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004cb55c jle 0x4cb587                                                                      |         
    0x004cb55e mov edi, 0x4f4e04                                                                 |         
    0x004cb563 mov edx, 0x4f5e02                                                                 |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004cb568 mov esi, 0x1009                                                                   |         esi = 0x1009;
    0x004cb56d xor eax, eax                                                                      |         eax = 0;
    0x004cb56f call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb574 mov eax, dword [rip + 0x24d41e]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb57a cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb57d ja 0x4cb587                                                                       |             goto label_19;
                                                                                                 |         }
    0x004cb57f inc eax                                                                           |         eax++;
    0x004cb581 mov dword [rip + 0x24d411], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_19:
    0x004cb587 cmp r14d, dword [rip + 0x24d41e]                                                  |     
                                                                                                 |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004cb58e je 0x4cb050                                                                       |         goto label_1;
                                                                                                 |     }
    0x004cb594 mov edi, 0x4f4e04                                                                 |     
    0x004cb599 mov edx, 0x4f5de4                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cb59e mov esi, 0x100a                                                                   |     esi = 0x100a;
                                                                                                 | label_18:
    0x004cb5a3 xor eax, eax                                                                      |     eax = 0;
    0x004cb5a5 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb5aa mov eax, dword [rip + 0x24d3e8]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004cb5b0 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004cb5b3 ja 0x4cb050                                                                       |         goto label_1;
                                                                                                 |     }
    0x004cb5b9 inc eax                                                                           |     eax++;
    0x004cb5bb mov dword [rip + 0x24d3d7], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cb5c1 jmp 0x4cb050                                                                      |     goto label_1;
                                                                                                 | label_5:
    0x004cb5c6 cmp byte [rip + 0x24d3c9], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004cb5cd je 0x4cb5d9                                                                       |         
    0x004cb5cf mov edi, 0x4f695c                                                                 |         
    0x004cb5d4 call 0x401710                                                                     |         puts ("\t\tfrom different type.");
                                                                                                 |     }
    0x004cb5d9 xor r12d, r12d                                                                    |     r12d = 0;
    0x004cb5dc jmp 0x4cb607                                                                      |     goto label_20;
                                                                                                 | label_3:
    0x004cb5e0 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb5e5 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004cb5e8 call 0x4e34b0                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb5ed mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb5f2 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004cb5f5 call 0x4e36f0                                                                     |     voidcleanup<intvolatile*>(intvolatile**,char const*) ();
    0x004cb5fa inc r12                                                                           |     r12++;
    0x004cb5fd cmp r12, 0x1e                                                                     |     
                                                                                                 |     if (r12 == 0x1e) {
    0x004cb601 je 0x4cbc2d                                                                       |         goto label_21;
                                                                                                 |     }
                                                                                                 | label_20:
    0x004cb607 lea rbx, [r12*8]                                                                  |     rbx = r12*8;
    0x004cb60f mov rbp, qword [rbx + rbx*4 + 0x4f3c98]                                           |     rbp = *((rbx + rbx*4 + 0x4f3c98));
    0x004cb617 mov rdi, rbp                                                                      |     
    0x004cb61a call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004cb61f cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004cb622 jl 0x4cb64d                                                                       |         
    0x004cb624 mov edi, 0x4f4e04                                                                 |         
    0x004cb629 mov edx, 0x4f4393                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cb62e mov esi, 0x1019                                                                   |         esi = 0x1019;
    0x004cb633 xor eax, eax                                                                      |         eax = 0;
    0x004cb635 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb63a mov eax, dword [rip + 0x24d358]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb640 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb643 ja 0x4cb64d                                                                       |             goto label_22;
                                                                                                 |         }
    0x004cb645 inc eax                                                                           |         eax++;
    0x004cb647 mov dword [rip + 0x24d34b], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_22:
    0x004cb64d mov rdi, rbp                                                                      |     
    0x004cb650 call 0x401790                                                                     |     rax = strlen (rbp);
    0x004cb655 cmp rax, 0x14                                                                     |     
                                                                                                 |     if (rax >= 0x14) {
    0x004cb659 jb 0x4cb684                                                                       |         
    0x004cb65b mov edi, 0x4f4e04                                                                 |         
    0x004cb660 mov edx, 0x4f5e26                                                                 |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004cb665 mov esi, 0x101c                                                                   |         esi = 0x101c;
    0x004cb66a xor eax, eax                                                                      |         eax = 0;
    0x004cb66c call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb671 mov eax, dword [rip + 0x24d321]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb677 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb67a ja 0x4cb684                                                                       |             goto label_23;
                                                                                                 |         }
    0x004cb67c inc eax                                                                           |         eax++;
    0x004cb67e mov dword [rip + 0x24d314], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_23:
    0x004cb684 mov qword [rsp + 0x18], r12                                                       |     *((rsp + 0x18)) = r12;
    0x004cb689 pxor xmm0, xmm0                                                                   |     xmm0 = 0;
    0x004cb68d movdqa xmmword [rsp + 0x20], xmm0                                                 |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004cb693 mov dword [rsp + 0x30], 0                                                         |     *((rsp + 0x30)) = 0;
    0x004cb69b mov al, byte [rbp]                                                                |     al = *(rbp);
    0x004cb69e test al, al                                                                       |     
                                                                                                 |     if (al == 0) {
    0x004cb6a0 je 0x4cb6c0                                                                       |         goto label_24;
                                                                                                 |     }
    0x004cb6a2 xor ecx, ecx                                                                      |     ecx = 0;
    0x004cb6a4 nop word cs:[rax + rax]                                                           |     
    0x004cb6ae nop                                                                               |     
                                                                                                 |     do {
    0x004cb6b0 mov byte [rsp + rcx + 0x20], al                                                   |         *((rsp + rcx + 0x20)) = al;
    0x004cb6b4 movzx eax, byte [rbp + rcx + 1]                                                   |         eax = *((rbp + rcx + 1));
    0x004cb6b9 inc rcx                                                                           |         rcx++;
    0x004cb6bc test al, al                                                                       |         
    0x004cb6be jne 0x4cb6b0                                                                      |         
                                                                                                 |     } while (al != 0);
                                                                                                 | label_24:
    0x004cb6c0 mov r14d, dword [rbx + rbx*4 + 0x4f3c90]                                          |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004cb6c8 movsxd r13, dword [rbx + rbx*4 + 0x4f3ca0]                                        |     r13 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004cb6d0 movsxd r12, dword [rbx + rbx*4 + 0x4f3ca4]                                        |     r12 = *((rbx + rbx*4 + 0x4f3ca4));
    0x004cb6d8 movsxd r15, dword [rbx + rbx*4 + 0x4f3ca8]                                        |     r15 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004cb6e0 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                           |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004cb6e8 cmp byte [rip + 0x24d2a1], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb6ef je 0x4cb710                                                                       |         
    0x004cb6f1 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004cb6f5 mov edi, 0x4f5c41                                                                 |         
    0x004cb6fa mov esi, r14d                                                                     |         esi = r14d;
    0x004cb6fd mov rdx, rbp                                                                      |         rdx = rbp;
    0x004cb700 mov ecx, r13d                                                                     |         ecx = r13d;
    0x004cb703 mov r8d, r12d                                                                     |         r8d = r12d;
    0x004cb706 mov r9d, r15d                                                                     |         r9d = r15d;
    0x004cb709 xor eax, eax                                                                      |         eax = 0;
    0x004cb70b call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004cb710 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb715 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb718 call 0x4e33d0                                                                     |     intvolatile*&gg<intvolatile*>(intvolatile**,char const*) ();
    0x004cb71d mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb722 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb725 call 0x4e34b0                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb72a mov eax, dword [rip + 0x24d274]                                                   |     eax = numCopyCtorCalls;
    0x004cb730 mov dword [rsp + 0x48], eax                                                       |     *((rsp + 0x48)) = eax;
    0x004cb734 mov eax, dword [rip + 0x24d272]                                                   |     eax = numCharCtorCalls;
    0x004cb73a mov dword [rsp + 0x14], eax                                                       |     *((rsp + 0x14)) = eax;
    0x004cb73e cmp byte [rsp + 0x54], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x54)) == 0) {
    0x004cb743 je 0x4cb810                                                                       |         goto label_25;
                                                                                                 |     }
    0x004cb749 cmp byte [rip + 0x24d240], 0                                                      |     
    0x004cb750 mov ebp, r14d                                                                     |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb753 je 0x4cb768                                                                       |         
    0x004cb755 cmp dword [rip + 0x24ce50], 0                                                     |         
                                                                                                 |         if (*(0x007185ac) == 0) {
    0x004cb75c je 0x4cb768                                                                       |             goto label_26;
                                                                                                 |         }
    0x004cb75e mov edi, 0x4f43ea                                                                 |         
    0x004cb763 call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_26:
    0x004cb768 mov dword [rip + 0x24ce3a], 0                                                     |     *(0x007185ac) = 0;
    0x004cb772 cmp byte [rip + 0x24d21c], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cb779 je 0x4cb785                                                                       |         
    0x004cb77b mov edi, 0x4f4411                                                                 |         
    0x004cb780 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004cb785 mov rax, qword [rip + 0x24d094]                                                   |     rax = Z;
    0x004cb78c mov qword [rsp + 0x58], 0x4f69e0                                                  |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cb795 mov qword [rsp + 0x60], rax                                                       |     *((rsp + 0x60)) = rax;
    0x004cb79a mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004cb7a2 test rax, rax                                                                     |     
    0x004cb7a5 je 0x4cb89d                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_2:
    0x004cb7ab cmp qword [rsp + 0x18], 6                                                         |         
                                                                                                 |         if (*((rsp + 0x18)) < 6) {
    0x004cb7b1 jb 0x4cbb81                                                                       |             goto label_27;
                                                                                                 |         }
    0x004cb7b7 lea rcx, [rsp + r13 + 0x20]                                                       |         rcx = rsp + r13 + 0x20;
    0x004cb7bc lea rsi, [r15*8 + 0x74f960]                                                       |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb7c4 lea eax, [r13 + r12]                                                              |         eax = r13 + r12;
    0x004cb7c9 movsxd r9, eax                                                                    |         r9 = (int64_t) eax;
    0x004cb7cc mov r10, r9                                                                       |         r10 = r9;
    0x004cb7cf sub r10, r13                                                                      |         r10 -= r13;
    0x004cb7d2 cmp r10, 4                                                                        |         
                                                                                                 |         if (r10 < 4) {
    0x004cb7d6 jb 0x4cbb66                                                                       |             goto label_28;
                                                                                                 |         }
    0x004cb7dc mov r11, rbx                                                                      |         r11 = rbx;
    0x004cb7df mov r8, r10                                                                       |         r8 = r10;
    0x004cb7e2 and r8, 0xfffffffffffffffc                                                        |         r8 &= 0xfffffffffffffffc;
    0x004cb7e6 lea rax, [r8 - 4]                                                                 |         rax = r8 - 4;
    0x004cb7ea mov rbp, rax                                                                      |         
    0x004cb7ed shr rbp, 2                                                                        |         rbp >>= 2;
    0x004cb7f1 inc rbp                                                                           |         rbp++;
    0x004cb7f4 mov edi, ebp                                                                      |         edi = ebp;
    0x004cb7f6 and edi, 3                                                                        |         edi &= 3;
    0x004cb7f9 cmp rax, 0xc                                                                      |         
                                                                                                 |         if (rax >= 0xc) {
    0x004cb7fd jae 0x4cba56                                                                      |             goto label_29;
                                                                                                 |         }
    0x004cb803 xor ebx, ebx                                                                      |         ebx = 0;
    0x004cb805 jmp 0x4cbb05                                                                      |         goto label_30;
                                                                                                 | label_25:
    0x004cb810 cmp qword [rip + 0x24d008], 0                                                     |         
    0x004cb818 mov ebp, r14d                                                                     |         
    0x004cb81b mov r11, r12                                                                      |         r11 = r12;
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004cb81e jne 0x4cb840                                                                      |             
    0x004cb820 mov rax, qword [rip + 0x285a91]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb827 test rax, rax                                                                     |             
                                                                                                 |             if (rax != 0) {
    0x004cb82a jne 0x4cb840                                                                      |                 goto label_31;
                                                                                                 |             }
    0x004cb82c call 0x4eede0                                                                     |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb831 mov r11, r12                                                                      |             r11 = r12;
    0x004cb834 nop word cs:[rax + rax]                                                           |             
    0x004cb83e nop                                                                               |             
                                                                                                 |         }
                                                                                                 | label_31:
    0x004cb840 mov r12, qword [rsp + 0x18]                                                       |         r12 = *((rsp + 0x18));
    0x004cb845 cmp r12, 6                                                                        |         
                                                                                                 |         if (r12 < 6) {
    0x004cb849 jb 0x4cbbc0                                                                       |             goto label_32;
                                                                                                 |         }
    0x004cb84f lea rax, [r15*8 + 0x74f960]                                                       |         rax = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb857 lea rcx, [rsp + r13 + 0x20]                                                       |         rcx = rsp + r13 + 0x20;
    0x004cb85c add r11, r13                                                                      |         r11 += r13;
    0x004cb85f mov r9, r11                                                                       |         r9 = r11;
    0x004cb862 sub r9, r13                                                                       |         r9 -= r13;
    0x004cb865 cmp r9, 4                                                                         |         
                                                                                                 |         if (r9 < 4) {
    0x004cb869 jb 0x4cba2a                                                                       |             goto label_33;
                                                                                                 |         }
    0x004cb86f mov r10, rbx                                                                      |         r10 = rbx;
    0x004cb872 mov r8, r9                                                                        |         r8 = r9;
    0x004cb875 and r8, 0xfffffffffffffffc                                                        |         r8 &= 0xfffffffffffffffc;
    0x004cb879 lea rsi, [r8 - 4]                                                                 |         rsi = r8 - 4;
    0x004cb87d mov rdi, rsi                                                                      |         rdi = rsi;
    0x004cb880 shr rdi, 2                                                                        |         rdi >>= 2;
    0x004cb884 inc rdi                                                                           |         rdi++;
    0x004cb887 mov ebp, edi                                                                      |         
    0x004cb889 and ebp, 3                                                                        |         ebp &= 3;
    0x004cb88c cmp rsi, 0xc                                                                      |         
                                                                                                 |         if (rsi >= 0xc) {
    0x004cb890 jae 0x4cb91d                                                                      |             goto label_34;
                                                                                                 |         }
    0x004cb896 xor ebx, ebx                                                                      |         ebx = 0;
    0x004cb898 jmp 0x4cb9c5                                                                      |         goto label_35;
    0x004cb89d mov eax, 1                                                                        |         eax = 1;
    0x004cb8a2 mov qword [rsp + 0x40], rax                                                       |         *((rsp + 0x40)) = rax;
    0x004cb8a7 mov rax, qword [rip + 0x285a0a]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb8ae test rax, rax                                                                     |         
    0x004cb8b1 jne 0x4cb7ab                                                                      |         
                                                                                                 |     }
    0x004cb8b7 call 0x4eede0                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb8bc jmp 0x4cb7ab                                                                      |     goto label_2;
                                                                                                 | label_34:
    0x004cb91d lea rdx, [rsp + 0x2e]                                                             |     rdx = rsp + 0x2e;
    0x004cb922 lea rsi, [rdx + r13]                                                              |     rsi = rdx + r13;
    0x004cb926 and rdi, 0xfffffffffffffffc                                                       |     rdi &= 0xfffffffffffffffc;
    0x004cb92a neg rdi                                                                           |     rdi = -rdi;
    0x004cb92d xor ebx, ebx                                                                      |     ebx = 0;
    0x004cb92f nop                                                                               |     
                                                                                                 |     do {
    0x004cb930 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                             |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cb937 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                             |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cb93e lea rdx, [r15*8]                                                                  |         rdx = r15*8;
    0x004cb946 movdqu xmmword [rdx + rbx*8 + 0x74f960], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cb94f movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1");
    0x004cb958 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                             |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cb95f pmovsxbq xmm1, word [rsi + rbx - 8]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cb966 movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0");
    0x004cb96f movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1");
    0x004cb978 pmovsxbq xmm0, word [rsi + rbx - 6]                                               |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cb97f pmovsxbq xmm1, word [rsi + rbx - 4]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cb986 movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0");
    0x004cb98f movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1");
    0x004cb998 pmovsxbq xmm0, word [rsi + rbx - 2]                                               |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cb99f pmovsxbq xmm1, word [rsi + rbx]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cb9a5 movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0");
    0x004cb9ae movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1");
    0x004cb9b7 add rbx, 0x10                                                                     |         rbx += 0x10;
    0x004cb9bb add rdi, 4                                                                        |         rdi += 4;
    0x004cb9bf jne 0x4cb930                                                                      |         
                                                                                                 |     } while (rdi != 0);
                                                                                                 | label_35:
    0x004cb9c5 test rbp, rbp                                                                     |     
                                                                                                 |     if (rbp == 0) {
    0x004cb9c8 je 0x4cba14                                                                       |         goto label_36;
                                                                                                 |     }
    0x004cb9ca add r13, rbx                                                                      |     r13 += rbx;
    0x004cb9cd lea rdx, [rsp + 0x22]                                                             |     rdx = rsp + 0x22;
    0x004cb9d2 add r13, rdx                                                                      |     r13 += rdx;
    0x004cb9d5 shl r15, 3                                                                        |     r15 <<= 3;
    0x004cb9d9 lea rsi, [r15 + rbx*8 + 0x74f970]                                                 |     rsi = r15 + rbx*8 + 0x74f970;
    0x004cb9e1 shl rbp, 2                                                                        |     rbp <<= 2;
    0x004cb9e5 xor edi, edi                                                                      |     edi = 0;
    0x004cb9e7 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cb9f0 pmovsxbq xmm0, word [r13 + rdi - 2]                                               |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cb9f8 pmovsxbq xmm1, word [r13 + rdi]                                                   |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cba00 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                         |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cba06 movdqu xmmword [rsi + rdi*8], xmm1                                                |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cba0b add rdi, 4                                                                        |         rdi += 4;
    0x004cba0f cmp rbp, rdi                                                                      |         
    0x004cba12 jne 0x4cb9f0                                                                      |         
                                                                                                 |     } while (rbp != rdi);
                                                                                                 | label_36:
    0x004cba14 cmp r9, r8                                                                        |     
    0x004cba17 mov rbx, r10                                                                      |     rbx = r10;
    0x004cba1a mov ebp, r14d                                                                     |     
                                                                                                 |     if (r9 == r8) {
    0x004cba1d je 0x4cbbc0                                                                       |         goto label_32;
                                                                                                 |     }
    0x004cba23 add rcx, r8                                                                       |     rcx += r8;
    0x004cba26 lea rax, [rax + r8*8]                                                             |     rax = rax + r8*8;
                                                                                                 | label_33:
    0x004cba2a sub r11, rcx                                                                      |     r11 -= rcx;
    0x004cba2d lea rdx, [rsp + r11 + 0x20]                                                       |     rdx = rsp + r11 + 0x20;
    0x004cba32 xor esi, esi                                                                      |     esi = 0;
    0x004cba34 nop word cs:[rax + rax]                                                           |     
    0x004cba3e nop                                                                               |     
                                                                                                 |     do {
    0x004cba40 movsx rdi, byte [rcx + rsi]                                                       |         rdi = *((rcx + rsi));
    0x004cba45 mov qword [rax + rsi*8], rdi                                                      |         *((rax + rsi*8)) = rdi;
    0x004cba49 inc rsi                                                                           |         rsi++;
    0x004cba4c cmp rdx, rsi                                                                      |         
    0x004cba4f jne 0x4cba40                                                                      |         
                                                                                                 |     } while (rdx != rsi);
    0x004cba51 jmp 0x4cbbc0                                                                      |     goto label_32;
                                                                                                 | label_29:
    0x004cba56 lea rax, [rsp + 0x2e]                                                             |     rax = rsp + 0x2e;
    0x004cba5b add rax, r13                                                                      |     rax += r13;
    0x004cba5e and rbp, 0xfffffffffffffffc                                                       |     rbp &= 0xfffffffffffffffc;
    0x004cba62 neg rbp                                                                           |     rbp = -rbp;
    0x004cba65 xor ebx, ebx                                                                      |     ebx = 0;
    0x004cba67 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cba70 pmovsxbq xmm0, word [rax + rbx - 0xe]                                             |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cba77 pmovsxbq xmm1, word [rax + rbx - 0xc]                                             |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cba7e lea rdx, [r15*8]                                                                  |         rdx = r15*8;
    0x004cba86 movdqu xmmword [rdx + rbx*8 + 0x74f960], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cba8f movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1");
    0x004cba98 pmovsxbq xmm0, word [rax + rbx - 0xa]                                             |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cba9f pmovsxbq xmm1, word [rax + rbx - 8]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cbaa6 movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0");
    0x004cbaaf movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1");
    0x004cbab8 pmovsxbq xmm0, word [rax + rbx - 6]                                               |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cbabf pmovsxbq xmm1, word [rax + rbx - 4]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cbac6 movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0");
    0x004cbacf movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1");
    0x004cbad8 pmovsxbq xmm0, word [rax + rbx - 2]                                               |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cbadf pmovsxbq xmm1, word [rax + rbx]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cbae5 movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0");
    0x004cbaee movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1");
    0x004cbaf7 add rbx, 0x10                                                                     |         rbx += 0x10;
    0x004cbafb add rbp, 4                                                                        |         rbp += 4;
    0x004cbaff jne 0x4cba70                                                                      |         
                                                                                                 |     } while (rbp != 0);
                                                                                                 | label_30:
    0x004cbb05 test rdi, rdi                                                                     |     
                                                                                                 |     if (rdi == 0) {
    0x004cbb08 je 0x4cbb54                                                                       |         goto label_37;
                                                                                                 |     }
    0x004cbb0a add r13, rbx                                                                      |     r13 += rbx;
    0x004cbb0d lea rax, [rsp + 0x22]                                                             |     rax = rsp + 0x22;
    0x004cbb12 add r13, rax                                                                      |     r13 += rax;
    0x004cbb15 shl r15, 3                                                                        |     r15 <<= 3;
    0x004cbb19 lea rax, [r15 + rbx*8 + 0x74f970]                                                 |     rax = r15 + rbx*8 + 0x74f970;
    0x004cbb21 shl rdi, 2                                                                        |     rdi <<= 2;
    0x004cbb25 xor ebp, ebp                                                                      |     ebp = 0;
    0x004cbb27 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cbb30 pmovsxbq xmm0, word [r13 + rbp - 2]                                               |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004cbb38 pmovsxbq xmm1, word [r13 + rbp]                                                   |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004cbb40 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                         |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004cbb46 movdqu xmmword [rax + rbp*8], xmm1                                                |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004cbb4b add rbp, 4                                                                        |         rbp += 4;
    0x004cbb4f cmp rdi, rbp                                                                      |         
    0x004cbb52 jne 0x4cbb30                                                                      |         
                                                                                                 |     } while (rdi != rbp);
                                                                                                 | label_37:
    0x004cbb54 cmp r10, r8                                                                       |     
    0x004cbb57 mov rbx, r11                                                                      |     rbx = r11;
    0x004cbb5a mov ebp, r14d                                                                     |     
                                                                                                 |     if (r10 == r8) {
    0x004cbb5d je 0x4cbb81                                                                       |         goto label_27;
                                                                                                 |     }
    0x004cbb5f add rcx, r8                                                                       |     rcx += r8;
    0x004cbb62 lea rsi, [rsi + r8*8]                                                             |     rsi = rsi + r8*8;
                                                                                                 | label_28:
    0x004cbb66 sub r9, rcx                                                                       |     r9 -= rcx;
    0x004cbb69 lea rax, [rsp + r9 + 0x20]                                                        |     rax = rsp + r9 + 0x20;
    0x004cbb6e xor edi, edi                                                                      |     edi = 0;
                                                                                                 |     do {
    0x004cbb70 movsx rdx, byte [rcx + rdi]                                                       |         rdx = *((rcx + rdi));
    0x004cbb75 mov qword [rsi + rdi*8], rdx                                                      |         *((rsi + rdi*8)) = rdx;
    0x004cbb79 inc rdi                                                                           |         rdi++;
    0x004cbb7c cmp rax, rdi                                                                      |         
    0x004cbb7f jne 0x4cbb70                                                                      |         
                                                                                                 |     } while (rax != rdi);
                                                                                                 | label_27:
    0x004cbb81 mov rax, qword [rsp + 0x58]                                                       |     rax = *((rsp + 0x58));
    0x004cbb86 lea rdi, [rsp + 0x58]                                                             |     rdi = rsp + 0x58;
    0x004cbb8b mov rsi, 0xffffffffffffffff                                                       |     rsi = 0xffffffffffffffff;
    0x004cbb92 call qword [rax + 0x10]                                                           |     uint64_t (*rax + 0x10)() ();
    0x004cbb95 cmp byte [rip + 0x24cdf9], 0                                                      |     
    0x004cbb9c mov r12, qword [rsp + 0x18]                                                       |     r12 = *((rsp + 0x18));
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cbba1 je 0x4cbbad                                                                       |         
    0x004cbba3 mov edi, 0x4f4571                                                                 |         
    0x004cbba8 call 0x401710                                                                     |         puts ("\t\tEnd bslma exception test.");
                                                                                                 |     }
    0x004cbbad cmp byte [rip + 0x24cddc], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cbbb4 je 0x4cbbeb                                                                       |         
    0x004cbbb6 mov edi, 0xa                                                                      |         
    0x004cbbbb call 0x401720                                                                     |         eax = putchar (0xa);
                                                                                                 | label_32:
    0x004cbbc0 cmp byte [rip + 0x24cdc9], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004cbbc7 je 0x4cbbeb                                                                       |             goto label_38;
                                                                                                 |         }
    0x004cbbc9 mov edx, dword [rip + 0x24cdd5]                                                   |         edx = numCopyCtorCalls;
    0x004cbbcf sub edx, dword [rsp + 0x48]                                                       |         edx -= *((rsp + 0x48));
    0x004cbbd3 mov ecx, dword [rip + 0x24cdd3]                                                   |         ecx = numCharCtorCalls;
    0x004cbbd9 sub ecx, dword [rsp + 0x14]                                                       |         ecx -= *((rsp + 0x14));
    0x004cbbdd mov edi, 0x4f5db4                                                                 |         
    0x004cbbe2 mov esi, ebp                                                                      |         esi = ebp;
    0x004cbbe4 xor eax, eax                                                                      |         eax = 0;
    0x004cbbe6 call 0x401680                                                                     |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_38:
    0x004cbbeb mov eax, dword [rsp + 0x48]                                                       |     eax = *((rsp + 0x48));
    0x004cbbef cmp eax, dword [rip + 0x24cdaf]                                                   |     
                                                                                                 |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cbbf5 je 0x4cb5e0                                                                       |         goto label_3;
                                                                                                 |     }
    0x004cbbfb mov edi, 0x4f4e04                                                                 |     
    0x004cbc00 mov edx, 0x4f5176                                                                 |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cbc05 mov esi, 0x103f                                                                   |     esi = 0x103f;
    0x004cbc0a xor eax, eax                                                                      |     eax = 0;
    0x004cbc0c call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cbc11 mov eax, dword [rip + 0x24cd81]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004cbc17 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004cbc1a ja 0x4cb5e0                                                                       |         goto label_3;
                                                                                                 |     }
    0x004cbc20 inc eax                                                                           |     eax++;
    0x004cbc22 mov dword [rip + 0x24cd70], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cbc28 jmp 0x4cb5e0                                                                      |     goto label_3;
                                                                                                 | label_21:
    0x004cbc2d add rsp, 0x68                                                                     |     
    0x004cbc31 pop rbx                                                                           |     
    0x004cbc32 pop r12                                                                           |     
    0x004cbc34 pop r13                                                                           |     
    0x004cbc36 pop r14                                                                           |     
    0x004cbc38 pop r15                                                                           |     
    0x004cbc3a pop rbp                                                                           |     
    0x004cbc3b ret                                                                               |     return rax;
                                                                                                 | }