; assembly                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                             | /* bdlsb_fixedmeminput.t/assume @ 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 rbx, rdi                                                                                                                                                                  |     rbx = rdi;
    0x0040bd8e cmp byte [rdi + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((rdi + 8)) == 0) {
    0x0040bd92 je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bd98 mov byte [rbx + 8], 0                                                                                                                                                         |     *((rbx + 8)) = 0;
    0x0040bd9c mov rax, qword [rbx]                                                                                                                                                          |     rax = *(rbx);
    0x0040bd9f mov rcx, qword [rax + 0x10]                                                                                                                                                   |     rcx = *((rax + 0x10));
    0x0040bda3 cmp rcx, qword [rax + 8]                                                                                                                                                      |     
                                                                                                                                                                                             |     if (rcx >= *((rax + 8))) {
    0x0040bda7 jae 0x40bf98                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bdad mov r14, rsi                                                                                                                                                                  |     r14 = rsi;
    0x0040bdb0 mov rdx, qword [rax]                                                                                                                                                          |     rdx = *(rax);
    0x0040bdb3 cmp byte [rdx + rcx], 0                                                                                                                                                       |     
    0x0040bdb7 mov byte [rbx + 8], 0                                                                                                                                                         |     *((rbx + 8)) = 0;
                                                                                                                                                                                             |     if (*((rdx + rcx)) >= 0) {
    0x0040bdbb js 0x40be00                                                                                                                                                                   |         
    0x0040bdbd mov rdx, qword [rax + 0x10]                                                                                                                                                   |         rdx = *((rax + 0x10));
    0x0040bdc1 cmp rdx, qword [rax + 8]                                                                                                                                                      |         
                                                                                                                                                                                             |         if (rdx >= *((rax + 8))) {
    0x0040bdc5 jae 0x40bfb4                                                                                                                                                                  |             goto label_5;
                                                                                                                                                                                             |         }
    0x0040bdcb mov rcx, qword [rax]                                                                                                                                                          |         rcx = *(rax);
    0x0040bdce movsx ecx, byte [rcx + rdx]                                                                                                                                                   |         ecx = *((rcx + rdx));
    0x0040bdd2 inc rdx                                                                                                                                                                       |         rdx++;
    0x0040bdd5 mov qword [rax + 0x10], rdx                                                                                                                                                   |         *((rax + 0x10)) = rdx;
    0x0040bdd9 mov byte [rbx + 8], 1                                                                                                                                                         |         *((rbx + 8)) = 1;
    0x0040bddd mov al, 1                                                                                                                                                                     |         al = 1;
                                                                                                                                                                                             | label_1:
    0x0040bddf mov esi, ecx                                                                                                                                                                  |         esi = ecx;
    0x0040bde1 and esi, 0xffffff00                                                                                                                                                           |         esi &= 0xffffff00;
    0x0040bde7 mov edx, ecx                                                                                                                                                                  |         edx = ecx;
    0x0040bde9 and edx, 0xffff0000                                                                                                                                                           |         edx &= 0xffff0000;
    0x0040bdef mov edi, ecx                                                                                                                                                                  |         edi = ecx;
    0x0040bdf1 and edi, 0xff000000                                                                                                                                                           |         edi &= 0xff000000;
    0x0040bdf7 test al, al                                                                                                                                                                   |         
                                                                                                                                                                                             |         if (al != 0) {
    0x0040bdf9 jne 0x40be6e                                                                                                                                                                  |             goto label_6;
                                                                                                                                                                                             |         }
    0x0040bdfb jmp 0x40bf98                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040be00 mov r15, qword [rax + 8]                                                                                                                                                      |     r15 = *((rax + 8));
    0x0040be04 mov rsi, qword [rax + 0x10]                                                                                                                                                   |     rsi = *((rax + 0x10));
    0x0040be08 mov rcx, rsi                                                                                                                                                                  |     rcx = *((rax + 0x10));
    0x0040be0b sub rcx, 0xfffffffffffffffc                                                                                                                                                   |     rcx -= 0xfffffffffffffffc;
    0x0040be0f mov qword [rax + 0x10], rcx                                                                                                                                                   |     *((rax + 0x10)) = rcx;
                                                                                                                                                                                             |     if (rcx >= 0) {
    0x0040be13 jae 0x40bfbd                                                                                                                                                                  |         goto label_7;
                                                                                                                                                                                             |     }
    0x0040be19 cmp rcx, r15                                                                                                                                                                  |     
                                                                                                                                                                                             |     if (rcx > r15) {
    0x0040be1c ja 0x40bfbd                                                                                                                                                                   |         goto label_7;
                                                                                                                                                                                             |     }
    0x0040be22 mov rax, qword [rax]                                                                                                                                                          |     rax = *(rax);
    0x0040be25 mov ecx, dword [rax + rsi]                                                                                                                                                    |     ecx = *((rax + rsi));
    0x0040be28 mov edx, ecx                                                                                                                                                                  |     edx = *((rax + rsi));
    0x0040be2a shr edx, 8                                                                                                                                                                    |     edx >>= 8;
    0x0040be2d mov esi, ecx                                                                                                                                                                  |     esi = ecx;
    0x0040be2f shr esi, 0x10                                                                                                                                                                 |     esi >>= 0x10;
    0x0040be32 mov ebp, ecx                                                                                                                                                                  |     
    0x0040be34 shr ebp, 0x18                                                                                                                                                                 |     ebp >>= 0x18;
                                                                                                                                                                                             | label_2:
    0x0040be37 mov byte [rbx + 8], 1                                                                                                                                                         |     *((rbx + 8)) = 1;
    0x0040be3b mov al, 1                                                                                                                                                                     |     al = 1;
                                                                                                                                                                                             | label_3:
    0x0040be3d movzx edi, cl                                                                                                                                                                 |     edi = (int32_t) cl;
    0x0040be40 shl edi, 0x18                                                                                                                                                                 |     edi <<= 0x18;
    0x0040be43 movzx edx, dl                                                                                                                                                                 |     edx = (int32_t) dl;
    0x0040be46 shl edx, 0x10                                                                                                                                                                 |     edx <<= 0x10;
    0x0040be49 or edx, edi                                                                                                                                                                   |     edx |= edi;
    0x0040be4b movzx esi, sil                                                                                                                                                                |     esi = (int32_t) sil;
    0x0040be4f shl esi, 8                                                                                                                                                                    |     esi <<= 8;
    0x0040be52 movzx ecx, bpl                                                                                                                                                                |     ecx = (int32_t) bpl;
    0x0040be56 and edx, 0x7fff0000                                                                                                                                                           |     edx &= 0x7fff0000;
    0x0040be5c or esi, edx                                                                                                                                                                   |     esi |= edx;
    0x0040be5e or ecx, esi                                                                                                                                                                   |     ecx |= esi;
    0x0040be60 and edi, 0x7f000000                                                                                                                                                           |     edi &= 0x7f000000;
    0x0040be66 test al, al                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (al == 0) {
    0x0040be68 je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
                                                                                                                                                                                             | label_6:
    0x0040be6e and edx, 0xff0000                                                                                                                                                             |     edx &= 0xff0000;
    0x0040be74 or edx, edi                                                                                                                                                                   |     edx |= edi;
    0x0040be76 and esi, 0xff00                                                                                                                                                               |     esi &= 0xff00;
    0x0040be7c movzx r13d, cl                                                                                                                                                                |     r13d = (int32_t) cl;
    0x0040be80 or r13d, esi                                                                                                                                                                  |     r13d |= esi;
    0x0040be83 or r13d, edx                                                                                                                                                                  |     r13d |= edx;
    0x0040be86 cmp r13d, 0x1000000                                                                                                                                                           |     
    0x0040be8d mov r12d, 0x1000000                                                                                                                                                           |     r12d = 0x1000000;
                                                                                                                                                                                             |     if (r13d < 0x1000000) {
    0x0040be93 cmovl r12d, r13d                                                                                                                                                              |         r12d = r13d;
                                                                                                                                                                                             |     }
    0x0040be97 cmp r12d, 0xffffffff                                                                                                                                                          |     
                                                                                                                                                                                             |     if (r12d == 0xffffffff) {
    0x0040be9b je 0x40bfaa                                                                                                                                                                   |         goto label_8;
                                                                                                                                                                                             |     }
    0x0040bea1 movsxd r15, r12d                                                                                                                                                              |     r15 = (int64_t) r12d;
    0x0040bea4 mov rdi, r14                                                                                                                                                                  |     
    0x0040bea7 mov rsi, r15                                                                                                                                                                  |     
    0x0040beaa xor edx, edx                                                                                                                                                                  |     
    0x0040beac call 0x411030                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r15, 0);
    0x0040beb1 test r13d, r13d                                                                                                                                                               |     
                                                                                                                                                                                             |     if (r13d == 0) {
    0x0040beb4 je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040beba cmp qword [r14 + 0x20], 0x17                                                                                                                                                  |     
    0x0040bebf mov r8, r14                                                                                                                                                                   |     r8 = r14;
                                                                                                                                                                                             |     if (*((r14 + 0x20)) != 0x17) {
    0x0040bec2 je 0x40bec7                                                                                                                                                                   |         
    0x0040bec4 mov r8, qword [r14]                                                                                                                                                           |         r8 = *(r14);
                                                                                                                                                                                             |     }
    0x0040bec7 cmp byte [rbx + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((rbx + 8)) == 0) {
    0x0040becb je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bed1 mov esi, r12d                                                                                                                                                                 |     esi = r12d;
    0x0040bed4 mov al, 1                                                                                                                                                                     |     al = 1;
    0x0040bed6 xor edx, edx                                                                                                                                                                  |     edx = 0;
    0x0040bed8 nop dword [rax + rax]                                                                                                                                                         |     
                                                                                                                                                                                             |     do {
    0x0040bee0 test al, al                                                                                                                                                                   |         
                                                                                                                                                                                             |         if (al != 0) {
    0x0040bee2 je 0x40bf0c                                                                                                                                                                   |             
    0x0040bee4 mov byte [rbx + 8], 0                                                                                                                                                         |             *((rbx + 8)) = 0;
    0x0040bee8 mov rax, qword [rbx]                                                                                                                                                          |             rax = *(rbx);
    0x0040beeb mov rdi, qword [rax + 0x10]                                                                                                                                                   |             rdi = *((rax + 0x10));
    0x0040beef cmp rdi, qword [rax + 8]                                                                                                                                                      |             
                                                                                                                                                                                             |             if (rdi >= *((rax + 8))) {
    0x0040bef3 jae 0x40bf0c                                                                                                                                                                  |                 goto label_9;
                                                                                                                                                                                             |             }
    0x0040bef5 mov rbp, qword [rax]                                                                                                                                                          |             rbp = *(rax);
    0x0040bef8 movzx ecx, byte [rbp + rdi]                                                                                                                                                   |             ecx = *((rbp + rdi));
    0x0040befd inc rdi                                                                                                                                                                       |             rdi++;
    0x0040bf00 mov qword [rax + 0x10], rdi                                                                                                                                                   |             *((rax + 0x10)) = rdi;
    0x0040bf04 mov byte [rbx + 8], 1                                                                                                                                                         |             *((rbx + 8)) = 1;
    0x0040bf08 mov byte [r8 + rdx], cl                                                                                                                                                       |             *((r8 + rdx)) = cl;
                                                                                                                                                                                             |         }
                                                                                                                                                                                             | label_9:
    0x0040bf0c movzx eax, byte [rbx + 8]                                                                                                                                                     |         eax = *((rbx + 8));
    0x0040bf10 inc rdx                                                                                                                                                                       |         rdx++;
    0x0040bf13 cmp rsi, rdx                                                                                                                                                                  |         
    0x0040bf16 jne 0x40bee0                                                                                                                                                                  |         
                                                                                                                                                                                             |     } while (rsi != rdx);
    0x0040bf18 cmp r13d, 0x1000001                                                                                                                                                           |     
                                                                                                                                                                                             |     if (r13d < 0x1000001) {
    0x0040bf1f jl 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf21 test al, al                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (al == 0) {
    0x0040bf23 je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf25 mov esi, r13d                                                                                                                                                                 |     
    0x0040bf28 mov rdi, r14                                                                                                                                                                  |     
    0x0040bf2b xor edx, edx                                                                                                                                                                  |     
    0x0040bf2d call 0x411030                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x0040bf32 cmp qword [r14 + 0x20], 0x17                                                                                                                                                  |     
                                                                                                                                                                                             |     if (*((r14 + 0x20)) != 0x17) {
    0x0040bf37 je 0x40bf3c                                                                                                                                                                   |         
    0x0040bf39 mov r14, qword [r14]                                                                                                                                                          |         r14 = *(r14);
                                                                                                                                                                                             |     }
    0x0040bf3c sub r13d, r12d                                                                                                                                                                |     r13d -= r12d;
                                                                                                                                                                                             |     if (r13d == 0) {
    0x0040bf3f je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf41 cmp byte [rbx + 8], 0                                                                                                                                                         |     
                                                                                                                                                                                             |     if (*((rbx + 8)) == 0) {
    0x0040bf45 je 0x40bf98                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                             |     }
    0x0040bf47 add r14, r15                                                                                                                                                                  |     r14 += r15;
    0x0040bf4a mov ebp, r13d                                                                                                                                                                 |     
    0x0040bf4d dec rbp                                                                                                                                                                       |     rbp--;
    0x0040bf50 mov dl, 1                                                                                                                                                                     |     dl = 1;
    0x0040bf52 xor ecx, ecx                                                                                                                                                                  |     ecx = 0;
    0x0040bf54 test dl, dl                                                                                                                                                                   |     
                                                                                                                                                                                             |     if (dl == 0) {
    0x0040bf56 je 0x40bf86                                                                                                                                                                   |         goto label_0;
                                                                                                                                                                                             |     }
    0x0040bf58 nop dword [rax + rax]                                                                                                                                                         |     
                                                                                                                                                                                             |     do {
    0x0040bf60 mov byte [rbx + 8], 0                                                                                                                                                         |         *((rbx + 8)) = 0;
    0x0040bf64 mov rdx, qword [rbx]                                                                                                                                                          |         rdx = *(rbx);
    0x0040bf67 mov rsi, qword [rdx + 0x10]                                                                                                                                                   |         rsi = *((rdx + 0x10));
    0x0040bf6b cmp rsi, qword [rdx + 8]                                                                                                                                                      |         
                                                                                                                                                                                             |         if (rsi < *((rdx + 8))) {
    0x0040bf6f jae 0x40bf86                                                                                                                                                                  |             
    0x0040bf71 mov rdi, qword [rdx]                                                                                                                                                          |             rdi = *(rdx);
    0x0040bf74 mov al, byte [rdi + rsi]                                                                                                                                                      |             al = *((rdi + rsi));
    0x0040bf77 inc rsi                                                                                                                                                                       |             rsi++;
    0x0040bf7a mov qword [rdx + 0x10], rsi                                                                                                                                                   |             *((rdx + 0x10)) = rsi;
    0x0040bf7e mov byte [rbx + 8], 1                                                                                                                                                         |             *((rbx + 8)) = 1;
    0x0040bf82 mov byte [r14 + rcx], al                                                                                                                                                      |             *((r14 + rcx)) = al;
                                                                                                                                                                                             |         }
                                                                                                                                                                                             | label_0:
    0x0040bf86 cmp rbp, rcx                                                                                                                                                                  |         
                                                                                                                                                                                             |         if (rbp == rcx) {
    0x0040bf89 je 0x40bf98                                                                                                                                                                   |             goto label_4;
                                                                                                                                                                                             |         }
    0x0040bf8b movzx edx, byte [rbx + 8]                                                                                                                                                     |         edx = *((rbx + 8));
    0x0040bf8f inc rcx                                                                                                                                                                       |         rcx++;
    0x0040bf92 test dl, dl                                                                                                                                                                   |         
    0x0040bf94 jne 0x40bf60                                                                                                                                                                  |         
                                                                                                                                                                                             |     } while (dl != 0);
    0x0040bf96 jmp 0x40bf86                                                                                                                                                                  |     goto label_0;
                                                                                                                                                                                             | label_4:
    0x0040bf98 mov rax, rbx                                                                                                                                                                  |     rax = rbx;
    0x0040bf9b add rsp, 8                                                                                                                                                                    |     
    0x0040bf9f pop rbx                                                                                                                                                                       |     
    0x0040bfa0 pop r12                                                                                                                                                                       |     
    0x0040bfa2 pop r13                                                                                                                                                                       |     
    0x0040bfa4 pop r14                                                                                                                                                                       |     
    0x0040bfa6 pop r15                                                                                                                                                                       |     
    0x0040bfa8 pop rbp                                                                                                                                                                       |     
    0x0040bfa9 ret                                                                                                                                                                           |     return rax;
                                                                                                                                                                                             | label_8:
    0x0040bfaa mov edi, 0x434bde                                                                                                                                                             |     
    0x0040bfaf call 0x40e6d0                                                                                                                                                                 |     eax = BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                             | label_5:
    0x0040bfb4 xor eax, eax                                                                                                                                                                  |     eax = 0;
    0x0040bfb6 xor ecx, ecx                                                                                                                                                                  |     ecx = 0;
    0x0040bfb8 jmp 0x40bddf                                                                                                                                                                  |     goto label_1;
                                                                                                                                                                                             | label_7:
    0x0040bfbd mov qword [rax + 0x10], r15                                                                                                                                                   |     *((rax + 0x10)) = r15;
    0x0040bfc1 sub r15, rsi                                                                                                                                                                  |     r15 -= rsi;
    0x0040bfc4 add rsi, qword [rax]                                                                                                                                                          |     rsi += *(rax);
    0x0040bfc7 lea rdi, [rsp + 4]                                                                                                                                                            |     
    0x0040bfcc mov rdx, r15                                                                                                                                                                  |     
    0x0040bfcf call 0x404250                                                                                                                                                                 |     memcpy (rsp + 4, rsi, r15);
    0x0040bfd4 cmp r15, 4                                                                                                                                                                    |     
                                                                                                                                                                                             |     if (r15 == 4) {
    0x0040bfd8 jne 0x40bff1                                                                                                                                                                  |         
    0x0040bfda mov cl, byte [rsp + 4]                                                                                                                                                        |         cl = *((rsp + 4));
    0x0040bfde mov dl, byte [rsp + 5]                                                                                                                                                        |         dl = *((rsp + 5));
    0x0040bfe2 mov sil, byte [rsp + 6]                                                                                                                                                       |         sil = *((rsp + 6));
    0x0040bfe7 mov bpl, byte [rsp + 7]                                                                                                                                                       |         bpl = *((rsp + 7));
    0x0040bfec jmp 0x40be37                                                                                                                                                                  |         goto label_2;
                                                                                                                                                                                             |     }
    0x0040bff1 mov al, byte [rbx + 8]                                                                                                                                                        |     al = *((rbx + 8));
    0x0040bff4 jmp 0x40be3d                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                             | }