; assembly                                                                               | /* r2dec pseudo code output */
                                                                                             | /* bslalg_arrayprimitives.t/assume @ 0x4c8a00 */
                                                                                             | #include <stdint.h>
                                                                                             |  
    ; (fcn) sym.void_testCopyConstructWithIterators_void_const__bool__bool__bool_ ()         | uint64_t void_testCopyConstructWithIterators_void_const_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                             |     int64_t var_14h;
                                                                                             |     uint32_t var_18h;
                                                                                             |     int64_t var_20h;
                                                                                             |     int64_t var_22h;
                                                                                             |     int64_t var_28h;
                                                                                             |     int64_t var_2eh;
                                                                                             |     int64_t var_30h;
                                                                                             |     uint32_t var_40h;
                                                                                             |     int64_t var_48h;
                                                                                             |     uint32_t var_54h;
                                                                                             |     int64_t var_58h;
                                                                                             |     int64_t var_60h;
                                                                                             |     rdx = arg3;
                                                                                             |     rsi = arg2;
                                                                                             |     /* void testCopyConstructWithIterators<void const*>(bool, bool, bool) */
    0x004c8a00 push rbp                                                                      |     
    0x004c8a01 push r15                                                                      |     
    0x004c8a03 push r14                                                                      |     
    0x004c8a05 push r13                                                                      |     
    0x004c8a07 push r12                                                                      |     
    0x004c8a09 push rbx                                                                      |     
    0x004c8a0a sub rsp, 0x68                                                                 |     
    0x004c8a0e mov dword [rsp + 0x54], edx                                                   |     *((rsp + 0x54)) = edx;
    0x004c8a12 mov dword [rsp + 0x40], esi                                                   |     *((rsp + 0x40)) = esi;
    0x004c8a16 cmp byte [rip + 0x24ff79], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004c8a1d je 0x4c8a29                                                                   |         
    0x004c8a1f mov edi, 0x4f67e9                                                             |         
    0x004c8a24 call 0x401710                                                                 |         eax = puts ("\t\tfrom same type.");
                                                                                             |     }
    0x004c8a29 xor eax, eax                                                                  |     eax = 0;
    0x004c8a2b jmp 0x4c8a5c                                                                  |     goto label_5;
                                                                                             | label_2:
    0x004c8a30 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8a35 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c8a38 call 0x4e2460                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c8a3d mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8a42 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c8a45 call 0x4e26a0                                                                 |     voidcleanup<voidconst*>(voidconst**,char const*) ();
    0x004c8a4a mov rax, qword [rsp + 0x18]                                                   |     rax = *((rsp + 0x18));
    0x004c8a4f inc rax                                                                       |     rax++;
    0x004c8a52 cmp rax, 0x1e                                                                 |     
                                                                                             |     if (rax == 0x1e) {
    0x004c8a56 je 0x4c8f99                                                                   |         goto label_6;
                                                                                             |     }
                                                                                             | label_5:
    0x004c8a5c mov qword [rsp + 0x18], rax                                                   |     *((rsp + 0x18)) = rax;
    0x004c8a61 lea rbp, [rax*8]                                                              |     rbp = rax*8;
    0x004c8a69 mov r12, qword [rbp + rbp*4 + 0x4f3b08]                                       |     r12 = *((rbp + rbp*4 + 0x4f3b08));
    0x004c8a71 mov rdi, r12                                                                  |     
    0x004c8a74 call 0x401790                                                                 |     eax = strlen (*((rbp + rbp*4 + 0x4f3b08)));
    0x004c8a79 cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004c8a7c jl 0x4c8aa7                                                                   |         
    0x004c8a7e mov edi, 0x4f4c78                                                             |         
    0x004c8a83 mov edx, 0x4f4203                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c8a88 mov esi, 0xfe6                                                                |         esi = 0xfe6;
    0x004c8a8d xor eax, eax                                                                  |         eax = 0;
    0x004c8a8f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c8a94 mov eax, dword [rip + 0x24fefe]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c8a9a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c8a9d ja 0x4c8aa7                                                                   |             goto label_7;
                                                                                             |         }
    0x004c8a9f inc eax                                                                       |         eax++;
    0x004c8aa1 mov dword [rip + 0x24fef1], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_7:
    0x004c8aa7 mov r13d, dword [rbp + rbp*4 + 0x4f3b00]                                      |     r13d = *((rbp + rbp*4 + obj.DATA_3));
    0x004c8aaf movsxd r15, dword [rbp + rbp*4 + 0x4f3b10]                                    |     r15 = *((rbp + rbp*4 + 0x4f3b10));
    0x004c8ab7 mov ebx, dword [rbp + rbp*4 + 0x4f3b14]                                       |     ebx = *((rbp + rbp*4 + 0x4f3b14));
    0x004c8abe movsxd r14, dword [rbp + rbp*4 + 0x4f3b18]                                    |     r14 = *((rbp + rbp*4 + 0x4f3b18));
    0x004c8ac6 mov rbp, qword [rbp + rbp*4 + 0x4f3b20]                                       |     rbp = *((rbp + rbp*4 + 0x4f3b20));
    0x004c8ace cmp byte [rip + 0x24febb], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8ad5 je 0x4c8af6                                                                   |         
    0x004c8ad7 mov qword [rsp], rbp                                                          |         *(rsp) = rbp;
    0x004c8adb mov edi, 0x4f5ab7                                                             |         
    0x004c8ae0 mov esi, r13d                                                                 |         esi = r13d;
    0x004c8ae3 mov rdx, r12                                                                  |         rdx = r12;
    0x004c8ae6 mov ecx, r15d                                                                 |         ecx = r15d;
    0x004c8ae9 mov r8d, ebx                                                                  |         r8d = ebx;
    0x004c8aec mov r9d, r14d                                                                 |         r9d = r14d;
    0x004c8aef xor eax, eax                                                                  |         eax = 0;
    0x004c8af1 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004c8af6 mov qword [rsp + 0x48], rbx                                                   |     *((rsp + 0x48)) = rbx;
    0x004c8afb mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8b00 mov rsi, r12                                                                  |     rsi = r12;
    0x004c8b03 call 0x4e2380                                                                 |     voidconst*&gg<voidconst*>(voidconst**,char const*) ();
    0x004c8b08 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8b0d mov rsi, r12                                                                  |     rsi = r12;
    0x004c8b10 call 0x4e2460                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c8b15 mov r12d, dword [rip + 0x24fe88]                                              |     r12d = numCopyCtorCalls;
    0x004c8b1c mov eax, dword [rip + 0x24fe8a]                                               |     eax = numCharCtorCalls;
    0x004c8b22 mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004c8b26 cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004c8b2b je 0x4c8c10                                                                   |         goto label_8;
                                                                                             |     }
    0x004c8b31 cmp byte [rip + 0x24fe58], 0                                                  |     
    0x004c8b38 mov ebx, r13d                                                                 |     ebx = r13d;
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8b3b je 0x4c8b50                                                                   |         
    0x004c8b3d cmp dword [rip + 0x24fa4c], 0                                                 |         
                                                                                             |         if (*(0x00718590) == 0) {
    0x004c8b44 je 0x4c8b50                                                                   |             goto label_9;
                                                                                             |         }
    0x004c8b46 mov edi, 0x4f425a                                                             |         
    0x004c8b4b call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_9:
    0x004c8b50 mov dword [rip + 0x24fa36], 0                                                 |     *(0x00718590) = 0;
    0x004c8b5a cmp byte [rip + 0x24fe34], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c8b61 je 0x4c8b6d                                                                   |         
    0x004c8b63 mov edi, 0x4f4281                                                             |         
    0x004c8b68 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004c8b6d mov rax, qword [rip + 0x24fcac]                                               |     rax = Z;
    0x004c8b74 mov qword [rsp + 0x20], 0x4f6858                                              |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c8b7d mov qword [rsp + 0x28], rax                                                   |     *((rsp + 0x28)) = rax;
    0x004c8b82 mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004c8b8a test rax, rax                                                                 |     
    0x004c8b8d je 0x4c8c79                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_0:
    0x004c8b93 lea rsi, [r15*8 + 0x74f7e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8b9b mov rax, qword [rsp + 0x48]                                                   |         rax = *((rsp + 0x48));
    0x004c8ba0 add eax, r15d                                                                 |         eax += r15d;
    0x004c8ba3 cdqe                                                                          |         rax = (int64_t) eax;
    0x004c8ba5 lea rdx, [rax*8 + 0x74f7e0]                                                   |         rdx = rax*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8bad sub rdx, rsi                                                                  |         rdx -= rsi;
                                                                                             |         if (rdx != 0) {
    0x004c8bb0 je 0x4c8bbf                                                                   |             
    0x004c8bb2 lea rdi, [r14*8 + 0x74f7e0]                                                   |             
    0x004c8bba call 0x401930                                                                 |             memcpy (r14*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u, rsi, rdx);
                                                                                             |         }
    0x004c8bbf mov rax, qword [rsp + 0x20]                                                   |         rax = *((rsp + 0x20));
    0x004c8bc4 lea rdi, [rsp + 0x20]                                                         |         rdi = rsp + 0x20;
    0x004c8bc9 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004c8bd0 call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004c8bd3 cmp byte [rip + 0x24fdbb], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004c8bda je 0x4c8be6                                                                   |             
    0x004c8bdc mov edi, 0x4f43e1                                                             |             
    0x004c8be1 call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004c8be6 cmp byte [rip + 0x24fda3], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004c8bed je 0x4c8ebb                                                                   |             goto label_10;
                                                                                             |         }
    0x004c8bf3 mov edi, 0xa                                                                  |         
    0x004c8bf8 call 0x401720                                                                 |         putchar (0xa);
    0x004c8bfd jmp 0x4c8e91                                                                  |         goto label_11;
                                                                                             | label_8:
    0x004c8c10 cmp qword [rip + 0x24fc08], 0                                                 |         
    0x004c8c18 mov ebx, r13d                                                                 |         ebx = r13d;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004c8c1b jne 0x4c8c2d                                                                  |             
    0x004c8c1d mov rax, qword [rip + 0x288694]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c8c24 test rax, rax                                                                 |             
                                                                                             |             if (rax == 0) {
    0x004c8c27 je 0x4c8d33                                                                   |                 goto label_12;
                                                                                             |             }
                                                                                             |         }
    0x004c8c2d cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004c8c33 jb 0x4c8e91                                                                   |             goto label_11;
                                                                                             |         }
                                                                                             | label_1:
    0x004c8c39 lea rax, [r15*8 + 0x74f7e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8c41 lea rcx, [r14*8 + 0x74f7e0]                                                   |         rcx = r14*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8c49 mov rbx, qword [rsp + 0x48]                                                   |         rbx = *((rsp + 0x48));
    0x004c8c4e lea edx, [rbx + r15]                                                          |         edx = rbx + r15;
    0x004c8c52 movsxd r9, edx                                                                |         r9 = (int64_t) edx;
    0x004c8c55 shl r9, 3                                                                     |         r9 <<= 3;
    0x004c8c59 lea rdi, [r15*8]                                                              |         rdi = r15*8;
    0x004c8c61 mov r10, r9                                                                   |         r10 = r9;
    0x004c8c64 sub r10, rdi                                                                  |         r10 -= rdi;
    0x004c8c67 add r10, 0xfffffffffffffff8                                                   |         r10 += 0xfffffffffffffff8;
    0x004c8c6b cmp r10, 0x18                                                                 |         
                                                                                             |         if (r10 >= 0x18) {
    0x004c8c6f jae 0x4c8ced                                                                  |             goto label_13;
                                                                                             |         }
    0x004c8c71 mov ebx, r13d                                                                 |         ebx = r13d;
    0x004c8c74 jmp 0x4c8e70                                                                  |         goto label_14;
    0x004c8c79 mov r13d, 1                                                                   |         r13d = 1;
    0x004c8c7f mov rax, qword [rip + 0x288632]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c8c86 test rax, rax                                                                 |         
    0x004c8c89 jne 0x4c8b93                                                                  |         
                                                                                             |     }
    0x004c8c8f call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c8c94 jmp 0x4c8b93                                                                  |     goto label_0;
                                                                                             | label_13:
    0x004c8ced mov r11, rbp                                                                  |     r11 = rbp;
    0x004c8cf0 lea rsi, [r14*8 + 0x74f7e0]                                                   |     rsi = r14*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8cf8 lea edx, [rbx + r15]                                                          |     edx = rbx + r15;
    0x004c8cfc movsxd rdx, edx                                                               |     rdx = (int64_t) edx;
    0x004c8cff lea rbp, [rdx*8 + 0x74f7e0]                                                   |     rbp = rdx*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8d07 cmp rsi, rbp                                                                  |     
                                                                                             |     if (rsi >= rbp) {
    0x004c8d0a jae 0x4c8d49                                                                  |         goto label_15;
                                                                                             |     }
    0x004c8d0c shl rdx, 3                                                                    |     rdx <<= 3;
    0x004c8d10 sub rdx, rdi                                                                  |     rdx -= rdi;
    0x004c8d13 lea rdx, [rdx + r14*8 + 0x74f7e0]                                             |     rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8d1b lea rsi, [r15*8 + 0x74f7e0]                                                   |     rsi = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8d23 cmp rsi, rdx                                                                  |     
                                                                                             |     if (rsi >= rdx) {
    0x004c8d26 jae 0x4c8d49                                                                  |         goto label_15;
                                                                                             |     }
    0x004c8d28 mov rbp, r11                                                                  |     
    0x004c8d2b mov ebx, r13d                                                                 |     ebx = r13d;
    0x004c8d2e jmp 0x4c8e70                                                                  |     goto label_14;
                                                                                             | label_12:
    0x004c8d33 call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c8d38 cmp qword [rsp + 0x18], 6                                                     |     
                                                                                             |     if (*((rsp + 0x18)) >= 6) {
    0x004c8d3e jae 0x4c8c39                                                                  |         goto label_1;
                                                                                             |     }
    0x004c8d44 jmp 0x4c8e91                                                                  |     goto label_11;
                                                                                             | label_15:
    0x004c8d49 shr r10, 3                                                                    |     r10 >>= 3;
    0x004c8d4d inc r10                                                                       |     r10++;
    0x004c8d50 mov r8, r10                                                                   |     r8 = r10;
    0x004c8d53 and r8, 0xfffffffffffffffc                                                    |     r8 &= 0xfffffffffffffffc;
    0x004c8d57 lea rsi, [r8 - 4]                                                             |     rsi = r8 - 4;
    0x004c8d5b mov rbp, rsi                                                                  |     
    0x004c8d5e shr rbp, 2                                                                    |     rbp >>= 2;
    0x004c8d62 inc rbp                                                                       |     rbp++;
    0x004c8d65 mov edx, ebp                                                                  |     edx = ebp;
    0x004c8d67 and edx, 3                                                                    |     edx &= 3;
    0x004c8d6a cmp rsi, 0xc                                                                  |     
                                                                                             |     if (rsi < 0xc) {
    0x004c8d6e jae 0x4c8d77                                                                  |         
    0x004c8d70 xor ebx, ebx                                                                  |         ebx = 0;
    0x004c8d72 jmp 0x4c8e00                                                                  |         goto label_16;
                                                                                             |     }
    0x004c8d77 and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004c8d7b neg rbp                                                                       |     rbp = -rbp;
    0x004c8d7e mov esi, 0x74f7e0                                                             |     esi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8d83 xor ebx, ebx                                                                  |     ebx = 0;
    0x004c8d85 nop word cs:[rax + rax]                                                       |     
    0x004c8d8f nop                                                                           |     
                                                                                             |     do {
    0x004c8d90 movups xmm0, xmmword [rsi + r15*8]                                            |         __asm ("movups xmm0, xmmword [rsi + r15*8]");
    0x004c8d95 movups xmm1, xmmword [rsi + r15*8 + 0x10]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x10]");
    0x004c8d9b movups xmmword [rsi + r14*8], xmm0                                            |         __asm ("movups xmmword [rsi + r14*8], xmm0");
    0x004c8da0 movups xmmword [rsi + r14*8 + 0x10], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x10], xmm1");
    0x004c8da6 movups xmm0, xmmword [rsi + r15*8 + 0x20]                                     |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x20]");
    0x004c8dac movups xmm1, xmmword [rsi + r15*8 + 0x30]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x30]");
    0x004c8db2 movups xmmword [rsi + r14*8 + 0x20], xmm0                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x20], xmm0");
    0x004c8db8 movups xmmword [rsi + r14*8 + 0x30], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x30], xmm1");
    0x004c8dbe movups xmm0, xmmword [rsi + r15*8 + 0x40]                                     |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x40]");
    0x004c8dc4 movups xmm1, xmmword [rsi + r15*8 + 0x50]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x50]");
    0x004c8dca movups xmmword [rsi + r14*8 + 0x40], xmm0                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x40], xmm0");
    0x004c8dd0 movups xmmword [rsi + r14*8 + 0x50], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x50], xmm1");
    0x004c8dd6 movdqu xmm0, xmmword [rsi + r15*8 + 0x60]                                     |         __asm ("movdqu xmm0, xmmword [rsi + r15*8 + 0x60]");
    0x004c8ddd movdqu xmm1, xmmword [rsi + r15*8 + 0x70]                                     |         __asm ("movdqu xmm1, xmmword [rsi + r15*8 + 0x70]");
    0x004c8de4 movdqu xmmword [rsi + r14*8 + 0x60], xmm0                                     |         __asm ("movdqu xmmword [rsi + r14*8 + 0x60], xmm0");
    0x004c8deb movdqu xmmword [rsi + r14*8 + 0x70], xmm1                                     |         __asm ("movdqu xmmword [rsi + r14*8 + 0x70], xmm1");
    0x004c8df2 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004c8df6 sub rsi, 0xffffffffffffff80                                                   |         rsi -= 0xffffffffffffff80;
    0x004c8dfa add rbp, 4                                                                    |         rbp += 4;
    0x004c8dfe jne 0x4c8d90                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_16:
    0x004c8e00 test rdx, rdx                                                                 |     
                                                                                             |     if (rdx == 0) {
    0x004c8e03 je 0x4c8e53                                                                   |         goto label_17;
                                                                                             |     }
    0x004c8e05 shl r14, 3                                                                    |     r14 <<= 3;
    0x004c8e09 lea rsi, [rbx*8 + 0x74f7e0]                                                   |     rsi = rbx*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8e11 neg rdx                                                                       |     rdx = -rdx;
    0x004c8e14 nop word cs:[rax + rax]                                                       |     
    0x004c8e1e nop                                                                           |     
                                                                                             |     do {
    0x004c8e20 movdqu xmm0, xmmword [rdi + rbx*8 + 0x74f7e0]                                 |         __asm ("movdqu xmm0, xmmword [rdi + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u]");
    0x004c8e29 movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f7f0]                                 |         __asm ("movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f7f0]");
    0x004c8e32 movdqu xmmword [r14 + rbx*8 + 0x74f7e0], xmm0                                 |         __asm ("movdqu xmmword [r14 + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c8e3c movdqu xmmword [r14 + rbx*8 + 0x74f7f0], xmm1                                 |         __asm ("movdqu xmmword [r14 + rbx*8 + 0x74f7f0], xmm1");
    0x004c8e46 add rbx, 4                                                                    |         rbx += 4;
    0x004c8e4a add rsi, 0x20                                                                 |         rsi += 0x20;
    0x004c8e4e inc rdx                                                                       |         rdx++;
    0x004c8e51 jne 0x4c8e20                                                                  |         
                                                                                             |     } while (rdx != 0);
                                                                                             | label_17:
    0x004c8e53 cmp r10, r8                                                                   |     
    0x004c8e56 mov rbp, r11                                                                  |     
    0x004c8e59 mov ebx, r13d                                                                 |     ebx = r13d;
                                                                                             |     if (r10 == r8) {
    0x004c8e5c je 0x4c8e91                                                                   |         goto label_11;
                                                                                             |     }
    0x004c8e5e lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
    0x004c8e62 lea rcx, [rcx + r8*8]                                                         |     rcx = rcx + r8*8;
    0x004c8e66 nop word cs:[rax + rax]                                                       |     
                                                                                             | label_14:
    0x004c8e70 sub r9, rax                                                                   |     r9 -= rax;
    0x004c8e73 lea rdx, [r9 + 0x74f7e0]                                                      |     rdx = r9 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c8e7a xor esi, esi                                                                  |     esi = 0;
    0x004c8e7c nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004c8e80 mov rdi, qword [rax + rsi]                                                    |         rdi = *((rax + rsi));
    0x004c8e84 mov qword [rcx + rsi], rdi                                                    |         *((rcx + rsi)) = rdi;
    0x004c8e88 add rsi, 8                                                                    |         rsi += 8;
    0x004c8e8c cmp rdx, rsi                                                                  |         
    0x004c8e8f jne 0x4c8e80                                                                  |         
                                                                                             |     } while (rdx != rsi);
                                                                                             | label_11:
    0x004c8e91 cmp byte [rip + 0x24faf8], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c8e98 je 0x4c8ebb                                                                   |         
    0x004c8e9a mov edx, dword [rip + 0x24fb04]                                               |         edx = numCopyCtorCalls;
    0x004c8ea0 sub edx, r12d                                                                 |         edx -= r12d;
    0x004c8ea3 mov ecx, dword [rip + 0x24fb03]                                               |         ecx = numCharCtorCalls;
    0x004c8ea9 sub ecx, dword [rsp + 0x14]                                                   |         ecx -= *((rsp + 0x14));
    0x004c8ead mov edi, 0x4f5c2a                                                             |         
    0x004c8eb2 mov esi, ebx                                                                  |         esi = ebx;
    0x004c8eb4 xor eax, eax                                                                  |         eax = 0;
    0x004c8eb6 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_10:
    0x004c8ebb cmp byte [rsp + 0x40], 0                                                      |     
                                                                                             |     if (*((rsp + 0x40)) == 0) {
    0x004c8ec0 je 0x4c8f20                                                                   |         goto label_18;
                                                                                             |     }
    0x004c8ec2 cmp r12d, dword [rip + 0x24fadb]                                              |     
                                                                                             |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004c8ec9 je 0x4c8ef4                                                                   |         
    0x004c8ecb mov edi, 0x4f4c78                                                             |         
    0x004c8ed0 mov edx, 0x4f4fec                                                             |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c8ed5 mov esi, 0x1005                                                               |         esi = 0x1005;
    0x004c8eda xor eax, eax                                                                  |         eax = 0;
    0x004c8edc call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c8ee1 mov eax, dword [rip + 0x24fab1]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c8ee7 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c8eea ja 0x4c8ef4                                                                   |             goto label_19;
                                                                                             |         }
    0x004c8eec inc eax                                                                       |         eax++;
    0x004c8eee mov dword [rip + 0x24faa4], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_19:
    0x004c8ef4 mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004c8ef8 cmp eax, dword [rip + 0x24faae]                                               |     
                                                                                             |     if (eax == *(obj.numCharCtorCalls)) {
    0x004c8efe je 0x4c8a30                                                                   |         goto label_2;
                                                                                             |     }
    0x004c8f04 mov edi, 0x4f4c78                                                             |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004c8f09 mov edx, 0x4f5c5a                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c8f0e mov esi, 0x1006                                                               |     esi = 0x1006;
    0x004c8f13 jmp 0x4c8f76                                                                  |     goto label_20;
                                                                                             | label_18:
    0x004c8f20 add r12d, dword [rsp + 0x48]                                                  |     r12d += *((rsp + 0x48));
    0x004c8f25 cmp r12d, dword [rip + 0x24fa78]                                              |     
                                                                                             |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004c8f2c jle 0x4c8f57                                                                  |         
    0x004c8f2e mov edi, 0x4f4c78                                                             |         
    0x004c8f33 mov edx, 0x4f5c78                                                             |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004c8f38 mov esi, 0x1009                                                               |         esi = 0x1009;
    0x004c8f3d xor eax, eax                                                                  |         eax = 0;
    0x004c8f3f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c8f44 mov eax, dword [rip + 0x24fa4e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c8f4a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c8f4d ja 0x4c8f57                                                                   |             goto label_21;
                                                                                             |         }
    0x004c8f4f inc eax                                                                       |         eax++;
    0x004c8f51 mov dword [rip + 0x24fa41], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_21:
    0x004c8f57 mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004c8f5b cmp eax, dword [rip + 0x24fa4b]                                               |     
                                                                                             |     if (eax == *(obj.numCharCtorCalls)) {
    0x004c8f61 je 0x4c8a30                                                                   |         goto label_2;
                                                                                             |     }
    0x004c8f67 mov edi, 0x4f4c78                                                             |     
    0x004c8f6c mov edx, 0x4f5c5a                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c8f71 mov esi, 0x100a                                                               |     esi = 0x100a;
                                                                                             | label_20:
    0x004c8f76 xor eax, eax                                                                  |     eax = 0;
    0x004c8f78 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c8f7d mov eax, dword [rip + 0x24fa15]                                               |     eax = (anonymous namespace)::testStatus;
    0x004c8f83 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004c8f86 ja 0x4c8a30                                                                   |         goto label_2;
                                                                                             |     }
    0x004c8f8c inc eax                                                                       |     eax++;
    0x004c8f8e mov dword [rip + 0x24fa04], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c8f94 jmp 0x4c8a30                                                                  |     goto label_2;
                                                                                             | label_6:
    0x004c8f99 cmp byte [rip + 0x24f9f6], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004c8fa0 je 0x4c8fac                                                                   |         
    0x004c8fa2 mov edi, 0x4f67d2                                                             |         
    0x004c8fa7 call 0x401710                                                                 |         puts ("\t\tfrom different type.");
                                                                                             |     }
    0x004c8fac xor r12d, r12d                                                                |     r12d = 0;
    0x004c8faf jmp 0x4c8fe7                                                                  |     goto label_22;
                                                                                             | label_4:
    0x004c8fc0 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8fc5 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004c8fc8 call 0x4e2460                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c8fcd mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c8fd2 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004c8fd5 call 0x4e26a0                                                                 |     voidcleanup<voidconst*>(voidconst**,char const*) ();
    0x004c8fda inc r12                                                                       |     r12++;
    0x004c8fdd cmp r12, 0x1e                                                                 |     
                                                                                             |     if (r12 == 0x1e) {
    0x004c8fe1 je 0x4c960d                                                                   |         goto label_23;
                                                                                             |     }
                                                                                             | label_22:
    0x004c8fe7 lea rbx, [r12*8]                                                              |     rbx = r12*8;
    0x004c8fef mov rbp, qword [rbx + rbx*4 + 0x4f3b08]                                       |     rbp = *((rbx + rbx*4 + 0x4f3b08));
    0x004c8ff7 mov rdi, rbp                                                                  |     
    0x004c8ffa call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004c8fff cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004c9002 jl 0x4c902d                                                                   |         
    0x004c9004 mov edi, 0x4f4c78                                                             |         
    0x004c9009 mov edx, 0x4f4203                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c900e mov esi, 0x1019                                                               |         esi = 0x1019;
    0x004c9013 xor eax, eax                                                                  |         eax = 0;
    0x004c9015 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c901a mov eax, dword [rip + 0x24f978]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c9020 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c9023 ja 0x4c902d                                                                   |             goto label_24;
                                                                                             |         }
    0x004c9025 inc eax                                                                       |         eax++;
    0x004c9027 mov dword [rip + 0x24f96b], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_24:
    0x004c902d mov rdi, rbp                                                                  |     
    0x004c9030 call 0x401790                                                                 |     rax = strlen (rbp);
    0x004c9035 cmp rax, 0x14                                                                 |     
                                                                                             |     if (rax >= 0x14) {
    0x004c9039 jb 0x4c9064                                                                   |         
    0x004c903b mov edi, 0x4f4c78                                                             |         
    0x004c9040 mov edx, 0x4f5c9c                                                             |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004c9045 mov esi, 0x101c                                                               |         esi = 0x101c;
    0x004c904a xor eax, eax                                                                  |         eax = 0;
    0x004c904c call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c9051 mov eax, dword [rip + 0x24f941]                                               |         eax = (anonymous namespace)::testStatus;
    0x004c9057 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004c905a ja 0x4c9064                                                                   |             goto label_25;
                                                                                             |         }
    0x004c905c inc eax                                                                       |         eax++;
    0x004c905e mov dword [rip + 0x24f934], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_25:
    0x004c9064 mov qword [rsp + 0x18], r12                                                   |     *((rsp + 0x18)) = r12;
    0x004c9069 pxor xmm0, xmm0                                                               |     xmm0 = 0;
    0x004c906d movdqa xmmword [rsp + 0x20], xmm0                                             |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004c9073 mov dword [rsp + 0x30], 0                                                     |     *((rsp + 0x30)) = 0;
    0x004c907b mov al, byte [rbp]                                                            |     al = *(rbp);
    0x004c907e test al, al                                                                   |     
                                                                                             |     if (al == 0) {
    0x004c9080 je 0x4c90a0                                                                   |         goto label_26;
                                                                                             |     }
    0x004c9082 xor ecx, ecx                                                                  |     ecx = 0;
    0x004c9084 nop word cs:[rax + rax]                                                       |     
    0x004c908e nop                                                                           |     
                                                                                             |     do {
    0x004c9090 mov byte [rsp + rcx + 0x20], al                                               |         *((rsp + rcx + 0x20)) = al;
    0x004c9094 movzx eax, byte [rbp + rcx + 1]                                               |         eax = *((rbp + rcx + 1));
    0x004c9099 inc rcx                                                                       |         rcx++;
    0x004c909c test al, al                                                                   |         
    0x004c909e jne 0x4c9090                                                                  |         
                                                                                             |     } while (al != 0);
                                                                                             | label_26:
    0x004c90a0 mov r14d, dword [rbx + rbx*4 + 0x4f3b00]                                      |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004c90a8 movsxd r13, dword [rbx + rbx*4 + 0x4f3b10]                                    |     r13 = *((rbx + rbx*4 + 0x4f3b10));
    0x004c90b0 movsxd r12, dword [rbx + rbx*4 + 0x4f3b14]                                    |     r12 = *((rbx + rbx*4 + 0x4f3b14));
    0x004c90b8 movsxd r15, dword [rbx + rbx*4 + 0x4f3b18]                                    |     r15 = *((rbx + rbx*4 + 0x4f3b18));
    0x004c90c0 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                       |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004c90c8 cmp byte [rip + 0x24f8c1], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c90cf je 0x4c90f0                                                                   |         
    0x004c90d1 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004c90d5 mov edi, 0x4f5ab7                                                             |         
    0x004c90da mov esi, r14d                                                                 |         esi = r14d;
    0x004c90dd mov rdx, rbp                                                                  |         rdx = rbp;
    0x004c90e0 mov ecx, r13d                                                                 |         ecx = r13d;
    0x004c90e3 mov r8d, r12d                                                                 |         r8d = r12d;
    0x004c90e6 mov r9d, r15d                                                                 |         r9d = r15d;
    0x004c90e9 xor eax, eax                                                                  |         eax = 0;
    0x004c90eb call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004c90f0 mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c90f5 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c90f8 call 0x4e2380                                                                 |     voidconst*&gg<voidconst*>(voidconst**,char const*) ();
    0x004c90fd mov edi, 0x74f7e0                                                             |     edi = testCopyConstructWithIterators<void const*>(bool, bool, bool)::u;
    0x004c9102 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004c9105 call 0x4e2460                                                                 |     voidverify<voidconst*>(voidconst**,char const*) ();
    0x004c910a mov eax, dword [rip + 0x24f894]                                               |     eax = numCopyCtorCalls;
    0x004c9110 mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004c9114 mov eax, dword [rip + 0x24f892]                                               |     eax = numCharCtorCalls;
    0x004c911a mov dword [rsp + 0x48], eax                                                   |     *((rsp + 0x48)) = eax;
    0x004c911e cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004c9123 je 0x4c91f0                                                                   |         goto label_27;
                                                                                             |     }
    0x004c9129 cmp byte [rip + 0x24f860], 0                                                  |     
    0x004c9130 mov ebp, r14d                                                                 |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c9133 je 0x4c9148                                                                   |         
    0x004c9135 cmp dword [rip + 0x24f458], 0                                                 |         
                                                                                             |         if (*(obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::firstTime) == 0) {
    0x004c913c je 0x4c9148                                                                   |             goto label_28;
                                                                                             |         }
    0x004c913e mov edi, 0x4f425a                                                             |         
    0x004c9143 call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_28:
    0x004c9148 mov dword [rip + 0x24f442], 0                                                 |     *(obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::firstTime) = 0;
    0x004c9152 cmp byte [rip + 0x24f83c], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c9159 je 0x4c9165                                                                   |         
    0x004c915b mov edi, 0x4f4281                                                             |         
    0x004c9160 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004c9165 mov rax, qword [rip + 0x24f6b4]                                               |     rax = Z;
    0x004c916c mov qword [rsp + 0x58], 0x4f6858                                              |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c9175 mov qword [rsp + 0x60], rax                                                   |     *((rsp + 0x60)) = rax;
    0x004c917a mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004c9182 test rax, rax                                                                 |     
    0x004c9185 je 0x4c927d                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_3:
    0x004c918b cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004c9191 jb 0x4c9561                                                                   |             goto label_29;
                                                                                             |         }
    0x004c9197 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004c919c lea rsi, [r15*8 + 0x74f7e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c91a4 lea eax, [r13 + r12]                                                          |         eax = r13 + r12;
    0x004c91a9 movsxd r9, eax                                                                |         r9 = (int64_t) eax;
    0x004c91ac mov r10, r9                                                                   |         r10 = r9;
    0x004c91af sub r10, r13                                                                  |         r10 -= r13;
    0x004c91b2 cmp r10, 4                                                                    |         
                                                                                             |         if (r10 < 4) {
    0x004c91b6 jb 0x4c9546                                                                   |             goto label_30;
                                                                                             |         }
    0x004c91bc mov r11, rbx                                                                  |         r11 = rbx;
    0x004c91bf mov r8, r10                                                                   |         r8 = r10;
    0x004c91c2 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004c91c6 lea rax, [r8 - 4]                                                             |         rax = r8 - 4;
    0x004c91ca mov rbp, rax                                                                  |         
    0x004c91cd shr rbp, 2                                                                    |         rbp >>= 2;
    0x004c91d1 inc rbp                                                                       |         rbp++;
    0x004c91d4 mov edi, ebp                                                                  |         edi = ebp;
    0x004c91d6 and edi, 3                                                                    |         edi &= 3;
    0x004c91d9 cmp rax, 0xc                                                                  |         
                                                                                             |         if (rax >= 0xc) {
    0x004c91dd jae 0x4c9436                                                                  |             goto label_31;
                                                                                             |         }
    0x004c91e3 xor ebx, ebx                                                                  |         ebx = 0;
    0x004c91e5 jmp 0x4c94e5                                                                  |         goto label_32;
                                                                                             | label_27:
    0x004c91f0 cmp qword [rip + 0x24f628], 0                                                 |         
    0x004c91f8 mov ebp, r14d                                                                 |         
    0x004c91fb mov r11, r12                                                                  |         r11 = r12;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004c91fe jne 0x4c9220                                                                  |             
    0x004c9200 mov rax, qword [rip + 0x2880b1]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c9207 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004c920a jne 0x4c9220                                                                  |                 goto label_33;
                                                                                             |             }
    0x004c920c call 0x4eec50                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c9211 mov r11, r12                                                                  |             r11 = r12;
    0x004c9214 nop word cs:[rax + rax]                                                       |             
    0x004c921e nop                                                                           |             
                                                                                             |         }
                                                                                             | label_33:
    0x004c9220 mov r12, qword [rsp + 0x18]                                                   |         r12 = *((rsp + 0x18));
    0x004c9225 cmp r12, 6                                                                    |         
                                                                                             |         if (r12 < 6) {
    0x004c9229 jb 0x4c95a0                                                                   |             goto label_34;
                                                                                             |         }
    0x004c922f lea rax, [r15*8 + 0x74f7e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_void_const__bool__bool__bool_::u;
    0x004c9237 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004c923c add r11, r13                                                                  |         r11 += r13;
    0x004c923f mov r9, r11                                                                   |         r9 = r11;
    0x004c9242 sub r9, r13                                                                   |         r9 -= r13;
    0x004c9245 cmp r9, 4                                                                     |         
                                                                                             |         if (r9 < 4) {
    0x004c9249 jb 0x4c940a                                                                   |             goto label_35;
                                                                                             |         }
    0x004c924f mov r10, rbx                                                                  |         r10 = rbx;
    0x004c9252 mov r8, r9                                                                    |         r8 = r9;
    0x004c9255 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004c9259 lea rsi, [r8 - 4]                                                             |         rsi = r8 - 4;
    0x004c925d mov rdi, rsi                                                                  |         rdi = rsi;
    0x004c9260 shr rdi, 2                                                                    |         rdi >>= 2;
    0x004c9264 inc rdi                                                                       |         rdi++;
    0x004c9267 mov ebp, edi                                                                  |         
    0x004c9269 and ebp, 3                                                                    |         ebp &= 3;
    0x004c926c cmp rsi, 0xc                                                                  |         
                                                                                             |         if (rsi >= 0xc) {
    0x004c9270 jae 0x4c92fd                                                                  |             goto label_36;
                                                                                             |         }
    0x004c9276 xor ebx, ebx                                                                  |         ebx = 0;
    0x004c9278 jmp 0x4c93a5                                                                  |         goto label_37;
    0x004c927d mov eax, 1                                                                    |         eax = 1;
    0x004c9282 mov qword [rsp + 0x40], rax                                                   |         *((rsp + 0x40)) = rax;
    0x004c9287 mov rax, qword [rip + 0x28802a]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c928e test rax, rax                                                                 |         
    0x004c9291 jne 0x4c918b                                                                  |         
                                                                                             |     }
    0x004c9297 call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c929c jmp 0x4c918b                                                                  |     goto label_3;
                                                                                             | label_36:
    0x004c92fd lea rdx, [rsp + 0x2e]                                                         |     rdx = rsp + 0x2e;
    0x004c9302 lea rsi, [rdx + r13]                                                          |     rsi = rdx + r13;
    0x004c9306 and rdi, 0xfffffffffffffffc                                                   |     rdi &= 0xfffffffffffffffc;
    0x004c930a neg rdi                                                                       |     rdi = -rdi;
    0x004c930d xor ebx, ebx                                                                  |     ebx = 0;
    0x004c930f nop                                                                           |     
                                                                                             |     do {
    0x004c9310 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004c9317 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004c931e lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004c9326 movdqu xmmword [rdx + rbx*8 + 0x74f7e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c932f movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1");
    0x004c9338 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004c933f pmovsxbq xmm1, word [rsi + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004c9346 movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0");
    0x004c934f movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1");
    0x004c9358 pmovsxbq xmm0, word [rsi + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004c935f pmovsxbq xmm1, word [rsi + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004c9366 movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0");
    0x004c936f movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1");
    0x004c9378 pmovsxbq xmm0, word [rsi + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004c937f pmovsxbq xmm1, word [rsi + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004c9385 movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0");
    0x004c938e movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1");
    0x004c9397 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004c939b add rdi, 4                                                                    |         rdi += 4;
    0x004c939f jne 0x4c9310                                                                  |         
                                                                                             |     } while (rdi != 0);
                                                                                             | label_37:
    0x004c93a5 test rbp, rbp                                                                 |     
                                                                                             |     if (rbp == 0) {
    0x004c93a8 je 0x4c93f4                                                                   |         goto label_38;
                                                                                             |     }
    0x004c93aa add r13, rbx                                                                  |     r13 += rbx;
    0x004c93ad lea rdx, [rsp + 0x22]                                                         |     rdx = rsp + 0x22;
    0x004c93b2 add r13, rdx                                                                  |     r13 += rdx;
    0x004c93b5 shl r15, 3                                                                    |     r15 <<= 3;
    0x004c93b9 lea rsi, [r15 + rbx*8 + 0x74f7f0]                                             |     rsi = r15 + rbx*8 + 0x74f7f0;
    0x004c93c1 shl rbp, 2                                                                    |     rbp <<= 2;
    0x004c93c5 xor edi, edi                                                                  |     edi = 0;
    0x004c93c7 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c93d0 pmovsxbq xmm0, word [r13 + rdi - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004c93d8 pmovsxbq xmm1, word [r13 + rdi]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004c93e0 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004c93e6 movdqu xmmword [rsi + rdi*8], xmm1                                            |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004c93eb add rdi, 4                                                                    |         rdi += 4;
    0x004c93ef cmp rbp, rdi                                                                  |         
    0x004c93f2 jne 0x4c93d0                                                                  |         
                                                                                             |     } while (rbp != rdi);
                                                                                             | label_38:
    0x004c93f4 cmp r9, r8                                                                    |     
    0x004c93f7 mov rbx, r10                                                                  |     rbx = r10;
    0x004c93fa mov ebp, r14d                                                                 |     
                                                                                             |     if (r9 == r8) {
    0x004c93fd je 0x4c95a0                                                                   |         goto label_34;
                                                                                             |     }
    0x004c9403 add rcx, r8                                                                   |     rcx += r8;
    0x004c9406 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
                                                                                             | label_35:
    0x004c940a sub r11, rcx                                                                  |     r11 -= rcx;
    0x004c940d lea rdx, [rsp + r11 + 0x20]                                                   |     rdx = rsp + r11 + 0x20;
    0x004c9412 xor esi, esi                                                                  |     esi = 0;
    0x004c9414 nop word cs:[rax + rax]                                                       |     
    0x004c941e nop                                                                           |     
                                                                                             |     do {
    0x004c9420 movsx rdi, byte [rcx + rsi]                                                   |         rdi = *((rcx + rsi));
    0x004c9425 mov qword [rax + rsi*8], rdi                                                  |         *((rax + rsi*8)) = rdi;
    0x004c9429 inc rsi                                                                       |         rsi++;
    0x004c942c cmp rdx, rsi                                                                  |         
    0x004c942f jne 0x4c9420                                                                  |         
                                                                                             |     } while (rdx != rsi);
    0x004c9431 jmp 0x4c95a0                                                                  |     goto label_34;
                                                                                             | label_31:
    0x004c9436 lea rax, [rsp + 0x2e]                                                         |     rax = rsp + 0x2e;
    0x004c943b add rax, r13                                                                  |     rax += r13;
    0x004c943e and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004c9442 neg rbp                                                                       |     rbp = -rbp;
    0x004c9445 xor ebx, ebx                                                                  |     ebx = 0;
    0x004c9447 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c9450 pmovsxbq xmm0, word [rax + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004c9457 pmovsxbq xmm1, word [rax + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004c945e lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004c9466 movdqu xmmword [rdx + rbx*8 + 0x74f7e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_void_const__bool__bool__bool_::u], xmm0");
    0x004c946f movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f7f0], xmm1");
    0x004c9478 pmovsxbq xmm0, word [rax + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004c947f pmovsxbq xmm1, word [rax + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004c9486 movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f800], xmm0");
    0x004c948f movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f810], xmm1");
    0x004c9498 pmovsxbq xmm0, word [rax + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004c949f pmovsxbq xmm1, word [rax + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004c94a6 movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f820], xmm0");
    0x004c94af movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f830], xmm1");
    0x004c94b8 pmovsxbq xmm0, word [rax + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004c94bf pmovsxbq xmm1, word [rax + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004c94c5 movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f840], xmm0");
    0x004c94ce movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f850], xmm1");
    0x004c94d7 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004c94db add rbp, 4                                                                    |         rbp += 4;
    0x004c94df jne 0x4c9450                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_32:
    0x004c94e5 test rdi, rdi                                                                 |     
                                                                                             |     if (rdi == 0) {
    0x004c94e8 je 0x4c9534                                                                   |         goto label_39;
                                                                                             |     }
    0x004c94ea add r13, rbx                                                                  |     r13 += rbx;
    0x004c94ed lea rax, [rsp + 0x22]                                                         |     rax = rsp + 0x22;
    0x004c94f2 add r13, rax                                                                  |     r13 += rax;
    0x004c94f5 shl r15, 3                                                                    |     r15 <<= 3;
    0x004c94f9 lea rax, [r15 + rbx*8 + 0x74f7f0]                                             |     rax = r15 + rbx*8 + 0x74f7f0;
    0x004c9501 shl rdi, 2                                                                    |     rdi <<= 2;
    0x004c9505 xor ebp, ebp                                                                  |     ebp = 0;
    0x004c9507 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004c9510 pmovsxbq xmm0, word [r13 + rbp - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004c9518 pmovsxbq xmm1, word [r13 + rbp]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004c9520 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004c9526 movdqu xmmword [rax + rbp*8], xmm1                                            |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004c952b add rbp, 4                                                                    |         rbp += 4;
    0x004c952f cmp rdi, rbp                                                                  |         
    0x004c9532 jne 0x4c9510                                                                  |         
                                                                                             |     } while (rdi != rbp);
                                                                                             | label_39:
    0x004c9534 cmp r10, r8                                                                   |     
    0x004c9537 mov rbx, r11                                                                  |     rbx = r11;
    0x004c953a mov ebp, r14d                                                                 |     
                                                                                             |     if (r10 == r8) {
    0x004c953d je 0x4c9561                                                                   |         goto label_29;
                                                                                             |     }
    0x004c953f add rcx, r8                                                                   |     rcx += r8;
    0x004c9542 lea rsi, [rsi + r8*8]                                                         |     rsi = rsi + r8*8;
                                                                                             | label_30:
    0x004c9546 sub r9, rcx                                                                   |     r9 -= rcx;
    0x004c9549 lea rax, [rsp + r9 + 0x20]                                                    |     rax = rsp + r9 + 0x20;
    0x004c954e xor edi, edi                                                                  |     edi = 0;
                                                                                             |     do {
    0x004c9550 movsx rdx, byte [rcx + rdi]                                                   |         rdx = *((rcx + rdi));
    0x004c9555 mov qword [rsi + rdi*8], rdx                                                  |         *((rsi + rdi*8)) = rdx;
    0x004c9559 inc rdi                                                                       |         rdi++;
    0x004c955c cmp rax, rdi                                                                  |         
    0x004c955f jne 0x4c9550                                                                  |         
                                                                                             |     } while (rax != rdi);
                                                                                             | label_29:
    0x004c9561 mov rax, qword [rsp + 0x58]                                                   |     rax = *((rsp + 0x58));
    0x004c9566 lea rdi, [rsp + 0x58]                                                         |     rdi = rsp + 0x58;
    0x004c956b mov rsi, 0xffffffffffffffff                                                   |     rsi = 0xffffffffffffffff;
    0x004c9572 call qword [rax + 0x10]                                                       |     uint64_t (*rax + 0x10)() ();
    0x004c9575 cmp byte [rip + 0x24f419], 0                                                  |     
    0x004c957c mov r12, qword [rsp + 0x18]                                                   |     r12 = *((rsp + 0x18));
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c9581 je 0x4c958d                                                                   |         
    0x004c9583 mov edi, 0x4f43e1                                                             |         
    0x004c9588 call 0x401710                                                                 |         puts ("\t\tEnd bslma exception test.");
                                                                                             |     }
    0x004c958d cmp byte [rip + 0x24f3fc], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004c9594 je 0x4c95cb                                                                   |         
    0x004c9596 mov edi, 0xa                                                                  |         
    0x004c959b call 0x401720                                                                 |         eax = putchar (0xa);
                                                                                             | label_34:
    0x004c95a0 cmp byte [rip + 0x24f3e9], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004c95a7 je 0x4c95cb                                                                   |             goto label_40;
                                                                                             |         }
    0x004c95a9 mov edx, dword [rip + 0x24f3f5]                                               |         edx = numCopyCtorCalls;
    0x004c95af sub edx, dword [rsp + 0x14]                                                   |         edx -= *((rsp + 0x14));
    0x004c95b3 mov ecx, dword [rip + 0x24f3f3]                                               |         ecx = numCharCtorCalls;
    0x004c95b9 sub ecx, dword [rsp + 0x48]                                                   |         ecx -= *((rsp + 0x48));
    0x004c95bd mov edi, 0x4f5c2a                                                             |         
    0x004c95c2 mov esi, ebp                                                                  |         esi = ebp;
    0x004c95c4 xor eax, eax                                                                  |         eax = 0;
    0x004c95c6 call 0x401680                                                                 |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_40:
    0x004c95cb mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004c95cf cmp eax, dword [rip + 0x24f3cf]                                               |     
                                                                                             |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004c95d5 je 0x4c8fc0                                                                   |         goto label_4;
                                                                                             |     }
    0x004c95db mov edi, 0x4f4c78                                                             |     
    0x004c95e0 mov edx, 0x4f4fec                                                             |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c95e5 mov esi, 0x103f                                                               |     esi = 0x103f;
    0x004c95ea xor eax, eax                                                                  |     eax = 0;
    0x004c95ec call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c95f1 mov eax, dword [rip + 0x24f3a1]                                               |     eax = (anonymous namespace)::testStatus;
    0x004c95f7 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004c95fa ja 0x4c8fc0                                                                   |         goto label_4;
                                                                                             |     }
    0x004c9600 inc eax                                                                       |     eax++;
    0x004c9602 mov dword [rip + 0x24f390], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c9608 jmp 0x4c8fc0                                                                  |     goto label_4;
                                                                                             | label_23:
    0x004c960d add rsp, 0x68                                                                 |     
    0x004c9611 pop rbx                                                                       |     
    0x004c9612 pop r12                                                                       |     
    0x004c9614 pop r13                                                                       |     
    0x004c9616 pop r14                                                                       |     
    0x004c9618 pop r15                                                                       |     
    0x004c961a pop rbp                                                                       |     
    0x004c961b ret                                                                           |     return rax;
                                                                                             | }