; assembly                                                                                   | /* r2dec pseudo code output */
                                                                                                 | /* bslalg_arrayprimitives.t/assume @ 0x4bf5e0 */
                                                                                                 | #include <stdint.h>
                                                                                                 |  
    ; (fcn) sym.void_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_ ()          | uint64_t void_testCopyConstructWithIterators_unsigned_char_bool_bool_bool_ (uint32_t arg3, uint32_t arg2) {
                                                                                                 |     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;
                                                                                                 |     int64_t var_48h;
                                                                                                 |     uint32_t var_54h;
                                                                                                 |     int64_t var_58h;
                                                                                                 |     int64_t var_60h;
                                                                                                 |     rdx = arg3;
                                                                                                 |     rsi = arg2;
                                                                                                 |     /* void testCopyConstructWithIterators<unsigned char>(bool, bool, bool) */
    0x004bf5e0 push rbp                                                                          |     
    0x004bf5e1 push r15                                                                          |     
    0x004bf5e3 push r14                                                                          |     
    0x004bf5e5 push r13                                                                          |     
    0x004bf5e7 push r12                                                                          |     
    0x004bf5e9 push rbx                                                                          |     
    0x004bf5ea sub rsp, 0x68                                                                     |     
    0x004bf5ee mov dword [rsp + 0x2c], edx                                                       |     *((rsp + 0x2c)) = edx;
    0x004bf5f2 mov dword [rsp + 0x54], esi                                                       |     *((rsp + 0x54)) = esi;
    0x004bf5f6 cmp byte [rip + 0x259399], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004bf5fd je 0x4bf609                                                                       |         
    0x004bf5ff mov edi, 0x4f67e9                                                                 |         
    0x004bf604 call 0x401710                                                                     |         eax = puts ("\t\tfrom same type.");
                                                                                                 |     }
    0x004bf609 xor eax, eax                                                                      |     eax = 0;
    0x004bf60b jmp 0x4bf63c                                                                      |     goto label_7;
                                                                                                 | label_2:
    0x004bf610 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf615 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bf618 call 0x4de270                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf61d mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf622 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bf625 call 0x4de4b0                                                                     |     voidcleanup<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf62a mov rax, qword [rsp + 0x20]                                                       |     rax = *((rsp + 0x20));
    0x004bf62f inc rax                                                                           |     rax++;
    0x004bf632 cmp rax, 0x1e                                                                     |     
                                                                                                 |     if (rax == 0x1e) {
    0x004bf636 je 0x4bfbaa                                                                       |         goto label_8;
                                                                                                 |     }
                                                                                                 | label_7:
    0x004bf63c mov qword [rsp + 0x20], rax                                                       |     *((rsp + 0x20)) = rax;
    0x004bf641 lea rbx, [rax*8]                                                                  |     rbx = rax*8;
    0x004bf649 mov r12, qword [rbx + rbx*4 + 0x4f3b08]                                           |     r12 = *((rbx + rbx*4 + 0x4f3b08));
    0x004bf651 mov rdi, r12                                                                      |     
    0x004bf654 call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004bf659 cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004bf65c jl 0x4bf687                                                                       |         
    0x004bf65e mov edi, 0x4f4c78                                                                 |         
    0x004bf663 mov edx, 0x4f4203                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bf668 mov esi, 0xfe6                                                                    |         esi = 0xfe6;
    0x004bf66d xor eax, eax                                                                      |         eax = 0;
    0x004bf66f call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf674 mov eax, dword [rip + 0x25931e]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bf67a cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bf67d ja 0x4bf687                                                                       |             goto label_9;
                                                                                                 |         }
    0x004bf67f inc eax                                                                           |         eax++;
    0x004bf681 mov dword [rip + 0x259311], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_9:
    0x004bf687 mov r13d, dword [rbx + rbx*4 + 0x4f3b00]                                          |     r13d = *((rbx + rbx*4 + obj.DATA_3));
    0x004bf68f movsxd r15, dword [rbx + rbx*4 + 0x4f3b10]                                        |     r15 = *((rbx + rbx*4 + 0x4f3b10));
    0x004bf697 mov ebp, dword [rbx + rbx*4 + 0x4f3b14]                                           |     ebp = *((rbx + rbx*4 + 0x4f3b14));
    0x004bf69e movsxd r14, dword [rbx + rbx*4 + 0x4f3b18]                                        |     r14 = *((rbx + rbx*4 + 0x4f3b18));
    0x004bf6a6 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                           |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004bf6ae cmp byte [rip + 0x2592db], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bf6b5 je 0x4bf6d6                                                                       |         
    0x004bf6b7 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004bf6bb mov edi, 0x4f5ab7                                                                 |         
    0x004bf6c0 mov esi, r13d                                                                     |         esi = r13d;
    0x004bf6c3 mov rdx, r12                                                                      |         rdx = r12;
    0x004bf6c6 mov ecx, r15d                                                                     |         ecx = r15d;
    0x004bf6c9 mov r8d, ebp                                                                      |         r8d = ebp;
    0x004bf6cc mov r9d, r14d                                                                     |         r9d = r14d;
    0x004bf6cf xor eax, eax                                                                      |         eax = 0;
    0x004bf6d1 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004bf6d6 mov qword [rsp + 0x18], rbp                                                       |     *((rsp + 0x18)) = rbp;
    0x004bf6db mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf6e0 mov rsi, r12                                                                      |     rsi = r12;
    0x004bf6e3 call 0x4de190                                                                     |     unsignedchar&gg<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf6e8 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf6ed mov rsi, r12                                                                      |     rsi = r12;
    0x004bf6f0 call 0x4de270                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf6f5 mov r12d, dword [rip + 0x2592a8]                                                  |     r12d = numCopyCtorCalls;
    0x004bf6fc mov ebp, dword [rip + 0x2592aa]                                                   |     ebp = numCharCtorCalls;
    0x004bf702 cmp byte [rsp + 0x2c], 0                                                          |     
    0x004bf707 mov qword [rsp + 0x10], rbx                                                       |     *((rsp + 0x10)) = rbx;
                                                                                                 |     if (*((rsp + 0x2c)) == 0) {
    0x004bf70c je 0x4bf7e0                                                                       |         goto label_10;
                                                                                                 |     }
    0x004bf712 cmp byte [rip + 0x259277], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bf719 je 0x4bf72e                                                                       |         
    0x004bf71b cmp dword [rip + 0x258e06], 0                                                     |         
                                                                                                 |         if (*(obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::firstTime) == 0) {
    0x004bf722 je 0x4bf72e                                                                       |             goto label_11;
                                                                                                 |         }
    0x004bf724 mov edi, 0x4f425a                                                                 |         
    0x004bf729 call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_11:
    0x004bf72e mov dword [rip + 0x258df0], 0                                                     |     *(obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::firstTime) = 0;
    0x004bf738 cmp byte [rip + 0x259256], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004bf73f je 0x4bf74b                                                                       |         
    0x004bf741 mov edi, 0x4f4281                                                                 |         
    0x004bf746 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004bf74b mov rax, qword [rip + 0x2590ce]                                                   |     rax = Z;
    0x004bf752 mov qword [rsp + 0x30], 0x4f6858                                                  |     *((rsp + 0x30)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bf75b mov qword [rsp + 0x38], rax                                                       |     *((rsp + 0x38)) = rax;
    0x004bf760 mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004bf768 test rax, rax                                                                     |     
    0x004bf76b je 0x4bf876                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_0:
    0x004bf771 lea rsi, [r15 + 0x74f2d0]                                                         |         rsi = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf778 mov rax, qword [rsp + 0x18]                                                       |         rax = *((rsp + 0x18));
    0x004bf77d add eax, r15d                                                                     |         eax += r15d;
    0x004bf780 cdqe                                                                              |         rax = (int64_t) eax;
    0x004bf782 lea rdx, [rax + 0x74f2d0]                                                         |         rdx = rax + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf789 sub rdx, rsi                                                                      |         rdx -= rsi;
                                                                                                 |         if (rdx != 0) {
    0x004bf78c je 0x4bf79a                                                                       |             
    0x004bf78e lea rdi, [r14 + 0x74f2d0]                                                         |             
    0x004bf795 call 0x401930                                                                     |             memcpy (r14 + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsi, rdx);
                                                                                                 |         }
    0x004bf79a mov rax, qword [rsp + 0x30]                                                       |         rax = *((rsp + 0x30));
    0x004bf79f lea rdi, [rsp + 0x30]                                                             |         rdi = rsp + 0x30;
    0x004bf7a4 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004bf7ab call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004bf7ae cmp byte [rip + 0x2591e0], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bf7b5 je 0x4bf7c1                                                                       |             
    0x004bf7b7 mov edi, 0x4f43e1                                                                 |             
    0x004bf7bc call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004bf7c1 cmp byte [rip + 0x2591c8], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004bf7c8 je 0x4bfac8                                                                       |             goto label_12;
                                                                                                 |         }
    0x004bf7ce mov edi, 0xa                                                                      |         
    0x004bf7d3 call 0x401720                                                                     |         putchar (0xa);
    0x004bf7d8 jmp 0x4bfa9f                                                                      |         goto label_13;
                                                                                                 | label_10:
    0x004bf7e0 cmp qword [rip + 0x259038], 0                                                     |         
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004bf7e8 jne 0x4bf7fa                                                                      |             
    0x004bf7ea mov rax, qword [rip + 0x291ac7]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf7f1 test rax, rax                                                                     |             
                                                                                                 |             if (rax == 0) {
    0x004bf7f4 je 0x4bf8f6                                                                       |                 goto label_14;
                                                                                                 |             }
                                                                                                 |         }
    0x004bf7fa cmp qword [rsp + 0x20], 6                                                         |         
                                                                                                 |         if (*((rsp + 0x20)) < 6) {
    0x004bf800 jb 0x4bfa9f                                                                       |             goto label_13;
                                                                                                 |         }
                                                                                                 | label_1:
    0x004bf806 lea rax, [r15 + 0x74f2d0]                                                         |         rax = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf80d lea rcx, [r14 + 0x74f2d0]                                                         |         rcx = r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf814 mov rbx, qword [rsp + 0x18]                                                       |         rbx = *((rsp + 0x18));
    0x004bf819 lea edx, [rbx + r15]                                                              |         edx = rbx + r15;
    0x004bf81d movsxd r8, edx                                                                    |         r8 = (int64_t) edx;
    0x004bf820 mov r10, r8                                                                       |         r10 = r8;
    0x004bf823 sub r10, r15                                                                      |         r10 -= r15;
    0x004bf826 cmp r10, 4                                                                        |         
                                                                                                 |         if (r10 < 4) {
    0x004bf82a jb 0x4bfa80                                                                       |             goto label_15;
                                                                                                 |         }
    0x004bf830 mov r9d, ebp                                                                      |         r9d = ebp;
    0x004bf833 lea rdi, [r14 + 0x74f2d0]                                                         |         rdi = r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf83a lea edx, [rbx + r15]                                                              |         edx = rbx + r15;
    0x004bf83e movsxd rdx, edx                                                                   |         rdx = (int64_t) edx;
    0x004bf841 lea rbp, [rdx + 0x74f2d0]                                                         |         rbp = rdx + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf848 cmp rdi, rbp                                                                      |         
                                                                                                 |         if (rdi >= rbp) {
    0x004bf84b jae 0x4bf90c                                                                      |             goto label_16;
                                                                                                 |         }
    0x004bf851 add rdx, r14                                                                      |         rdx += r14;
    0x004bf854 sub rdx, r15                                                                      |         rdx -= r15;
    0x004bf857 lea rdx, [rdx + 0x74f2d0]                                                         |         rdx = rdx + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf85e lea rdi, [r15 + 0x74f2d0]                                                         |         rdi = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf865 cmp rdi, rdx                                                                      |         
                                                                                                 |         if (rdi >= rdx) {
    0x004bf868 jae 0x4bf90c                                                                      |             goto label_16;
                                                                                                 |         }
    0x004bf86e mov ebp, r9d                                                                      |         
    0x004bf871 jmp 0x4bfa80                                                                      |         goto label_15;
    0x004bf876 mov eax, 1                                                                        |         eax = 1;
    0x004bf87b mov qword [rsp + 0x48], rax                                                       |         *((rsp + 0x48)) = rax;
    0x004bf880 mov rax, qword [rip + 0x291a31]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf887 test rax, rax                                                                     |         
    0x004bf88a jne 0x4bf771                                                                      |         
                                                                                                 |     }
    0x004bf890 call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf895 jmp 0x4bf771                                                                      |     goto label_0;
                                                                                                 | label_14:
    0x004bf8f6 call 0x4eec50                                                                     |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf8fb cmp qword [rsp + 0x20], 6                                                         |     
                                                                                                 |     if (*((rsp + 0x20)) >= 6) {
    0x004bf901 jae 0x4bf806                                                                      |         goto label_1;
                                                                                                 |     }
    0x004bf907 jmp 0x4bfa9f                                                                      |     goto label_13;
                                                                                                 | label_16:
    0x004bf90c cmp r10, 0x20                                                                     |     
                                                                                                 |     if (r10 < 0x20) {
    0x004bf910 jae 0x4bf919                                                                      |         
    0x004bf912 xor edi, edi                                                                      |         edi = 0;
    0x004bf914 jmp 0x4bfa29                                                                      |         goto label_17;
                                                                                                 |     }
    0x004bf919 mov rdi, r10                                                                      |     rdi = r10;
    0x004bf91c and rdi, 0xffffffffffffffe0                                                       |     rdi &= 0xffffffffffffffe0;
    0x004bf920 lea rbx, [rdi - 0x20]                                                             |     rbx = rdi - 0x20;
    0x004bf924 mov rdx, rbx                                                                      |     rdx = rbx;
    0x004bf927 shr rdx, 5                                                                        |     rdx >>= 5;
    0x004bf92b inc rdx                                                                           |     rdx++;
    0x004bf92e mov ebp, edx                                                                      |     
    0x004bf930 and ebp, 3                                                                        |     ebp &= 3;
    0x004bf933 cmp rbx, 0x60                                                                     |     
                                                                                                 |     if (rbx < 0x60) {
    0x004bf937 jae 0x4bf940                                                                      |         
    0x004bf939 xor ebx, ebx                                                                      |         ebx = 0;
    0x004bf93b jmp 0x4bf9ee                                                                      |         goto label_18;
                                                                                                 |     }
    0x004bf940 and rdx, 0xfffffffffffffffc                                                       |     rdx &= 0xfffffffffffffffc;
    0x004bf944 neg rdx                                                                           |     rdx = -rdx;
    0x004bf947 xor ebx, ebx                                                                      |     ebx = 0;
    0x004bf949 nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004bf950 movups xmm0, xmmword [r15 + rbx + 0x74f2d0]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u]");
    0x004bf959 movups xmm1, xmmword [r15 + rbx + 0x74f2e0]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u]");
    0x004bf962 movups xmmword [r14 + rbx + 0x74f2d0], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u], xmm0");
    0x004bf96b movups xmmword [r14 + rbx + 0x74f2e0], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u], xmm1");
    0x004bf974 movups xmm0, xmmword [r15 + rbx + 0x74f2f0]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f2f0]");
    0x004bf97d movups xmm1, xmmword [r15 + rbx + 0x74f300]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u]");
    0x004bf986 movups xmmword [r14 + rbx + 0x74f2f0], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f2f0], xmm0");
    0x004bf98f movups xmmword [r14 + rbx + 0x74f300], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u], xmm1");
    0x004bf998 movups xmm0, xmmword [r15 + rbx + 0x74f310]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f310]");
    0x004bf9a1 movups xmm1, xmmword [r15 + rbx + 0x74f320]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f320]");
    0x004bf9aa movups xmmword [r14 + rbx + 0x74f310], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f310], xmm0");
    0x004bf9b3 movups xmmword [r14 + rbx + 0x74f320], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f320], xmm1");
    0x004bf9bc movups xmm0, xmmword [r15 + rbx + 0x74f330]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f330]");
    0x004bf9c5 movups xmm1, xmmword [r15 + rbx + 0x74f340]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f340]");
    0x004bf9ce movups xmmword [r14 + rbx + 0x74f330], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f330], xmm0");
    0x004bf9d7 movups xmmword [r14 + rbx + 0x74f340], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f340], xmm1");
    0x004bf9e0 sub rbx, 0xffffffffffffff80                                                       |         rbx -= 0xffffffffffffff80;
    0x004bf9e4 add rdx, 4                                                                        |         rdx += 4;
    0x004bf9e8 jne 0x4bf950                                                                      |         
                                                                                                 |     } while (rdx != 0);
                                                                                                 | label_18:
    0x004bf9ee test rbp, rbp                                                                     |     
                                                                                                 |     if (rbp == 0) {
    0x004bf9f1 je 0x4bfa1b                                                                       |         goto label_19;
                                                                                                 |     }
    0x004bf9f3 nop word cs:[rax + rax]                                                           |     
    0x004bf9fd nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004bfa00 movups xmm0, xmmword [rax + rbx]                                                  |         __asm ("movups xmm0, xmmword [rax + rbx]");
    0x004bfa04 movups xmm1, xmmword [rax + rbx + 0x10]                                           |         __asm ("movups xmm1, xmmword [rax + rbx + 0x10]");
    0x004bfa09 movups xmmword [rcx + rbx], xmm0                                                  |         __asm ("movups xmmword [rcx + rbx], xmm0");
    0x004bfa0d movups xmmword [rcx + rbx + 0x10], xmm1                                           |         __asm ("movups xmmword [rcx + rbx + 0x10], xmm1");
    0x004bfa12 add rbx, 0x20                                                                     |         rbx += 0x20;
    0x004bfa16 dec rbp                                                                           |         rbp--;
    0x004bfa19 jne 0x4bfa00                                                                      |         
                                                                                                 |     } while (rbp != 0);
                                                                                                 | label_19:
    0x004bfa1b cmp r10, rdi                                                                      |     
    0x004bfa1e mov ebp, r9d                                                                      |     
                                                                                                 |     if (r10 == rdi) {
    0x004bfa21 je 0x4bfa9f                                                                       |         goto label_13;
                                                                                                 |     }
    0x004bfa23 test r10b, 0x1c                                                                   |     
                                                                                                 |     if ((r10b & 0x1c) == 0) {
    0x004bfa27 je 0x4bfa73                                                                       |         goto label_20;
                                                                                                 |     }
                                                                                                 | label_17:
    0x004bfa29 mov rdx, qword [rsp + 0x18]                                                       |     rdx = *((rsp + 0x18));
    0x004bfa2e add edx, r15d                                                                     |     edx += r15d;
    0x004bfa31 movsxd rbx, edx                                                                   |     rbx = (int64_t) edx;
    0x004bfa34 sub rbx, r15                                                                      |     rbx -= r15;
    0x004bfa37 mov rdx, rbx                                                                      |     rdx = rbx;
    0x004bfa3a and rdx, 0xfffffffffffffffc                                                       |     rdx &= 0xfffffffffffffffc;
    0x004bfa3e add rax, rdx                                                                      |     rax += rdx;
    0x004bfa41 add rcx, rdx                                                                      |     rcx += rdx;
    0x004bfa44 nop word cs:[rax + rax]                                                           |     
    0x004bfa4e nop                                                                               |     
                                                                                                 |     do {
    0x004bfa50 mov ebp, dword [r15 + rdi + 0x74f2d0]                                             |         ebp = *((r15 + rdi + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u));
    0x004bfa58 mov dword [r14 + rdi + 0x74f2d0], ebp                                             |         *((r14 + rdi + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u)) = ebp;
    0x004bfa60 add rdi, 4                                                                        |         rdi += 4;
    0x004bfa64 cmp rdx, rdi                                                                      |         
    0x004bfa67 jne 0x4bfa50                                                                      |         
                                                                                                 |     } while (rdx != rdi);
    0x004bfa69 cmp rbx, rdx                                                                      |     
    0x004bfa6c mov ebp, r9d                                                                      |     
                                                                                                 |     if (rbx == rdx) {
    0x004bfa6f jne 0x4bfa80                                                                      |         
    0x004bfa71 jmp 0x4bfa9f                                                                      |         goto label_13;
                                                                                                 | label_20:
    0x004bfa73 add rcx, rdi                                                                      |         rcx += rdi;
    0x004bfa76 add rax, rdi                                                                      |         rax += rdi;
    0x004bfa79 nop dword [rax]                                                                   |         
                                                                                                 |     }
                                                                                                 | label_15:
    0x004bfa80 sub r8, rax                                                                       |     r8 -= rax;
    0x004bfa83 lea rdx, [r8 + 0x74f2d0]                                                          |     rdx = r8 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bfa8a xor edi, edi                                                                      |     edi = 0;
    0x004bfa8c nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004bfa90 movzx ebx, byte [rax + rdi]                                                       |         ebx = *((rax + rdi));
    0x004bfa94 mov byte [rcx + rdi], bl                                                          |         *((rcx + rdi)) = bl;
    0x004bfa97 inc rdi                                                                           |         rdi++;
    0x004bfa9a cmp rdx, rdi                                                                      |         
    0x004bfa9d jne 0x4bfa90                                                                      |         
                                                                                                 |     } while (rdx != rdi);
                                                                                                 | label_13:
    0x004bfa9f cmp byte [rip + 0x258eea], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfaa6 je 0x4bfac8                                                                       |         
    0x004bfaa8 mov edx, dword [rip + 0x258ef6]                                                   |         edx = numCopyCtorCalls;
    0x004bfaae sub edx, r12d                                                                     |         edx -= r12d;
    0x004bfab1 mov ecx, dword [rip + 0x258ef5]                                                   |         ecx = numCharCtorCalls;
    0x004bfab7 sub ecx, ebp                                                                      |         ecx -= ebp;
    0x004bfab9 mov edi, 0x4f5c2a                                                                 |         
    0x004bfabe mov esi, r13d                                                                     |         esi = r13d;
    0x004bfac1 xor eax, eax                                                                      |         eax = 0;
    0x004bfac3 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_12:
    0x004bfac8 cmp byte [rsp + 0x54], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x54)) == 0) {
    0x004bfacd je 0x4bfb30                                                                       |         goto label_21;
                                                                                                 |     }
    0x004bfacf cmp r12d, dword [rip + 0x258ece]                                                  |     
    0x004bfad6 mov rbx, qword [rsp + 0x10]                                                       |     rbx = *((rsp + 0x10));
                                                                                                 |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004bfadb je 0x4bfb06                                                                       |         
    0x004bfadd mov edi, 0x4f4c78                                                                 |         
    0x004bfae2 mov edx, 0x4f4fec                                                                 |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bfae7 mov esi, 0x1005                                                                   |         esi = 0x1005;
    0x004bfaec xor eax, eax                                                                      |         eax = 0;
    0x004bfaee call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfaf3 mov eax, dword [rip + 0x258e9f]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfaf9 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfafc ja 0x4bfb06                                                                       |             goto label_22;
                                                                                                 |         }
    0x004bfafe inc eax                                                                           |         eax++;
    0x004bfb00 mov dword [rip + 0x258e92], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_22:
    0x004bfb06 cmp ebp, dword [rip + 0x258ea0]                                                   |     
                                                                                                 |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bfb0c je 0x4bf610                                                                       |         goto label_2;
                                                                                                 |     }
    0x004bfb12 mov edi, 0x4f4c78                                                                 |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004bfb17 mov edx, 0x4f5c5a                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bfb1c mov esi, 0x1006                                                                   |     esi = 0x1006;
    0x004bfb21 jmp 0x4bfb87                                                                      |     goto label_23;
                                                                                                 | label_21:
    0x004bfb30 add r12d, dword [rsp + 0x18]                                                      |     r12d += *((rsp + 0x18));
    0x004bfb35 cmp r12d, dword [rip + 0x258e68]                                                  |     
    0x004bfb3c mov rbx, qword [rsp + 0x10]                                                       |     rbx = *((rsp + 0x10));
                                                                                                 |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004bfb41 jle 0x4bfb6c                                                                      |         
    0x004bfb43 mov edi, 0x4f4c78                                                                 |         
    0x004bfb48 mov edx, 0x4f5c78                                                                 |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004bfb4d mov esi, 0x1009                                                                   |         esi = 0x1009;
    0x004bfb52 xor eax, eax                                                                      |         eax = 0;
    0x004bfb54 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfb59 mov eax, dword [rip + 0x258e39]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfb5f cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfb62 ja 0x4bfb6c                                                                       |             goto label_24;
                                                                                                 |         }
    0x004bfb64 inc eax                                                                           |         eax++;
    0x004bfb66 mov dword [rip + 0x258e2c], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_24:
    0x004bfb6c cmp ebp, dword [rip + 0x258e3a]                                                   |     
                                                                                                 |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bfb72 je 0x4bf610                                                                       |         goto label_2;
                                                                                                 |     }
    0x004bfb78 mov edi, 0x4f4c78                                                                 |     
    0x004bfb7d mov edx, 0x4f5c5a                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bfb82 mov esi, 0x100a                                                                   |     esi = 0x100a;
                                                                                                 | label_23:
    0x004bfb87 xor eax, eax                                                                      |     eax = 0;
    0x004bfb89 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfb8e mov eax, dword [rip + 0x258e04]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004bfb94 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004bfb97 ja 0x4bf610                                                                       |         goto label_2;
                                                                                                 |     }
    0x004bfb9d inc eax                                                                           |     eax++;
    0x004bfb9f mov dword [rip + 0x258df3], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bfba5 jmp 0x4bf610                                                                      |     goto label_2;
                                                                                                 | label_8:
    0x004bfbaa cmp byte [rip + 0x258de5], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004bfbb1 je 0x4bfbbd                                                                       |         
    0x004bfbb3 mov edi, 0x4f67d2                                                                 |         
    0x004bfbb8 call 0x401710                                                                     |         puts ("\t\tfrom different type.");
                                                                                                 |     }
    0x004bfbbd xor r15d, r15d                                                                    |     r15d = 0;
    0x004bfbc0 jmp 0x4bfbf7                                                                      |     goto label_25;
                                                                                                 | label_3:
    0x004bfbd0 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfbd5 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bfbd8 call 0x4de270                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfbdd mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfbe2 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bfbe5 call 0x4de4b0                                                                     |     voidcleanup<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfbea inc r15                                                                           |     r15++;
    0x004bfbed cmp r15, 0x1e                                                                     |     
                                                                                                 |     if (r15 == 0x1e) {
    0x004bfbf1 je 0x4bff2f                                                                       |         goto label_26;
                                                                                                 |     }
                                                                                                 | label_25:
    0x004bfbf7 lea rbx, [r15*8]                                                                  |     rbx = r15*8;
    0x004bfbff mov r12, qword [rbx + rbx*4 + 0x4f3b08]                                           |     r12 = *((rbx + rbx*4 + 0x4f3b08));
    0x004bfc07 mov rdi, r12                                                                      |     
    0x004bfc0a call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3b08)));
    0x004bfc0f cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004bfc12 jl 0x4bfc3d                                                                       |         
    0x004bfc14 mov edi, 0x4f4c78                                                                 |         
    0x004bfc19 mov edx, 0x4f4203                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bfc1e mov esi, 0x1019                                                                   |         esi = 0x1019;
    0x004bfc23 xor eax, eax                                                                      |         eax = 0;
    0x004bfc25 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfc2a mov eax, dword [rip + 0x258d68]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfc30 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfc33 ja 0x4bfc3d                                                                       |             goto label_27;
                                                                                                 |         }
    0x004bfc35 inc eax                                                                           |         eax++;
    0x004bfc37 mov dword [rip + 0x258d5b], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_27:
    0x004bfc3d mov rdi, r12                                                                      |     
    0x004bfc40 call 0x401790                                                                     |     rax = strlen (r12);
    0x004bfc45 cmp rax, 0x14                                                                     |     
                                                                                                 |     if (rax >= 0x14) {
    0x004bfc49 jb 0x4bfc74                                                                       |         
    0x004bfc4b mov edi, 0x4f4c78                                                                 |         
    0x004bfc50 mov edx, 0x4f5c9c                                                                 |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004bfc55 mov esi, 0x101c                                                                   |         esi = 0x101c;
    0x004bfc5a xor eax, eax                                                                      |         eax = 0;
    0x004bfc5c call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfc61 mov eax, dword [rip + 0x258d31]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfc67 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfc6a ja 0x4bfc74                                                                       |             goto label_28;
                                                                                                 |         }
    0x004bfc6c inc eax                                                                           |         eax++;
    0x004bfc6e mov dword [rip + 0x258d24], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_28:
    0x004bfc74 xorps xmm0, xmm0                                                                  |     __asm ("xorps xmm0, xmm0");
    0x004bfc77 movaps xmmword [rsp + 0x30], xmm0                                                 |     *((rsp + 0x30)) = xmm0;
    0x004bfc7c mov dword [rsp + 0x40], 0                                                         |     *((rsp + 0x40)) = 0;
    0x004bfc84 mov al, byte [r12]                                                                |     al = *(r12);
    0x004bfc88 test al, al                                                                       |     
                                                                                                 |     if (al == 0) {
    0x004bfc8a je 0x4bfca1                                                                       |         goto label_29;
                                                                                                 |     }
    0x004bfc8c xor ecx, ecx                                                                      |     ecx = 0;
    0x004bfc8e nop                                                                               |     
                                                                                                 |     do {
    0x004bfc90 mov byte [rsp + rcx + 0x30], al                                                   |         *((rsp + rcx + 0x30)) = al;
    0x004bfc94 movzx eax, byte [r12 + rcx + 1]                                                   |         eax = *((r12 + rcx + 1));
    0x004bfc9a inc rcx                                                                           |         rcx++;
    0x004bfc9d test al, al                                                                       |         
    0x004bfc9f jne 0x4bfc90                                                                      |         
                                                                                                 |     } while (al != 0);
                                                                                                 | label_29:
    0x004bfca1 mov eax, dword [rbx + rbx*4 + 0x4f3b00]                                           |     eax = *((rbx + rbx*4 + obj.DATA_3));
    0x004bfca8 mov dword [rsp + 0x20], eax                                                       |     *((rsp + 0x20)) = eax;
    0x004bfcac movsxd r14, dword [rbx + rbx*4 + 0x4f3b10]                                        |     r14 = *((rbx + rbx*4 + 0x4f3b10));
    0x004bfcb4 movsxd rbp, dword [rbx + rbx*4 + 0x4f3b14]                                        |     rbp = *((rbx + rbx*4 + 0x4f3b14));
    0x004bfcbc movsxd r13, dword [rbx + rbx*4 + 0x4f3b18]                                        |     r13 = *((rbx + rbx*4 + 0x4f3b18));
    0x004bfcc4 mov rbx, qword [rbx + rbx*4 + 0x4f3b20]                                           |     rbx = *((rbx + rbx*4 + 0x4f3b20));
    0x004bfccc cmp byte [rip + 0x258cbd], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfcd3 je 0x4bfcf5                                                                       |         
    0x004bfcd5 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004bfcd9 mov edi, 0x4f5ab7                                                                 |         
    0x004bfcde mov esi, dword [rsp + 0x20]                                                       |         esi = *((rsp + 0x20));
    0x004bfce2 mov rdx, r12                                                                      |         rdx = r12;
    0x004bfce5 mov ecx, r14d                                                                     |         ecx = r14d;
    0x004bfce8 mov r8d, ebp                                                                      |         r8d = ebp;
    0x004bfceb mov r9d, r13d                                                                     |         r9d = r13d;
    0x004bfcee xor eax, eax                                                                      |         eax = 0;
    0x004bfcf0 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004bfcf5 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfcfa mov rsi, r12                                                                      |     rsi = r12;
    0x004bfcfd call 0x4de190                                                                     |     unsignedchar&gg<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfd02 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfd07 mov rsi, r12                                                                      |     rsi = r12;
    0x004bfd0a call 0x4de270                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfd0f mov r12d, dword [rip + 0x258c8e]                                                  |     r12d = numCopyCtorCalls;
    0x004bfd16 mov eax, dword [rip + 0x258c90]                                                   |     eax = numCharCtorCalls;
    0x004bfd1c mov dword [rsp + 0x18], eax                                                       |     *((rsp + 0x18)) = eax;
    0x004bfd20 cmp byte [rsp + 0x2c], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x2c)) != 0) {
    0x004bfd25 je 0x4bfdf0                                                                       |         
    0x004bfd2b cmp byte [rip + 0x258c5e], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) != 0) {
    0x004bfd32 je 0x4bfd47                                                                       |             
    0x004bfd34 cmp dword [rip + 0x2587f1], 0                                                     |             
                                                                                                 |             if (*(0x0071852c) == 0) {
    0x004bfd3b je 0x4bfd47                                                                       |                 goto label_30;
                                                                                                 |             }
    0x004bfd3d mov edi, 0x4f425a                                                                 |             
    0x004bfd42 call 0x401710                                                                     |             puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |         }
                                                                                                 | label_30:
    0x004bfd47 mov dword [rip + 0x2587db], 0                                                     |         *(0x0071852c) = 0;
    0x004bfd51 cmp byte [rip + 0x258c3d], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bfd58 je 0x4bfd64                                                                       |             
    0x004bfd5a mov edi, 0x4f4281                                                                 |             
    0x004bfd5f call 0x401710                                                                     |             puts ("\t\tBegin bslma exception test.");
                                                                                                 |         }
    0x004bfd64 mov rax, qword [rip + 0x258ab5]                                                   |         rax = Z;
    0x004bfd6b mov qword [rsp + 0x58], 0x4f6858                                                  |         *((rsp + 0x58)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bfd74 mov qword [rsp + 0x60], rax                                                       |         *((rsp + 0x60)) = rax;
    0x004bfd79 mov qword [rax + 0x20], 0                                                         |         *((rax + 0x20)) = 0;
    0x004bfd81 test rax, rax                                                                     |         
                                                                                                 |         if (rax == 0) {
    0x004bfd84 je 0x4bfe98                                                                       |             goto label_31;
                                                                                                 |         }
                                                                                                 | label_4:
    0x004bfd8a cmp r15, 6                                                                        |         
                                                                                                 |         if (r15 >= 6) {
    0x004bfd8e jb 0x4bfdab                                                                       |             
    0x004bfd90 lea eax, [r14 + rbp]                                                              |             eax = r14 + rbp;
    0x004bfd94 movsxd rdx, eax                                                                   |             rdx = (int64_t) eax;
    0x004bfd97 lea rdi, [r13 + 0x74f2d0]                                                         |             
    0x004bfd9e lea rsi, [rsp + r14 + 0x30]                                                       |             
    0x004bfda3 sub rdx, r14                                                                      |             rdx -= r14;
    0x004bfda6 call 0x401930                                                                     |             memcpy (r13 + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsp + r14 + 0x30, rdx);
                                                                                                 |         }
    0x004bfdab mov rax, qword [rsp + 0x58]                                                       |         rax = *((rsp + 0x58));
    0x004bfdb0 lea rdi, [rsp + 0x58]                                                             |         rdi = rsp + 0x58;
    0x004bfdb5 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004bfdbc call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004bfdbf cmp byte [rip + 0x258bcf], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bfdc6 je 0x4bfdd2                                                                       |             
    0x004bfdc8 mov edi, 0x4f43e1                                                                 |             
    0x004bfdcd call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004bfdd2 cmp byte [rip + 0x258bb7], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004bfdd9 je 0x4bfe59                                                                       |             goto label_32;
                                                                                                 |         }
    0x004bfddb mov edi, 0xa                                                                      |         
    0x004bfde0 call 0x401720                                                                     |         putchar (0xa);
    0x004bfde5 jmp 0x4bfe2d                                                                      |         
                                                                                                 |     } else {
    0x004bfdf0 cmp qword [rip + 0x258a28], 0                                                     |         
    0x004bfdf8 mov rcx, r13                                                                      |         rcx = r13;
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004bfdfb jne 0x4bfe0d                                                                      |             
    0x004bfdfd mov rax, qword [rip + 0x2914b4]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bfe04 test rax, rax                                                                     |             
                                                                                                 |             if (rax == 0) {
    0x004bfe07 je 0x4bff18                                                                       |                 goto label_33;
                                                                                                 |             }
                                                                                                 |         }
    0x004bfe0d cmp r15, 6                                                                        |         
                                                                                                 |         if (r15 < 6) {
    0x004bfe11 jb 0x4bfe2d                                                                       |             goto label_6;
                                                                                                 |         }
                                                                                                 | label_5:
    0x004bfe13 add rbp, r14                                                                      |         rbp += r14;
    0x004bfe16 lea rdi, [rcx + 0x74f2d0]                                                         |         
    0x004bfe1d lea rsi, [rsp + r14 + 0x30]                                                       |         
    0x004bfe22 sub rbp, r14                                                                      |         rbp -= r14;
    0x004bfe25 mov rdx, rbp                                                                      |         
    0x004bfe28 call 0x401930                                                                     |         eax = memcpy (rcx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsp + r14 + 0x30, rbp);
                                                                                                 |     }
                                                                                                 | label_6:
    0x004bfe2d cmp byte [rip + 0x258b5c], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfe34 je 0x4bfe59                                                                       |         
    0x004bfe36 mov edx, dword [rip + 0x258b68]                                                   |         edx = numCopyCtorCalls;
    0x004bfe3c sub edx, r12d                                                                     |         edx -= r12d;
    0x004bfe3f mov ecx, dword [rip + 0x258b67]                                                   |         ecx = numCharCtorCalls;
    0x004bfe45 sub ecx, dword [rsp + 0x18]                                                       |         ecx -= *((rsp + 0x18));
    0x004bfe49 mov edi, 0x4f5c2a                                                                 |         
    0x004bfe4e mov esi, dword [rsp + 0x20]                                                       |         esi = *((rsp + 0x20));
    0x004bfe52 xor eax, eax                                                                      |         eax = 0;
    0x004bfe54 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_32:
    0x004bfe59 cmp r12d, dword [rip + 0x258b44]                                                  |     
                                                                                                 |     if (r12d == *(obj.numCopyCtorCalls)) {
    0x004bfe60 je 0x4bfbd0                                                                       |         goto label_3;
                                                                                                 |     }
    0x004bfe66 mov edi, 0x4f4c78                                                                 |     
    0x004bfe6b mov edx, 0x4f4fec                                                                 |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bfe70 mov esi, 0x103f                                                                   |     esi = 0x103f;
    0x004bfe75 xor eax, eax                                                                      |     eax = 0;
    0x004bfe77 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-assume/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfe7c mov eax, dword [rip + 0x258b16]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004bfe82 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004bfe85 ja 0x4bfbd0                                                                       |         goto label_3;
                                                                                                 |     }
    0x004bfe8b inc eax                                                                           |     eax++;
    0x004bfe8d mov dword [rip + 0x258b05], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bfe93 jmp 0x4bfbd0                                                                      |     goto label_3;
                                                                                                 | label_31:
    0x004bfe98 mov eax, 1                                                                        |     eax = 1;
    0x004bfe9d mov qword [rsp + 0x10], rax                                                       |     *((rsp + 0x10)) = rax;
    0x004bfea2 mov rax, qword [rip + 0x29140f]                                                   |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bfea9 test rax, rax                                                                     |     
                                                                                                 |     if (rax != 0) {
    0x004bfeac jne 0x4bfd8a                                                                      |         goto label_4;
                                                                                                 |     }
    0x004bfeb2 call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bfeb7 jmp 0x4bfd8a                                                                      |     goto label_4;
                                                                                                 | label_33:
    0x004bff18 call 0x4eec50                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bff1d mov rcx, r13                                                                      |     rcx = r13;
    0x004bff20 cmp r15, 6                                                                        |     
                                                                                                 |     if (r15 >= 6) {
    0x004bff24 jae 0x4bfe13                                                                      |         goto label_5;
                                                                                                 |     }
    0x004bff2a jmp 0x4bfe2d                                                                      |     goto label_6;
                                                                                                 | label_26:
    0x004bff2f add rsp, 0x68                                                                     |     
    0x004bff33 pop rbx                                                                           |     
    0x004bff34 pop r12                                                                           |     
    0x004bff36 pop r13                                                                           |     
    0x004bff38 pop r14                                                                           |     
    0x004bff3a pop r15                                                                           |     
    0x004bff3c pop rbp                                                                           |     
    0x004bff3d ret                                                                               |     return rax;
                                                                                                 | }