; assembly                                                                           | /* r2dec pseudo code output */
                                                                                         | /* bslalg_arrayprimitives.t/none @ 0x4c5e60 */
                                                                                         | #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_14h;
                                                                                         |     uint32_t var_18h;
                                                                                         |     int64_t var_20h;
                                                                                         |     int64_t var_28h;
                                                                                         |     int64_t var_2ch;
                                                                                         |     int64_t var_30h;
                                                                                         |     uint32_t var_40h;
                                                                                         |     uint32_t var_48h;
                                                                                         |     int64_t var_50h;
                                                                                         |     uint32_t var_54h;
                                                                                         |     int64_t var_58h;
                                                                                         |     int64_t var_60h;
                                                                                         |     rdx = arg3;
                                                                                         |     rsi = arg2;
                                                                                         |     /* void testCopyConstructWithIterators<float>(bool, bool, bool) */
    0x004c5e60 push rbp                                                                  |     
    0x004c5e61 push r15                                                                  |     
    0x004c5e63 push r14                                                                  |     
    0x004c5e65 push r13                                                                  |     
    0x004c5e67 push r12                                                                  |     
    0x004c5e69 push rbx                                                                  |     
    0x004c5e6a sub rsp, 0x68                                                             |     
    0x004c5e6e mov dword [rsp + 0x54], edx                                               |     *((rsp + 0x54)) = edx;
    0x004c5e72 mov dword [rsp + 0x40], esi                                               |     *((rsp + 0x40)) = esi;
    0x004c5e76 cmp byte [rip + 0x252b19], 0                                              |     
                                                                                         |     if (*(obj.verbose) != 0) {
    0x004c5e7d je 0x4c5e89                                                               |         
    0x004c5e7f mov edi, 0x4f6973                                                         |         
    0x004c5e84 call 0x401710                                                             |         eax = puts ("\t\tfrom same type.");
                                                                                         |     }
    0x004c5e89 xor eax, eax                                                              |     eax = 0;
    0x004c5e8b jmp 0x4c5ebc                                                              |     goto label_8;
                                                                                         | label_1:
    0x004c5e90 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5e95 mov rsi, rbp                                                              |     rsi = rbp;
    0x004c5e98 call 0x4e10f0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c5e9d mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5ea2 mov rsi, rbp                                                              |     rsi = rbp;
    0x004c5ea5 call 0x4e1340                                                             |     voidcleanup<float>(float*,char const*) ();
    0x004c5eaa mov rax, qword [rsp + 0x48]                                               |     rax = *((rsp + 0x48));
    0x004c5eaf inc rax                                                                   |     rax++;
    0x004c5eb2 cmp rax, 0x1e                                                             |     
                                                                                         |     if (rax == 0x1e) {
    0x004c5eb6 je 0x4c6406                                                               |         goto label_9;
                                                                                         |     }
                                                                                         | label_8:
    0x004c5ebc mov qword [rsp + 0x48], rax                                               |     *((rsp + 0x48)) = rax;
    0x004c5ec1 lea rbp, [rax*8]                                                          |     rbp = rax*8;
    0x004c5ec9 mov r12, qword [rbp + rbp*4 + 0x4f3c98]                                   |     r12 = *((rbp + rbp*4 + 0x4f3c98));
    0x004c5ed1 mov rdi, r12                                                              |     
    0x004c5ed4 call 0x401790                                                             |     eax = strlen (*((rbp + rbp*4 + 0x4f3c98)));
    0x004c5ed9 cmp eax, 0x11                                                             |     
                                                                                         |     if (eax >= 0x11) {
    0x004c5edc jl 0x4c5f07                                                               |         
    0x004c5ede mov edi, 0x4f4e04                                                         |         
    0x004c5ee3 mov edx, 0x4f4393                                                         |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c5ee8 mov esi, 0xfe6                                                            |         esi = 0xfe6;
    0x004c5eed xor eax, eax                                                              |         eax = 0;
    0x004c5eef call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c5ef4 mov eax, dword [rip + 0x252a9e]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c5efa cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c5efd ja 0x4c5f07                                                               |             goto label_10;
                                                                                         |         }
    0x004c5eff inc eax                                                                   |         eax++;
    0x004c5f01 mov dword [rip + 0x252a91], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_10:
    0x004c5f07 mov r14d, dword [rbp + rbp*4 + 0x4f3c90]                                  |     r14d = *((rbp + rbp*4 + obj.DATA_3));
    0x004c5f0f movsxd r15, dword [rbp + rbp*4 + 0x4f3ca0]                                |     r15 = *((rbp + rbp*4 + 0x4f3ca0));
    0x004c5f17 mov ebx, dword [rbp + rbp*4 + 0x4f3ca4]                                   |     ebx = *((rbp + rbp*4 + 0x4f3ca4));
    0x004c5f1e movsxd r13, dword [rbp + rbp*4 + 0x4f3ca8]                                |     r13 = *((rbp + rbp*4 + 0x4f3ca8));
    0x004c5f26 mov rbp, qword [rbp + rbp*4 + 0x4f3cb0]                                   |     rbp = *((rbp + rbp*4 + 0x4f3cb0));
    0x004c5f2e cmp byte [rip + 0x252a5b], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c5f35 je 0x4c5f56                                                               |         
    0x004c5f37 mov qword [rsp], rbp                                                      |         *(rsp) = rbp;
    0x004c5f3b mov edi, 0x4f5c41                                                         |         
    0x004c5f40 mov esi, r14d                                                             |         esi = r14d;
    0x004c5f43 mov rdx, r12                                                              |         rdx = r12;
    0x004c5f46 mov ecx, r15d                                                             |         ecx = r15d;
    0x004c5f49 mov r8d, ebx                                                              |         r8d = ebx;
    0x004c5f4c mov r9d, r13d                                                             |         r9d = r13d;
    0x004c5f4f xor eax, eax                                                              |         eax = 0;
    0x004c5f51 call 0x401680                                                             |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                         |     }
    0x004c5f56 mov dword [rsp + 0x14], r14d                                              |     *((rsp + 0x14)) = r14d;
    0x004c5f5b mov qword [rsp + 0x18], rbx                                               |     *((rsp + 0x18)) = rbx;
    0x004c5f60 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5f65 mov rsi, r12                                                              |     rsi = r12;
    0x004c5f68 call 0x4e1000                                                             |     float&gg<float>(float*,char const*) ();
    0x004c5f6d mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c5f72 mov rsi, r12                                                              |     rsi = r12;
    0x004c5f75 call 0x4e10f0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c5f7a mov r12d, dword [rip + 0x252a23]                                          |     r12d = numCopyCtorCalls;
    0x004c5f81 mov r14d, dword [rip + 0x252a24]                                          |     r14d = numCharCtorCalls;
    0x004c5f88 cmp byte [rsp + 0x54], 0                                                  |     
                                                                                         |     if (*((rsp + 0x54)) == 0) {
    0x004c5f8d je 0x4c6070                                                               |         goto label_11;
                                                                                         |     }
    0x004c5f93 cmp byte [rip + 0x2529f6], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c5f9a je 0x4c5faf                                                               |         
    0x004c5f9c cmp dword [rip + 0x2525cd], 0                                             |         
                                                                                         |         if (*(obj.testCopyConstructWithIterators_float__bool__bool__bool_::firstTime) == 0) {
    0x004c5fa3 je 0x4c5faf                                                               |             goto label_12;
                                                                                         |         }
    0x004c5fa5 mov edi, 0x4f43ea                                                         |         
    0x004c5faa call 0x401710                                                             |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                         |     }
                                                                                         | label_12:
    0x004c5faf mov dword [rip + 0x2525b7], 0                                             |     *(obj.testCopyConstructWithIterators_float__bool__bool__bool_::firstTime) = 0;
    0x004c5fb9 cmp byte [rip + 0x2529d5], 0                                              |     
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c5fc0 je 0x4c5fcc                                                               |         
    0x004c5fc2 mov edi, 0x4f4411                                                         |         
    0x004c5fc7 call 0x401710                                                             |         puts ("\t\tBegin bslma exception test.");
                                                                                         |     }
    0x004c5fcc mov rax, qword [rip + 0x25284d]                                           |     rax = Z;
    0x004c5fd3 mov qword [rsp + 0x20], 0x4f69e0                                          |     *((rsp + 0x20)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c5fdc mov qword [rsp + 0x28], rax                                               |     *((rsp + 0x28)) = rax;
    0x004c5fe1 mov qword [rax + 0x20], 0                                                 |     *((rax + 0x20)) = 0;
    0x004c5fe9 test rax, rax                                                             |     
    0x004c5fec je 0x4c6135                                                               |     
                                                                                         |     while (rax != 0) {
                                                                                         | label_0:
    0x004c5ff2 lea rsi, [r15*4 + 0x74f5a0]                                               |         rsi = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c5ffa mov rax, qword [rsp + 0x18]                                               |         rax = *((rsp + 0x18));
    0x004c5fff add eax, r15d                                                             |         eax += r15d;
    0x004c6002 cdqe                                                                      |         rax = (int64_t) eax;
    0x004c6004 lea rdx, [rax*4 + 0x74f5a0]                                               |         rdx = rax*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c600c sub rdx, rsi                                                              |         rdx -= rsi;
                                                                                         |         if (rdx != 0) {
    0x004c600f je 0x4c601e                                                               |             
    0x004c6011 lea rdi, [r13*4 + 0x74f5a0]                                               |             
    0x004c6019 call 0x401930                                                             |             memcpy (r13*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u, rsi, rdx);
                                                                                         |         }
    0x004c601e mov rax, qword [rsp + 0x20]                                               |         rax = *((rsp + 0x20));
    0x004c6023 lea rdi, [rsp + 0x20]                                                     |         rdi = rsp + 0x20;
    0x004c6028 mov rsi, 0xffffffffffffffff                                               |         rsi = 0xffffffffffffffff;
    0x004c602f call qword [rax + 0x10]                                                   |         uint64_t (*rax + 0x10)() ();
    0x004c6032 cmp byte [rip + 0x25295c], 0                                              |         
                                                                                         |         if (*(obj.veryVeryVerbose) != 0) {
    0x004c6039 je 0x4c6045                                                               |             
    0x004c603b mov edi, 0x4f4571                                                         |             
    0x004c6040 call 0x401710                                                             |             puts ("\t\tEnd bslma exception test.");
                                                                                         |         }
    0x004c6045 cmp byte [rip + 0x252944], 0                                              |         
                                                                                         |         if (*(obj.veryVerbose) == 0) {
    0x004c604c je 0x4c632c                                                               |             goto label_13;
                                                                                         |         }
    0x004c6052 mov edi, 0xa                                                              |         
    0x004c6057 call 0x401720                                                             |         putchar (0xa);
    0x004c605c mov ebx, dword [rsp + 0x14]                                               |         ebx = *((rsp + 0x14));
    0x004c6060 jmp 0x4c6303                                                              |         goto label_14;
                                                                                         | label_11:
    0x004c6070 cmp qword [rip + 0x2527a8], 0                                             |         
                                                                                         |         if (*(obj.Z) == 0) {
    0x004c6078 jne 0x4c6090                                                              |             
    0x004c607a mov rax, qword [rip + 0x28b237]                                           |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6081 test rax, rax                                                             |             
                                                                                         |             if (rax != 0) {
    0x004c6084 jne 0x4c6090                                                              |                 goto label_15;
                                                                                         |             }
    0x004c6086 call 0x4eede0                                                             |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c608b nop dword [rax + rax]                                                     |             
                                                                                         |         }
                                                                                         | label_15:
    0x004c6090 cmp qword [rsp + 0x48], 6                                                 |         
    0x004c6096 mov ebx, dword [rsp + 0x14]                                               |         ebx = *((rsp + 0x14));
                                                                                         |         if (*((rsp + 0x48)) < 6) {
    0x004c609a jb 0x4c6303                                                               |             goto label_14;
                                                                                         |         }
    0x004c60a0 lea rax, [r15*4 + 0x74f5a0]                                               |         rax = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c60a8 lea rcx, [r13*4 + 0x74f5a0]                                               |         rcx = r13*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c60b0 mov rsi, qword [rsp + 0x18]                                               |         rsi = *((rsp + 0x18));
    0x004c60b5 lea edx, [rsi + r15]                                                      |         edx = rsi + r15;
    0x004c60b9 movsxd r9, edx                                                            |         r9 = (int64_t) edx;
    0x004c60bc shl r9, 2                                                                 |         r9 <<= 2;
    0x004c60c0 lea rdi, [r15*4]                                                          |         rdi = r15*4;
    0x004c60c8 mov r10, r9                                                               |         r10 = r9;
    0x004c60cb sub r10, rdi                                                              |         r10 -= rdi;
    0x004c60ce add r10, 0xfffffffffffffffc                                               |         r10 += 0xfffffffffffffffc;
    0x004c60d2 cmp r10, 0x1c                                                             |         
                                                                                         |         if (r10 < 0x1c) {
    0x004c60d6 jb 0x4c62e0                                                               |             goto label_16;
                                                                                         |         }
    0x004c60dc mov dword [rsp + 0x50], r14d                                              |         *((rsp + 0x50)) = r14d;
    0x004c60e1 mov r11, rbp                                                              |         r11 = rbp;
    0x004c60e4 lea rbp, [r13*4 + 0x74f5a0]                                               |         rbp = r13*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c60ec lea edx, [rsi + r15]                                                      |         edx = rsi + r15;
    0x004c60f0 movsxd rdx, edx                                                           |         rdx = (int64_t) edx;
    0x004c60f3 lea rbx, [rdx*4 + 0x74f5a0]                                               |         rbx = rdx*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c60fb cmp rbp, rbx                                                              |         
                                                                                         |         if (rbp >= rbx) {
    0x004c60fe jae 0x4c61a7                                                              |             goto label_17;
                                                                                         |         }
    0x004c6104 shl rdx, 2                                                                |         rdx <<= 2;
    0x004c6108 sub rdx, rdi                                                              |         rdx -= rdi;
    0x004c610b lea rdx, [rdx + r13*4 + 0x74f5a0]                                         |         rdx = rdx + r13*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6113 lea rbp, [r15*4 + 0x74f5a0]                                               |         rbp = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c611b cmp rbp, rdx                                                              |         
                                                                                         |         if (rbp >= rdx) {
    0x004c611e jae 0x4c61a7                                                              |             goto label_17;
                                                                                         |         }
    0x004c6124 mov rbp, r11                                                              |         
    0x004c6127 mov r14d, dword [rsp + 0x50]                                              |         r14d = *((rsp + 0x50));
    0x004c612c mov ebx, dword [rsp + 0x14]                                               |         ebx = *((rsp + 0x14));
    0x004c6130 jmp 0x4c62e0                                                              |         goto label_16;
    0x004c6135 mov ebx, 1                                                                |         ebx = 1;
    0x004c613a mov rax, qword [rip + 0x28b177]                                           |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6141 test rax, rax                                                             |         
    0x004c6144 jne 0x4c5ff2                                                              |         
                                                                                         |     }
    0x004c614a call 0x4eede0                                                             |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c614f jmp 0x4c5ff2                                                              |     goto label_0;
                                                                                         | label_17:
    0x004c61a7 shr r10, 2                                                                |     r10 >>= 2;
    0x004c61ab inc r10                                                                   |     r10++;
    0x004c61ae mov r8, r10                                                               |     r8 = r10;
    0x004c61b1 and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c61b5 lea rdx, [r8 - 8]                                                         |     rdx = r8 - 8;
    0x004c61b9 mov rbp, rdx                                                              |     
    0x004c61bc shr rbp, 3                                                                |     rbp >>= 3;
    0x004c61c0 inc rbp                                                                   |     rbp++;
    0x004c61c3 mov ebx, ebp                                                              |     ebx = ebp;
    0x004c61c5 and ebx, 3                                                                |     ebx &= 3;
    0x004c61c8 cmp rdx, 0x18                                                             |     
                                                                                         |     if (rdx < 0x18) {
    0x004c61cc jae 0x4c61d5                                                              |         
    0x004c61ce xor edx, edx                                                              |         edx = 0;
    0x004c61d0 jmp 0x4c6276                                                              |         goto label_18;
                                                                                         |     }
    0x004c61d5 and rbp, 0xfffffffffffffffc                                               |     rbp &= 0xfffffffffffffffc;
    0x004c61d9 neg rbp                                                                   |     rbp = -rbp;
    0x004c61dc xor edx, edx                                                              |     edx = 0;
    0x004c61de nop                                                                       |     
                                                                                         |     do {
    0x004c61e0 movups xmm0, xmmword [rdi + rdx*4 + 0x74f5a0]                             |         __asm ("movups xmm0, xmmword [rdi + rdx*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u]");
    0x004c61e8 movups xmm1, xmmword [rdi + rdx*4 + 0x74f5b0]                             |         __asm ("movups xmm1, xmmword [rdi + rdx*4 + 0x74f5b0]");
    0x004c61f0 lea rsi, [r13*4]                                                          |         rsi = r13*4;
    0x004c61f8 movups xmmword [rsi + rdx*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [rsi + rdx*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c6200 movups xmmword [rsi + rdx*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f5b0], xmm1");
    0x004c6208 movups xmm0, xmmword [rdi + rdx*4 + 0x74f5c0]                             |         __asm ("movups xmm0, xmmword [rdi + rdx*4 + 0x74f5c0]");
    0x004c6210 movups xmm1, xmmword [rdi + rdx*4 + 0x74f5d0]                             |         __asm ("movups xmm1, xmmword [rdi + rdx*4 + 0x74f5d0]");
    0x004c6218 movups xmmword [rsi + rdx*4 + 0x74f5c0], xmm0                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f5c0], xmm0");
    0x004c6220 movups xmmword [rsi + rdx*4 + 0x74f5d0], xmm1                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f5d0], xmm1");
    0x004c6228 movups xmm0, xmmword [rdi + rdx*4 + 0x74f5e0]                             |         __asm ("movups xmm0, xmmword [rdi + rdx*4 + obj.testCopyConstructWithIterators_double__bool__bool__bool_::u]");
    0x004c6230 movups xmm1, xmmword [rdi + rdx*4 + 0x74f5f0]                             |         __asm ("movups xmm1, xmmword [rdi + rdx*4 + 0x74f5f0]");
    0x004c6238 movups xmmword [rsi + rdx*4 + 0x74f5e0], xmm0                             |         __asm ("movups xmmword [rsi + rdx*4 + obj.testCopyConstructWithIterators_double__bool__bool__bool_::u], xmm0");
    0x004c6240 movups xmmword [rsi + rdx*4 + 0x74f5f0], xmm1                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f5f0], xmm1");
    0x004c6248 movups xmm0, xmmword [rdi + rdx*4 + 0x74f600]                             |         __asm ("movups xmm0, xmmword [rdi + rdx*4 + 0x74f600]");
    0x004c6250 movups xmm1, xmmword [rdi + rdx*4 + 0x74f610]                             |         __asm ("movups xmm1, xmmword [rdi + rdx*4 + 0x74f610]");
    0x004c6258 movups xmmword [rsi + rdx*4 + 0x74f600], xmm0                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f600], xmm0");
    0x004c6260 movups xmmword [rsi + rdx*4 + 0x74f610], xmm1                             |         __asm ("movups xmmword [rsi + rdx*4 + 0x74f610], xmm1");
    0x004c6268 add rdx, 0x20                                                             |         rdx += 0x20;
    0x004c626c add rbp, 4                                                                |         rbp += 4;
    0x004c6270 jne 0x4c61e0                                                              |         
                                                                                         |     } while (rbp != 0);
                                                                                         | label_18:
    0x004c6276 test rbx, rbx                                                             |     
                                                                                         |     if (rbx == 0) {
    0x004c6279 je 0x4c62bc                                                               |         goto label_19;
                                                                                         |     }
    0x004c627b shl r13, 2                                                                |     r13 <<= 2;
    0x004c627f lea rbp, [r13 + rdx*4 + 0x74f5b0]                                         |     rbp = r13 + rdx*4 + 0x74f5b0;
    0x004c6287 lea rdx, [rdi + rdx*4 + 0x74f5b0]                                         |     rdx = rdi + rdx*4 + 0x74f5b0;
    0x004c628f shl rbx, 5                                                                |     rbx <<= 5;
    0x004c6293 xor edi, edi                                                              |     edi = 0;
    0x004c6295 nop word cs:[rax + rax]                                                   |     
    0x004c629f nop                                                                       |     
                                                                                         |     do {
    0x004c62a0 movups xmm0, xmmword [rdx + rdi - 0x10]                                   |         __asm ("movups xmm0, xmmword [rdx + rdi - 0x10]");
    0x004c62a5 movups xmm1, xmmword [rdx + rdi]                                          |         __asm ("movups xmm1, xmmword [rdx + rdi]");
    0x004c62a9 movups xmmword [rbp + rdi - 0x10], xmm0                                   |         __asm ("movups xmmword [rbp + rdi - 0x10], xmm0");
    0x004c62ae movups xmmword [rbp + rdi], xmm1                                          |         __asm ("movups xmmword [rbp + rdi], xmm1");
    0x004c62b3 add rdi, 0x20                                                             |         rdi += 0x20;
    0x004c62b7 cmp rbx, rdi                                                              |         
    0x004c62ba jne 0x4c62a0                                                              |         
                                                                                         |     } while (rbx != rdi);
                                                                                         | label_19:
    0x004c62bc cmp r10, r8                                                               |     
    0x004c62bf mov rbp, r11                                                              |     
    0x004c62c2 mov r14d, dword [rsp + 0x50]                                              |     r14d = *((rsp + 0x50));
    0x004c62c7 mov ebx, dword [rsp + 0x14]                                               |     ebx = *((rsp + 0x14));
                                                                                         |     if (r10 == r8) {
    0x004c62cb je 0x4c6303                                                               |         goto label_14;
                                                                                         |     }
    0x004c62cd lea rax, [rax + r8*4]                                                     |     rax = rax + r8*4;
    0x004c62d1 lea rcx, [rcx + r8*4]                                                     |     rcx = rcx + r8*4;
    0x004c62d5 nop word cs:[rax + rax]                                                   |     
    0x004c62df nop                                                                       |     
                                                                                         | label_16:
    0x004c62e0 sub r9, rax                                                               |     r9 -= rax;
    0x004c62e3 lea rdx, [r9 + 0x74f5a0]                                                  |     rdx = r9 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c62ea xor esi, esi                                                              |     esi = 0;
    0x004c62ec nop dword [rax]                                                           |     
                                                                                         |     do {
    0x004c62f0 movss xmm0, dword [rax + rsi]                                             |         xmm0 = *((rax + rsi));
    0x004c62f5 movss dword [rcx + rsi], xmm0                                             |         *((rcx + rsi)) = xmm0;
    0x004c62fa add rsi, 4                                                                |         rsi += 4;
    0x004c62fe cmp rdx, rsi                                                              |         
    0x004c6301 jne 0x4c62f0                                                              |         
                                                                                         |     } while (rdx != rsi);
                                                                                         | label_14:
    0x004c6303 cmp byte [rip + 0x252686], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c630a je 0x4c632c                                                               |         
    0x004c630c mov edx, dword [rip + 0x252692]                                           |         edx = numCopyCtorCalls;
    0x004c6312 sub edx, r12d                                                             |         edx -= r12d;
    0x004c6315 mov ecx, dword [rip + 0x252691]                                           |         ecx = numCharCtorCalls;
    0x004c631b sub ecx, r14d                                                             |         ecx -= r14d;
    0x004c631e mov edi, 0x4f5db4                                                         |         
    0x004c6323 mov esi, ebx                                                              |         esi = ebx;
    0x004c6325 xor eax, eax                                                              |         eax = 0;
    0x004c6327 call 0x401680                                                             |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                         |     }
                                                                                         | label_13:
    0x004c632c cmp byte [rsp + 0x40], 0                                                  |     
                                                                                         |     if (*((rsp + 0x40)) == 0) {
    0x004c6331 je 0x4c6390                                                               |         goto label_20;
                                                                                         |     }
    0x004c6333 cmp r12d, dword [rip + 0x25266a]                                          |     
                                                                                         |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004c633a je 0x4c6365                                                               |         
    0x004c633c mov edi, 0x4f4e04                                                         |         
    0x004c6341 mov edx, 0x4f5176                                                         |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c6346 mov esi, 0x1005                                                           |         esi = 0x1005;
    0x004c634b xor eax, eax                                                              |         eax = 0;
    0x004c634d call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c6352 mov eax, dword [rip + 0x252640]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c6358 cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c635b ja 0x4c6365                                                               |             goto label_21;
                                                                                         |         }
    0x004c635d inc eax                                                                   |         eax++;
    0x004c635f mov dword [rip + 0x252633], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_21:
    0x004c6365 cmp r14d, dword [rip + 0x252640]                                          |     
                                                                                         |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004c636c je 0x4c5e90                                                               |         goto label_1;
                                                                                         |     }
    0x004c6372 mov edi, 0x4f4e04                                                         |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004c6377 mov edx, 0x4f5de4                                                         |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c637c mov esi, 0x1006                                                           |     esi = 0x1006;
    0x004c6381 jmp 0x4c63e3                                                              |     goto label_22;
                                                                                         | label_20:
    0x004c6390 add r12d, dword [rsp + 0x18]                                              |     r12d += *((rsp + 0x18));
    0x004c6395 cmp r12d, dword [rip + 0x252608]                                          |     
                                                                                         |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004c639c jle 0x4c63c7                                                              |         
    0x004c639e mov edi, 0x4f4e04                                                         |         
    0x004c63a3 mov edx, 0x4f5e02                                                         |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004c63a8 mov esi, 0x1009                                                           |         esi = 0x1009;
    0x004c63ad xor eax, eax                                                              |         eax = 0;
    0x004c63af call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c63b4 mov eax, dword [rip + 0x2525de]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c63ba cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c63bd ja 0x4c63c7                                                               |             goto label_23;
                                                                                         |         }
    0x004c63bf inc eax                                                                   |         eax++;
    0x004c63c1 mov dword [rip + 0x2525d1], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_23:
    0x004c63c7 cmp r14d, dword [rip + 0x2525de]                                          |     
                                                                                         |     if (r14d == *(obj.numCharCtorCalls)) {
    0x004c63ce je 0x4c5e90                                                               |         goto label_1;
                                                                                         |     }
    0x004c63d4 mov edi, 0x4f4e04                                                         |     
    0x004c63d9 mov edx, 0x4f5de4                                                         |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004c63de mov esi, 0x100a                                                           |     esi = 0x100a;
                                                                                         | label_22:
    0x004c63e3 xor eax, eax                                                              |     eax = 0;
    0x004c63e5 call 0x401680                                                             |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c63ea mov eax, dword [rip + 0x2525a8]                                           |     eax = (anonymous namespace)::testStatus;
    0x004c63f0 cmp eax, 0x64                                                             |     
                                                                                         |     if (eax > 0x64) {
    0x004c63f3 ja 0x4c5e90                                                               |         goto label_1;
                                                                                         |     }
    0x004c63f9 inc eax                                                                   |     eax++;
    0x004c63fb mov dword [rip + 0x252597], eax                                           |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c6401 jmp 0x4c5e90                                                              |     goto label_1;
                                                                                         | label_9:
    0x004c6406 cmp byte [rip + 0x252589], 0                                              |     
                                                                                         |     if (*(obj.verbose) != 0) {
    0x004c640d je 0x4c6419                                                               |         
    0x004c640f mov edi, 0x4f695c                                                         |         
    0x004c6414 call 0x401710                                                             |         puts ("\t\tfrom different type.");
                                                                                         |     }
    0x004c6419 xor r12d, r12d                                                            |     r12d = 0;
    0x004c641c jmp 0x4c6447                                                              |     goto label_24;
                                                                                         | label_2:
    0x004c6420 mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6425 mov rsi, r13                                                              |     rsi = r13;
    0x004c6428 call 0x4e10f0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c642d mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6432 mov rsi, r13                                                              |     rsi = r13;
    0x004c6435 call 0x4e1340                                                             |     voidcleanup<float>(float*,char const*) ();
    0x004c643a inc r12                                                                   |     r12++;
    0x004c643d cmp r12, 0x1e                                                             |     
                                                                                         |     if (r12 == 0x1e) {
    0x004c6441 je 0x4c69b7                                                               |         goto label_25;
                                                                                         |     }
                                                                                         | label_24:
    0x004c6447 lea r13, [r12*8]                                                          |     r13 = r12*8;
    0x004c644f mov rbx, qword [r13 + r13*4 + 0x4f3c98]                                   |     rbx = *((r13 + r13*4 + 0x4f3c98));
    0x004c6457 mov rdi, rbx                                                              |     
    0x004c645a call 0x401790                                                             |     eax = strlen (*((r13 + r13*4 + 0x4f3c98)));
    0x004c645f cmp eax, 0x11                                                             |     
                                                                                         |     if (eax >= 0x11) {
    0x004c6462 jl 0x4c648d                                                               |         
    0x004c6464 mov edi, 0x4f4e04                                                         |         
    0x004c6469 mov edx, 0x4f4393                                                         |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004c646e mov esi, 0x1019                                                           |         esi = 0x1019;
    0x004c6473 xor eax, eax                                                              |         eax = 0;
    0x004c6475 call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c647a mov eax, dword [rip + 0x252518]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c6480 cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c6483 ja 0x4c648d                                                               |             goto label_26;
                                                                                         |         }
    0x004c6485 inc eax                                                                   |         eax++;
    0x004c6487 mov dword [rip + 0x25250b], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_26:
    0x004c648d mov rdi, rbx                                                              |     
    0x004c6490 call 0x401790                                                             |     rax = strlen (rbx);
    0x004c6495 cmp rax, 0x14                                                             |     
                                                                                         |     if (rax >= 0x14) {
    0x004c6499 jb 0x4c64c4                                                               |         
    0x004c649b mov edi, 0x4f4e04                                                         |         
    0x004c64a0 mov edx, 0x4f5e26                                                         |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004c64a5 mov esi, 0x101c                                                           |         esi = 0x101c;
    0x004c64aa xor eax, eax                                                              |         eax = 0;
    0x004c64ac call 0x401680                                                             |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c64b1 mov eax, dword [rip + 0x2524e1]                                           |         eax = (anonymous namespace)::testStatus;
    0x004c64b7 cmp eax, 0x64                                                             |         
                                                                                         |         if (eax > 0x64) {
    0x004c64ba ja 0x4c64c4                                                               |             goto label_27;
                                                                                         |         }
    0x004c64bc inc eax                                                                   |         eax++;
    0x004c64be mov dword [rip + 0x2524d4], eax                                           |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                         |     }
                                                                                         | label_27:
    0x004c64c4 mov qword [rsp + 0x18], r12                                               |     *((rsp + 0x18)) = r12;
    0x004c64c9 xorps xmm0, xmm0                                                          |     __asm ("xorps xmm0, xmm0");
    0x004c64cc movaps xmmword [rsp + 0x20], xmm0                                         |     *((rsp + 0x20)) = xmm0;
    0x004c64d1 mov dword [rsp + 0x30], 0                                                 |     *((rsp + 0x30)) = 0;
    0x004c64d9 mov al, byte [rbx]                                                        |     al = *(rbx);
    0x004c64db test al, al                                                               |     
                                                                                         |     if (al == 0) {
    0x004c64dd je 0x4c6500                                                               |         goto label_28;
                                                                                         |     }
    0x004c64df xor ecx, ecx                                                              |     ecx = 0;
    0x004c64e1 nop word cs:[rax + rax]                                                   |     
    0x004c64eb nop dword [rax + rax]                                                     |     
                                                                                         |     do {
    0x004c64f0 mov byte [rsp + rcx + 0x20], al                                           |         *((rsp + rcx + 0x20)) = al;
    0x004c64f4 movzx eax, byte [rbx + rcx + 1]                                           |         eax = *((rbx + rcx + 1));
    0x004c64f9 inc rcx                                                                   |         rcx++;
    0x004c64fc test al, al                                                               |         
    0x004c64fe jne 0x4c64f0                                                              |         
                                                                                         |     } while (al != 0);
                                                                                         | label_28:
    0x004c6500 mov r14d, dword [r13 + r13*4 + 0x4f3c90]                                  |     r14d = *((r13 + r13*4 + obj.DATA_3));
    0x004c6508 movsxd rbp, dword [r13 + r13*4 + 0x4f3ca0]                                |     rbp = *((r13 + r13*4 + 0x4f3ca0));
    0x004c6510 movsxd r12, dword [r13 + r13*4 + 0x4f3ca4]                                |     r12 = *((r13 + r13*4 + 0x4f3ca4));
    0x004c6518 movsxd r15, dword [r13 + r13*4 + 0x4f3ca8]                                |     r15 = *((r13 + r13*4 + 0x4f3ca8));
    0x004c6520 mov r13, qword [r13 + r13*4 + 0x4f3cb0]                                   |     r13 = *((r13 + r13*4 + 0x4f3cb0));
    0x004c6528 cmp byte [rip + 0x252461], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c652f je 0x4c654f                                                               |         
    0x004c6531 mov qword [rsp], r13                                                      |         *(rsp) = r13;
    0x004c6535 mov edi, 0x4f5c41                                                         |         
    0x004c653a mov esi, r14d                                                             |         esi = r14d;
    0x004c653d mov rdx, rbx                                                              |         rdx = rbx;
    0x004c6540 mov ecx, ebp                                                              |         ecx = ebp;
    0x004c6542 mov r8d, r12d                                                             |         r8d = r12d;
    0x004c6545 mov r9d, r15d                                                             |         r9d = r15d;
    0x004c6548 xor eax, eax                                                              |         eax = 0;
    0x004c654a call 0x401680                                                             |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                         |     }
    0x004c654f mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6554 mov rsi, rbx                                                              |     rsi = rbx;
    0x004c6557 call 0x4e1000                                                             |     float&gg<float>(float*,char const*) ();
    0x004c655c mov edi, 0x74f5a0                                                         |     edi = testCopyConstructWithIterators<float>(bool, bool, bool)::u;
    0x004c6561 mov rsi, rbx                                                              |     rsi = rbx;
    0x004c6564 call 0x4e10f0                                                             |     voidverify<float>(float*,char const*) ();
    0x004c6569 mov eax, dword [rip + 0x252435]                                           |     eax = numCopyCtorCalls;
    0x004c656f mov dword [rsp + 0x48], eax                                               |     *((rsp + 0x48)) = eax;
    0x004c6573 mov eax, dword [rip + 0x252433]                                           |     eax = numCharCtorCalls;
    0x004c6579 mov dword [rsp + 0x14], eax                                               |     *((rsp + 0x14)) = eax;
    0x004c657d cmp byte [rsp + 0x54], 0                                                  |     
                                                                                         |     if (*((rsp + 0x54)) == 0) {
    0x004c6582 je 0x4c6750                                                               |         goto label_29;
                                                                                         |     }
    0x004c6588 cmp byte [rip + 0x252401], 0                                              |     
    0x004c658f mov ebx, r14d                                                             |     ebx = r14d;
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c6592 je 0x4c65a7                                                               |         
    0x004c6594 cmp dword [rip + 0x251fd9], 0                                             |         
                                                                                         |         if (*(0x00718574) == 0) {
    0x004c659b je 0x4c65a7                                                               |             goto label_30;
                                                                                         |         }
    0x004c659d mov edi, 0x4f43ea                                                         |         
    0x004c65a2 call 0x401710                                                             |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                         |     }
                                                                                         | label_30:
    0x004c65a7 mov dword [rip + 0x251fc3], 0                                             |     *(0x00718574) = 0;
    0x004c65b1 cmp byte [rip + 0x2523dd], 0                                              |     
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c65b8 je 0x4c65c4                                                               |         
    0x004c65ba mov edi, 0x4f4411                                                         |         
    0x004c65bf call 0x401710                                                             |         puts ("\t\tBegin bslma exception test.");
                                                                                         |     }
    0x004c65c4 mov rax, qword [rip + 0x252255]                                           |     rax = Z;
    0x004c65cb mov qword [rsp + 0x58], 0x4f69e0                                          |     *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004c65d4 mov qword [rsp + 0x60], rax                                               |     *((rsp + 0x60)) = rax;
    0x004c65d9 mov qword [rax + 0x20], 0                                                 |     *((rax + 0x20)) = 0;
    0x004c65e1 test rax, rax                                                             |     
                                                                                         |     if (rax == 0) {
    0x004c65e4 je 0x4c6915                                                               |         goto label_31;
                                                                                         |     }
                                                                                         | label_3:
    0x004c65ea cmp qword [rsp + 0x18], 6                                                 |     
                                                                                         |     if (*((rsp + 0x18)) < 6) {
    0x004c65f0 jb 0x4c6708                                                               |         goto label_32;
                                                                                         |     }
    0x004c65f6 lea rcx, [rsp + rbp + 0x20]                                               |     rcx = rsp + rbp + 0x20;
    0x004c65fb lea rsi, [r15*4 + 0x74f5a0]                                               |     rsi = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6603 lea eax, [rbp + r12]                                                      |     eax = rbp + r12;
    0x004c6608 movsxd r9, eax                                                            |     r9 = (int64_t) eax;
    0x004c660b mov rdx, r9                                                               |     rdx = r9;
    0x004c660e sub rdx, rbp                                                              |     rdx -= rbp;
    0x004c6611 cmp rdx, 8                                                                |     
                                                                                         |     if (rdx < 8) {
    0x004c6615 jb 0x4c66db                                                               |         goto label_33;
                                                                                         |     }
    0x004c661b mov r8, rdx                                                               |     r8 = rdx;
    0x004c661e and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c6622 lea rdi, [r8 - 8]                                                         |     rdi = r8 - 8;
    0x004c6626 mov r10, rdi                                                              |     r10 = rdi;
    0x004c6629 shr r10, 3                                                                |     r10 >>= 3;
    0x004c662d inc r10                                                                   |     r10++;
    0x004c6630 test rdi, rdi                                                             |     
                                                                                         |     if (rdi == 0) {
    0x004c6633 je 0x4c69a6                                                               |         goto label_34;
                                                                                         |     }
    0x004c6639 lea rax, [rsp + 0x2c]                                                     |     rax = rsp + 0x2c;
    0x004c663e add rbp, rax                                                              |     rbp += rax;
    0x004c6641 mov rbx, r10                                                              |     rbx = r10;
    0x004c6644 and rbx, 0xfffffffffffffffe                                               |     rbx &= 0xfffffffffffffffe;
    0x004c6648 neg rbx                                                                   |     rbx = -rbx;
    0x004c664b xor edi, edi                                                              |     edi = 0;
    0x004c664d nop dword [rax]                                                           |     
                                                                                         |     do {
    0x004c6650 pmovsxbd xmm0, dword [rbp + rdi - 0xc]                                    |         __asm ("pmovsxbd xmm0, dword [rbp + rdi - 0xc]");
    0x004c6657 pmovsxbd xmm1, dword [rbp + rdi - 8]                                      |         __asm ("pmovsxbd xmm1, dword [rbp + rdi - 8]");
    0x004c665e cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c6661 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6664 lea rax, [r15*4]                                                          |         rax = r15*4;
    0x004c666c movups xmmword [rax + rdi*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [rax + rdi*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c6674 movups xmmword [rax + rdi*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5b0], xmm1");
    0x004c667c pmovsxbd xmm0, dword [rbp + rdi - 4]                                      |         __asm ("pmovsxbd xmm0, dword [rbp + rdi - 4]");
    0x004c6683 pmovsxbd xmm1, dword [rbp + rdi]                                          |         __asm ("pmovsxbd xmm1, dword [rbp + rdi]");
    0x004c668a cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c668d cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6690 movups xmmword [rax + rdi*4 + 0x74f5c0], xmm0                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5c0], xmm0");
    0x004c6698 movups xmmword [rax + rdi*4 + 0x74f5d0], xmm1                             |         __asm ("movups xmmword [rax + rdi*4 + 0x74f5d0], xmm1");
    0x004c66a0 add rdi, 0x10                                                             |         rdi += 0x10;
    0x004c66a4 add rbx, 2                                                                |         rbx += 2;
    0x004c66a8 jne 0x4c6650                                                              |         
                                                                                         |     } while (rbx != 0);
    0x004c66aa test r10b, 1                                                              |     
                                                                                         |     if ((r10b & 1) != 0) {
    0x004c66ae je 0x4c66cc                                                               |         
                                                                                         | label_6:
    0x004c66b0 pmovsxbd xmm0, dword [rcx + rdi]                                          |         __asm ("pmovsxbd xmm0, dword [rcx + rdi]");
    0x004c66b6 pmovsxbd xmm1, dword [rcx + rdi + 4]                                      |         __asm ("pmovsxbd xmm1, dword [rcx + rdi + 4]");
    0x004c66bd cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c66c0 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c66c3 movups xmmword [rsi + rdi*4], xmm0                                        |         __asm ("movups xmmword [rsi + rdi*4], xmm0");
    0x004c66c7 movups xmmword [rsi + rdi*4 + 0x10], xmm1                                 |         __asm ("movups xmmword [rsi + rdi*4 + 0x10], xmm1");
                                                                                         |     }
                                                                                         | label_7:
    0x004c66cc cmp rdx, r8                                                               |     
    0x004c66cf mov ebx, r14d                                                             |     ebx = r14d;
                                                                                         |     if (rdx == r8) {
    0x004c66d2 je 0x4c6708                                                               |         goto label_32;
                                                                                         |     }
    0x004c66d4 add rcx, r8                                                               |     rcx += r8;
    0x004c66d7 lea rsi, [rsi + r8*4]                                                     |     rsi = rsi + r8*4;
                                                                                         | label_33:
    0x004c66db sub r9, rcx                                                               |     r9 -= rcx;
    0x004c66de lea rax, [rsp + r9 + 0x20]                                                |     rax = rsp + r9 + 0x20;
    0x004c66e3 xor edi, edi                                                              |     edi = 0;
    0x004c66e5 nop word cs:[rax + rax]                                                   |     
    0x004c66ef nop                                                                       |     
                                                                                         |     do {
    0x004c66f0 movsx edx, byte [rcx + rdi]                                               |         edx = *((rcx + rdi));
    0x004c66f4 xorps xmm0, xmm0                                                          |         __asm ("xorps xmm0, xmm0");
    0x004c66f7 cvtsi2ss xmm0, edx                                                        |         __asm ("cvtsi2ss xmm0, edx");
    0x004c66fb movss dword [rsi + rdi*4], xmm0                                           |         *((rsi + rdi*4)) = xmm0;
    0x004c6700 inc rdi                                                                   |         rdi++;
    0x004c6703 cmp rax, rdi                                                              |         
    0x004c6706 jne 0x4c66f0                                                              |         
                                                                                         |     } while (rax != rdi);
                                                                                         | label_32:
    0x004c6708 mov rax, qword [rsp + 0x58]                                               |     rax = *((rsp + 0x58));
    0x004c670d lea rdi, [rsp + 0x58]                                                     |     rdi = rsp + 0x58;
    0x004c6712 mov rsi, 0xffffffffffffffff                                               |     rsi = 0xffffffffffffffff;
    0x004c6719 call qword [rax + 0x10]                                                   |     uint64_t (*rax + 0x10)() ();
    0x004c671c cmp byte [rip + 0x252272], 0                                              |     
    0x004c6723 mov r12, qword [rsp + 0x18]                                               |     r12 = *((rsp + 0x18));
                                                                                         |     if (*(obj.veryVeryVerbose) != 0) {
    0x004c6728 je 0x4c6734                                                               |         
    0x004c672a mov edi, 0x4f4571                                                         |         
    0x004c672f call 0x401710                                                             |         puts ("\t\tEnd bslma exception test.");
                                                                                         |     }
    0x004c6734 cmp byte [rip + 0x252255], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) == 0) {
    0x004c673b je 0x4c68d3                                                               |         goto label_35;
                                                                                         |     }
    0x004c6741 mov edi, 0xa                                                              |     
    0x004c6746 call 0x401720                                                             |     putchar (0xa);
    0x004c674b jmp 0x4c68a8                                                              |     goto label_36;
                                                                                         | label_29:
    0x004c6750 cmp qword [rip + 0x2520c8], 0                                             |     
    0x004c6758 mov ebx, r14d                                                             |     ebx = r14d;
    0x004c675b mov r10, r12                                                              |     r10 = r12;
                                                                                         |     if (*(obj.Z) == 0) {
    0x004c675e jne 0x4c6780                                                              |         
    0x004c6760 mov rax, qword [rip + 0x28ab51]                                           |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6767 test rax, rax                                                             |         
                                                                                         |         if (rax != 0) {
    0x004c676a jne 0x4c6780                                                              |             goto label_37;
                                                                                         |         }
    0x004c676c call 0x4eede0                                                             |         BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c6771 mov r10, r12                                                              |         r10 = r12;
    0x004c6774 nop word cs:[rax + rax]                                                   |         
    0x004c677e nop                                                                       |         
                                                                                         |     }
                                                                                         | label_37:
    0x004c6780 mov r12, qword [rsp + 0x18]                                               |     r12 = *((rsp + 0x18));
    0x004c6785 cmp r12, 6                                                                |     
                                                                                         |     if (r12 < 6) {
    0x004c6789 jb 0x4c68a8                                                               |         goto label_36;
                                                                                         |     }
    0x004c678f lea rax, [r15*4 + 0x74f5a0]                                               |     rax = r15*4 + obj_testCopyConstructWithIterators_float__bool__bool__bool_::u;
    0x004c6797 lea rcx, [rsp + rbp + 0x20]                                               |     rcx = rsp + rbp + 0x20;
    0x004c679c add r10, rbp                                                              |     r10 += rbp;
    0x004c679f mov rdx, r10                                                              |     rdx = r10;
    0x004c67a2 sub rdx, rbp                                                              |     rdx -= rbp;
    0x004c67a5 cmp rdx, 8                                                                |     
                                                                                         |     if (rdx < 8) {
    0x004c67a9 jb 0x4c687b                                                               |         goto label_38;
                                                                                         |     }
    0x004c67af mov r8, rdx                                                               |     r8 = rdx;
    0x004c67b2 and r8, 0xfffffffffffffff8                                                |     r8 &= 0xfffffffffffffff8;
    0x004c67b6 lea rdi, [r8 - 8]                                                         |     rdi = r8 - 8;
    0x004c67ba mov r9, rdi                                                               |     r9 = rdi;
    0x004c67bd shr r9, 3                                                                 |     r9 >>= 3;
    0x004c67c1 inc r9                                                                    |     r9++;
    0x004c67c4 test rdi, rdi                                                             |     
                                                                                         |     if (rdi == 0) {
    0x004c67c7 je 0x4c6995                                                               |         goto label_39;
                                                                                         |     }
    0x004c67cd lea rsi, [rsp + 0x2c]                                                     |     rsi = rsp + 0x2c;
    0x004c67d2 add rbp, rsi                                                              |     rbp += rsi;
    0x004c67d5 mov rdi, r9                                                               |     rdi = r9;
    0x004c67d8 and rdi, 0xfffffffffffffffe                                               |     rdi &= 0xfffffffffffffffe;
    0x004c67dc neg rdi                                                                   |     rdi = -rdi;
    0x004c67df xor ebx, ebx                                                              |     ebx = 0;
    0x004c67e1 nop word cs:[rax + rax]                                                   |     
    0x004c67eb nop dword [rax + rax]                                                     |     
                                                                                         |     do {
    0x004c67f0 pmovsxbd xmm0, dword [rbp + rbx - 0xc]                                    |         __asm ("pmovsxbd xmm0, dword [rbp + rbx - 0xc]");
    0x004c67f7 pmovsxbd xmm1, dword [rbp + rbx - 8]                                      |         __asm ("pmovsxbd xmm1, dword [rbp + rbx - 8]");
    0x004c67fe cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c6801 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6804 lea rsi, [r15*4]                                                          |         rsi = r15*4;
    0x004c680c movups xmmword [rsi + rbx*4 + 0x74f5a0], xmm0                             |         __asm ("movups xmmword [rsi + rbx*4 + obj.testCopyConstructWithIterators_float__bool__bool__bool_::u], xmm0");
    0x004c6814 movups xmmword [rsi + rbx*4 + 0x74f5b0], xmm1                             |         __asm ("movups xmmword [rsi + rbx*4 + 0x74f5b0], xmm1");
    0x004c681c pmovsxbd xmm0, dword [rbp + rbx - 4]                                      |         __asm ("pmovsxbd xmm0, dword [rbp + rbx - 4]");
    0x004c6823 pmovsxbd xmm1, dword [rbp + rbx]                                          |         __asm ("pmovsxbd xmm1, dword [rbp + rbx]");
    0x004c682a cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c682d cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6830 movups xmmword [rsi + rbx*4 + 0x74f5c0], xmm0                             |         __asm ("movups xmmword [rsi + rbx*4 + 0x74f5c0], xmm0");
    0x004c6838 movups xmmword [rsi + rbx*4 + 0x74f5d0], xmm1                             |         __asm ("movups xmmword [rsi + rbx*4 + 0x74f5d0], xmm1");
    0x004c6840 add rbx, 0x10                                                             |         rbx += 0x10;
    0x004c6844 add rdi, 2                                                                |         rdi += 2;
    0x004c6848 jne 0x4c67f0                                                              |         
                                                                                         |     } while (rdi != 0);
    0x004c684a test r9b, 1                                                               |     
                                                                                         |     if ((r9b & 1) != 0) {
    0x004c684e je 0x4c686c                                                               |         
                                                                                         | label_4:
    0x004c6850 pmovsxbd xmm0, dword [rcx + rbx]                                          |         __asm ("pmovsxbd xmm0, dword [rcx + rbx]");
    0x004c6856 pmovsxbd xmm1, dword [rcx + rbx + 4]                                      |         __asm ("pmovsxbd xmm1, dword [rcx + rbx + 4]");
    0x004c685d cvtdq2ps xmm0, xmm0                                                       |         __asm ("cvtdq2ps xmm0, xmm0");
    0x004c6860 cvtdq2ps xmm1, xmm1                                                       |         __asm ("cvtdq2ps xmm1, xmm1");
    0x004c6863 movups xmmword [rax + rbx*4], xmm0                                        |         __asm ("movups xmmword [rax + rbx*4], xmm0");
    0x004c6867 movups xmmword [rax + rbx*4 + 0x10], xmm1                                 |         __asm ("movups xmmword [rax + rbx*4 + 0x10], xmm1");
                                                                                         |     }
                                                                                         | label_5:
    0x004c686c cmp rdx, r8                                                               |     
    0x004c686f mov ebx, r14d                                                             |     ebx = r14d;
                                                                                         |     if (rdx == r8) {
    0x004c6872 je 0x4c68a8                                                               |         goto label_36;
                                                                                         |     }
    0x004c6874 add rcx, r8                                                               |     rcx += r8;
    0x004c6877 lea rax, [rax + r8*4]                                                     |     rax = rax + r8*4;
                                                                                         | label_38:
    0x004c687b sub r10, rcx                                                              |     r10 -= rcx;
    0x004c687e lea rdx, [rsp + r10 + 0x20]                                               |     rdx = rsp + r10 + 0x20;
    0x004c6883 xor esi, esi                                                              |     esi = 0;
    0x004c6885 nop word cs:[rax + rax]                                                   |     
    0x004c688f nop                                                                       |     
                                                                                         |     do {
    0x004c6890 movsx edi, byte [rcx + rsi]                                               |         edi = *((rcx + rsi));
    0x004c6894 xorps xmm0, xmm0                                                          |         __asm ("xorps xmm0, xmm0");
    0x004c6897 cvtsi2ss xmm0, edi                                                        |         __asm ("cvtsi2ss xmm0, edi");
    0x004c689b movss dword [rax + rsi*4], xmm0                                           |         *((rax + rsi*4)) = xmm0;
    0x004c68a0 inc rsi                                                                   |         rsi++;
    0x004c68a3 cmp rdx, rsi                                                              |         
    0x004c68a6 jne 0x4c6890                                                              |         
                                                                                         |     } while (rdx != rsi);
                                                                                         | label_36:
    0x004c68a8 cmp byte [rip + 0x2520e1], 0                                              |     
                                                                                         |     if (*(obj.veryVerbose) != 0) {
    0x004c68af je 0x4c68d3                                                               |         
    0x004c68b1 mov edx, dword [rip + 0x2520ed]                                           |         edx = numCopyCtorCalls;
    0x004c68b7 sub edx, dword [rsp + 0x48]                                               |         edx -= *((rsp + 0x48));
    0x004c68bb mov ecx, dword [rip + 0x2520eb]                                           |         ecx = numCharCtorCalls;
    0x004c68c1 sub ecx, dword [rsp + 0x14]                                               |         ecx -= *((rsp + 0x14));
    0x004c68c5 mov edi, 0x4f5db4                                                         |         
    0x004c68ca mov esi, ebx                                                              |         esi = ebx;
    0x004c68cc xor eax, eax                                                              |         eax = 0;
    0x004c68ce call 0x401680                                                             |         printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                         |     }
                                                                                         | label_35:
    0x004c68d3 mov eax, dword [rsp + 0x48]                                               |     eax = *((rsp + 0x48));
    0x004c68d7 cmp eax, dword [rip + 0x2520c7]                                           |     
                                                                                         |     if (eax == *(obj.numCopyCtorCalls)) {
    0x004c68dd je 0x4c6420                                                               |         goto label_2;
                                                                                         |     }
    0x004c68e3 mov edi, 0x4f4e04                                                         |     
    0x004c68e8 mov edx, 0x4f5176                                                         |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004c68ed mov esi, 0x103f                                                           |     esi = 0x103f;
    0x004c68f2 xor eax, eax                                                              |     eax = 0;
    0x004c68f4 call 0x401680                                                             |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004c68f9 mov eax, dword [rip + 0x252099]                                           |     eax = (anonymous namespace)::testStatus;
    0x004c68ff cmp eax, 0x64                                                             |     
                                                                                         |     if (eax > 0x64) {
    0x004c6902 ja 0x4c6420                                                               |         goto label_2;
                                                                                         |     }
    0x004c6908 inc eax                                                                   |     eax++;
    0x004c690a mov dword [rip + 0x252088], eax                                           |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004c6910 jmp 0x4c6420                                                              |     goto label_2;
                                                                                         | label_31:
    0x004c6915 mov eax, 1                                                                |     eax = 1;
    0x004c691a mov qword [rsp + 0x40], rax                                               |     *((rsp + 0x40)) = rax;
    0x004c691f mov rax, qword [rip + 0x28a992]                                           |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004c6926 test rax, rax                                                             |     
                                                                                         |     if (rax != 0) {
    0x004c6929 jne 0x4c65ea                                                              |         goto label_3;
                                                                                         |     }
    0x004c692f call 0x4eede0                                                             |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004c6934 jmp 0x4c65ea                                                              |     goto label_3;
                                                                                         | label_39:
    0x004c6995 xor ebx, ebx                                                              |     ebx = 0;
    0x004c6997 test r9b, 1                                                               |     
                                                                                         |     if ((r9b & 1) != 0) {
    0x004c699b jne 0x4c6850                                                              |         goto label_4;
                                                                                         |     }
    0x004c69a1 jmp 0x4c686c                                                              |     goto label_5;
                                                                                         | label_34:
    0x004c69a6 xor edi, edi                                                              |     edi = 0;
    0x004c69a8 test r10b, 1                                                              |     
                                                                                         |     if ((r10b & 1) != 0) {
    0x004c69ac jne 0x4c66b0                                                              |         goto label_6;
                                                                                         |     }
    0x004c69b2 jmp 0x4c66cc                                                              |     goto label_7;
                                                                                         | label_25:
    0x004c69b7 add rsp, 0x68                                                             |     
    0x004c69bb pop rbx                                                                   |     
    0x004c69bc pop r12                                                                   |     
    0x004c69be pop r13                                                                   |     
    0x004c69c0 pop r14                                                                   |     
    0x004c69c2 pop r15                                                                   |     
    0x004c69c4 pop rbp                                                                   |     
    0x004c69c5 ret                                                                       |     return rax;
                                                                                         | }