; assembly                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                 | /* balcl_commandline.t/none @ 0x456af0 */
                                                                                                                                 | #include <stdint.h>
                                                                                                                                 |  
    ; (fcn) method.BloombergLP::balcl::CommandLine.parse_std::__1::basic_ostream_char__std::__1::char_traits_char____ ()         | int64_t method_BloombergLP::balcl::CommandLine_parse_std::_1::basic_ostream_char_std::_1::char_traits_char_ (int64_t arg2, int64_t arg1) {
                                                                                                                                 |     int64_t var_8h;
                                                                                                                                 |     int64_t var_17h;
                                                                                                                                 |     int64_t var_18h;
                                                                                                                                 |     int64_t var_30h;
                                                                                                                                 |     uint32_t var_38h;
                                                                                                                                 |     int64_t var_40h;
                                                                                                                                 |     int64_t var_48h;
                                                                                                                                 |     int64_t var_50h;
                                                                                                                                 |     int64_t var_58h;
                                                                                                                                 |     uint32_t var_60h;
                                                                                                                                 |     rsi = arg2;
                                                                                                                                 |     rdi = arg1;
                                                                                                                                 |     /* BloombergLP::balcl::CommandLine::parse(std::__1::basic_ostream<char, std::__1::char_traits<char> >&) */
    0x00456af0 push rbp                                                                                                          |     
    0x00456af1 push r15                                                                                                          |     
    0x00456af3 push r14                                                                                                          |     
    0x00456af5 push r13                                                                                                          |     
    0x00456af7 push r12                                                                                                          |     
    0x00456af9 push rbx                                                                                                          |     
    0x00456afa sub rsp, 0x68                                                                                                     |     
    0x00456afe mov qword [rsp], rsi                                                                                              |     *(rsp) = rsi;
    0x00456b02 mov r15, rdi                                                                                                      |     r15 = rdi;
    0x00456b05 mov rax, qword [rdi + 0x68]                                                                                       |     rax = *((rdi + 0x68));
    0x00456b09 mov rcx, qword [rdi + 0x70]                                                                                       |     rcx = *((rdi + 0x70));
    0x00456b0d sub rcx, rax                                                                                                      |     rcx -= rax;
    0x00456b10 sar rcx, 4                                                                                                        |     rcx >>= 4;
    0x00456b14 movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |     r12 = 0xaaaaaaaaaaaaaaab;
    0x00456b1e imul rcx, r12                                                                                                     |     rcx *= r12;
    0x00456b22 cmp rcx, 2                                                                                                        |     
                                                                                                                                 |     if (rcx < 2) {
    0x00456b26 jb 0x45767a                                                                                                       |         goto label_8;
                                                                                                                                 |     }
    0x00456b2c mov r14d, 1                                                                                                       |     r14d = 1;
    0x00456b32 mov edx, 1                                                                                                        |     edx = 1;
    0x00456b37 xor ebx, ebx                                                                                                      |     ebx = 0;
    0x00456b39 lea r13, [rsp + 0x18]                                                                                             |     r13 = rsp + 0x18;
    0x00456b3e movabs rdi, 0x100000000                                                                                           |     rdi = 0x100000000;
    0x00456b48 jmp 0x456b7c                                                                                                      |     goto label_9;
                                                                                                                                 | label_0:
    0x00456b4a mov r14, qword [rsp + 8]                                                                                          |     r14 = *((rsp + 8));
    0x00456b4f nop                                                                                                               |     
                                                                                                                                 |     do {
    0x00456b50 movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |         r12 = 0xaaaaaaaaaaaaaaab;
                                                                                                                                 | label_3:
    0x00456b5a inc r14d                                                                                                          |         r14d++;
    0x00456b5d mov rax, qword [r15 + 0x68]                                                                                       |         rax = *((r15 + 0x68));
    0x00456b61 mov rcx, qword [r15 + 0x70]                                                                                       |         rcx = *((r15 + 0x70));
    0x00456b65 sub rcx, rax                                                                                                      |         rcx -= rax;
    0x00456b68 sar rcx, 4                                                                                                        |         rcx >>= 4;
    0x00456b6c imul rcx, r12                                                                                                     |         rcx *= r12;
    0x00456b70 mov rdx, r14                                                                                                      |         rdx = r14;
    0x00456b73 cmp rcx, r14                                                                                                      |         
                                                                                                                                 |         if (rcx <= r14) {
    0x00456b76 jbe 0x45767a                                                                                                      |             goto label_8;
                                                                                                                                 |         }
                                                                                                                                 | label_9:
    0x00456b7c lea rcx, [rdx + rdx*2]                                                                                            |         rcx = rdx * 3;
    0x00456b80 shl rcx, 4                                                                                                        |         rcx <<= 4;
    0x00456b84 lea rsi, [rax + rcx]                                                                                              |         rsi = rax + rcx;
    0x00456b88 mov qword [rsp + 0x50], rcx                                                                                       |         *((rsp + 0x50)) = rcx;
    0x00456b8d mov rcx, qword [rax + rcx + 0x20]                                                                                 |         rcx = *((rax + rcx + 0x20));
    0x00456b92 cmp rcx, 0x17                                                                                                     |         
                                                                                                                                 |         if (rcx == 0x17) {
    0x00456b96 jne 0x456bc0                                                                                                      |             
    0x00456b98 cmp byte [rsi], 0x2d                                                                                              |             
                                                                                                                                 |             if (*(rsi) != 0x2d) {
    0x00456b9b jne 0x456c00                                                                                                      |                 goto label_10;
                                                                                                                                 |             }
    0x00456b9d mov qword [rsp + 0x60], rdx                                                                                       |             *((rsp + 0x60)) = rdx;
    0x00456ba2 mov qword [rsp + 8], r14                                                                                          |             *((rsp + 8)) = r14;
    0x00456ba7 mov dl, byte [rsi + 1]                                                                                            |             dl = *((rsi + 1));
    0x00456baa cmp dl, 0x2d                                                                                                      |             
                                                                                                                                 |             if (dl == 0x2d) {
    0x00456bad je 0x456ca6                                                                                                       |                 goto label_11;
                                                                                                                                 |             }
    0x00456bb3 test dl, dl                                                                                                       |             
                                                                                                                                 |             if (dl != 0) {
    0x00456bb5 jne 0x456cb6                                                                                                      |                 goto label_12;
                                                                                                                                 |             }
    0x00456bbb jmp 0x457303                                                                                                      |             goto label_13;
                                                                                                                                 |         }
    0x00456bc0 mov rbp, qword [rsi]                                                                                              |         rbp = *(rsi);
    0x00456bc3 cmp byte [rbp], 0x2d                                                                                              |         
                                                                                                                                 |         if (*(rbp) == 0x2d) {
    0x00456bc7 jne 0x456c00                                                                                                      |             
    0x00456bc9 mov qword [rsp + 0x60], rdx                                                                                       |             *((rsp + 0x60)) = rdx;
    0x00456bce mov qword [rsp + 8], r14                                                                                          |             *((rsp + 8)) = r14;
    0x00456bd3 mov r12b, byte [rbp + 1]                                                                                          |             r12b = *((rbp + 1));
    0x00456bd7 cmp r12b, 0x2d                                                                                                    |             
                                                                                                                                 |             if (r12b == 0x2d) {
    0x00456bdb je 0x456cd4                                                                                                       |                 goto label_14;
                                                                                                                                 |             }
    0x00456be1 test r12b, r12b                                                                                                   |             
                                                                                                                                 |             if (r12b == 0) {
    0x00456be4 je 0x457303                                                                                                       |                 goto label_13;
                                                                                                                                 |             }
    0x00456bea cmp r12b, 0x2d                                                                                                    |             
                                                                                                                                 |             if (r12b == 0x2d) {
    0x00456bee je 0x456ceb                                                                                                       |                 goto label_15;
                                                                                                                                 |             }
    0x00456bf4 jmp 0x456d60                                                                                                      |             goto label_16;
                                                                                                                                 |         }
                                                                                                                                 | label_10:
    0x00456c00 mov rax, qword [r15 + 0x40]                                                                                       |         rax = *((r15 + 0x40));
    0x00456c04 mov rcx, qword [r15 + 0x48]                                                                                       |         rcx = *((r15 + 0x48));
    0x00456c08 sub rcx, rax                                                                                                      |         rcx -= rax;
    0x00456c0b sar rcx, 2                                                                                                        |         rcx >>= 2;
    0x00456c0f cmp rcx, rbx                                                                                                      |         
                                                                                                                                 |         if (rcx <= rbx) {
    0x00456c12 jbe 0x45727b                                                                                                      |             goto label_17;
                                                                                                                                 |         }
    0x00456c18 movsxd rbp, dword [rax + rbx*4]                                                                                   |         rbp = *((rax + rbx*4));
    0x00456c1c mov rdi, rbp                                                                                                      |         
    0x00456c1f shl rdi, 5                                                                                                        |         rdi <<= 5;
    0x00456c23 add rdi, qword [r15 + 0x20]                                                                                       |         rdi += *((r15 + 0x20));
    0x00456c27 mov dword [rsp + 0x18], r14d                                                                                      |         *((rsp + 0x18)) = r14d;
    0x00456c2c mov rsi, r13                                                                                                      |         
    0x00456c2f call 0x493f30                                                                                                     |         bsl::vector<int,bsl::allocator<int>>::push_back(int&&) (rbp, r13);
    0x00456c34 mov r13, rbx                                                                                                      |         r13 = rbx;
    0x00456c37 lea rbx, [rbp + rbp*4]                                                                                            |         rbx = rbp + rbp*4;
    0x00456c3c shl rbx, 4                                                                                                        |         rbx <<= 4;
    0x00456c40 add rbx, qword [r15 + 0xa8]                                                                                       |         rbx += *((r15 + 0xa8));
    0x00456c47 mov r12, qword [rsp + 0x50]                                                                                       |         r12 = *((rsp + 0x50));
    0x00456c4c add r12, qword [r15 + 0x68]                                                                                       |         r12 += *((r15 + 0x68));
    0x00456c50 imul rbp, rbp, 0x118                                                                                              |         rbp *= 0x118;
    0x00456c57 mov rdi, qword [r15]                                                                                              |         
    0x00456c5a add rdi, rbp                                                                                                      |         rdi += rbp;
    0x00456c5d call 0x4649e0                                                                                                     |         rax = BloombergLP::balcl::Option::typeInfo()const (*(r15));
    0x00456c62 mov rdi, rbx                                                                                                      |         
    0x00456c65 mov rsi, r12                                                                                                      |         
    0x00456c68 mov rdx, rax                                                                                                      |         
    0x00456c6b mov rcx, qword [rsp]                                                                                              |         
    0x00456c6f call 0x46bb30                                                                                                     |         al = BloombergLP::balcl::TypeInfoUtil::parseAndValidate(BloombergLP::balcl::OptionValue*,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,BloombergLP::balcl::TypeInfoconst&,std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (rbx, r12, rax, *(rsp));
    0x00456c74 test al, al                                                                                                       |         
                                                                                                                                 |         if (al == 0) {
    0x00456c76 je 0x4572df                                                                                                       |             goto label_18;
                                                                                                                                 |         }
    0x00456c7c add rbp, qword [r15]                                                                                              |         rbp += *(r15);
    0x00456c7f mov rdi, rbp                                                                                                      |         
    0x00456c82 call 0x464950                                                                                                     |         al = BloombergLP::balcl::Option::isArray()const (rbp);
    0x00456c87 xor al, 1                                                                                                         |         al ^= 1;
    0x00456c89 movzx eax, al                                                                                                     |         eax = (int32_t) al;
    0x00456c8c add r13, rax                                                                                                      |         r13 += rax;
    0x00456c8f mov rbx, r13                                                                                                      |         rbx = r13;
    0x00456c92 lea r13, [rsp + 0x18]                                                                                             |         r13 = rsp + 0x18;
    0x00456c97 movabs rdi, 0x100000000                                                                                           |         rdi = 0x100000000;
    0x00456ca1 jmp 0x456b50                                                                                                      |         
                                                                                                                                 |     } while (1);
                                                                                                                                 | label_11:
    0x00456ca6 cmp byte [rsi + 2], 0                                                                                             |     
                                                                                                                                 |     if (*((rsi + 2)) == 0) {
    0x00456caa je 0x45730a                                                                                                       |         goto label_19;
                                                                                                                                 |     }
    0x00456cb0 cmp rcx, 0x17                                                                                                     |     
                                                                                                                                 |     if (rcx == 0x17) {
    0x00456cb4 jne 0x456cde                                                                                                      |         
                                                                                                                                 | label_12:
    0x00456cb6 mov r12b, byte [rsi + 1]                                                                                          |         r12b = *((rsi + 1));
    0x00456cba mov rbp, rsi                                                                                                      |         
    0x00456cbd cmp r12b, 0x2d                                                                                                    |         
                                                                                                                                 |         if (r12b != 0x2d) {
    0x00456cc1 jne 0x456d60                                                                                                      |             goto label_16;
                                                                                                                                 |         }
    0x00456cc7 mov qword [rsp + 0x48], rbx                                                                                       |         *((rsp + 0x48)) = rbx;
    0x00456ccc mov bl, byte [rsi + 2]                                                                                            |         bl = *((rsi + 2));
    0x00456ccf mov rbp, rsi                                                                                                      |         
    0x00456cd2 jmp 0x456cf3                                                                                                      |         goto label_20;
                                                                                                                                 | label_14:
    0x00456cd4 cmp byte [rbp + 2], 0                                                                                             |         
                                                                                                                                 |         if (*((rbp + 2)) == 0) {
    0x00456cd8 je 0x45730a                                                                                                       |             goto label_19;
                                                                                                                                 |         }
                                                                                                                                 |     }
    0x00456cde mov rbp, qword [rsi]                                                                                              |     rbp = *(rsi);
    0x00456ce1 mov r12b, byte [rbp + 1]                                                                                          |     r12b = *((rbp + 1));
    0x00456ce5 cmp r12b, 0x2d                                                                                                    |     
                                                                                                                                 |     if (r12b != 0x2d) {
    0x00456ce9 jne 0x456d60                                                                                                      |         goto label_16;
                                                                                                                                 |     }
                                                                                                                                 | label_15:
    0x00456ceb mov qword [rsp + 0x48], rbx                                                                                       |     *((rsp + 0x48)) = rbx;
    0x00456cf0 mov bl, byte [rbp + 2]                                                                                            |     bl = *((rbp + 2));
                                                                                                                                 | label_20:
    0x00456cf3 cmp bl, 0x2d                                                                                                      |     
                                                                                                                                 |     if (bl == 0x2d) {
    0x00456cf6 je 0x45732b                                                                                                       |         goto label_21;
                                                                                                                                 |     }
    0x00456cfc lea r13, [rbp + 2]                                                                                                |     r13 = rbp + 2;
    0x00456d00 lea r14d, [rbp + 3]                                                                                               |     r14d = rbp + 3;
    0x00456d04 xor edx, edx                                                                                                      |     edx = 0;
    0x00456d06 xor r12d, r12d                                                                                                    |     r12d = 0;
    0x00456d09 test bl, bl                                                                                                       |     
                                                                                                                                 |     if (bl == 0) {
    0x00456d0b je 0x456d2c                                                                                                       |         goto label_22;
                                                                                                                                 |     }
    0x00456d0d nop dword [rax]                                                                                                   |     
                                                                                                                                 |     do {
    0x00456d10 cmp bl, 0x3d                                                                                                      |         
                                                                                                                                 |         if (bl == 0x3d) {
    0x00456d13 je 0x456ef7                                                                                                       |             goto label_23;
                                                                                                                                 |         }
    0x00456d19 movzx ebx, byte [rbp + r12 + 3]                                                                                   |         ebx = *((rbp + r12 + 3));
    0x00456d1f inc r14d                                                                                                          |         r14d++;
    0x00456d22 inc r12                                                                                                           |         r12++;
    0x00456d25 add rdx, rdi                                                                                                      |         rdx += rdi;
    0x00456d28 test bl, bl                                                                                                       |         
    0x00456d2a jne 0x456d10                                                                                                      |         
                                                                                                                                 |     } while (bl != 0);
                                                                                                                                 | label_22:
    0x00456d2c cmp rcx, 0x17                                                                                                     |     
                                                                                                                                 |     if (rcx != 0x17) {
    0x00456d30 je 0x456d35                                                                                                       |         
    0x00456d32 mov rsi, qword [rsi]                                                                                              |         rsi = *(rsi);
                                                                                                                                 |     }
    0x00456d35 add rsi, 2                                                                                                        |     rsi += 2;
    0x00456d39 mov rcx, qword [rsp + 0x50]                                                                                       |     rcx = *((rsp + 0x50));
    0x00456d3e mov rdx, qword [rax + rcx + 0x18]                                                                                 |     rdx = *((rax + rcx + 0x18));
    0x00456d43 shl rdx, 0x20                                                                                                     |     rdx <<= 0x20;
    0x00456d47 movabs rax, 0xfffffffe00000000                                                                                    |     rax = 0xfffffffe00000000;
    0x00456d51 add rdx, rax                                                                                                      |     rdx += rax;
    0x00456d54 jmp 0x456efa                                                                                                      |     goto label_24;
                                                                                                                                 | label_16:
    0x00456d60 test r12b, r12b                                                                                                   |     
                                                                                                                                 |     if (r12b == 0) {
    0x00456d63 je 0x456b4a                                                                                                       |         goto label_0;
                                                                                                                                 |     }
    0x00456d69 lea rax, [rbp + 1]                                                                                                |     rax = rbp + 1;
    0x00456d6d mov qword [rsp + 0x48], rbx                                                                                       |     *((rsp + 0x48)) = rbx;
                                                                                                                                 | label_2:
    0x00456d72 mov qword [rsp + 0x58], rax                                                                                       |     *((rsp + 0x58)) = rax;
    0x00456d77 mov rdi, qword [r15]                                                                                              |     rdi = *(r15);
    0x00456d7a mov r13d, 0xffffffff                                                                                              |     r13d = 0xffffffff;
    0x00456d80 cmp qword [r15 + 8], rdi                                                                                          |     
                                                                                                                                 |     if (*((r15 + 8)) == rdi) {
    0x00456d84 je 0x4570b6                                                                                                       |         goto label_25;
                                                                                                                                 |     }
    0x00456d8a mov r14d, 1                                                                                                       |     r14d = 1;
    0x00456d90 xor eax, eax                                                                                                      |     eax = 0;
    0x00456d92 jmp 0x456dcb                                                                                                      |     
                                                                                                                                 |     while (eax == 2) {
                                                                                                                                 | label_1:
    0x00456da0 mov eax, r14d                                                                                                     |         eax = r14d;
    0x00456da3 mov rdi, qword [r15]                                                                                              |         rdi = *(r15);
    0x00456da6 mov rcx, qword [r15 + 8]                                                                                          |         rcx = *((r15 + 8));
    0x00456daa sub rcx, rdi                                                                                                      |         rcx -= rdi;
    0x00456dad sar rcx, 3                                                                                                        |         rcx >>= 3;
    0x00456db1 movabs rdx, 0xaf8af8af8af8af8b                                                                                    |         rdx = 0xaf8af8af8af8af8b;
    0x00456dbb imul rcx, rdx                                                                                                     |         rcx *= rdx;
    0x00456dbf inc r14d                                                                                                          |         r14d++;
    0x00456dc2 cmp rcx, rax                                                                                                      |         
                                                                                                                                 |         if (rcx <= rax) {
    0x00456dc5 jbe 0x4570b6                                                                                                      |             goto label_25;
                                                                                                                                 |         }
    0x00456dcb imul rbx, rax, 0x118                                                                                              |         rbx = rax * 0x118;
    0x00456dd2 add rdi, rbx                                                                                                      |         rdi += rbx;
    0x00456dd5 call 0x464910                                                                                                     |         eax = BloombergLP::balcl::Option::argType()const (rdi);
    0x00456dda cmp eax, 2                                                                                                        |         
    0x00456ddd je 0x456da0                                                                                                       |         
                                                                                                                                 |     }
    0x00456ddf add rbx, qword [r15]                                                                                              |     rbx += *(r15);
    0x00456de2 mov rdi, rbx                                                                                                      |     
    0x00456de5 call 0x4649b0                                                                                                     |     al = BloombergLP::balcl::Option::shortTag()const (rbx);
    0x00456dea cmp al, r12b                                                                                                      |     
                                                                                                                                 |     if (al != r12b) {
    0x00456ded jne 0x456da0                                                                                                      |         goto label_1;
                                                                                                                                 |     }
    0x00456def mov eax, r14d                                                                                                     |     eax = r14d;
    0x00456df2 sub eax, 1                                                                                                        |     eax--;
                                                                                                                                 |     if (eax < 0) {
    0x00456df5 jb 0x4570b6                                                                                                       |         goto label_25;
                                                                                                                                 |     }
    0x00456dfb movsxd rbx, eax                                                                                                   |     rbx = (int64_t) eax;
    0x00456dfe imul r12, rbx, 0x118                                                                                              |     r12 = rbx * 0x118;
    0x00456e05 mov rdi, qword [r15]                                                                                              |     
    0x00456e08 add rdi, r12                                                                                                      |     rdi += r12;
    0x00456e0b call 0x464910                                                                                                     |     eax = BloombergLP::balcl::Option::argType()const (*(r15));
    0x00456e10 test eax, eax                                                                                                     |     
                                                                                                                                 |     if (eax != 0) {
    0x00456e12 jne 0x4570b0                                                                                                      |         goto label_26;
                                                                                                                                 |     }
    0x00456e18 add r12, qword [r15]                                                                                              |     r12 += *(r15);
    0x00456e1b lea rbp, [rbx + rbx*4]                                                                                            |     rbp = rbx * 5;
    0x00456e1f shl rbp, 4                                                                                                        |     rbp <<= 4;
    0x00456e23 add rbp, qword [r15 + 0xa8]                                                                                       |     rbp += *((r15 + 0xa8));
    0x00456e2a mov rax, qword [rip + 0x2aedf7]                                                                                   |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00456e31 test rax, rax                                                                                                     |     
                                                                                                                                 |     if (rax == 0) {
    0x00456e34 jne 0x456e3b                                                                                                      |         
    0x00456e36 call 0x47ce20                                                                                                     |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                 |     }
    0x00456e3b lea r13, [rsp + 0x18]                                                                                             |     r13 = rsp + 0x18;
    0x00456e40 mov qword [rsp + 0x18], 0                                                                                         |     *((rsp + 0x18)) = 0;
    0x00456e49 mov qword [rsp + 0x40], rax                                                                                       |     *((rsp + 0x40)) = rax;
    0x00456e4e movaps xmm0, xmmword [rip + 0x4d5bb]                                                                              |     xmm0 = .comment;
    0x00456e55 movups xmmword [rsp + 0x30], xmm0                                                                                 |     __asm ("movups xmmword [rsp + 0x30], xmm0");
    0x00456e5a mov esi, 0x4cd544                                                                                                 |     
    0x00456e5f mov ecx, 0x4ae8f1                                                                                                 |     
    0x00456e64 mov rdi, r13                                                                                                      |     
    0x00456e67 xor edx, edx                                                                                                      |     
    0x00456e69 call 0x481e80                                                                                                     |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (r13, 0x4cd544, 0, "string<...>::assign(char*...): string too long");
    0x00456e6e mov rdi, r12                                                                                                      |     
    0x00456e71 call 0x4649e0                                                                                                     |     rax = BloombergLP::balcl::Option::typeInfo()const (r12);
    0x00456e76 mov rdi, rbp                                                                                                      |     
    0x00456e79 mov rsi, r13                                                                                                      |     
    0x00456e7c mov rdx, rax                                                                                                      |     
    0x00456e7f mov rcx, qword [rsp]                                                                                              |     
    0x00456e83 call 0x46bb30                                                                                                     |     eax = BloombergLP::balcl::TypeInfoUtil::parseAndValidate(BloombergLP::balcl::OptionValue*,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,BloombergLP::balcl::TypeInfoconst&,std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (rbp, r13, rax, *(rsp));
    0x00456e88 mov ebp, eax                                                                                                      |     
    0x00456e8a cmp qword [rsp + 0x38], 0x17                                                                                      |     
    0x00456e90 mov r14, qword [rsp + 8]                                                                                          |     r14 = *((rsp + 8));
                                                                                                                                 |     if (*((rsp + 0x38)) != 0x17) {
    0x00456e95 je 0x456ea7                                                                                                       |         
    0x00456e97 mov rsi, qword [rsp + 0x18]                                                                                       |         rsi = *((rsp + 0x18));
    0x00456e9c mov rdi, qword [rsp + 0x40]                                                                                       |         rdi = *((rsp + 0x40));
    0x00456ea1 mov rax, qword [rdi]                                                                                              |         rax = *(rdi);
    0x00456ea4 call qword [rax + 0x18]                                                                                           |         uint64_t (*rax + 0x18)() ();
                                                                                                                                 |     }
    0x00456ea7 test bpl, bpl                                                                                                     |     
                                                                                                                                 |     if (bpl == 0) {
    0x00456eaa je 0x45780c                                                                                                       |         goto label_27;
                                                                                                                                 |     }
    0x00456eb0 shl rbx, 5                                                                                                        |     rbx <<= 5;
    0x00456eb4 add rbx, qword [r15 + 0x20]                                                                                       |     rbx += *((r15 + 0x20));
    0x00456eb8 mov dword [rsp + 0x18], r14d                                                                                      |     *((rsp + 0x18)) = r14d;
    0x00456ebd mov rdi, rbx                                                                                                      |     
    0x00456ec0 mov rsi, r13                                                                                                      |     
    0x00456ec3 call 0x493f30                                                                                                     |     bsl::vector<int,bsl::allocator<int>>::push_back(int&&) (rbx, r13);
    0x00456ec8 mov rbp, qword [rsp + 0x58]                                                                                       |     rbp = *((rsp + 0x58));
    0x00456ecd lea rax, [rbp + 1]                                                                                                |     rax = rbp + 1;
    0x00456ed1 mov r12b, byte [rbp + 1]                                                                                          |     r12b = *((rbp + 1));
    0x00456ed5 test r12b, r12b                                                                                                   |     
    0x00456ed8 mov rbx, qword [rsp + 0x48]                                                                                       |     rbx = *((rsp + 0x48));
                                                                                                                                 |     if (r12b != 0) {
    0x00456edd jne 0x456d72                                                                                                      |         goto label_2;
                                                                                                                                 |     }
    0x00456ee3 mov r14, qword [rsp + 8]                                                                                          |     r14 = *((rsp + 8));
    0x00456ee8 movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |     r12 = 0xaaaaaaaaaaaaaaab;
    0x00456ef2 jmp 0x45726c                                                                                                      |     goto label_28;
                                                                                                                                 | label_23:
    0x00456ef7 mov rsi, r13                                                                                                      |     
                                                                                                                                 | label_24:
    0x00456efa sar rdx, 0x20                                                                                                     |     rdx >>= 0x20;
    0x00456efe mov rdi, r15                                                                                                      |     
    0x00456f01 call 0x457c50                                                                                                     |     eax = BloombergLP::balcl::CommandLine::findTag(char const*,unsigned long)const (r15, r13, rdx);
    0x00456f06 cmp eax, 0xffffffff                                                                                               |     
                                                                                                                                 |     if (eax != 0xffffffff) {
    0x00456f09 je 0x4573c2                                                                                                       |         
    0x00456f0f cdqe                                                                                                              |         rax = (int64_t) eax;
    0x00456f11 mov rcx, rax                                                                                                      |         rcx = rax;
    0x00456f14 mov qword [rsp + 0x58], rax                                                                                       |         *((rsp + 0x58)) = rax;
    0x00456f19 imul r13, rax, 0x118                                                                                              |         r13 = rax * 0x118;
    0x00456f20 add r13, qword [r15]                                                                                              |         r13 += *(r15);
    0x00456f23 cmp byte [rbp + r12 + 2], 0x3d                                                                                    |         
                                                                                                                                 |         if (*((rbp + r12 + 2)) == 0x3d) {
    0x00456f29 jne 0x456f32                                                                                                      |             
    0x00456f2b lea r12, [rbp + r12 + 3]                                                                                          |             r12 = rbp + r12 + 3;
    0x00456f30 jmp 0x456f94                                                                                                      |             
                                                                                                                                 |         } else {
    0x00456f32 mov rdi, r13                                                                                                      |             
    0x00456f35 call 0x464910                                                                                                     |             eax = BloombergLP::balcl::Option::argType()const (r13);
    0x00456f3a test eax, eax                                                                                                     |             
                                                                                                                                 |             if (eax != 0) {
    0x00456f3c je 0x456f8e                                                                                                       |                 
    0x00456f3e mov rax, qword [r15 + 0x68]                                                                                       |                 rax = *((r15 + 0x68));
    0x00456f42 mov rcx, qword [r15 + 0x70]                                                                                       |                 rcx = *((r15 + 0x70));
    0x00456f46 sub rcx, rax                                                                                                      |                 rcx -= rax;
    0x00456f49 sar rcx, 4                                                                                                        |                 rcx >>= 4;
    0x00456f4d movabs rdx, 0xaaaaaaaaaaaaaaab                                                                                    |                 rdx = 0xaaaaaaaaaaaaaaab;
    0x00456f57 imul rcx, rdx                                                                                                     |                 rcx *= rdx;
    0x00456f5b dec rcx                                                                                                           |                 rcx--;
    0x00456f5e cmp rcx, qword [rsp + 0x60]                                                                                       |                 
                                                                                                                                 |                 if (rcx == *((rsp + 0x60))) {
    0x00456f63 je 0x45775f                                                                                                       |                     goto label_29;
                                                                                                                                 |                 }
    0x00456f69 mov rcx, qword [rsp + 8]                                                                                          |                 rcx = *((rsp + 8));
    0x00456f6e lea ebp, [rcx + 1]                                                                                                |                 ebp = rcx + 1;
    0x00456f71 movsxd rcx, ebp                                                                                                   |                 rcx = (int64_t) ebp;
    0x00456f74 lea rcx, [rcx + rcx*2]                                                                                            |                 rcx *= 3;
    0x00456f78 shl rcx, 4                                                                                                        |                 rcx <<= 4;
    0x00456f7c lea r12, [rax + rcx]                                                                                              |                 r12 = rax + rcx;
    0x00456f80 cmp qword [rax + rcx + 0x20], 0x17                                                                                |                 
                                                                                                                                 |                 if (*((rax + rcx + 0x20)) == 0x17) {
    0x00456f86 je 0x456f9b                                                                                                       |                     goto label_30;
                                                                                                                                 |                 }
    0x00456f88 mov r12, qword [r12]                                                                                              |                 r12 = *(r12);
    0x00456f8c jmp 0x456f9b                                                                                                      |                 goto label_30;
                                                                                                                                 |             }
    0x00456f8e mov r12d, 0x4cd544                                                                                                |             r12d = 0x4cd544;
                                                                                                                                 |         }
    0x00456f94 mov rax, qword [rsp + 8]                                                                                          |         rax = *((rsp + 8));
    0x00456f99 mov ebp, eax                                                                                                      |         
                                                                                                                                 | label_30:
    0x00456f9b mov rdi, r13                                                                                                      |         
    0x00456f9e call 0x464950                                                                                                     |         al = BloombergLP::balcl::Option::isArray()const (r13);
    0x00456fa3 test al, al                                                                                                       |         
                                                                                                                                 |         if (al == 0) {
    0x00456fa5 jne 0x456fcf                                                                                                      |             
    0x00456fa7 mov rdi, r13                                                                                                      |             
    0x00456faa call 0x464910                                                                                                     |             eax = BloombergLP::balcl::Option::argType()const (r13);
    0x00456faf test eax, eax                                                                                                     |             
                                                                                                                                 |             if (eax == 0) {
    0x00456fb1 je 0x456fcf                                                                                                       |                 goto label_31;
                                                                                                                                 |             }
    0x00456fb3 mov rax, qword [r15 + 0x20]                                                                                       |             rax = *((r15 + 0x20));
    0x00456fb7 mov rcx, qword [rsp + 0x58]                                                                                       |             rcx = *((rsp + 0x58));
    0x00456fbc shl rcx, 5                                                                                                        |             rcx <<= 5;
    0x00456fc0 mov rdx, qword [rax + rcx + 8]                                                                                    |             rdx = *((rax + rcx + 8));
    0x00456fc5 cmp rdx, qword [rax + rcx]                                                                                        |             
                                                                                                                                 |             if (rdx != *((rax + rcx))) {
    0x00456fc9 jne 0x45777d                                                                                                      |                 goto label_32;
                                                                                                                                 |             }
                                                                                                                                 |         }
                                                                                                                                 | label_31:
    0x00456fcf mov dword [rsp + 0x60], ebp                                                                                       |         *((rsp + 0x60)) = ebp;
    0x00456fd3 mov rax, qword [rsp + 0x58]                                                                                       |         rax = *((rsp + 0x58));
    0x00456fd8 lea rbp, [rax + rax*4]                                                                                            |         rbp = rax * 5;
    0x00456fdc shl rbp, 4                                                                                                        |         rbp <<= 4;
    0x00456fe0 add rbp, qword [r15 + 0xa8]                                                                                       |         rbp += *((r15 + 0xa8));
    0x00456fe7 mov rax, qword [rip + 0x2aec3a]                                                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00456fee test rax, rax                                                                                                     |         
                                                                                                                                 |         if (rax == 0) {
    0x00456ff1 jne 0x456ff8                                                                                                      |             
    0x00456ff3 call 0x47ce20                                                                                                     |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                 |         }
    0x00456ff8 mov qword [rsp + 0x18], 0                                                                                         |         *((rsp + 0x18)) = 0;
    0x00457001 movaps xmm0, xmmword [rip + 0x4d408]                                                                              |         xmm0 = .comment;
    0x00457008 movups xmmword [rsp + 0x30], xmm0                                                                                 |         __asm ("movups xmmword [rsp + 0x30], xmm0");
    0x0045700d mov qword [rsp + 0x40], rax                                                                                       |         *((rsp + 0x40)) = rax;
    0x00457012 mov rdi, r12                                                                                                      |         
    0x00457015 call 0x4046c0                                                                                                     |         rax = strlen (r12);
    0x0045701a mov qword [rsp + 0x30], 0                                                                                         |         *((rsp + 0x30)) = 0;
    0x00457023 mov ecx, 0x4ae8f1                                                                                                 |         
    0x00457028 lea rbx, [rsp + 0x18]                                                                                             |         rbx = rsp + 0x18;
    0x0045702d mov rdi, rbx                                                                                                      |         
    0x00457030 mov rsi, r12                                                                                                      |         
    0x00457033 mov rdx, rax                                                                                                      |         
    0x00457036 call 0x481e80                                                                                                     |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (rbx, r12, rax, "string<...>::assign(char*...): string too long");
    0x0045703b mov rdi, r13                                                                                                      |         
    0x0045703e call 0x4649e0                                                                                                     |         rax = BloombergLP::balcl::Option::typeInfo()const (r13);
    0x00457043 mov rdi, rbp                                                                                                      |         
    0x00457046 mov rsi, rbx                                                                                                      |         
    0x00457049 mov rdx, rax                                                                                                      |         
    0x0045704c mov rcx, qword [rsp]                                                                                              |         
    0x00457050 call 0x46bb30                                                                                                     |         eax = BloombergLP::balcl::TypeInfoUtil::parseAndValidate(BloombergLP::balcl::OptionValue*,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,BloombergLP::balcl::TypeInfoconst&,std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (rbp, rbx, rax, *(rsp));
    0x00457055 mov ebx, eax                                                                                                      |         ebx = eax;
    0x00457057 cmp qword [rsp + 0x38], 0x17                                                                                      |         
    0x0045705d mov rbp, qword [rsp + 8]                                                                                          |         rbp = *((rsp + 8));
    0x00457062 movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |         r12 = 0xaaaaaaaaaaaaaaab;
                                                                                                                                 |         if (*((rsp + 0x38)) != 0x17) {
    0x0045706c je 0x45707e                                                                                                       |             
    0x0045706e mov rsi, qword [rsp + 0x18]                                                                                       |             rsi = *((rsp + 0x18));
    0x00457073 mov rdi, qword [rsp + 0x40]                                                                                       |             rdi = *((rsp + 0x40));
    0x00457078 mov rax, qword [rdi]                                                                                              |             rax = *(rdi);
    0x0045707b call qword [rax + 0x18]                                                                                           |             uint64_t (*rax + 0x18)() ();
                                                                                                                                 |         }
    0x0045707e test bl, bl                                                                                                       |         
                                                                                                                                 |         if (bl == 0) {
    0x00457080 je 0x457488                                                                                                       |             goto label_33;
                                                                                                                                 |         }
    0x00457086 mov rdi, qword [rsp + 0x58]                                                                                       |         
    0x0045708b shl rdi, 5                                                                                                        |         rdi <<= 5;
    0x0045708f add rdi, qword [r15 + 0x20]                                                                                       |         rdi += *((r15 + 0x20));
    0x00457093 mov dword [rsp + 0x18], ebp                                                                                       |         *((rsp + 0x18)) = ebp;
    0x00457097 lea r13, [rsp + 0x18]                                                                                             |         r13 = rsp + 0x18;
    0x0045709c mov rsi, r13                                                                                                      |         
    0x0045709f call 0x493f30                                                                                                     |         bsl::vector<int,bsl::allocator<int>>::push_back(int&&) (*((rsp + 0x58)), r13);
    0x004570a4 mov eax, dword [rsp + 0x60]                                                                                       |         eax = *((rsp + 0x60));
    0x004570a8 mov r14d, eax                                                                                                     |         r14d = *((rsp + 0x60));
    0x004570ab jmp 0x457267                                                                                                      |         goto label_34;
                                                                                                                                 | label_26:
    0x004570b0 dec r14d                                                                                                          |         r14d--;
    0x004570b3 mov r13d, r14d                                                                                                    |         r13d = r14d;
                                                                                                                                 | label_25:
    0x004570b6 cmp byte [rbp + 1], 0                                                                                             |         
                                                                                                                                 |         if (*((rbp + 1)) != 0) {
    0x004570ba je 0x45712f                                                                                                       |             
    0x004570bc cmp r13d, 0xffffffff                                                                                              |             
                                                                                                                                 |             if (r13d == 0xffffffff) {
    0x004570c0 je 0x457699                                                                                                       |                 goto label_35;
                                                                                                                                 |             }
    0x004570c6 movsxd rbx, r13d                                                                                                  |             rbx = (int64_t) r13d;
    0x004570c9 imul r12, rbx, 0x118                                                                                              |             r12 = rbx * 0x118;
    0x004570d0 add r12, qword [r15]                                                                                              |             r12 += *(r15);
    0x004570d3 mov al, byte [rbp + 2]                                                                                            |             al = *((rbp + 2));
    0x004570d6 cmp al, 0x3d                                                                                                      |             
                                                                                                                                 |             if (al != 0x3d) {
    0x004570d8 je 0x457157                                                                                                       |                 
    0x004570da test al, al                                                                                                       |                 
                                                                                                                                 |                 if (al != 0) {
    0x004570dc jne 0x45715d                                                                                                      |                     goto label_36;
                                                                                                                                 |                 }
    0x004570de mov rax, qword [r15 + 0x68]                                                                                       |                 rax = *((r15 + 0x68));
    0x004570e2 mov rcx, qword [r15 + 0x70]                                                                                       |                 rcx = *((r15 + 0x70));
    0x004570e6 sub rcx, rax                                                                                                      |                 rcx -= rax;
    0x004570e9 sar rcx, 4                                                                                                        |                 rcx >>= 4;
    0x004570ed movabs rdx, 0xaaaaaaaaaaaaaaab                                                                                    |                 rdx = 0xaaaaaaaaaaaaaaab;
    0x004570f7 imul rcx, rdx                                                                                                     |                 rcx *= rdx;
    0x004570fb dec rcx                                                                                                           |                 rcx--;
    0x004570fe cmp rcx, qword [rsp + 0x60]                                                                                       |                 
                                                                                                                                 |                 if (rcx == *((rsp + 0x60))) {
    0x00457103 je 0x4578cc                                                                                                       |                     goto label_37;
                                                                                                                                 |                 }
    0x00457109 mov rcx, qword [rsp + 8]                                                                                          |                 rcx = *((rsp + 8));
    0x0045710e lea r14d, [rcx + 1]                                                                                               |                 r14d = rcx + 1;
    0x00457112 movsxd rcx, r14d                                                                                                  |                 rcx = (int64_t) r14d;
    0x00457115 lea rcx, [rcx + rcx*2]                                                                                            |                 rcx *= 3;
    0x00457119 shl rcx, 4                                                                                                        |                 rcx <<= 4;
    0x0045711d lea rbp, [rax + rcx]                                                                                              |                 rbp = rax + rcx;
    0x00457121 cmp qword [rax + rcx + 0x20], 0x17                                                                                |                 
                                                                                                                                 |                 if (*((rax + rcx + 0x20)) == 0x17) {
    0x00457127 je 0x457169                                                                                                       |                     goto label_38;
                                                                                                                                 |                 }
    0x00457129 mov rbp, qword [rbp]                                                                                              |                 rbp = *(rbp);
    0x0045712d jmp 0x457169                                                                                                      |                 
                                                                                                                                 |             } else {
    0x0045712f mov r14, qword [rsp + 8]                                                                                          |                 r14 = *((rsp + 8));
    0x00457134 movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |                 r12 = 0xaaaaaaaaaaaaaaab;
    0x0045713e mov rbx, qword [rsp + 0x48]                                                                                       |                 rbx = *((rsp + 0x48));
    0x00457143 movabs rdi, 0x100000000                                                                                           |                 rdi = 0x100000000;
    0x0045714d lea r13, [rsp + 0x18]                                                                                             |                 r13 = rsp + 0x18;
    0x00457152 jmp 0x456b5a                                                                                                      |                 goto label_3;
                                                                                                                                 |             }
    0x00457157 add rbp, 3                                                                                                        |             rbp += 3;
    0x0045715b jmp 0x457161                                                                                                      |             goto label_39;
                                                                                                                                 | label_36:
    0x0045715d add rbp, 2                                                                                                        |             rbp += 2;
                                                                                                                                 | label_39:
    0x00457161 mov rax, qword [rsp + 8]                                                                                          |             rax = *((rsp + 8));
    0x00457166 mov r14d, eax                                                                                                     |             r14d = eax;
                                                                                                                                 |         }
                                                                                                                                 | label_38:
    0x00457169 mov rdi, r12                                                                                                      |         
    0x0045716c call 0x464950                                                                                                     |         al = BloombergLP::balcl::Option::isArray()const (r12);
    0x00457171 test al, al                                                                                                       |         
                                                                                                                                 |         if (al == 0) {
    0x00457173 jne 0x45718f                                                                                                      |             
    0x00457175 mov rax, qword [r15 + 0x20]                                                                                       |             rax = *((r15 + 0x20));
    0x00457179 mov rcx, rbx                                                                                                      |             rcx = rbx;
    0x0045717c shl rcx, 5                                                                                                        |             rcx <<= 5;
    0x00457180 mov rdx, qword [rax + rcx + 8]                                                                                    |             rdx = *((rax + rcx + 8));
    0x00457185 cmp rdx, qword [rax + rcx]                                                                                        |             
                                                                                                                                 |             if (rdx != *((rax + rcx))) {
    0x00457189 jne 0x457816                                                                                                      |                 goto label_40;
                                                                                                                                 |             }
                                                                                                                                 |         }
    0x0045718f mov dword [rsp + 0x50], r14d                                                                                      |         *((rsp + 0x50)) = r14d;
    0x00457194 lea r13, [rbx + rbx*4]                                                                                            |         r13 = rbx * 5;
    0x00457198 shl r13, 4                                                                                                        |         r13 <<= 4;
    0x0045719c add r13, qword [r15 + 0xa8]                                                                                       |         r13 += *((r15 + 0xa8));
    0x004571a3 mov rax, qword [rip + 0x2aea7e]                                                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004571aa test rax, rax                                                                                                     |         
                                                                                                                                 |         if (rax == 0) {
    0x004571ad jne 0x4571b4                                                                                                      |             
    0x004571af call 0x47ce20                                                                                                     |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                 |         }
    0x004571b4 mov qword [rsp + 0x18], 0                                                                                         |         *((rsp + 0x18)) = 0;
    0x004571bd movaps xmm0, xmmword [rip + 0x4d24c]                                                                              |         xmm0 = .comment;
    0x004571c4 movups xmmword [rsp + 0x30], xmm0                                                                                 |         __asm ("movups xmmword [rsp + 0x30], xmm0");
    0x004571c9 mov qword [rsp + 0x40], rax                                                                                       |         *((rsp + 0x40)) = rax;
    0x004571ce mov rdi, rbp                                                                                                      |         
    0x004571d1 call 0x4046c0                                                                                                     |         rax = strlen (rbp);
    0x004571d6 mov qword [rsp + 0x30], 0                                                                                         |         *((rsp + 0x30)) = 0;
    0x004571df mov ecx, 0x4ae8f1                                                                                                 |         
    0x004571e4 lea r14, [rsp + 0x18]                                                                                             |         r14 = rsp + 0x18;
    0x004571e9 mov rdi, r14                                                                                                      |         
    0x004571ec mov rsi, rbp                                                                                                      |         
    0x004571ef mov rdx, rax                                                                                                      |         
    0x004571f2 call 0x481e80                                                                                                     |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (r14, rbp, rax, "string<...>::assign(char*...): string too long");
    0x004571f7 mov rdi, r12                                                                                                      |         
    0x004571fa call 0x4649e0                                                                                                     |         rax = BloombergLP::balcl::Option::typeInfo()const (r12);
    0x004571ff mov rdi, r13                                                                                                      |         
    0x00457202 mov rsi, r14                                                                                                      |         
    0x00457205 mov rdx, rax                                                                                                      |         
    0x00457208 mov rcx, qword [rsp]                                                                                              |         
    0x0045720c call 0x46bb30                                                                                                     |         eax = BloombergLP::balcl::TypeInfoUtil::parseAndValidate(BloombergLP::balcl::OptionValue*,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,BloombergLP::balcl::TypeInfoconst&,std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (r13, r14, rax, *(rsp));
    0x00457211 mov r12d, eax                                                                                                     |         r12d = eax;
    0x00457214 cmp qword [rsp + 0x38], 0x17                                                                                      |         
                                                                                                                                 |         if (*((rsp + 0x38)) != 0x17) {
    0x0045721a je 0x45722c                                                                                                       |             
    0x0045721c mov rsi, qword [rsp + 0x18]                                                                                       |             rsi = *((rsp + 0x18));
    0x00457221 mov rdi, qword [rsp + 0x40]                                                                                       |             rdi = *((rsp + 0x40));
    0x00457226 mov rax, qword [rdi]                                                                                              |             rax = *(rdi);
    0x00457229 call qword [rax + 0x18]                                                                                           |             uint64_t (*rax + 0x18)() ();
                                                                                                                                 |         }
    0x0045722c test r12b, r12b                                                                                                   |         
    0x0045722f lea r13, [rsp + 0x18]                                                                                             |         r13 = rsp + 0x18;
                                                                                                                                 |         if (r12b == 0) {
    0x00457234 je 0x457728                                                                                                       |             goto label_41;
                                                                                                                                 |         }
    0x0045723a shl rbx, 5                                                                                                        |         rbx <<= 5;
    0x0045723e add rbx, qword [r15 + 0x20]                                                                                       |         rbx += *((r15 + 0x20));
    0x00457242 mov rax, qword [rsp + 8]                                                                                          |         rax = *((rsp + 8));
    0x00457247 mov dword [rsp + 0x18], eax                                                                                       |         *((rsp + 0x18)) = eax;
    0x0045724b mov rdi, rbx                                                                                                      |         
    0x0045724e mov rsi, r13                                                                                                      |         
    0x00457251 call 0x493f30                                                                                                     |         bsl::vector<int,bsl::allocator<int>>::push_back(int&&) (rbx, r13);
    0x00457256 mov eax, dword [rsp + 0x50]                                                                                       |         eax = *((rsp + 0x50));
    0x0045725a mov r14d, eax                                                                                                     |         r14d = *((rsp + 0x50));
    0x0045725d movabs r12, 0xaaaaaaaaaaaaaaab                                                                                    |         r12 = 0xaaaaaaaaaaaaaaab;
                                                                                                                                 | label_34:
    0x00457267 mov rbx, qword [rsp + 0x48]                                                                                       |         rbx = *((rsp + 0x48));
                                                                                                                                 | label_28:
    0x0045726c movabs rdi, 0x100000000                                                                                           |         rdi = 0x100000000;
    0x00457276 jmp 0x456b5a                                                                                                      |         goto label_3;
                                                                                                                                 | label_17:
    0x0045727b mov esi, 0x4af850                                                                                                 |         
    0x00457280 mov edx, 0xe                                                                                                      |         
    0x00457285 mov rbp, qword [rsp]                                                                                              |         rbp = *(rsp);
    0x00457289 mov rdi, rbp                                                                                                      |         
    0x0045728c call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "The argument \", 0xe);
    0x00457291 mov rsi, qword [rsp + 0x50]                                                                                       |         
    0x00457296 add rsi, qword [r15 + 0x68]                                                                                       |         rsi += *((r15 + 0x68));
    0x0045729a mov rdi, rax                                                                                                      |         
    0x0045729d call 0x44f6f0                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&bsl::operator << <char,std::_1::char_traits<char>,bsl::allocator<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&) (rax, *((rsp + 0x50)));
    0x004572a2 mov esi, 0x4af86f                                                                                                 |         
    0x004572a7 mov edx, 0x11                                                                                                     |         
    0x004572ac mov rdi, rax                                                                                                      |         
    0x004572af call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, 0x4af86f, 0x11);
    0x004572b4 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x004572b9 lea rsi, [rsp + 0x18]                                                                                             |         
    0x004572be mov edx, 1                                                                                                        |         
    0x004572c3 mov rdi, rax                                                                                                      |         
    0x004572c6 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x004572cb mov rdi, rax                                                                                                      |         rdi = rax;
    0x004572ce call 0x404980                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x004572d3 mov esi, 0x4afac2                                                                                                 |         esi = "The error occurred while parsing the ";
    0x004572d8 mov edx, 0x25                                                                                                     |         edx = 0x25;
    0x004572dd jmp 0x4572ed                                                                                                      |         goto label_42;
                                                                                                                                 | label_18:
    0x004572df mov esi, 0x4afac2                                                                                                 |         
    0x004572e4 mov edx, 0x25                                                                                                     |         
    0x004572e9 mov rbp, qword [rsp]                                                                                              |         rbp = *(rsp);
                                                                                                                                 | label_42:
    0x004572ed mov rdi, rbp                                                                                                      |         
    0x004572f0 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "The error occurred while parsing the ", 0x25);
    0x004572f5 mov rbx, rax                                                                                                      |         rbx = rax;
    0x004572f8 dec r14d                                                                                                          |         r14d--;
                                                                                                                                 | label_6:
    0x004572fb movsxd rsi, r14d                                                                                                  |         rsi = (int64_t) r14d;
    0x004572fe mov rdi, rax                                                                                                      |         rdi = rax;
    0x00457301 jmp 0x457382                                                                                                      |         goto label_43;
                                                                                                                                 | label_13:
    0x00457303 mov esi, 0x4af85f                                                                                                 |         esi = "The character \"-\" was unexpected.";
    0x00457308 jmp 0x457324                                                                                                      |         goto label_44;
                                                                                                                                 | label_19:
    0x0045730a mov rax, qword [r15 + 0x48]                                                                                       |         rax = *((r15 + 0x48));
    0x0045730e sub rax, qword [r15 + 0x40]                                                                                       |         rax -= *((r15 + 0x40));
    0x00457312 sar rax, 2                                                                                                        |         rax >>= 2;
    0x00457316 cmp rax, rbx                                                                                                      |         
                                                                                                                                 |         if (rax != rbx) {
    0x00457319 jne 0x4574be                                                                                                      |             goto label_45;
                                                                                                                                 |         }
    0x0045731f mov esi, 0x4af881                                                                                                 |         esi = "The argument \"--\" was unexpected.";
                                                                                                                                 | label_44:
    0x00457324 mov edx, 0x21                                                                                                     |         edx = 0x21;
    0x00457329 jmp 0x457335                                                                                                      |         goto label_46;
                                                                                                                                 | label_21:
    0x0045732b mov esi, 0x4af8a6                                                                                                 |         
    0x00457330 mov edx, 0x54                                                                                                     |         
                                                                                                                                 | label_46:
    0x00457335 mov rbp, qword [rsp]                                                                                              |         rbp = *(rsp);
    0x00457339 mov rdi, rbp                                                                                                      |         
    0x0045733c call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "Long option expected, instead of \"---\".\n(Note: long options may not begin with '-'.)", 0x54);
    0x00457341 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x00457346 lea rsi, [rsp + 0x18]                                                                                             |         
    0x0045734b mov edx, 1                                                                                                        |         
    0x00457350 mov rdi, rax                                                                                                      |         
    0x00457353 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x00457358 mov rdi, rax                                                                                                      |         rdi = rax;
    0x0045735b call 0x404980                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x00457360 mov esi, 0x4afac2                                                                                                 |         
    0x00457365 mov edx, 0x25                                                                                                     |         
    0x0045736a mov rdi, rbp                                                                                                      |         
    0x0045736d call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rbp, "The error occurred while parsing the ", 0x25);
    0x00457372 mov rbx, rax                                                                                                      |         rbx = rax;
    0x00457375 mov rax, qword [rsp + 8]                                                                                          |         rax = *((rsp + 8));
    0x0045737a dec eax                                                                                                           |         eax--;
    0x0045737c movsxd rsi, eax                                                                                                   |         rsi = (int64_t) eax;
    0x0045737f mov rdi, rbx                                                                                                      |         
                                                                                                                                 | label_43:
    0x00457382 call 0x459310                                                                                                     |         BloombergLP::balcl::(anonymousnamespace)::u::operator << (std::_1::basic_ostream<char,std::_1::char_traits<char>>&,BloombergLP::balcl::(anonymousnamespace)::u::Ordinal) (rbx, rsi, rdx);
    0x00457387 mov esi, 0x4afb01                                                                                                 |         
    0x0045738c mov edx, 0xa                                                                                                      |         
    0x00457391 mov rdi, rbx                                                                                                      |         
    0x00457394 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rbx, " argument.", 0xa);
    0x00457399 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x0045739e lea rsi, [rsp + 0x18]                                                                                             |         
    0x004573a3 mov edx, 1                                                                                                        |         
    0x004573a8 mov rdi, rax                                                                                                      |         
    0x004573ab call 0x455480                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x004573b0 mov rdi, rbp                                                                                                      |         rdi = rbp;
                                                                                                                                 | label_7:
    0x004573b3 call 0x404980                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x004573b8 mov ebx, 0xffffffff                                                                                               |         ebx = 0xffffffff;
    0x004573bd jmp 0x457688                                                                                                      |         goto label_5;
                                                                                                                                 |     }
    0x004573c2 mov esi, 0x4af8fb                                                                                                 |     
    0x004573c7 mov edx, 0xc                                                                                                      |     
    0x004573cc mov rdi, qword [rsp]                                                                                              |     
    0x004573d0 call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "The string \", 0xc);
    0x004573d5 mov r14, rax                                                                                                      |     r14 = rax;
    0x004573d8 mov rax, qword [rip + 0x2ae849]                                                                                   |     rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x004573df test rax, rax                                                                                                     |     
                                                                                                                                 |     if (rax == 0) {
    0x004573e2 jne 0x4573e9                                                                                                      |         
    0x004573e4 call 0x47ce20                                                                                                     |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                 |     }
    0x004573e9 mov qword [rsp + 0x18], 0                                                                                         |     *((rsp + 0x18)) = 0;
    0x004573f2 mov qword [rsp + 0x40], rax                                                                                       |     *((rsp + 0x40)) = rax;
    0x004573f7 movaps xmm0, xmmword [rip + 0x4d012]                                                                              |     xmm0 = .comment;
    0x004573fe movups xmmword [rsp + 0x30], xmm0                                                                                 |     __asm ("movups xmmword [rsp + 0x30], xmm0");
    0x00457403 lea rbp, [rsp + 0x18]                                                                                             |     rbp = rsp + 0x18;
    0x00457408 mov ecx, 0x4ae8f1                                                                                                 |     
    0x0045740d mov rdi, rbp                                                                                                      |     
    0x00457410 mov rsi, r13                                                                                                      |     
    0x00457413 mov rdx, r12                                                                                                      |     
    0x00457416 call 0x481e80                                                                                                     |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (rbp, r13, r12, "string<...>::assign(char*...): string too long");
    0x0045741b mov rdi, r14                                                                                                      |     
    0x0045741e mov rsi, rbp                                                                                                      |     
    0x00457421 call 0x44f6f0                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&bsl::operator << <char,std::_1::char_traits<char>,bsl::allocator<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&) (r14, rbp);
    0x00457426 mov esi, 0x4af908                                                                                                 |     
    0x0045742b mov edx, 0x1e                                                                                                     |     
    0x00457430 mov rdi, rax                                                                                                      |     
    0x00457433 call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, "\" does not match any long tag.", 0x1e);
    0x00457438 mov byte [rsp + 0x17], 0xa                                                                                        |     *((rsp + 0x17)) = 0xa;
    0x0045743d lea rsi, [rsp + 0x17]                                                                                             |     
    0x00457442 mov edx, 1                                                                                                        |     
    0x00457447 mov rdi, rax                                                                                                      |     
    0x0045744a call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x17, 1);
    0x0045744f mov rdi, rax                                                                                                      |     rdi = rax;
    0x00457452 call 0x404980                                                                                                     |     std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x00457457 cmp qword [rsp + 0x38], 0x17                                                                                      |     
                                                                                                                                 |     if (*((rsp + 0x38)) != 0x17) {
    0x0045745d je 0x45746f                                                                                                       |         
    0x0045745f mov rsi, qword [rsp + 0x18]                                                                                       |         rsi = *((rsp + 0x18));
    0x00457464 mov rdi, qword [rsp + 0x40]                                                                                       |         rdi = *((rsp + 0x40));
    0x00457469 mov rax, qword [rdi]                                                                                              |         rax = *(rdi);
    0x0045746c call qword [rax + 0x18]                                                                                           |         uint64_t (*rax + 0x18)() ();
                                                                                                                                 |     }
    0x0045746f inc r12d                                                                                                          |     r12d++;
    0x00457472 mov rsi, qword [rsp]                                                                                              |     rsi = *(rsp);
    0x00457476 mov rdx, qword [rsp + 8]                                                                                          |     rdx = *((rsp + 8));
    0x0045747b mov ecx, 2                                                                                                        |     ecx = 2;
    0x00457480 mov r8d, r12d                                                                                                     |     r8d = r12d;
    0x00457483 jmp 0x457807                                                                                                      |     goto label_47;
                                                                                                                                 | label_33:
    0x00457488 mov rax, qword [r15 + 0x68]                                                                                       |     rax = *((r15 + 0x68));
    0x0045748c mov rdx, qword [rsp + 0x50]                                                                                       |     rdx = *((rsp + 0x50));
    0x00457491 lea rcx, [rax + rdx]                                                                                              |     rcx = rax + rdx;
    0x00457495 cmp qword [rax + rdx + 0x20], 0x17                                                                                |     
                                                                                                                                 |     if (*((rax + rdx + 0x20)) != 0x17) {
    0x0045749b je 0x4574a0                                                                                                       |         
    0x0045749d mov rcx, qword [rcx]                                                                                              |         rcx = *(rcx);
                                                                                                                                 |     }
    0x004574a0 sub r14d, ecx                                                                                                     |     r14d -= ecx;
    0x004574a3 mov rcx, qword [rsp + 0x50]                                                                                       |     rcx = *((rsp + 0x50));
    0x004574a8 mov r8d, dword [rax + rcx + 0x18]                                                                                 |     r8d = *((rax + rcx + 0x18));
    0x004574ad dec r8d                                                                                                           |     r8d--;
    0x004574b0 mov rsi, qword [rsp]                                                                                              |     rsi = *(rsp);
    0x004574b4 mov edx, ebp                                                                                                      |     edx = ebp;
    0x004574b6 mov ecx, r14d                                                                                                     |     ecx = r14d;
    0x004574b9 jmp 0x457807                                                                                                      |     goto label_47;
                                                                                                                                 | label_45:
    0x004574be mov qword [rsp + 0x48], rbx                                                                                       |     *((rsp + 0x48)) = rbx;
    0x004574c3 mov rdi, qword [r15]                                                                                              |     rdi = *(r15);
    0x004574c6 cmp qword [r15 + 8], rdi                                                                                          |     
                                                                                                                                 |     if (*((r15 + 8)) == rdi) {
    0x004574ca je 0x457557                                                                                                       |         goto label_48;
                                                                                                                                 |     }
    0x004574d0 mov r12d, 1                                                                                                       |     r12d = 1;
    0x004574d6 xor ebx, ebx                                                                                                      |     ebx = 0;
    0x004574d8 jmp 0x457507                                                                                                      |     
                                                                                                                                 |     while (eax == 0) {
                                                                                                                                 | label_4:
    0x004574e0 mov ebx, r12d                                                                                                     |         ebx = r12d;
    0x004574e3 mov rdi, qword [r15]                                                                                              |         rdi = *(r15);
    0x004574e6 mov rax, qword [r15 + 8]                                                                                          |         rax = *((r15 + 8));
    0x004574ea sub rax, rdi                                                                                                      |         rax -= rdi;
    0x004574ed sar rax, 3                                                                                                        |         rax >>= 3;
    0x004574f1 movabs rcx, 0xaf8af8af8af8af8b                                                                                    |         rcx = 0xaf8af8af8af8af8b;
    0x004574fb imul rax, rcx                                                                                                     |         rax *= rcx;
    0x004574ff inc r12d                                                                                                          |         r12d++;
    0x00457502 cmp rax, rbx                                                                                                      |         
                                                                                                                                 |         if (rax <= rbx) {
    0x00457505 jbe 0x457557                                                                                                      |             goto label_48;
                                                                                                                                 |         }
    0x00457507 imul rbp, rbx, 0x118                                                                                              |         rbp = rbx * 0x118;
    0x0045750e add rdi, rbp                                                                                                      |         rdi += rbp;
    0x00457511 call 0x464910                                                                                                     |         eax = BloombergLP::balcl::Option::argType()const (rdi);
    0x00457516 test eax, eax                                                                                                     |         
    0x00457518 je 0x4574e0                                                                                                       |         
                                                                                                                                 |     }
    0x0045751a mov r14d, eax                                                                                                     |     r14d = eax;
    0x0045751d mov rax, qword [r15 + 0x20]                                                                                       |     rax = *((r15 + 0x20));
    0x00457521 shl rbx, 5                                                                                                        |     rbx <<= 5;
    0x00457525 mov rcx, qword [rax + rbx]                                                                                        |     rcx = *((rax + rbx));
    0x00457529 cmp qword [rax + rbx + 8], rcx                                                                                    |     
                                                                                                                                 |     if (*((rax + rbx + 8)) != rcx) {
    0x0045752e jne 0x4574e0                                                                                                      |         goto label_4;
                                                                                                                                 |     }
    0x00457530 add rbp, qword [r15]                                                                                              |     rbp += *(r15);
    0x00457533 mov rdi, rbp                                                                                                      |     
    0x00457536 call 0x4649a0                                                                                                     |     rax = BloombergLP::balcl::Option::occurrenceInfo()const (rbp);
    0x0045753b mov rdi, rax                                                                                                      |     
    0x0045753e call 0x4627b0                                                                                                     |     al = BloombergLP::balcl::OccurrenceInfo::isRequired()const (rax);
    0x00457543 cmp r14d, 1                                                                                                       |     
                                                                                                                                 |     if (r14d != 1) {
    0x00457547 jne 0x4574e0                                                                                                      |         goto label_4;
                                                                                                                                 |     }
    0x00457549 test al, al                                                                                                       |     
                                                                                                                                 |     if (al == 0) {
    0x0045754b je 0x4574e0                                                                                                       |         goto label_4;
                                                                                                                                 |     }
    0x0045754d sub r12d, 1                                                                                                       |     r12d--;
                                                                                                                                 |     if (r12d >= 0) {
    0x00457551 jae 0x457926                                                                                                      |         goto label_49;
                                                                                                                                 |     }
                                                                                                                                 | label_48:
    0x00457557 mov r14, qword [rsp + 8]                                                                                          |     r14 = *((rsp + 8));
    0x0045755c lea eax, [r14 + 1]                                                                                                |     eax = r14 + 1;
    0x00457560 mov rbp, qword [r15 + 0x68]                                                                                       |     rbp = *((r15 + 0x68));
    0x00457564 mov rcx, qword [r15 + 0x70]                                                                                       |     rcx = *((r15 + 0x70));
    0x00457568 sub rcx, rbp                                                                                                      |     rcx -= rbp;
    0x0045756b sar rcx, 4                                                                                                        |     rcx >>= 4;
    0x0045756f movabs rdx, 0xaaaaaaaaaaaaaaab                                                                                    |     rdx = 0xaaaaaaaaaaaaaaab;
    0x00457579 imul rcx, rdx                                                                                                     |     rcx *= rdx;
    0x0045757d cmp rcx, rax                                                                                                      |     
    0x00457580 mov rdx, qword [rsp + 0x48]                                                                                       |     rdx = *((rsp + 0x48));
                                                                                                                                 |     if (rcx <= rax) {
    0x00457585 jbe 0x45767a                                                                                                      |         goto label_8;
                                                                                                                                 |     }
    0x0045758b mov rcx, qword [r15 + 0x40]                                                                                       |     rcx = *((r15 + 0x40));
    0x0045758f movsxd r12, dword [rcx + rdx*4]                                                                                   |     r12 = *((rcx + rdx*4));
    0x00457593 lea rbx, [r12 + r12*4]                                                                                            |     rbx = r12 * 5;
    0x00457597 shl rbx, 4                                                                                                        |     rbx <<= 4;
    0x0045759b add rbx, qword [r15 + 0xa8]                                                                                       |     rbx += *((r15 + 0xa8));
    0x004575a2 lea rax, [rax + rax*2]                                                                                            |     rax *= 3;
    0x004575a6 shl rax, 4                                                                                                        |     rax <<= 4;
    0x004575aa add rbp, rax                                                                                                      |     rbp += rax;
    0x004575ad imul rdi, r12, 0x118                                                                                              |     rdi = r12 * 0x118;
    0x004575b4 add rdi, qword [r15]                                                                                              |     rdi += *(r15);
    0x004575b7 call 0x4649e0                                                                                                     |     rax = BloombergLP::balcl::Option::typeInfo()const (rdi);
    0x004575bc mov rdi, rbx                                                                                                      |     
    0x004575bf mov rsi, rbp                                                                                                      |     
                                                                                                                                 |     do {
    0x004575c2 mov rdx, rax                                                                                                      |         
    0x004575c5 mov rcx, qword [rsp]                                                                                              |         
    0x004575c9 call 0x46bb30                                                                                                     |         al = BloombergLP::balcl::TypeInfoUtil::parseAndValidate(BloombergLP::balcl::OptionValue*,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&,BloombergLP::balcl::TypeInfoconst&,std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (rbx, rbp, rax, *(rsp));
    0x004575ce test al, al                                                                                                       |         
                                                                                                                                 |         if (al == 0) {
    0x004575d0 je 0x4578ae                                                                                                       |             goto label_50;
                                                                                                                                 |         }
    0x004575d6 mov ebp, r14d                                                                                                     |         
    0x004575d9 lea r14d, [rbp + 1]                                                                                               |         r14d = rbp + 1;
    0x004575dd mov rdi, r12                                                                                                      |         
    0x004575e0 shl rdi, 5                                                                                                        |         rdi <<= 5;
    0x004575e4 add rdi, qword [r15 + 0x20]                                                                                       |         rdi += *((r15 + 0x20));
    0x004575e8 mov dword [rsp + 0x18], r14d                                                                                      |         *((rsp + 0x18)) = r14d;
    0x004575ed lea rsi, [rsp + 0x18]                                                                                             |         
    0x004575f2 call 0x493f30                                                                                                     |         bsl::vector<int,bsl::allocator<int>>::push_back(int&&) (r12, rsp + 0x18);
    0x004575f7 imul rdi, r12, 0x118                                                                                              |         rdi = r12 * 0x118;
    0x004575fe add rdi, qword [r15]                                                                                              |         rdi += *(r15);
    0x00457601 call 0x464950                                                                                                     |         BloombergLP::balcl::Option::isArray()const (rdi);
    0x00457606 add ebp, 2                                                                                                        |         ebp += 2;
    0x00457609 mov r13, qword [r15 + 0x68]                                                                                       |         r13 = *((r15 + 0x68));
    0x0045760d mov rcx, qword [r15 + 0x70]                                                                                       |         rcx = *((r15 + 0x70));
    0x00457611 sub rcx, r13                                                                                                      |         rcx -= r13;
    0x00457614 sar rcx, 4                                                                                                        |         rcx >>= 4;
    0x00457618 movabs rdx, 0xaaaaaaaaaaaaaaab                                                                                    |         rdx = 0xaaaaaaaaaaaaaaab;
    0x00457622 imul rcx, rdx                                                                                                     |         rcx *= rdx;
    0x00457626 cmp rcx, rbp                                                                                                      |         
    0x00457629 mov rcx, qword [rsp + 0x48]                                                                                       |         rcx = *((rsp + 0x48));
                                                                                                                                 |         if (rcx <= rbp) {
    0x0045762e jbe 0x45767a                                                                                                      |             goto label_8;
                                                                                                                                 |         }
    0x00457630 xor al, 1                                                                                                         |         al ^= 1;
    0x00457632 movzx eax, al                                                                                                     |         eax = (int32_t) al;
    0x00457635 add rcx, rax                                                                                                      |         rcx += rax;
    0x00457638 mov rax, qword [r15 + 0x40]                                                                                       |         rax = *((r15 + 0x40));
    0x0045763c mov qword [rsp + 0x48], rcx                                                                                       |         *((rsp + 0x48)) = rcx;
    0x00457641 movsxd r12, dword [rax + rcx*4]                                                                                   |         r12 = *((rax + rcx*4));
    0x00457645 lea rbx, [r12 + r12*4]                                                                                            |         rbx = r12 * 5;
    0x00457649 shl rbx, 4                                                                                                        |         rbx <<= 4;
    0x0045764d add rbx, qword [r15 + 0xa8]                                                                                       |         rbx += *((r15 + 0xa8));
    0x00457654 lea rax, [rbp + rbp*2]                                                                                            |         rax = rbp + rbp*2;
    0x00457659 shl rax, 4                                                                                                        |         rax <<= 4;
    0x0045765d add r13, rax                                                                                                      |         r13 += rax;
    0x00457660 imul rdi, r12, 0x118                                                                                              |         rdi = r12 * 0x118;
    0x00457667 add rdi, qword [r15]                                                                                              |         rdi += *(r15);
    0x0045766a call 0x4649e0                                                                                                     |         BloombergLP::balcl::Option::typeInfo()const (rdi);
    0x0045766f mov rdi, rbx                                                                                                      |         rdi = rbx;
    0x00457672 mov rsi, r13                                                                                                      |         rsi = r13;
    0x00457675 jmp 0x4575c2                                                                                                      |         
                                                                                                                                 |     } while (1);
                                                                                                                                 | label_8:
    0x0045767a mov rdi, r15                                                                                                      |     
    0x0045767d mov rsi, qword [rsp]                                                                                              |     
    0x00457681 call 0x457da0                                                                                                     |     eax = BloombergLP::balcl::CommandLine::postParse(std::_1::basic_ostream<char,std::_1::char_traits<char>>&) (r15, *(rsp));
    0x00457686 mov ebx, eax                                                                                                      |     ebx = eax;
                                                                                                                                 |     do {
                                                                                                                                 | label_5:
    0x00457688 mov eax, ebx                                                                                                      |         
    0x0045768a add rsp, 0x68                                                                                                     |         
    0x0045768e pop rbx                                                                                                           |         
    0x0045768f pop r12                                                                                                           |         
    0x00457691 pop r13                                                                                                           |         
    0x00457693 pop r14                                                                                                           |         
    0x00457695 pop r15                                                                                                           |         
    0x00457697 pop rbp                                                                                                           |         
    0x00457698 ret                                                                                                               |         return rax;
                                                                                                                                 | label_35:
    0x00457699 mov esi, 0x4af98a                                                                                                 |         
    0x0045769e mov edx, 0xf                                                                                                      |         
    0x004576a3 mov rdi, qword [rsp]                                                                                              |         
    0x004576a7 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "The character \", 0xf);
    0x004576ac mov cl, byte [rbp + 1]                                                                                            |         cl = *((rbp + 1));
    0x004576af mov byte [rsp + 0x18], cl                                                                                         |         *((rsp + 0x18)) = cl;
    0x004576b3 lea rsi, [rsp + 0x18]                                                                                             |         
    0x004576b8 mov edx, 1                                                                                                        |         
    0x004576bd mov rdi, rax                                                                                                      |         
    0x004576c0 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x004576c5 mov esi, 0x4af99a                                                                                                 |         
    0x004576ca mov edx, 0x1f                                                                                                     |         
    0x004576cf mov rdi, rax                                                                                                      |         
    0x004576d2 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, "\" does not match any short tag.", 0x1f);
    0x004576d7 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x004576dc lea rsi, [rsp + 0x18]                                                                                             |         
    0x004576e1 mov edx, 1                                                                                                        |         
    0x004576e6 mov rdi, rax                                                                                                      |         
    0x004576e9 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x004576ee mov rdi, rax                                                                                                      |         rdi = rax;
    0x004576f1 call 0x404980                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x004576f6 mov rcx, qword [r15 + 0x68]                                                                                       |         rcx = *((r15 + 0x68));
    0x004576fa mov rdx, qword [rsp + 0x50]                                                                                       |         rdx = *((rsp + 0x50));
    0x004576ff lea rax, [rcx + rdx]                                                                                              |         rax = rcx + rdx;
    0x00457703 cmp qword [rcx + rdx + 0x20], 0x17                                                                                |         
                                                                                                                                 |         if (*((rcx + rdx + 0x20)) != 0x17) {
    0x00457709 je 0x45770e                                                                                                       |             
    0x0045770b mov rax, qword [rax]                                                                                              |             rax = *(rax);
                                                                                                                                 |         }
    0x0045770e mov rdx, qword [rsp + 8]                                                                                          |         rdx = *((rsp + 8));
    0x00457713 mov rcx, qword [rsp + 0x58]                                                                                       |         rcx = *((rsp + 0x58));
    0x00457718 sub ecx, eax                                                                                                      |         ecx -= eax;
    0x0045771a mov ebx, 0xffffffff                                                                                               |         ebx = 0xffffffff;
    0x0045771f mov rsi, qword [rsp]                                                                                              |         rsi = *(rsp);
    0x00457723 jmp 0x45789e                                                                                                      |         goto label_51;
                                                                                                                                 | label_41:
    0x00457728 mov edx, dword [rsp + 0x50]                                                                                       |         edx = *((rsp + 0x50));
    0x0045772c movsxd rcx, edx                                                                                                   |         rcx = (int64_t) edx;
    0x0045772f mov rax, qword [r15 + 0x68]                                                                                       |         rax = *((r15 + 0x68));
    0x00457733 lea rcx, [rcx + rcx*2]                                                                                            |         rcx *= 3;
    0x00457737 shl rcx, 4                                                                                                        |         rcx <<= 4;
    0x0045773b lea rsi, [rax + rcx]                                                                                              |         rsi = rax + rcx;
    0x0045773f cmp qword [rax + rcx + 0x20], 0x17                                                                                |         
                                                                                                                                 |         if (*((rax + rcx + 0x20)) != 0x17) {
    0x00457745 je 0x45774a                                                                                                       |             
    0x00457747 mov rsi, qword [rsi]                                                                                              |             rsi = *(rsi);
                                                                                                                                 |         }
    0x0045774a sub ebp, esi                                                                                                      |         ebp -= esi;
    0x0045774c mov r8d, dword [rax + rcx + 0x18]                                                                                 |         r8d = *((rax + rcx + 0x18));
    0x00457751 dec r8d                                                                                                           |         r8d--;
    0x00457754 mov rsi, qword [rsp]                                                                                              |         rsi = *(rsp);
    0x00457758 mov ecx, ebp                                                                                                      |         ecx = ebp;
    0x0045775a jmp 0x457807                                                                                                      |         goto label_47;
                                                                                                                                 | label_29:
    0x0045775f mov esi, 0x4af927                                                                                                 |         
    0x00457764 mov edx, 0x32                                                                                                     |         
    0x00457769 mov rdi, qword [rsp]                                                                                              |         
    0x0045776d call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "Error: No value has been provided for the option \", 0x32);
    0x00457772 mov rbx, rax                                                                                                      |         rbx = rax;
    0x00457775 mov rdi, r13                                                                                                      |         rdi = r13;
    0x00457778 jmp 0x4578e5                                                                                                      |         goto label_52;
                                                                                                                                 | label_32:
    0x0045777d mov esi, 0x4af95a                                                                                                 |         
    0x00457782 mov edx, 0x2f                                                                                                     |         
    0x00457787 mov rdi, qword [rsp]                                                                                              |         
    0x0045778b call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "Only one value can be provided for the option \", 0x2f);
    0x00457790 mov rbx, rax                                                                                                      |         rbx = rax;
    0x00457793 mov rdi, r13                                                                                                      |         
    0x00457796 call 0x4649d0                                                                                                     |         rax = BloombergLP::balcl::Option::tagString()const (r13);
    0x0045779b mov rdi, rbx                                                                                                      |         
    0x0045779e mov rsi, rax                                                                                                      |         
    0x004577a1 call 0x44f6f0                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&bsl::operator << <char,std::_1::char_traits<char>,bsl::allocator<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&) (rbx, rax);
    0x004577a6 mov esi, 0x4af8a3                                                                                                 |         
    0x004577ab mov edx, 2                                                                                                        |         
    0x004577b0 mov rdi, rax                                                                                                      |         
    0x004577b3 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, 0x4af8a3, 2);
    0x004577b8 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x004577bd lea rsi, [rsp + 0x18]                                                                                             |         
    0x004577c2 mov edx, 1                                                                                                        |         
    0x004577c7 mov rdi, rax                                                                                                      |         
    0x004577ca call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x004577cf mov rdi, rax                                                                                                      |         rdi = rax;
    0x004577d2 call 0x404980                                                                                                     |         std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x004577d7 mov rcx, qword [r15 + 0x68]                                                                                       |         rcx = *((r15 + 0x68));
    0x004577db mov rdx, qword [rsp + 0x50]                                                                                       |         rdx = *((rsp + 0x50));
    0x004577e0 lea rax, [rcx + rdx]                                                                                              |         rax = rcx + rdx;
    0x004577e4 cmp qword [rcx + rdx + 0x20], 0x17                                                                                |         
                                                                                                                                 |         if (*((rcx + rdx + 0x20)) != 0x17) {
    0x004577ea je 0x4577ef                                                                                                       |             
    0x004577ec mov rax, qword [rax]                                                                                              |             rax = *(rax);
                                                                                                                                 |         }
    0x004577ef mov rdx, qword [rsp + 8]                                                                                          |         
    0x004577f4 sub r14d, eax                                                                                                     |         r14d -= eax;
    0x004577f7 add r14d, 0xfffffffe                                                                                              |         r14d += 0xfffffffe;
    0x004577fb mov rsi, qword [rsp]                                                                                              |         
    0x004577ff mov ecx, 2                                                                                                        |         
    0x00457804 mov r8d, r14d                                                                                                     |         r8d = r14d;
                                                                                                                                 | label_47:
    0x00457807 call 0x457a20                                                                                                     |         BloombergLP::balcl::CommandLine::location(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,int,int,int)const (rdi, *(rsp), *((rsp + 8)), 2);
                                                                                                                                 | label_27:
    0x0045780c mov ebx, 0xffffffff                                                                                               |         ebx = 0xffffffff;
    0x00457811 jmp 0x457688                                                                                                      |         
                                                                                                                                 |     } while (1);
                                                                                                                                 | label_40:
    0x00457816 mov esi, 0x4af9ba                                                                                                 |     
    0x0045781b mov edx, 0x30                                                                                                     |     
    0x00457820 mov rdi, qword [rsp]                                                                                              |     
    0x00457824 call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "Only one value can be provided for the option \"-", 0x30);
    0x00457829 mov rbx, rax                                                                                                      |     rbx = rax;
    0x0045782c mov rdi, r12                                                                                                      |     
    0x0045782f call 0x4649d0                                                                                                     |     rax = BloombergLP::balcl::Option::tagString()const (r12);
    0x00457834 mov rdi, rbx                                                                                                      |     
    0x00457837 mov rsi, rax                                                                                                      |     
    0x0045783a call 0x44f6f0                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&bsl::operator << <char,std::_1::char_traits<char>,bsl::allocator<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&) (rbx, rax);
    0x0045783f mov esi, 0x4af8a3                                                                                                 |     
    0x00457844 mov edx, 2                                                                                                        |     
    0x00457849 mov rdi, rax                                                                                                      |     
    0x0045784c call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, 0x4af8a3, 2);
    0x00457851 mov byte [rsp + 0x18], 0xa                                                                                        |     *((rsp + 0x18)) = 0xa;
    0x00457856 lea rsi, [rsp + 0x18]                                                                                             |     
    0x0045785b mov edx, 1                                                                                                        |     
    0x00457860 mov rdi, rax                                                                                                      |     
    0x00457863 call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x00457868 mov rdi, rax                                                                                                      |     rdi = rax;
    0x0045786b call 0x404980                                                                                                     |     std::_1::basic_ostream<char,std::_1::char_traits<char>>::flush() ();
    0x00457870 movsxd rax, r14d                                                                                                  |     rax = (int64_t) r14d;
    0x00457873 mov rcx, qword [r15 + 0x68]                                                                                       |     rcx = *((r15 + 0x68));
    0x00457877 lea rdx, [rax + rax*2]                                                                                            |     rdx = rax * 3;
    0x0045787b shl rdx, 4                                                                                                        |     rdx <<= 4;
    0x0045787f lea rax, [rcx + rdx]                                                                                              |     rax = rcx + rdx;
    0x00457883 cmp qword [rcx + rdx + 0x20], 0x17                                                                                |     
                                                                                                                                 |     if (*((rcx + rdx + 0x20)) != 0x17) {
    0x00457889 je 0x45788e                                                                                                       |         
    0x0045788b mov rax, qword [rax]                                                                                              |         rax = *(rax);
                                                                                                                                 |     }
    0x0045788e sub ebp, eax                                                                                                      |     ebp -= eax;
    0x00457890 mov ebx, 0xffffffff                                                                                               |     ebx = 0xffffffff;
    0x00457895 mov rsi, qword [rsp]                                                                                              |     
    0x00457899 mov edx, r14d                                                                                                     |     
    0x0045789c mov ecx, ebp                                                                                                      |     
                                                                                                                                 | label_51:
    0x0045789e mov r8d, 0xffffffff                                                                                               |     r8d = 0xffffffff;
    0x004578a4 call 0x457a20                                                                                                     |     BloombergLP::balcl::CommandLine::location(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,int,int,int)const (rdi, *(rsp), r14d, ebp);
    0x004578a9 jmp 0x457688                                                                                                      |     goto label_5;
                                                                                                                                 | label_50:
    0x004578ae mov esi, 0x4afac2                                                                                                 |     
    0x004578b3 mov edx, 0x25                                                                                                     |     
    0x004578b8 mov rbp, qword [rsp]                                                                                              |     rbp = *(rsp);
    0x004578bc mov rdi, rbp                                                                                                      |     
    0x004578bf call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "The error occurred while parsing the ", 0x25);
    0x004578c4 mov rbx, rax                                                                                                      |     rbx = rax;
    0x004578c7 jmp 0x4572fb                                                                                                      |     goto label_6;
                                                                                                                                 | label_37:
    0x004578cc mov esi, 0x4af927                                                                                                 |     
    0x004578d1 mov edx, 0x32                                                                                                     |     
    0x004578d6 mov rdi, qword [rsp]                                                                                              |     
    0x004578da call 0x455480                                                                                                     |     rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), "Error: No value has been provided for the option \", 0x32);
    0x004578df mov rbx, rax                                                                                                      |     rbx = rax;
    0x004578e2 mov rdi, r12                                                                                                      |     
                                                                                                                                 | label_52:
    0x004578e5 call 0x4649d0                                                                                                     |     rax = BloombergLP::balcl::Option::tagString()const (r12);
    0x004578ea mov rdi, rbx                                                                                                      |     
                                                                                                                                 |     do {
    0x004578ed mov rsi, rax                                                                                                      |         
    0x004578f0 call 0x44f6f0                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&bsl::operator << <char,std::_1::char_traits<char>,bsl::allocator<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>const&) (rbx, rax);
    0x004578f5 mov esi, 0x4af8a3                                                                                                 |         
    0x004578fa mov edx, 2                                                                                                        |         
    0x004578ff mov rdi, rax                                                                                                      |         
    0x00457902 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, 0x4af8a3, 2);
    0x00457907 mov byte [rsp + 0x18], 0xa                                                                                        |         *((rsp + 0x18)) = 0xa;
    0x0045790c lea rsi, [rsp + 0x18]                                                                                             |         
    0x00457911 mov edx, 1                                                                                                        |         
    0x00457916 mov rdi, rax                                                                                                      |         
    0x00457919 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (rax, rsp + 0x18, 1);
    0x0045791e mov rdi, rax                                                                                                      |         rdi = rax;
    0x00457921 jmp 0x4573b3                                                                                                      |         goto label_7;
                                                                                                                                 | label_49:
    0x00457926 mov esi, 0x4afa29                                                                                                 |         
    0x0045792b mov edx, 0x22                                                                                                     |         
    0x00457930 mov rdi, qword [rsp]                                                                                              |         
    0x00457934 call 0x455480                                                                                                     |         rax = std::_1::basic_ostream<char,std::_1::char_traits<char>>&std::_1::_put_character_sequence<char,std::_1::char_traits<char>>(std::_1::basic_ostream<char,std::_1::char_traits<char>>&,char const*,unsigned long) (*(rsp), 0x4afa29, 0x22);
    0x00457939 mov rbp, rax                                                                                                      |         
    0x0045793c movsxd rax, r12d                                                                                                  |         rax = (int64_t) r12d;
    0x0045793f imul rdi, rax, 0x118                                                                                              |         rdi = rax * 0x118;
    0x00457946 add rdi, qword [r15]                                                                                              |         rdi += *(r15);
    0x00457949 call 0x4649d0                                                                                                     |         BloombergLP::balcl::Option::tagString()const (rdi);
    0x0045794e mov rdi, rbp                                                                                                      |         rdi = rbp;
    0x00457951 jmp 0x4578ed                                                                                                      |         
                                                                                                                                 |     } while (1);
                                                                                                                                 | }