; assembly                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                             | /* bdlsb_fixedmeminput.t/none @ 0x40bd80 */
                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bslx::GenericInStream_BloombergLP::bdlsb::FixedMemInput_.getString_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char____ ()           | int64_t method_BloombergLP::bslx::GenericInStream_BloombergLP::bdlsb::FixedMemInput_getString_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_ (char * arg2, char * arg1) {
                                                                                                                                                                                             |     void * s1;
                                                                                                                                                                                             |     void * var_5h;
                                                                                                                                                                                             |     void * var_6h;
                                                                                                                                                                                             |     void * var_7h;
                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                             |     /* BloombergLP::bslx::GenericInStream<BloombergLP::bdlsb::FixedMemInput>::getString(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >&) */
    0x0040bd80 push rbp                                                                                                                                                                      |     
    0x0040bd81 push r15                                                                                                                                                                      |     
    0x0040bd83 push r14                                                                                                                                                                      |     
    0x0040bd85 push r13                                                                                                                                                                      |     
    0x0040bd87 push r12                                                                                                                                                                      |     
    0x0040bd89 push rbx                                                                                                                                                                      |     
    0x0040bd8a push rax                                                                                                                                                                      |     
    0x0040bd8b mov r15, rdi                                                                                                                                                                  |     r15 = rdi;
    0x0040bd8e cmp byte [rdi + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((rdi + 8)) == 0) {
    0x0040bd92 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bd98 mov byte [r15 + 8], 0                                                                                                                                                         |     *((r15 + 8)) = 0;
    0x0040bd9d mov rax, qword [r15]                                                                                                                                                          |     rax = *(r15);
    0x0040bda0 mov rcx, qword [rax + 0x10]                                                                                                                                                   |     rcx = *((rax + 0x10));
    0x0040bda4 cmp rcx, qword [rax + 8]                                                                                                                                                      |     
                                                                                                                                                                                             |     if (rcx >= *((rax + 8))) {
    0x0040bda8 jae 0x40bf9b                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bdae mov r14, rsi                                                                                                                                                                  |     r14 = rsi;
    0x0040bdb1 mov rdx, qword [rax]                                                                                                                                                          |     rdx = *(rax);
    0x0040bdb4 cmp byte [rdx + rcx], 0                                                                                                                                                       |     
    0x0040bdb8 mov byte [r15 + 8], 0                                                                                                                                                         |     *((r15 + 8)) = 0;
                                                                                                                                                                                             |     if (*((rdx + rcx)) >= 0) {
    0x0040bdbd js 0x40be03                                                                                                                                                                   |         
    0x0040bdbf mov rdx, qword [rax + 0x10]                                                                                                                                                   |         rdx = *((rax + 0x10));
    0x0040bdc3 cmp rdx, qword [rax + 8]                                                                                                                                                      |         
                                                                                                                                                                                             |         if (rdx >= *((rax + 8))) {
    0x0040bdc7 jae 0x40bfb7                                                                                                                                                                  |             goto label_5;
                                                                                                                                                                                             |         }
    0x0040bdcd mov rcx, qword [rax]                                                                                                                                                          |         rcx = *(rax);
    0x0040bdd0 movsx ecx, byte [rcx + rdx]                                                                                                                                                   |         ecx = *((rcx + rdx));
    0x0040bdd4 inc rdx                                                                                                                                                                       |         rdx++;
    0x0040bdd7 mov qword [rax + 0x10], rdx                                                                                                                                                   |         *((rax + 0x10)) = rdx;
    0x0040bddb mov byte [r15 + 8], 1                                                                                                                                                         |         *((r15 + 8)) = 1;
    0x0040bde0 mov al, 1                                                                                                                                                                     |         al = 1;
                                                                                                                                                                                             | label_1:
    0x0040bde2 mov esi, ecx                                                                                                                                                                  |         esi = ecx;
    0x0040bde4 and esi, 0xffffff00                                                                                                                                                           |         esi &= 0xffffff00;
    0x0040bdea mov edx, ecx                                                                                                                                                                  |         edx = ecx;
    0x0040bdec and edx, 0xffff0000                                                                                                                                                           |         edx &= 0xffff0000;
    0x0040bdf2 mov edi, ecx                                                                                                                                                                  |         edi = ecx;
    0x0040bdf4 and edi, 0xff000000                                                                                                                                                           |         edi &= 0xff000000;
    0x0040bdfa test al, al                                                                                                                                                                   |         
                                                                                                                                                                                             |         if (al != 0) {
    0x0040bdfc jne 0x40be72                                                                                                                                                                  |             goto label_6;
                                                                                                                                                                                             |         }
    0x0040bdfe jmp 0x40bf9b                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040be03 mov rbx, qword [rax + 8]                                                                                                                                                      |     rbx = *((rax + 8));
    0x0040be07 mov rsi, qword [rax + 0x10]                                                                                                                                                   |     rsi = *((rax + 0x10));
    0x0040be0b mov rcx, rsi                                                                                                                                                                  |     rcx = *((rax + 0x10));
    0x0040be0e sub rcx, 0xfffffffffffffffc                                                                                                                                                   |     rcx -= 0xfffffffffffffffc;
    0x0040be12 mov qword [rax + 0x10], rcx                                                                                                                                                   |     *((rax + 0x10)) = rcx;
                                                                                                                                                                                             |     if (rcx >= 0) {
    0x0040be16 jae 0x40bfc0                                                                                                                                                                  |         goto label_7;
                                                                                                                                                                                             |     }
    0x0040be1c cmp rcx, rbx                                                                                                                                                                  |     
                                                                                                                                                                                             |     if (rcx > rbx) {
    0x0040be1f ja 0x40bfc0                                                                                                                                                                   |         goto label_7;
                                                                                                                                                                                             |     }
    0x0040be25 mov rax, qword [rax]                                                                                                                                                          |     rax = *(rax);
    0x0040be28 mov ecx, dword [rax + rsi]                                                                                                                                                    |     ecx = *((rax + rsi));
    0x0040be2b mov edx, ecx                                                                                                                                                                  |     edx = *((rax + rsi));
    0x0040be2d shr edx, 8                                                                                                                                                                    |     edx >>= 8;
    0x0040be30 mov esi, ecx                                                                                                                                                                  |     esi = ecx;
    0x0040be32 shr esi, 0x10                                                                                                                                                                 |     esi >>= 0x10;
    0x0040be35 mov ebp, ecx                                                                                                                                                                  |     
    0x0040be37 shr ebp, 0x18                                                                                                                                                                 |     ebp >>= 0x18;
                                                                                                                                                                                             | label_2:
    0x0040be3a mov byte [r15 + 8], 1                                                                                                                                                         |     *((r15 + 8)) = 1;
    0x0040be3f mov al, 1                                                                                                                                                                     |     al = 1;
                                                                                                                                                                                             | label_3:
    0x0040be41 movzx edi, cl                                                                                                                                                                 |     edi = (int32_t) cl;
    0x0040be44 shl edi, 0x18                                                                                                                                                                 |     edi <<= 0x18;
    0x0040be47 movzx edx, dl                                                                                                                                                                 |     edx = (int32_t) dl;
    0x0040be4a shl edx, 0x10                                                                                                                                                                 |     edx <<= 0x10;
    0x0040be4d or edx, edi                                                                                                                                                                   |     edx |= edi;
    0x0040be4f movzx esi, sil                                                                                                                                                                |     esi = (int32_t) sil;
    0x0040be53 shl esi, 8                                                                                                                                                                    |     esi <<= 8;
    0x0040be56 movzx ecx, bpl                                                                                                                                                                |     ecx = (int32_t) bpl;
    0x0040be5a and edx, 0x7fff0000                                                                                                                                                           |     edx &= 0x7fff0000;
    0x0040be60 or esi, edx                                                                                                                                                                   |     esi |= edx;
    0x0040be62 or ecx, esi                                                                                                                                                                   |     ecx |= esi;
    0x0040be64 and edi, 0x7f000000                                                                                                                                                           |     edi &= 0x7f000000;
    0x0040be6a test al, al                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (al == 0) {
    0x0040be6c je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
                                                                                                                                                                                             | label_6:
    0x0040be72 and edx, 0xff0000                                                                                                                                                             |     edx &= 0xff0000;
    0x0040be78 or edx, edi                                                                                                                                                                   |     edx |= edi;
    0x0040be7a and esi, 0xff00                                                                                                                                                               |     esi &= 0xff00;
    0x0040be80 movzx r13d, cl                                                                                                                                                                |     r13d = (int32_t) cl;
    0x0040be84 or r13d, esi                                                                                                                                                                  |     r13d |= esi;
    0x0040be87 or r13d, edx                                                                                                                                                                  |     r13d |= edx;
    0x0040be8a cmp r13d, 0x1000000                                                                                                                                                           |     
    0x0040be91 mov r12d, 0x1000000                                                                                                                                                           |     r12d = 0x1000000;
                                                                                                                                                                                             |     if (r13d < 0x1000000) {
    0x0040be97 cmovl r12d, r13d                                                                                                                                                              |         r12d = r13d;
                                                                                                                                                                                             |     }
    0x0040be9b cmp r12d, 0xffffffff                                                                                                                                                          |     
                                                                                                                                                                                             |     if (r12d == 0xffffffff) {
    0x0040be9f je 0x40bfad                                                                                                                                                                   |         goto label_8;
                                                                                                                                                                                             |     }
    0x0040bea5 movsxd rbx, r12d                                                                                                                                                              |     rbx = (int64_t) r12d;
    0x0040bea8 mov rdi, r14                                                                                                                                                                  |     
    0x0040beab mov rsi, rbx                                                                                                                                                                  |     
    0x0040beae xor edx, edx                                                                                                                                                                  |     
    0x0040beb0 call 0x411050                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, rbx, 0);
    0x0040beb5 test r13d, r13d                                                                                                                                                               |     
                                                                                                                                                                                             |     if (r13d == 0) {
    0x0040beb8 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bebe cmp qword [r14 + 0x20], 0x17                                                                                                                                                  |     
    0x0040bec3 mov rbp, r14                                                                                                                                                                  |     
                                                                                                                                                                                             |     if (*((r14 + 0x20)) != 0x17) {
    0x0040bec6 je 0x40becb                                                                                                                                                                   |         
    0x0040bec8 mov rbp, qword [r14]                                                                                                                                                          |         rbp = *(r14);
                                                                                                                                                                                             |     }
    0x0040becb cmp byte [r15 + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((r15 + 8)) == 0) {
    0x0040bed0 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bed6 mov dl, 1                                                                                                                                                                     |     dl = 1;
    0x0040bed8 xor ecx, ecx                                                                                                                                                                  |     ecx = 0;
    0x0040beda nop word [rax + rax]                                                                                                                                                          |     
                                                                                                                                                                                             |     do {
    0x0040bee0 test dl, dl                                                                                                                                                                   |         
                                                                                                                                                                                             |         if (dl != 0) {
    0x0040bee2 je 0x40bf0d                                                                                                                                                                   |             
    0x0040bee4 mov byte [r15 + 8], 0                                                                                                                                                         |             *((r15 + 8)) = 0;
    0x0040bee9 mov rdx, qword [r15]                                                                                                                                                          |             rdx = *(r15);
    0x0040beec mov rsi, qword [rdx + 0x10]                                                                                                                                                   |             rsi = *((rdx + 0x10));
    0x0040bef0 cmp rsi, qword [rdx + 8]                                                                                                                                                      |             
                                                                                                                                                                                             |             if (rsi >= *((rdx + 8))) {
    0x0040bef4 jae 0x40bf0d                                                                                                                                                                  |                 goto label_9;
                                                                                                                                                                                             |             }
    0x0040bef6 mov rdi, qword [rdx]                                                                                                                                                          |             rdi = *(rdx);
    0x0040bef9 movzx eax, byte [rdi + rsi]                                                                                                                                                   |             eax = *((rdi + rsi));
    0x0040befd inc rsi                                                                                                                                                                       |             rsi++;
    0x0040bf00 mov qword [rdx + 0x10], rsi                                                                                                                                                   |             *((rdx + 0x10)) = rsi;
    0x0040bf04 mov byte [r15 + 8], 1                                                                                                                                                         |             *((r15 + 8)) = 1;
    0x0040bf09 mov byte [rbp + rcx], al                                                                                                                                                      |             *((rbp + rcx)) = al;
                                                                                                                                                                                             |         }
                                                                                                                                                                                             | label_9:
    0x0040bf0d movzx edx, byte [r15 + 8]                                                                                                                                                     |         edx = *((r15 + 8));
    0x0040bf12 inc rcx                                                                                                                                                                       |         rcx++;
    0x0040bf15 cmp rbx, rcx                                                                                                                                                                  |         
    0x0040bf18 jne 0x40bee0                                                                                                                                                                  |         
                                                                                                                                                                                             |     } while (rbx != rcx);
    0x0040bf1a cmp r13d, 0x1000001                                                                                                                                                           |     
                                                                                                                                                                                             |     if (r13d < 0x1000001) {
    0x0040bf21 jl 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf23 test dl, dl                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (dl == 0) {
    0x0040bf25 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf27 mov esi, r13d                                                                                                                                                                 |     
    0x0040bf2a mov rdi, r14                                                                                                                                                                  |     
    0x0040bf2d xor edx, edx                                                                                                                                                                  |     
    0x0040bf2f call 0x411050                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x0040bf34 cmp qword [r14 + 0x20], 0x17                                                                                                                                                  |     
                                                                                                                                                                                             |     if (*((r14 + 0x20)) != 0x17) {
    0x0040bf39 je 0x40bf3e                                                                                                                                                                   |         
    0x0040bf3b mov r14, qword [r14]                                                                                                                                                          |         r14 = *(r14);
                                                                                                                                                                                             |     }
    0x0040bf3e cmp r13d, r12d                                                                                                                                                                |     
                                                                                                                                                                                             |     if (r13d == r12d) {
    0x0040bf41 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf43 cmp byte [r15 + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((r15 + 8)) == 0) {
    0x0040bf48 je 0x40bf9b                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf4a movsxd rdi, r13d                                                                                                                                                              |     rdi = (int64_t) r13d;
    0x0040bf4d dec rdi                                                                                                                                                                       |     rdi--;
    0x0040bf50 mov cl, 1                                                                                                                                                                     |     cl = 1;
    0x0040bf52 test cl, cl                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (cl == 0) {
    0x0040bf54 je 0x40bf88                                                                                                                                                                   |         goto label_0;
                                                                                                                                                                                             |     }
    0x0040bf56 nop word cs:[rax + rax]                                                                                                                                                       |     
                                                                                                                                                                                             |     do {
    0x0040bf60 mov byte [r15 + 8], 0                                                                                                                                                         |         *((r15 + 8)) = 0;
    0x0040bf65 mov rcx, qword [r15]                                                                                                                                                          |         rcx = *(r15);
    0x0040bf68 mov rdx, qword [rcx + 0x10]                                                                                                                                                   |         rdx = *((rcx + 0x10));
    0x0040bf6c cmp rdx, qword [rcx + 8]                                                                                                                                                      |         
                                                                                                                                                                                             |         if (rdx < *((rcx + 8))) {
    0x0040bf70 jae 0x40bf88                                                                                                                                                                  |             
    0x0040bf72 mov rsi, qword [rcx]                                                                                                                                                          |             rsi = *(rcx);
    0x0040bf75 mov al, byte [rsi + rdx]                                                                                                                                                      |             al = *((rsi + rdx));
    0x0040bf78 inc rdx                                                                                                                                                                       |             rdx++;
    0x0040bf7b mov qword [rcx + 0x10], rdx                                                                                                                                                   |             *((rcx + 0x10)) = rdx;
    0x0040bf7f mov byte [r15 + 8], 1                                                                                                                                                         |             *((r15 + 8)) = 1;
    0x0040bf84 mov byte [r14 + rbx], al                                                                                                                                                      |             *((r14 + rbx)) = al;
                                                                                                                                                                                             |         }
                                                                                                                                                                                             | label_0:
    0x0040bf88 cmp rdi, rbx                                                                                                                                                                  |         
                                                                                                                                                                                             |         if (rdi == rbx) {
    0x0040bf8b je 0x40bf9b                                                                                                                                                                   |             goto label_4;
                                                                                                                                                                                             |         }
    0x0040bf8d movzx ecx, byte [r15 + 8]                                                                                                                                                     |         ecx = *((r15 + 8));
    0x0040bf92 inc rbx                                                                                                                                                                       |         rbx++;
    0x0040bf95 test cl, cl                                                                                                                                                                   |         
    0x0040bf97 jne 0x40bf60                                                                                                                                                                  |         
                                                                                                                                                                                             |     } while (cl != 0);
    0x0040bf99 jmp 0x40bf88                                                                                                                                                                  |     goto label_0;
                                                                                                                                                                                             | label_4:
    0x0040bf9b mov rax, r15                                                                                                                                                                  |     rax = r15;
    0x0040bf9e add rsp, 8                                                                                                                                                                    |     
    0x0040bfa2 pop rbx                                                                                                                                                                       |     
    0x0040bfa3 pop r12                                                                                                                                                                       |     
    0x0040bfa5 pop r13                                                                                                                                                                       |     
    0x0040bfa7 pop r14                                                                                                                                                                       |     
    0x0040bfa9 pop r15                                                                                                                                                                       |     
    0x0040bfab pop rbp                                                                                                                                                                       |     
    0x0040bfac ret                                                                                                                                                                           |     return rax;
                                                                                                                                                                                             | label_8:
    0x0040bfad mov edi, 0x434c1a                                                                                                                                                             |     
    0x0040bfb2 call 0x40e6f0                                                                                                                                                                 |     eax = BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                             | label_5:
    0x0040bfb7 xor eax, eax                                                                                                                                                                  |     eax = 0;
    0x0040bfb9 xor ecx, ecx                                                                                                                                                                  |     ecx = 0;
    0x0040bfbb jmp 0x40bde2                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                             | label_7:
    0x0040bfc0 mov qword [rax + 0x10], rbx                                                                                                                                                   |     *((rax + 0x10)) = rbx;
    0x0040bfc4 sub rbx, rsi                                                                                                                                                                  |     rbx -= rsi;
    0x0040bfc7 add rsi, qword [rax]                                                                                                                                                          |     rsi += *(rax);
    0x0040bfca lea rdi, [rsp + 4]                                                                                                                                                            |     
    0x0040bfcf mov rdx, rbx                                                                                                                                                                  |     
    0x0040bfd2 call 0x404250                                                                                                                                                                 |     memcpy (rsp + 4, rsi, rbx);
    0x0040bfd7 cmp rbx, 4                                                                                                                                                                    |     
                                                                                                                                                                                             |     if (rbx == 4) {
    0x0040bfdb jne 0x40bff4                                                                                                                                                                  |         
    0x0040bfdd mov cl, byte [rsp + 4]                                                                                                                                                        |         cl = *((rsp + 4));
    0x0040bfe1 mov dl, byte [rsp + 5]                                                                                                                                                        |         dl = *((rsp + 5));
    0x0040bfe5 mov sil, byte [rsp + 6]                                                                                                                                                       |         sil = *((rsp + 6));
    0x0040bfea mov bpl, byte [rsp + 7]                                                                                                                                                       |         bpl = *((rsp + 7));
    0x0040bfef jmp 0x40be3a                                                                                                                                                                  |         goto label_2;
                                                                                                                                                                                             |     }
    0x0040bff4 mov al, byte [r15 + 8]                                                                                                                                                        |     al = *((r15 + 8));
    0x0040bff8 jmp 0x40be41                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                             | }