; assembly                                                                                   | /* r2dec pseudo code output */
                                                                                                 | /* bslalg_arrayprimitives.t/none @ 0x4bf620 */
                                                                                                 | #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_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<unsigned char>(bool, bool, bool) */
    0x004bf620 push rbp                                                                          |     
    0x004bf621 push r15                                                                          |     
    0x004bf623 push r14                                                                          |     
    0x004bf625 push r13                                                                          |     
    0x004bf627 push r12                                                                          |     
    0x004bf629 push rbx                                                                          |     
    0x004bf62a sub rsp, 0x58                                                                     |     
    0x004bf62e mov dword [rsp + 0x2c], edx                                                       |     *((rsp + 0x2c)) = edx;
    0x004bf632 mov dword [rsp + 0x44], esi                                                       |     *((rsp + 0x44)) = esi;
    0x004bf636 cmp byte [rip + 0x259359], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004bf63d je 0x4bf649                                                                       |         
    0x004bf63f mov edi, 0x4f6973                                                                 |         
    0x004bf644 call 0x401710                                                                     |         eax = puts ("\t\tfrom same type.");
                                                                                                 |     }
    0x004bf649 xor eax, eax                                                                      |     eax = 0;
    0x004bf64b jmp 0x4bf67c                                                                      |     goto label_6;
                                                                                                 | label_1:
    0x004bf650 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf655 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bf658 call 0x4de3c0                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf65d mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf662 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bf665 call 0x4de600                                                                     |     voidcleanup<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf66a mov rax, qword [rsp + 0x20]                                                       |     rax = *((rsp + 0x20));
    0x004bf66f inc rax                                                                           |     rax++;
    0x004bf672 cmp rax, 0x1e                                                                     |     
                                                                                                 |     if (rax == 0x1e) {
    0x004bf676 je 0x4bfbfa                                                                       |         goto label_7;
                                                                                                 |     }
                                                                                                 | label_6:
    0x004bf67c mov qword [rsp + 0x20], rax                                                       |     *((rsp + 0x20)) = rax;
    0x004bf681 lea rbx, [rax*8]                                                                  |     rbx = rax*8;
    0x004bf689 mov r12, qword [rbx + rbx*4 + 0x4f3c98]                                           |     r12 = *((rbx + rbx*4 + 0x4f3c98));
    0x004bf691 mov rdi, r12                                                                      |     
    0x004bf694 call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004bf699 cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004bf69c jl 0x4bf6c7                                                                       |         
    0x004bf69e mov edi, 0x4f4e04                                                                 |         
    0x004bf6a3 mov edx, 0x4f4393                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bf6a8 mov esi, 0xfe6                                                                    |         esi = 0xfe6;
    0x004bf6ad xor eax, eax                                                                      |         eax = 0;
    0x004bf6af call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bf6b4 mov eax, dword [rip + 0x2592de]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bf6ba cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bf6bd ja 0x4bf6c7                                                                       |             goto label_8;
                                                                                                 |         }
    0x004bf6bf inc eax                                                                           |         eax++;
    0x004bf6c1 mov dword [rip + 0x2592d1], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_8:
    0x004bf6c7 mov r13d, dword [rbx + rbx*4 + 0x4f3c90]                                          |     r13d = *((rbx + rbx*4 + obj.DATA_3));
    0x004bf6cf movsxd r15, dword [rbx + rbx*4 + 0x4f3ca0]                                        |     r15 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004bf6d7 mov ebp, dword [rbx + rbx*4 + 0x4f3ca4]                                           |     ebp = *((rbx + rbx*4 + 0x4f3ca4));
    0x004bf6de movsxd r14, dword [rbx + rbx*4 + 0x4f3ca8]                                        |     r14 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004bf6e6 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                           |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004bf6ee cmp byte [rip + 0x25929b], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bf6f5 je 0x4bf716                                                                       |         
    0x004bf6f7 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004bf6fb mov edi, 0x4f5c41                                                                 |         
    0x004bf700 mov esi, r13d                                                                     |         esi = r13d;
    0x004bf703 mov rdx, r12                                                                      |         rdx = r12;
    0x004bf706 mov ecx, r15d                                                                     |         ecx = r15d;
    0x004bf709 mov r8d, ebp                                                                      |         r8d = ebp;
    0x004bf70c mov r9d, r14d                                                                     |         r9d = r14d;
    0x004bf70f xor eax, eax                                                                      |         eax = 0;
    0x004bf711 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004bf716 mov qword [rsp + 0x18], rbp                                                       |     *((rsp + 0x18)) = rbp;
    0x004bf71b mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf720 mov rsi, r12                                                                      |     rsi = r12;
    0x004bf723 call 0x4de2e0                                                                     |     unsignedchar&gg<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf728 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bf72d mov rsi, r12                                                                      |     rsi = r12;
    0x004bf730 call 0x4de3c0                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bf735 mov r12d, dword [rip + 0x259268]                                                  |     r12d = numCopyCtorCalls;
    0x004bf73c mov ebp, dword [rip + 0x25926a]                                                   |     ebp = numCharCtorCalls;
    0x004bf742 cmp byte [rsp + 0x2c], 0                                                          |     
    0x004bf747 mov qword [rsp + 0x10], rbx                                                       |     *((rsp + 0x10)) = rbx;
                                                                                                 |     if (*((rsp + 0x2c)) == 0) {
    0x004bf74c je 0x4bf820                                                                       |         goto label_9;
                                                                                                 |     }
    0x004bf752 cmp byte [rip + 0x259237], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bf759 je 0x4bf76e                                                                       |         
    0x004bf75b cmp dword [rip + 0x258dc6], 0                                                     |         
                                                                                                 |         if (*(obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::firstTime) == 0) {
    0x004bf762 je 0x4bf76e                                                                       |             goto label_10;
                                                                                                 |         }
    0x004bf764 mov edi, 0x4f43ea                                                                 |         
    0x004bf769 call 0x401710                                                                     |         puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |     }
                                                                                                 | label_10:
    0x004bf76e mov dword [rip + 0x258db0], 0                                                     |     *(obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::firstTime) = 0;
    0x004bf778 cmp byte [rip + 0x259216], 0                                                      |     
                                                                                                 |     if (*(obj.veryVeryVerbose) != 0) {
    0x004bf77f je 0x4bf78b                                                                       |         
    0x004bf781 mov edi, 0x4f4411                                                                 |         
    0x004bf786 call 0x401710                                                                     |         puts ("\t\tBegin bslma exception test.");
                                                                                                 |     }
    0x004bf78b mov rax, qword [rip + 0x25908e]                                                   |     rax = Z;
    0x004bf792 mov qword [rsp + 0x30], 0x4f69e0                                                  |     *((rsp + 0x30)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bf79b mov qword [rsp + 0x38], rax                                                       |     *((rsp + 0x38)) = rax;
    0x004bf7a0 mov qword [rax + 0x20], 0                                                         |     *((rax + 0x20)) = 0;
    0x004bf7a8 test rax, rax                                                                     |     
    0x004bf7ab je 0x4bf8c1                                                                       |     
                                                                                                 |     while (rax != 0) {
                                                                                                 | label_0:
    0x004bf7b1 lea rsi, [r15 + 0x74f2d0]                                                         |         rsi = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf7b8 mov rax, qword [rsp + 0x18]                                                       |         rax = *((rsp + 0x18));
    0x004bf7bd add eax, r15d                                                                     |         eax += r15d;
    0x004bf7c0 cdqe                                                                              |         rax = (int64_t) eax;
    0x004bf7c2 lea rdx, [rax + 0x74f2d0]                                                         |         rdx = rax + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf7c9 sub rdx, rsi                                                                      |         rdx -= rsi;
                                                                                                 |         if (rdx != 0) {
    0x004bf7cc je 0x4bf7da                                                                       |             
    0x004bf7ce lea rdi, [r14 + 0x74f2d0]                                                         |             
    0x004bf7d5 call 0x401930                                                                     |             memcpy (r14 + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsi, rdx);
                                                                                                 |         }
    0x004bf7da mov rax, qword [rsp + 0x30]                                                       |         rax = *((rsp + 0x30));
    0x004bf7df lea rdi, [rsp + 0x30]                                                             |         rdi = rsp + 0x30;
    0x004bf7e4 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004bf7eb call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004bf7ee cmp byte [rip + 0x2591a0], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bf7f5 je 0x4bf801                                                                       |             
    0x004bf7f7 mov edi, 0x4f4571                                                                 |             
    0x004bf7fc call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004bf801 cmp byte [rip + 0x259188], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004bf808 je 0x4bfb25                                                                       |             goto label_11;
                                                                                                 |         }
    0x004bf80e mov edi, 0xa                                                                      |         
    0x004bf813 call 0x401720                                                                     |         putchar (0xa);
    0x004bf818 mov esi, r13d                                                                     |         esi = r13d;
    0x004bf81b jmp 0x4bfaff                                                                      |         goto label_12;
                                                                                                 | label_9:
    0x004bf820 cmp qword [rip + 0x258ff8], 0                                                     |         
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004bf828 jne 0x4bf840                                                                      |             
    0x004bf82a mov rax, qword [rip + 0x291a87]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf831 test rax, rax                                                                     |             
                                                                                                 |             if (rax != 0) {
    0x004bf834 jne 0x4bf840                                                                      |                 goto label_13;
                                                                                                 |             }
    0x004bf836 call 0x4eede0                                                                     |             BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf83b nop dword [rax + rax]                                                             |             
                                                                                                 |         }
                                                                                                 | label_13:
    0x004bf840 cmp qword [rsp + 0x20], 6                                                         |         
    0x004bf846 mov esi, r13d                                                                     |         esi = r13d;
                                                                                                 |         if (*((rsp + 0x20)) < 6) {
    0x004bf849 jb 0x4bfaff                                                                       |             goto label_12;
                                                                                                 |         }
    0x004bf84f lea rax, [r15 + 0x74f2d0]                                                         |         rax = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf856 lea rcx, [r14 + 0x74f2d0]                                                         |         rcx = r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf85d mov rbx, qword [rsp + 0x18]                                                       |         rbx = *((rsp + 0x18));
    0x004bf862 lea edx, [rbx + r15]                                                              |         edx = rbx + r15;
    0x004bf866 movsxd r9, edx                                                                    |         r9 = (int64_t) edx;
    0x004bf869 mov r10, r9                                                                       |         r10 = r9;
    0x004bf86c sub r10, r15                                                                      |         r10 -= r15;
    0x004bf86f cmp r10, 4                                                                        |         
                                                                                                 |         if (r10 < 4) {
    0x004bf873 jb 0x4bfae0                                                                       |             goto label_14;
                                                                                                 |         }
    0x004bf879 mov dword [rsp + 8], ebp                                                          |         *((rsp + 8)) = ebp;
    0x004bf87d lea rdi, [r14 + 0x74f2d0]                                                         |         rdi = r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf884 lea edx, [rbx + r15]                                                              |         edx = rbx + r15;
    0x004bf888 movsxd rdx, edx                                                                   |         rdx = (int64_t) edx;
    0x004bf88b lea rbp, [rdx + 0x74f2d0]                                                         |         rbp = rdx + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf892 cmp rdi, rbp                                                                      |         
                                                                                                 |         if (rdi >= rbp) {
    0x004bf895 jae 0x4bf941                                                                      |             goto label_15;
                                                                                                 |         }
    0x004bf89b add rdx, r14                                                                      |         rdx += r14;
    0x004bf89e sub rdx, r15                                                                      |         rdx -= r15;
    0x004bf8a1 lea rdx, [rdx + 0x74f2d0]                                                         |         rdx = rdx + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf8a8 lea rdi, [r15 + 0x74f2d0]                                                         |         rdi = r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bf8af cmp rdi, rdx                                                                      |         
                                                                                                 |         if (rdi >= rdx) {
    0x004bf8b2 jae 0x4bf941                                                                      |             goto label_15;
                                                                                                 |         }
    0x004bf8b8 mov ebp, dword [rsp + 8]                                                          |         ebp = *((rsp + 8));
    0x004bf8bc jmp 0x4bfae0                                                                      |         goto label_14;
    0x004bf8c1 mov eax, 1                                                                        |         eax = 1;
    0x004bf8c6 mov qword [rsp + 8], rax                                                          |         *((rsp + 8)) = rax;
    0x004bf8cb mov rax, qword [rip + 0x2919e6]                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bf8d2 test rax, rax                                                                     |         
    0x004bf8d5 jne 0x4bf7b1                                                                      |         
                                                                                                 |     }
    0x004bf8db call 0x4eede0                                                                     |     rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bf8e0 jmp 0x4bf7b1                                                                      |     goto label_0;
                                                                                                 | label_15:
    0x004bf941 cmp r10, 0x20                                                                     |     
                                                                                                 |     if (r10 < 0x20) {
    0x004bf945 jae 0x4bf94f                                                                      |         
    0x004bf947 xor r8d, r8d                                                                      |         r8d = 0;
    0x004bf94a jmp 0x4bfa6e                                                                      |         goto label_16;
                                                                                                 |     }
    0x004bf94f mov r8, r10                                                                       |     r8 = r10;
    0x004bf952 and r8, 0xffffffffffffffe0                                                        |     r8 &= 0xffffffffffffffe0;
    0x004bf956 lea rbp, [r8 - 0x20]                                                              |     rbp = r8 - 0x20;
    0x004bf95a mov rdx, rbp                                                                      |     rdx = rbp;
    0x004bf95d shr rdx, 5                                                                        |     rdx >>= 5;
    0x004bf961 inc rdx                                                                           |     rdx++;
    0x004bf964 mov edi, edx                                                                      |     edi = edx;
    0x004bf966 and edi, 3                                                                        |     edi &= 3;
    0x004bf969 cmp rbp, 0x60                                                                     |     
                                                                                                 |     if (rbp < 0x60) {
    0x004bf96d jae 0x4bf976                                                                      |         
    0x004bf96f xor ebx, ebx                                                                      |         ebx = 0;
    0x004bf971 jmp 0x4bfa1e                                                                      |         goto label_17;
                                                                                                 |     }
    0x004bf976 and rdx, 0xfffffffffffffffc                                                       |     rdx &= 0xfffffffffffffffc;
    0x004bf97a neg rdx                                                                           |     rdx = -rdx;
    0x004bf97d xor ebx, ebx                                                                      |     ebx = 0;
    0x004bf97f nop                                                                               |     
                                                                                                 |     do {
    0x004bf980 movups xmm0, xmmword [r15 + rbx + 0x74f2d0]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u]");
    0x004bf989 movups xmm1, xmmword [r15 + rbx + 0x74f2e0]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u]");
    0x004bf992 movups xmmword [r14 + rbx + 0x74f2d0], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u], xmm0");
    0x004bf99b movups xmmword [r14 + rbx + 0x74f2e0], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_short__bool__bool__bool_::u], xmm1");
    0x004bf9a4 movups xmm0, xmmword [r15 + rbx + 0x74f2f0]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f2f0]");
    0x004bf9ad movups xmm1, xmmword [r15 + rbx + 0x74f300]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u]");
    0x004bf9b6 movups xmmword [r14 + rbx + 0x74f2f0], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f2f0], xmm0");
    0x004bf9bf movups xmmword [r14 + rbx + 0x74f300], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + obj.testCopyConstructWithIterators_unsigned_short__bool__bool__bool_::u], xmm1");
    0x004bf9c8 movups xmm0, xmmword [r15 + rbx + 0x74f310]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f310]");
    0x004bf9d1 movups xmm1, xmmword [r15 + rbx + 0x74f320]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f320]");
    0x004bf9da movups xmmword [r14 + rbx + 0x74f310], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f310], xmm0");
    0x004bf9e3 movups xmmword [r14 + rbx + 0x74f320], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f320], xmm1");
    0x004bf9ec movups xmm0, xmmword [r15 + rbx + 0x74f330]                                       |         __asm ("movups xmm0, xmmword [r15 + rbx + 0x74f330]");
    0x004bf9f5 movups xmm1, xmmword [r15 + rbx + 0x74f340]                                       |         __asm ("movups xmm1, xmmword [r15 + rbx + 0x74f340]");
    0x004bf9fe movups xmmword [r14 + rbx + 0x74f330], xmm0                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f330], xmm0");
    0x004bfa07 movups xmmword [r14 + rbx + 0x74f340], xmm1                                       |         __asm ("movups xmmword [r14 + rbx + 0x74f340], xmm1");
    0x004bfa10 sub rbx, 0xffffffffffffff80                                                       |         rbx -= 0xffffffffffffff80;
    0x004bfa14 add rdx, 4                                                                        |         rdx += 4;
    0x004bfa18 jne 0x4bf980                                                                      |         
                                                                                                 |     } while (rdx != 0);
                                                                                                 | label_17:
    0x004bfa1e test rdi, rdi                                                                     |     
                                                                                                 |     if (rdi == 0) {
    0x004bfa21 je 0x4bfa5b                                                                       |         goto label_18;
                                                                                                 |     }
    0x004bfa23 lea rdx, [rbx + r14 + 0x74f2e0]                                                   |     rdx = rbx + r14 + obj_testCopyConstructWithIterators_short__bool__bool__bool_::u;
    0x004bfa2b lea rbx, [rbx + r15 + 0x74f2e0]                                                   |     rbx = rbx + r15 + obj_testCopyConstructWithIterators_short__bool__bool__bool_::u;
    0x004bfa33 shl rdi, 5                                                                        |     rdi <<= 5;
    0x004bfa37 xor ebp, ebp                                                                      |     ebp = 0;
    0x004bfa39 nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004bfa40 movups xmm0, xmmword [rbx + rbp - 0x10]                                           |         __asm ("movups xmm0, xmmword [rbx + rbp - 0x10]");
    0x004bfa45 movups xmm1, xmmword [rbx + rbp]                                                  |         __asm ("movups xmm1, xmmword [rbx + rbp]");
    0x004bfa49 movups xmmword [rdx + rbp - 0x10], xmm0                                           |         __asm ("movups xmmword [rdx + rbp - 0x10], xmm0");
    0x004bfa4e movups xmmword [rdx + rbp], xmm1                                                  |         __asm ("movups xmmword [rdx + rbp], xmm1");
    0x004bfa52 add rbp, 0x20                                                                     |         rbp += 0x20;
    0x004bfa56 cmp rdi, rbp                                                                      |         
    0x004bfa59 jne 0x4bfa40                                                                      |         
                                                                                                 |     } while (rdi != rbp);
                                                                                                 | label_18:
    0x004bfa5b cmp r10, r8                                                                       |     
    0x004bfa5e mov ebp, dword [rsp + 8]                                                          |     ebp = *((rsp + 8));
                                                                                                 |     if (r10 == r8) {
    0x004bfa62 je 0x4bfaff                                                                       |         goto label_12;
                                                                                                 |     }
    0x004bfa68 test r10b, 0x1c                                                                   |     
                                                                                                 |     if ((r10b & 0x1c) == 0) {
    0x004bfa6c je 0x4bfacd                                                                       |         goto label_19;
                                                                                                 |     }
                                                                                                 | label_16:
    0x004bfa6e mov rdx, qword [rsp + 0x18]                                                       |     rdx = *((rsp + 0x18));
    0x004bfa73 add edx, r15d                                                                     |     edx += r15d;
    0x004bfa76 movsxd r10, edx                                                                   |     r10 = (int64_t) edx;
    0x004bfa79 sub r10, r15                                                                      |     r10 -= r15;
    0x004bfa7c mov r11, r10                                                                      |     r11 = r10;
    0x004bfa7f and r11, 0xfffffffffffffffc                                                       |     r11 &= 0xfffffffffffffffc;
    0x004bfa83 add rax, r11                                                                      |     rax += r11;
    0x004bfa86 add rcx, r11                                                                      |     rcx += r11;
    0x004bfa89 lea rdi, [r8 + r14 + 0x74f2d0]                                                    |     rdi = r8 + r14 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bfa91 lea rbx, [r8 + r15 + 0x74f2d0]                                                    |     rbx = r8 + r15 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bfa99 mov rsi, r11                                                                      |     rsi = r11;
    0x004bfa9c sub rsi, r8                                                                       |     rsi -= r8;
    0x004bfa9f xor ebp, ebp                                                                      |     ebp = 0;
    0x004bfaa1 nop word cs:[rax + rax]                                                           |     
    0x004bfaab nop dword [rax + rax]                                                             |     
                                                                                                 |     do {
    0x004bfab0 mov edx, dword [rbx + rbp]                                                        |         edx = *((rbx + rbp));
    0x004bfab3 mov dword [rdi + rbp], edx                                                        |         *((rdi + rbp)) = edx;
    0x004bfab6 add rbp, 4                                                                        |         rbp += 4;
    0x004bfaba cmp rsi, rbp                                                                      |         
    0x004bfabd jne 0x4bfab0                                                                      |         
                                                                                                 |     } while (rsi != rbp);
    0x004bfabf cmp r10, r11                                                                      |     
    0x004bfac2 mov ebp, dword [rsp + 8]                                                          |     ebp = *((rsp + 8));
    0x004bfac6 mov esi, r13d                                                                     |     esi = r13d;
                                                                                                 |     if (r10 == r11) {
    0x004bfac9 jne 0x4bfae0                                                                      |         
    0x004bfacb jmp 0x4bfaff                                                                      |         goto label_12;
                                                                                                 | label_19:
    0x004bfacd add rcx, r8                                                                       |         rcx += r8;
    0x004bfad0 add rax, r8                                                                       |         rax += r8;
    0x004bfad3 nop word cs:[rax + rax]                                                           |         
    0x004bfadd nop dword [rax]                                                                   |         
                                                                                                 |     }
                                                                                                 | label_14:
    0x004bfae0 sub r9, rax                                                                       |     r9 -= rax;
    0x004bfae3 lea rdx, [r9 + 0x74f2d0]                                                          |     rdx = r9 + obj_testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u;
    0x004bfaea xor edi, edi                                                                      |     edi = 0;
    0x004bfaec nop dword [rax]                                                                   |     
                                                                                                 |     do {
    0x004bfaf0 movzx ebx, byte [rax + rdi]                                                       |         ebx = *((rax + rdi));
    0x004bfaf4 mov byte [rcx + rdi], bl                                                          |         *((rcx + rdi)) = bl;
    0x004bfaf7 inc rdi                                                                           |         rdi++;
    0x004bfafa cmp rdx, rdi                                                                      |         
    0x004bfafd jne 0x4bfaf0                                                                      |         
                                                                                                 |     } while (rdx != rdi);
                                                                                                 | label_12:
    0x004bfaff cmp byte [rip + 0x258e8a], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfb06 je 0x4bfb25                                                                       |         
    0x004bfb08 mov edx, dword [rip + 0x258e96]                                                   |         edx = numCopyCtorCalls;
    0x004bfb0e sub edx, r12d                                                                     |         edx -= r12d;
    0x004bfb11 mov ecx, dword [rip + 0x258e95]                                                   |         ecx = numCharCtorCalls;
    0x004bfb17 sub ecx, ebp                                                                      |         ecx -= ebp;
    0x004bfb19 mov edi, 0x4f5db4                                                                 |         
    0x004bfb1e xor eax, eax                                                                      |         eax = 0;
    0x004bfb20 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_11:
    0x004bfb25 cmp byte [rsp + 0x44], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x44)) == 0) {
    0x004bfb2a je 0x4bfb80                                                                       |         goto label_20;
                                                                                                 |     }
    0x004bfb2c cmp r12d, dword [rip + 0x258e71]                                                  |     
    0x004bfb33 mov rbx, qword [rsp + 0x10]                                                       |     rbx = *((rsp + 0x10));
                                                                                                 |     if (r12d != *(obj.numCopyCtorCalls)) {
    0x004bfb38 je 0x4bfb63                                                                       |         
    0x004bfb3a mov edi, 0x4f4e04                                                                 |         
    0x004bfb3f mov edx, 0x4f5176                                                                 |         edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bfb44 mov esi, 0x1005                                                                   |         esi = 0x1005;
    0x004bfb49 xor eax, eax                                                                      |         eax = 0;
    0x004bfb4b call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfb50 mov eax, dword [rip + 0x258e42]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfb56 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfb59 ja 0x4bfb63                                                                       |             goto label_21;
                                                                                                 |         }
    0x004bfb5b inc eax                                                                           |         eax++;
    0x004bfb5d mov dword [rip + 0x258e35], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_21:
    0x004bfb63 cmp ebp, dword [rip + 0x258e43]                                                   |     
                                                                                                 |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bfb69 je 0x4bf650                                                                       |         goto label_1;
                                                                                                 |     }
    0x004bfb6f mov edi, 0x4f4e04                                                                 |     edi = "Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n";
    0x004bfb74 mov edx, 0x4f5de4                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bfb79 mov esi, 0x1006                                                                   |     esi = 0x1006;
    0x004bfb7e jmp 0x4bfbd7                                                                      |     goto label_22;
                                                                                                 | label_20:
    0x004bfb80 add r12d, dword [rsp + 0x18]                                                      |     r12d += *((rsp + 0x18));
    0x004bfb85 cmp r12d, dword [rip + 0x258e18]                                                  |     
    0x004bfb8c mov rbx, qword [rsp + 0x10]                                                       |     rbx = *((rsp + 0x10));
                                                                                                 |     if (r12d > *(obj.numCopyCtorCalls)) {
    0x004bfb91 jle 0x4bfbbc                                                                      |         
    0x004bfb93 mov edi, 0x4f4e04                                                                 |         
    0x004bfb98 mov edx, 0x4f5e02                                                                 |         edx = "NUM_COPIES + NE <= numCopyCtorCalls";
    0x004bfb9d mov esi, 0x1009                                                                   |         esi = 0x1009;
    0x004bfba2 xor eax, eax                                                                      |         eax = 0;
    0x004bfba4 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfba9 mov eax, dword [rip + 0x258de9]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfbaf cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfbb2 ja 0x4bfbbc                                                                       |             goto label_23;
                                                                                                 |         }
    0x004bfbb4 inc eax                                                                           |         eax++;
    0x004bfbb6 mov dword [rip + 0x258ddc], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_23:
    0x004bfbbc cmp ebp, dword [rip + 0x258dea]                                                   |     
                                                                                                 |     if (ebp == *(obj.numCharCtorCalls)) {
    0x004bfbc2 je 0x4bf650                                                                       |         goto label_1;
                                                                                                 |     }
    0x004bfbc8 mov edi, 0x4f4e04                                                                 |     
    0x004bfbcd mov edx, 0x4f5de4                                                                 |     edx = "NUM_CTORS == numCharCtorCalls";
    0x004bfbd2 mov esi, 0x100a                                                                   |     esi = 0x100a;
                                                                                                 | label_22:
    0x004bfbd7 xor eax, eax                                                                      |     eax = 0;
    0x004bfbd9 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfbde mov eax, dword [rip + 0x258db4]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004bfbe4 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004bfbe7 ja 0x4bf650                                                                       |         goto label_1;
                                                                                                 |     }
    0x004bfbed inc eax                                                                           |     eax++;
    0x004bfbef mov dword [rip + 0x258da3], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bfbf5 jmp 0x4bf650                                                                      |     goto label_1;
                                                                                                 | label_7:
    0x004bfbfa cmp byte [rip + 0x258d95], 0                                                      |     
                                                                                                 |     if (*(obj.verbose) != 0) {
    0x004bfc01 je 0x4bfc0d                                                                       |         
    0x004bfc03 mov edi, 0x4f695c                                                                 |         
    0x004bfc08 call 0x401710                                                                     |         puts ("\t\tfrom different type.");
                                                                                                 |     }
    0x004bfc0d xor r15d, r15d                                                                    |     r15d = 0;
    0x004bfc10 jmp 0x4bfc47                                                                      |     goto label_24;
                                                                                                 | label_2:
    0x004bfc20 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfc25 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bfc28 call 0x4de3c0                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfc2d mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfc32 mov rsi, rbx                                                                      |     rsi = rbx;
    0x004bfc35 call 0x4de600                                                                     |     voidcleanup<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfc3a inc r15                                                                           |     r15++;
    0x004bfc3d cmp r15, 0x1e                                                                     |     
                                                                                                 |     if (r15 == 0x1e) {
    0x004bfc41 je 0x4bff7f                                                                       |         goto label_25;
                                                                                                 |     }
                                                                                                 | label_24:
    0x004bfc47 lea rbx, [r15*8]                                                                  |     rbx = r15*8;
    0x004bfc4f mov r12, qword [rbx + rbx*4 + 0x4f3c98]                                           |     r12 = *((rbx + rbx*4 + 0x4f3c98));
    0x004bfc57 mov rdi, r12                                                                      |     
    0x004bfc5a call 0x401790                                                                     |     eax = strlen (*((rbx + rbx*4 + 0x4f3c98)));
    0x004bfc5f cmp eax, 0x11                                                                     |     
                                                                                                 |     if (eax >= 0x11) {
    0x004bfc62 jl 0x4bfc8d                                                                       |         
    0x004bfc64 mov edi, 0x4f4e04                                                                 |         
    0x004bfc69 mov edx, 0x4f4393                                                                 |         edx = "MAX_SIZE >= (int)std::strlen(SPEC)";
    0x004bfc6e mov esi, 0x1019                                                                   |         esi = 0x1019;
    0x004bfc73 xor eax, eax                                                                      |         eax = 0;
    0x004bfc75 call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfc7a mov eax, dword [rip + 0x258d18]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfc80 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfc83 ja 0x4bfc8d                                                                       |             goto label_26;
                                                                                                 |         }
    0x004bfc85 inc eax                                                                           |         eax++;
    0x004bfc87 mov dword [rip + 0x258d0b], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_26:
    0x004bfc8d mov rdi, r12                                                                      |     
    0x004bfc90 call 0x401790                                                                     |     rax = strlen (r12);
    0x004bfc95 cmp rax, 0x14                                                                     |     
                                                                                                 |     if (rax >= 0x14) {
    0x004bfc99 jb 0x4bfcc4                                                                       |         
    0x004bfc9b mov edi, 0x4f4e04                                                                 |         
    0x004bfca0 mov edx, 0x4f5e26                                                                 |         edx = "SPEC_CE_LEN > std::strlen(SPEC)";
    0x004bfca5 mov esi, 0x101c                                                                   |         esi = 0x101c;
    0x004bfcaa xor eax, eax                                                                      |         eax = 0;
    0x004bfcac call 0x401680                                                                     |         printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfcb1 mov eax, dword [rip + 0x258ce1]                                                   |         eax = (anonymous namespace)::testStatus;
    0x004bfcb7 cmp eax, 0x64                                                                     |         
                                                                                                 |         if (eax > 0x64) {
    0x004bfcba ja 0x4bfcc4                                                                       |             goto label_27;
                                                                                                 |         }
    0x004bfcbc inc eax                                                                           |         eax++;
    0x004bfcbe mov dword [rip + 0x258cd4], eax                                                   |         *(obj._anonymous_namespace_::testStatus) = eax;
                                                                                                 |     }
                                                                                                 | label_27:
    0x004bfcc4 xorps xmm0, xmm0                                                                  |     __asm ("xorps xmm0, xmm0");
    0x004bfcc7 movaps xmmword [rsp + 0x30], xmm0                                                 |     *((rsp + 0x30)) = xmm0;
    0x004bfccc mov dword [rsp + 0x40], 0                                                         |     *((rsp + 0x40)) = 0;
    0x004bfcd4 mov al, byte [r12]                                                                |     al = *(r12);
    0x004bfcd8 test al, al                                                                       |     
                                                                                                 |     if (al == 0) {
    0x004bfcda je 0x4bfcf1                                                                       |         goto label_28;
                                                                                                 |     }
    0x004bfcdc xor ecx, ecx                                                                      |     ecx = 0;
    0x004bfcde nop                                                                               |     
                                                                                                 |     do {
    0x004bfce0 mov byte [rsp + rcx + 0x30], al                                                   |         *((rsp + rcx + 0x30)) = al;
    0x004bfce4 movzx eax, byte [r12 + rcx + 1]                                                   |         eax = *((r12 + rcx + 1));
    0x004bfcea inc rcx                                                                           |         rcx++;
    0x004bfced test al, al                                                                       |         
    0x004bfcef jne 0x4bfce0                                                                      |         
                                                                                                 |     } while (al != 0);
                                                                                                 | label_28:
    0x004bfcf1 mov eax, dword [rbx + rbx*4 + 0x4f3c90]                                           |     eax = *((rbx + rbx*4 + obj.DATA_3));
    0x004bfcf8 mov dword [rsp + 0x20], eax                                                       |     *((rsp + 0x20)) = eax;
    0x004bfcfc movsxd r14, dword [rbx + rbx*4 + 0x4f3ca0]                                        |     r14 = *((rbx + rbx*4 + 0x4f3ca0));
    0x004bfd04 movsxd rbp, dword [rbx + rbx*4 + 0x4f3ca4]                                        |     rbp = *((rbx + rbx*4 + 0x4f3ca4));
    0x004bfd0c movsxd r13, dword [rbx + rbx*4 + 0x4f3ca8]                                        |     r13 = *((rbx + rbx*4 + 0x4f3ca8));
    0x004bfd14 mov rbx, qword [rbx + rbx*4 + 0x4f3cb0]                                           |     rbx = *((rbx + rbx*4 + 0x4f3cb0));
    0x004bfd1c cmp byte [rip + 0x258c6d], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfd23 je 0x4bfd45                                                                       |         
    0x004bfd25 mov qword [rsp], rbx                                                              |         *(rsp) = rbx;
    0x004bfd29 mov edi, 0x4f5c41                                                                 |         
    0x004bfd2e mov esi, dword [rsp + 0x20]                                                       |         esi = *((rsp + 0x20));
    0x004bfd32 mov rdx, r12                                                                      |         rdx = r12;
    0x004bfd35 mov ecx, r14d                                                                     |         ecx = r14d;
    0x004bfd38 mov r8d, ebp                                                                      |         r8d = ebp;
    0x004bfd3b mov r9d, r13d                                                                     |         r9d = r13d;
    0x004bfd3e xor eax, eax                                                                      |         eax = 0;
    0x004bfd40 call 0x401680                                                                     |         printf ("LINE = %d, SPEC = %s, SRC = %d, NE = %d, DST = %d, EXP = %s\n");
                                                                                                 |     }
    0x004bfd45 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfd4a mov rsi, r12                                                                      |     rsi = r12;
    0x004bfd4d call 0x4de2e0                                                                     |     unsignedchar&gg<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfd52 mov edi, 0x74f2d0                                                                 |     edi = testCopyConstructWithIterators<unsigned char>(bool, bool, bool)::u;
    0x004bfd57 mov rsi, r12                                                                      |     rsi = r12;
    0x004bfd5a call 0x4de3c0                                                                     |     voidverify<unsignedchar>(unsignedchar*,char const*) ();
    0x004bfd5f mov r12d, dword [rip + 0x258c3e]                                                  |     r12d = numCopyCtorCalls;
    0x004bfd66 mov eax, dword [rip + 0x258c40]                                                   |     eax = numCharCtorCalls;
    0x004bfd6c mov dword [rsp + 0x18], eax                                                       |     *((rsp + 0x18)) = eax;
    0x004bfd70 cmp byte [rsp + 0x2c], 0                                                          |     
                                                                                                 |     if (*((rsp + 0x2c)) != 0) {
    0x004bfd75 je 0x4bfe40                                                                       |         
    0x004bfd7b cmp byte [rip + 0x258c0e], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) != 0) {
    0x004bfd82 je 0x4bfd97                                                                       |             
    0x004bfd84 cmp dword [rip + 0x2587a1], 0                                                     |             
                                                                                                 |             if (*(0x0071852c) == 0) {
    0x004bfd8b je 0x4bfd97                                                                       |                 goto label_29;
                                                                                                 |             }
    0x004bfd8d mov edi, 0x4f43ea                                                                 |             
    0x004bfd92 call 0x401710                                                                     |             puts ("\t\tBSLMA EXCEPTION TEST -- (ENABLED) --");
                                                                                                 |         }
                                                                                                 | label_29:
    0x004bfd97 mov dword [rip + 0x25878b], 0                                                     |         *(0x0071852c) = 0;
    0x004bfda1 cmp byte [rip + 0x258bed], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bfda8 je 0x4bfdb4                                                                       |             
    0x004bfdaa mov edi, 0x4f4411                                                                 |             
    0x004bfdaf call 0x401710                                                                     |             puts ("\t\tBegin bslma exception test.");
                                                                                                 |         }
    0x004bfdb4 mov rax, qword [rip + 0x258a65]                                                   |         rax = Z;
    0x004bfdbb mov qword [rsp + 0x48], 0x4f69e0                                                  |         *((rsp + 0x48)) = vtable.BloombergLP::bslma::TestAllocator_Proxy_BloombergLP::bslma::TestAllocator_.0;
    0x004bfdc4 mov qword [rsp + 0x50], rax                                                       |         *((rsp + 0x50)) = rax;
    0x004bfdc9 mov qword [rax + 0x20], 0                                                         |         *((rax + 0x20)) = 0;
    0x004bfdd1 test rax, rax                                                                     |         
                                                                                                 |         if (rax == 0) {
    0x004bfdd4 je 0x4bfee8                                                                       |             goto label_30;
                                                                                                 |         }
                                                                                                 | label_3:
    0x004bfdda cmp r15, 6                                                                        |         
                                                                                                 |         if (r15 >= 6) {
    0x004bfdde jb 0x4bfdfb                                                                       |             
    0x004bfde0 lea eax, [r14 + rbp]                                                              |             eax = r14 + rbp;
    0x004bfde4 movsxd rdx, eax                                                                   |             rdx = (int64_t) eax;
    0x004bfde7 lea rdi, [r13 + 0x74f2d0]                                                         |             
    0x004bfdee lea rsi, [rsp + r14 + 0x30]                                                       |             
    0x004bfdf3 sub rdx, r14                                                                      |             rdx -= r14;
    0x004bfdf6 call 0x401930                                                                     |             memcpy (r13 + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsp + r14 + 0x30, rdx);
                                                                                                 |         }
    0x004bfdfb mov rax, qword [rsp + 0x48]                                                       |         rax = *((rsp + 0x48));
    0x004bfe00 lea rdi, [rsp + 0x48]                                                             |         rdi = rsp + 0x48;
    0x004bfe05 mov rsi, 0xffffffffffffffff                                                       |         rsi = 0xffffffffffffffff;
    0x004bfe0c call qword [rax + 0x10]                                                           |         uint64_t (*rax + 0x10)() ();
    0x004bfe0f cmp byte [rip + 0x258b7f], 0                                                      |         
                                                                                                 |         if (*(obj.veryVeryVerbose) != 0) {
    0x004bfe16 je 0x4bfe22                                                                       |             
    0x004bfe18 mov edi, 0x4f4571                                                                 |             
    0x004bfe1d call 0x401710                                                                     |             puts ("\t\tEnd bslma exception test.");
                                                                                                 |         }
    0x004bfe22 cmp byte [rip + 0x258b67], 0                                                      |         
                                                                                                 |         if (*(obj.veryVerbose) == 0) {
    0x004bfe29 je 0x4bfea9                                                                       |             goto label_31;
                                                                                                 |         }
    0x004bfe2b mov edi, 0xa                                                                      |         
    0x004bfe30 call 0x401720                                                                     |         putchar (0xa);
    0x004bfe35 jmp 0x4bfe7d                                                                      |         
                                                                                                 |     } else {
    0x004bfe40 cmp qword [rip + 0x2589d8], 0                                                     |         
    0x004bfe48 mov rcx, r13                                                                      |         rcx = r13;
                                                                                                 |         if (*(obj.Z) == 0) {
    0x004bfe4b jne 0x4bfe5d                                                                      |             
    0x004bfe4d mov rax, qword [rip + 0x291464]                                                   |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bfe54 test rax, rax                                                                     |             
                                                                                                 |             if (rax == 0) {
    0x004bfe57 je 0x4bff68                                                                       |                 goto label_32;
                                                                                                 |             }
                                                                                                 |         }
    0x004bfe5d cmp r15, 6                                                                        |         
                                                                                                 |         if (r15 < 6) {
    0x004bfe61 jb 0x4bfe7d                                                                       |             goto label_5;
                                                                                                 |         }
                                                                                                 | label_4:
    0x004bfe63 add rbp, r14                                                                      |         rbp += r14;
    0x004bfe66 lea rdi, [rcx + 0x74f2d0]                                                         |         
    0x004bfe6d lea rsi, [rsp + r14 + 0x30]                                                       |         
    0x004bfe72 sub rbp, r14                                                                      |         rbp -= r14;
    0x004bfe75 mov rdx, rbp                                                                      |         
    0x004bfe78 call 0x401930                                                                     |         eax = memcpy (rcx + obj.testCopyConstructWithIterators_unsigned_char__bool__bool__bool_::u, rsp + r14 + 0x30, rbp);
                                                                                                 |     }
                                                                                                 | label_5:
    0x004bfe7d cmp byte [rip + 0x258b0c], 0                                                      |     
                                                                                                 |     if (*(obj.veryVerbose) != 0) {
    0x004bfe84 je 0x4bfea9                                                                       |         
    0x004bfe86 mov edx, dword [rip + 0x258b18]                                                   |         edx = numCopyCtorCalls;
    0x004bfe8c sub edx, r12d                                                                     |         edx -= r12d;
    0x004bfe8f mov ecx, dword [rip + 0x258b17]                                                   |         ecx = numCharCtorCalls;
    0x004bfe95 sub ecx, dword [rsp + 0x18]                                                       |         ecx -= *((rsp + 0x18));
    0x004bfe99 mov edi, 0x4f5db4                                                                 |         
    0x004bfe9e mov esi, dword [rsp + 0x20]                                                       |         esi = *((rsp + 0x20));
    0x004bfea2 xor eax, eax                                                                      |         eax = 0;
    0x004bfea4 call 0x401680                                                                     |         eax = printf ("LINE = %d, #copy ctors = %d, #char ctors = %d.\n");
                                                                                                 |     }
                                                                                                 | label_31:
    0x004bfea9 cmp r12d, dword [rip + 0x258af4]                                                  |     
                                                                                                 |     if (r12d == *(obj.numCopyCtorCalls)) {
    0x004bfeb0 je 0x4bfc20                                                                       |         goto label_2;
                                                                                                 |     }
    0x004bfeb6 mov edi, 0x4f4e04                                                                 |     
    0x004bfebb mov edx, 0x4f5176                                                                 |     edx = "NUM_COPIES == numCopyCtorCalls";
    0x004bfec0 mov esi, 0x103f                                                                   |     esi = 0x103f;
    0x004bfec5 xor eax, eax                                                                      |     eax = 0;
    0x004bfec7 call 0x401680                                                                     |     printf ("Error /home/parsa/experiments/assumptions/crush/ccm-none/groups/bsl/bslalg/bslalg_arrayprimitives.t.cpp(%d): %s    (failed)\n");
    0x004bfecc mov eax, dword [rip + 0x258ac6]                                                   |     eax = (anonymous namespace)::testStatus;
    0x004bfed2 cmp eax, 0x64                                                                     |     
                                                                                                 |     if (eax > 0x64) {
    0x004bfed5 ja 0x4bfc20                                                                       |         goto label_2;
                                                                                                 |     }
    0x004bfedb inc eax                                                                           |     eax++;
    0x004bfedd mov dword [rip + 0x258ab5], eax                                                   |     *(obj._anonymous_namespace_::testStatus) = eax;
    0x004bfee3 jmp 0x4bfc20                                                                      |     goto label_2;
                                                                                                 | label_30:
    0x004bfee8 mov eax, 1                                                                        |     eax = 1;
    0x004bfeed mov qword [rsp + 0x10], rax                                                       |     *((rsp + 0x10)) = rax;
    0x004bfef2 mov rax, qword [rip + 0x2913bf]                                                   |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004bfef9 test rax, rax                                                                     |     
                                                                                                 |     if (rax != 0) {
    0x004bfefc jne 0x4bfdda                                                                      |         goto label_3;
                                                                                                 |     }
    0x004bff02 call 0x4eede0                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bff07 jmp 0x4bfdda                                                                      |     goto label_3;
                                                                                                 | label_32:
    0x004bff68 call 0x4eede0                                                                     |     BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x004bff6d mov rcx, r13                                                                      |     rcx = r13;
    0x004bff70 cmp r15, 6                                                                        |     
                                                                                                 |     if (r15 >= 6) {
    0x004bff74 jae 0x4bfe63                                                                      |         goto label_4;
                                                                                                 |     }
    0x004bff7a jmp 0x4bfe7d                                                                      |     goto label_5;
                                                                                                 | label_25:
    0x004bff7f add rsp, 0x58                                                                     |     
    0x004bff83 pop rbx                                                                           |     
    0x004bff84 pop r12                                                                           |     
    0x004bff86 pop r13                                                                           |     
    0x004bff88 pop r14                                                                           |     
    0x004bff8a pop r15                                                                           |     
    0x004bff8c pop rbp                                                                           |     
    0x004bff8d ret                                                                               |     return rax;
                                                                                                 | }