; assembly | /* r2dec pseudo code output */ | /* balcl_commandline.t/none @ 0x45b1a0 */ | #include | ; (fcn) method.BloombergLP::balcl::CommandLine.printUsage_std::__1::basic_ostream_char__std::__1::char_traits_char_____const () | int64_t method_BloombergLP::balcl::CommandLine_printUsage_std::_1::basic_ostream_char_std::_1::char_traits_char_const (int64_t arg2, char * arg1) { | int32_t var_4h; | int64_t var_8h; | int64_t var_10h; | 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; | int64_t var_60h; | int64_t var_68h; | int64_t var_70h; | int64_t var_78h; | int64_t var_80h; | int64_t var_88h; | int64_t var_90h; | int64_t var_a8h; | uint32_t var_b0h; | int64_t var_b8h; | int64_t var_c0h; | int64_t var_c8h; | int64_t var_d0h; | int64_t var_d8h; | uint32_t var_e0h; | int64_t var_e8h; | int64_t var_108h; | int64_t var_120h; | uint32_t var_128h; | int64_t var_130h; | int64_t var_148h; | int64_t var_1d0h; | int64_t var_1d8h; | int64_t var_1e8h; | int64_t var_200h; | uint32_t var_208h; | int64_t var_210h; | int64_t var_218h; | int64_t var_230h; | uint32_t var_238h; | int64_t var_240h; | int64_t var_248h; | uint32_t var_268h; | int64_t var_270h; | int64_t var_278h; | int64_t var_290h; | uint32_t var_298h; | int64_t var_2a0h; | rsi = arg2; | rdi = arg1; | /* BloombergLP::balcl::CommandLine::printUsage(std::__1::basic_ostream >&) const */ 0x0045b1a0 push rbp | 0x0045b1a1 push r15 | 0x0045b1a3 push r14 | 0x0045b1a5 push r13 | 0x0045b1a7 push r12 | 0x0045b1a9 push rbx | 0x0045b1aa sub rsp, 0x2a8 | 0x0045b1b1 mov rbp, rsi | 0x0045b1b4 mov r14, rdi | r14 = rdi; 0x0045b1b7 mov rax, qword [rip + 0x2aaa6a] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b1be test rax, rax | | if (rax == 0) { 0x0045b1c1 jne 0x45b1c8 | 0x0045b1c3 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b1c8 mov qword [rsp + 0x278], 0 | *((rsp + 0x278)) = 0; 0x0045b1d4 mov qword [rsp + 0x2a0], rax | *((rsp + 0x2a0)) = rax; 0x0045b1dc movaps xmm0, xmmword [rip + 0x4922d] | xmm0 = .comment; 0x0045b1e3 movups xmmword [rsp + 0x290], xmm0 | __asm ("movups xmmword [rsp + 0x290], xmm0"); 0x0045b1eb lea rdi, [rsp + 0x278] | 0x0045b1f3 mov esi, 0x4afb1f | 0x0045b1f8 mov edx, 7 | 0x0045b1fd mov ecx, 0x4ae8f1 | 0x0045b202 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rsp + 0x278, "Usage: ", 7, "string<...>::assign(char*...): string too long"); 0x0045b207 mov rbx, qword [r14 + 0x68] | rbx = *((r14 + 0x68)); 0x0045b20b cmp qword [r14 + 0x70], rbx | | if (*((r14 + 0x70)) != rbx) { 0x0045b20f je 0x45b2de | 0x0045b215 mov rax, qword [rbx + 0x20] | rax = *((rbx + 0x20)); 0x0045b219 mov qword [rsp + 0xe0], rax | *((rsp + 0xe0)) = rax; 0x0045b221 movups xmm0, xmmword [rbx] | __asm ("movups xmm0, xmmword [rbx]"); 0x0045b224 movups xmm1, xmmword [rbx + 0x10] | __asm ("movups xmm1, xmmword [rbx + 0x10]"); 0x0045b228 movaps xmmword [rsp + 0xd0], xmm1 | *((rsp + 0xd0)) = xmm1; 0x0045b230 movaps xmmword [rsp + 0xc0], xmm0 | *((rsp + 0xc0)) = xmm0; 0x0045b238 mov rax, qword [rip + 0x2aa9e9] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b23f test rax, rax | | if (rax == 0) { 0x0045b242 jne 0x45b249 | 0x0045b244 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b249 mov qword [rsp + 0xe8], rax | *((rsp + 0xe8)) = rax; 0x0045b251 cmp qword [rsp + 0xe0], 0x17 | | if (*((rsp + 0xe0)) == 0x17) { 0x0045b25a je 0x45b32e | goto label_7; | } 0x0045b260 mov rcx, qword [rbx + 0x18] | rcx = *((rbx + 0x18)); 0x0045b264 cmp rcx, 0x17 | 0x0045b268 mov esi, 0x17 | esi = 0x17; | if (rcx > 0x17) { 0x0045b26d cmova rsi, rcx | rsi = rcx; | } 0x0045b271 mov qword [rsp + 0xc0], 0 | *((rsp + 0xc0)) = 0; 0x0045b27d mov qword [rsp + 0xd8], rcx | *((rsp + 0xd8)) = rcx; 0x0045b285 mov qword [rsp + 0xe0], rsi | *((rsp + 0xe0)) = rsi; 0x0045b28d cmp rcx, 0x18 | | if (rcx >= 0x18) { 0x0045b291 jb 0x45b2b2 | 0x0045b293 inc rsi | rsi++; 0x0045b296 mov rcx, qword [rax] | rcx = *(rax); 0x0045b299 mov rdi, rax | rdi = rax; 0x0045b29c call qword [rcx + 0x10] | rax = uint64_t (*rcx + 0x10)() (); 0x0045b29f mov qword [rsp + 0xc0], rax | *((rsp + 0xc0)) = rax; 0x0045b2a7 cmp qword [rsp + 0xe0], 0x17 | | if (*((rsp + 0xe0)) != 0x17) { 0x0045b2b0 jne 0x45b2ba | goto label_8; | } | } 0x0045b2b2 lea rax, [rsp + 0xc0] | rax = rsp + 0xc0; | label_8: 0x0045b2ba mov rdx, qword [rsp + 0xd8] | rdx = *((rsp + 0xd8)); 0x0045b2c2 inc rdx | rdx++; | if (rdx == 0) { 0x0045b2c5 je 0x45b32e | goto label_7; | } 0x0045b2c7 cmp qword [rbx + 0x20], 0x17 | | if (*((rbx + 0x20)) != 0x17) { 0x0045b2cc je 0x45b2d1 | 0x0045b2ce mov rbx, qword [rbx] | rbx = *(rbx); | } 0x0045b2d1 mov rdi, rax | 0x0045b2d4 mov rsi, rbx | 0x0045b2d7 call 0x404c70 | memcpy (rax, rbx, rdx); 0x0045b2dc jmp 0x45b32e | | } else { 0x0045b2de mov rax, qword [rip + 0x2aa943] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b2e5 test rax, rax | | if (rax == 0) { 0x0045b2e8 jne 0x45b2ef | 0x0045b2ea call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b2ef mov qword [rsp + 0xc0], 0 | *((rsp + 0xc0)) = 0; 0x0045b2fb mov qword [rsp + 0xe8], rax | *((rsp + 0xe8)) = rax; 0x0045b303 movaps xmm0, xmmword [rip + 0x49106] | xmm0 = .comment; 0x0045b30a movups xmmword [rsp + 0xd8], xmm0 | __asm ("movups xmmword [rsp + 0xd8], xmm0"); 0x0045b312 lea rdi, [rsp + 0xc0] | 0x0045b31a mov esi, 0x4ae851 | 0x0045b31f mov edx, 0xb | 0x0045b324 mov ecx, 0x4ae8f1 | 0x0045b329 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rsp + 0xc0, 0x4ae851, 0xb, "string<...>::assign(char*...): string too long"); | } | label_7: 0x0045b32e lea rdi, [rsp + 0x278] | 0x0045b336 lea rsi, [rsp + 0xc0] | 0x0045b33e xor edx, edx | 0x0045b340 mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045b347 call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (rsp + 0x278, rsp + 0xc0, 0); 0x0045b34c cmp qword [rsp + 0xe0], 0x17 | | if (*((rsp + 0xe0)) != 0x17) { 0x0045b355 je 0x45b36d | 0x0045b357 mov rsi, qword [rsp + 0xc0] | rsi = *((rsp + 0xc0)); 0x0045b35f mov rdi, qword [rsp + 0xe8] | rdi = *((rsp + 0xe8)); 0x0045b367 mov rax, qword [rdi] | rax = *(rdi); 0x0045b36a call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045b36d lea rdi, [rsp + 0x278] | 0x0045b375 mov esi, 1 | 0x0045b37a mov ecx, 0x4afdba | 0x0045b37f mov edx, 0x20 | 0x0045b384 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x278, 1, 0x20, "string<...>::append(n,c): string too long"); 0x0045b389 xorps xmm0, xmm0 | __asm ("xorps xmm0, xmm0"); 0x0045b38c movaps xmmword [rsp + 0x50], xmm0 | *((rsp + 0x50)) = xmm0; 0x0045b391 mov qword [rsp + 0x60], 0 | *((rsp + 0x60)) = 0; 0x0045b39a mov rax, qword [rip + 0x2aa887] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b3a1 test rax, rax | | if (rax == 0) { 0x0045b3a4 jne 0x45b3ab | 0x0045b3a6 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b3ab mov qword [rsp + 0x68], rax | *((rsp + 0x68)) = rax; 0x0045b3b0 xorps xmm0, xmm0 | __asm ("xorps xmm0, xmm0"); 0x0045b3b3 movaps xmmword [rsp + 0x70], xmm0 | *((rsp + 0x70)) = xmm0; 0x0045b3b8 mov qword [rsp + 0x80], 0 | *((rsp + 0x80)) = 0; 0x0045b3c4 mov rax, qword [rip + 0x2aa85d] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b3cb test rax, rax | 0x0045b3ce mov qword [rsp + 0x10], rbp | *((rsp + 0x10)) = rbp; | if (rax == 0) { 0x0045b3d3 jne 0x45b3da | 0x0045b3d5 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b3da mov qword [rsp + 0x88], rax | *((rsp + 0x88)) = rax; 0x0045b3e2 mov rdi, qword [r14] | rdi = *(r14); 0x0045b3e5 cmp qword [r14 + 8], rdi | | if (*((r14 + 8)) == rdi) { 0x0045b3e9 je 0x45b88c | goto label_9; | } 0x0045b3ef mov r13d, 1 | r13d = 1; 0x0045b3f5 xor eax, eax | eax = 0; 0x0045b3f7 jmp 0x45b42b | | while (al != 0) { | label_0: 0x0045b400 mov eax, r13d | eax = r13d; 0x0045b403 mov rdi, qword [r14] | rdi = *(r14); 0x0045b406 mov rcx, qword [r14 + 8] | rcx = *((r14 + 8)); 0x0045b40a sub rcx, rdi | rcx -= rdi; 0x0045b40d sar rcx, 3 | rcx >>= 3; 0x0045b411 movabs rdx, 0xaf8af8af8af8af8b | rdx = 0xaf8af8af8af8af8b; 0x0045b41b imul rcx, rdx | rcx *= rdx; 0x0045b41f inc r13d | r13d++; 0x0045b422 cmp rcx, rax | | if (rcx <= rax) { 0x0045b425 jbe 0x45b88c | goto label_9; | } 0x0045b42b imul rbp, rax, 0x118 | rbp = rax * 0x118; 0x0045b432 add rdi, rbp | rdi += rbp; 0x0045b435 call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (rdi); 0x0045b43a cmp eax, 2 | | if (eax >= 2) { 0x0045b43d jae 0x45b4a0 | goto label_10; | } 0x0045b43f mov rdi, qword [r14] | 0x0045b442 add rdi, rbp | rdi += rbp; 0x0045b445 call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045b44a mov rdi, rax | 0x0045b44d call 0x4627a0 | al = BloombergLP::balcl::OccurrenceInfo::isHidden()const (rax); 0x0045b452 test al, al | 0x0045b454 jne 0x45b400 | | } 0x0045b456 mov rdi, qword [r14] | 0x0045b459 add rdi, rbp | rdi += rbp; 0x0045b45c call 0x464950 | al = BloombergLP::balcl::Option::isArray()const (*(r14)); 0x0045b461 test al, al | | if (al != 0) { 0x0045b463 jne 0x45b511 | goto label_11; | } 0x0045b469 mov rdi, qword [r14] | 0x0045b46c add rdi, rbp | rdi += rbp; 0x0045b46f call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045b474 mov rdi, rax | 0x0045b477 call 0x4627b0 | al = BloombergLP::balcl::OccurrenceInfo::isRequired()const (rax); 0x0045b47c test al, al | | if (al == 0) { 0x0045b47e je 0x45b511 | goto label_11; | } 0x0045b484 mov al, 1 | al = 1; 0x0045b486 mov dword [rsp + 4], eax | *((rsp + 4)) = eax; 0x0045b48a xor r12d, r12d | r12d = 0; 0x0045b48d mov dword [rsp + 8], 0 | *((rsp + 8)) = 0; 0x0045b495 jmp 0x45b522 | goto label_12; | if (al != 0) { | label_10: 0x0045b4a0 jne 0x45b400 | goto label_0; | } 0x0045b4a6 mov rdi, qword [r14] | 0x0045b4a9 add rdi, rbp | rdi += rbp; 0x0045b4ac call 0x464950 | al = BloombergLP::balcl::Option::isArray()const (*(r14)); 0x0045b4b1 test al, al | | if (al == 0) { 0x0045b4b3 jne 0x45b4db | 0x0045b4b5 mov rdi, qword [r14] | 0x0045b4b8 add rdi, rbp | rdi += rbp; 0x0045b4bb call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045b4c0 mov rdi, rax | 0x0045b4c3 call 0x4627b0 | al = BloombergLP::balcl::OccurrenceInfo::isRequired()const (rax); 0x0045b4c8 test al, al | | if (al != 0) { 0x0045b4ca je 0x45b4db | 0x0045b4cc mov r12b, 1 | r12b = 1; 0x0045b4cf xor ebx, ebx | ebx = 0; 0x0045b4d1 mov dword [rsp + 4], 0 | *((rsp + 4)) = 0; 0x0045b4d9 jmp 0x45b4e6 | | } | } else { 0x0045b4db mov al, 0x5b | al = 0x5b; 0x0045b4dd mov dword [rsp + 4], eax | *((rsp + 4)) = eax; 0x0045b4e1 mov bl, 0x5d | bl = 0x5d; 0x0045b4e3 xor r12d, r12d | r12d = 0; | } 0x0045b4e6 mov rdi, qword [r14] | 0x0045b4e9 add rdi, rbp | rdi += rbp; 0x0045b4ec call 0x464950 | al = BloombergLP::balcl::Option::isArray()const (*(r14)); 0x0045b4f1 test al, al | | if (al != 0) { 0x0045b4f3 je 0x45b554 | 0x0045b4f5 mov rdi, qword [r14] | 0x0045b4f8 add rdi, rbp | rdi += rbp; 0x0045b4fb call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045b500 mov rdi, rax | 0x0045b503 call 0x4627b0 | eax = BloombergLP::balcl::OccurrenceInfo::isRequired()const (rax); 0x0045b508 mov r15d, eax | r15d = eax; 0x0045b50b or r15b, 0x2a | r15b |= 0x2a; 0x0045b50f jmp 0x45b557 | goto label_13; | label_11: 0x0045b511 mov al, 0x5b | al = 0x5b; 0x0045b513 mov dword [rsp + 8], eax | *((rsp + 8)) = eax; 0x0045b517 mov r12b, 0x5d | r12b = 0x5d; 0x0045b51a mov dword [rsp + 4], 0 | *((rsp + 4)) = 0; | label_12: 0x0045b522 mov rdi, qword [r14] | 0x0045b525 add rdi, rbp | rdi += rbp; 0x0045b528 call 0x464950 | al = BloombergLP::balcl::Option::isArray()const (*(r14)); 0x0045b52d test al, al | | if (al == 0) { 0x0045b52f je 0x45b68b | goto label_14; | } 0x0045b535 mov rdi, qword [r14] | 0x0045b538 add rdi, rbp | rdi += rbp; 0x0045b53b call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045b540 mov rdi, rax | 0x0045b543 call 0x4627b0 | eax = BloombergLP::balcl::OccurrenceInfo::isRequired()const (rax); 0x0045b548 mov r15d, eax | r15d = eax; 0x0045b54b or r15b, 0x2a | r15b |= 0x2a; 0x0045b54f jmp 0x45b68e | goto label_15; | } 0x0045b554 xor r15d, r15d | r15d = 0; | label_13: 0x0045b557 mov rax, qword [rip + 0x2aa6ca] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b55e test rax, rax | 0x0045b561 mov dword [rsp + 8], ebx | *((rsp + 8)) = ebx; | if (rax == 0) { 0x0045b565 jne 0x45b56c | 0x0045b567 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b56c mov qword [rsp + 0xc0], 0 | *((rsp + 0xc0)) = 0; 0x0045b578 mov qword [rsp + 0xe8], rax | *((rsp + 0xe8)) = rax; 0x0045b580 movaps xmm0, xmmword [rip + 0x48e89] | xmm0 = .comment; 0x0045b587 movups xmmword [rsp + 0xd8], xmm0 | __asm ("movups xmmword [rsp + 0xd8], xmm0"); 0x0045b58f mov esi, 0x4cd544 | 0x0045b594 mov ecx, 0x4ae8f1 | 0x0045b599 lea rbx, [rsp + 0xc0] | rbx = rsp + 0xc0; 0x0045b5a1 mov rdi, rbx | 0x0045b5a4 xor edx, edx | 0x0045b5a6 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rbx, 0x4cd544, 0, "string<...>::assign(char*...): string too long"); 0x0045b5ab lea rdi, [rsp + 0x70] | rdi = rsp + 0x70; 0x0045b5b0 mov rsi, rbx | rsi = rbx; 0x0045b5b3 call 0x453dc0 | bsl::vector,bsl::allocator>,bsl::allocator,bsl::allocator>>>::push_back(bsl::basic_string,bsl::allocator>&&) (); 0x0045b5b8 cmp qword [rsp + 0xe0], 0x17 | | if (*((rsp + 0xe0)) != 0x17) { 0x0045b5c1 je 0x45b5d9 | 0x0045b5c3 mov rsi, qword [rsp + 0xc0] | rsi = *((rsp + 0xc0)); 0x0045b5cb mov rdi, qword [rsp + 0xe8] | rdi = *((rsp + 0xe8)); 0x0045b5d3 mov rax, qword [rdi] | rax = *(rdi); 0x0045b5d6 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045b5d9 mov rbx, qword [rsp + 0x78] | rbx = *((rsp + 0x78)); 0x0045b5de add rbx, 0xffffffffffffffd0 | rbx += 0xffffffffffffffd0; 0x0045b5e2 test r12b, r12b | | if (r12b == 0) { 0x0045b5e5 jne 0x45b5fe | 0x0045b5e7 movzx edx, byte [rsp + 4] | edx = *((rsp + 4)); 0x0045b5ec mov esi, 1 | 0x0045b5f1 mov ecx, 0x4afdba | 0x0045b5f6 mov rdi, rbx | 0x0045b5f9 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rbx, 1, rdx, "string<...>::append(n,c): string too long"); | } 0x0045b5fe mov esi, 1 | 0x0045b603 mov ecx, 0x4afdba | 0x0045b608 mov rdi, rbx | 0x0045b60b mov edx, 0x3c | 0x0045b610 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rbx, 1, 0x3c, "string<...>::append(n,c): string too long"); 0x0045b615 add rbp, qword [r14] | rbp += *(r14); 0x0045b618 mov rdi, rbp | 0x0045b61b call 0x464990 | rax = BloombergLP::balcl::Option::name()const (rbp); 0x0045b620 mov rdi, rbx | 0x0045b623 mov rsi, rax | 0x0045b626 xor edx, edx | 0x0045b628 mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045b62f call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (rbx, rax, 0); 0x0045b634 mov esi, 1 | 0x0045b639 mov ecx, 0x4afdba | 0x0045b63e mov rdi, rbx | 0x0045b641 mov edx, 0x3e | 0x0045b646 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rbx, 1, 0x3e, "string<...>::append(n,c): string too long"); 0x0045b64b test r12b, r12b | | if (r12b == 0) { 0x0045b64e jne 0x45b667 | 0x0045b650 movzx edx, byte [rsp + 8] | edx = *((rsp + 8)); 0x0045b655 mov esi, 1 | 0x0045b65a mov ecx, 0x4afdba | 0x0045b65f mov rdi, rbx | 0x0045b662 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rbx, 1, rdx, "string<...>::append(n,c): string too long"); | } 0x0045b667 test r15b, r15b | | if (r15b == 0) { 0x0045b66a je 0x45b400 | goto label_0; | } 0x0045b670 movzx edx, r15b | edx = (int32_t) r15b; 0x0045b674 mov esi, 1 | 0x0045b679 mov ecx, 0x4afdba | 0x0045b67e mov rdi, rbx | 0x0045b681 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rbx, 1, rdx, "string<...>::append(n,c): string too long"); 0x0045b686 jmp 0x45b400 | goto label_0; | label_14: 0x0045b68b xor r15d, r15d | r15d = 0; | label_15: 0x0045b68e mov rax, qword [rip + 0x2aa593] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b695 test rax, rax | | if (rax == 0) { 0x0045b698 jne 0x45b69f | 0x0045b69a call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045b69f mov qword [rsp + 0xc0], 0 | *((rsp + 0xc0)) = 0; 0x0045b6ab mov qword [rsp + 0xe8], rax | *((rsp + 0xe8)) = rax; 0x0045b6b3 movaps xmm0, xmmword [rip + 0x48d56] | xmm0 = .comment; 0x0045b6ba movups xmmword [rsp + 0xd8], xmm0 | __asm ("movups xmmword [rsp + 0xd8], xmm0"); 0x0045b6c2 mov esi, 0x4cd544 | 0x0045b6c7 mov ecx, 0x4ae8f1 | 0x0045b6cc lea rbx, [rsp + 0xc0] | rbx = rsp + 0xc0; 0x0045b6d4 mov rdi, rbx | 0x0045b6d7 xor edx, edx | 0x0045b6d9 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rbx, 0x4cd544, 0, "string<...>::assign(char*...): string too long"); 0x0045b6de lea rdi, [rsp + 0x50] | rdi = rsp + 0x50; 0x0045b6e3 mov rsi, rbx | rsi = rbx; 0x0045b6e6 call 0x453dc0 | bsl::vector,bsl::allocator>,bsl::allocator,bsl::allocator>>>::push_back(bsl::basic_string,bsl::allocator>&&) (); 0x0045b6eb mov dword [rsp + 0x48], r12d | *((rsp + 0x48)) = r12d; 0x0045b6f0 cmp qword [rsp + 0xe0], 0x17 | | if (*((rsp + 0xe0)) != 0x17) { 0x0045b6f9 je 0x45b711 | 0x0045b6fb mov rsi, qword [rsp + 0xc0] | rsi = *((rsp + 0xc0)); 0x0045b703 mov rdi, qword [rsp + 0xe8] | rdi = *((rsp + 0xe8)); 0x0045b70b mov rax, qword [rdi] | rax = *(rdi); 0x0045b70e call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045b711 mov r12, qword [rsp + 0x58] | r12 = *((rsp + 0x58)); 0x0045b716 add r12, 0xffffffffffffffd0 | r12 += 0xffffffffffffffd0; 0x0045b71a cmp byte [rsp + 4], 0 | | if (*((rsp + 4)) == 0) { 0x0045b71f jne 0x45b738 | 0x0045b721 movzx edx, byte [rsp + 8] | edx = *((rsp + 8)); 0x0045b726 mov esi, 1 | 0x0045b72b mov ecx, 0x4afdba | 0x0045b730 mov rdi, r12 | 0x0045b733 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, rdx, "string<...>::append(n,c): string too long"); | } 0x0045b738 mov rdi, qword [r14] | 0x0045b73b add rdi, rbp | rdi += rbp; 0x0045b73e call 0x4649b0 | al = BloombergLP::balcl::Option::shortTag()const (*(r14)); 0x0045b743 test al, al | | if (al != 0) { 0x0045b745 je 0x45b797 | 0x0045b747 mov esi, 1 | 0x0045b74c mov ecx, 0x4afdba | 0x0045b751 mov rdi, r12 | 0x0045b754 mov edx, 0x2d | 0x0045b759 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, 0x2d, "string<...>::append(n,c): string too long"); 0x0045b75e mov rdi, qword [r14] | 0x0045b761 add rdi, rbp | rdi += rbp; 0x0045b764 call 0x4649b0 | al = BloombergLP::balcl::Option::shortTag()const (*(r14)); 0x0045b769 movsx edx, al | edx = (int32_t) al; 0x0045b76c mov esi, 1 | 0x0045b771 mov ecx, 0x4afdba | 0x0045b776 mov rdi, r12 | 0x0045b779 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, rdx, "string<...>::append(n,c): string too long"); 0x0045b77e mov esi, 1 | 0x0045b783 mov ecx, 0x4afdba | 0x0045b788 mov rdi, r12 | 0x0045b78b mov edx, 0x7c | 0x0045b790 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, 0x7c, "string<...>::append(n,c): string too long"); 0x0045b795 jmp 0x45b7ae | | } else { 0x0045b797 mov esi, 2 | 0x0045b79c mov ecx, 0x4afdba | 0x0045b7a1 mov rdi, r12 | 0x0045b7a4 mov edx, 0x2d | 0x0045b7a9 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 2, 0x2d, "string<...>::append(n,c): string too long"); | } 0x0045b7ae mov rdi, qword [r14] | 0x0045b7b1 add rdi, rbp | rdi += rbp; 0x0045b7b4 call 0x464970 | rax = BloombergLP::balcl::Option::longTag()const (*(r14)); 0x0045b7b9 mov rbx, rax | rbx = rax; 0x0045b7bc mov rdi, rax | 0x0045b7bf call 0x4046c0 | rax = strlen (rax); 0x0045b7c4 mov ecx, 0x4ae3c0 | 0x0045b7c9 mov rdi, r12 | 0x0045b7cc mov rsi, rbx | 0x0045b7cf mov rdx, rax | 0x0045b7d2 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r12, rbx, rax, "string<...>::append(char*...): string too long"); 0x0045b7d7 mov rdi, qword [r14] | 0x0045b7da add rdi, rbp | rdi += rbp; 0x0045b7dd call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (*(r14)); 0x0045b7e2 test eax, eax | | if (eax != 0) { 0x0045b7e4 je 0x45b84a | 0x0045b7e6 mov esi, 1 | 0x0045b7eb mov ecx, 0x4afdba | 0x0045b7f0 mov rdi, r12 | 0x0045b7f3 mov edx, 0x20 | 0x0045b7f8 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, 0x20, "string<...>::append(n,c): string too long"); 0x0045b7fd mov esi, 1 | 0x0045b802 mov ecx, 0x4afdba | 0x0045b807 mov rdi, r12 | 0x0045b80a mov edx, 0x3c | 0x0045b80f call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, 0x3c, "string<...>::append(n,c): string too long"); 0x0045b814 add rbp, qword [r14] | rbp += *(r14); 0x0045b817 mov rdi, rbp | 0x0045b81a call 0x464990 | rax = BloombergLP::balcl::Option::name()const (rbp); 0x0045b81f mov rdi, r12 | 0x0045b822 mov rsi, rax | 0x0045b825 xor edx, edx | 0x0045b827 mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045b82e call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (r12, rax, 0); 0x0045b833 mov esi, 1 | 0x0045b838 mov ecx, 0x4afdba | 0x0045b83d mov rdi, r12 | 0x0045b840 mov edx, 0x3e | 0x0045b845 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, 0x3e, "string<...>::append(n,c): string too long"); | } 0x0045b84a cmp byte [rsp + 4], 0 | | if (*((rsp + 4)) == 0) { 0x0045b84f jne 0x45b868 | 0x0045b851 movzx edx, byte [rsp + 0x48] | edx = *((rsp + 0x48)); 0x0045b856 mov esi, 1 | 0x0045b85b mov ecx, 0x4afdba | 0x0045b860 mov rdi, r12 | 0x0045b863 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, rdx, "string<...>::append(n,c): string too long"); | } 0x0045b868 test r15b, r15b | | if (r15b == 0) { 0x0045b86b je 0x45b400 | goto label_0; | } 0x0045b871 movzx edx, r15b | edx = (int32_t) r15b; 0x0045b875 mov esi, 1 | 0x0045b87a mov ecx, 0x4afdba | 0x0045b87f mov rdi, r12 | 0x0045b882 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r12, 1, rdx, "string<...>::append(n,c): string too long"); 0x0045b887 jmp 0x45b400 | goto label_0; | label_9: 0x0045b88c mov rsi, qword [rsp + 0x58] | rsi = *((rsp + 0x58)); 0x0045b891 mov rdx, qword [rsp + 0x70] | rdx = *((rsp + 0x70)); 0x0045b896 mov rcx, qword [rsp + 0x78] | rcx = *((rsp + 0x78)); 0x0045b89b lea rdi, [rsp + 0x50] | rdi = rsp + 0x50; 0x0045b8a0 lea r8, [rsp + 0xc0] | r8 = rsp + 0xc0; 0x0045b8a8 call 0x461980 | voidbsl::vector,bsl::allocator>,bsl::allocator,bsl::allocator>>>::privateInsert,bsl::allocator>*>(bsl::basic_string,bsl::allocator>const*,bsl::basic_string,bsl::allocator>*,bsl::basic_string,bsl::allocator>*,std::_1::forward_iterator_tagconst&) (); 0x0045b8ad mov byte [rsp + 0xc0], 0xa | *((rsp + 0xc0)) = 0xa; 0x0045b8b5 lea rsi, [rsp + 0xc0] | 0x0045b8bd mov edx, 1 | 0x0045b8c2 mov rbx, qword [rsp + 0x10] | rbx = *((rsp + 0x10)); 0x0045b8c7 mov rdi, rbx | 0x0045b8ca call 0x455480 | std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (*((rsp + 0x10)), rsp + 0xc0, 1); 0x0045b8cf lea rsi, [rsp + 0x278] | 0x0045b8d7 mov rdi, rbx | 0x0045b8da call 0x44f6f0 | std::_1::basic_ostream>&bsl::operator << ,bsl::allocator>(std::_1::basic_ostream>&,bsl::basic_string,bsl::allocator>const&) (rbx, rsp + 0x278); 0x0045b8df movsxd rcx, dword [rsp + 0x290] | rcx = *((rsp + 0x290)); 0x0045b8e7 lea rsi, [rsp + 0x50] | 0x0045b8ec mov rdi, rcx | 0x0045b8ef mov rdx, rbx | 0x0045b8f2 call 0x45d840 | BloombergLP::balcl::(anonymousnamespace)::u::format(unsigned long,unsigned long,bsl::vector,bsl::allocator>,bsl::allocator,bsl::allocator>>>const&,std::_1::basic_ostream>&,unsigned long) (rcx, rsp + 0x50, rbx, rcx); 0x0045b8f7 mov esi, 0x4afb27 | 0x0045b8fc mov edx, 8 | 0x0045b901 mov rdi, rbx | 0x0045b904 call 0x455480 | std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (rbx, "\nWhere:\n", 8); 0x0045b909 mov qword [rsp + 0x1e8], 0 | *((rsp + 0x1e8)) = 0; 0x0045b915 movaps xmm0, xmmword [rip + 0x48af4] | xmm0 = .comment; 0x0045b91c movups xmmword [rsp + 0x200], xmm0 | __asm ("movups xmmword [rsp + 0x200], xmm0"); 0x0045b924 mov rax, qword [rip + 0x2aa2fd] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045b92b test rax, rax | | if (rax != 0) { 0x0045b92e je 0x45b942 | 0x0045b930 lea rcx, [rsp + 0x1e8] | rcx = rsp + 0x1e8; 0x0045b938 mov qword [rsp + 0x210], rax | *((rsp + 0x210)) = rax; 0x0045b940 jmp 0x45b96c | | } else { 0x0045b942 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x0045b947 cmp qword [rsp + 0x208], 0x17 | 0x0045b950 mov qword [rsp + 0x210], rax | *((rsp + 0x210)) = rax; | if (*((rsp + 0x208)) != 0x17) { 0x0045b958 je 0x45b964 | 0x0045b95a mov rcx, qword [rsp + 0x1e8] | rcx = *((rsp + 0x1e8)); 0x0045b962 jmp 0x45b96c | | } else { 0x0045b964 lea rcx, [rsp + 0x1e8] | rcx = rsp + 0x1e8; | } | } 0x0045b96c mov byte [rcx], 0 | *(rcx) = 0; 0x0045b96f lea rdi, [rsp + 0x1e8] | 0x0045b977 mov esi, 2 | 0x0045b97c mov ecx, 0x4afdba | 0x0045b981 mov edx, 0x20 | 0x0045b986 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x1e8, 2, 0x20, "string<...>::append(n,c): string too long"); 0x0045b98b lea rdi, [rsp + 0x1e8] | 0x0045b993 mov esi, 1 | 0x0045b998 mov ecx, 0x4afdba | 0x0045b99d mov edx, 0x2d | 0x0045b9a2 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x1e8, 1, 0x2d, "string<...>::append(n,c): string too long"); 0x0045b9a7 lea rdi, [rsp + 0x1e8] | 0x0045b9af mov esi, 1 | 0x0045b9b4 mov ecx, 0x4afdba | 0x0045b9b9 mov edx, 0x58 | 0x0045b9be call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x1e8, 1, 0x58, "string<...>::append(n,c): string too long"); 0x0045b9c3 lea rdi, [rsp + 0x1e8] | 0x0045b9cb mov esi, 0x4afb30 | 0x0045b9d0 mov edx, 5 | 0x0045b9d5 mov ecx, 0x4ae3c0 | 0x0045b9da call 0x481e80 | eax = bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rsp + 0x1e8, " | --", 5, "string<...>::append(char*...): string too long"); 0x0045b9df mov rdi, qword [r14] | rdi = *(r14); 0x0045b9e2 cmp qword [r14 + 8], rdi | | if (*((r14 + 8)) == rdi) { 0x0045b9e6 je 0x45c45f | goto label_16; | } 0x0045b9ec mov r15, qword [rsp + 0x200] | r15 = *((rsp + 0x200)); 0x0045b9f4 xor eax, eax | eax = 0; 0x0045b9f6 mov ebp, 1 | 0x0045b9fb xor r13d, r13d | r13d = 0; 0x0045b9fe jmp 0x45ba37 | goto label_17; | label_1: 0x0045ba00 mov rdi, rax | 0x0045ba03 call 0x4046c0 | eax = strlen (rax); 0x0045ba08 cmp r13d, eax | 0x0045ba0b cmovl r13d, eax | r13d = eax; | while (eax == 2) { 0x0045ba0f mov eax, ebp | eax = ebp; 0x0045ba11 mov rdi, qword [r14] | rdi = *(r14); 0x0045ba14 mov rcx, qword [r14 + 8] | rcx = *((r14 + 8)); 0x0045ba18 mov rdx, rcx | rdx = *((r14 + 8)); 0x0045ba1b sub rdx, rdi | rdx -= rdi; 0x0045ba1e sar rdx, 3 | rdx >>= 3; 0x0045ba22 movabs rsi, 0xaf8af8af8af8af8b | rsi = 0xaf8af8af8af8af8b; 0x0045ba2c imul rdx, rsi | rdx *= rsi; 0x0045ba30 inc ebp | ebp++; 0x0045ba32 cmp rdx, rax | | if (rdx <= rax) { 0x0045ba35 jbe 0x45ba58 | goto label_18; | } | label_17: 0x0045ba37 imul rbx, rax, 0x118 | rbx = rax * 0x118; 0x0045ba3e add rdi, rbx | rdi += rbx; 0x0045ba41 call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (rdi); 0x0045ba46 cmp eax, 2 | 0x0045ba49 je 0x45ba0f | | } 0x0045ba4b add rbx, qword [r14] | rbx += *(r14); 0x0045ba4e mov rdi, rbx | 0x0045ba51 call 0x464970 | BloombergLP::balcl::Option::longTag()const (rbx); 0x0045ba56 jmp 0x45ba00 | goto label_1; | label_18: 0x0045ba58 cmp rcx, rdi | | if (rcx == rdi) { 0x0045ba5b je 0x45c45f | goto label_16; | } 0x0045ba61 mov eax, r13d | eax = r13d; 0x0045ba64 add r13d, r15d | r13d += r15d; 0x0045ba67 lea r15d, [rax + r15 + 2] | r15d = rax + r15 + 2; 0x0045ba6c xor eax, eax | eax = 0; 0x0045ba6e mov ebp, 1 | 0x0045ba73 xor r12d, r12d | r12d = 0; 0x0045ba76 jmp 0x45bab2 | goto label_19; | label_2: 0x0045ba80 mov eax, dword [rax + 0x18] | eax = *((rax + 0x18)); 0x0045ba83 cmp r12d, eax | 0x0045ba86 cmovl r12d, eax | r12d = eax; | while (eax == 0) { 0x0045ba8a mov eax, ebp | eax = ebp; 0x0045ba8c mov rdi, qword [r14] | rdi = *(r14); 0x0045ba8f mov rcx, qword [r14 + 8] | rcx = *((r14 + 8)); 0x0045ba93 mov rdx, rcx | rdx = *((r14 + 8)); 0x0045ba96 sub rdx, rdi | rdx -= rdi; 0x0045ba99 sar rdx, 3 | rdx >>= 3; 0x0045ba9d movabs rsi, 0xaf8af8af8af8af8b | rsi = 0xaf8af8af8af8af8b; 0x0045baa7 imul rdx, rsi | rdx *= rsi; 0x0045baab inc ebp | ebp++; 0x0045baad cmp rdx, rax | | if (rdx <= rax) { 0x0045bab0 jbe 0x45bad2 | goto label_20; | } | label_19: 0x0045bab2 imul rbx, rax, 0x118 | rbx = rax * 0x118; 0x0045bab9 add rdi, rbx | rdi += rbx; 0x0045babc call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (rdi); 0x0045bac1 test eax, eax | 0x0045bac3 je 0x45ba8a | | } 0x0045bac5 add rbx, qword [r14] | rbx += *(r14); 0x0045bac8 mov rdi, rbx | 0x0045bacb call 0x464990 | BloombergLP::balcl::Option::name()const (rbx); 0x0045bad0 jmp 0x45ba80 | goto label_2; | label_20: 0x0045bad2 cmp rcx, rdi | | if (rcx == rdi) { 0x0045bad5 je 0x45c45f | goto label_16; | } 0x0045badb lea eax, [r13 + r12 + 3] | eax = r13 + r12 + 3; 0x0045bae0 mov dword [rsp + 4], eax | *((rsp + 4)) = eax; 0x0045bae4 lea eax, [r13 + r12 + 6] | eax = r13 + r12 + 6; 0x0045bae9 movsxd rcx, r15d | rcx = (int64_t) r15d; 0x0045baec mov qword [rsp + 0x48], rcx | *((rsp + 0x48)) = rcx; 0x0045baf1 cdqe | rax = (int64_t) eax; 0x0045baf3 mov qword [rsp + 8], rax | *((rsp + 8)) = rax; 0x0045baf8 mov r12d, 1 | r12d = 1; 0x0045bafe xor eax, eax | eax = 0; 0x0045bb00 lea r13, [rsp + 0x18] | r13 = rsp + 0x18; 0x0045bb05 jmp 0x45bb3e | | while (eax == 2) { | label_3: 0x0045bb10 mov eax, r12d | eax = r12d; 0x0045bb13 mov rdi, qword [r14] | rdi = *(r14); 0x0045bb16 mov rcx, qword [r14 + 8] | rcx = *((r14 + 8)); 0x0045bb1a mov rdx, rcx | rdx = *((r14 + 8)); 0x0045bb1d sub rdx, rdi | rdx -= rdi; 0x0045bb20 sar rdx, 3 | rdx >>= 3; 0x0045bb24 movabs rsi, 0xaf8af8af8af8af8b | rsi = 0xaf8af8af8af8af8b; 0x0045bb2e imul rdx, rsi | rdx *= rsi; 0x0045bb32 inc r12d | r12d++; 0x0045bb35 cmp rdx, rax | | if (rdx <= rax) { 0x0045bb38 jbe 0x45c012 | goto label_21; | } 0x0045bb3e imul rbp, rax, 0x118 | rbp = rax * 0x118; 0x0045bb45 add rdi, rbp | rdi += rbp; 0x0045bb48 call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (rdi); 0x0045bb4d cmp eax, 2 | 0x0045bb50 je 0x45bb10 | | } 0x0045bb52 mov rdi, qword [r14] | 0x0045bb55 add rdi, rbp | rdi += rbp; 0x0045bb58 call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045bb5d mov rdi, rax | 0x0045bb60 call 0x4627a0 | al = BloombergLP::balcl::OccurrenceInfo::isHidden()const (rax); 0x0045bb65 test al, al | | if (al != 0) { 0x0045bb67 jne 0x45bb10 | goto label_3; | } 0x0045bb69 mov qword [rsp + 0x18], 0 | *((rsp + 0x18)) = 0; 0x0045bb72 movaps xmm0, xmmword [rip + 0x48897] | xmm0 = .comment; 0x0045bb79 movups xmmword [rsp + 0x30], xmm0 | __asm ("movups xmmword [rsp + 0x30], xmm0"); 0x0045bb7e mov rax, qword [rip + 0x2aa0a3] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045bb85 test rax, rax | | if (rax != 0) { 0x0045bb88 je 0x45bb94 | 0x0045bb8a mov qword [rsp + 0x40], rax | *((rsp + 0x40)) = rax; 0x0045bb8f mov rcx, r13 | rcx = r13; 0x0045bb92 jmp 0x45bbb0 | | } else { 0x0045bb94 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x0045bb99 cmp qword [rsp + 0x38], 0x17 | 0x0045bb9f mov qword [rsp + 0x40], rax | *((rsp + 0x40)) = rax; 0x0045bba4 mov rcx, r13 | rcx = r13; | if (*((rsp + 0x38)) == 0x17) { 0x0045bba7 je 0x45bbb0 | goto label_22; | } 0x0045bba9 mov rcx, qword [rsp + 0x18] | rcx = *((rsp + 0x18)); 0x0045bbae nop | | } | label_22: 0x0045bbb0 mov byte [rcx], 0 | *(rcx) = 0; 0x0045bbb3 mov esi, 2 | 0x0045bbb8 mov ecx, 0x4afdba | 0x0045bbbd mov rdi, r13 | 0x0045bbc0 mov edx, 0x20 | 0x0045bbc5 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, 2, 0x20, "string<...>::append(n,c): string too long"); 0x0045bbca mov rdi, qword [r14] | 0x0045bbcd add rdi, rbp | rdi += rbp; 0x0045bbd0 call 0x4649b0 | al = BloombergLP::balcl::Option::shortTag()const (*(r14)); 0x0045bbd5 test al, al | | if (al != 0) { 0x0045bbd7 je 0x45bc29 | 0x0045bbd9 mov esi, 1 | 0x0045bbde mov ecx, 0x4afdba | 0x0045bbe3 mov rdi, r13 | 0x0045bbe6 mov edx, 0x2d | 0x0045bbeb call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, 1, 0x2d, "string<...>::append(n,c): string too long"); 0x0045bbf0 mov rdi, qword [r14] | 0x0045bbf3 add rdi, rbp | rdi += rbp; 0x0045bbf6 call 0x4649b0 | al = BloombergLP::balcl::Option::shortTag()const (*(r14)); 0x0045bbfb movsx edx, al | edx = (int32_t) al; 0x0045bbfe mov esi, 1 | 0x0045bc03 mov ecx, 0x4afdba | 0x0045bc08 mov rdi, r13 | 0x0045bc0b call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, 1, rdx, "string<...>::append(n,c): string too long"); 0x0045bc10 mov esi, 0x4afb30 | 0x0045bc15 mov edx, 5 | 0x0045bc1a mov ecx, 0x4ae3c0 | 0x0045bc1f mov rdi, r13 | 0x0045bc22 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r13, " | --", 5, "string<...>::append(char*...): string too long"); 0x0045bc27 jmp 0x45bc40 | | } else { 0x0045bc29 mov esi, 0x4afb36 | 0x0045bc2e mov edx, 7 | 0x0045bc33 mov ecx, 0x4ae3c0 | 0x0045bc38 mov rdi, r13 | 0x0045bc3b call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r13, " --", 7, "string<...>::append(char*...): string too long"); | } 0x0045bc40 mov rdi, qword [r14] | 0x0045bc43 add rdi, rbp | rdi += rbp; 0x0045bc46 call 0x464970 | rax = BloombergLP::balcl::Option::longTag()const (*(r14)); 0x0045bc4b mov rbx, rax | rbx = rax; 0x0045bc4e mov rdi, rax | 0x0045bc51 call 0x4046c0 | rax = strlen (rax); 0x0045bc56 mov ecx, 0x4ae3c0 | 0x0045bc5b mov rdi, r13 | 0x0045bc5e mov rsi, rbx | 0x0045bc61 mov rdx, rax | 0x0045bc64 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r13, rbx, rax, "string<...>::append(char*...): string too long"); 0x0045bc69 mov rdi, qword [r14] | 0x0045bc6c add rdi, rbp | rdi += rbp; 0x0045bc6f call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (*(r14)); 0x0045bc74 cmp eax, 1 | | if (eax == 1) { 0x0045bc77 jne 0x45bce5 | 0x0045bc79 mov rsi, qword [rsp + 0x48] | 0x0045bc7e sub rsi, qword [rsp + 0x30] | rsi -= *((rsp + 0x30)); 0x0045bc83 mov ecx, 0x4afdba | 0x0045bc88 mov rdi, r13 | 0x0045bc8b mov edx, 0x20 | 0x0045bc90 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, *((rsp + 0x48)), 0x20, "string<...>::append(n,c): string too long"); 0x0045bc95 mov esi, 1 | 0x0045bc9a mov ecx, 0x4afdba | 0x0045bc9f mov rdi, r13 | 0x0045bca2 mov edx, 0x3c | 0x0045bca7 call 0x482050 | rax = bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, 1, 0x3c, "string<...>::append(n,c): string too long"); 0x0045bcac mov rbx, rax | rbx = rax; 0x0045bcaf mov rdi, qword [r14] | 0x0045bcb2 add rdi, rbp | rdi += rbp; 0x0045bcb5 call 0x464990 | rax = BloombergLP::balcl::Option::name()const (*(r14)); 0x0045bcba mov rdi, rbx | 0x0045bcbd mov rsi, rax | 0x0045bcc0 xor edx, edx | 0x0045bcc2 mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045bcc9 call 0x483a00 | rax = bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (rbx, rax, 0); 0x0045bcce mov esi, 1 | 0x0045bcd3 mov ecx, 0x4afdba | 0x0045bcd8 mov rdi, rax | 0x0045bcdb mov edx, 0x3e | 0x0045bce0 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rax, 1, 0x3e, "string<...>::append(n,c): string too long"); | } 0x0045bce5 cmp dword [rsp + 4], 0x1c | | if (*((rsp + 4)) >= 0x1c) { 0x0045bcea jl 0x45bd05 | 0x0045bcec mov esi, 0x4afdb8 | 0x0045bcf1 mov edx, 1 | 0x0045bcf6 mov ecx, 0x4ae3c0 | 0x0045bcfb mov rdi, r13 | 0x0045bcfe call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r13, 0x4afdb8, 1, "string<...>::append(char*...): string too long"); 0x0045bd03 jmp 0x45bd21 | | } else { 0x0045bd05 mov rsi, qword [rsp + 8] | 0x0045bd0a sub rsi, qword [rsp + 0x30] | rsi -= *((rsp + 0x30)); 0x0045bd0f mov ecx, 0x4afdba | 0x0045bd14 mov rdi, r13 | 0x0045bd17 mov edx, 0x20 | 0x0045bd1c call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (r13, *((rsp + 8)), 0x20, "string<...>::append(n,c): string too long"); | } 0x0045bd21 mov rdi, qword [rsp + 0x10] | 0x0045bd26 mov rsi, r13 | 0x0045bd29 call 0x44f6f0 | std::_1::basic_ostream>&bsl::operator << ,bsl::allocator>(std::_1::basic_ostream>&,bsl::basic_string,bsl::allocator>const&) (*((rsp + 0x10)), r13); 0x0045bd2e mov rdi, qword [r14] | 0x0045bd31 add rdi, rbp | rdi += rbp; 0x0045bd34 call 0x464940 | rax = BloombergLP::balcl::Option::description()const (*(r14)); 0x0045bd39 cmp r13, rax | | if (r13 != rax) { 0x0045bd3c je 0x45bd6a | 0x0045bd3e cmp qword [rax + 0x20], 0x17 | 0x0045bd43 mov rsi, rax | rsi = rax; | if (*((rax + 0x20)) != 0x17) { 0x0045bd46 je 0x45bd4b | 0x0045bd48 mov rsi, qword [rax] | | } 0x0045bd4b mov rdx, qword [rax + 0x18] | 0x0045bd4f mov rbx, qword [rsp + 0x30] | rbx = *((rsp + 0x30)); 0x0045bd54 mov qword [rsp + 0x30], 0 | *((rsp + 0x30)) = 0; 0x0045bd5d mov ecx, 0x4ae7f9 | 0x0045bd62 mov rdi, r13 | 0x0045bd65 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (r13, *(rax), *((rax + 0x18)), "string<...>::operator=(const string&...): string too long"); | } 0x0045bd6a mov rdi, qword [r14] | 0x0045bd6d add rdi, rbp | rdi += rbp; 0x0045bd70 call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (*(r14)); 0x0045bd75 cmp eax, 1 | | if (eax == 1) { 0x0045bd78 jne 0x45bf98 | 0x0045bd7e mov rdi, qword [r14] | 0x0045bd81 add rdi, rbp | rdi += rbp; 0x0045bd84 call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045bd89 mov rdi, rax | 0x0045bd8c call 0x462790 | al = BloombergLP::balcl::OccurrenceInfo::hasDefaultValue()const (rax); 0x0045bd91 test al, al | | if (al == 0) { 0x0045bd93 je 0x45bf98 | goto label_23; | } 0x0045bd99 mov rax, qword [rip + 0x2a9e88] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045bda0 test rax, rax | | if (rax == 0) { 0x0045bda3 jne 0x45bdaa | 0x0045bda5 call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045bdaa mov qword [rsp + 0x90], rax | *((rsp + 0x90)) = rax; 0x0045bdb2 mov qword [rsp + 0x148], 0x6fac10 | *((rsp + 0x148)) = 0x6fac10; 0x0045bdbe lea rbx, [rsp + 0xc8] | rbx = rsp + 0xc8; 0x0045bdc6 mov rdi, rbx | 0x0045bdc9 mov esi, 0x10 | 0x0045bdce lea rdx, [rsp + 0x90] | 0x0045bdd6 call 0x455390 | bsl::basic_stringbuf,bsl::allocator>::basic_stringbuf(unsignedint,bsl::allocatorconst&) (rbx, 0x10, rsp + 0x90); 0x0045bddb mov qword [rsp + 0xc0], 0x4aea90 | *((rsp + 0xc0)) = sym.imp.std::__1::basic_ostream_char__std::__1::char_traits_char___::basic_ostream__; 0x0045bde7 mov qword [rsp + 0x148], 0x4aeab8 | *((rsp + sym.imp.virtual_thunk_to_std::__1::basic_ostream_char__std::__1::char_traits_char___::basic_ostream__)) = 0x4aeab8; 0x0045bdf3 lea rdi, [rsp + 0x148] | rdi = rsp + 0x148; 0x0045bdfb mov rsi, rbx | rsi = rbx; 0x0045bdfe call 0x404640 | std::_1::ios_base::init(void*) (); 0x0045be03 mov qword [rsp + 0x1d0], 0 | *((rsp + 0x1d0)) = 0; 0x0045be0f mov dword [rsp + 0x1d8], 0xffffffff | *((rsp + 0x1d8)) = 0xffffffff; 0x0045be1a mov qword [rsp + 0xc0], 0x4aea20 | *((rsp + 0xc0)) = vtable.bsl::basic_ostringstream_char__std::__1::char_traits_char___bsl::allocator_char___.0; 0x0045be26 mov qword [rsp + 0x148], 0x4aea48 | *((rsp + method.virtual_thunk_to_bsl::basic_ostringstream_char__std::__1::char_traits_char___bsl::allocator_char___.basic_ostringstream__)) = 0x4aea48; 0x0045be32 add rbp, qword [r14] | rbp += *(r14); 0x0045be35 mov rdi, rbp | 0x0045be38 call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (rbp); 0x0045be3d mov rdi, rax | 0x0045be40 call 0x462780 | rax = BloombergLP::balcl::OccurrenceInfo::defaultValue()const (rax); 0x0045be45 mov rdi, rax | 0x0045be48 lea rsi, [rsp + 0xc0] | 0x0045be50 xor edx, edx | 0x0045be52 mov ecx, 0xffffffff | 0x0045be57 call 0x465860 | BloombergLP::balcl::OptionValue::print(std::_1::basic_ostream>&,int,int)const (rax, rsp + 0xc0, 0, 0xffffffff); 0x0045be5c lea r15, [rsp + 0x248] | r15 = rsp + 0x248; 0x0045be64 mov rdi, r15 | 0x0045be67 lea rsi, [rsp + 0xc8] | 0x0045be6f call 0x455ee0 | bsl::basic_stringbuf,bsl::allocator>::str()const (r15, rsp + 0xc8); 0x0045be74 lea rbp, [rsp + 0x90] | rbp = rsp + 0x90; 0x0045be7c mov esi, 0x4afb3e | 0x0045be81 lea rbx, [rsp + 0x218] | rbx = rsp + 0x218; 0x0045be89 mov rdi, rbx | 0x0045be8c mov rdx, r15 | 0x0045be8f call 0x45e940 | bsl::basic_string,bsl::allocator>bsl::operator+,bsl::allocator>(char const*,bsl::basic_string,bsl::allocator>const&) (rbx, " (default: ", r15); 0x0045be94 mov rdi, rbp | 0x0045be97 mov rsi, rbx | 0x0045be9a mov edx, 0x29 | 0x0045be9f call 0x454a80 | bsl::basic_string,bsl::allocator>bsl::operator+,bsl::allocator>(bsl::basic_string,bsl::allocator>const&,char) (rbp, rbx, 0x29); 0x0045bea4 mov rdi, r13 | 0x0045bea7 mov rsi, rbp | 0x0045beaa xor edx, edx | 0x0045beac mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045beb3 call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (r13, rbp, 0); 0x0045beb8 cmp qword [rsp + 0xb0], 0x17 | | if (*((rsp + 0xb0)) != 0x17) { 0x0045bec1 je 0x45bed9 | 0x0045bec3 mov rsi, qword [rsp + 0x90] | rsi = *((rsp + 0x90)); 0x0045becb mov rdi, qword [rsp + 0xb8] | rdi = *((rsp + 0xb8)); 0x0045bed3 mov rax, qword [rdi] | rax = *(rdi); 0x0045bed6 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045bed9 mov qword [rsp + 0xa8], 0xffffffffffffffff | *((rsp + 0xa8)) = 0xffffffffffffffff; 0x0045bee5 cmp qword [rsp + 0x238], 0x17 | | if (*((rsp + 0x238)) != 0x17) { 0x0045beee je 0x45bf06 | 0x0045bef0 mov rsi, qword [rsp + 0x218] | rsi = *((rsp + 0x218)); 0x0045bef8 mov rdi, qword [rsp + 0x240] | rdi = *((rsp + 0x240)); 0x0045bf00 mov rax, qword [rdi] | rax = *(rdi); 0x0045bf03 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045bf06 mov qword [rsp + 0x230], 0xffffffffffffffff | *((rsp + 0x230)) = 0xffffffffffffffff; 0x0045bf12 cmp qword [rsp + 0x268], 0x17 | | if (*((rsp + 0x268)) != 0x17) { 0x0045bf1b je 0x45bf33 | 0x0045bf1d mov rsi, qword [rsp + 0x248] | rsi = *((rsp + 0x248)); 0x0045bf25 mov rdi, qword [rsp + 0x270] | rdi = *((rsp + 0x270)); 0x0045bf2d mov rax, qword [rdi] | rax = *(rdi); 0x0045bf30 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045bf33 mov esi, 0x4aea60 | esi = 0x4aea60; 0x0045bf38 lea rdi, [rsp + 0xc0] | rdi = rsp + 0xc0; 0x0045bf40 call 0x404b70 | std::_1::basic_ostream>::~basic_ostream() (); 0x0045bf45 mov qword [rsp + 0xc8], 0x4aebb0 | *((rsp + 0xc8)) = vtable.bsl::basic_stringbuf_char__std::__1::char_traits_char___bsl::allocator_char___.0; 0x0045bf51 cmp qword [rsp + 0x128], 0x17 | | if (*((rsp + 0x128)) != 0x17) { 0x0045bf5a je 0x45bf72 | 0x0045bf5c mov rsi, qword [rsp + 0x108] | rsi = *((rsp + 0x108)); 0x0045bf64 mov rdi, qword [rsp + 0x130] | rdi = *((rsp + 0x130)); 0x0045bf6c mov rax, qword [rdi] | rax = *(rdi); 0x0045bf6f call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045bf72 mov qword [rsp + 0x120], 0xffffffffffffffff | *((rsp + 0x120)) = 0xffffffffffffffff; 0x0045bf7e lea rdi, [rsp + 0xc8] | rdi = rsp + 0xc8; 0x0045bf86 call 0x404560 | std::_1::basic_streambuf>::~basic_streambuf() (); 0x0045bf8b lea rdi, [rsp + 0x148] | rdi = rsp + 0x148; 0x0045bf93 call 0x404490 | std::_1::basic_ios>::~basic_ios() (); | } | label_23: 0x0045bf98 cmp dword [rsp + 4], 0x1c | | if (*((rsp + 4)) >= 0x1c) { 0x0045bf9d jl 0x45bfb5 | 0x0045bf9f mov edi, 0xa | 0x0045bfa4 mov rsi, r13 | 0x0045bfa7 mov rdx, qword [rsp + 0x10] | 0x0045bfac xor ecx, ecx | 0x0045bfae call 0x45dad0 | BloombergLP::balcl::(anonymousnamespace)::u::format(unsigned long,unsigned long,bsl::basic_string,bsl::allocator>&,std::_1::basic_ostream>&,unsigned long) (0xa, r13, *((rsp + 0x10)), 0); 0x0045bfb3 jmp 0x45bfca | | } else { 0x0045bfb5 mov rcx, qword [rsp + 8] | rcx = *((rsp + 8)); 0x0045bfba mov rdi, rcx | 0x0045bfbd mov rsi, r13 | 0x0045bfc0 mov rdx, qword [rsp + 0x10] | 0x0045bfc5 call 0x45dad0 | BloombergLP::balcl::(anonymousnamespace)::u::format(unsigned long,unsigned long,bsl::basic_string,bsl::allocator>&,std::_1::basic_ostream>&,unsigned long) (*((rsp + 8)), r13, *((rsp + 0x10)), *(rcx)); | } 0x0045bfca mov byte [rsp + 0xc0], 0xa | *((rsp + 0xc0)) = 0xa; 0x0045bfd2 mov edx, 1 | 0x0045bfd7 mov rdi, qword [rsp + 0x10] | 0x0045bfdc lea rsi, [rsp + 0xc0] | 0x0045bfe4 call 0x455480 | rax = std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (*((rsp + 0x10)), rsp + 0xc0, 1); 0x0045bfe9 mov rdi, rax | rdi = rax; 0x0045bfec call 0x404980 | std::_1::basic_ostream>::flush() (); 0x0045bff1 cmp qword [rsp + 0x38], 0x17 | | if (*((rsp + 0x38)) == 0x17) { 0x0045bff7 je 0x45bb10 | goto label_3; | } 0x0045bffd mov rsi, qword [rsp + 0x18] | rsi = *((rsp + 0x18)); 0x0045c002 mov rdi, qword [rsp + 0x40] | rdi = *((rsp + 0x40)); 0x0045c007 mov rax, qword [rdi] | rax = *(rdi); 0x0045c00a call qword [rax + 0x18] | eax = uint64_t (*rax + 0x18)() (); 0x0045c00d jmp 0x45bb10 | goto label_3; | label_21: 0x0045c012 cmp rcx, rdi | | if (rcx == rdi) { 0x0045c015 je 0x45c45f | goto label_16; | } 0x0045c01b mov ebx, 1 | ebx = 1; 0x0045c020 xor eax, eax | eax = 0; 0x0045c022 jmp 0x45c059 | | while (eax != 2) { | label_4: 0x0045c030 mov eax, ebx | eax = ebx; 0x0045c032 mov rdi, qword [r14] | rdi = *(r14); 0x0045c035 mov rcx, qword [r14 + 8] | rcx = *((r14 + 8)); 0x0045c039 sub rcx, rdi | rcx -= rdi; 0x0045c03c sar rcx, 3 | rcx >>= 3; 0x0045c040 movabs rdx, 0xaf8af8af8af8af8b | rdx = 0xaf8af8af8af8af8b; 0x0045c04a imul rcx, rdx | rcx *= rdx; 0x0045c04e inc ebx | ebx++; 0x0045c050 cmp rcx, rax | | if (rcx <= rax) { 0x0045c053 jbe 0x45c45f | goto label_16; | } 0x0045c059 imul rbp, rax, 0x118 | rbp = rax * 0x118; 0x0045c060 add rdi, rbp | rdi += rbp; 0x0045c063 call 0x464910 | eax = BloombergLP::balcl::Option::argType()const (rdi); 0x0045c068 cmp eax, 2 | 0x0045c06b jne 0x45c030 | | } 0x0045c06d mov qword [rsp + 0x18], 0 | *((rsp + 0x18)) = 0; 0x0045c076 movaps xmm0, xmmword [rip + 0x48393] | xmm0 = .comment; 0x0045c07d movups xmmword [rsp + 0x30], xmm0 | __asm ("movups xmmword [rsp + 0x30], xmm0"); 0x0045c082 mov rax, qword [rip + 0x2a9b9f] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045c089 test rax, rax | | if (rax != 0) { 0x0045c08c je 0x45c09d | 0x0045c08e mov qword [rsp + 0x40], rax | *((rsp + 0x40)) = rax; 0x0045c093 lea rdi, [rsp + 0x18] | rdi = rsp + 0x18; 0x0045c098 mov rcx, rdi | rcx = rdi; 0x0045c09b jmp 0x45c0be | | } else { 0x0045c09d call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); 0x0045c0a2 cmp qword [rsp + 0x38], 0x17 | 0x0045c0a8 mov qword [rsp + 0x40], rax | *((rsp + 0x40)) = rax; 0x0045c0ad lea rcx, [rsp + 0x18] | rcx = rsp + 0x18; | if (*((rsp + 0x38)) != 0x17) { 0x0045c0b2 je 0x45c0b9 | 0x0045c0b4 mov rcx, qword [rsp + 0x18] | rcx = *((rsp + 0x18)); | } 0x0045c0b9 lea rdi, [rsp + 0x18] | | } 0x0045c0be mov byte [rcx], 0 | *(rcx) = 0; 0x0045c0c1 mov ecx, 0x4afdba | 0x0045c0c6 mov rsi, qword [rsp + 0x48] | 0x0045c0cb mov edx, 0x20 | 0x0045c0d0 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x18, *((rsp + 0x48)), 0x20, "string<...>::append(n,c): string too long"); 0x0045c0d5 mov esi, 1 | 0x0045c0da mov ecx, 0x4afdba | 0x0045c0df lea rdi, [rsp + 0x18] | 0x0045c0e4 mov edx, 0x3c | 0x0045c0e9 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x18, 1, 0x3c, "string<...>::append(n,c): string too long"); 0x0045c0ee mov rdi, qword [r14] | 0x0045c0f1 add rdi, rbp | rdi += rbp; 0x0045c0f4 call 0x464990 | rax = BloombergLP::balcl::Option::name()const (*(r14)); 0x0045c0f9 lea rdi, [rsp + 0x18] | 0x0045c0fe mov rsi, rax | 0x0045c101 xor edx, edx | 0x0045c103 mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045c10a call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (rsp + 0x18, rax, 0); 0x0045c10f mov esi, 1 | 0x0045c114 mov ecx, 0x4afdba | 0x0045c119 lea rdi, [rsp + 0x18] | 0x0045c11e mov edx, 0x3e | 0x0045c123 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x18, 1, 0x3e, "string<...>::append(n,c): string too long"); 0x0045c128 cmp dword [rsp + 4], 0x1c | | if (*((rsp + 4)) >= 0x1c) { 0x0045c12d jl 0x45c150 | 0x0045c12f mov esi, 0x4afdb8 | 0x0045c134 mov edx, 1 | 0x0045c139 mov ecx, 0x4ae3c0 | 0x0045c13e lea rdi, [rsp + 0x18] | 0x0045c143 call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rsp + 0x18, 0x4afdb8, 1, "string<...>::append(char*...): string too long"); 0x0045c148 jmp 0x45c16e | | } else { 0x0045c150 mov rsi, qword [rsp + 8] | 0x0045c155 sub rsi, qword [rsp + 0x30] | rsi -= *((rsp + 0x30)); 0x0045c15a mov ecx, 0x4afdba | 0x0045c15f lea rdi, [rsp + 0x18] | 0x0045c164 mov edx, 0x20 | 0x0045c169 call 0x482050 | bsl::basic_string,bsl::allocator>::privateAppend(unsigned long,char,char const*) (rsp + 0x18, *((rsp + 8)), 0x20, "string<...>::append(n,c): string too long"); | } 0x0045c16e mov rdi, qword [rsp + 0x10] | 0x0045c173 lea rsi, [rsp + 0x18] | 0x0045c178 call 0x44f6f0 | std::_1::basic_ostream>&bsl::operator << ,bsl::allocator>(std::_1::basic_ostream>&,bsl::basic_string,bsl::allocator>const&) (*((rsp + 0x10)), rsp + 0x18); 0x0045c17d mov rdi, qword [r14] | 0x0045c180 add rdi, rbp | rdi += rbp; 0x0045c183 call 0x464940 | rax = BloombergLP::balcl::Option::description()const (*(r14)); 0x0045c188 lea rcx, [rsp + 0x18] | rcx = rsp + 0x18; 0x0045c18d cmp rcx, rax | | if (rcx != rax) { 0x0045c190 je 0x45c1c0 | 0x0045c192 cmp qword [rax + 0x20], 0x17 | 0x0045c197 mov rsi, rax | rsi = rax; | if (*((rax + 0x20)) != 0x17) { 0x0045c19a je 0x45c19f | 0x0045c19c mov rsi, qword [rax] | | } 0x0045c19f mov rdx, qword [rax + 0x18] | 0x0045c1a3 mov r12, qword [rsp + 0x30] | r12 = *((rsp + 0x30)); 0x0045c1a8 mov qword [rsp + 0x30], 0 | *((rsp + 0x30)) = 0; 0x0045c1b1 mov ecx, 0x4ae7f9 | 0x0045c1b6 lea rdi, [rsp + 0x18] | 0x0045c1bb call 0x481e80 | bsl::basic_string,bsl::allocator>::privateAppend(char const*,unsigned long,char const*) (rsp + 0x18, *(rax), *((rax + 0x18)), "string<...>::operator=(const string&...): string too long"); | } 0x0045c1c0 mov rdi, qword [r14] | 0x0045c1c3 add rdi, rbp | rdi += rbp; 0x0045c1c6 call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (*(r14)); 0x0045c1cb lea r12, [rsp + 0xc8] | r12 = rsp + 0xc8; 0x0045c1d3 mov rdi, rax | 0x0045c1d6 call 0x462790 | al = BloombergLP::balcl::OccurrenceInfo::hasDefaultValue()const (rax); 0x0045c1db test al, al | | if (al != 0) { 0x0045c1dd je 0x45c3d2 | 0x0045c1e3 mov rax, qword [rip + 0x2a9a3e] | rax = BloombergLP::bslma::Default::s_defaultAllocator; 0x0045c1ea test rax, rax | | if (rax == 0) { 0x0045c1ed jne 0x45c1f4 | 0x0045c1ef call 0x47ce20 | rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() (); | } 0x0045c1f4 mov qword [rsp + 0x90], rax | *((rsp + 0x90)) = rax; 0x0045c1fc mov qword [rsp + 0x148], 0x6fac10 | *((rsp + 0x148)) = 0x6fac10; 0x0045c208 mov rdi, r12 | 0x0045c20b mov esi, 0x10 | 0x0045c210 lea rdx, [rsp + 0x90] | 0x0045c218 call 0x455390 | bsl::basic_stringbuf,bsl::allocator>::basic_stringbuf(unsignedint,bsl::allocatorconst&) (r12, 0x10, rsp + 0x90); 0x0045c21d mov qword [rsp + 0xc0], 0x4aea90 | *((rsp + 0xc0)) = sym.imp.std::__1::basic_ostream_char__std::__1::char_traits_char___::basic_ostream__; 0x0045c229 mov qword [rsp + 0x148], 0x4aeab8 | *((rsp + sym.imp.virtual_thunk_to_std::__1::basic_ostream_char__std::__1::char_traits_char___::basic_ostream__)) = 0x4aeab8; 0x0045c235 lea rdi, [rsp + 0x148] | rdi = rsp + 0x148; 0x0045c23d mov rsi, r12 | rsi = r12; 0x0045c240 call 0x404640 | std::_1::ios_base::init(void*) (); 0x0045c245 mov qword [rsp + 0x1d0], 0 | *((rsp + 0x1d0)) = 0; 0x0045c251 mov dword [rsp + 0x1d8], 0xffffffff | *((rsp + 0x1d8)) = 0xffffffff; 0x0045c25c mov qword [rsp + 0xc0], 0x4aea20 | *((rsp + 0xc0)) = vtable.bsl::basic_ostringstream_char__std::__1::char_traits_char___bsl::allocator_char___.0; 0x0045c268 mov qword [rsp + 0x148], 0x4aea48 | *((rsp + method.virtual_thunk_to_bsl::basic_ostringstream_char__std::__1::char_traits_char___bsl::allocator_char___.basic_ostringstream__)) = 0x4aea48; 0x0045c274 add rbp, qword [r14] | rbp += *(r14); 0x0045c277 mov rdi, rbp | 0x0045c27a call 0x4649a0 | rax = BloombergLP::balcl::Option::occurrenceInfo()const (rbp); 0x0045c27f mov rdi, rax | 0x0045c282 call 0x462780 | rax = BloombergLP::balcl::OccurrenceInfo::defaultValue()const (rax); 0x0045c287 mov rdi, rax | 0x0045c28a lea rsi, [rsp + 0xc0] | 0x0045c292 xor edx, edx | 0x0045c294 mov ecx, 0xffffffff | 0x0045c299 call 0x465860 | BloombergLP::balcl::OptionValue::print(std::_1::basic_ostream>&,int,int)const (rax, rsp + 0xc0, 0, 0xffffffff); 0x0045c29e lea r15, [rsp + 0x248] | r15 = rsp + 0x248; 0x0045c2a6 mov rdi, r15 | 0x0045c2a9 mov rsi, r12 | 0x0045c2ac call 0x455ee0 | bsl::basic_stringbuf,bsl::allocator>::str()const (r15, r12); 0x0045c2b1 lea rbp, [rsp + 0x90] | rbp = rsp + 0x90; 0x0045c2b9 mov esi, 0x4afb3e | 0x0045c2be lea r13, [rsp + 0x218] | r13 = rsp + 0x218; 0x0045c2c6 mov rdi, r13 | 0x0045c2c9 mov rdx, r15 | 0x0045c2cc call 0x45e940 | bsl::basic_string,bsl::allocator>bsl::operator+,bsl::allocator>(char const*,bsl::basic_string,bsl::allocator>const&) (r13, " (default: ", r15); 0x0045c2d1 mov rdi, rbp | 0x0045c2d4 mov rsi, r13 | 0x0045c2d7 mov edx, 0x29 | 0x0045c2dc call 0x454a80 | bsl::basic_string,bsl::allocator>bsl::operator+,bsl::allocator>(bsl::basic_string,bsl::allocator>const&,char) (rbp, r13, 0x29); 0x0045c2e1 lea rdi, [rsp + 0x18] | 0x0045c2e6 mov rsi, rbp | 0x0045c2e9 xor edx, edx | 0x0045c2eb mov rcx, 0xffffffffffffffff | rcx = 0xffffffffffffffff; 0x0045c2f2 call 0x483a00 | bsl::basic_string,bsl::allocator>::append(bsl::basic_string,bsl::allocator>const&,unsigned long,unsigned long) (rsp + 0x18, rbp, 0); 0x0045c2f7 cmp qword [rsp + 0xb0], 0x17 | | if (*((rsp + 0xb0)) != 0x17) { 0x0045c300 je 0x45c318 | 0x0045c302 mov rsi, qword [rsp + 0x90] | rsi = *((rsp + 0x90)); 0x0045c30a mov rdi, qword [rsp + 0xb8] | rdi = *((rsp + 0xb8)); 0x0045c312 mov rax, qword [rdi] | rax = *(rdi); 0x0045c315 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c318 mov qword [rsp + 0xa8], 0xffffffffffffffff | *((rsp + 0xa8)) = 0xffffffffffffffff; 0x0045c324 cmp qword [rsp + 0x238], 0x17 | | if (*((rsp + 0x238)) != 0x17) { 0x0045c32d je 0x45c345 | 0x0045c32f mov rsi, qword [rsp + 0x218] | rsi = *((rsp + 0x218)); 0x0045c337 mov rdi, qword [rsp + 0x240] | rdi = *((rsp + 0x240)); 0x0045c33f mov rax, qword [rdi] | rax = *(rdi); 0x0045c342 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c345 mov qword [rsp + 0x230], 0xffffffffffffffff | *((rsp + 0x230)) = 0xffffffffffffffff; 0x0045c351 cmp qword [rsp + 0x268], 0x17 | | if (*((rsp + 0x268)) != 0x17) { 0x0045c35a je 0x45c372 | 0x0045c35c mov rsi, qword [rsp + 0x248] | rsi = *((rsp + 0x248)); 0x0045c364 mov rdi, qword [rsp + 0x270] | rdi = *((rsp + 0x270)); 0x0045c36c mov rax, qword [rdi] | rax = *(rdi); 0x0045c36f call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c372 mov esi, 0x4aea60 | esi = 0x4aea60; 0x0045c377 lea rdi, [rsp + 0xc0] | rdi = rsp + 0xc0; 0x0045c37f call 0x404b70 | std::_1::basic_ostream>::~basic_ostream() (); 0x0045c384 mov qword [rsp + 0xc8], 0x4aebb0 | *((rsp + 0xc8)) = vtable.bsl::basic_stringbuf_char__std::__1::char_traits_char___bsl::allocator_char___.0; 0x0045c390 cmp qword [rsp + 0x128], 0x17 | | if (*((rsp + 0x128)) != 0x17) { 0x0045c399 je 0x45c3b1 | 0x0045c39b mov rsi, qword [rsp + 0x108] | rsi = *((rsp + 0x108)); 0x0045c3a3 mov rdi, qword [rsp + 0x130] | rdi = *((rsp + 0x130)); 0x0045c3ab mov rax, qword [rdi] | rax = *(rdi); 0x0045c3ae call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c3b1 mov qword [rsp + 0x120], 0xffffffffffffffff | *((rsp + 0x120)) = 0xffffffffffffffff; 0x0045c3bd mov rdi, r12 | rdi = r12; 0x0045c3c0 call 0x404560 | std::_1::basic_streambuf>::~basic_streambuf() (); 0x0045c3c5 lea rdi, [rsp + 0x148] | rdi = rsp + 0x148; 0x0045c3cd call 0x404490 | std::_1::basic_ios>::~basic_ios() (); | } 0x0045c3d2 cmp dword [rsp + 4], 0x1c | | if (*((rsp + 4)) >= 0x1c) { 0x0045c3d7 jl 0x45c400 | 0x0045c3d9 mov edi, 0xa | 0x0045c3de lea rsi, [rsp + 0x18] | 0x0045c3e3 mov rdx, qword [rsp + 0x10] | 0x0045c3e8 xor ecx, ecx | 0x0045c3ea call 0x45dad0 | BloombergLP::balcl::(anonymousnamespace)::u::format(unsigned long,unsigned long,bsl::basic_string,bsl::allocator>&,std::_1::basic_ostream>&,unsigned long) (0xa, rsp + 0x18, *((rsp + 0x10)), 0); 0x0045c3ef jmp 0x45c417 | | } else { 0x0045c400 mov rcx, qword [rsp + 8] | rcx = *((rsp + 8)); 0x0045c405 mov rdi, rcx | 0x0045c408 lea rsi, [rsp + 0x18] | 0x0045c40d mov rdx, qword [rsp + 0x10] | 0x0045c412 call 0x45dad0 | BloombergLP::balcl::(anonymousnamespace)::u::format(unsigned long,unsigned long,bsl::basic_string,bsl::allocator>&,std::_1::basic_ostream>&,unsigned long) (*((rsp + 8)), rsp + 0x18, *((rsp + 0x10)), *(rcx)); | } 0x0045c417 mov byte [rsp + 0xc0], 0xa | *((rsp + 0xc0)) = 0xa; 0x0045c41f mov edx, 1 | 0x0045c424 mov rdi, qword [rsp + 0x10] | 0x0045c429 lea rsi, [rsp + 0xc0] | 0x0045c431 call 0x455480 | rax = std::_1::basic_ostream>&std::_1::_put_character_sequence>(std::_1::basic_ostream>&,char const*,unsigned long) (*((rsp + 0x10)), rsp + 0xc0, 1); 0x0045c436 mov rdi, rax | rdi = rax; 0x0045c439 call 0x404980 | std::_1::basic_ostream>::flush() (); 0x0045c43e cmp qword [rsp + 0x38], 0x17 | | if (*((rsp + 0x38)) == 0x17) { 0x0045c444 je 0x45c030 | goto label_4; | } 0x0045c44a mov rsi, qword [rsp + 0x18] | rsi = *((rsp + 0x18)); 0x0045c44f mov rdi, qword [rsp + 0x40] | rdi = *((rsp + 0x40)); 0x0045c454 mov rax, qword [rdi] | rax = *(rdi); 0x0045c457 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); 0x0045c45a jmp 0x45c030 | goto label_4; | label_16: 0x0045c45f cmp qword [rsp + 0x208], 0x17 | | if (*((rsp + 0x208)) != 0x17) { 0x0045c468 je 0x45c480 | 0x0045c46a mov rsi, qword [rsp + 0x1e8] | rsi = *((rsp + 0x1e8)); 0x0045c472 mov rdi, qword [rsp + 0x210] | rdi = *((rsp + 0x210)); 0x0045c47a mov rax, qword [rdi] | rax = *(rdi); 0x0045c47d call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c480 mov rbx, qword [rsp + 0x70] | rbx = *((rsp + 0x70)); 0x0045c485 test rbx, rbx | | if (rbx == 0) { 0x0045c488 je 0x45c4dd | goto label_24; | } 0x0045c48a mov rbp, qword [rsp + 0x78] | rbp = *((rsp + 0x78)); 0x0045c48f cmp rbx, rbp | | if (rbx != rbp) { 0x0045c492 jne 0x45c4b1 | goto label_25; | } 0x0045c494 jmp 0x45c4cc | goto label_26; | do { | label_5: 0x0045c4a0 mov qword [rbx + 0x18], 0xffffffffffffffff | *((rbx + 0x18)) = 0xffffffffffffffff; 0x0045c4a8 add rbx, 0x30 | rbx += 0x30; 0x0045c4ac cmp rbp, rbx | | if (rbp == rbx) { 0x0045c4af je 0x45c4c7 | goto label_27; | } | label_25: 0x0045c4b1 cmp qword [rbx + 0x20], 0x17 | 0x0045c4b6 je 0x45c4a0 | | } while (*((rbx + 0x20)) == 0x17); 0x0045c4b8 mov rsi, qword [rbx] | rsi = *(rbx); 0x0045c4bb mov rdi, qword [rbx + 0x28] | rdi = *((rbx + 0x28)); 0x0045c4bf mov rax, qword [rdi] | rax = *(rdi); 0x0045c4c2 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); 0x0045c4c5 jmp 0x45c4a0 | goto label_5; | label_27: 0x0045c4c7 mov rbx, qword [rsp + 0x70] | rbx = *((rsp + 0x70)); | label_26: 0x0045c4cc mov rdi, qword [rsp + 0x88] | rdi = *((rsp + 0x88)); 0x0045c4d4 mov rax, qword [rdi] | rax = *(rdi); 0x0045c4d7 mov rsi, rbx | rsi = rbx; 0x0045c4da call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | label_24: 0x0045c4dd mov rbx, qword [rsp + 0x50] | rbx = *((rsp + 0x50)); 0x0045c4e2 test rbx, rbx | | if (rbx == 0) { 0x0045c4e5 je 0x45c53a | goto label_28; | } 0x0045c4e7 mov rbp, qword [rsp + 0x58] | rbp = *((rsp + 0x58)); 0x0045c4ec cmp rbx, rbp | | if (rbx != rbp) { 0x0045c4ef jne 0x45c511 | goto label_29; | } 0x0045c4f1 jmp 0x45c52c | goto label_30; | do { | label_6: 0x0045c500 mov qword [rbx + 0x18], 0xffffffffffffffff | *((rbx + 0x18)) = 0xffffffffffffffff; 0x0045c508 add rbx, 0x30 | rbx += 0x30; 0x0045c50c cmp rbp, rbx | | if (rbp == rbx) { 0x0045c50f je 0x45c527 | goto label_31; | } | label_29: 0x0045c511 cmp qword [rbx + 0x20], 0x17 | 0x0045c516 je 0x45c500 | | } while (*((rbx + 0x20)) == 0x17); 0x0045c518 mov rsi, qword [rbx] | rsi = *(rbx); 0x0045c51b mov rdi, qword [rbx + 0x28] | rdi = *((rbx + 0x28)); 0x0045c51f mov rax, qword [rdi] | rax = *(rdi); 0x0045c522 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); 0x0045c525 jmp 0x45c500 | goto label_6; | label_31: 0x0045c527 mov rbx, qword [rsp + 0x50] | rbx = *((rsp + 0x50)); | label_30: 0x0045c52c mov rdi, qword [rsp + 0x68] | rdi = *((rsp + 0x68)); 0x0045c531 mov rax, qword [rdi] | rax = *(rdi); 0x0045c534 mov rsi, rbx | rsi = rbx; 0x0045c537 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | label_28: 0x0045c53a cmp qword [rsp + 0x298], 0x17 | | if (*((rsp + 0x298)) != 0x17) { 0x0045c543 je 0x45c55b | 0x0045c545 mov rsi, qword [rsp + 0x278] | rsi = *((rsp + 0x278)); 0x0045c54d mov rdi, qword [rsp + 0x2a0] | rdi = *((rsp + 0x2a0)); 0x0045c555 mov rax, qword [rdi] | rax = *(rdi); 0x0045c558 call qword [rax + 0x18] | uint64_t (*rax + 0x18)() (); | } 0x0045c55b add rsp, 0x2a8 | 0x0045c562 pop rbx | 0x0045c563 pop r12 | 0x0045c565 pop r13 | 0x0045c567 pop r14 | 0x0045c569 pop r15 | 0x0045c56b pop rbp | 0x0045c56c ret | return rax; | }