; assembly                                                                               | /* r2dec pseudo code output */
                                                                                             | /* bslalg_arrayprimitives.t/none @ 0x4bec80 */
                                                                                             | #include <stdint.h>
                                                                                             |  
    ; (fcn) sym.void_testCopyConstructWithIterators_signed_char__bool__bool__bool_ ()        | uint64_t void_testCopyConstructWithIterators_signed_char_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                             |     int64_t var_8h;
                                                                                             |     int64_t var_10h;
                                                                                             |     int64_t var_18h;
                                                                                             |     uint32_t var_20h;
                                                                                             |     uint32_t var_2ch;
                                                                                             |     void * s2;
                                                                                             |     int64_t var_38h;
                                                                                             |     int64_t var_40h;
                                                                                             |     uint32_t var_44h;
                                                                                             |     int64_t var_48h;
                                                                                             |     int64_t var_50h;
                                                                                             |     rdx = arg3;
                                                                                             |     rsi = arg2;
                                                                                             |     /* void testCopyConstructWithIterators<signed char>(bool, bool, bool) */
    0x004bec80 push rbp                                                                      |     
    0x004bec81 push r15                                                                      |     
    0x004bec83 push r14                                                                      |     
    0x004bec85 push r13                                                                      |     
    0x004bec87 push r12                                                                      |     
    0x004bec89 push rbx                                                                      |     
    0x004bec8a sub rsp, 0x58                                                                 |     
    0x004bec8e mov dword [rsp + 0x2c], edx                                                   |     *((rsp + 0x2c)) = edx;
    0x004bec92 mov dword [rsp + 0x44], esi                                                   |     *((rsp + 0x44)) = esi;
    0x004bec96 cmp byte [rip + 0x259cf9], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004bec9d je 0x4beca9                                                                   |         
    0x004bec9f mov edi, 0x4f6973                                                             |         
    0x004beca4 call 0x401710                                                                 |         eax = puts ("\t\tfrom same type.");
                                                                                             |     }
    0x004beca9 xor eax, eax                                                                  |     eax = 0;
    0x004becab jmp 0x4becdc                                                                  |     goto label_6;
                                                                                             | label_1:
    0x004becb0 mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004becb5 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004becb8 call 0x4ddec0                                                                 |     voidverify<signedchar>(signedchar*,char const*) ();
    0x004becbd mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004becc2 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004becc5 call 0x4de100                                                                 |     voidcleanup<signedchar>(signedchar*,char const*) ();
    0x004becca mov rax, qword [rsp + 0x20]                                                   |     rax = *((rsp + 0x20));
    0x004beccf inc rax                                                                       |     rax++;
    0x004becd2 cmp rax, 0x1e                                                                 |     
                                                                                             |     if (rax == 0x1e) {
    0x004becd6 je 0x4bf25a                                                                   |         goto label_7;
                                                                                             |     }
                                                                                             | label_6:
    0x004becdc mov qword [rsp + 0x20], rax                                                   |     *((rsp + 0x20)) = rax;
    0x004bece1 lea rbx, [rax*8]                                                              |     rbx = rax*8;
    0x004bece9 mov r12, qword [rbx + rbx*4 + 0x4f3c98]                                       |     r12 = *((rbx + rbx*4 + 0x4f3c98));
    0x004becf1 mov rdi, r12                                                                  |     
    0x004becf4 call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004becf9 cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004becfc jl 0x4bed27                                                                   |         
    0x004becfe mov edi, 0x4f4e04                                                             |         
    0x004bed03 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bed08 mov esi, 0xfe6                                                                |         esi = 0xfe6;
    0x004bed0d xor eax, eax                                                                  |         eax = 0;
    0x004bed0f call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bed14 mov eax, dword [rip + 0x259c7e]                                               |         eax = (anonymous namespace)::testStatus;
    0x004bed1a cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004bed1d ja 0x4bed27                                                                   |             goto label_8;
                                                                                             |         }
    0x004bed1f inc eax                                                                       |         eax++;
    0x004bed21 mov dword [rip + 0x259c71], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_8:
    0x004bed27 mov r13d, dword [rbx + rbx*4 + 0x4f3c90]                                      |     r13d = *((rbx + rbx*4 + obj.DATA_3));
    0x004bed2f movsxd r15, dword [rbx + rbx*4 + 0x4f3ca0]                                    |     r15 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004bed37 mov ebp, dword [rbx + rbx*4 + 0x4f3ca4]                                       |     ebp = *((rbx + rbx*4 + 0x4f3ca4));
    0x004bed3e movsxd r14, dword [rbx + rbx*4 + 0x4f3ca8]                                    |     r14 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004bed46 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                       |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004bed4e cmp byte [rip + 0x259c3b], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004bed55 je 0x4bed76                                                                   |         
    0x004bed57 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004bed5b mov edi, 0x4f5c41                                                             |         
    0x004bed60 mov esi, r13d                                                                 |         esi = r13d;
    0x004bed63 mov rdx, r12                                                                  |         rdx = r12;
    0x004bed66 mov ecx, r15d                                                                 |         ecx = r15d;
    0x004bed69 mov r8d, ebp                                                                  |         r8d = ebp;
    0x004bed6c mov r9d, r14d                                                                 |         r9d = r14d;
    0x004bed6f xor eax, eax                                                                  |         eax = 0;
    0x004bed71 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004bed76 mov qword [rsp + 0x18], rbp                                                   |     *((rsp + 0x18)) = rbp;
    0x004bed7b mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bed80 mov rsi, r12                                                                  |     rsi = r12;
    0x004bed83 call 0x4ddde0                                                                 |     signedchar&gg<signedchar>(signedchar*,char const*) ();
    0x004bed88 mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bed8d mov rsi, r12                                                                  |     rsi = r12;
    0x004bed90 call 0x4ddec0                                                                 |     voidverify<signedchar>(signedchar*,char const*) ();
    0x004bed95 mov r12d, dword [rip + 0x259c08]                                              |     r12d = numCopyCtorCalls;
    0x004bed9c mov ebp, dword [rip + 0x259c0a]                                               |     ebp = numCharCtorCalls;
    0x004beda2 cmp byte [rsp + 0x2c], 0                                                      |     
    0x004beda7 mov qword [rsp + 0x10], rbx                                                   |     *((rsp + 0x10)) = rbx;
                                                                                             |     if (*((rsp + 0x2c)) == 0) {
    0x004bedac je 0x4bee80                                                                   |         goto label_9;
                                                                                             |     }
    0x004bedb2 cmp byte [rip + 0x259bd7], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004bedb9 je 0x4bedce                                                                   |         
    0x004bedbb cmp dword [rip + 0x25975e], 0                                                 |         
                                                                                             |         if (*(0x00718520) == 0) {
    0x004bedc2 je 0x4bedce                                                                   |             goto label_10;
                                                                                             |         }
    0x004bedc4 mov edi, 0x4f43ea                                                             |         
    0x004bedc9 call 0x401710                                                                 |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |     }
                                                                                             | label_10:
    0x004bedce mov dword [rip + 0x259748], 0                                                 |     *(0x00718520) = 0;
    0x004bedd8 cmp byte [rip + 0x259bb6], 0                                                  |     
                                                                                             |     if (*(obj.veryVeryVerbose) != 0) {
    0x004beddf je 0x4bedeb                                                                   |         
    0x004bede1 mov edi, 0x4f4411                                                             |         
    0x004bede6 call 0x401710                                                                 |         puts ("\t\tBegin bslma exception test.");
                                                                                             |     }
    0x004bedeb mov rax, qword [rip + 0x259a2e]                                               |     rax = Z;
    0x004bedf2 mov qword [rsp + 0x30], 0x4f69e0                                              |     *((rsp + 0x30)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bedfb mov qword [rsp + 0x38], rax                                                   |     *((rsp + 0x38)) = rax;
    0x004bee00 mov qword [rax + 0x20], 0                                                     |     *((rax + 0x20)) = 0;
    0x004bee08 test rax, rax                                                                 |     
    0x004bee0b je 0x4bef21                                                                   |     
                                                                                             |     while (rax != 0) {
                                                                                             | label_0:
    0x004bee11 lea rsi, [r15 + 0x74f2c0]                                                     |         rsi = r15 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bee18 mov rax, qword [rsp + 0x18]                                                   |         rax = *((rsp + 0x18));
    0x004bee1d add eax, r15d                                                                 |         eax += r15d;
    0x004bee20 cdqe                                                                          |         rax = (int64_t) eax;
    0x004bee22 lea rdx, [rax + 0x74f2c0]                                                     |         rdx = rax + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bee29 sub rdx, rsi                                                                  |         rdx -= rsi;
                                                                                             |         if (rdx != 0) {
    0x004bee2c je 0x4bee3a                                                                   |             
    0x004bee2e lea rdi, [r14 + 0x74f2c0]                                                     |             
    0x004bee35 call 0x401930                                                                 |             memcpy (r14 + obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::u, rsi, rdx);
                                                                                             |         }
    0x004bee3a mov rax, qword [rsp + 0x30]                                                   |         rax = *((rsp + 0x30));
    0x004bee3f lea rdi, [rsp + 0x30]                                                         |         rdi = rsp + 0x30;
    0x004bee44 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004bee4b call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004bee4e cmp byte [rip + 0x259b40], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bee55 je 0x4bee61                                                                   |             
    0x004bee57 mov edi, 0x4f4571                                                             |             
    0x004bee5c call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004bee61 cmp byte [rip + 0x259b28], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004bee68 je 0x4bf185                                                                   |             goto label_11;
                                                                                             |         }
    0x004bee6e mov edi, 0xa                                                                  |         
    0x004bee73 call 0x401720                                                                 |         putchar (0xa);
    0x004bee78 mov esi, r13d                                                                 |         esi = r13d;
    0x004bee7b jmp 0x4bf15f                                                                  |         goto label_12;
                                                                                             | label_9:
    0x004bee80 cmp qword [rip + 0x259998], 0                                                 |         
                                                                                             |         if (*(obj.Z) == 0) {
    0x004bee88 jne 0x4beea0                                                                  |             
    0x004bee8a mov rax, qword [rip + 0x292427]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bee91 test rax, rax                                                                 |             
                                                                                             |             if (rax != 0) {
    0x004bee94 jne 0x4beea0                                                                  |                 goto label_13;
                                                                                             |             }
    0x004bee96 call 0x4eede0                                                                 |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bee9b nop dword [rax + rax]                                                         |             
                                                                                             |         }
                                                                                             | label_13:
    0x004beea0 cmp qword [rsp + 0x20], 6                                                     |         
    0x004beea6 mov esi, r13d                                                                 |         esi = r13d;
                                                                                             |         if (*((rsp + 0x20)) < 6) {
    0x004beea9 jb 0x4bf15f                                                                   |             goto label_12;
                                                                                             |         }
    0x004beeaf lea rax, [r15 + 0x74f2c0]                                                     |         rax = r15 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004beeb6 lea rcx, [r14 + 0x74f2c0]                                                     |         rcx = r14 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004beebd mov rbx, qword [rsp + 0x18]                                                   |         rbx = *((rsp + 0x18));
    0x004beec2 lea edx, [rbx + r15]                                                          |         edx = rbx + r15;
    0x004beec6 movsxd r9, edx                                                                |         r9 = (int64_t) edx;
    0x004beec9 mov r10, r9                                                                   |         r10 = r9;
    0x004beecc sub r10, r15                                                                  |         r10 -= r15;
    0x004beecf cmp r10, 4                                                                    |         
                                                                                             |         if (r10 < 4) {
    0x004beed3 jb 0x4bf140                                                                   |             goto label_14;
                                                                                             |         }
    0x004beed9 mov dword [rsp + 8], ebp                                                      |         *((rsp + 8)) = ebp;
    0x004beedd lea rdi, [r14 + 0x74f2c0]                                                     |         rdi = r14 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004beee4 lea edx, [rbx + r15]                                                          |         edx = rbx + r15;
    0x004beee8 movsxd rdx, edx                                                               |         rdx = (int64_t) edx;
    0x004beeeb lea rbp, [rdx + 0x74f2c0]                                                     |         rbp = rdx + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004beef2 cmp rdi, rbp                                                                  |         
                                                                                             |         if (rdi >= rbp) {
    0x004beef5 jae 0x4befa1                                                                  |             goto label_15;
                                                                                             |         }
    0x004beefb add rdx, r14                                                                  |         rdx += r14;
    0x004beefe sub rdx, r15                                                                  |         rdx -= r15;
    0x004bef01 lea rdx, [rdx + 0x74f2c0]                                                     |         rdx = rdx + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bef08 lea rdi, [r15 + 0x74f2c0]                                                     |         rdi = r15 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bef0f cmp rdi, rdx                                                                  |         
                                                                                             |         if (rdi >= rdx) {
    0x004bef12 jae 0x4befa1                                                                  |             goto label_15;
                                                                                             |         }
    0x004bef18 mov ebp, dword [rsp + 8]                                                      |         ebp = *((rsp + 8));
    0x004bef1c jmp 0x4bf140                                                                  |         goto label_14;
    0x004bef21 mov eax, 1                                                                    |         eax = 1;
    0x004bef26 mov qword [rsp + 8], rax                                                      |         *((rsp + 8)) = rax;
    0x004bef2b mov rax, qword [rip + 0x292386]                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bef32 test rax, rax                                                                 |         
    0x004bef35 jne 0x4bee11                                                                  |         
                                                                                             |     }
    0x004bef3b call 0x4eede0                                                                 |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bef40 jmp 0x4bee11                                                                  |     goto label_0;
                                                                                             | label_15:
    0x004befa1 cmp r10, 0x20                                                                 |     
                                                                                             |     if (r10 < 0x20) {
    0x004befa5 jae 0x4befaf                                                                  |         
    0x004befa7 xor r8d, r8d                                                                  |         r8d = 0;
    0x004befaa jmp 0x4bf0ce                                                                  |         goto label_16;
                                                                                             |     }
    0x004befaf mov r8, r10                                                                   |     r8 = r10;
    0x004befb2 and r8, 0xffffffffffffffe0                                                    |     r8 &= 0xffffffffffffffe0;
    0x004befb6 lea rbp, [r8 - 0x20]                                                          |     rbp = r8 - 0x20;
    0x004befba mov rdx, rbp                                                                  |     rdx = rbp;
    0x004befbd shr rdx, 5                                                                    |     rdx >>= 5;
    0x004befc1 inc rdx                                                                       |     rdx++;
    0x004befc4 mov edi, edx                                                                  |     edi = edx;
    0x004befc6 and edi, 3                                                                    |     edi &= 3;
    0x004befc9 cmp rbp, 0x60                                                                 |     
                                                                                             |     if (rbp < 0x60) {
    0x004befcd jae 0x4befd6                                                                  |         
    0x004befcf xor ebx, ebx                                                                  |         ebx = 0;
    0x004befd1 jmp 0x4bf07e                                                                  |         goto label_17;
                                                                                             |     }
    0x004befd6 and rdx, 0xfffffffffffffffc                                                   |     rdx &= 0xfffffffffffffffc;
    0x004befda neg rdx                                                                       |     rdx = -rdx;
    0x004befdd xor ebx, ebx                                                                  |     ebx = 0;
    0x004befdf nop                                                                           |     
                                                                                             |     do {
    0x004befe0 movups xmm0, xmmword [r15 + rbx + 0x74f2c0]                                   |         __asm ("movups xmm0, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::u]");
    0x004befe9 movups xmm1, xmmword [r15 + rbx + 0x74f2d0]                                   |         __asm ("movups xmm1, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u]");
    0x004beff2 movups xmmword [r14 + rbx + 0x74f2c0], xmm0                                   |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::u], xmm0");
    0x004beffb movups xmmword [r14 + rbx + 0x74f2d0], xmm1                                   |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u], xmm1");
    0x004bf004 movups xmm0, xmmword [r15 + rbx + 0x74f2e0]                                   |         __asm ("movups xmm0, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u]");
    0x004bf00d movups xmm1, xmmword [r15 + rbx + 0x74f2f0]                                   |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f2f0]");
    0x004bf016 movups xmmword [r14 + rbx + 0x74f2e0], xmm0                                   |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u], xmm0");
    0x004bf01f movups xmmword [r14 + rbx + 0x74f2f0], xmm1                                   |         __asm ("movups xmmword [r14 + rbx + 0x74f2f0], xmm1");
    0x004bf028 movups xmm0, xmmword [r15 + rbx + 0x74f300]                                   |         __asm ("movups xmm0, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u]");
    0x004bf031 movups xmm1, xmmword [r15 + rbx + 0x74f310]                                   |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f310]");
    0x004bf03a movups xmmword [r14 + rbx + 0x74f300], xmm0                                   |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u], xmm0");
    0x004bf043 movups xmmword [r14 + rbx + 0x74f310], xmm1                                   |         __asm ("movups xmmword [r14 + rbx + 0x74f310], xmm1");
    0x004bf04c movups xmm0, xmmword [r15 + rbx + 0x74f320]                                   |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f320]");
    0x004bf055 movups xmm1, xmmword [r15 + rbx + 0x74f330]                                   |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f330]");
    0x004bf05e movups xmmword [r14 + rbx + 0x74f320], xmm0                                   |         __asm ("movups xmmword [r14 + rbx + 0x74f320], xmm0");
    0x004bf067 movups xmmword [r14 + rbx + 0x74f330], xmm1                                   |         __asm ("movups xmmword [r14 + rbx + 0x74f330], xmm1");
    0x004bf070 sub rbx, 0xffffffffffffff80                                                   |         rbx -= 0xffffffffffffff80;
    0x004bf074 add rdx, 4                                                                    |         rdx += 4;
    0x004bf078 jne 0x4befe0                                                                  |         
                                                                                             |     } while (rdx != 0);
                                                                                             | label_17:
    0x004bf07e test rdi, rdi                                                                 |     
                                                                                             |     if (rdi == 0) {
    0x004bf081 je 0x4bf0bb                                                                   |         goto label_18;
                                                                                             |     }
    0x004bf083 lea rdx, [rbx + r14 + 0x74f2d0]                                               |     rdx = rbx + r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf08b lea rbx, [rbx + r15 + 0x74f2d0]                                               |     rbx = rbx + r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf093 shl rdi, 5                                                                    |     rdi <<= 5;
    0x004bf097 xor ebp, ebp                                                                  |     ebp = 0;
    0x004bf099 nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004bf0a0 movups xmm0, xmmword [rbx + rbp - 0x10]                                       |         __asm ("movups xmm0, xmmword [rbx + rbp - 0x10]");
    0x004bf0a5 movups xmm1, xmmword [rbx + rbp]                                              |         __asm ("movups xmm1, xmmword [rbx + rbp]");
    0x004bf0a9 movups xmmword [rdx + rbp - 0x10], xmm0                                       |         __asm ("movups xmmword [rdx + rbp - 0x10], xmm0");
    0x004bf0ae movups xmmword [rdx + rbp], xmm1                                              |         __asm ("movups xmmword [rdx + rbp], xmm1");
    0x004bf0b2 add rbp, 0x20                                                                 |         rbp += 0x20;
    0x004bf0b6 cmp rdi, rbp                                                                  |         
    0x004bf0b9 jne 0x4bf0a0                                                                  |         
                                                                                             |     } while (rdi != rbp);
                                                                                             | label_18:
    0x004bf0bb cmp r10, r8                                                                   |     
    0x004bf0be mov ebp, dword [rsp + 8]                                                      |     ebp = *((rsp + 8));
                                                                                             |     if (r10 == r8) {
    0x004bf0c2 je 0x4bf15f                                                                   |         goto label_12;
                                                                                             |     }
    0x004bf0c8 test r10b, 0x1c                                                               |     
                                                                                             |     if ((r10b & 0x1c) == 0) {
    0x004bf0cc je 0x4bf12d                                                                   |         goto label_19;
                                                                                             |     }
                                                                                             | label_16:
    0x004bf0ce mov rdx, qword [rsp + 0x18]                                                   |     rdx = *((rsp + 0x18));
    0x004bf0d3 add edx, r15d                                                                 |     edx += r15d;
    0x004bf0d6 movsxd r10, edx                                                               |     r10 = (int64_t) edx;
    0x004bf0d9 sub r10, r15                                                                  |     r10 -= r15;
    0x004bf0dc mov r11, r10                                                                  |     r11 = r10;
    0x004bf0df and r11, 0xfffffffffffffffc                                                   |     r11 &= 0xfffffffffffffffc;
    0x004bf0e3 add rax, r11                                                                  |     rax += r11;
    0x004bf0e6 add rcx, r11                                                                  |     rcx += r11;
    0x004bf0e9 lea rdi, [r8 + r14 + 0x74f2c0]                                                |     rdi = r8 + r14 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bf0f1 lea rbx, [r8 + r15 + 0x74f2c0]                                                |     rbx = r8 + r15 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bf0f9 mov rsi, r11                                                                  |     rsi = r11;
    0x004bf0fc sub rsi, r8                                                                   |     rsi -= r8;
    0x004bf0ff xor ebp, ebp                                                                  |     ebp = 0;
    0x004bf101 nop word cs:[rax + rax]                                                       |     
    0x004bf10b nop dword [rax + rax]                                                         |     
                                                                                             |     do {
    0x004bf110 mov edx, dword [rbx + rbp]                                                    |         edx = *((rbx + rbp));
    0x004bf113 mov dword [rdi + rbp], edx                                                    |         *((rdi + rbp)) = edx;
    0x004bf116 add rbp, 4                                                                    |         rbp += 4;
    0x004bf11a cmp rsi, rbp                                                                  |         
    0x004bf11d jne 0x4bf110                                                                  |         
                                                                                             |     } while (rsi != rbp);
    0x004bf11f cmp r10, r11                                                                  |     
    0x004bf122 mov ebp, dword [rsp + 8]                                                      |     ebp = *((rsp + 8));
    0x004bf126 mov esi, r13d                                                                 |     esi = r13d;
                                                                                             |     if (r10 == r11) {
    0x004bf129 jne 0x4bf140                                                                  |         
    0x004bf12b jmp 0x4bf15f                                                                  |         goto label_12;
                                                                                             | label_19:
    0x004bf12d add rcx, r8                                                                   |         rcx += r8;
    0x004bf130 add rax, r8                                                                   |         rax += r8;
    0x004bf133 nop word cs:[rax + rax]                                                       |         
    0x004bf13d nop dword [rax]                                                               |         
                                                                                             |     }
                                                                                             | label_14:
    0x004bf140 sub r9, rax                                                                   |     r9 -= rax;
    0x004bf143 lea rdx, [r9 + 0x74f2c0]                                                      |     rdx = r9 + obj_testCopyConstructWithIterators_signed_char__bool__bool__bool_::u;
    0x004bf14a xor edi, edi                                                                  |     edi = 0;
    0x004bf14c nop dword [rax]                                                               |     
                                                                                             |     do {
    0x004bf150 movzx ebx, byte [rax + rdi]                                                   |         ebx = *((rax + rdi));
    0x004bf154 mov byte [rcx + rdi], bl                                                      |         *((rcx + rdi)) = bl;
    0x004bf157 inc rdi                                                                       |         rdi++;
    0x004bf15a cmp rdx, rdi                                                                  |         
    0x004bf15d jne 0x4bf150                                                                  |         
                                                                                             |     } while (rdx != rdi);
                                                                                             | label_12:
    0x004bf15f cmp byte [rip + 0x25982a], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004bf166 je 0x4bf185                                                                   |         
    0x004bf168 mov edx, dword [rip + 0x259836]                                               |         edx = numCopyCtorCalls;
    0x004bf16e sub edx, r12d                                                                 |         edx -= r12d;
    0x004bf171 mov ecx, dword [rip + 0x259835]                                               |         ecx = numCharCtorCalls;
    0x004bf177 sub ecx, ebp                                                                  |         ecx -= ebp;
    0x004bf179 mov edi, 0x4f5db4                                                             |         
    0x004bf17e xor eax, eax                                                                  |         eax = 0;
    0x004bf180 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_11:
    0x004bf185 cmp byte [rsp + 0x44], 0                                                      |     
                                                                                             |     if (*((rsp + 0x44)) == 0) {
    0x004bf18a je 0x4bf1e0                                                                   |         goto label_20;
                                                                                             |     }
    0x004bf18c cmp r12d, dword [rip + 0x259811]                                              |     
    0x004bf193 mov rbx, qword [rsp + 0x10]                                                   |     rbx = *((rsp + 0x10));
                                                                                             |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004bf198 je 0x4bf1c3                                                                   |         
    0x004bf19a mov edi, 0x4f4e04                                                             |         
    0x004bf19f mov edx, 0x4f5176                                                             |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bf1a4 mov esi, 0x1005                                                               |         esi = 0x1005;
    0x004bf1a9 xor eax, eax                                                                  |         eax = 0;
    0x004bf1ab call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf1b0 mov eax, dword [rip + 0x2597e2]                                               |         eax = (anonymous namespace)::testStatus;
    0x004bf1b6 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004bf1b9 ja 0x4bf1c3                                                                   |             goto label_21;
                                                                                             |         }
    0x004bf1bb inc eax                                                                       |         eax++;
    0x004bf1bd mov dword [rip + 0x2597d5], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_21:
    0x004bf1c3 cmp ebp, dword [rip + 0x2597e3]                                               |     
                                                                                             |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bf1c9 je 0x4becb0                                                                   |         goto label_1;
                                                                                             |     }
    0x004bf1cf mov edi, 0x4f4e04                                                             |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004bf1d4 mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bf1d9 mov esi, 0x1006                                                               |     esi = 0x1006;
    0x004bf1de jmp 0x4bf237                                                                  |     goto label_22;
                                                                                             | label_20:
    0x004bf1e0 add r12d, dword [rsp + 0x18]                                                  |     r12d += *((rsp + 0x18));
    0x004bf1e5 cmp r12d, dword [rip + 0x2597b8]                                              |     
    0x004bf1ec mov rbx, qword [rsp + 0x10]                                                   |     rbx = *((rsp + 0x10));
                                                                                             |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004bf1f1 jle 0x4bf21c                                                                  |         
    0x004bf1f3 mov edi, 0x4f4e04                                                             |         
    0x004bf1f8 mov edx, 0x4f5e02                                                             |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004bf1fd mov esi, 0x1009                                                               |         esi = 0x1009;
    0x004bf202 xor eax, eax                                                                  |         eax = 0;
    0x004bf204 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf209 mov eax, dword [rip + 0x259789]                                               |         eax = (anonymous namespace)::testStatus;
    0x004bf20f cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004bf212 ja 0x4bf21c                                                                   |             goto label_23;
                                                                                             |         }
    0x004bf214 inc eax                                                                       |         eax++;
    0x004bf216 mov dword [rip + 0x25977c], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_23:
    0x004bf21c cmp ebp, dword [rip + 0x25978a]                                               |     
                                                                                             |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bf222 je 0x4becb0                                                                   |         goto label_1;
                                                                                             |     }
    0x004bf228 mov edi, 0x4f4e04                                                             |     
    0x004bf22d mov edx, 0x4f5de4                                                             |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bf232 mov esi, 0x100a                                                               |     esi = 0x100a;
                                                                                             | label_22:
    0x004bf237 xor eax, eax                                                                  |     eax = 0;
    0x004bf239 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf23e mov eax, dword [rip + 0x259754]                                               |     eax = (anonymous namespace)::testStatus;
    0x004bf244 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004bf247 ja 0x4becb0                                                                   |         goto label_1;
                                                                                             |     }
    0x004bf24d inc eax                                                                       |     eax++;
    0x004bf24f mov dword [rip + 0x259743], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bf255 jmp 0x4becb0                                                                  |     goto label_1;
                                                                                             | label_7:
    0x004bf25a cmp byte [rip + 0x259735], 0                                                  |     
                                                                                             |     if (*(obj.verbose) != 0) {
    0x004bf261 je 0x4bf26d                                                                   |         
    0x004bf263 mov edi, 0x4f695c                                                             |         
    0x004bf268 call 0x401710                                                                 |         puts ("\t\tfrom different type.");
                                                                                             |     }
    0x004bf26d xor r15d, r15d                                                                |     r15d = 0;
    0x004bf270 jmp 0x4bf2a7                                                                  |     goto label_24;
                                                                                             | label_2:
    0x004bf280 mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bf285 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004bf288 call 0x4ddec0                                                                 |     voidverify<signedchar>(signedchar*,char const*) ();
    0x004bf28d mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bf292 mov rsi, rbx                                                                  |     rsi = rbx;
    0x004bf295 call 0x4de100                                                                 |     voidcleanup<signedchar>(signedchar*,char const*) ();
    0x004bf29a inc r15                                                                       |     r15++;
    0x004bf29d cmp r15, 0x1e                                                                 |     
                                                                                             |     if (r15 == 0x1e) {
    0x004bf2a1 je 0x4bf5df                                                                   |         goto label_25;
                                                                                             |     }
                                                                                             | label_24:
    0x004bf2a7 lea rbx, [r15*8]                                                              |     rbx = r15*8;
    0x004bf2af mov r12, qword [rbx + rbx*4 + 0x4f3c98]                                       |     r12 = *((rbx + rbx*4 + 0x4f3c98));
    0x004bf2b7 mov rdi, r12                                                                  |     
    0x004bf2ba call 0x401790                                                                 |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004bf2bf cmp eax, 0x11                                                                 |     
                                                                                             |     if (eax >= 0x11) {
    0x004bf2c2 jl 0x4bf2ed                                                                   |         
    0x004bf2c4 mov edi, 0x4f4e04                                                             |         
    0x004bf2c9 mov edx, 0x4f4393                                                             |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bf2ce mov esi, 0x1019                                                               |         esi = 0x1019;
    0x004bf2d3 xor eax, eax                                                                  |         eax = 0;
    0x004bf2d5 call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf2da mov eax, dword [rip + 0x2596b8]                                               |         eax = (anonymous namespace)::testStatus;
    0x004bf2e0 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004bf2e3 ja 0x4bf2ed                                                                   |             goto label_26;
                                                                                             |         }
    0x004bf2e5 inc eax                                                                       |         eax++;
    0x004bf2e7 mov dword [rip + 0x2596ab], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_26:
    0x004bf2ed mov rdi, r12                                                                  |     
    0x004bf2f0 call 0x401790                                                                 |     rax = strlen (r12);
    0x004bf2f5 cmp rax, 0x14                                                                 |     
                                                                                             |     if (rax >= 0x14) {
    0x004bf2f9 jb 0x4bf324                                                                   |         
    0x004bf2fb mov edi, 0x4f4e04                                                             |         
    0x004bf300 mov edx, 0x4f5e26                                                             |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004bf305 mov esi, 0x101c                                                               |         esi = 0x101c;
    0x004bf30a xor eax, eax                                                                  |         eax = 0;
    0x004bf30c call 0x401680                                                                 |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf311 mov eax, dword [rip + 0x259681]                                               |         eax = (anonymous namespace)::testStatus;
    0x004bf317 cmp eax, 0x64                                                                 |         
                                                                                             |         if (eax > 0x64) {
    0x004bf31a ja 0x4bf324                                                                   |             goto label_27;
                                                                                             |         }
    0x004bf31c inc eax                                                                       |         eax++;
    0x004bf31e mov dword [rip + 0x259674], eax                                               |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                             |     }
                                                                                             | label_27:
    0x004bf324 xorps xmm0, xmm0                                                              |     __asm ("xorps xmm0, xmm0");
    0x004bf327 movaps xmmword [rsp + 0x30], xmm0                                             |     *((rsp + 0x30)) = xmm0;
    0x004bf32c mov dword [rsp + 0x40], 0                                                     |     *((rsp + 0x40)) = 0;
    0x004bf334 mov al, byte [r12]                                                            |     al = *(r12);
    0x004bf338 test al, al                                                                   |     
                                                                                             |     if (al == 0) {
    0x004bf33a je 0x4bf351                                                                   |         goto label_28;
                                                                                             |     }
    0x004bf33c xor ecx, ecx                                                                  |     ecx = 0;
    0x004bf33e nop                                                                           |     
                                                                                             |     do {
    0x004bf340 mov byte [rsp + rcx + 0x30], al                                               |         *((rsp + rcx + 0x30)) = al;
    0x004bf344 movzx eax, byte [r12 + rcx + 1]                                               |         eax = *((r12 + rcx + 1));
    0x004bf34a inc rcx                                                                       |         rcx++;
    0x004bf34d test al, al                                                                   |         
    0x004bf34f jne 0x4bf340                                                                  |         
                                                                                             |     } while (al != 0);
                                                                                             | label_28:
    0x004bf351 mov eax, dword [rbx + rbx*4 + 0x4f3c90]                                       |     eax = *((rbx + rbx*4 + obj.DATA_3));
    0x004bf358 mov dword [rsp + 0x20], eax                                                   |     *((rsp + 0x20)) = eax;
    0x004bf35c movsxd r14, dword [rbx + rbx*4 + 0x4f3ca0]                                    |     r14 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004bf364 movsxd rbp, dword [rbx + rbx*4 + 0x4f3ca4]                                    |     rbp = *((rbx + rbx*4 + 0x4f3ca4));
    0x004bf36c movsxd r13, dword [rbx + rbx*4 + 0x4f3ca8]                                    |     r13 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004bf374 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                       |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004bf37c cmp byte [rip + 0x25960d], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004bf383 je 0x4bf3a5                                                                   |         
    0x004bf385 mov qword [rsp], rbx                                                          |         *(rsp) = rbx;
    0x004bf389 mov edi, 0x4f5c41                                                             |         
    0x004bf38e mov esi, dword [rsp + 0x20]                                                   |         esi = *((rsp + 0x20));
    0x004bf392 mov rdx, r12                                                                  |         rdx = r12;
    0x004bf395 mov ecx, r14d                                                                 |         ecx = r14d;
    0x004bf398 mov r8d, ebp                                                                  |         r8d = ebp;
    0x004bf39b mov r9d, r13d                                                                 |         r9d = r13d;
    0x004bf39e xor eax, eax                                                                  |         eax = 0;
    0x004bf3a0 call 0x401680                                                                 |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                             |     }
    0x004bf3a5 mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bf3aa mov rsi, r12                                                                  |     rsi = r12;
    0x004bf3ad call 0x4ddde0                                                                 |     signedchar&gg<signedchar>(signedchar*,char const*) ();
    0x004bf3b2 mov edi, 0x74f2c0                                                             |     edi = testCopyConstructWithIterators<signed char>(bool, bool, bool)::u;
    0x004bf3b7 mov rsi, r12                                                                  |     rsi = r12;
    0x004bf3ba call 0x4ddec0                                                                 |     voidverify<signedchar>(signedchar*,char const*) ();
    0x004bf3bf mov r12d, dword [rip + 0x2595de]                                              |     r12d = numCopyCtorCalls;
    0x004bf3c6 mov eax, dword [rip + 0x2595e0]                                               |     eax = numCharCtorCalls;
    0x004bf3cc mov dword [rsp + 0x18], eax                                                   |     *((rsp + 0x18)) = eax;
    0x004bf3d0 cmp byte [rsp + 0x2c], 0                                                      |     
                                                                                             |     if (*((rsp + 0x2c)) != 0) {
    0x004bf3d5 je 0x4bf4a0                                                                   |         
    0x004bf3db cmp byte [rip + 0x2595ae], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) != 0) {
    0x004bf3e2 je 0x4bf3f7                                                                   |             
    0x004bf3e4 cmp dword [rip + 0x259139], 0                                                 |             
                                                                                             |             if (*(obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::firstTime) == 0) {
    0x004bf3eb je 0x4bf3f7                                                                   |                 goto label_29;
                                                                                             |             }
    0x004bf3ed mov edi, 0x4f43ea                                                             |             
    0x004bf3f2 call 0x401710                                                                 |             puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                             |         }
                                                                                             | label_29:
    0x004bf3f7 mov dword [rip + 0x259123], 0                                                 |         *(obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::firstTime) = 0;
    0x004bf401 cmp byte [rip + 0x25958d], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bf408 je 0x4bf414                                                                   |             
    0x004bf40a mov edi, 0x4f4411                                                             |             
    0x004bf40f call 0x401710                                                                 |             puts ("\t\tBegin bslma exception test.");
                                                                                             |         }
    0x004bf414 mov rax, qword [rip + 0x259405]                                               |         rax = Z;
    0x004bf41b mov qword [rsp + 0x48], 0x4f69e0                                              |         *((rsp + 0x48)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bf424 mov qword [rsp + 0x50], rax                                                   |         *((rsp + 0x50)) = rax;
    0x004bf429 mov qword [rax + 0x20], 0                                                     |         *((rax + 0x20)) = 0;
    0x004bf431 test rax, rax                                                                 |         
                                                                                             |         if (rax == 0) {
    0x004bf434 je 0x4bf548                                                                   |             goto label_30;
                                                                                             |         }
                                                                                             | label_3:
    0x004bf43a cmp r15, 6                                                                    |         
                                                                                             |         if (r15 >= 6) {
    0x004bf43e jb 0x4bf45b                                                                   |             
    0x004bf440 lea eax, [r14 + rbp]                                                          |             eax = r14 + rbp;
    0x004bf444 movsxd rdx, eax                                                               |             rdx = (int64_t) eax;
    0x004bf447 lea rdi, [r13 + 0x74f2c0]                                                     |             
    0x004bf44e lea rsi, [rsp + r14 + 0x30]                                                   |             
    0x004bf453 sub rdx, r14                                                                  |             rdx -= r14;
    0x004bf456 call 0x401930                                                                 |             memcpy (r13 + obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::u, rsp + r14 + 0x30, rdx);
                                                                                             |         }
    0x004bf45b mov rax, qword [rsp + 0x48]                                                   |         rax = *((rsp + 0x48));
    0x004bf460 lea rdi, [rsp + 0x48]                                                         |         rdi = rsp + 0x48;
    0x004bf465 mov rsi, 0xffffffffffffffff                                                   |         rsi = 0xffffffffffffffff;
    0x004bf46c call qword [rax + 0x10]                                                       |         uint64_t (*rax + 0x10)() ();
    0x004bf46f cmp byte [rip + 0x25951f], 0                                                  |         
                                                                                             |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bf476 je 0x4bf482                                                                   |             
    0x004bf478 mov edi, 0x4f4571                                                             |             
    0x004bf47d call 0x401710                                                                 |             puts ("\t\tEnd bslma exception test.");
                                                                                             |         }
    0x004bf482 cmp byte [rip + 0x259507], 0                                                  |         
                                                                                             |         if (*(obj.veryVerbose) == 0) {
    0x004bf489 je 0x4bf509                                                                   |             goto label_31;
                                                                                             |         }
    0x004bf48b mov edi, 0xa                                                                  |         
    0x004bf490 call 0x401720                                                                 |         putchar (0xa);
    0x004bf495 jmp 0x4bf4dd                                                                  |         
                                                                                             |     } else {
    0x004bf4a0 cmp qword [rip + 0x259378], 0                                                 |         
    0x004bf4a8 mov rcx, r13                                                                  |         rcx = r13;
                                                                                             |         if (*(obj.Z) == 0) {
    0x004bf4ab jne 0x4bf4bd                                                                  |             
    0x004bf4ad mov rax, qword [rip + 0x291e04]                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf4b4 test rax, rax                                                                 |             
                                                                                             |             if (rax == 0) {
    0x004bf4b7 je 0x4bf5c8                                                                   |                 goto label_32;
                                                                                             |             }
                                                                                             |         }
    0x004bf4bd cmp r15, 6                                                                    |         
                                                                                             |         if (r15 < 6) {
    0x004bf4c1 jb 0x4bf4dd                                                                   |             goto label_5;
                                                                                             |         }
                                                                                             | label_4:
    0x004bf4c3 add rbp, r14                                                                  |         rbp += r14;
    0x004bf4c6 lea rdi, [rcx + 0x74f2c0]                                                     |         
    0x004bf4cd lea rsi, [rsp + r14 + 0x30]                                                   |         
    0x004bf4d2 sub rbp, r14                                                                  |         rbp -= r14;
    0x004bf4d5 mov rdx, rbp                                                                  |         
    0x004bf4d8 call 0x401930                                                                 |         eax = memcpy (rcx + obj.testCopyConstructWithIterators_signed_char__bool__bool__bool_::u, rsp + r14 + 0x30, rbp);
                                                                                             |     }
                                                                                             | label_5:
    0x004bf4dd cmp byte [rip + 0x2594ac], 0                                                  |     
                                                                                             |     if (*(obj.veryVerbose) != 0) {
    0x004bf4e4 je 0x4bf509                                                                   |         
    0x004bf4e6 mov edx, dword [rip + 0x2594b8]                                               |         edx = numCopyCtorCalls;
    0x004bf4ec sub edx, r12d                                                                 |         edx -= r12d;
    0x004bf4ef mov ecx, dword [rip + 0x2594b7]                                               |         ecx = numCharCtorCalls;
    0x004bf4f5 sub ecx, dword [rsp + 0x18]                                                   |         ecx -= *((rsp + 0x18));
    0x004bf4f9 mov edi, 0x4f5db4                                                             |         
    0x004bf4fe mov esi, dword [rsp + 0x20]                                                   |         esi = *((rsp + 0x20));
    0x004bf502 xor eax, eax                                                                  |         eax = 0;
    0x004bf504 call 0x401680                                                                 |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                             |     }
                                                                                             | label_31:
    0x004bf509 cmp r12d, dword [rip + 0x259494]                                              |     
                                                                                             |     if (r12d == *(obj.numCopyCtorCalls)) {
    0x004bf510 je 0x4bf280                                                                   |         goto label_2;
                                                                                             |     }
    0x004bf516 mov edi, 0x4f4e04                                                             |     
    0x004bf51b mov edx, 0x4f5176                                                             |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bf520 mov esi, 0x103f                                                               |     esi = 0x103f;
    0x004bf525 xor eax, eax                                                                  |     eax = 0;
    0x004bf527 call 0x401680                                                                 |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf52c mov eax, dword [rip + 0x259466]                                               |     eax = (anonymous namespace)::testStatus;
    0x004bf532 cmp eax, 0x64                                                                 |     
                                                                                             |     if (eax > 0x64) {
    0x004bf535 ja 0x4bf280                                                                   |         goto label_2;
                                                                                             |     }
    0x004bf53b inc eax                                                                       |     eax++;
    0x004bf53d mov dword [rip + 0x259455], eax                                               |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bf543 jmp 0x4bf280                                                                  |     goto label_2;
                                                                                             | label_30:
    0x004bf548 mov eax, 1                                                                    |     eax = 1;
    0x004bf54d mov qword [rsp + 0x10], rax                                                   |     *((rsp + 0x10)) = rax;
    0x004bf552 mov rax, qword [rip + 0x291d5f]                                               |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf559 test rax, rax                                                                 |     
                                                                                             |     if (rax != 0) {
    0x004bf55c jne 0x4bf43a                                                                  |         goto label_3;
                                                                                             |     }
    0x004bf562 call 0x4eede0                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf567 jmp 0x4bf43a                                                                  |     goto label_3;
                                                                                             | label_32:
    0x004bf5c8 call 0x4eede0                                                                 |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf5cd mov rcx, r13                                                                  |     rcx = r13;
    0x004bf5d0 cmp r15, 6                                                                    |     
                                                                                             |     if (r15 >= 6) {
    0x004bf5d4 jae 0x4bf4c3                                                                  |         goto label_4;
                                                                                             |     }
    0x004bf5da jmp 0x4bf4dd                                                                  |     goto label_5;
                                                                                             | label_25:
    0x004bf5df add rsp, 0x58                                                                 |     
    0x004bf5e3 pop rbx                                                                       |     
    0x004bf5e4 pop r12                                                                       |     
    0x004bf5e6 pop r13                                                                       |     
    0x004bf5e8 pop r14                                                                       |     
    0x004bf5ea pop r15                                                                       |     
    0x004bf5ec pop rbp                                                                       |     
    0x004bf5ed ret                                                                           |     return rax;
                                                                                             | }