; assembly                                                                                   | /* r2dec pseudo code output */
                                                                                                 | /* bslalg_arrayprimitives.t/assume @ 0x4caef0 */
                                                                                                 | #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;
                                                                                                 |     int64_t var_48h;
                                                                                                 |     uint32_t var_54h;
                                                                                                 |     int64_t var_58h;
                                                                                                 |     int64_t var_60h;
                                                                                                 |     rdx = arg3;
                                                                                                 |     rsi = arg2;
                                                                                                 |     /* void testCopyConstructWithIterators<int volatile*>(bool, bool, bool) */
    0x004caef0 push rbp                                                                          |     
    0x004caef1 push r15                                                                          |     
    0x004caef3 push r14                                                                          |     
    0x004caef5 push r13                                                                          |     
    0x004caef7 push r12                                                                          |     
    0x004caef9 push rbx                                                                          |     
    0x004caefa sub rsp, 0x68                                                                     |     
    0x004caefe mov dword [rsp + 0x54], edx                                                       |     *((rsp + 0x54)) = edx;
    0x004caf02 mov dword [rsp + 0x40], esi                                                       |     *((rsp + 0x40)) = esi;
    0x004caf06 cmp byte [rip + 0x24da89], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004caf0d je 0x4caf19                                                                       |         
    0x004caf0f mov edi, 0x4f67e9                                                                 |         
    0x004caf14 call 0x401710                                                                     |         eax = puts ("\t\tfrom same type.");
                                                                                                 |     }
    0x004caf19 xor eax, eax                                                                      |     eax = 0;
    0x004caf1b jmp 0x4caf4c                                                                      |     goto label_5;
                                                                                                 | label_2:
    0x004caf20 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004caf25 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004caf28 call 0x4e3360                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004caf2d mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004caf32 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004caf35 call 0x4e35a0                                                                     |     voidcleanup<intvolatile*>(intvolatile**,char const*) ();
    0x004caf3a mov rax, qword [rsp + 0x18]                                                       |     rax = *((rsp + 0x18));
    0x004caf3f inc rax                                                                           |     rax++;
    0x004caf42 cmp rax, 0x1e                                                                     |     
                                                                                                 |     if (rax == 0x1e) {
    0x004caf46 je 0x4cb489                                                                       |         goto label_6;
                                                                                                 |     }
                                                                                                 | label_5:
    0x004caf4c mov qword [rsp + 0x18], rax                                                       |     *((rsp + 0x18)) = rax;
    0x004caf51 lea rbp, [rax*8]                                                                  |     rbp = rax*8;
    0x004caf59 mov r12, qword [rbp + rbp*4 + 0x4f3b08]                                           |     r12 = *((rbp + rbp*4 + 0x4f3b08));
    0x004caf61 mov rdi, r12                                                                      |     
    0x004caf64 call 0x401790                                                                     |     eax = strlen (*((rbp + rbp*4 + 0x4f3b08)));
    0x004caf69 cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004caf6c jl 0x4caf97                                                                       |         
    0x004caf6e mov edi, 0x4f4c78                                                                 |         
    0x004caf73 mov edx, 0x4f4203                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004caf78 mov esi, 0xfe6                                                                    |         esi = 0xfe6;
    0x004caf7d xor eax, eax                                                                      |         eax = 0;
    0x004caf7f call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004caf84 mov eax, dword [rip + 0x24da0e]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004caf8a cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004caf8d ja 0x4caf97                                                                       |             goto label_7;
                                                                                                 |         }
    0x004caf8f inc eax                                                                           |         eax++;
    0x004caf91 mov dword [rip + 0x24da01], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_7:
    0x004caf97 mov r13d, dword [rbp + rbp*4 + 0x4f3b00]                                          |     r13d = *((rbp + rbp*4 + obj.DATA_3));
    0x004caf9f movsxd r15, dword [rbp + rbp*4 + 0x4f3b10]                                        |     r15 = *((rbp + rbp*4 + 0x4f3b10));
    0x004cafa7 mov ebx, dword [rbp + rbp*4 + 0x4f3b14]                                           |     ebx = *((rbp + rbp*4 + 0x4f3b14));
    0x004cafae movsxd r14, dword [rbp + rbp*4 + 0x4f3b18]                                        |     r14 = *((rbp + rbp*4 + 0x4f3b18));
    0x004cafb6 mov rbp, qword [rbp + rbp*4 + 0x4f3b20]                                           |     rbp = *((rbp + rbp*4 + 0x4f3b20));
    0x004cafbe cmp byte [rip + 0x24d9cb], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cafc5 je 0x4cafe6                                                                       |         
    0x004cafc7 mov qword [rsp], rbp                                                              |         *(rsp) = rbp;
    0x004cafcb mov edi, 0x4f5ab7                                                                 |         
    0x004cafd0 mov esi, r13d                                                                     |         esi = r13d;
    0x004cafd3 mov rdx, r12                                                                      |         rdx = r12;
    0x004cafd6 mov ecx, r15d                                                                     |         ecx = r15d;
    0x004cafd9 mov r8d, ebx                                                                      |         r8d = ebx;
    0x004cafdc mov r9d, r14d                                                                     |         r9d = r14d;
    0x004cafdf xor eax, eax                                                                      |         eax = 0;
    0x004cafe1 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004cafe6 mov qword [rsp + 0x48], rbx                                                       |     *((rsp + 0x48)) = rbx;
    0x004cafeb mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004caff0 mov rsi, r12                                                                      |     rsi = r12;
    0x004caff3 call 0x4e3280                                                                     |     intvolatile*&gg<intvolatile*>(intvolatile**,char const*) ();
    0x004caff8 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004caffd mov rsi, r12                                                                      |     rsi = r12;
    0x004cb000 call 0x4e3360                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb005 mov r12d, dword [rip + 0x24d998]                                                  |     r12d = numCopyCtorCalls;
    0x004cb00c mov eax, dword [rip + 0x24d99a]                                                   |     eax = numCharCtorCalls;
    0x004cb012 mov dword [rsp + 0x14], eax                                                       |     *((rsp + 0x14)) = eax;
    0x004cb016 cmp byte [rsp + 0x54], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x54)) == 0) {
    0x004cb01b je 0x4cb100                                                                       |         goto label_8;
                                                                                                 |     }
    0x004cb021 cmp byte [rip + 0x24d968], 0                                                      |     
    0x004cb028 mov ebx, r13d                                                                     |     ebx = r13d;
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb02b je 0x4cb040                                                                       |         
    0x004cb02d cmp dword [rip + 0x24d574], 0                                                     |         
                                                                                                 |         if (*(obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::firstTime) == 0) {
    0x004cb034 je 0x4cb040                                                                       |             goto label_9;
                                                                                                 |         }
    0x004cb036 mov edi, 0x4f425a                                                                 |         
    0x004cb03b call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_9:
    0x004cb040 mov dword [rip + 0x24d55e], 0                                                     |     *(obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::firstTime) = 0;
    0x004cb04a cmp byte [rip + 0x24d944], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cb051 je 0x4cb05d                                                                       |         
    0x004cb053 mov edi, 0x4f4281                                                                 |         
    0x004cb058 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004cb05d mov rax, qword [rip + 0x24d7bc]                                                   |     rax = Z;
    0x004cb064 mov qword [rsp + 0x20], 0x4f6858                                                  |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cb06d mov qword [rsp + 0x28], rax                                                       |     *((rsp + 0x28)) = rax;
    0x004cb072 mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004cb07a test rax, rax                                                                     |     
    0x004cb07d je 0x4cb169                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_0:
    0x004cb083 lea rsi, [r15*8 + 0x74f960]                                                       |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb08b mov rax, qword [rsp + 0x48]                                                       |         rax = *((rsp + 0x48));
    0x004cb090 add eax, r15d                                                                     |         eax += r15d;
    0x004cb093 cdqe                                                                              |         rax = (int64_t) eax;
    0x004cb095 lea rdx, [rax*8 + 0x74f960]                                                       |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb09d sub rdx, rsi                                                                      |         rdx -= rsi;
                                                                                                 |         if (rdx != 0) {
    0x004cb0a0 je 0x4cb0af                                                                       |             
    0x004cb0a2 lea rdi, [r14*8 + 0x74f960]                                                       |             
    0x004cb0aa call 0x401930                                                                     |             memcpy (r14*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u, rsi, rdx);
                                                                                                 |         }
    0x004cb0af mov rax, qword [rsp + 0x20]                                                       |         rax = *((rsp + 0x20));
    0x004cb0b4 lea rdi, [rsp + 0x20]                                                             |         rdi = rsp + 0x20;
    0x004cb0b9 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004cb0c0 call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004cb0c3 cmp byte [rip + 0x24d8cb], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004cb0ca je 0x4cb0d6                                                                       |             
    0x004cb0cc mov edi, 0x4f43e1                                                                 |             
    0x004cb0d1 call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004cb0d6 cmp byte [rip + 0x24d8b3], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004cb0dd je 0x4cb3ab                                                                       |             goto label_10;
                                                                                                 |         }
    0x004cb0e3 mov edi, 0xa                                                                      |         
    0x004cb0e8 call 0x401720                                                                     |         putchar (0xa);
    0x004cb0ed jmp 0x4cb381                                                                      |         goto label_11;
                                                                                                 | label_8:
    0x004cb100 cmp qword [rip + 0x24d718], 0                                                     |         
    0x004cb108 mov ebx, r13d                                                                     |         ebx = r13d;
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004cb10b jne 0x4cb11d                                                                      |             
    0x004cb10d mov rax, qword [rip + 0x2861a4]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb114 test rax, rax                                                                     |             
                                                                                                 |             if (rax == 0) {
    0x004cb117 je 0x4cb223                                                                       |                 goto label_12;
                                                                                                 |             }
                                                                                                 |         }
    0x004cb11d cmp qword [rsp + 0x18], 6                                                         |         
                                                                                                 |         if (*((rsp + 0x18)) < 6) {
    0x004cb123 jb 0x4cb381                                                                       |             goto label_11;
                                                                                                 |         }
                                                                                                 | label_1:
    0x004cb129 lea rax, [r15*8 + 0x74f960]                                                       |         rax = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb131 lea rcx, [r14*8 + 0x74f960]                                                       |         rcx = r14*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb139 mov rbx, qword [rsp + 0x48]                                                       |         rbx = *((rsp + 0x48));
    0x004cb13e lea edx, [rbx + r15]                                                              |         edx = rbx + r15;
    0x004cb142 movsxd r9, edx                                                                    |         r9 = (int64_t) edx;
    0x004cb145 shl r9, 3                                                                         |         r9 <<= 3;
    0x004cb149 lea rdi, [r15*8]                                                                  |         rdi = r15*8;
    0x004cb151 mov r10, r9                                                                       |         r10 = r9;
    0x004cb154 sub r10, rdi                                                                      |         r10 -= rdi;
    0x004cb157 add r10, 0xfffffffffffffff8                                                       |         r10 += 0xfffffffffffffff8;
    0x004cb15b cmp r10, 0x18                                                                     |         
                                                                                                 |         if (r10 >= 0x18) {
    0x004cb15f jae 0x4cb1dd                                                                      |             goto label_13;
                                                                                                 |         }
    0x004cb161 mov ebx, r13d                                                                     |         ebx = r13d;
    0x004cb164 jmp 0x4cb360                                                                      |         goto label_14;
    0x004cb169 mov r13d, 1                                                                       |         r13d = 1;
    0x004cb16f mov rax, qword [rip + 0x286142]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb176 test rax, rax                                                                     |         
    0x004cb179 jne 0x4cb083                                                                      |         
                                                                                                 |     }
    0x004cb17f call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb184 jmp 0x4cb083                                                                      |     goto label_0;
                                                                                                 | label_13:
    0x004cb1dd mov r11, rbp                                                                      |     r11 = rbp;
    0x004cb1e0 lea rsi, [r14*8 + 0x74f960]                                                       |     rsi = r14*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb1e8 lea edx, [rbx + r15]                                                              |     edx = rbx + r15;
    0x004cb1ec movsxd rdx, edx                                                                   |     rdx = (int64_t) edx;
    0x004cb1ef lea rbp, [rdx*8 + 0x74f960]                                                       |     rbp = rdx*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb1f7 cmp rsi, rbp                                                                      |     
                                                                                                 |     if (rsi >= rbp) {
    0x004cb1fa jae 0x4cb239                                                                      |         goto label_15;
                                                                                                 |     }
    0x004cb1fc shl rdx, 3                                                                        |     rdx <<= 3;
    0x004cb200 sub rdx, rdi                                                                      |     rdx -= rdi;
    0x004cb203 lea rdx, [rdx + r14*8 + 0x74f960]                                                 |     rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb20b lea rsi, [r15*8 + 0x74f960]                                                       |     rsi = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb213 cmp rsi, rdx                                                                      |     
                                                                                                 |     if (rsi >= rdx) {
    0x004cb216 jae 0x4cb239                                                                      |         goto label_15;
                                                                                                 |     }
    0x004cb218 mov rbp, r11                                                                      |     
    0x004cb21b mov ebx, r13d                                                                     |     ebx = r13d;
    0x004cb21e jmp 0x4cb360                                                                      |     goto label_14;
                                                                                                 | label_12:
    0x004cb223 call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb228 cmp qword [rsp + 0x18], 6                                                         |     
                                                                                                 |     if (*((rsp + 0x18)) >= 6) {
    0x004cb22e jae 0x4cb129                                                                      |         goto label_1;
                                                                                                 |     }
    0x004cb234 jmp 0x4cb381                                                                      |     goto label_11;
                                                                                                 | label_15:
    0x004cb239 shr r10, 3                                                                        |     r10 >>= 3;
    0x004cb23d inc r10                                                                           |     r10++;
    0x004cb240 mov r8, r10                                                                       |     r8 = r10;
    0x004cb243 and r8, 0xfffffffffffffffc                                                        |     r8 &= 0xfffffffffffffffc;
    0x004cb247 lea rsi, [r8 - 4]                                                                 |     rsi = r8 - 4;
    0x004cb24b mov rbp, rsi                                                                      |     
    0x004cb24e shr rbp, 2                                                                        |     rbp >>= 2;
    0x004cb252 inc rbp                                                                           |     rbp++;
    0x004cb255 mov edx, ebp                                                                      |     edx = ebp;
    0x004cb257 and edx, 3                                                                        |     edx &= 3;
    0x004cb25a cmp rsi, 0xc                                                                      |     
                                                                                                 |     if (rsi < 0xc) {
    0x004cb25e jae 0x4cb267                                                                      |         
    0x004cb260 xor ebx, ebx                                                                      |         ebx = 0;
    0x004cb262 jmp 0x4cb2f0                                                                      |         goto label_16;
                                                                                                 |     }
    0x004cb267 and rbp, 0xfffffffffffffffc                                                       |     rbp &= 0xfffffffffffffffc;
    0x004cb26b neg rbp                                                                           |     rbp = -rbp;
    0x004cb26e mov esi, 0x74f960                                                                 |     esi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb273 xor ebx, ebx                                                                      |     ebx = 0;
    0x004cb275 nop word cs:[rax + rax]                                                           |     
    0x004cb27f nop                                                                               |     
                                                                                                 |     do {
    0x004cb280 movups xmm0, xmmword [rsi + r15*8]                                                |         __asm ("movups xmm0, xmmword [rsi + r15*8]");
    0x004cb285 movups xmm1, xmmword [rsi + r15*8 + 0x10]                                         |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x10]");
    0x004cb28b movups xmmword [rsi + r14*8], xmm0                                                |         __asm ("movups xmmword [rsi + r14*8], xmm0");
    0x004cb290 movups xmmword [rsi + r14*8 + 0x10], xmm1                                         |         __asm ("movups xmmword [rsi + r14*8 + 0x10], xmm1");
    0x004cb296 movups xmm0, xmmword [rsi + r15*8 + 0x20]                                         |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x20]");
    0x004cb29c movups xmm1, xmmword [rsi + r15*8 + 0x30]                                         |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x30]");
    0x004cb2a2 movups xmmword [rsi + r14*8 + 0x20], xmm0                                         |         __asm ("movups xmmword [rsi + r14*8 + 0x20], xmm0");
    0x004cb2a8 movups xmmword [rsi + r14*8 + 0x30], xmm1                                         |         __asm ("movups xmmword [rsi + r14*8 + 0x30], xmm1");
    0x004cb2ae movups xmm0, xmmword [rsi + r15*8 + 0x40]                                         |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x40]");
    0x004cb2b4 movups xmm1, xmmword [rsi + r15*8 + 0x50]                                         |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x50]");
    0x004cb2ba movups xmmword [rsi + r14*8 + 0x40], xmm0                                         |         __asm ("movups xmmword [rsi + r14*8 + 0x40], xmm0");
    0x004cb2c0 movups xmmword [rsi + r14*8 + 0x50], xmm1                                         |         __asm ("movups xmmword [rsi + r14*8 + 0x50], xmm1");
    0x004cb2c6 movdqu xmm0, xmmword [rsi + r15*8 + 0x60]                                         |         __asm ("movdqu xmm0, xmmword [rsi + r15*8 + 0x60]");
    0x004cb2cd movdqu xmm1, xmmword [rsi + r15*8 + 0x70]                                         |         __asm ("movdqu xmm1, xmmword [rsi + r15*8 + 0x70]");
    0x004cb2d4 movdqu xmmword [rsi + r14*8 + 0x60], xmm0                                         |         __asm ("movdqu xmmword [rsi + r14*8 + 0x60], xmm0");
    0x004cb2db movdqu xmmword [rsi + r14*8 + 0x70], xmm1                                         |         __asm ("movdqu xmmword [rsi + r14*8 + 0x70], xmm1");
    0x004cb2e2 add rbx, 0x10                                                                     |         rbx += 0x10;
    0x004cb2e6 sub rsi, 0xffffffffffffff80                                                       |         rsi -= 0xffffffffffffff80;
    0x004cb2ea add rbp, 4                                                                        |         rbp += 4;
    0x004cb2ee jne 0x4cb280                                                                      |         
                                                                                                 |     } while (rbp != 0);
                                                                                                 | label_16:
    0x004cb2f0 test rdx, rdx                                                                     |     
                                                                                                 |     if (rdx == 0) {
    0x004cb2f3 je 0x4cb343                                                                       |         goto label_17;
                                                                                                 |     }
    0x004cb2f5 shl r14, 3                                                                        |     r14 <<= 3;
    0x004cb2f9 lea rsi, [rbx*8 + 0x74f960]                                                       |     rsi = rbx*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb301 neg rdx                                                                           |     rdx = -rdx;
    0x004cb304 nop word cs:[rax + rax]                                                           |     
    0x004cb30e nop                                                                               |     
                                                                                                 |     do {
    0x004cb310 movdqu xmm0, xmmword [rdi + rbx*8 + 0x74f960]                                     |         __asm ("movdqu xmm0, xmmword [rdi + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u]");
    0x004cb319 movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f970]                                     |         __asm ("movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f970]");
    0x004cb322 movdqu xmmword [r14 + rbx*8 + 0x74f960], xmm0                                     |         __asm ("movdqu xmmword [r14 + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cb32c movdqu xmmword [r14 + rbx*8 + 0x74f970], xmm1                                     |         __asm ("movdqu xmmword [r14 + rbx*8 + 0x74f970], xmm1");
    0x004cb336 add rbx, 4                                                                        |         rbx += 4;
    0x004cb33a add rsi, 0x20                                                                     |         rsi += 0x20;
    0x004cb33e inc rdx                                                                           |         rdx++;
    0x004cb341 jne 0x4cb310                                                                      |         
                                                                                                 |     } while (rdx != 0);
                                                                                                 | label_17:
    0x004cb343 cmp r10, r8                                                                       |     
    0x004cb346 mov rbp, r11                                                                      |     
    0x004cb349 mov ebx, r13d                                                                     |     ebx = r13d;
                                                                                                 |     if (r10 == r8) {
    0x004cb34c je 0x4cb381                                                                       |         goto label_11;
                                                                                                 |     }
    0x004cb34e lea rax, [rax + r8*8]                                                             |     rax = rax + r8*8;
    0x004cb352 lea rcx, [rcx + r8*8]                                                             |     rcx = rcx + r8*8;
    0x004cb356 nop word cs:[rax + rax]                                                           |     
                                                                                                 | label_14:
    0x004cb360 sub r9, rax                                                                       |     r9 -= rax;
    0x004cb363 lea rdx, [r9 + 0x74f960]                                                          |     rdx = r9 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb36a xor esi, esi                                                                      |     esi = 0;
    0x004cb36c nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004cb370 mov rdi, qword [rax + rsi]                                                        |         rdi = *((rax + rsi));
    0x004cb374 mov qword [rcx + rsi], rdi                                                        |         *((rcx + rsi)) = rdi;
    0x004cb378 add rsi, 8                                                                        |         rsi += 8;
    0x004cb37c cmp rdx, rsi                                                                      |         
    0x004cb37f jne 0x4cb370                                                                      |         
                                                                                                 |     } while (rdx != rsi);
                                                                                                 | label_11:
    0x004cb381 cmp byte [rip + 0x24d608], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb388 je 0x4cb3ab                                                                       |         
    0x004cb38a mov edx, dword [rip + 0x24d614]                                                   |         edx = numCopyCtorCalls;
    0x004cb390 sub edx, r12d                                                                     |         edx -= r12d;
    0x004cb393 mov ecx, dword [rip + 0x24d613]                                                   |         ecx = numCharCtorCalls;
    0x004cb399 sub ecx, dword [rsp + 0x14]                                                       |         ecx -= *((rsp + 0x14));
    0x004cb39d mov edi, 0x4f5c2a                                                                 |         
    0x004cb3a2 mov esi, ebx                                                                      |         esi = ebx;
    0x004cb3a4 xor eax, eax                                                                      |         eax = 0;
    0x004cb3a6 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_10:
    0x004cb3ab cmp byte [rsp + 0x40], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x40)) == 0) {
    0x004cb3b0 je 0x4cb410                                                                       |         goto label_18;
                                                                                                 |     }
    0x004cb3b2 cmp r12d, dword [rip + 0x24d5eb]                                                  |     
                                                                                                 |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004cb3b9 je 0x4cb3e4                                                                       |         
    0x004cb3bb mov edi, 0x4f4c78                                                                 |         
    0x004cb3c0 mov edx, 0x4f4fec                                                                 |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cb3c5 mov esi, 0x1005                                                                   |         esi = 0x1005;
    0x004cb3ca xor eax, eax                                                                      |         eax = 0;
    0x004cb3cc call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb3d1 mov eax, dword [rip + 0x24d5c1]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb3d7 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb3da ja 0x4cb3e4                                                                       |             goto label_19;
                                                                                                 |         }
    0x004cb3dc inc eax                                                                           |         eax++;
    0x004cb3de mov dword [rip + 0x24d5b4], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_19:
    0x004cb3e4 mov eax, dword [rsp + 0x14]                                                       |     eax = *((rsp + 0x14));
    0x004cb3e8 cmp eax, dword [rip + 0x24d5be]                                                   |     
                                                                                                 |     if (eax == *(obj.numCharCtorCalls)) {
    0x004cb3ee je 0x4caf20                                                                       |         goto label_2;
                                                                                                 |     }
    0x004cb3f4 mov edi, 0x4f4c78                                                                 |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004cb3f9 mov edx, 0x4f5c5a                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cb3fe mov esi, 0x1006                                                                   |     esi = 0x1006;
    0x004cb403 jmp 0x4cb466                                                                      |     goto label_20;
                                                                                                 | label_18:
    0x004cb410 add r12d, dword [rsp + 0x48]                                                      |     r12d += *((rsp + 0x48));
    0x004cb415 cmp r12d, dword [rip + 0x24d588]                                                  |     
                                                                                                 |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004cb41c jle 0x4cb447                                                                      |         
    0x004cb41e mov edi, 0x4f4c78                                                                 |         
    0x004cb423 mov edx, 0x4f5c78                                                                 |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004cb428 mov esi, 0x1009                                                                   |         esi = 0x1009;
    0x004cb42d xor eax, eax                                                                      |         eax = 0;
    0x004cb42f call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb434 mov eax, dword [rip + 0x24d55e]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb43a cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb43d ja 0x4cb447                                                                       |             goto label_21;
                                                                                                 |         }
    0x004cb43f inc eax                                                                           |         eax++;
    0x004cb441 mov dword [rip + 0x24d551], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_21:
    0x004cb447 mov eax, dword [rsp + 0x14]                                                       |     eax = *((rsp + 0x14));
    0x004cb44b cmp eax, dword [rip + 0x24d55b]                                                   |     
                                                                                                 |     if (eax == *(obj.numCharCtorCalls)) {
    0x004cb451 je 0x4caf20                                                                       |         goto label_2;
                                                                                                 |     }
    0x004cb457 mov edi, 0x4f4c78                                                                 |     
    0x004cb45c mov edx, 0x4f5c5a                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cb461 mov esi, 0x100a                                                                   |     esi = 0x100a;
                                                                                                 | label_20:
    0x004cb466 xor eax, eax                                                                      |     eax = 0;
    0x004cb468 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb46d mov eax, dword [rip + 0x24d525]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004cb473 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004cb476 ja 0x4caf20                                                                       |         goto label_2;
                                                                                                 |     }
    0x004cb47c inc eax                                                                           |     eax++;
    0x004cb47e mov dword [rip + 0x24d514], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cb484 jmp 0x4caf20                                                                      |     goto label_2;
                                                                                                 | label_6:
    0x004cb489 cmp byte [rip + 0x24d506], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004cb490 je 0x4cb49c                                                                       |         
    0x004cb492 mov edi, 0x4f67d2                                                                 |         
    0x004cb497 call 0x401710                                                                     |         puts ("\t\tfrom different type.");
                                                                                                 |     }
    0x004cb49c xor r12d, r12d                                                                    |     r12d = 0;
    0x004cb49f jmp 0x4cb4d7                                                                      |     goto label_22;
                                                                                                 | label_4:
    0x004cb4b0 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb4b5 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004cb4b8 call 0x4e3360                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb4bd mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb4c2 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004cb4c5 call 0x4e35a0                                                                     |     voidcleanup<intvolatile*>(intvolatile**,char const*) ();
    0x004cb4ca inc r12                                                                           |     r12++;
    0x004cb4cd cmp r12, 0x1e                                                                     |     
                                                                                                 |     if (r12 == 0x1e) {
    0x004cb4d1 je 0x4cbafd                                                                       |         goto label_23;
                                                                                                 |     }
                                                                                                 | label_22:
    0x004cb4d7 lea rbx, [r12*8]                                                                  |     rbx = r12*8;
    0x004cb4df mov rbp, qword [rbx + rbx*4 + 0x4f3b08]                                           |     rbp = *((rbx + rbx*4 + 0x4f3b08));
    0x004cb4e7 mov rdi, rbp                                                                      |     
    0x004cb4ea call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004cb4ef cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004cb4f2 jl 0x4cb51d                                                                       |         
    0x004cb4f4 mov edi, 0x4f4c78                                                                 |         
    0x004cb4f9 mov edx, 0x4f4203                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cb4fe mov esi, 0x1019                                                                   |         esi = 0x1019;
    0x004cb503 xor eax, eax                                                                      |         eax = 0;
    0x004cb505 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb50a mov eax, dword [rip + 0x24d488]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb510 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb513 ja 0x4cb51d                                                                       |             goto label_24;
                                                                                                 |         }
    0x004cb515 inc eax                                                                           |         eax++;
    0x004cb517 mov dword [rip + 0x24d47b], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_24:
    0x004cb51d mov rdi, rbp                                                                      |     
    0x004cb520 call 0x401790                                                                     |     rax = strlen (rbp);
    0x004cb525 cmp rax, 0x14                                                                     |     
                                                                                                 |     if (rax >= 0x14) {
    0x004cb529 jb 0x4cb554                                                                       |         
    0x004cb52b mov edi, 0x4f4c78                                                                 |         
    0x004cb530 mov edx, 0x4f5c9c                                                                 |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004cb535 mov esi, 0x101c                                                                   |         esi = 0x101c;
    0x004cb53a xor eax, eax                                                                      |         eax = 0;
    0x004cb53c call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cb541 mov eax, dword [rip + 0x24d451]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004cb547 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004cb54a ja 0x4cb554                                                                       |             goto label_25;
                                                                                                 |         }
    0x004cb54c inc eax                                                                           |         eax++;
    0x004cb54e mov dword [rip + 0x24d444], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_25:
    0x004cb554 mov qword [rsp + 0x18], r12                                                       |     *((rsp + 0x18)) = r12;
    0x004cb559 pxor xmm0, xmm0                                                                   |     xmm0 = 0;
    0x004cb55d movdqa xmmword [rsp + 0x20], xmm0                                                 |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004cb563 mov dword [rsp + 0x30], 0                                                         |     *((rsp + 0x30)) = 0;
    0x004cb56b mov al, byte [rbp]                                                                |     al = *(rbp);
    0x004cb56e test al, al                                                                       |     
                                                                                                 |     if (al == 0) {
    0x004cb570 je 0x4cb590                                                                       |         goto label_26;
                                                                                                 |     }
    0x004cb572 xor ecx, ecx                                                                      |     ecx = 0;
    0x004cb574 nop word cs:[rax + rax]                                                           |     
    0x004cb57e nop                                                                               |     
                                                                                                 |     do {
    0x004cb580 mov byte [rsp + rcx + 0x20], al                                                   |         *((rsp + rcx + 0x20)) = al;
    0x004cb584 movzx eax, byte [rbp + rcx + 1]                                                   |         eax = *((rbp + rcx + 1));
    0x004cb589 inc rcx                                                                           |         rcx++;
    0x004cb58c test al, al                                                                       |         
    0x004cb58e jne 0x4cb580                                                                      |         
                                                                                                 |     } while (al != 0);
                                                                                                 | label_26:
    0x004cb590 mov r14d, dword [rbx + rbx*4 + 0x4f3b00]                                          |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004cb598 movsxd r13, dword [rbx + rbx*4 + 0x4f3b10]                                        |     r13 = *((rbx + rbx*4 + 0x4f3b10));
    0x004cb5a0 movsxd r12, dword [rbx + rbx*4 + 0x4f3b14]                                        |     r12 = *((rbx + rbx*4 + 0x4f3b14));
    0x004cb5a8 movsxd r15, dword [rbx + rbx*4 + 0x4f3b18]                                        |     r15 = *((rbx + rbx*4 + 0x4f3b18));
    0x004cb5b0 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                           |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004cb5b8 cmp byte [rip + 0x24d3d1], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb5bf je 0x4cb5e0                                                                       |         
    0x004cb5c1 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004cb5c5 mov edi, 0x4f5ab7                                                                 |         
    0x004cb5ca mov esi, r14d                                                                     |         esi = r14d;
    0x004cb5cd mov rdx, rbp                                                                      |         rdx = rbp;
    0x004cb5d0 mov ecx, r13d                                                                     |         ecx = r13d;
    0x004cb5d3 mov r8d, r12d                                                                     |         r8d = r12d;
    0x004cb5d6 mov r9d, r15d                                                                     |         r9d = r15d;
    0x004cb5d9 xor eax, eax                                                                      |         eax = 0;
    0x004cb5db call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004cb5e0 mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb5e5 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb5e8 call 0x4e3280                                                                     |     intvolatile*&gg<intvolatile*>(intvolatile**,char const*) ();
    0x004cb5ed mov edi, 0x74f960                                                                 |     edi = testCopyConstructWithIterators<int volatile*>(bool, bool, bool)::u;
    0x004cb5f2 mov rsi, rbp                                                                      |     rsi = rbp;
    0x004cb5f5 call 0x4e3360                                                                     |     voidverify<intvolatile*>(intvolatile**,char const*) ();
    0x004cb5fa mov eax, dword [rip + 0x24d3a4]                                                   |     eax = numCopyCtorCalls;
    0x004cb600 mov dword [rsp + 0x14], eax                                                       |     *((rsp + 0x14)) = eax;
    0x004cb604 mov eax, dword [rip + 0x24d3a2]                                                   |     eax = numCharCtorCalls;
    0x004cb60a mov dword [rsp + 0x48], eax                                                       |     *((rsp + 0x48)) = eax;
    0x004cb60e cmp byte [rsp + 0x54], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x54)) == 0) {
    0x004cb613 je 0x4cb6e0                                                                       |         goto label_27;
                                                                                                 |     }
    0x004cb619 cmp byte [rip + 0x24d370], 0                                                      |     
    0x004cb620 mov ebp, r14d                                                                     |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cb623 je 0x4cb638                                                                       |         
    0x004cb625 cmp dword [rip + 0x24cf80], 0                                                     |         
                                                                                                 |         if (*(0x007185ac) == 0) {
    0x004cb62c je 0x4cb638                                                                       |             goto label_28;
                                                                                                 |         }
    0x004cb62e mov edi, 0x4f425a                                                                 |         
    0x004cb633 call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_28:
    0x004cb638 mov dword [rip + 0x24cf6a], 0                                                     |     *(0x007185ac) = 0;
    0x004cb642 cmp byte [rip + 0x24d34c], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cb649 je 0x4cb655                                                                       |         
    0x004cb64b mov edi, 0x4f4281                                                                 |         
    0x004cb650 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004cb655 mov rax, qword [rip + 0x24d1c4]                                                   |     rax = Z;
    0x004cb65c mov qword [rsp + 0x58], 0x4f6858                                                  |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cb665 mov qword [rsp + 0x60], rax                                                       |     *((rsp + 0x60)) = rax;
    0x004cb66a mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004cb672 test rax, rax                                                                     |     
    0x004cb675 je 0x4cb76d                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_3:
    0x004cb67b cmp qword [rsp + 0x18], 6                                                         |         
                                                                                                 |         if (*((rsp + 0x18)) < 6) {
    0x004cb681 jb 0x4cba51                                                                       |             goto label_29;
                                                                                                 |         }
    0x004cb687 lea rcx, [rsp + r13 + 0x20]                                                       |         rcx = rsp + r13 + 0x20;
    0x004cb68c lea rsi, [r15*8 + 0x74f960]                                                       |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb694 lea eax, [r13 + r12]                                                              |         eax = r13 + r12;
    0x004cb699 movsxd r9, eax                                                                    |         r9 = (int64_t) eax;
    0x004cb69c mov r10, r9                                                                       |         r10 = r9;
    0x004cb69f sub r10, r13                                                                      |         r10 -= r13;
    0x004cb6a2 cmp r10, 4                                                                        |         
                                                                                                 |         if (r10 < 4) {
    0x004cb6a6 jb 0x4cba36                                                                       |             goto label_30;
                                                                                                 |         }
    0x004cb6ac mov r11, rbx                                                                      |         r11 = rbx;
    0x004cb6af mov r8, r10                                                                       |         r8 = r10;
    0x004cb6b2 and r8, 0xfffffffffffffffc                                                        |         r8 &= 0xfffffffffffffffc;
    0x004cb6b6 lea rax, [r8 - 4]                                                                 |         rax = r8 - 4;
    0x004cb6ba mov rbp, rax                                                                      |         
    0x004cb6bd shr rbp, 2                                                                        |         rbp >>= 2;
    0x004cb6c1 inc rbp                                                                           |         rbp++;
    0x004cb6c4 mov edi, ebp                                                                      |         edi = ebp;
    0x004cb6c6 and edi, 3                                                                        |         edi &= 3;
    0x004cb6c9 cmp rax, 0xc                                                                      |         
                                                                                                 |         if (rax >= 0xc) {
    0x004cb6cd jae 0x4cb926                                                                      |             goto label_31;
                                                                                                 |         }
    0x004cb6d3 xor ebx, ebx                                                                      |         ebx = 0;
    0x004cb6d5 jmp 0x4cb9d5                                                                      |         goto label_32;
                                                                                                 | label_27:
    0x004cb6e0 cmp qword [rip + 0x24d138], 0                                                     |         
    0x004cb6e8 mov ebp, r14d                                                                     |         
    0x004cb6eb mov r11, r12                                                                      |         r11 = r12;
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004cb6ee jne 0x4cb710                                                                      |             
    0x004cb6f0 mov rax, qword [rip + 0x285bc1]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb6f7 test rax, rax                                                                     |             
                                                                                                 |             if (rax != 0) {
    0x004cb6fa jne 0x4cb710                                                                      |                 goto label_33;
                                                                                                 |             }
    0x004cb6fc call 0x4eec50                                                                     |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb701 mov r11, r12                                                                      |             r11 = r12;
    0x004cb704 nop word cs:[rax + rax]                                                           |             
    0x004cb70e nop                                                                               |             
                                                                                                 |         }
                                                                                                 | label_33:
    0x004cb710 mov r12, qword [rsp + 0x18]                                                       |         r12 = *((rsp + 0x18));
    0x004cb715 cmp r12, 6                                                                        |         
                                                                                                 |         if (r12 < 6) {
    0x004cb719 jb 0x4cba90                                                                       |             goto label_34;
                                                                                                 |         }
    0x004cb71f lea rax, [r15*8 + 0x74f960]                                                       |         rax = r15*8 + obj_testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u;
    0x004cb727 lea rcx, [rsp + r13 + 0x20]                                                       |         rcx = rsp + r13 + 0x20;
    0x004cb72c add r11, r13                                                                      |         r11 += r13;
    0x004cb72f mov r9, r11                                                                       |         r9 = r11;
    0x004cb732 sub r9, r13                                                                       |         r9 -= r13;
    0x004cb735 cmp r9, 4                                                                         |         
                                                                                                 |         if (r9 < 4) {
    0x004cb739 jb 0x4cb8fa                                                                       |             goto label_35;
                                                                                                 |         }
    0x004cb73f mov r10, rbx                                                                      |         r10 = rbx;
    0x004cb742 mov r8, r9                                                                        |         r8 = r9;
    0x004cb745 and r8, 0xfffffffffffffffc                                                        |         r8 &= 0xfffffffffffffffc;
    0x004cb749 lea rsi, [r8 - 4]                                                                 |         rsi = r8 - 4;
    0x004cb74d mov rdi, rsi                                                                      |         rdi = rsi;
    0x004cb750 shr rdi, 2                                                                        |         rdi >>= 2;
    0x004cb754 inc rdi                                                                           |         rdi++;
    0x004cb757 mov ebp, edi                                                                      |         
    0x004cb759 and ebp, 3                                                                        |         ebp &= 3;
    0x004cb75c cmp rsi, 0xc                                                                      |         
                                                                                                 |         if (rsi >= 0xc) {
    0x004cb760 jae 0x4cb7ed                                                                      |             goto label_36;
                                                                                                 |         }
    0x004cb766 xor ebx, ebx                                                                      |         ebx = 0;
    0x004cb768 jmp 0x4cb895                                                                      |         goto label_37;
    0x004cb76d mov eax, 1                                                                        |         eax = 1;
    0x004cb772 mov qword [rsp + 0x40], rax                                                       |         *((rsp + 0x40)) = rax;
    0x004cb777 mov rax, qword [rip + 0x285b3a]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cb77e test rax, rax                                                                     |         
    0x004cb781 jne 0x4cb67b                                                                      |         
                                                                                                 |     }
    0x004cb787 call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cb78c jmp 0x4cb67b                                                                      |     goto label_3;
                                                                                                 | label_36:
    0x004cb7ed lea rdx, [rsp + 0x2e]                                                             |     rdx = rsp + 0x2e;
    0x004cb7f2 lea rsi, [rdx + r13]                                                              |     rsi = rdx + r13;
    0x004cb7f6 and rdi, 0xfffffffffffffffc                                                       |     rdi &= 0xfffffffffffffffc;
    0x004cb7fa neg rdi                                                                           |     rdi = -rdi;
    0x004cb7fd xor ebx, ebx                                                                      |     ebx = 0;
    0x004cb7ff nop                                                                               |     
                                                                                                 |     do {
    0x004cb800 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                             |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cb807 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                             |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cb80e lea rdx, [r15*8]                                                                  |         rdx = r15*8;
    0x004cb816 movdqu xmmword [rdx + rbx*8 + 0x74f960], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cb81f movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1");
    0x004cb828 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                             |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cb82f pmovsxbq xmm1, word [rsi + rbx - 8]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cb836 movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0");
    0x004cb83f movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1");
    0x004cb848 pmovsxbq xmm0, word [rsi + rbx - 6]                                               |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cb84f pmovsxbq xmm1, word [rsi + rbx - 4]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cb856 movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0");
    0x004cb85f movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1");
    0x004cb868 pmovsxbq xmm0, word [rsi + rbx - 2]                                               |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cb86f pmovsxbq xmm1, word [rsi + rbx]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cb875 movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0");
    0x004cb87e movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1");
    0x004cb887 add rbx, 0x10                                                                     |         rbx += 0x10;
    0x004cb88b add rdi, 4                                                                        |         rdi += 4;
    0x004cb88f jne 0x4cb800                                                                      |         
                                                                                                 |     } while (rdi != 0);
                                                                                                 | label_37:
    0x004cb895 test rbp, rbp                                                                     |     
                                                                                                 |     if (rbp == 0) {
    0x004cb898 je 0x4cb8e4                                                                       |         goto label_38;
                                                                                                 |     }
    0x004cb89a add r13, rbx                                                                      |     r13 += rbx;
    0x004cb89d lea rdx, [rsp + 0x22]                                                             |     rdx = rsp + 0x22;
    0x004cb8a2 add r13, rdx                                                                      |     r13 += rdx;
    0x004cb8a5 shl r15, 3                                                                        |     r15 <<= 3;
    0x004cb8a9 lea rsi, [r15 + rbx*8 + 0x74f970]                                                 |     rsi = r15 + rbx*8 + 0x74f970;
    0x004cb8b1 shl rbp, 2                                                                        |     rbp <<= 2;
    0x004cb8b5 xor edi, edi                                                                      |     edi = 0;
    0x004cb8b7 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cb8c0 pmovsxbq xmm0, word [r13 + rdi - 2]                                               |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cb8c8 pmovsxbq xmm1, word [r13 + rdi]                                                   |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cb8d0 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                         |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cb8d6 movdqu xmmword [rsi + rdi*8], xmm1                                                |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cb8db add rdi, 4                                                                        |         rdi += 4;
    0x004cb8df cmp rbp, rdi                                                                      |         
    0x004cb8e2 jne 0x4cb8c0                                                                      |         
                                                                                                 |     } while (rbp != rdi);
                                                                                                 | label_38:
    0x004cb8e4 cmp r9, r8                                                                        |     
    0x004cb8e7 mov rbx, r10                                                                      |     rbx = r10;
    0x004cb8ea mov ebp, r14d                                                                     |     
                                                                                                 |     if (r9 == r8) {
    0x004cb8ed je 0x4cba90                                                                       |         goto label_34;
                                                                                                 |     }
    0x004cb8f3 add rcx, r8                                                                       |     rcx += r8;
    0x004cb8f6 lea rax, [rax + r8*8]                                                             |     rax = rax + r8*8;
                                                                                                 | label_35:
    0x004cb8fa sub r11, rcx                                                                      |     r11 -= rcx;
    0x004cb8fd lea rdx, [rsp + r11 + 0x20]                                                       |     rdx = rsp + r11 + 0x20;
    0x004cb902 xor esi, esi                                                                      |     esi = 0;
    0x004cb904 nop word cs:[rax + rax]                                                           |     
    0x004cb90e nop                                                                               |     
                                                                                                 |     do {
    0x004cb910 movsx rdi, byte [rcx + rsi]                                                       |         rdi = *((rcx + rsi));
    0x004cb915 mov qword [rax + rsi*8], rdi                                                      |         *((rax + rsi*8)) = rdi;
    0x004cb919 inc rsi                                                                           |         rsi++;
    0x004cb91c cmp rdx, rsi                                                                      |         
    0x004cb91f jne 0x4cb910                                                                      |         
                                                                                                 |     } while (rdx != rsi);
    0x004cb921 jmp 0x4cba90                                                                      |     goto label_34;
                                                                                                 | label_31:
    0x004cb926 lea rax, [rsp + 0x2e]                                                             |     rax = rsp + 0x2e;
    0x004cb92b add rax, r13                                                                      |     rax += r13;
    0x004cb92e and rbp, 0xfffffffffffffffc                                                       |     rbp &= 0xfffffffffffffffc;
    0x004cb932 neg rbp                                                                           |     rbp = -rbp;
    0x004cb935 xor ebx, ebx                                                                      |     ebx = 0;
    0x004cb937 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cb940 pmovsxbq xmm0, word [rax + rbx - 0xe]                                             |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cb947 pmovsxbq xmm1, word [rax + rbx - 0xc]                                             |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cb94e lea rdx, [r15*8]                                                                  |         rdx = r15*8;
    0x004cb956 movdqu xmmword [rdx + rbx*8 + 0x74f960], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_volatile__bool__bool__bool_::u], xmm0");
    0x004cb95f movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f970], xmm1");
    0x004cb968 pmovsxbq xmm0, word [rax + rbx - 0xa]                                             |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cb96f pmovsxbq xmm1, word [rax + rbx - 8]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cb976 movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f980], xmm0");
    0x004cb97f movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f990], xmm1");
    0x004cb988 pmovsxbq xmm0, word [rax + rbx - 6]                                               |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cb98f pmovsxbq xmm1, word [rax + rbx - 4]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cb996 movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9a0], xmm0");
    0x004cb99f movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9b0], xmm1");
    0x004cb9a8 pmovsxbq xmm0, word [rax + rbx - 2]                                               |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cb9af pmovsxbq xmm1, word [rax + rbx]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cb9b5 movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9c0], xmm0");
    0x004cb9be movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1                                     |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9d0], xmm1");
    0x004cb9c7 add rbx, 0x10                                                                     |         rbx += 0x10;
    0x004cb9cb add rbp, 4                                                                        |         rbp += 4;
    0x004cb9cf jne 0x4cb940                                                                      |         
                                                                                                 |     } while (rbp != 0);
                                                                                                 | label_32:
    0x004cb9d5 test rdi, rdi                                                                     |     
                                                                                                 |     if (rdi == 0) {
    0x004cb9d8 je 0x4cba24                                                                       |         goto label_39;
                                                                                                 |     }
    0x004cb9da add r13, rbx                                                                      |     r13 += rbx;
    0x004cb9dd lea rax, [rsp + 0x22]                                                             |     rax = rsp + 0x22;
    0x004cb9e2 add r13, rax                                                                      |     r13 += rax;
    0x004cb9e5 shl r15, 3                                                                        |     r15 <<= 3;
    0x004cb9e9 lea rax, [r15 + rbx*8 + 0x74f970]                                                 |     rax = r15 + rbx*8 + 0x74f970;
    0x004cb9f1 shl rdi, 2                                                                        |     rdi <<= 2;
    0x004cb9f5 xor ebp, ebp                                                                      |     ebp = 0;
    0x004cb9f7 nop word [rax + rax]                                                              |     
                                                                                                 |     do {
    0x004cba00 pmovsxbq xmm0, word [r13 + rbp - 2]                                               |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004cba08 pmovsxbq xmm1, word [r13 + rbp]                                                   |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004cba10 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                         |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004cba16 movdqu xmmword [rax + rbp*8], xmm1                                                |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004cba1b add rbp, 4                                                                        |         rbp += 4;
    0x004cba1f cmp rdi, rbp                                                                      |         
    0x004cba22 jne 0x4cba00                                                                      |         
                                                                                                 |     } while (rdi != rbp);
                                                                                                 | label_39:
    0x004cba24 cmp r10, r8                                                                       |     
    0x004cba27 mov rbx, r11                                                                      |     rbx = r11;
    0x004cba2a mov ebp, r14d                                                                     |     
                                                                                                 |     if (r10 == r8) {
    0x004cba2d je 0x4cba51                                                                       |         goto label_29;
                                                                                                 |     }
    0x004cba2f add rcx, r8                                                                       |     rcx += r8;
    0x004cba32 lea rsi, [rsi + r8*8]                                                             |     rsi = rsi + r8*8;
                                                                                                 | label_30:
    0x004cba36 sub r9, rcx                                                                       |     r9 -= rcx;
    0x004cba39 lea rax, [rsp + r9 + 0x20]                                                        |     rax = rsp + r9 + 0x20;
    0x004cba3e xor edi, edi                                                                      |     edi = 0;
                                                                                                 |     do {
    0x004cba40 movsx rdx, byte [rcx + rdi]                                                       |         rdx = *((rcx + rdi));
    0x004cba45 mov qword [rsi + rdi*8], rdx                                                      |         *((rsi + rdi*8)) = rdx;
    0x004cba49 inc rdi                                                                           |         rdi++;
    0x004cba4c cmp rax, rdi                                                                      |         
    0x004cba4f jne 0x4cba40                                                                      |         
                                                                                                 |     } while (rax != rdi);
                                                                                                 | label_29:
    0x004cba51 mov rax, qword [rsp + 0x58]                                                       |     rax = *((rsp + 0x58));
    0x004cba56 lea rdi, [rsp + 0x58]                                                             |     rdi = rsp + 0x58;
    0x004cba5b mov rsi, 0xffffffffffffffff                                                       |     rsi = 0xffffffffffffffff;
    0x004cba62 call qword [rax + 0x10]                                                           |     uint64_t (*rax + 0x10)() ();
    0x004cba65 cmp byte [rip + 0x24cf29], 0                                                      |     
    0x004cba6c mov r12, qword [rsp + 0x18]                                                       |     r12 = *((rsp + 0x18));
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cba71 je 0x4cba7d                                                                       |         
    0x004cba73 mov edi, 0x4f43e1                                                                 |         
    0x004cba78 call 0x401710                                                                     |         puts ("\t\tEnd bslma exception test.");
                                                                                                 |     }
    0x004cba7d cmp byte [rip + 0x24cf0c], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004cba84 je 0x4cbabb                                                                       |         
    0x004cba86 mov edi, 0xa                                                                      |         
    0x004cba8b call 0x401720                                                                     |         eax = putchar (0xa);
                                                                                                 | label_34:
    0x004cba90 cmp byte [rip + 0x24cef9], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004cba97 je 0x4cbabb                                                                       |             goto label_40;
                                                                                                 |         }
    0x004cba99 mov edx, dword [rip + 0x24cf05]                                                   |         edx = numCopyCtorCalls;
    0x004cba9f sub edx, dword [rsp + 0x14]                                                       |         edx -= *((rsp + 0x14));
    0x004cbaa3 mov ecx, dword [rip + 0x24cf03]                                                   |         ecx = numCharCtorCalls;
    0x004cbaa9 sub ecx, dword [rsp + 0x48]                                                       |         ecx -= *((rsp + 0x48));
    0x004cbaad mov edi, 0x4f5c2a                                                                 |         
    0x004cbab2 mov esi, ebp                                                                      |         esi = ebp;
    0x004cbab4 xor eax, eax                                                                      |         eax = 0;
    0x004cbab6 call 0x401680                                                                     |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_40:
    0x004cbabb mov eax, dword [rsp + 0x14]                                                       |     eax = *((rsp + 0x14));
    0x004cbabf cmp eax, dword [rip + 0x24cedf]                                                   |     
                                                                                                 |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cbac5 je 0x4cb4b0                                                                       |         goto label_4;
                                                                                                 |     }
    0x004cbacb mov edi, 0x4f4c78                                                                 |     
    0x004cbad0 mov edx, 0x4f4fec                                                                 |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cbad5 mov esi, 0x103f                                                                   |     esi = 0x103f;
    0x004cbada xor eax, eax                                                                      |     eax = 0;
    0x004cbadc call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cbae1 mov eax, dword [rip + 0x24ceb1]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004cbae7 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004cbaea ja 0x4cb4b0                                                                       |         goto label_4;
                                                                                                 |     }
    0x004cbaf0 inc eax                                                                           |     eax++;
    0x004cbaf2 mov dword [rip + 0x24cea0], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cbaf8 jmp 0x4cb4b0                                                                      |     goto label_4;
                                                                                                 | label_23:
    0x004cbafd add rsp, 0x68                                                                     |     
    0x004cbb01 pop rbx                                                                           |     
    0x004cbb02 pop r12                                                                           |     
    0x004cbb04 pop r13                                                                           |     
    0x004cbb06 pop r14                                                                           |     
    0x004cbb08 pop r15                                                                           |     
    0x004cbb0a pop rbp                                                                           |     
    0x004cbb0b ret                                                                               |     return rax;
                                                                                                 | }