; assembly                                                                           | /* r2dec pseudo code output */
                                                                                         | /* bslalg_arrayprimitives.t/assume @ 0x4c5d90 */
                                                                                         | #include <stdint.h>
                                                                                         |  
    ; (fcn) sym.void_testCopyConstructWithIterators_float__bool__bool__bool_ ()          | uint64_t void_testCopyConstructWithIterators_float_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                         |     int64_t var_10h;
                                                                                         |     uint32_t var_18h;
                                                                                         |     int64_t var_20h;
                                                                                         |     int64_t var_28h;
                                                                                         |     int64_t var_2ch;
                                                                                         |     int64_t var_30h;
                                                                                         |     uint32_t var_3ch;
                                                                                         |     uint32_t var_40h;
                                                                                         |     uint32_t var_4ch;
                                                                                         |     int64_t var_50h;
                                                                                         |     int64_t var_58h;
                                                                                         |     int64_t var_60h;
                                                                                         |     rdx = arg3;
                                                                                         |     rsi = arg2;
                                                                                         |     /* void testCopyConstructWithIterators<float>(bool, bool, bool) */
    0x004c5d90 push rbp                                                                  |     
    0x004c5d91 push r15                                                                  |     
    0x004c5d93 push r14                                                                  |     
    0x004c5d95 push r13                                                                  |     
    0x004c5d97 push r12                                                                  |     
    0x004c5d99 push rbx                                                                  |     
    0x004c5d9a sub rsp, 0x68                                                             |     
    0x004c5d9e mov dword [rsp + 0x3c], edx                                               |     *((rsp + 0x3c)) = edx;
    0x004c5da2 mov dword [rsp + 0x4c], esi                                               |     *((rsp + 0x4c)) = esi;
    0x004c5da6 cmp byte [rip + 0x252be9], 0                                              |     
                                                                                         |     if (*(obj.verbose) != 0) {
    0x004c5dad je 0x4c5db9                                                               |         
    0x004c5daf mov edi, 0x4f67e9                                                         |         
    0x004c5db4 call 0x401710                                                             |         eax = puts ("\t\tfrom same type.");
                                                                                         |     }
    0x004c5db9 xor eax, eax                                                              |     eax = 0;
    0x004c5dbb jmp 0x4c5dec                                                              |     goto label_8;
                                                                                         | label_1:
    0x004c5dc0 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5dc5 mov rsi, rbx                                                              |     rsi = rbx;
    0x004c5dc8 call 0x4e0fa0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c5dcd mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5dd2 mov rsi, rbx                                                              |     rsi = rbx;
    0x004c5dd5 call 0x4e11f0                                                             |     voidcleanup<float>(float*,char const*) ();
    0x004c5dda mov rax, qword [rsp + 0x40]                                               |     rax = *((rsp + 0x40));
    0x004c5ddf inc rax                                                                   |     rax++;
    0x004c5de2 cmp rax, 0x1e                                                             |     
                                                                                         |     if (rax == 0x1e) {
    0x004c5de6 je 0x4c6309                                                               |         goto label_9;
                                                                                         |     }
                                                                                         | label_8:
    0x004c5dec mov qword [rsp + 0x40], rax                                               |     *((rsp + 0x40)) = rax;
    0x004c5df1 lea rbx, [rax*8]                                                          |     rbx = rax*8;
    0x004c5df9 mov r12, qword [rbx + rbx*4 + 0x4f3b08]                                   |     r12 = *((rbx + rbx*4 + 0x4f3b08));
    0x004c5e01 mov rdi, r12                                                              |     
    0x004c5e04 call 0x401790                                                             |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004c5e09 cmp eax, 0x11                                                             |     
                                                                                         |     if (eax >= 0x11) {
    0x004c5e0c jl 0x4c5e37                                                               |         
    0x004c5e0e mov edi, 0x4f4c78                                                         |         
    0x004c5e13 mov edx, 0x4f4203                                                         |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c5e18 mov esi, 0xfe6                                                            |         esi = 0xfe6;
    0x004c5e1d xor eax, eax                                                              |         eax = 0;
    0x004c5e1f call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c5e24 mov eax, dword [rip + 0x252b6e]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c5e2a cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c5e2d ja 0x4c5e37                                                               |             goto label_10;
                                                                                         |         }
    0x004c5e2f inc eax                                                                   |         eax++;
    0x004c5e31 mov dword [rip + 0x252b61], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_10:
    0x004c5e37 mov r13d, dword [rbx + rbx*4 + 0x4f3b00]                                  |     r13d = *((rbx + rbx*4 + obj.DATA_3));
    0x004c5e3f movsxd r15, dword [rbx + rbx*4 + 0x4f3b10]                                |     r15 = *((rbx + rbx*4 + 0x4f3b10));
    0x004c5e47 mov ebp, dword [rbx + rbx*4 + 0x4f3b14]                                   |     ebp = *((rbx + rbx*4 + 0x4f3b14));
    0x004c5e4e movsxd r14, dword [rbx + rbx*4 + 0x4f3b18]                                |     r14 = *((rbx + rbx*4 + 0x4f3b18));
    0x004c5e56 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                   |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004c5e5e cmp byte [rip + 0x252b2b], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c5e65 je 0x4c5e86                                                               |         
    0x004c5e67 mov qword [rsp], rbx                                                      |         *(rsp) = rbx;
    0x004c5e6b mov edi, 0x4f5ab7                                                         |         
    0x004c5e70 mov esi, r13d                                                             |         esi = r13d;
    0x004c5e73 mov rdx, r12                                                              |         rdx = r12;
    0x004c5e76 mov ecx, r15d                                                             |         ecx = r15d;
    0x004c5e79 mov r8d, ebp                                                              |         r8d = ebp;
    0x004c5e7c mov r9d, r14d                                                             |         r9d = r14d;
    0x004c5e7f xor eax, eax                                                              |         eax = 0;
    0x004c5e81 call 0x401680                                                             |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                         |     }
    0x004c5e86 mov qword [rsp + 0x10], rbp                                               |     *((rsp + 0x10)) = rbp;
    0x004c5e8b mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5e90 mov rsi, r12                                                              |     rsi = r12;
    0x004c5e93 call 0x4e0eb0                                                             |     float&gg<float>(float*,char const*) ();
    0x004c5e98 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5e9d mov rsi, r12                                                              |     rsi = r12;
    0x004c5ea0 call 0x4e0fa0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c5ea5 mov r12d, dword [rip + 0x252af8]                                          |     r12d = numCopyCtorCalls;
    0x004c5eac mov eax, dword [rip + 0x252afa]                                           |     eax = numCharCtorCalls;
    0x004c5eb2 mov dword [rsp + 0x18], eax                                               |     *((rsp + 0x18)) = eax;
    0x004c5eb6 cmp byte [rsp + 0x3c], 0                                                  |     
                                                                                         |     if (*((rsp + 0x3c)) == 0) {
    0x004c5ebb je 0x4c5fa0                                                               |         goto label_11;
                                                                                         |     }
    0x004c5ec1 cmp byte [rip + 0x252ac8], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c5ec8 je 0x4c5edd                                                               |         
    0x004c5eca cmp dword [rip + 0x25269f], 0                                             |         
                                                                                         |         if (*(obj.testCopyConstructWithIterators_float__bool__bool__bool_::firstTime) == 0) {
    0x004c5ed1 je 0x4c5edd                                                               |             goto label_12;
                                                                                         |         }
    0x004c5ed3 mov edi, 0x4f425a                                                         |         
    0x004c5ed8 call 0x401710                                                             |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                         |     }
                                                                                         | label_12:
    0x004c5edd mov dword [rip + 0x252689], 0                                             |     *(obj.testCopyConstructWithIterators_float__bool__bool__bool_::firstTime) = 0;
    0x004c5ee7 cmp byte [rip + 0x252aa7], 0                                              |     
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c5eee je 0x4c5efa                                                               |         
    0x004c5ef0 mov edi, 0x4f4281                                                         |         
    0x004c5ef5 call 0x401710                                                             |         puts ("\t\tBegin bslma exception test.");
                                                                                         |     }
    0x004c5efa mov rax, qword [rip + 0x25291f]                                           |     rax = Z;
    0x004c5f01 mov qword [rsp + 0x20], 0x4f6858                                          |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c5f0a mov qword [rsp + 0x28], rax                                               |     *((rsp + 0x28)) = rax;
    0x004c5f0f mov qword [rax + 0x20], 0                                                 |     *((rax + 0x20)) = 0;
    0x004c5f17 test rax, rax                                                             |     
    0x004c5f1a je 0x4c604f                                                               |     
                                                                                         |     while (rax != 0) {
                                                                                         | label_0:
    0x004c5f20 lea rsi, [r15*4 + 0x74f5a0]                                               |         rsi = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c5f28 mov rax, qword [rsp + 0x10]                                               |         rax = *((rsp + 0x10));
    0x004c5f2d add eax, r15d                                                             |         eax += r15d;
    0x004c5f30 cdqe                                                                      |         rax = (int64_t) eax;
    0x004c5f32 lea rdx, [rax*4 + 0x74f5a0]                                               |         rdx = rax*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c5f3a sub rdx, rsi                                                              |         rdx -= rsi;
                                                                                         |         if (rdx != 0) {
    0x004c5f3d je 0x4c5f4c                                                               |             
    0x004c5f3f lea rdi, [r14*4 + 0x74f5a0]                                               |             
    0x004c5f47 call 0x401930                                                             |             memcpy (r14*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u, rsi, rdx);
                                                                                         |         }
    0x004c5f4c mov rax, qword [rsp + 0x20]                                               |         rax = *((rsp + 0x20));
    0x004c5f51 lea rdi, [rsp + 0x20]                                                     |         rdi = rsp + 0x20;
    0x004c5f56 mov rsi, 0xffffffffffffffff                                               |         rsi = 0xffffffffffffffff;
    0x004c5f5d call qword [rax + 0x10]                                                   |         uint64_t (*rax + 0x10)() ();
    0x004c5f60 cmp byte [rip + 0x252a2e], 0                                              |         
                                                                                         |         if (*(obj.veryVeryVerbose) != 0) {
    0x004c5f67 je 0x4c5f73                                                               |             
    0x004c5f69 mov edi, 0x4f43e1                                                         |             
    0x004c5f6e call 0x401710                                                             |             puts ("\t\tEnd bslma exception test.");
                                                                                         |         }
    0x004c5f73 cmp byte [rip + 0x252a16], 0                                              |         
                                                                                         |         if (*(obj.veryVerbose) == 0) {
    0x004c5f7a je 0x4c622d                                                               |             goto label_13;
                                                                                         |         }
    0x004c5f80 mov edi, 0xa                                                              |         
    0x004c5f85 call 0x401720                                                             |         putchar (0xa);
    0x004c5f8a mov ebp, r13d                                                             |         
    0x004c5f8d jmp 0x4c6203                                                              |         goto label_14;
                                                                                         | label_11:
    0x004c5fa0 cmp qword [rip + 0x252878], 0                                             |         
                                                                                         |         if (*(obj.Z) == 0) {
    0x004c5fa8 jne 0x4c5fc0                                                              |             
    0x004c5faa mov rax, qword [rip + 0x28b307]                                           |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c5fb1 test rax, rax                                                             |             
                                                                                         |             if (rax != 0) {
    0x004c5fb4 jne 0x4c5fc0                                                              |                 goto label_15;
                                                                                         |             }
    0x004c5fb6 call 0x4eec50                                                             |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c5fbb nop dword [rax + rax]                                                     |             
                                                                                         |         }
                                                                                         | label_15:
    0x004c5fc0 cmp qword [rsp + 0x40], 6                                                 |         
    0x004c5fc6 mov ebp, r13d                                                             |         
                                                                                         |         if (*((rsp + 0x40)) < 6) {
    0x004c5fc9 jb 0x4c6203                                                               |             goto label_14;
                                                                                         |         }
    0x004c5fcf lea rax, [r15*4 + 0x74f5a0]                                               |         rax = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c5fd7 lea rcx, [r14*4 + 0x74f5a0]                                               |         rcx = r14*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c5fdf mov rsi, qword [rsp + 0x10]                                               |         rsi = *((rsp + 0x10));
    0x004c5fe4 lea edx, [rsi + r15]                                                      |         edx = rsi + r15;
    0x004c5fe8 movsxd r9, edx                                                            |         r9 = (int64_t) edx;
    0x004c5feb shl r9, 2                                                                 |         r9 <<= 2;
    0x004c5fef lea rdi, [r15*4]                                                          |         rdi = r15*4;
    0x004c5ff7 mov r10, r9                                                               |         r10 = r9;
    0x004c5ffa sub r10, rdi                                                              |         r10 -= rdi;
    0x004c5ffd add r10, 0xfffffffffffffffc                                               |         r10 += 0xfffffffffffffffc;
    0x004c6001 cmp r10, 0x1c                                                             |         
                                                                                         |         if (r10 < 0x1c) {
    0x004c6005 jb 0x4c61e0                                                               |             goto label_16;
                                                                                         |         }
    0x004c600b lea r8, [r14*4 + 0x74f5a0]                                                |         r8 = r14*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6013 lea edx, [rsi + r15]                                                      |         edx = rsi + r15;
    0x004c6017 movsxd rdx, edx                                                           |         rdx = (int64_t) edx;
    0x004c601a lea rbp, [rdx*4 + 0x74f5a0]                                               |         rbp = rdx*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6022 cmp r8, rbp                                                               |         
                                                                                         |         if (r8 >= rbp) {
    0x004c6025 jae 0x4c60c1                                                              |             goto label_17;
                                                                                         |         }
    0x004c602b shl rdx, 2                                                                |         rdx <<= 2;
    0x004c602f sub rdx, rdi                                                              |         rdx -= rdi;
    0x004c6032 lea rdx, [rdx + r14*4 + 0x74f5a0]                                         |         rdx = rdx + r14*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c603a lea rsi, [r15*4 + 0x74f5a0]                                               |         rsi = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6042 cmp rsi, rdx                                                              |         
                                                                                         |         if (rsi >= rdx) {
    0x004c6045 jae 0x4c60c1                                                              |             goto label_17;
                                                                                         |         }
    0x004c6047 mov ebp, r13d                                                             |         
    0x004c604a jmp 0x4c61e0                                                              |         goto label_16;
    0x004c604f mov ebp, 1                                                                |         
    0x004c6054 mov rax, qword [rip + 0x28b25d]                                           |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c605b test rax, rax                                                             |         
    0x004c605e jne 0x4c5f20                                                              |         
                                                                                         |     }
    0x004c6064 call 0x4eec50                                                             |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c6069 jmp 0x4c5f20                                                              |     goto label_0;
                                                                                         | label_17:
    0x004c60c1 mov qword [rsp + 0x60], rbx                                               |     *((rsp + 0x60)) = rbx;
    0x004c60c6 shr r10, 2                                                                |     r10 >>= 2;
    0x004c60ca inc r10                                                                   |     r10++;
    0x004c60cd mov r8, r10                                                               |     r8 = r10;
    0x004c60d0 and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c60d4 lea rsi, [r8 - 8]                                                         |     rsi = r8 - 8;
    0x004c60d8 mov rbx, rsi                                                              |     rbx = rsi;
    0x004c60db shr rbx, 3                                                                |     rbx >>= 3;
    0x004c60df inc rbx                                                                   |     rbx++;
    0x004c60e2 mov edx, ebx                                                              |     edx = ebx;
    0x004c60e4 and edx, 3                                                                |     edx &= 3;
    0x004c60e7 cmp rsi, 0x18                                                             |     
                                                                                         |     if (rsi < 0x18) {
    0x004c60eb jae 0x4c60f4                                                              |         
    0x004c60ed xor ebp, ebp                                                              |         ebp = 0;
    0x004c60ef jmp 0x4c617c                                                              |         goto label_18;
                                                                                         |     }
    0x004c60f4 and rbx, 0xfffffffffffffffc                                               |     rbx &= 0xfffffffffffffffc;
    0x004c60f8 neg rbx                                                                   |     rbx = -rbx;
    0x004c60fb mov esi, 0x74f5a0                                                         |     esi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6100 xor ebp, ebp                                                              |     ebp = 0;
    0x004c6102 nop word cs:[rax + rax]                                                   |     
    0x004c610c nop dword [rax]                                                           |     
                                                                                         |     do {
    0x004c6110 movups xmm0, xmmword [rsi + r15*4]                                        |         __asm ("movups xmm0, xmmword [rsi + r15*4]");
    0x004c6115 movups xmm1, xmmword [rsi + r15*4 + 0x10]                                 |         __asm ("movups xmm1, xmmword [rsi + r15*4 + 0x10]");
    0x004c611b movups xmmword [rsi + r14*4], xmm0                                        |         __asm ("movups xmmword [rsi + r14*4], xmm0");
    0x004c6120 movups xmmword [rsi + r14*4 + 0x10], xmm1                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x10], xmm1");
    0x004c6126 movups xmm0, xmmword [rsi + r15*4 + 0x20]                                 |         __asm ("movups xmm0, xmmword [rsi + r15*4 + 0x20]");
    0x004c612c movups xmm1, xmmword [rsi + r15*4 + 0x30]                                 |         __asm ("movups xmm1, xmmword [rsi + r15*4 + 0x30]");
    0x004c6132 movups xmmword [rsi + r14*4 + 0x20], xmm0                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x20], xmm0");
    0x004c6138 movups xmmword [rsi + r14*4 + 0x30], xmm1                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x30], xmm1");
    0x004c613e movups xmm0, xmmword [rsi + r15*4 + 0x40]                                 |         __asm ("movups xmm0, xmmword [rsi + r15*4 + 0x40]");
    0x004c6144 movups xmm1, xmmword [rsi + r15*4 + 0x50]                                 |         __asm ("movups xmm1, xmmword [rsi + r15*4 + 0x50]");
    0x004c614a movups xmmword [rsi + r14*4 + 0x40], xmm0                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x40], xmm0");
    0x004c6150 movups xmmword [rsi + r14*4 + 0x50], xmm1                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x50], xmm1");
    0x004c6156 movups xmm0, xmmword [rsi + r15*4 + 0x60]                                 |         __asm ("movups xmm0, xmmword [rsi + r15*4 + 0x60]");
    0x004c615c movups xmm1, xmmword [rsi + r15*4 + 0x70]                                 |         __asm ("movups xmm1, xmmword [rsi + r15*4 + 0x70]");
    0x004c6162 movups xmmword [rsi + r14*4 + 0x60], xmm0                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x60], xmm0");
    0x004c6168 movups xmmword [rsi + r14*4 + 0x70], xmm1                                 |         __asm ("movups xmmword [rsi + r14*4 + 0x70], xmm1");
    0x004c616e add rbp, 0x20                                                             |         rbp += 0x20;
    0x004c6172 sub rsi, 0xffffffffffffff80                                               |         rsi -= 0xffffffffffffff80;
    0x004c6176 add rbx, 4                                                                |         rbx += 4;
    0x004c617a jne 0x4c6110                                                              |         
                                                                                         |     } while (rbx != 0);
                                                                                         | label_18:
    0x004c617c test rdx, rdx                                                             |     
                                                                                         |     if (rdx == 0) {
    0x004c617f je 0x4c61bf                                                               |         goto label_19;
                                                                                         |     }
    0x004c6181 shl r14, 2                                                                |     r14 <<= 2;
    0x004c6185 lea rsi, [rbp*4 + 0x74f5a0]                                               |     rsi = rbp*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c618d neg rdx                                                                   |     rdx = -rdx;
                                                                                         |     do {
    0x004c6190 movups xmm0, xmmword [rdi + rbp*4 + 0x74f5a0]                             |         __asm ("movups xmm0, xmmword [rdi + rbp*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u]");
    0x004c6198 movups xmm1, xmmword [rdi + rbp*4 + 0x74f5b0]                             |         __asm ("movups xmm1, xmmword [rdi + rbp*4 + 0x74f5b0]");
    0x004c61a0 movups xmmword [r14 + rbp*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [r14 + rbp*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c61a9 movups xmmword [r14 + rbp*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [r14 + rbp*4 + 0x74f5b0], xmm1");
    0x004c61b2 add rbp, 8                                                                |         rbp += 8;
    0x004c61b6 add rsi, 0x20                                                             |         rsi += 0x20;
    0x004c61ba inc rdx                                                                   |         rdx++;
    0x004c61bd jne 0x4c6190                                                              |         
                                                                                         |     } while (rdx != 0);
                                                                                         | label_19:
    0x004c61bf cmp r10, r8                                                               |     
    0x004c61c2 mov rbx, qword [rsp + 0x60]                                               |     rbx = *((rsp + 0x60));
    0x004c61c7 mov ebp, r13d                                                             |     
                                                                                         |     if (r10 == r8) {
    0x004c61ca je 0x4c6203                                                               |         goto label_14;
                                                                                         |     }
    0x004c61cc lea rax, [rax + r8*4]                                                     |     rax = rax + r8*4;
    0x004c61d0 lea rcx, [rcx + r8*4]                                                     |     rcx = rcx + r8*4;
    0x004c61d4 nop word cs:[rax + rax]                                                   |     
    0x004c61de nop                                                                       |     
                                                                                         | label_16:
    0x004c61e0 sub r9, rax                                                               |     r9 -= rax;
    0x004c61e3 lea rdx, [r9 + 0x74f5a0]                                                  |     rdx = r9 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c61ea xor esi, esi                                                              |     esi = 0;
    0x004c61ec nop dword [rax]                                                           |     
                                                                                         |     do {
    0x004c61f0 movss xmm0, dword [rax + rsi]                                             |         xmm0 = *((rax + rsi));
    0x004c61f5 movss dword [rcx + rsi], xmm0                                             |         *((rcx + rsi)) = xmm0;
    0x004c61fa add rsi, 4                                                                |         rsi += 4;
    0x004c61fe cmp rdx, rsi                                                              |         
    0x004c6201 jne 0x4c61f0                                                              |         
                                                                                         |     } while (rdx != rsi);
                                                                                         | label_14:
    0x004c6203 cmp byte [rip + 0x252786], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c620a je 0x4c622d                                                               |         
    0x004c620c mov edx, dword [rip + 0x252792]                                           |         edx = numCopyCtorCalls;
    0x004c6212 sub edx, r12d                                                             |         edx -= r12d;
    0x004c6215 mov ecx, dword [rip + 0x252791]                                           |         ecx = numCharCtorCalls;
    0x004c621b sub ecx, dword [rsp + 0x18]                                               |         ecx -= *((rsp + 0x18));
    0x004c621f mov edi, 0x4f5c2a                                                         |         
    0x004c6224 mov esi, ebp                                                              |         esi = ebp;
    0x004c6226 xor eax, eax                                                              |         eax = 0;
    0x004c6228 call 0x401680                                                             |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                         |     }
                                                                                         | label_13:
    0x004c622d cmp byte [rsp + 0x4c], 0                                                  |     
                                                                                         |     if (*((rsp + 0x4c)) == 0) {
    0x004c6232 je 0x4c6290                                                               |         goto label_20;
                                                                                         |     }
    0x004c6234 cmp r12d, dword [rip + 0x252769]                                          |     
                                                                                         |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004c623b je 0x4c6266                                                               |         
    0x004c623d mov edi, 0x4f4c78                                                         |         
    0x004c6242 mov edx, 0x4f4fec                                                         |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c6247 mov esi, 0x1005                                                           |         esi = 0x1005;
    0x004c624c xor eax, eax                                                              |         eax = 0;
    0x004c624e call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c6253 mov eax, dword [rip + 0x25273f]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c6259 cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c625c ja 0x4c6266                                                               |             goto label_21;
                                                                                         |         }
    0x004c625e inc eax                                                                   |         eax++;
    0x004c6260 mov dword [rip + 0x252732], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_21:
    0x004c6266 mov eax, dword [rsp + 0x18]                                               |     eax = *((rsp + 0x18));
    0x004c626a cmp eax, dword [rip + 0x25273c]                                           |     
                                                                                         |     if (eax == *(obj.numCharCtorCalls)) {
    0x004c6270 je 0x4c5dc0                                                               |         goto label_1;
                                                                                         |     }
    0x004c6276 mov edi, 0x4f4c78                                                         |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004c627b mov edx, 0x4f5c5a                                                         |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c6280 mov esi, 0x1006                                                           |     esi = 0x1006;
    0x004c6285 jmp 0x4c62e6                                                              |     goto label_22;
                                                                                         | label_20:
    0x004c6290 add r12d, dword [rsp + 0x10]                                              |     r12d += *((rsp + 0x10));
    0x004c6295 cmp r12d, dword [rip + 0x252708]                                          |     
                                                                                         |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004c629c jle 0x4c62c7                                                              |         
    0x004c629e mov edi, 0x4f4c78                                                         |         
    0x004c62a3 mov edx, 0x4f5c78                                                         |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004c62a8 mov esi, 0x1009                                                           |         esi = 0x1009;
    0x004c62ad xor eax, eax                                                              |         eax = 0;
    0x004c62af call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c62b4 mov eax, dword [rip + 0x2526de]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c62ba cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c62bd ja 0x4c62c7                                                               |             goto label_23;
                                                                                         |         }
    0x004c62bf inc eax                                                                   |         eax++;
    0x004c62c1 mov dword [rip + 0x2526d1], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_23:
    0x004c62c7 mov eax, dword [rsp + 0x18]                                               |     eax = *((rsp + 0x18));
    0x004c62cb cmp eax, dword [rip + 0x2526db]                                           |     
                                                                                         |     if (eax == *(obj.numCharCtorCalls)) {
    0x004c62d1 je 0x4c5dc0                                                               |         goto label_1;
                                                                                         |     }
    0x004c62d7 mov edi, 0x4f4c78                                                         |     
    0x004c62dc mov edx, 0x4f5c5a                                                         |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c62e1 mov esi, 0x100a                                                           |     esi = 0x100a;
                                                                                         | label_22:
    0x004c62e6 xor eax, eax                                                              |     eax = 0;
    0x004c62e8 call 0x401680                                                             |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c62ed mov eax, dword [rip + 0x2526a5]                                           |     eax = (anonymous namespace)::testStatus;
    0x004c62f3 cmp eax, 0x64                                                             |     
                                                                                         |     if (eax > 0x64) {
    0x004c62f6 ja 0x4c5dc0                                                               |         goto label_1;
                                                                                         |     }
    0x004c62fc inc eax                                                                   |     eax++;
    0x004c62fe mov dword [rip + 0x252694], eax                                           |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c6304 jmp 0x4c5dc0                                                              |     goto label_1;
                                                                                         | label_9:
    0x004c6309 cmp byte [rip + 0x252686], 0                                              |     
                                                                                         |     if (*(obj.verbose) != 0) {
    0x004c6310 je 0x4c631c                                                               |         
    0x004c6312 mov edi, 0x4f67d2                                                         |         
    0x004c6317 call 0x401710                                                             |         puts ("\t\tfrom different type.");
                                                                                         |     }
    0x004c631c xor ebx, ebx                                                              |     ebx = 0;
    0x004c631e jmp 0x4c634c                                                              |     goto label_24;
                                                                                         | label_2:
    0x004c6320 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6325 mov rsi, rbp                                                              |     rsi = rbp;
    0x004c6328 call 0x4e0fa0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c632d mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6332 mov rsi, rbp                                                              |     rsi = rbp;
    0x004c6335 call 0x4e11f0                                                             |     voidcleanup<float>(float*,char const*) ();
    0x004c633a mov rbx, qword [rsp + 0x18]                                               |     rbx = *((rsp + 0x18));
    0x004c633f inc rbx                                                                   |     rbx++;
    0x004c6342 cmp rbx, 0x1e                                                             |     
                                                                                         |     if (rbx == 0x1e) {
    0x004c6346 je 0x4c68a4                                                               |         goto label_25;
                                                                                         |     }
                                                                                         | label_24:
    0x004c634c lea rbp, [rbx*8]                                                          |     rbp = rbx*8;
    0x004c6354 mov r12, qword [rbp + rbp*4 + 0x4f3b08]                                   |     r12 = *((rbp + rbp*4 + 0x4f3b08));
    0x004c635c mov rdi, r12                                                              |     
    0x004c635f call 0x401790                                                             |     eax = strlen (*((rbp + rbp*4 + 0x4f3b08)));
    0x004c6364 cmp eax, 0x11                                                             |     
                                                                                         |     if (eax >= 0x11) {
    0x004c6367 jl 0x4c6392                                                               |         
    0x004c6369 mov edi, 0x4f4c78                                                         |         
    0x004c636e mov edx, 0x4f4203                                                         |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c6373 mov esi, 0x1019                                                           |         esi = 0x1019;
    0x004c6378 xor eax, eax                                                              |         eax = 0;
    0x004c637a call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c637f mov eax, dword [rip + 0x252613]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c6385 cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c6388 ja 0x4c6392                                                               |             goto label_26;
                                                                                         |         }
    0x004c638a inc eax                                                                   |         eax++;
    0x004c638c mov dword [rip + 0x252606], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_26:
    0x004c6392 mov rdi, r12                                                              |     
    0x004c6395 call 0x401790                                                             |     rax = strlen (r12);
    0x004c639a cmp rax, 0x14                                                             |     
                                                                                         |     if (rax >= 0x14) {
    0x004c639e jb 0x4c63c9                                                               |         
    0x004c63a0 mov edi, 0x4f4c78                                                         |         
    0x004c63a5 mov edx, 0x4f5c9c                                                         |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004c63aa mov esi, 0x101c                                                           |         esi = 0x101c;
    0x004c63af xor eax, eax                                                              |         eax = 0;
    0x004c63b1 call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c63b6 mov eax, dword [rip + 0x2525dc]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c63bc cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c63bf ja 0x4c63c9                                                               |             goto label_27;
                                                                                         |         }
    0x004c63c1 inc eax                                                                   |         eax++;
    0x004c63c3 mov dword [rip + 0x2525cf], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_27:
    0x004c63c9 mov qword [rsp + 0x18], rbx                                               |     *((rsp + 0x18)) = rbx;
    0x004c63ce xorps xmm0, xmm0                                                          |     __asm ("xorps xmm0, xmm0");
    0x004c63d1 movaps xmmword [rsp + 0x20], xmm0                                         |     *((rsp + 0x20)) = xmm0;
    0x004c63d6 mov dword [rsp + 0x30], 0                                                 |     *((rsp + 0x30)) = 0;
    0x004c63de mov al, byte [r12]                                                        |     al = *(r12);
    0x004c63e2 test al, al                                                               |     
                                                                                         |     if (al == 0) {
    0x004c63e4 je 0x4c6401                                                               |         goto label_28;
                                                                                         |     }
    0x004c63e6 xor ecx, ecx                                                              |     ecx = 0;
    0x004c63e8 nop dword [rax + rax]                                                     |     
                                                                                         |     do {
    0x004c63f0 mov byte [rsp + rcx + 0x20], al                                           |         *((rsp + rcx + 0x20)) = al;
    0x004c63f4 movzx eax, byte [r12 + rcx + 1]                                           |         eax = *((r12 + rcx + 1));
    0x004c63fa inc rcx                                                                   |         rcx++;
    0x004c63fd test al, al                                                               |         
    0x004c63ff jne 0x4c63f0                                                              |         
                                                                                         |     } while (al != 0);
                                                                                         | label_28:
    0x004c6401 mov r14d, dword [rbp + rbp*4 + 0x4f3b00]                                  |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004c6409 movsxd rbx, dword [rbp + rbp*4 + 0x4f3b10]                                |     rbx = *((rbp + rbp*4 + 0x4f3b10));
    0x004c6411 movsxd r15, dword [rbp + rbp*4 + 0x4f3b14]                                |     r15 = *((rbp + rbp*4 + 0x4f3b14));
    0x004c6419 movsxd r13, dword [rbp + rbp*4 + 0x4f3b18]                                |     r13 = *((rbp + rbp*4 + 0x4f3b18));
    0x004c6421 mov rbp, qword [rbp + rbp*4 + 0x4f3b20]                                   |     rbp = *((rbp + rbp*4 + 0x4f3b20));
    0x004c6429 cmp byte [rip + 0x252560], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c6430 je 0x4c6450                                                               |         
    0x004c6432 mov qword [rsp], rbp                                                      |         *(rsp) = rbp;
    0x004c6436 mov edi, 0x4f5ab7                                                         |         
    0x004c643b mov esi, r14d                                                             |         esi = r14d;
    0x004c643e mov rdx, r12                                                              |         rdx = r12;
    0x004c6441 mov ecx, ebx                                                              |         ecx = ebx;
    0x004c6443 mov r8d, r15d                                                             |         r8d = r15d;
    0x004c6446 mov r9d, r13d                                                             |         r9d = r13d;
    0x004c6449 xor eax, eax                                                              |         eax = 0;
    0x004c644b call 0x401680                                                             |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                         |     }
    0x004c6450 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6455 mov rsi, r12                                                              |     rsi = r12;
    0x004c6458 call 0x4e0eb0                                                             |     float&gg<float>(float*,char const*) ();
    0x004c645d mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6462 mov rsi, r12                                                              |     rsi = r12;
    0x004c6465 call 0x4e0fa0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c646a mov r12d, dword [rip + 0x252533]                                          |     r12d = numCopyCtorCalls;
    0x004c6471 mov eax, dword [rip + 0x252535]                                           |     eax = numCharCtorCalls;
    0x004c6477 mov dword [rsp + 0x40], eax                                               |     *((rsp + 0x40)) = eax;
    0x004c647b cmp byte [rsp + 0x3c], 0                                                  |     
                                                                                         |     if (*((rsp + 0x3c)) == 0) {
    0x004c6480 je 0x4c6650                                                               |         goto label_29;
                                                                                         |     }
    0x004c6486 cmp byte [rip + 0x252503], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c648d je 0x4c64a2                                                               |         
    0x004c648f cmp dword [rip + 0x2520de], 0                                             |         
                                                                                         |         if (*(0x00718574) == 0) {
    0x004c6496 je 0x4c64a2                                                               |             goto label_30;
                                                                                         |         }
    0x004c6498 mov edi, 0x4f425a                                                         |         
    0x004c649d call 0x401710                                                             |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                         |     }
                                                                                         | label_30:
    0x004c64a2 mov dword [rip + 0x2520c8], 0                                             |     *(0x00718574) = 0;
    0x004c64ac cmp byte [rip + 0x2524e2], 0                                              |     
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c64b3 je 0x4c64bf                                                               |         
    0x004c64b5 mov edi, 0x4f4281                                                         |         
    0x004c64ba call 0x401710                                                             |         puts ("\t\tBegin bslma exception test.");
                                                                                         |     }
    0x004c64bf mov rax, qword [rip + 0x25235a]                                           |     rax = Z;
    0x004c64c6 mov qword [rsp + 0x50], 0x4f6858                                          |     *((rsp + 0x50)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c64cf mov qword [rsp + 0x58], rax                                               |     *((rsp + 0x58)) = rax;
    0x004c64d4 mov qword [rax + 0x20], 0                                                 |     *((rax + 0x20)) = 0;
    0x004c64dc test rax, rax                                                             |     
                                                                                         |     if (rax == 0) {
    0x004c64df je 0x4c6802                                                               |         goto label_31;
                                                                                         |     }
                                                                                         | label_3:
    0x004c64e5 cmp qword [rsp + 0x18], 6                                                 |     
                                                                                         |     if (*((rsp + 0x18)) < 6) {
    0x004c64eb jb 0x4c6608                                                               |         goto label_32;
                                                                                         |     }
    0x004c64f1 lea rcx, [rsp + rbx + 0x20]                                               |     rcx = rsp + rbx + 0x20;
    0x004c64f6 lea rsi, [r13*4 + 0x74f5a0]                                               |     rsi = r13*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c64fe lea eax, [rbx + r15]                                                      |     eax = rbx + r15;
    0x004c6502 movsxd r9, eax                                                            |     r9 = (int64_t) eax;
    0x004c6505 mov rdx, r9                                                               |     rdx = r9;
    0x004c6508 sub rdx, rbx                                                              |     rdx -= rbx;
    0x004c650b cmp rdx, 8                                                                |     
                                                                                         |     if (rdx < 8) {
    0x004c650f jb 0x4c65da                                                               |         goto label_33;
                                                                                         |     }
    0x004c6515 mov r11, rbp                                                              |     r11 = rbp;
    0x004c6518 mov r8, rdx                                                               |     r8 = rdx;
    0x004c651b and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c651f lea rdi, [r8 - 8]                                                         |     rdi = r8 - 8;
    0x004c6523 mov r10, rdi                                                              |     r10 = rdi;
    0x004c6526 shr r10, 3                                                                |     r10 >>= 3;
    0x004c652a inc r10                                                                   |     r10++;
    0x004c652d test rdi, rdi                                                             |     
                                                                                         |     if (rdi == 0) {
    0x004c6530 je 0x4c6893                                                               |         goto label_34;
                                                                                         |     }
    0x004c6536 lea rax, [rsp + 0x2c]                                                     |     rax = rsp + 0x2c;
    0x004c653b add rbx, rax                                                              |     rbx += rax;
    0x004c653e mov rbp, r10                                                              |     
    0x004c6541 and rbp, 0xfffffffffffffffe                                               |     rbp &= 0xfffffffffffffffe;
    0x004c6545 neg rbp                                                                   |     rbp = -rbp;
    0x004c6548 xor edi, edi                                                              |     edi = 0;
    0x004c654a nop word [rax + rax]                                                      |     
                                                                                         |     do {
    0x004c6550 pmovsxbd xmm0, dword [rbx + rdi - 0xc]                                    |         __asm ("pmovsxbd xmm0, dword [rbx + rdi - 0xc]");
    0x004c6557 pmovsxbd xmm1, dword [rbx + rdi - 8]                                      |         __asm ("pmovsxbd xmm1, dword [rbx + rdi - 8]");
    0x004c655e cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c6561 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6564 lea rax, [r13*4]                                                          |         rax = r13*4;
    0x004c656c movups xmmword [rax + rdi*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [rax + rdi*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c6574 movups xmmword [rax + rdi*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5b0], xmm1");
    0x004c657c pmovsxbd xmm0, dword [rbx + rdi - 4]                                      |         __asm ("pmovsxbd xmm0, dword [rbx + rdi - 4]");
    0x004c6583 pmovsxbd xmm1, dword [rbx + rdi]                                          |         __asm ("pmovsxbd xmm1, dword [rbx + rdi]");
    0x004c6589 cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c658c cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c658f movups xmmword [rax + rdi*4 + 0x74f5c0], xmm0                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5c0], xmm0");
    0x004c6597 movups xmmword [rax + rdi*4 + 0x74f5d0], xmm1                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5d0], xmm1");
    0x004c659f add rdi, 0x10                                                             |         rdi += 0x10;
    0x004c65a3 add rbp, 2                                                                |         rbp += 2;
    0x004c65a7 jne 0x4c6550                                                              |         
                                                                                         |     } while (rbp != 0);
    0x004c65a9 test r10b, 1                                                              |     
                                                                                         |     if ((r10b & 1) != 0) {
    0x004c65ad je 0x4c65cb                                                               |         
                                                                                         | label_6:
    0x004c65af pmovsxbd xmm0, dword [rcx + rdi]                                          |         __asm ("pmovsxbd xmm0, dword [rcx + rdi]");
    0x004c65b5 pmovsxbd xmm1, dword [rcx + rdi + 4]                                      |         __asm ("pmovsxbd xmm1, dword [rcx + rdi + 4]");
    0x004c65bc cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c65bf cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c65c2 movups xmmword [rsi + rdi*4], xmm0                                        |         __asm ("movups xmmword [rsi + rdi*4], xmm0");
    0x004c65c6 movups xmmword [rsi + rdi*4 + 0x10], xmm1                                 |         __asm ("movups xmmword [rsi + rdi*4 + 0x10], xmm1");
                                                                                         |     }
                                                                                         | label_7:
    0x004c65cb cmp rdx, r8                                                               |     
    0x004c65ce mov rbp, r11                                                              |     
                                                                                         |     if (rdx == r8) {
    0x004c65d1 je 0x4c6608                                                               |         goto label_32;
                                                                                         |     }
    0x004c65d3 add rcx, r8                                                               |     rcx += r8;
    0x004c65d6 lea rsi, [rsi + r8*4]                                                     |     rsi = rsi + r8*4;
                                                                                         | label_33:
    0x004c65da sub r9, rcx                                                               |     r9 -= rcx;
    0x004c65dd lea rax, [rsp + r9 + 0x20]                                                |     rax = rsp + r9 + 0x20;
    0x004c65e2 xor edi, edi                                                              |     edi = 0;
    0x004c65e4 nop word cs:[rax + rax]                                                   |     
    0x004c65ee nop                                                                       |     
                                                                                         |     do {
    0x004c65f0 movsx edx, byte [rcx + rdi]                                               |         edx = *((rcx + rdi));
    0x004c65f4 xorps xmm0, xmm0                                                          |         __asm ("xorps xmm0, xmm0");
    0x004c65f7 cvtsi2ss xmm0, edx                                                        |         __asm ("cvtsi2ss xmm0, edx");
    0x004c65fb movss dword [rsi + rdi*4], xmm0                                           |         *((rsi + rdi*4)) = xmm0;
    0x004c6600 inc rdi                                                                   |         rdi++;
    0x004c6603 cmp rax, rdi                                                              |         
    0x004c6606 jne 0x4c65f0                                                              |         
                                                                                         |     } while (rax != rdi);
                                                                                         | label_32:
    0x004c6608 mov rax, qword [rsp + 0x50]                                               |     rax = *((rsp + 0x50));
    0x004c660d lea rdi, [rsp + 0x50]                                                     |     rdi = rsp + 0x50;
    0x004c6612 mov rsi, 0xffffffffffffffff                                               |     rsi = 0xffffffffffffffff;
    0x004c6619 call qword [rax + 0x10]                                                   |     uint64_t (*rax + 0x10)() ();
    0x004c661c cmp byte [rip + 0x252372], 0                                              |     
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c6623 je 0x4c662f                                                               |         
    0x004c6625 mov edi, 0x4f43e1                                                         |         
    0x004c662a call 0x401710                                                             |         puts ("\t\tEnd bslma exception test.");
                                                                                         |     }
    0x004c662f cmp byte [rip + 0x25235a], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) == 0) {
    0x004c6636 je 0x4c67c3                                                               |         goto label_35;
                                                                                         |     }
    0x004c663c mov edi, 0xa                                                              |     
    0x004c6641 call 0x401720                                                             |     putchar (0xa);
    0x004c6646 mov r11d, r14d                                                            |     r11d = r14d;
    0x004c6649 jmp 0x4c6798                                                              |     goto label_36;
                                                                                         | label_29:
    0x004c6650 cmp qword [rip + 0x2521c8], 0                                             |     
                                                                                         |     if (*(obj.Z) == 0) {
    0x004c6658 jne 0x4c6670                                                              |         
    0x004c665a mov rax, qword [rip + 0x28ac57]                                           |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6661 test rax, rax                                                             |         
                                                                                         |         if (rax != 0) {
    0x004c6664 jne 0x4c6670                                                              |             goto label_37;
                                                                                         |         }
    0x004c6666 call 0x4eec50                                                             |         BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c666b nop dword [rax + rax]                                                     |         
                                                                                         |     }
                                                                                         | label_37:
    0x004c6670 cmp qword [rsp + 0x18], 6                                                 |     
    0x004c6676 mov r11d, r14d                                                            |     r11d = r14d;
                                                                                         |     if (*((rsp + 0x18)) < 6) {
    0x004c6679 jb 0x4c6798                                                               |         goto label_36;
                                                                                         |     }
    0x004c667f lea rax, [r13*4 + 0x74f5a0]                                               |     rax = r13*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6687 lea rcx, [rsp + rbx + 0x20]                                               |     rcx = rsp + rbx + 0x20;
    0x004c668c add r15, rbx                                                              |     r15 += rbx;
    0x004c668f mov rdx, r15                                                              |     rdx = r15;
    0x004c6692 sub rdx, rbx                                                              |     rdx -= rbx;
    0x004c6695 cmp rdx, 8                                                                |     
                                                                                         |     if (rdx < 8) {
    0x004c6699 jb 0x4c676a                                                               |         goto label_38;
                                                                                         |     }
    0x004c669f mov r10, rbp                                                              |     r10 = rbp;
    0x004c66a2 mov r8, rdx                                                               |     r8 = rdx;
    0x004c66a5 and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c66a9 lea rdi, [r8 - 8]                                                         |     rdi = r8 - 8;
    0x004c66ad mov r9, rdi                                                               |     r9 = rdi;
    0x004c66b0 shr r9, 3                                                                 |     r9 >>= 3;
    0x004c66b4 inc r9                                                                    |     r9++;
    0x004c66b7 test rdi, rdi                                                             |     
                                                                                         |     if (rdi == 0) {
    0x004c66ba je 0x4c6882                                                               |         goto label_39;
                                                                                         |     }
    0x004c66c0 lea rsi, [rsp + 0x2c]                                                     |     rsi = rsp + 0x2c;
    0x004c66c5 add rbx, rsi                                                              |     rbx += rsi;
    0x004c66c8 mov rdi, r9                                                               |     rdi = r9;
    0x004c66cb and rdi, 0xfffffffffffffffe                                               |     rdi &= 0xfffffffffffffffe;
    0x004c66cf neg rdi                                                                   |     rdi = -rdi;
    0x004c66d2 xor ebp, ebp                                                              |     ebp = 0;
    0x004c66d4 nop word cs:[rax + rax]                                                   |     
    0x004c66de nop                                                                       |     
                                                                                         |     do {
    0x004c66e0 pmovsxbd xmm0, dword [rbx + rbp - 0xc]                                    |         __asm ("pmovsxbd xmm0, dword [rbx + rbp - 0xc]");
    0x004c66e7 pmovsxbd xmm1, dword [rbx + rbp - 8]                                      |         __asm ("pmovsxbd xmm1, dword [rbx + rbp - 8]");
    0x004c66ee cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c66f1 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c66f4 lea rsi, [r13*4]                                                          |         rsi = r13*4;
    0x004c66fc movups xmmword [rsi + rbp*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [rsi + rbp*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c6704 movups xmmword [rsi + rbp*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [rsi + rbp*4 + 0x74f5b0], xmm1");
    0x004c670c pmovsxbd xmm0, dword [rbx + rbp - 4]                                      |         __asm ("pmovsxbd xmm0, dword [rbx + rbp - 4]");
    0x004c6713 pmovsxbd xmm1, dword [rbx + rbp]                                          |         __asm ("pmovsxbd xmm1, dword [rbx + rbp]");
    0x004c6719 cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c671c cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c671f movups xmmword [rsi + rbp*4 + 0x74f5c0], xmm0                             |         __asm ("movups xmmword [rsi + rbp*4 + 0x74f5c0], xmm0");
    0x004c6727 movups xmmword [rsi + rbp*4 + 0x74f5d0], xmm1                             |         __asm ("movups xmmword [rsi + rbp*4 + 0x74f5d0], xmm1");
    0x004c672f add rbp, 0x10                                                             |         rbp += 0x10;
    0x004c6733 add rdi, 2                                                                |         rdi += 2;
    0x004c6737 jne 0x4c66e0                                                              |         
                                                                                         |     } while (rdi != 0);
    0x004c6739 test r9b, 1                                                               |     
                                                                                         |     if ((r9b & 1) != 0) {
    0x004c673d je 0x4c675b                                                               |         
                                                                                         | label_4:
    0x004c673f pmovsxbd xmm0, dword [rcx + rbp]                                          |         __asm ("pmovsxbd xmm0, dword [rcx + rbp]");
    0x004c6745 pmovsxbd xmm1, dword [rcx + rbp + 4]                                      |         __asm ("pmovsxbd xmm1, dword [rcx + rbp + 4]");
    0x004c674c cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c674f cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6752 movups xmmword [rax + rbp*4], xmm0                                        |         __asm ("movups xmmword [rax + rbp*4], xmm0");
    0x004c6756 movups xmmword [rax + rbp*4 + 0x10], xmm1                                 |         __asm ("movups xmmword [rax + rbp*4 + 0x10], xmm1");
                                                                                         |     }
                                                                                         | label_5:
    0x004c675b cmp rdx, r8                                                               |     
    0x004c675e mov rbp, r10                                                              |     
                                                                                         |     if (rdx == r8) {
    0x004c6761 je 0x4c6798                                                               |         goto label_36;
                                                                                         |     }
    0x004c6763 add rcx, r8                                                               |     rcx += r8;
    0x004c6766 lea rax, [rax + r8*4]                                                     |     rax = rax + r8*4;
                                                                                         | label_38:
    0x004c676a sub r15, rcx                                                              |     r15 -= rcx;
    0x004c676d lea rdx, [rsp + r15 + 0x20]                                               |     rdx = rsp + r15 + 0x20;
    0x004c6772 xor esi, esi                                                              |     esi = 0;
    0x004c6774 nop word cs:[rax + rax]                                                   |     
    0x004c677e nop                                                                       |     
                                                                                         |     do {
    0x004c6780 movsx edi, byte [rcx + rsi]                                               |         edi = *((rcx + rsi));
    0x004c6784 xorps xmm0, xmm0                                                          |         __asm ("xorps xmm0, xmm0");
    0x004c6787 cvtsi2ss xmm0, edi                                                        |         __asm ("cvtsi2ss xmm0, edi");
    0x004c678b movss dword [rax + rsi*4], xmm0                                           |         *((rax + rsi*4)) = xmm0;
    0x004c6790 inc rsi                                                                   |         rsi++;
    0x004c6793 cmp rdx, rsi                                                              |         
    0x004c6796 jne 0x4c6780                                                              |         
                                                                                         |     } while (rdx != rsi);
                                                                                         | label_36:
    0x004c6798 cmp byte [rip + 0x2521f1], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c679f je 0x4c67c3                                                               |         
    0x004c67a1 mov edx, dword [rip + 0x2521fd]                                           |         edx = numCopyCtorCalls;
    0x004c67a7 sub edx, r12d                                                             |         edx -= r12d;
    0x004c67aa mov ecx, dword [rip + 0x2521fc]                                           |         ecx = numCharCtorCalls;
    0x004c67b0 sub ecx, dword [rsp + 0x40]                                               |         ecx -= *((rsp + 0x40));
    0x004c67b4 mov edi, 0x4f5c2a                                                         |         
    0x004c67b9 mov esi, r11d                                                             |         esi = r11d;
    0x004c67bc xor eax, eax                                                              |         eax = 0;
    0x004c67be call 0x401680                                                             |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                         |     }
                                                                                         | label_35:
    0x004c67c3 cmp r12d, dword [rip + 0x2521da]                                          |     
                                                                                         |     if (r12d == *(obj.numCopyCtorCalls)) {
    0x004c67ca je 0x4c6320                                                               |         goto label_2;
                                                                                         |     }
    0x004c67d0 mov edi, 0x4f4c78                                                         |     
    0x004c67d5 mov edx, 0x4f4fec                                                         |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c67da mov esi, 0x103f                                                           |     esi = 0x103f;
    0x004c67df xor eax, eax                                                              |     eax = 0;
    0x004c67e1 call 0x401680                                                             |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c67e6 mov eax, dword [rip + 0x2521ac]                                           |     eax = (anonymous namespace)::testStatus;
    0x004c67ec cmp eax, 0x64                                                             |     
                                                                                         |     if (eax > 0x64) {
    0x004c67ef ja 0x4c6320                                                               |         goto label_2;
                                                                                         |     }
    0x004c67f5 inc eax                                                                   |     eax++;
    0x004c67f7 mov dword [rip + 0x25219b], eax                                           |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c67fd jmp 0x4c6320                                                              |     goto label_2;
                                                                                         | label_31:
    0x004c6802 mov eax, 1                                                                |     eax = 1;
    0x004c6807 mov qword [rsp + 0x10], rax                                               |     *((rsp + 0x10)) = rax;
    0x004c680c mov rax, qword [rip + 0x28aaa5]                                           |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6813 test rax, rax                                                             |     
                                                                                         |     if (rax != 0) {
    0x004c6816 jne 0x4c64e5                                                              |         goto label_3;
                                                                                         |     }
    0x004c681c call 0x4eec50                                                             |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c6821 jmp 0x4c64e5                                                              |     goto label_3;
                                                                                         | label_39:
    0x004c6882 xor ebp, ebp                                                              |     ebp = 0;
    0x004c6884 test r9b, 1                                                               |     
                                                                                         |     if ((r9b & 1) != 0) {
    0x004c6888 jne 0x4c673f                                                              |         goto label_4;
                                                                                         |     }
    0x004c688e jmp 0x4c675b                                                              |     goto label_5;
                                                                                         | label_34:
    0x004c6893 xor edi, edi                                                              |     edi = 0;
    0x004c6895 test r10b, 1                                                              |     
                                                                                         |     if ((r10b & 1) != 0) {
    0x004c6899 jne 0x4c65af                                                              |         goto label_6;
                                                                                         |     }
    0x004c689f jmp 0x4c65cb                                                              |     goto label_7;
                                                                                         | label_25:
    0x004c68a4 add rsp, 0x68                                                             |     
    0x004c68a8 pop rbx                                                                   |     
    0x004c68a9 pop r12                                                                   |     
    0x004c68ab pop r13                                                                   |     
    0x004c68ad pop r14                                                                   |     
    0x004c68af pop r15                                                                   |     
    0x004c68b1 pop rbp                                                                   |     
    0x004c68b2 ret                                                                       |     return rax;
                                                                                         | }