; assembly                                                                               | /* r2dec pseudo code output */
                                                                                             | /* bslalg_arrayprimitives.t/assume @ 0x4ca2a0 */
                                                                                             | #include <stdint.h>
                                                                                             |  
    ; (fcn) sym.void_testCopyConstructWithIterators_int_const__bool__bool__bool_ ()          | uint64_t void_testCopyConstructWithIterators_int_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<int const*>(bool, bool, bool) */
    0x004ca2a0 push rbp                                                                      |     
    0x004ca2a1 push r15                                                                      |     
    0x004ca2a3 push r14                                                                      |     
    0x004ca2a5 push r13                                                                      |     
    0x004ca2a7 push r12                                                                      |     
    0x004ca2a9 push rbx                                                                      |     
    0x004ca2aa sub rsp, 0x68                                                                 |     
    0x004ca2ae mov dword [rsp + 0x54], edx                                                   |     *((rsp + 0x54)) = edx;
    0x004ca2b2 mov dword [rsp + 0x40], esi                                                   |     *((rsp + 0x40)) = esi;
    0x004ca2b6 cmp byte [rip + 0x24e6d9], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004ca2bd je 0x4ca2c9                                                                   |         
    0x004ca2bf mov edi, 0x4f67e9                                                             |         
    0x004ca2c4 call 0x401710                                                                 |         eax = puts ("\t\tfrom same type.");
                                                                                             |     }
    0x004ca2c9 xor eax, eax                                                                  |     eax = 0;
    0x004ca2cb jmp 0x4ca2fc                                                                  |     goto label_5;
                                                                                             | label_2:
    0x004ca2d0 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca2d5 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca2d8 call 0x4e2e60                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca2dd mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca2e2 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca2e5 call 0x4e30a0                                                                 |     voidcleanup<intconst*>(intconst**,char const*) ();
    0x004ca2ea mov rax, qword [rsp + 0x18]                                                   |     rax = *((rsp + 0x18));
    0x004ca2ef inc rax                                                                       |     rax++;
    0x004ca2f2 cmp rax, 0x1e                                                                 |     
                                                                                             |     if (rax == 0x1e) {
    0x004ca2f6 je 0x4ca839                                                                   |         goto label_6;
                                                                                             |     }
                                                                                             | label_5:
    0x004ca2fc mov qword [rsp + 0x18], rax                                                   |     *((rsp + 0x18)) = rax;
    0x004ca301 lea rbp, [rax*8]                                                              |     rbp = rax*8;
    0x004ca309 mov r12, qword [rbp + rbp*4 + 0x4f3b08]                                       |     r12 = *((rbp + rbp*4 + 0x4f3b08));
    0x004ca311 mov rdi, r12                                                                  |     
    0x004ca314 call 0x401790                                                                 |     eax = strlen (*((rbp + rbp*4 + 0x4f3b08)));
    0x004ca319 cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004ca31c jl 0x4ca347                                                                   |         
    0x004ca31e mov edi, 0x4f4c78                                                             |         
    0x004ca323 mov edx, 0x4f4203                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004ca328 mov esi, 0xfe6                                                                |         esi = 0xfe6;
    0x004ca32d xor eax, eax                                                                  |         eax = 0;
    0x004ca32f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca334 mov eax, dword [rip + 0x24e65e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca33a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca33d ja 0x4ca347                                                                   |             goto label_7;
                                                                                             |         }
    0x004ca33f inc eax                                                                       |         eax++;
    0x004ca341 mov dword [rip + 0x24e651], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_7:
    0x004ca347 mov r13d, dword [rbp + rbp*4 + 0x4f3b00]                                      |     r13d = *((rbp + rbp*4 + obj.DATA_3));
    0x004ca34f movsxd r15, dword [rbp + rbp*4 + 0x4f3b10]                                    |     r15 = *((rbp + rbp*4 + 0x4f3b10));
    0x004ca357 mov ebx, dword [rbp + rbp*4 + 0x4f3b14]                                       |     ebx = *((rbp + rbp*4 + 0x4f3b14));
    0x004ca35e movsxd r14, dword [rbp + rbp*4 + 0x4f3b18]                                    |     r14 = *((rbp + rbp*4 + 0x4f3b18));
    0x004ca366 mov rbp, qword [rbp + rbp*4 + 0x4f3b20]                                       |     rbp = *((rbp + rbp*4 + 0x4f3b20));
    0x004ca36e cmp byte [rip + 0x24e61b], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca375 je 0x4ca396                                                                   |         
    0x004ca377 mov qword [rsp], rbp                                                          |         *(rsp) = rbp;
    0x004ca37b mov edi, 0x4f5ab7                                                             |         
    0x004ca380 mov esi, r13d                                                                 |         esi = r13d;
    0x004ca383 mov rdx, r12                                                                  |         rdx = r12;
    0x004ca386 mov ecx, r15d                                                                 |         ecx = r15d;
    0x004ca389 mov r8d, ebx                                                                  |         r8d = ebx;
    0x004ca38c mov r9d, r14d                                                                 |         r9d = r14d;
    0x004ca38f xor eax, eax                                                                  |         eax = 0;
    0x004ca391 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004ca396 mov qword [rsp + 0x48], rbx                                                   |     *((rsp + 0x48)) = rbx;
    0x004ca39b mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca3a0 mov rsi, r12                                                                  |     rsi = r12;
    0x004ca3a3 call 0x4e2d80                                                                 |     intconst*&gg<intconst*>(intconst**,char const*) ();
    0x004ca3a8 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca3ad mov rsi, r12                                                                  |     rsi = r12;
    0x004ca3b0 call 0x4e2e60                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca3b5 mov r12d, dword [rip + 0x24e5e8]                                              |     r12d = numCopyCtorCalls;
    0x004ca3bc mov eax, dword [rip + 0x24e5ea]                                               |     eax = numCharCtorCalls;
    0x004ca3c2 mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004ca3c6 cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004ca3cb je 0x4ca4b0                                                                   |         goto label_8;
                                                                                             |     }
    0x004ca3d1 cmp byte [rip + 0x24e5b8], 0                                                  |     
    0x004ca3d8 mov ebx, r13d                                                                 |     ebx = r13d;
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca3db je 0x4ca3f0                                                                   |         
    0x004ca3dd cmp dword [rip + 0x24e1bc], 0                                                 |         
                                                                                             |         if (*(0x007185a0) == 0) {
    0x004ca3e4 je 0x4ca3f0                                                                   |             goto label_9;
                                                                                             |         }
    0x004ca3e6 mov edi, 0x4f425a                                                             |         
    0x004ca3eb call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_9:
    0x004ca3f0 mov dword [rip + 0x24e1a6], 0                                                 |     *(0x007185a0) = 0;
    0x004ca3fa cmp byte [rip + 0x24e594], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004ca401 je 0x4ca40d                                                                   |         
    0x004ca403 mov edi, 0x4f4281                                                             |         
    0x004ca408 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004ca40d mov rax, qword [rip + 0x24e40c]                                               |     rax = Z;
    0x004ca414 mov qword [rsp + 0x20], 0x4f6858                                              |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004ca41d mov qword [rsp + 0x28], rax                                                   |     *((rsp + 0x28)) = rax;
    0x004ca422 mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004ca42a test rax, rax                                                                 |     
    0x004ca42d je 0x4ca519                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_0:
    0x004ca433 lea rsi, [r15*8 + 0x74f8e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca43b mov rax, qword [rsp + 0x48]                                                   |         rax = *((rsp + 0x48));
    0x004ca440 add eax, r15d                                                                 |         eax += r15d;
    0x004ca443 cdqe                                                                          |         rax = (int64_t) eax;
    0x004ca445 lea rdx, [rax*8 + 0x74f8e0]                                                   |         rdx = rax*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca44d sub rdx, rsi                                                                  |         rdx -= rsi;
                                                                                             |         if (rdx != 0) {
    0x004ca450 je 0x4ca45f                                                                   |             
    0x004ca452 lea rdi, [r14*8 + 0x74f8e0]                                                   |             
    0x004ca45a call 0x401930                                                                 |             memcpy (r14*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u, rsi, rdx);
                                                                                             |         }
    0x004ca45f mov rax, qword [rsp + 0x20]                                                   |         rax = *((rsp + 0x20));
    0x004ca464 lea rdi, [rsp + 0x20]                                                         |         rdi = rsp + 0x20;
    0x004ca469 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004ca470 call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004ca473 cmp byte [rip + 0x24e51b], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004ca47a je 0x4ca486                                                                   |             
    0x004ca47c mov edi, 0x4f43e1                                                             |             
    0x004ca481 call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004ca486 cmp byte [rip + 0x24e503], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004ca48d je 0x4ca75b                                                                   |             goto label_10;
                                                                                             |         }
    0x004ca493 mov edi, 0xa                                                                  |         
    0x004ca498 call 0x401720                                                                 |         putchar (0xa);
    0x004ca49d jmp 0x4ca731                                                                  |         goto label_11;
                                                                                             | label_8:
    0x004ca4b0 cmp qword [rip + 0x24e368], 0                                                 |         
    0x004ca4b8 mov ebx, r13d                                                                 |         ebx = r13d;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004ca4bb jne 0x4ca4cd                                                                  |             
    0x004ca4bd mov rax, qword [rip + 0x286df4]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004ca4c4 test rax, rax                                                                 |             
                                                                                             |             if (rax == 0) {
    0x004ca4c7 je 0x4ca5d3                                                                   |                 goto label_12;
                                                                                             |             }
                                                                                             |         }
    0x004ca4cd cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004ca4d3 jb 0x4ca731                                                                   |             goto label_11;
                                                                                             |         }
                                                                                             | label_1:
    0x004ca4d9 lea rax, [r15*8 + 0x74f8e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca4e1 lea rcx, [r14*8 + 0x74f8e0]                                                   |         rcx = r14*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca4e9 mov rbx, qword [rsp + 0x48]                                                   |         rbx = *((rsp + 0x48));
    0x004ca4ee lea edx, [rbx + r15]                                                          |         edx = rbx + r15;
    0x004ca4f2 movsxd r9, edx                                                                |         r9 = (int64_t) edx;
    0x004ca4f5 shl r9, 3                                                                     |         r9 <<= 3;
    0x004ca4f9 lea rdi, [r15*8]                                                              |         rdi = r15*8;
    0x004ca501 mov r10, r9                                                                   |         r10 = r9;
    0x004ca504 sub r10, rdi                                                                  |         r10 -= rdi;
    0x004ca507 add r10, 0xfffffffffffffff8                                                   |         r10 += 0xfffffffffffffff8;
    0x004ca50b cmp r10, 0x18                                                                 |         
                                                                                             |         if (r10 >= 0x18) {
    0x004ca50f jae 0x4ca58d                                                                  |             goto label_13;
                                                                                             |         }
    0x004ca511 mov ebx, r13d                                                                 |         ebx = r13d;
    0x004ca514 jmp 0x4ca710                                                                  |         goto label_14;
    0x004ca519 mov r13d, 1                                                                   |         r13d = 1;
    0x004ca51f mov rax, qword [rip + 0x286d92]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004ca526 test rax, rax                                                                 |         
    0x004ca529 jne 0x4ca433                                                                  |         
                                                                                             |     }
    0x004ca52f call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004ca534 jmp 0x4ca433                                                                  |     goto label_0;
                                                                                             | label_13:
    0x004ca58d mov r11, rbp                                                                  |     r11 = rbp;
    0x004ca590 lea rsi, [r14*8 + 0x74f8e0]                                                   |     rsi = r14*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca598 lea edx, [rbx + r15]                                                          |     edx = rbx + r15;
    0x004ca59c movsxd rdx, edx                                                               |     rdx = (int64_t) edx;
    0x004ca59f lea rbp, [rdx*8 + 0x74f8e0]                                                   |     rbp = rdx*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca5a7 cmp rsi, rbp                                                                  |     
                                                                                             |     if (rsi >= rbp) {
    0x004ca5aa jae 0x4ca5e9                                                                  |         goto label_15;
                                                                                             |     }
    0x004ca5ac shl rdx, 3                                                                    |     rdx <<= 3;
    0x004ca5b0 sub rdx, rdi                                                                  |     rdx -= rdi;
    0x004ca5b3 lea rdx, [rdx + r14*8 + 0x74f8e0]                                             |     rdx = rdx + r14*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca5bb lea rsi, [r15*8 + 0x74f8e0]                                                   |     rsi = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca5c3 cmp rsi, rdx                                                                  |     
                                                                                             |     if (rsi >= rdx) {
    0x004ca5c6 jae 0x4ca5e9                                                                  |         goto label_15;
                                                                                             |     }
    0x004ca5c8 mov rbp, r11                                                                  |     
    0x004ca5cb mov ebx, r13d                                                                 |     ebx = r13d;
    0x004ca5ce jmp 0x4ca710                                                                  |     goto label_14;
                                                                                             | label_12:
    0x004ca5d3 call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004ca5d8 cmp qword [rsp + 0x18], 6                                                     |     
                                                                                             |     if (*((rsp + 0x18)) >= 6) {
    0x004ca5de jae 0x4ca4d9                                                                  |         goto label_1;
                                                                                             |     }
    0x004ca5e4 jmp 0x4ca731                                                                  |     goto label_11;
                                                                                             | label_15:
    0x004ca5e9 shr r10, 3                                                                    |     r10 >>= 3;
    0x004ca5ed inc r10                                                                       |     r10++;
    0x004ca5f0 mov r8, r10                                                                   |     r8 = r10;
    0x004ca5f3 and r8, 0xfffffffffffffffc                                                    |     r8 &= 0xfffffffffffffffc;
    0x004ca5f7 lea rsi, [r8 - 4]                                                             |     rsi = r8 - 4;
    0x004ca5fb mov rbp, rsi                                                                  |     
    0x004ca5fe shr rbp, 2                                                                    |     rbp >>= 2;
    0x004ca602 inc rbp                                                                       |     rbp++;
    0x004ca605 mov edx, ebp                                                                  |     edx = ebp;
    0x004ca607 and edx, 3                                                                    |     edx &= 3;
    0x004ca60a cmp rsi, 0xc                                                                  |     
                                                                                             |     if (rsi < 0xc) {
    0x004ca60e jae 0x4ca617                                                                  |         
    0x004ca610 xor ebx, ebx                                                                  |         ebx = 0;
    0x004ca612 jmp 0x4ca6a0                                                                  |         goto label_16;
                                                                                             |     }
    0x004ca617 and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004ca61b neg rbp                                                                       |     rbp = -rbp;
    0x004ca61e mov esi, 0x74f8e0                                                             |     esi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca623 xor ebx, ebx                                                                  |     ebx = 0;
    0x004ca625 nop word cs:[rax + rax]                                                       |     
    0x004ca62f nop                                                                           |     
                                                                                             |     do {
    0x004ca630 movups xmm0, xmmword [rsi + r15*8]                                            |         __asm ("movups xmm0, xmmword [rsi + r15*8]");
    0x004ca635 movups xmm1, xmmword [rsi + r15*8 + 0x10]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x10]");
    0x004ca63b movups xmmword [rsi + r14*8], xmm0                                            |         __asm ("movups xmmword [rsi + r14*8], xmm0");
    0x004ca640 movups xmmword [rsi + r14*8 + 0x10], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x10], xmm1");
    0x004ca646 movups xmm0, xmmword [rsi + r15*8 + 0x20]                                     |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x20]");
    0x004ca64c movups xmm1, xmmword [rsi + r15*8 + 0x30]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x30]");
    0x004ca652 movups xmmword [rsi + r14*8 + 0x20], xmm0                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x20], xmm0");
    0x004ca658 movups xmmword [rsi + r14*8 + 0x30], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x30], xmm1");
    0x004ca65e movups xmm0, xmmword [rsi + r15*8 + 0x40]                                     |         __asm ("movups xmm0, xmmword [rsi + r15*8 + 0x40]");
    0x004ca664 movups xmm1, xmmword [rsi + r15*8 + 0x50]                                     |         __asm ("movups xmm1, xmmword [rsi + r15*8 + 0x50]");
    0x004ca66a movups xmmword [rsi + r14*8 + 0x40], xmm0                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x40], xmm0");
    0x004ca670 movups xmmword [rsi + r14*8 + 0x50], xmm1                                     |         __asm ("movups xmmword [rsi + r14*8 + 0x50], xmm1");
    0x004ca676 movdqu xmm0, xmmword [rsi + r15*8 + 0x60]                                     |         __asm ("movdqu xmm0, xmmword [rsi + r15*8 + 0x60]");
    0x004ca67d movdqu xmm1, xmmword [rsi + r15*8 + 0x70]                                     |         __asm ("movdqu xmm1, xmmword [rsi + r15*8 + 0x70]");
    0x004ca684 movdqu xmmword [rsi + r14*8 + 0x60], xmm0                                     |         __asm ("movdqu xmmword [rsi + r14*8 + 0x60], xmm0");
    0x004ca68b movdqu xmmword [rsi + r14*8 + 0x70], xmm1                                     |         __asm ("movdqu xmmword [rsi + r14*8 + 0x70], xmm1");
    0x004ca692 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004ca696 sub rsi, 0xffffffffffffff80                                                   |         rsi -= 0xffffffffffffff80;
    0x004ca69a add rbp, 4                                                                    |         rbp += 4;
    0x004ca69e jne 0x4ca630                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_16:
    0x004ca6a0 test rdx, rdx                                                                 |     
                                                                                             |     if (rdx == 0) {
    0x004ca6a3 je 0x4ca6f3                                                                   |         goto label_17;
                                                                                             |     }
    0x004ca6a5 shl r14, 3                                                                    |     r14 <<= 3;
    0x004ca6a9 lea rsi, [rbx*8 + 0x74f8e0]                                                   |     rsi = rbx*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca6b1 neg rdx                                                                       |     rdx = -rdx;
    0x004ca6b4 nop word cs:[rax + rax]                                                       |     
    0x004ca6be nop                                                                           |     
                                                                                             |     do {
    0x004ca6c0 movdqu xmm0, xmmword [rdi + rbx*8 + 0x74f8e0]                                 |         __asm ("movdqu xmm0, xmmword [rdi + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u]");
    0x004ca6c9 movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f8f0]                                 |         __asm ("movdqu xmm1, xmmword [rdi + rbx*8 + 0x74f8f0]");
    0x004ca6d2 movdqu xmmword [r14 + rbx*8 + 0x74f8e0], xmm0                                 |         __asm ("movdqu xmmword [r14 + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004ca6dc movdqu xmmword [r14 + rbx*8 + 0x74f8f0], xmm1                                 |         __asm ("movdqu xmmword [r14 + rbx*8 + 0x74f8f0], xmm1");
    0x004ca6e6 add rbx, 4                                                                    |         rbx += 4;
    0x004ca6ea add rsi, 0x20                                                                 |         rsi += 0x20;
    0x004ca6ee inc rdx                                                                       |         rdx++;
    0x004ca6f1 jne 0x4ca6c0                                                                  |         
                                                                                             |     } while (rdx != 0);
                                                                                             | label_17:
    0x004ca6f3 cmp r10, r8                                                                   |     
    0x004ca6f6 mov rbp, r11                                                                  |     
    0x004ca6f9 mov ebx, r13d                                                                 |     ebx = r13d;
                                                                                             |     if (r10 == r8) {
    0x004ca6fc je 0x4ca731                                                                   |         goto label_11;
                                                                                             |     }
    0x004ca6fe lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
    0x004ca702 lea rcx, [rcx + r8*8]                                                         |     rcx = rcx + r8*8;
    0x004ca706 nop word cs:[rax + rax]                                                       |     
                                                                                             | label_14:
    0x004ca710 sub r9, rax                                                                   |     r9 -= rax;
    0x004ca713 lea rdx, [r9 + 0x74f8e0]                                                      |     rdx = r9 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004ca71a xor esi, esi                                                                  |     esi = 0;
    0x004ca71c nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004ca720 mov rdi, qword [rax + rsi]                                                    |         rdi = *((rax + rsi));
    0x004ca724 mov qword [rcx + rsi], rdi                                                    |         *((rcx + rsi)) = rdi;
    0x004ca728 add rsi, 8                                                                    |         rsi += 8;
    0x004ca72c cmp rdx, rsi                                                                  |         
    0x004ca72f jne 0x4ca720                                                                  |         
                                                                                             |     } while (rdx != rsi);
                                                                                             | label_11:
    0x004ca731 cmp byte [rip + 0x24e258], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca738 je 0x4ca75b                                                                   |         
    0x004ca73a mov edx, dword [rip + 0x24e264]                                               |         edx = numCopyCtorCalls;
    0x004ca740 sub edx, r12d                                                                 |         edx -= r12d;
    0x004ca743 mov ecx, dword [rip + 0x24e263]                                               |         ecx = numCharCtorCalls;
    0x004ca749 sub ecx, dword [rsp + 0x14]                                                   |         ecx -= *((rsp + 0x14));
    0x004ca74d mov edi, 0x4f5c2a                                                             |         
    0x004ca752 mov esi, ebx                                                                  |         esi = ebx;
    0x004ca754 xor eax, eax                                                                  |         eax = 0;
    0x004ca756 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_10:
    0x004ca75b cmp byte [rsp + 0x40], 0                                                      |     
                                                                                             |     if (*((rsp + 0x40)) == 0) {
    0x004ca760 je 0x4ca7c0                                                                   |         goto label_18;
                                                                                             |     }
    0x004ca762 cmp r12d, dword [rip + 0x24e23b]                                              |     
                                                                                             |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004ca769 je 0x4ca794                                                                   |         
    0x004ca76b mov edi, 0x4f4c78                                                             |         
    0x004ca770 mov edx, 0x4f4fec                                                             |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004ca775 mov esi, 0x1005                                                               |         esi = 0x1005;
    0x004ca77a xor eax, eax                                                                  |         eax = 0;
    0x004ca77c call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca781 mov eax, dword [rip + 0x24e211]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca787 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca78a ja 0x4ca794                                                                   |             goto label_19;
                                                                                             |         }
    0x004ca78c inc eax                                                                       |         eax++;
    0x004ca78e mov dword [rip + 0x24e204], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_19:
    0x004ca794 mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004ca798 cmp eax, dword [rip + 0x24e20e]                                               |     
                                                                                             |     if (eax == *(obj.numCharCtorCalls)) {
    0x004ca79e je 0x4ca2d0                                                                   |         goto label_2;
                                                                                             |     }
    0x004ca7a4 mov edi, 0x4f4c78                                                             |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004ca7a9 mov edx, 0x4f5c5a                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004ca7ae mov esi, 0x1006                                                               |     esi = 0x1006;
    0x004ca7b3 jmp 0x4ca816                                                                  |     goto label_20;
                                                                                             | label_18:
    0x004ca7c0 add r12d, dword [rsp + 0x48]                                                  |     r12d += *((rsp + 0x48));
    0x004ca7c5 cmp r12d, dword [rip + 0x24e1d8]                                              |     
                                                                                             |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004ca7cc jle 0x4ca7f7                                                                  |         
    0x004ca7ce mov edi, 0x4f4c78                                                             |         
    0x004ca7d3 mov edx, 0x4f5c78                                                             |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004ca7d8 mov esi, 0x1009                                                               |         esi = 0x1009;
    0x004ca7dd xor eax, eax                                                                  |         eax = 0;
    0x004ca7df call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca7e4 mov eax, dword [rip + 0x24e1ae]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca7ea cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca7ed ja 0x4ca7f7                                                                   |             goto label_21;
                                                                                             |         }
    0x004ca7ef inc eax                                                                       |         eax++;
    0x004ca7f1 mov dword [rip + 0x24e1a1], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_21:
    0x004ca7f7 mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004ca7fb cmp eax, dword [rip + 0x24e1ab]                                               |     
                                                                                             |     if (eax == *(obj.numCharCtorCalls)) {
    0x004ca801 je 0x4ca2d0                                                                   |         goto label_2;
                                                                                             |     }
    0x004ca807 mov edi, 0x4f4c78                                                             |     
    0x004ca80c mov edx, 0x4f5c5a                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004ca811 mov esi, 0x100a                                                               |     esi = 0x100a;
                                                                                             | label_20:
    0x004ca816 xor eax, eax                                                                  |     eax = 0;
    0x004ca818 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca81d mov eax, dword [rip + 0x24e175]                                               |     eax = (anonymous namespace)::testStatus;
    0x004ca823 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004ca826 ja 0x4ca2d0                                                                   |         goto label_2;
                                                                                             |     }
    0x004ca82c inc eax                                                                       |     eax++;
    0x004ca82e mov dword [rip + 0x24e164], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004ca834 jmp 0x4ca2d0                                                                  |     goto label_2;
                                                                                             | label_6:
    0x004ca839 cmp byte [rip + 0x24e156], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004ca840 je 0x4ca84c                                                                   |         
    0x004ca842 mov edi, 0x4f67d2                                                             |         
    0x004ca847 call 0x401710                                                                 |         puts ("\t\tfrom different type.");
                                                                                             |     }
    0x004ca84c xor r12d, r12d                                                                |     r12d = 0;
    0x004ca84f jmp 0x4ca887                                                                  |     goto label_22;
                                                                                             | label_4:
    0x004ca860 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca865 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004ca868 call 0x4e2e60                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca86d mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca872 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004ca875 call 0x4e30a0                                                                 |     voidcleanup<intconst*>(intconst**,char const*) ();
    0x004ca87a inc r12                                                                       |     r12++;
    0x004ca87d cmp r12, 0x1e                                                                 |     
                                                                                             |     if (r12 == 0x1e) {
    0x004ca881 je 0x4caead                                                                   |         goto label_23;
                                                                                             |     }
                                                                                             | label_22:
    0x004ca887 lea rbx, [r12*8]                                                              |     rbx = r12*8;
    0x004ca88f mov rbp, qword [rbx + rbx*4 + 0x4f3b08]                                       |     rbp = *((rbx + rbx*4 + 0x4f3b08));
    0x004ca897 mov rdi, rbp                                                                  |     
    0x004ca89a call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004ca89f cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004ca8a2 jl 0x4ca8cd                                                                   |         
    0x004ca8a4 mov edi, 0x4f4c78                                                             |         
    0x004ca8a9 mov edx, 0x4f4203                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004ca8ae mov esi, 0x1019                                                               |         esi = 0x1019;
    0x004ca8b3 xor eax, eax                                                                  |         eax = 0;
    0x004ca8b5 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca8ba mov eax, dword [rip + 0x24e0d8]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca8c0 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca8c3 ja 0x4ca8cd                                                                   |             goto label_24;
                                                                                             |         }
    0x004ca8c5 inc eax                                                                       |         eax++;
    0x004ca8c7 mov dword [rip + 0x24e0cb], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_24:
    0x004ca8cd mov rdi, rbp                                                                  |     
    0x004ca8d0 call 0x401790                                                                 |     rax = strlen (rbp);
    0x004ca8d5 cmp rax, 0x14                                                                 |     
                                                                                             |     if (rax >= 0x14) {
    0x004ca8d9 jb 0x4ca904                                                                   |         
    0x004ca8db mov edi, 0x4f4c78                                                             |         
    0x004ca8e0 mov edx, 0x4f5c9c                                                             |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004ca8e5 mov esi, 0x101c                                                               |         esi = 0x101c;
    0x004ca8ea xor eax, eax                                                                  |         eax = 0;
    0x004ca8ec call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004ca8f1 mov eax, dword [rip + 0x24e0a1]                                               |         eax = (anonymous namespace)::testStatus;
    0x004ca8f7 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004ca8fa ja 0x4ca904                                                                   |             goto label_25;
                                                                                             |         }
    0x004ca8fc inc eax                                                                       |         eax++;
    0x004ca8fe mov dword [rip + 0x24e094], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_25:
    0x004ca904 mov qword [rsp + 0x18], r12                                                   |     *((rsp + 0x18)) = r12;
    0x004ca909 pxor xmm0, xmm0                                                               |     xmm0 = 0;
    0x004ca90d movdqa xmmword [rsp + 0x20], xmm0                                             |     __asm ("movdqa xmmword [rsp + 0x20], xmm0");
    0x004ca913 mov dword [rsp + 0x30], 0                                                     |     *((rsp + 0x30)) = 0;
    0x004ca91b mov al, byte [rbp]                                                            |     al = *(rbp);
    0x004ca91e test al, al                                                                   |     
                                                                                             |     if (al == 0) {
    0x004ca920 je 0x4ca940                                                                   |         goto label_26;
                                                                                             |     }
    0x004ca922 xor ecx, ecx                                                                  |     ecx = 0;
    0x004ca924 nop word cs:[rax + rax]                                                       |     
    0x004ca92e nop                                                                           |     
                                                                                             |     do {
    0x004ca930 mov byte [rsp + rcx + 0x20], al                                               |         *((rsp + rcx + 0x20)) = al;
    0x004ca934 movzx eax, byte [rbp + rcx + 1]                                               |         eax = *((rbp + rcx + 1));
    0x004ca939 inc rcx                                                                       |         rcx++;
    0x004ca93c test al, al                                                                   |         
    0x004ca93e jne 0x4ca930                                                                  |         
                                                                                             |     } while (al != 0);
                                                                                             | label_26:
    0x004ca940 mov r14d, dword [rbx + rbx*4 + 0x4f3b00]                                      |     r14d = *((rbx + rbx*4 + obj.DATA_3));
    0x004ca948 movsxd r13, dword [rbx + rbx*4 + 0x4f3b10]                                    |     r13 = *((rbx + rbx*4 + 0x4f3b10));
    0x004ca950 movsxd r12, dword [rbx + rbx*4 + 0x4f3b14]                                    |     r12 = *((rbx + rbx*4 + 0x4f3b14));
    0x004ca958 movsxd r15, dword [rbx + rbx*4 + 0x4f3b18]                                    |     r15 = *((rbx + rbx*4 + 0x4f3b18));
    0x004ca960 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                       |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004ca968 cmp byte [rip + 0x24e021], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca96f je 0x4ca990                                                                   |         
    0x004ca971 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004ca975 mov edi, 0x4f5ab7                                                             |         
    0x004ca97a mov esi, r14d                                                                 |         esi = r14d;
    0x004ca97d mov rdx, rbp                                                                  |         rdx = rbp;
    0x004ca980 mov ecx, r13d                                                                 |         ecx = r13d;
    0x004ca983 mov r8d, r12d                                                                 |         r8d = r12d;
    0x004ca986 mov r9d, r15d                                                                 |         r9d = r15d;
    0x004ca989 xor eax, eax                                                                  |         eax = 0;
    0x004ca98b call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004ca990 mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca995 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca998 call 0x4e2d80                                                                 |     intconst*&gg<intconst*>(intconst**,char const*) ();
    0x004ca99d mov edi, 0x74f8e0                                                             |     edi = testCopyConstructWithIterators<int const*>(bool, bool, bool)::u;
    0x004ca9a2 mov rsi, rbp                                                                  |     rsi = rbp;
    0x004ca9a5 call 0x4e2e60                                                                 |     voidverify<intconst*>(intconst**,char const*) ();
    0x004ca9aa mov eax, dword [rip + 0x24dff4]                                               |     eax = numCopyCtorCalls;
    0x004ca9b0 mov dword [rsp + 0x14], eax                                                   |     *((rsp + 0x14)) = eax;
    0x004ca9b4 mov eax, dword [rip + 0x24dff2]                                               |     eax = numCharCtorCalls;
    0x004ca9ba mov dword [rsp + 0x48], eax                                                   |     *((rsp + 0x48)) = eax;
    0x004ca9be cmp byte [rsp + 0x54], 0                                                      |     
                                                                                             |     if (*((rsp + 0x54)) == 0) {
    0x004ca9c3 je 0x4caa90                                                                   |         goto label_27;
                                                                                             |     }
    0x004ca9c9 cmp byte [rip + 0x24dfc0], 0                                                  |     
    0x004ca9d0 mov ebp, r14d                                                                 |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004ca9d3 je 0x4ca9e8                                                                   |         
    0x004ca9d5 cmp dword [rip + 0x24dbc8], 0                                                 |         
                                                                                             |         if (*(obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::firstTime) == 0) {
    0x004ca9dc je 0x4ca9e8                                                                   |             goto label_28;
                                                                                             |         }
    0x004ca9de mov edi, 0x4f425a                                                             |         
    0x004ca9e3 call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_28:
    0x004ca9e8 mov dword [rip + 0x24dbb2], 0                                                 |     *(obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::firstTime) = 0;
    0x004ca9f2 cmp byte [rip + 0x24df9c], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004ca9f9 je 0x4caa05                                                                   |         
    0x004ca9fb mov edi, 0x4f4281                                                             |         
    0x004caa00 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004caa05 mov rax, qword [rip + 0x24de14]                                               |     rax = Z;
    0x004caa0c mov qword [rsp + 0x58], 0x4f6858                                              |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004caa15 mov qword [rsp + 0x60], rax                                                   |     *((rsp + 0x60)) = rax;
    0x004caa1a mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004caa22 test rax, rax                                                                 |     
    0x004caa25 je 0x4cab1d                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_3:
    0x004caa2b cmp qword [rsp + 0x18], 6                                                     |         
                                                                                             |         if (*((rsp + 0x18)) < 6) {
    0x004caa31 jb 0x4cae01                                                                   |             goto label_29;
                                                                                             |         }
    0x004caa37 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004caa3c lea rsi, [r15*8 + 0x74f8e0]                                                   |         rsi = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004caa44 lea eax, [r13 + r12]                                                          |         eax = r13 + r12;
    0x004caa49 movsxd r9, eax                                                                |         r9 = (int64_t) eax;
    0x004caa4c mov r10, r9                                                                   |         r10 = r9;
    0x004caa4f sub r10, r13                                                                  |         r10 -= r13;
    0x004caa52 cmp r10, 4                                                                    |         
                                                                                             |         if (r10 < 4) {
    0x004caa56 jb 0x4cade6                                                                   |             goto label_30;
                                                                                             |         }
    0x004caa5c mov r11, rbx                                                                  |         r11 = rbx;
    0x004caa5f mov r8, r10                                                                   |         r8 = r10;
    0x004caa62 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004caa66 lea rax, [r8 - 4]                                                             |         rax = r8 - 4;
    0x004caa6a mov rbp, rax                                                                  |         
    0x004caa6d shr rbp, 2                                                                    |         rbp >>= 2;
    0x004caa71 inc rbp                                                                       |         rbp++;
    0x004caa74 mov edi, ebp                                                                  |         edi = ebp;
    0x004caa76 and edi, 3                                                                    |         edi &= 3;
    0x004caa79 cmp rax, 0xc                                                                  |         
                                                                                             |         if (rax >= 0xc) {
    0x004caa7d jae 0x4cacd6                                                                  |             goto label_31;
                                                                                             |         }
    0x004caa83 xor ebx, ebx                                                                  |         ebx = 0;
    0x004caa85 jmp 0x4cad85                                                                  |         goto label_32;
                                                                                             | label_27:
    0x004caa90 cmp qword [rip + 0x24dd88], 0                                                 |         
    0x004caa98 mov ebp, r14d                                                                 |         
    0x004caa9b mov r11, r12                                                                  |         r11 = r12;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004caa9e jne 0x4caac0                                                                  |             
    0x004caaa0 mov rax, qword [rip + 0x286811]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004caaa7 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004caaaa jne 0x4caac0                                                                  |                 goto label_33;
                                                                                             |             }
    0x004caaac call 0x4eec50                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004caab1 mov r11, r12                                                                  |             r11 = r12;
    0x004caab4 nop word cs:[rax + rax]                                                       |             
    0x004caabe nop                                                                           |             
                                                                                             |         }
                                                                                             | label_33:
    0x004caac0 mov r12, qword [rsp + 0x18]                                                   |         r12 = *((rsp + 0x18));
    0x004caac5 cmp r12, 6                                                                    |         
                                                                                             |         if (r12 < 6) {
    0x004caac9 jb 0x4cae40                                                                   |             goto label_34;
                                                                                             |         }
    0x004caacf lea rax, [r15*8 + 0x74f8e0]                                                   |         rax = r15*8 + obj_testCopyConstructWithIterators_int_const__bool__bool__bool_::u;
    0x004caad7 lea rcx, [rsp + r13 + 0x20]                                                   |         rcx = rsp + r13 + 0x20;
    0x004caadc add r11, r13                                                                  |         r11 += r13;
    0x004caadf mov r9, r11                                                                   |         r9 = r11;
    0x004caae2 sub r9, r13                                                                   |         r9 -= r13;
    0x004caae5 cmp r9, 4                                                                     |         
                                                                                             |         if (r9 < 4) {
    0x004caae9 jb 0x4cacaa                                                                   |             goto label_35;
                                                                                             |         }
    0x004caaef mov r10, rbx                                                                  |         r10 = rbx;
    0x004caaf2 mov r8, r9                                                                    |         r8 = r9;
    0x004caaf5 and r8, 0xfffffffffffffffc                                                    |         r8 &= 0xfffffffffffffffc;
    0x004caaf9 lea rsi, [r8 - 4]                                                             |         rsi = r8 - 4;
    0x004caafd mov rdi, rsi                                                                  |         rdi = rsi;
    0x004cab00 shr rdi, 2                                                                    |         rdi >>= 2;
    0x004cab04 inc rdi                                                                       |         rdi++;
    0x004cab07 mov ebp, edi                                                                  |         
    0x004cab09 and ebp, 3                                                                    |         ebp &= 3;
    0x004cab0c cmp rsi, 0xc                                                                  |         
                                                                                             |         if (rsi >= 0xc) {
    0x004cab10 jae 0x4cab9d                                                                  |             goto label_36;
                                                                                             |         }
    0x004cab16 xor ebx, ebx                                                                  |         ebx = 0;
    0x004cab18 jmp 0x4cac45                                                                  |         goto label_37;
    0x004cab1d mov eax, 1                                                                    |         eax = 1;
    0x004cab22 mov qword [rsp + 0x40], rax                                                   |         *((rsp + 0x40)) = rax;
    0x004cab27 mov rax, qword [rip + 0x28678a]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004cab2e test rax, rax                                                                 |         
    0x004cab31 jne 0x4caa2b                                                                  |         
                                                                                             |     }
    0x004cab37 call 0x4eec50                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004cab3c jmp 0x4caa2b                                                                  |     goto label_3;
                                                                                             | label_36:
    0x004cab9d lea rdx, [rsp + 0x2e]                                                         |     rdx = rsp + 0x2e;
    0x004caba2 lea rsi, [rdx + r13]                                                          |     rsi = rdx + r13;
    0x004caba6 and rdi, 0xfffffffffffffffc                                                   |     rdi &= 0xfffffffffffffffc;
    0x004cabaa neg rdi                                                                       |     rdi = -rdi;
    0x004cabad xor ebx, ebx                                                                  |     ebx = 0;
    0x004cabaf nop                                                                           |     
                                                                                             |     do {
    0x004cabb0 pmovsxbq xmm0, word [rsi + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xe]");
    0x004cabb7 pmovsxbq xmm1, word [rsi + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 0xc]");
    0x004cabbe lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004cabc6 movdqu xmmword [rdx + rbx*8 + 0x74f8e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004cabcf movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1");
    0x004cabd8 pmovsxbq xmm0, word [rsi + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 0xa]");
    0x004cabdf pmovsxbq xmm1, word [rsi + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 8]");
    0x004cabe6 movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0");
    0x004cabef movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1");
    0x004cabf8 pmovsxbq xmm0, word [rsi + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 6]");
    0x004cabff pmovsxbq xmm1, word [rsi + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rsi + rbx - 4]");
    0x004cac06 movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0");
    0x004cac0f movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1");
    0x004cac18 pmovsxbq xmm0, word [rsi + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rsi + rbx - 2]");
    0x004cac1f pmovsxbq xmm1, word [rsi + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rsi + rbx]");
    0x004cac25 movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0");
    0x004cac2e movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1");
    0x004cac37 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004cac3b add rdi, 4                                                                    |         rdi += 4;
    0x004cac3f jne 0x4cabb0                                                                  |         
                                                                                             |     } while (rdi != 0);
                                                                                             | label_37:
    0x004cac45 test rbp, rbp                                                                 |     
                                                                                             |     if (rbp == 0) {
    0x004cac48 je 0x4cac94                                                                   |         goto label_38;
                                                                                             |     }
    0x004cac4a add r13, rbx                                                                  |     r13 += rbx;
    0x004cac4d lea rdx, [rsp + 0x22]                                                         |     rdx = rsp + 0x22;
    0x004cac52 add r13, rdx                                                                  |     r13 += rdx;
    0x004cac55 shl r15, 3                                                                    |     r15 <<= 3;
    0x004cac59 lea rsi, [r15 + rbx*8 + 0x74f8f0]                                             |     rsi = r15 + rbx*8 + 0x74f8f0;
    0x004cac61 shl rbp, 2                                                                    |     rbp <<= 2;
    0x004cac65 xor edi, edi                                                                  |     edi = 0;
    0x004cac67 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004cac70 pmovsxbq xmm0, word [r13 + rdi - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rdi - 2]");
    0x004cac78 pmovsxbq xmm1, word [r13 + rdi]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rdi]");
    0x004cac80 movdqu xmmword [rsi + rdi*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rsi + rdi*8 - 0x10], xmm0");
    0x004cac86 movdqu xmmword [rsi + rdi*8], xmm1                                            |         __asm ("movdqu xmmword [rsi + rdi*8], xmm1");
    0x004cac8b add rdi, 4                                                                    |         rdi += 4;
    0x004cac8f cmp rbp, rdi                                                                  |         
    0x004cac92 jne 0x4cac70                                                                  |         
                                                                                             |     } while (rbp != rdi);
                                                                                             | label_38:
    0x004cac94 cmp r9, r8                                                                    |     
    0x004cac97 mov rbx, r10                                                                  |     rbx = r10;
    0x004cac9a mov ebp, r14d                                                                 |     
                                                                                             |     if (r9 == r8) {
    0x004cac9d je 0x4cae40                                                                   |         goto label_34;
                                                                                             |     }
    0x004caca3 add rcx, r8                                                                   |     rcx += r8;
    0x004caca6 lea rax, [rax + r8*8]                                                         |     rax = rax + r8*8;
                                                                                             | label_35:
    0x004cacaa sub r11, rcx                                                                  |     r11 -= rcx;
    0x004cacad lea rdx, [rsp + r11 + 0x20]                                                   |     rdx = rsp + r11 + 0x20;
    0x004cacb2 xor esi, esi                                                                  |     esi = 0;
    0x004cacb4 nop word cs:[rax + rax]                                                       |     
    0x004cacbe nop                                                                           |     
                                                                                             |     do {
    0x004cacc0 movsx rdi, byte [rcx + rsi]                                                   |         rdi = *((rcx + rsi));
    0x004cacc5 mov qword [rax + rsi*8], rdi                                                  |         *((rax + rsi*8)) = rdi;
    0x004cacc9 inc rsi                                                                       |         rsi++;
    0x004caccc cmp rdx, rsi                                                                  |         
    0x004caccf jne 0x4cacc0                                                                  |         
                                                                                             |     } while (rdx != rsi);
    0x004cacd1 jmp 0x4cae40                                                                  |     goto label_34;
                                                                                             | label_31:
    0x004cacd6 lea rax, [rsp + 0x2e]                                                         |     rax = rsp + 0x2e;
    0x004cacdb add rax, r13                                                                  |     rax += r13;
    0x004cacde and rbp, 0xfffffffffffffffc                                                   |     rbp &= 0xfffffffffffffffc;
    0x004cace2 neg rbp                                                                       |     rbp = -rbp;
    0x004cace5 xor ebx, ebx                                                                  |     ebx = 0;
    0x004cace7 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004cacf0 pmovsxbq xmm0, word [rax + rbx - 0xe]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xe]");
    0x004cacf7 pmovsxbq xmm1, word [rax + rbx - 0xc]                                         |         __asm ("pmovsxbq xmm1, word [rax + rbx - 0xc]");
    0x004cacfe lea rdx, [r15*8]                                                              |         rdx = r15*8;
    0x004cad06 movdqu xmmword [rdx + rbx*8 + 0x74f8e0], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + obj.testCopyConstructWithIterators_int_const__bool__bool__bool_::u], xmm0");
    0x004cad0f movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f8f0], xmm1");
    0x004cad18 pmovsxbq xmm0, word [rax + rbx - 0xa]                                         |         __asm ("pmovsxbq xmm0, word [rax + rbx - 0xa]");
    0x004cad1f pmovsxbq xmm1, word [rax + rbx - 8]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 8]");
    0x004cad26 movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f900], xmm0");
    0x004cad2f movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f910], xmm1");
    0x004cad38 pmovsxbq xmm0, word [rax + rbx - 6]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 6]");
    0x004cad3f pmovsxbq xmm1, word [rax + rbx - 4]                                           |         __asm ("pmovsxbq xmm1, word [rax + rbx - 4]");
    0x004cad46 movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f920], xmm0");
    0x004cad4f movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f930], xmm1");
    0x004cad58 pmovsxbq xmm0, word [rax + rbx - 2]                                           |         __asm ("pmovsxbq xmm0, word [rax + rbx - 2]");
    0x004cad5f pmovsxbq xmm1, word [rax + rbx]                                               |         __asm ("pmovsxbq xmm1, word [rax + rbx]");
    0x004cad65 movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f940], xmm0");
    0x004cad6e movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1                                 |         __asm ("movdqu xmmword [rdx + rbx*8 + 0x74f950], xmm1");
    0x004cad77 add rbx, 0x10                                                                 |         rbx += 0x10;
    0x004cad7b add rbp, 4                                                                    |         rbp += 4;
    0x004cad7f jne 0x4cacf0                                                                  |         
                                                                                             |     } while (rbp != 0);
                                                                                             | label_32:
    0x004cad85 test rdi, rdi                                                                 |     
                                                                                             |     if (rdi == 0) {
    0x004cad88 je 0x4cadd4                                                                   |         goto label_39;
                                                                                             |     }
    0x004cad8a add r13, rbx                                                                  |     r13 += rbx;
    0x004cad8d lea rax, [rsp + 0x22]                                                         |     rax = rsp + 0x22;
    0x004cad92 add r13, rax                                                                  |     r13 += rax;
    0x004cad95 shl r15, 3                                                                    |     r15 <<= 3;
    0x004cad99 lea rax, [r15 + rbx*8 + 0x74f8f0]                                             |     rax = r15 + rbx*8 + 0x74f8f0;
    0x004cada1 shl rdi, 2                                                                    |     rdi <<= 2;
    0x004cada5 xor ebp, ebp                                                                  |     ebp = 0;
    0x004cada7 nop word [rax + rax]                                                          |     
                                                                                             |     do {
    0x004cadb0 pmovsxbq xmm0, word [r13 + rbp - 2]                                           |         __asm ("pmovsxbq xmm0, word [r13 + rbp - 2]");
    0x004cadb8 pmovsxbq xmm1, word [r13 + rbp]                                               |         __asm ("pmovsxbq xmm1, word [r13 + rbp]");
    0x004cadc0 movdqu xmmword [rax + rbp*8 - 0x10], xmm0                                     |         __asm ("movdqu xmmword [rax + rbp*8 - 0x10], xmm0");
    0x004cadc6 movdqu xmmword [rax + rbp*8], xmm1                                            |         __asm ("movdqu xmmword [rax + rbp*8], xmm1");
    0x004cadcb add rbp, 4                                                                    |         rbp += 4;
    0x004cadcf cmp rdi, rbp                                                                  |         
    0x004cadd2 jne 0x4cadb0                                                                  |         
                                                                                             |     } while (rdi != rbp);
                                                                                             | label_39:
    0x004cadd4 cmp r10, r8                                                                   |     
    0x004cadd7 mov rbx, r11                                                                  |     rbx = r11;
    0x004cadda mov ebp, r14d                                                                 |     
                                                                                             |     if (r10 == r8) {
    0x004caddd je 0x4cae01                                                                   |         goto label_29;
                                                                                             |     }
    0x004caddf add rcx, r8                                                                   |     rcx += r8;
    0x004cade2 lea rsi, [rsi + r8*8]                                                         |     rsi = rsi + r8*8;
                                                                                             | label_30:
    0x004cade6 sub r9, rcx                                                                   |     r9 -= rcx;
    0x004cade9 lea rax, [rsp + r9 + 0x20]                                                    |     rax = rsp + r9 + 0x20;
    0x004cadee xor edi, edi                                                                  |     edi = 0;
                                                                                             |     do {
    0x004cadf0 movsx rdx, byte [rcx + rdi]                                                   |         rdx = *((rcx + rdi));
    0x004cadf5 mov qword [rsi + rdi*8], rdx                                                  |         *((rsi + rdi*8)) = rdx;
    0x004cadf9 inc rdi                                                                       |         rdi++;
    0x004cadfc cmp rax, rdi                                                                  |         
    0x004cadff jne 0x4cadf0                                                                  |         
                                                                                             |     } while (rax != rdi);
                                                                                             | label_29:
    0x004cae01 mov rax, qword [rsp + 0x58]                                                   |     rax = *((rsp + 0x58));
    0x004cae06 lea rdi, [rsp + 0x58]                                                         |     rdi = rsp + 0x58;
    0x004cae0b mov rsi, 0xffffffffffffffff                                                   |     rsi = 0xffffffffffffffff;
    0x004cae12 call qword [rax + 0x10]                                                       |     uint64_t (*rax + 0x10)() ();
    0x004cae15 cmp byte [rip + 0x24db79], 0                                                  |     
    0x004cae1c mov r12, qword [rsp + 0x18]                                                   |     r12 = *((rsp + 0x18));
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004cae21 je 0x4cae2d                                                                   |         
    0x004cae23 mov edi, 0x4f43e1                                                             |         
    0x004cae28 call 0x401710                                                                 |         puts ("\t\tEnd bslma exception test.");
                                                                                             |     }
    0x004cae2d cmp byte [rip + 0x24db5c], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004cae34 je 0x4cae6b                                                                   |         
    0x004cae36 mov edi, 0xa                                                                  |         
    0x004cae3b call 0x401720                                                                 |         eax = putchar (0xa);
                                                                                             | label_34:
    0x004cae40 cmp byte [rip + 0x24db49], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004cae47 je 0x4cae6b                                                                   |             goto label_40;
                                                                                             |         }
    0x004cae49 mov edx, dword [rip + 0x24db55]                                               |         edx = numCopyCtorCalls;
    0x004cae4f sub edx, dword [rsp + 0x14]                                                   |         edx -= *((rsp + 0x14));
    0x004cae53 mov ecx, dword [rip + 0x24db53]                                               |         ecx = numCharCtorCalls;
    0x004cae59 sub ecx, dword [rsp + 0x48]                                                   |         ecx -= *((rsp + 0x48));
    0x004cae5d mov edi, 0x4f5c2a                                                             |         
    0x004cae62 mov esi, ebp                                                                  |         esi = ebp;
    0x004cae64 xor eax, eax                                                                  |         eax = 0;
    0x004cae66 call 0x401680                                                                 |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_40:
    0x004cae6b mov eax, dword [rsp + 0x14]                                                   |     eax = *((rsp + 0x14));
    0x004cae6f cmp eax, dword [rip + 0x24db2f]                                               |     
                                                                                             |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004cae75 je 0x4ca860                                                                   |         goto label_4;
                                                                                             |     }
    0x004cae7b mov edi, 0x4f4c78                                                             |     
    0x004cae80 mov edx, 0x4f4fec                                                             |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004cae85 mov esi, 0x103f                                                               |     esi = 0x103f;
    0x004cae8a xor eax, eax                                                                  |     eax = 0;
    0x004cae8c call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004cae91 mov eax, dword [rip + 0x24db01]                                               |     eax = (anonymous namespace)::testStatus;
    0x004cae97 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004cae9a ja 0x4ca860                                                                   |         goto label_4;
                                                                                             |     }
    0x004caea0 inc eax                                                                       |     eax++;
    0x004caea2 mov dword [rip + 0x24daf0], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004caea8 jmp 0x4ca860                                                                  |     goto label_4;
                                                                                             | label_23:
    0x004caead add rsp, 0x68                                                                 |     
    0x004caeb1 pop rbx                                                                       |     
    0x004caeb2 pop r12                                                                       |     
    0x004caeb4 pop r13                                                                       |     
    0x004caeb6 pop r14                                                                       |     
    0x004caeb8 pop r15                                                                       |     
    0x004caeba pop rbp                                                                       |     
    0x004caebb ret                                                                           |     return rax;
                                                                                             | }