; assembly                                                                                       | /* r2dec pseudo code output */
                                                                                                     | /* bslalg_arrayprimitives.t/assume @ 0x4cbb40 */
                                                                                                     | #include <stdint.h>
                                                                                                     |  
    ; (fcn) sym.void_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_ ()         | uint64_t void_testCopyConstructWithIterators_int_const_volatile_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                                     |     int64_t var_14h;
                                                                                                     |     uint32_t var_18h;
                                                                                                     |     int64_t var_20h;
                                                                                                     |     int64_t var_22h;
                                                                                                     |     int64_t var_28h;
                                                                                                     |     int64_t var_2eh;
                                                                                                     |     int64_t var_30h;
                                                                                                     |     uint32_t var_40h;
                                                                                                     |     int64_t var_48h;
                                                                                                     |     uint32_t var_54h;
                                                                                                     |     int64_t var_58h;
                                                                                                     |     int64_t var_60h;
                                                                                                     |     rdx = arg3;
                                                                                                     |     rsi = arg2;
                                                                                                     |     /* void testCopyConstructWithIterators<int const volatile*>(bool, bool, bool) */
    0x004cbb40 push rbp                                                                              |     
    0x004cbb41 push r15                                                                              |     
    0x004cbb43 push r14                                                                              |     
    0x004cbb45 push r13                                                                              |     
    0x004cbb47 push r12                                                                              |     
    0x004cbb49 push rbx                                                                              |     
    0x004cbb4a sub rsp, 0x68                                                                         |     
    0x004cbb4e mov dword [rsp + 0x54], edx                                                           |     *((rsp + 0x54)) = edx;
    0x004cbb52 mov dword [rsp + 0x40], esi                                                           |     *((rsp + 0x40)) = esi;
    0x004cbb56 cmp byte [rip + 0x24ce39], 0                                                          |     
                                                                                                     |     if (*(obj.verbose) != 0) {
    0x004cbb5d je 0x4cbb69                                                                           |         
    0x004cbb5f mov edi, 0x4f67e9                                                                     |         
    0x004cbb64 call 0x401710                                                                         |         eax = puts ("\t\tfrom same type.");
                                                                                                     |     }
    0x004cbb69 xor eax, eax                                                                          |     eax = 0;
    0x004cbb6b jmp 0x4cbb9c                                                                          |     goto label_5;
                                                                                                     | label_2:
    0x004cbb70 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbb75 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cbb78 call 0x4e3860                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbb7d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbb82 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cbb85 call 0x4e3aa0                                                                         |     voidcleanup<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbb8a mov rax, qword [rsp + 0x18]                                                           |     rax = *((rsp + 0x18));
    0x004cbb8f inc rax                                                                               |     rax++;
    0x004cbb92 cmp rax, 0x1e                                                                         |     
                                                                                                     |     if (rax == 0x1e) {
    0x004cbb96 je 0x4cc0d9                                                                           |         goto label_6;
                                                                                                     |     }
                                                                                                     | label_5:
    0x004cbb9c mov qword [rsp + 0x18], rax                                                           |     *((rsp + 0x18)) = rax;
    0x004cbba1 lea rbp, [rax*8]                                                                      |     rbp = rax*8;
    0x004cbba9 mov r12, qword [rbp + rbp*4 + 0x4f3b08]                                               |     r12 = *((rbp + rbp*4 + 0x4f3b08));
    0x004cbbb1 mov rdi, r12                                                                          |     
    0x004cbbb4 call 0x401790                                                                         |     eax = strlen (*((rbp + rbp*4 + 0x4f3b08)));
    0x004cbbb9 cmp eax, 0x11                                                                         |     
                                                                                                     |     if (eax >= 0x11) {
    0x004cbbbc jl 0x4cbbe7                                                                           |         
    0x004cbbbe mov edi, 0x4f4c78                                                                     |         
    0x004cbbc3 mov edx, 0x4f4203                                                                     |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cbbc8 mov esi, 0xfe6                                                                        |         esi = 0xfe6;
    0x004cbbcd xor eax, eax                                                                          |         eax = 0;
    0x004cbbcf call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cbbd4 mov eax, dword [rip + 0x24cdbe]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cbbda cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cbbdd ja 0x4cbbe7                                                                           |             goto label_7;
                                                                                                     |         }
    0x004cbbdf inc eax                                                                               |         eax++;
    0x004cbbe1 mov dword [rip + 0x24cdb1], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_7:
    0x004cbbe7 mov r13d, dword [rbp + rbp*4 + 0x4f3b00]                                              |     r13d = *((rbp + rbp*4 + obj.DATA_3));
    0x004cbbef movsxd r15, dword [rbp + rbp*4 + 0x4f3b10]                                            |     r15 = *((rbp + rbp*4 + 0x4f3b10));
    0x004cbbf7 mov ebx, dword [rbp + rbp*4 + 0x4f3b14]                                               |     ebx = *((rbp + rbp*4 + 0x4f3b14));
    0x004cbbfe movsxd r14, dword [rbp + rbp*4 + 0x4f3b18]                                            |     r14 = *((rbp + rbp*4 + 0x4f3b18));
    0x004cbc06 mov rbp, qword [rbp + rbp*4 + 0x4f3b20]                                               |     rbp = *((rbp + rbp*4 + 0x4f3b20));
    0x004cbc0e cmp byte [rip + 0x24cd7b], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cbc15 je 0x4cbc36                                                                           |         
    0x004cbc17 mov qword [rsp], rbp                                                                  |         *(rsp) = rbp;
    0x004cbc1b mov edi, 0x4f5ab7                                                                     |         
    0x004cbc20 mov esi, r13d                                                                         |         esi = r13d;
    0x004cbc23 mov rdx, r12                                                                          |         rdx = r12;
    0x004cbc26 mov ecx, r15d                                                                         |         ecx = r15d;
    0x004cbc29 mov r8d, ebx                                                                          |         r8d = ebx;
    0x004cbc2c mov r9d, r14d                                                                         |         r9d = r14d;
    0x004cbc2f xor eax, eax                                                                          |         eax = 0;
    0x004cbc31 call 0x401680                                                                         |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                     |     }
    0x004cbc36 mov qword [rsp + 0x48], rbx                                                           |     *((rsp + 0x48)) = rbx;
    0x004cbc3b mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbc40 mov rsi, r12                                                                          |     rsi = r12;
    0x004cbc43 call 0x4e3780                                                                         |     intconstvolatile*&gg<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbc48 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbc4d mov rsi, r12                                                                          |     rsi = r12;
    0x004cbc50 call 0x4e3860                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cbc55 mov r12d, dword [rip + 0x24cd48]                                                      |     r12d = numCopyCtorCalls;
    0x004cbc5c mov eax, dword [rip + 0x24cd4a]                                                       |     eax = numCharCtorCalls;
    0x004cbc62 mov dword [rsp + 0x14], eax                                                           |     *((rsp + 0x14)) = eax;
    0x004cbc66 cmp byte [rsp + 0x54], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x54)) == 0) {
    0x004cbc6b je 0x4cbd50                                                                           |         goto label_8;
                                                                                                     |     }
    0x004cbc71 cmp byte [rip + 0x24cd18], 0                                                          |     
    0x004cbc78 mov ebx, r13d                                                                         |     ebx = r13d;
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cbc7b je 0x4cbc90                                                                           |         
    0x004cbc7d cmp dword [rip + 0x24c92c], 0                                                         |         
                                                                                                     |         if (*(obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::firstTime) == 0) {
    0x004cbc84 je 0x4cbc90                                                                           |             goto label_9;
                                                                                                     |         }
    0x004cbc86 mov edi, 0x4f425a                                                                     |         
    0x004cbc8b call 0x401710                                                                         |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                     |     }
                                                                                                     | label_9:
    0x004cbc90 mov dword [rip + 0x24c916], 0                                                         |     *(obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::firstTime) = 0;
    0x004cbc9a cmp byte [rip + 0x24ccf4], 0                                                          |     
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cbca1 je 0x4cbcad                                                                           |         
    0x004cbca3 mov edi, 0x4f4281                                                                     |         
    0x004cbca8 call 0x401710                                                                         |         puts ("\t\tBegin bslma exception test.");
                                                                                                     |     }
    0x004cbcad mov rax, qword [rip + 0x24cb6c]                                                       |     rax = Z;
    0x004cbcb4 mov qword [rsp + 0x20], 0x4f6858                                                      |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cbcbd mov qword [rsp + 0x28], rax                                                           |     *((rsp + 0x28)) = rax;
    0x004cbcc2 mov qword [rax + 0x20], 0                                                             |     *((rax + 0x20)) = 0;
    0x004cbcca test rax, rax                                                                         |     
    0x004cbccd je 0x4cbdb9                                                                           |     
                                                                                                     |     while (rax != 0) {
                                                                                                     | label_0:
    0x004cbcd3 lea rsi, [r15*8 + 0x74f9e0]                                                           |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbcdb mov rax, qword [rsp + 0x48]                                                           |         rax = *((rsp + 0x48));
    0x004cbce0 add eax, r15d                                                                         |         eax += r15d;
    0x004cbce3 cdqe                                                                                  |         rax = (int64_t) eax;
    0x004cbce5 lea rdx, [rax*8 + 0x74f9e0]                                                           |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbced sub rdx, rsi                                                                          |         rdx -= rsi;
                                                                                                     |         if (rdx != 0) {
    0x004cbcf0 je 0x4cbcff                                                                           |             
    0x004cbcf2 lea rdi, [r14*8 + 0x74f9e0]                                                           |             
    0x004cbcfa call 0x401930                                                                         |             memcpy (r14*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u, rsi, rdx);
                                                                                                     |         }
    0x004cbcff mov rax, qword [rsp + 0x20]                                                           |         rax = *((rsp + 0x20));
    0x004cbd04 lea rdi, [rsp + 0x20]                                                                 |         rdi = rsp + 0x20;
    0x004cbd09 mov rsi, 0xffffffffffffffff                                                           |         rsi = 0xffffffffffffffff;
    0x004cbd10 call qword [rax + 0x10]                                                               |         uint64_t (*rax + 0x10)() ();
    0x004cbd13 cmp byte [rip + 0x24cc7b], 0                                                          |         
                                                                                                     |         if (*(obj.veryVeryVerbose) != 0) {
    0x004cbd1a je 0x4cbd26                                                                           |             
    0x004cbd1c mov edi, 0x4f43e1                                                                     |             
    0x004cbd21 call 0x401710                                                                         |             puts ("\t\tEnd bslma exception test.");
                                                                                                     |         }
    0x004cbd26 cmp byte [rip + 0x24cc63], 0                                                          |         
                                                                                                     |         if (*(obj.veryVerbose) == 0) {
    0x004cbd2d je 0x4cbffb                                                                           |             goto label_10;
                                                                                                     |         }
    0x004cbd33 mov edi, 0xa                                                                          |         
    0x004cbd38 call 0x401720                                                                         |         putchar (0xa);
    0x004cbd3d jmp 0x4cbfd1                                                                          |         goto label_11;
                                                                                                     | label_8:
    0x004cbd50 cmp qword [rip + 0x24cac8], 0                                                         |         
    0x004cbd58 mov ebx, r13d                                                                         |         ebx = r13d;
                                                                                                     |         if (*(obj.Z) == 0) {
    0x004cbd5b jne 0x4cbd6d                                                                          |             
    0x004cbd5d mov rax, qword [rip + 0x285554]                                                       |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cbd64 test rax, rax                                                                         |             
                                                                                                     |             if (rax == 0) {
    0x004cbd67 je 0x4cbe73                                                                           |                 goto label_12;
                                                                                                     |             }
                                                                                                     |         }
    0x004cbd6d cmp qword [rsp + 0x18], 6                                                             |         
                                                                                                     |         if (*((rsp + 0x18)) < 6) {
    0x004cbd73 jb 0x4cbfd1                                                                           |             goto label_11;
                                                                                                     |         }
                                                                                                     | label_1:
    0x004cbd79 lea rax, [r15*8 + 0x74f9e0]                                                           |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbd81 lea rcx, [r14*8 + 0x74f9e0]                                                           |         rcx = r14*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbd89 mov rbx, qword [rsp + 0x48]                                                           |         rbx = *((rsp + 0x48));
    0x004cbd8e lea edx, [rbx + r15]                                                                  |         edx = rbx + r15;
    0x004cbd92 movsxd r9, edx                                                                        |         r9 = (int64_t) edx;
    0x004cbd95 shl r9, 3                                                                             |         r9 <<= 3;
    0x004cbd99 lea rdi, [r15*8]                                                                      |         rdi = r15*8;
    0x004cbda1 mov r10, r9                                                                           |         r10 = r9;
    0x004cbda4 sub r10, rdi                                                                          |         r10 -= rdi;
    0x004cbda7 add r10, 0xfffffffffffffff8                                                           |         r10 += 0xfffffffffffffff8;
    0x004cbdab cmp r10, 0x18                                                                         |         
                                                                                                     |         if (r10 >= 0x18) {
    0x004cbdaf jae 0x4cbe2d                                                                          |             goto label_13;
                                                                                                     |         }
    0x004cbdb1 mov ebx, r13d                                                                         |         ebx = r13d;
    0x004cbdb4 jmp 0x4cbfb0                                                                          |         goto label_14;
    0x004cbdb9 mov r13d, 1                                                                           |         r13d = 1;
    0x004cbdbf mov rax, qword [rip + 0x2854f2]                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cbdc6 test rax, rax                                                                         |         
    0x004cbdc9 jne 0x4cbcd3                                                                          |         
                                                                                                     |     }
    0x004cbdcf call 0x4eec50                                                                         |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cbdd4 jmp 0x4cbcd3                                                                          |     goto label_0;
                                                                                                     | label_13:
    0x004cbe2d mov r11, rbp                                                                          |     r11 = rbp;
    0x004cbe30 lea rsi, [r14*8 + 0x74f9e0]                                                           |     rsi = r14*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe38 lea edx, [rbx + r15]                                                                  |     edx = rbx + r15;
    0x004cbe3c movsxd rdx, edx                                                                       |     rdx = (int64_t) edx;
    0x004cbe3f lea rbp, [rdx*8 + 0x74f9e0]                                                           |     rbp = rdx*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe47 cmp rsi, rbp                                                                          |     
                                                                                                     |     if (rsi >= rbp) {
    0x004cbe4a jae 0x4cbe89                                                                          |         goto label_15;
                                                                                                     |     }
    0x004cbe4c shl rdx, 3                                                                            |     rdx <<= 3;
    0x004cbe50 sub rdx, rdi                                                                          |     rdx -= rdi;
    0x004cbe53 lea rdx, [rdx + r14*8 + 0x74f9e0]                                                     |     rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe5b lea rsi, [r15*8 + 0x74f9e0]                                                           |     rsi = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbe63 cmp rsi, rdx                                                                          |     
                                                                                                     |     if (rsi >= rdx) {
    0x004cbe66 jae 0x4cbe89                                                                          |         goto label_15;
                                                                                                     |     }
    0x004cbe68 mov rbp, r11                                                                          |     
    0x004cbe6b mov ebx, r13d                                                                         |     ebx = r13d;
    0x004cbe6e jmp 0x4cbfb0                                                                          |     goto label_14;
                                                                                                     | label_12:
    0x004cbe73 call 0x4eec50                                                                         |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cbe78 cmp qword [rsp + 0x18], 6                                                             |     
                                                                                                     |     if (*((rsp + 0x18)) >= 6) {
    0x004cbe7e jae 0x4cbd79                                                                          |         goto label_1;
                                                                                                     |     }
    0x004cbe84 jmp 0x4cbfd1                                                                          |     goto label_11;
                                                                                                     | label_15:
    0x004cbe89 shr r10, 3                                                                            |     r10 >>= 3;
    0x004cbe8d inc r10                                                                               |     r10++;
    0x004cbe90 mov r8, r10                                                                           |     r8 = r10;
    0x004cbe93 and r8, 0xfffffffffffffffc                                                            |     r8 &= 0xfffffffffffffffc;
    0x004cbe97 lea rsi, [r8 - 4]                                                                     |     rsi = r8 - 4;
    0x004cbe9b mov rbp, rsi                                                                          |     
    0x004cbe9e shr rbp, 2                                                                            |     rbp >>= 2;
    0x004cbea2 inc rbp                                                                               |     rbp++;
    0x004cbea5 mov edx, ebp                                                                          |     edx = ebp;
    0x004cbea7 and edx, 3                                                                            |     edx &= 3;
    0x004cbeaa cmp rsi, 0xc                                                                          |     
                                                                                                     |     if (rsi < 0xc) {
    0x004cbeae jae 0x4cbeb7                                                                          |         
    0x004cbeb0 xor ebx, ebx                                                                          |         ebx = 0;
    0x004cbeb2 jmp 0x4cbf40                                                                          |         goto label_16;
                                                                                                     |     }
    0x004cbeb7 and rbp, 0xfffffffffffffffc                                                           |     rbp &= 0xfffffffffffffffc;
    0x004cbebb neg rbp                                                                               |     rbp = -rbp;
    0x004cbebe mov esi, 0x74f9e0                                                                     |     esi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cbec3 xor ebx, ebx                                                                          |     ebx = 0;
    0x004cbec5 nop word cs:[rax + rax]                                                               |     
    0x004cbecf nop                                                                                   |     
                                                                                                     |     do {
    0x004cbed0 movups xmm0, xmmword [rsi + r15*8]                                                    |         __asm ("movups xmm0, xmmword [rsi + r15*8]");
    0x004cbed5 movups xmm1, xmmword [rsi + r15*8 + 0x10]                                             |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x10]");
    0x004cbedb movups xmmword [rsi + r14*8], xmm0                                                    |         __asm ("movups xmmword [rsi + r14*8], xmm0");
    0x004cbee0 movups xmmword [rsi + r14*8 + 0x10], xmm1                                             |         __asm ("movups xmmword [rsi + r14*8 + 0x10], xmm1");
    0x004cbee6 movups xmm0, xmmword [rsi + r15*8 + 0x20]                                             |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x20]");
    0x004cbeec movups xmm1, xmmword [rsi + r15*8 + 0x30]                                             |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x30]");
    0x004cbef2 movups xmmword [rsi + r14*8 + 0x20], xmm0                                             |         __asm ("movups xmmword [rsi + r14*8 + 0x20], xmm0");
    0x004cbef8 movups xmmword [rsi + r14*8 + 0x30], xmm1                                             |         __asm ("movups xmmword [rsi + r14*8 + 0x30], xmm1");
    0x004cbefe movups xmm0, xmmword [rsi + r15*8 + 0x40]                                             |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x40]");
    0x004cbf04 movups xmm1, xmmword [rsi + r15*8 + 0x50]                                             |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x50]");
    0x004cbf0a movups xmmword [rsi + r14*8 + 0x40], xmm0                                             |         __asm ("movups xmmword [rsi + r14*8 + 0x40], xmm0");
    0x004cbf10 movups xmmword [rsi + r14*8 + 0x50], xmm1                                             |         __asm ("movups xmmword [rsi + r14*8 + 0x50], xmm1");
    0x004cbf16 movdqu xmm0, xmmword [rsi + r15*8 + 0x60]                                             |         __asm ("movdqu xmm0, xmmword [rsi + r15*8 + 0x60]");
    0x004cbf1d movdqu xmm1, xmmword [rsi + r15*8 + 0x70]                                             |         __asm ("movdqu xmm1, xmmword [rsi + r15*8 + 0x70]");
    0x004cbf24 movdqu xmmword [rsi + r14*8 + 0x60], xmm0                                             |         __asm ("movdqu xmmword [rsi + r14*8 + 0x60], xmm0");
    0x004cbf2b movdqu xmmword [rsi + r14*8 + 0x70], xmm1                                             |         __asm ("movdqu xmmword [rsi + r14*8 + 0x70], xmm1");
    0x004cbf32 add rbx, 0x10                                                                         |         rbx += 0x10;
    0x004cbf36 sub rsi, 0xffffffffffffff80                                                           |         rsi -= 0xffffffffffffff80;
    0x004cbf3a add rbp, 4                                                                            |         rbp += 4;
    0x004cbf3e jne 0x4cbed0                                                                          |         
                                                                                                     |     } while (rbp != 0);
                                                                                                     | label_16:
    0x004cbf40 test rdx, rdx                                                                         |     
                                                                                                     |     if (rdx == 0) {
    0x004cbf43 je 0x4cbf93                                                                           |         goto label_17;
                                                                                                     |     }
    0x004cbf45 shl r14, 3                                                                            |     r14 <<= 3;
    0x004cbf49 lea rsi, [rbx*8 + 0x74f9e0]                                                           |     rsi = rbx*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbf51 neg rdx                                                                               |     rdx = -rdx;
    0x004cbf54 nop word cs:[rax + rax]                                                               |     
    0x004cbf5e nop                                                                                   |     
                                                                                                     |     do {
    0x004cbf60 movdqu xmm0, xmmword [rdi + rbx*8 + 0x74f9e0]                                         |         __asm ("movdqu xmm0, xmmword [rdi + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u]");
    0x004cbf69 movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f9f0]                                         |         __asm ("movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f9f0]");
    0x004cbf72 movdqu xmmword [r14 + rbx*8 + 0x74f9e0], xmm0                                         |         __asm ("movdqu xmmword [r14 + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cbf7c movdqu xmmword [r14 + rbx*8 + 0x74f9f0], xmm1                                         |         __asm ("movdqu xmmword [r14 + rbx*8 + 0x74f9f0], xmm1");
    0x004cbf86 add rbx, 4                                                                            |         rbx += 4;
    0x004cbf8a add rsi, 0x20                                                                         |         rsi += 0x20;
    0x004cbf8e inc rdx                                                                               |         rdx++;
    0x004cbf91 jne 0x4cbf60                                                                          |         
                                                                                                     |     } while (rdx != 0);
                                                                                                     | label_17:
    0x004cbf93 cmp r10, r8                                                                           |     
    0x004cbf96 mov rbp, r11                                                                          |     
    0x004cbf99 mov ebx, r13d                                                                         |     ebx = r13d;
                                                                                                     |     if (r10 == r8) {
    0x004cbf9c je 0x4cbfd1                                                                           |         goto label_11;
                                                                                                     |     }
    0x004cbf9e lea rax, [rax + r8*8]                                                                 |     rax = rax + r8*8;
    0x004cbfa2 lea rcx, [rcx + r8*8]                                                                 |     rcx = rcx + r8*8;
    0x004cbfa6 nop word cs:[rax + rax]                                                               |     
                                                                                                     | label_14:
    0x004cbfb0 sub r9, rax                                                                           |     r9 -= rax;
    0x004cbfb3 lea rdx, [r9 + 0x74f9e0]                                                              |     rdx = r9 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cbfba xor esi, esi                                                                          |     esi = 0;
    0x004cbfbc nop dword [rax]                                                                       |     
                                                                                                     |     do {
    0x004cbfc0 mov rdi, qword [rax + rsi]                                                            |         rdi = *((rax + rsi));
    0x004cbfc4 mov qword [rcx + rsi], rdi                                                            |         *((rcx + rsi)) = rdi;
    0x004cbfc8 add rsi, 8                                                                            |         rsi += 8;
    0x004cbfcc cmp rdx, rsi                                                                          |         
    0x004cbfcf jne 0x4cbfc0                                                                          |         
                                                                                                     |     } while (rdx != rsi);
                                                                                                     | label_11:
    0x004cbfd1 cmp byte [rip + 0x24c9b8], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cbfd8 je 0x4cbffb                                                                           |         
    0x004cbfda mov edx, dword [rip + 0x24c9c4]                                                       |         edx = numCopyCtorCalls;
    0x004cbfe0 sub edx, r12d                                                                         |         edx -= r12d;
    0x004cbfe3 mov ecx, dword [rip + 0x24c9c3]                                                       |         ecx = numCharCtorCalls;
    0x004cbfe9 sub ecx, dword [rsp + 0x14]                                                           |         ecx -= *((rsp + 0x14));
    0x004cbfed mov edi, 0x4f5c2a                                                                     |         
    0x004cbff2 mov esi, ebx                                                                          |         esi = ebx;
    0x004cbff4 xor eax, eax                                                                          |         eax = 0;
    0x004cbff6 call 0x401680                                                                         |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                     |     }
                                                                                                     | label_10:
    0x004cbffb cmp byte [rsp + 0x40], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x40)) == 0) {
    0x004cc000 je 0x4cc060                                                                           |         goto label_18;
                                                                                                     |     }
    0x004cc002 cmp r12d, dword [rip + 0x24c99b]                                                      |     
                                                                                                     |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004cc009 je 0x4cc034                                                                           |         
    0x004cc00b mov edi, 0x4f4c78                                                                     |         
    0x004cc010 mov edx, 0x4f4fec                                                                     |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cc015 mov esi, 0x1005                                                                       |         esi = 0x1005;
    0x004cc01a xor eax, eax                                                                          |         eax = 0;
    0x004cc01c call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc021 mov eax, dword [rip + 0x24c971]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc027 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc02a ja 0x4cc034                                                                           |             goto label_19;
                                                                                                     |         }
    0x004cc02c inc eax                                                                               |         eax++;
    0x004cc02e mov dword [rip + 0x24c964], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_19:
    0x004cc034 mov eax, dword [rsp + 0x14]                                                           |     eax = *((rsp + 0x14));
    0x004cc038 cmp eax, dword [rip + 0x24c96e]                                                       |     
                                                                                                     |     if (eax == *(obj.numCharCtorCalls)) {
    0x004cc03e je 0x4cbb70                                                                           |         goto label_2;
                                                                                                     |     }
    0x004cc044 mov edi, 0x4f4c78                                                                     |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004cc049 mov edx, 0x4f5c5a                                                                     |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cc04e mov esi, 0x1006                                                                       |     esi = 0x1006;
    0x004cc053 jmp 0x4cc0b6                                                                          |     goto label_20;
                                                                                                     | label_18:
    0x004cc060 add r12d, dword [rsp + 0x48]                                                          |     r12d += *((rsp + 0x48));
    0x004cc065 cmp r12d, dword [rip + 0x24c938]                                                      |     
                                                                                                     |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004cc06c jle 0x4cc097                                                                          |         
    0x004cc06e mov edi, 0x4f4c78                                                                     |         
    0x004cc073 mov edx, 0x4f5c78                                                                     |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004cc078 mov esi, 0x1009                                                                       |         esi = 0x1009;
    0x004cc07d xor eax, eax                                                                          |         eax = 0;
    0x004cc07f call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc084 mov eax, dword [rip + 0x24c90e]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc08a cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc08d ja 0x4cc097                                                                           |             goto label_21;
                                                                                                     |         }
    0x004cc08f inc eax                                                                               |         eax++;
    0x004cc091 mov dword [rip + 0x24c901], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_21:
    0x004cc097 mov eax, dword [rsp + 0x14]                                                           |     eax = *((rsp + 0x14));
    0x004cc09b cmp eax, dword [rip + 0x24c90b]                                                       |     
                                                                                                     |     if (eax == *(obj.numCharCtorCalls)) {
    0x004cc0a1 je 0x4cbb70                                                                           |         goto label_2;
                                                                                                     |     }
    0x004cc0a7 mov edi, 0x4f4c78                                                                     |     
    0x004cc0ac mov edx, 0x4f5c5a                                                                     |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004cc0b1 mov esi, 0x100a                                                                       |     esi = 0x100a;
                                                                                                     | label_20:
    0x004cc0b6 xor eax, eax                                                                          |     eax = 0;
    0x004cc0b8 call 0x401680                                                                         |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc0bd mov eax, dword [rip + 0x24c8d5]                                                       |     eax = (anonymous namespace)::testStatus;
    0x004cc0c3 cmp eax, 0x64                                                                         |     
                                                                                                     |     if (eax > 0x64) {
    0x004cc0c6 ja 0x4cbb70                                                                           |         goto label_2;
                                                                                                     |     }
    0x004cc0cc inc eax                                                                               |     eax++;
    0x004cc0ce mov dword [rip + 0x24c8c4], eax                                                       |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cc0d4 jmp 0x4cbb70                                                                          |     goto label_2;
                                                                                                     | label_6:
    0x004cc0d9 cmp byte [rip + 0x24c8b6], 0                                                          |     
                                                                                                     |     if (*(obj.verbose) != 0) {
    0x004cc0e0 je 0x4cc0ec                                                                           |         
    0x004cc0e2 mov edi, 0x4f67d2                                                                     |         
    0x004cc0e7 call 0x401710                                                                         |         puts ("\t\tfrom different type.");
                                                                                                     |     }
    0x004cc0ec xor r12d, r12d                                                                        |     r12d = 0;
    0x004cc0ef jmp 0x4cc127                                                                          |     goto label_22;
                                                                                                     | label_4:
    0x004cc100 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc105 mov rsi, rbx                                                                          |     rsi = rbx;
    0x004cc108 call 0x4e3860                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc10d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc112 mov rsi, rbx                                                                          |     rsi = rbx;
    0x004cc115 call 0x4e3aa0                                                                         |     voidcleanup<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc11a inc r12                                                                               |     r12++;
    0x004cc11d cmp r12, 0x1e                                                                         |     
                                                                                                     |     if (r12 == 0x1e) {
    0x004cc121 je 0x4cc74d                                                                           |         goto label_23;
                                                                                                     |     }
                                                                                                     | label_22:
    0x004cc127 lea rbx, [r12*8]                                                                      |     rbx = r12*8;
    0x004cc12f mov rbp, qword [rbx + rbx*4 + 0x4f3b08]                                               |     rbp = *((rbx + rbx*4 + 0x4f3b08));
    0x004cc137 mov rdi, rbp                                                                          |     
    0x004cc13a call 0x401790                                                                         |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004cc13f cmp eax, 0x11                                                                         |     
                                                                                                     |     if (eax >= 0x11) {
    0x004cc142 jl 0x4cc16d                                                                           |         
    0x004cc144 mov edi, 0x4f4c78                                                                     |         
    0x004cc149 mov edx, 0x4f4203                                                                     |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004cc14e mov esi, 0x1019                                                                       |         esi = 0x1019;
    0x004cc153 xor eax, eax                                                                          |         eax = 0;
    0x004cc155 call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc15a mov eax, dword [rip + 0x24c838]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc160 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc163 ja 0x4cc16d                                                                           |             goto label_24;
                                                                                                     |         }
    0x004cc165 inc eax                                                                               |         eax++;
    0x004cc167 mov dword [rip + 0x24c82b], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_24:
    0x004cc16d mov rdi, rbp                                                                          |     
    0x004cc170 call 0x401790                                                                         |     rax = strlen (rbp);
    0x004cc175 cmp rax, 0x14                                                                         |     
                                                                                                     |     if (rax >= 0x14) {
    0x004cc179 jb 0x4cc1a4                                                                           |         
    0x004cc17b mov edi, 0x4f4c78                                                                     |         
    0x004cc180 mov edx, 0x4f5c9c                                                                     |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004cc185 mov esi, 0x101c                                                                       |         esi = 0x101c;
    0x004cc18a xor eax, eax                                                                          |         eax = 0;
    0x004cc18c call 0x401680                                                                         |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc191 mov eax, dword [rip + 0x24c801]                                                       |         eax = (anonymous namespace)::testStatus;
    0x004cc197 cmp eax, 0x64                                                                         |         
                                                                                                     |         if (eax > 0x64) {
    0x004cc19a ja 0x4cc1a4                                                                           |             goto label_25;
                                                                                                     |         }
    0x004cc19c inc eax                                                                               |         eax++;
    0x004cc19e mov dword [rip + 0x24c7f4], eax                                                       |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                     |     }
                                                                                                     | label_25:
    0x004cc1a4 mov qword [rsp + 0x18], r12                                                           |     *((rsp + 0x18)) = r12;
    0x004cc1a9 pxor xmm0, xmm0                                                                       |     xmm0 = 0;
    0x004cc1ad movdqa xmmword [rsp + 0x20], xmm0                                                     |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004cc1b3 mov dword [rsp + 0x30], 0                                                             |     *((rsp + 0x30)) = 0;
    0x004cc1bb mov al, byte [rbp]                                                                    |     al = *(rbp);
    0x004cc1be test al, al                                                                           |     
                                                                                                     |     if (al == 0) {
    0x004cc1c0 je 0x4cc1e0                                                                           |         goto label_26;
                                                                                                     |     }
    0x004cc1c2 xor ecx, ecx                                                                          |     ecx = 0;
    0x004cc1c4 nop word cs:[rax + rax]                                                               |     
    0x004cc1ce nop                                                                                   |     
                                                                                                     |     do {
    0x004cc1d0 mov byte [rsp + rcx + 0x20], al                                                       |         *((rsp + rcx + 0x20)) = al;
    0x004cc1d4 movzx eax, byte [rbp + rcx + 1]                                                       |         eax = *((rbp + rcx + 1));
    0x004cc1d9 inc rcx                                                                               |         rcx++;
    0x004cc1dc test al, al                                                                           |         
    0x004cc1de jne 0x4cc1d0                                                                          |         
                                                                                                     |     } while (al != 0);
                                                                                                     | label_26:
    0x004cc1e0 mov r14d, dword [rbx + rbx*4 + 0x4f3b00]                                              |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004cc1e8 movsxd r13, dword [rbx + rbx*4 + 0x4f3b10]                                            |     r13 = *((rbx + rbx*4 + 0x4f3b10));
    0x004cc1f0 movsxd r12, dword [rbx + rbx*4 + 0x4f3b14]                                            |     r12 = *((rbx + rbx*4 + 0x4f3b14));
    0x004cc1f8 movsxd r15, dword [rbx + rbx*4 + 0x4f3b18]                                            |     r15 = *((rbx + rbx*4 + 0x4f3b18));
    0x004cc200 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                               |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004cc208 cmp byte [rip + 0x24c781], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc20f je 0x4cc230                                                                           |         
    0x004cc211 mov qword [rsp], rbx                                                                  |         *(rsp) = rbx;
    0x004cc215 mov edi, 0x4f5ab7                                                                     |         
    0x004cc21a mov esi, r14d                                                                         |         esi = r14d;
    0x004cc21d mov rdx, rbp                                                                          |         rdx = rbp;
    0x004cc220 mov ecx, r13d                                                                         |         ecx = r13d;
    0x004cc223 mov r8d, r12d                                                                         |         r8d = r12d;
    0x004cc226 mov r9d, r15d                                                                         |         r9d = r15d;
    0x004cc229 xor eax, eax                                                                          |         eax = 0;
    0x004cc22b call 0x401680                                                                         |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                     |     }
    0x004cc230 mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc235 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cc238 call 0x4e3780                                                                         |     intconstvolatile*&gg<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc23d mov edi, 0x74f9e0                                                                     |     edi = testCopyConstructWithIterators<int const volatile*>(bool, bool, bool)::u;
    0x004cc242 mov rsi, rbp                                                                          |     rsi = rbp;
    0x004cc245 call 0x4e3860                                                                         |     voidverify<intconstvolatile*>(intconstvolatile**,char const*) ();
    0x004cc24a mov eax, dword [rip + 0x24c754]                                                       |     eax = numCopyCtorCalls;
    0x004cc250 mov dword [rsp + 0x14], eax                                                           |     *((rsp + 0x14)) = eax;
    0x004cc254 mov eax, dword [rip + 0x24c752]                                                       |     eax = numCharCtorCalls;
    0x004cc25a mov dword [rsp + 0x48], eax                                                           |     *((rsp + 0x48)) = eax;
    0x004cc25e cmp byte [rsp + 0x54], 0                                                              |     
                                                                                                     |     if (*((rsp + 0x54)) == 0) {
    0x004cc263 je 0x4cc330                                                                           |         goto label_27;
                                                                                                     |     }
    0x004cc269 cmp byte [rip + 0x24c720], 0                                                          |     
    0x004cc270 mov ebp, r14d                                                                         |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc273 je 0x4cc288                                                                           |         
    0x004cc275 cmp dword [rip + 0x24c338], 0                                                         |         
                                                                                                     |         if (*(0x007185b4) == 0) {
    0x004cc27c je 0x4cc288                                                                           |             goto label_28;
                                                                                                     |         }
    0x004cc27e mov edi, 0x4f425a                                                                     |         
    0x004cc283 call 0x401710                                                                         |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                     |     }
                                                                                                     | label_28:
    0x004cc288 mov dword [rip + 0x24c322], 0                                                         |     *(0x007185b4) = 0;
    0x004cc292 cmp byte [rip + 0x24c6fc], 0                                                          |     
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cc299 je 0x4cc2a5                                                                           |         
    0x004cc29b mov edi, 0x4f4281                                                                     |         
    0x004cc2a0 call 0x401710                                                                         |         puts ("\t\tBegin bslma exception test.");
                                                                                                     |     }
    0x004cc2a5 mov rax, qword [rip + 0x24c574]                                                       |     rax = Z;
    0x004cc2ac mov qword [rsp + 0x58], 0x4f6858                                                      |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004cc2b5 mov qword [rsp + 0x60], rax                                                           |     *((rsp + 0x60)) = rax;
    0x004cc2ba mov qword [rax + 0x20], 0                                                             |     *((rax + 0x20)) = 0;
    0x004cc2c2 test rax, rax                                                                         |     
    0x004cc2c5 je 0x4cc3bd                                                                           |     
                                                                                                     |     while (rax != 0) {
                                                                                                     | label_3:
    0x004cc2cb cmp qword [rsp + 0x18], 6                                                             |         
                                                                                                     |         if (*((rsp + 0x18)) < 6) {
    0x004cc2d1 jb 0x4cc6a1                                                                           |             goto label_29;
                                                                                                     |         }
    0x004cc2d7 lea rcx, [rsp + r13 + 0x20]                                                           |         rcx = rsp + r13 + 0x20;
    0x004cc2dc lea rsi, [r15*8 + 0x74f9e0]                                                           |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cc2e4 lea eax, [r13 + r12]                                                                  |         eax = r13 + r12;
    0x004cc2e9 movsxd r9, eax                                                                        |         r9 = (int64_t) eax;
    0x004cc2ec mov r10, r9                                                                           |         r10 = r9;
    0x004cc2ef sub r10, r13                                                                          |         r10 -= r13;
    0x004cc2f2 cmp r10, 4                                                                            |         
                                                                                                     |         if (r10 < 4) {
    0x004cc2f6 jb 0x4cc686                                                                           |             goto label_30;
                                                                                                     |         }
    0x004cc2fc mov r11, rbx                                                                          |         r11 = rbx;
    0x004cc2ff mov r8, r10                                                                           |         r8 = r10;
    0x004cc302 and r8, 0xfffffffffffffffc                                                            |         r8 &= 0xfffffffffffffffc;
    0x004cc306 lea rax, [r8 - 4]                                                                     |         rax = r8 - 4;
    0x004cc30a mov rbp, rax                                                                          |         
    0x004cc30d shr rbp, 2                                                                            |         rbp >>= 2;
    0x004cc311 inc rbp                                                                               |         rbp++;
    0x004cc314 mov edi, ebp                                                                          |         edi = ebp;
    0x004cc316 and edi, 3                                                                            |         edi &= 3;
    0x004cc319 cmp rax, 0xc                                                                          |         
                                                                                                     |         if (rax >= 0xc) {
    0x004cc31d jae 0x4cc576                                                                          |             goto label_31;
                                                                                                     |         }
    0x004cc323 xor ebx, ebx                                                                          |         ebx = 0;
    0x004cc325 jmp 0x4cc625                                                                          |         goto label_32;
                                                                                                     | label_27:
    0x004cc330 cmp qword [rip + 0x24c4e8], 0                                                         |         
    0x004cc338 mov ebp, r14d                                                                         |         
    0x004cc33b mov r11, r12                                                                          |         r11 = r12;
                                                                                                     |         if (*(obj.Z) == 0) {
    0x004cc33e jne 0x4cc360                                                                          |             
    0x004cc340 mov rax, qword [rip + 0x284f71]                                                       |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cc347 test rax, rax                                                                         |             
                                                                                                     |             if (rax != 0) {
    0x004cc34a jne 0x4cc360                                                                          |                 goto label_33;
                                                                                                     |             }
    0x004cc34c call 0x4eec50                                                                         |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cc351 mov r11, r12                                                                          |             r11 = r12;
    0x004cc354 nop word cs:[rax + rax]                                                               |             
    0x004cc35e nop                                                                                   |             
                                                                                                     |         }
                                                                                                     | label_33:
    0x004cc360 mov r12, qword [rsp + 0x18]                                                           |         r12 = *((rsp + 0x18));
    0x004cc365 cmp r12, 6                                                                            |         
                                                                                                     |         if (r12 < 6) {
    0x004cc369 jb 0x4cc6e0                                                                           |             goto label_34;
                                                                                                     |         }
    0x004cc36f lea rax, [r15*8 + 0x74f9e0]                                                           |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u;
    0x004cc377 lea rcx, [rsp + r13 + 0x20]                                                           |         rcx = rsp + r13 + 0x20;
    0x004cc37c add r11, r13                                                                          |         r11 += r13;
    0x004cc37f mov r9, r11                                                                           |         r9 = r11;
    0x004cc382 sub r9, r13                                                                           |         r9 -= r13;
    0x004cc385 cmp r9, 4                                                                             |         
                                                                                                     |         if (r9 < 4) {
    0x004cc389 jb 0x4cc54a                                                                           |             goto label_35;
                                                                                                     |         }
    0x004cc38f mov r10, rbx                                                                          |         r10 = rbx;
    0x004cc392 mov r8, r9                                                                            |         r8 = r9;
    0x004cc395 and r8, 0xfffffffffffffffc                                                            |         r8 &= 0xfffffffffffffffc;
    0x004cc399 lea rsi, [r8 - 4]                                                                     |         rsi = r8 - 4;
    0x004cc39d mov rdi, rsi                                                                          |         rdi = rsi;
    0x004cc3a0 shr rdi, 2                                                                            |         rdi >>= 2;
    0x004cc3a4 inc rdi                                                                               |         rdi++;
    0x004cc3a7 mov ebp, edi                                                                          |         
    0x004cc3a9 and ebp, 3                                                                            |         ebp &= 3;
    0x004cc3ac cmp rsi, 0xc                                                                          |         
                                                                                                     |         if (rsi >= 0xc) {
    0x004cc3b0 jae 0x4cc43d                                                                          |             goto label_36;
                                                                                                     |         }
    0x004cc3b6 xor ebx, ebx                                                                          |         ebx = 0;
    0x004cc3b8 jmp 0x4cc4e5                                                                          |         goto label_37;
    0x004cc3bd mov eax, 1                                                                            |         eax = 1;
    0x004cc3c2 mov qword [rsp + 0x40], rax                                                           |         *((rsp + 0x40)) = rax;
    0x004cc3c7 mov rax, qword [rip + 0x284eea]                                                       |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cc3ce test rax, rax                                                                         |         
    0x004cc3d1 jne 0x4cc2cb                                                                          |         
                                                                                                     |     }
    0x004cc3d7 call 0x4eec50                                                                         |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cc3dc jmp 0x4cc2cb                                                                          |     goto label_3;
                                                                                                     | label_36:
    0x004cc43d lea rdx, [rsp + 0x2e]                                                                 |     rdx = rsp + 0x2e;
    0x004cc442 lea rsi, [rdx + r13]                                                                  |     rsi = rdx + r13;
    0x004cc446 and rdi, 0xfffffffffffffffc                                                           |     rdi &= 0xfffffffffffffffc;
    0x004cc44a neg rdi                                                                               |     rdi = -rdi;
    0x004cc44d xor ebx, ebx                                                                          |     ebx = 0;
    0x004cc44f nop                                                                                   |     
                                                                                                     |     do {
    0x004cc450 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                                 |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cc457 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                                 |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cc45e lea rdx, [r15*8]                                                                      |         rdx = r15*8;
    0x004cc466 movdqu xmmword [rdx + rbx*8 + 0x74f9e0], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cc46f movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1");
    0x004cc478 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                                 |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cc47f pmovsxbq xmm1, word [rsi + rbx - 8]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cc486 movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0");
    0x004cc48f movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1");
    0x004cc498 pmovsxbq xmm0, word [rsi + rbx - 6]                                                   |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cc49f pmovsxbq xmm1, word [rsi + rbx - 4]                                                   |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cc4a6 movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0");
    0x004cc4af movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1");
    0x004cc4b8 pmovsxbq xmm0, word [rsi + rbx - 2]                                                   |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cc4bf pmovsxbq xmm1, word [rsi + rbx]                                                       |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cc4c5 movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0");
    0x004cc4ce movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1");
    0x004cc4d7 add rbx, 0x10                                                                         |         rbx += 0x10;
    0x004cc4db add rdi, 4                                                                            |         rdi += 4;
    0x004cc4df jne 0x4cc450                                                                          |         
                                                                                                     |     } while (rdi != 0);
                                                                                                     | label_37:
    0x004cc4e5 test rbp, rbp                                                                         |     
                                                                                                     |     if (rbp == 0) {
    0x004cc4e8 je 0x4cc534                                                                           |         goto label_38;
                                                                                                     |     }
    0x004cc4ea add r13, rbx                                                                          |     r13 += rbx;
    0x004cc4ed lea rdx, [rsp + 0x22]                                                                 |     rdx = rsp + 0x22;
    0x004cc4f2 add r13, rdx                                                                          |     r13 += rdx;
    0x004cc4f5 shl r15, 3                                                                            |     r15 <<= 3;
    0x004cc4f9 lea rsi, [r15 + rbx*8 + 0x74f9f0]                                                     |     rsi = r15 + rbx*8 + 0x74f9f0;
    0x004cc501 shl rbp, 2                                                                            |     rbp <<= 2;
    0x004cc505 xor edi, edi                                                                          |     edi = 0;
    0x004cc507 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc510 pmovsxbq xmm0, word [r13 + rdi - 2]                                                   |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cc518 pmovsxbq xmm1, word [r13 + rdi]                                                       |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cc520 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                             |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cc526 movdqu xmmword [rsi + rdi*8], xmm1                                                    |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cc52b add rdi, 4                                                                            |         rdi += 4;
    0x004cc52f cmp rbp, rdi                                                                          |         
    0x004cc532 jne 0x4cc510                                                                          |         
                                                                                                     |     } while (rbp != rdi);
                                                                                                     | label_38:
    0x004cc534 cmp r9, r8                                                                            |     
    0x004cc537 mov rbx, r10                                                                          |     rbx = r10;
    0x004cc53a mov ebp, r14d                                                                         |     
                                                                                                     |     if (r9 == r8) {
    0x004cc53d je 0x4cc6e0                                                                           |         goto label_34;
                                                                                                     |     }
    0x004cc543 add rcx, r8                                                                           |     rcx += r8;
    0x004cc546 lea rax, [rax + r8*8]                                                                 |     rax = rax + r8*8;
                                                                                                     | label_35:
    0x004cc54a sub r11, rcx                                                                          |     r11 -= rcx;
    0x004cc54d lea rdx, [rsp + r11 + 0x20]                                                           |     rdx = rsp + r11 + 0x20;
    0x004cc552 xor esi, esi                                                                          |     esi = 0;
    0x004cc554 nop word cs:[rax + rax]                                                               |     
    0x004cc55e nop                                                                                   |     
                                                                                                     |     do {
    0x004cc560 movsx rdi, byte [rcx + rsi]                                                           |         rdi = *((rcx + rsi));
    0x004cc565 mov qword [rax + rsi*8], rdi                                                          |         *((rax + rsi*8)) = rdi;
    0x004cc569 inc rsi                                                                               |         rsi++;
    0x004cc56c cmp rdx, rsi                                                                          |         
    0x004cc56f jne 0x4cc560                                                                          |         
                                                                                                     |     } while (rdx != rsi);
    0x004cc571 jmp 0x4cc6e0                                                                          |     goto label_34;
                                                                                                     | label_31:
    0x004cc576 lea rax, [rsp + 0x2e]                                                                 |     rax = rsp + 0x2e;
    0x004cc57b add rax, r13                                                                          |     rax += r13;
    0x004cc57e and rbp, 0xfffffffffffffffc                                                           |     rbp &= 0xfffffffffffffffc;
    0x004cc582 neg rbp                                                                               |     rbp = -rbp;
    0x004cc585 xor ebx, ebx                                                                          |     ebx = 0;
    0x004cc587 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc590 pmovsxbq xmm0, word [rax + rbx - 0xe]                                                 |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cc597 pmovsxbq xmm1, word [rax + rbx - 0xc]                                                 |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cc59e lea rdx, [r15*8]                                                                      |         rdx = r15*8;
    0x004cc5a6 movdqu xmmword [rdx + rbx*8 + 0x74f9e0], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const_volatile__bool__bool__bool_::u], xmm0");
    0x004cc5af movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f9f0], xmm1");
    0x004cc5b8 pmovsxbq xmm0, word [rax + rbx - 0xa]                                                 |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cc5bf pmovsxbq xmm1, word [rax + rbx - 8]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cc5c6 movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa00], xmm0");
    0x004cc5cf movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa10], xmm1");
    0x004cc5d8 pmovsxbq xmm0, word [rax + rbx - 6]                                                   |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cc5df pmovsxbq xmm1, word [rax + rbx - 4]                                                   |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cc5e6 movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa20], xmm0");
    0x004cc5ef movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa30], xmm1");
    0x004cc5f8 pmovsxbq xmm0, word [rax + rbx - 2]                                                   |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cc5ff pmovsxbq xmm1, word [rax + rbx]                                                       |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cc605 movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa40], xmm0");
    0x004cc60e movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1                                         |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74fa50], xmm1");
    0x004cc617 add rbx, 0x10                                                                         |         rbx += 0x10;
    0x004cc61b add rbp, 4                                                                            |         rbp += 4;
    0x004cc61f jne 0x4cc590                                                                          |         
                                                                                                     |     } while (rbp != 0);
                                                                                                     | label_32:
    0x004cc625 test rdi, rdi                                                                         |     
                                                                                                     |     if (rdi == 0) {
    0x004cc628 je 0x4cc674                                                                           |         goto label_39;
                                                                                                     |     }
    0x004cc62a add r13, rbx                                                                          |     r13 += rbx;
    0x004cc62d lea rax, [rsp + 0x22]                                                                 |     rax = rsp + 0x22;
    0x004cc632 add r13, rax                                                                          |     r13 += rax;
    0x004cc635 shl r15, 3                                                                            |     r15 <<= 3;
    0x004cc639 lea rax, [r15 + rbx*8 + 0x74f9f0]                                                     |     rax = r15 + rbx*8 + 0x74f9f0;
    0x004cc641 shl rdi, 2                                                                            |     rdi <<= 2;
    0x004cc645 xor ebp, ebp                                                                          |     ebp = 0;
    0x004cc647 nop word [rax + rax]                                                                  |     
                                                                                                     |     do {
    0x004cc650 pmovsxbq xmm0, word [r13 + rbp - 2]                                                   |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004cc658 pmovsxbq xmm1, word [r13 + rbp]                                                       |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004cc660 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                             |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004cc666 movdqu xmmword [rax + rbp*8], xmm1                                                    |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004cc66b add rbp, 4                                                                            |         rbp += 4;
    0x004cc66f cmp rdi, rbp                                                                          |         
    0x004cc672 jne 0x4cc650                                                                          |         
                                                                                                     |     } while (rdi != rbp);
                                                                                                     | label_39:
    0x004cc674 cmp r10, r8                                                                           |     
    0x004cc677 mov rbx, r11                                                                          |     rbx = r11;
    0x004cc67a mov ebp, r14d                                                                         |     
                                                                                                     |     if (r10 == r8) {
    0x004cc67d je 0x4cc6a1                                                                           |         goto label_29;
                                                                                                     |     }
    0x004cc67f add rcx, r8                                                                           |     rcx += r8;
    0x004cc682 lea rsi, [rsi + r8*8]                                                                 |     rsi = rsi + r8*8;
                                                                                                     | label_30:
    0x004cc686 sub r9, rcx                                                                           |     r9 -= rcx;
    0x004cc689 lea rax, [rsp + r9 + 0x20]                                                            |     rax = rsp + r9 + 0x20;
    0x004cc68e xor edi, edi                                                                          |     edi = 0;
                                                                                                     |     do {
    0x004cc690 movsx rdx, byte [rcx + rdi]                                                           |         rdx = *((rcx + rdi));
    0x004cc695 mov qword [rsi + rdi*8], rdx                                                          |         *((rsi + rdi*8)) = rdx;
    0x004cc699 inc rdi                                                                               |         rdi++;
    0x004cc69c cmp rax, rdi                                                                          |         
    0x004cc69f jne 0x4cc690                                                                          |         
                                                                                                     |     } while (rax != rdi);
                                                                                                     | label_29:
    0x004cc6a1 mov rax, qword [rsp + 0x58]                                                           |     rax = *((rsp + 0x58));
    0x004cc6a6 lea rdi, [rsp + 0x58]                                                                 |     rdi = rsp + 0x58;
    0x004cc6ab mov rsi, 0xffffffffffffffff                                                           |     rsi = 0xffffffffffffffff;
    0x004cc6b2 call qword [rax + 0x10]                                                               |     uint64_t (*rax + 0x10)() ();
    0x004cc6b5 cmp byte [rip + 0x24c2d9], 0                                                          |     
    0x004cc6bc mov r12, qword [rsp + 0x18]                                                           |     r12 = *((rsp + 0x18));
                                                                                                     |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cc6c1 je 0x4cc6cd                                                                           |         
    0x004cc6c3 mov edi, 0x4f43e1                                                                     |         
    0x004cc6c8 call 0x401710                                                                         |         puts ("\t\tEnd bslma exception test.");
                                                                                                     |     }
    0x004cc6cd cmp byte [rip + 0x24c2bc], 0                                                          |     
                                                                                                     |     if (*(obj.veryVerbose) != 0) {
    0x004cc6d4 je 0x4cc70b                                                                           |         
    0x004cc6d6 mov edi, 0xa                                                                          |         
    0x004cc6db call 0x401720                                                                         |         eax = putchar (0xa);
                                                                                                     | label_34:
    0x004cc6e0 cmp byte [rip + 0x24c2a9], 0                                                          |         
                                                                                                     |         if (*(obj.veryVerbose) == 0) {
    0x004cc6e7 je 0x4cc70b                                                                           |             goto label_40;
                                                                                                     |         }
    0x004cc6e9 mov edx, dword [rip + 0x24c2b5]                                                       |         edx = numCopyCtorCalls;
    0x004cc6ef sub edx, dword [rsp + 0x14]                                                           |         edx -= *((rsp + 0x14));
    0x004cc6f3 mov ecx, dword [rip + 0x24c2b3]                                                       |         ecx = numCharCtorCalls;
    0x004cc6f9 sub ecx, dword [rsp + 0x48]                                                           |         ecx -= *((rsp + 0x48));
    0x004cc6fd mov edi, 0x4f5c2a                                                                     |         
    0x004cc702 mov esi, ebp                                                                          |         esi = ebp;
    0x004cc704 xor eax, eax                                                                          |         eax = 0;
    0x004cc706 call 0x401680                                                                         |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                     |     }
                                                                                                     | label_40:
    0x004cc70b mov eax, dword [rsp + 0x14]                                                           |     eax = *((rsp + 0x14));
    0x004cc70f cmp eax, dword [rip + 0x24c28f]                                                       |     
                                                                                                     |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cc715 je 0x4cc100                                                                           |         goto label_4;
                                                                                                     |     }
    0x004cc71b mov edi, 0x4f4c78                                                                     |     
    0x004cc720 mov edx, 0x4f4fec                                                                     |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cc725 mov esi, 0x103f                                                                       |     esi = 0x103f;
    0x004cc72a xor eax, eax                                                                          |     eax = 0;
    0x004cc72c call 0x401680                                                                         |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cc731 mov eax, dword [rip + 0x24c261]                                                       |     eax = (anonymous namespace)::testStatus;
    0x004cc737 cmp eax, 0x64                                                                         |     
                                                                                                     |     if (eax > 0x64) {
    0x004cc73a ja 0x4cc100                                                                           |         goto label_4;
                                                                                                     |     }
    0x004cc740 inc eax                                                                               |     eax++;
    0x004cc742 mov dword [rip + 0x24c250], eax                                                       |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004cc748 jmp 0x4cc100                                                                          |     goto label_4;
                                                                                                     | label_23:
    0x004cc74d add rsp, 0x68                                                                         |     
    0x004cc751 pop rbx                                                                               |     
    0x004cc752 pop r12                                                                               |     
    0x004cc754 pop r13                                                                               |     
    0x004cc756 pop r14                                                                               |     
    0x004cc758 pop r15                                                                               |     
    0x004cc75a pop rbp                                                                               |     
    0x004cc75b ret                                                                                   |     return rax;
                                                                                                     | }