; assembly                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                     | /* bslx_streambufinstream.t/assume @ 0x404970 */
                                                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bslx::GenericInStream_std::__1::basic_streambuf_char__std::__1::char_traits_char_____.getString_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char____ ()      | int64_t method_BloombergLP::bslx::GenericInStream_std::_1::basic_streambuf_char_std::_1::char_traits_char_getString_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_ (int64_t arg2, uint32_t arg1) {
                                                                                                                                                                                                                     |     int64_t var_18h;
                                                                                                                                                                                                                     |     int64_t var_4h;
                                                                                                                                                                                                                     |     int64_t var_5h;
                                                                                                                                                                                                                     |     int64_t var_6h;
                                                                                                                                                                                                                     |     int64_t var_7h;
                                                                                                                                                                                                                     |     int64_t var_8h;
                                                                                                                                                                                                                     |     int64_t var_10h;
                                                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                     |     /* BloombergLP::bslx::GenericInStream<std::__1::basic_streambuf<char, std::__1::char_traits<char> > >::getString(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >&) */
    0x00404970 push rbp                                                                                                                                                                                              |     
    0x00404971 push r15                                                                                                                                                                                              |     
    0x00404973 push r14                                                                                                                                                                                              |     
    0x00404975 push r13                                                                                                                                                                                              |     
    0x00404977 push r12                                                                                                                                                                                              |     
    0x00404979 push rbx                                                                                                                                                                                              |     
    0x0040497a sub rsp, 0x18                                                                                                                                                                                         |     
    0x0040497e mov rbx, rdi                                                                                                                                                                                          |     rbx = rdi;
    0x00404981 cmp byte [rdi + 8], 0                                                                                                                                                                                 |     
                                                                                                                                                                                                                     |     if (*((rdi + 8)) == 0) {
    0x00404985 je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x0040498b mov r14, rsi                                                                                                                                                                                          |     r14 = rsi;
    0x0040498e mov byte [rbx + 8], 0                                                                                                                                                                                 |     *((rbx + 8)) = 0;
    0x00404992 mov rdi, qword [rbx]                                                                                                                                                                                  |     rdi = *(rbx);
    0x00404995 mov rax, qword [rdi + 0x18]                                                                                                                                                                           |     rax = *((rdi + 0x18));
    0x00404999 cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (rax != *((rdi + 0x20))) {
    0x0040499d je 0x4049a4                                                                                                                                                                                           |         
    0x0040499f movzx eax, byte [rax]                                                                                                                                                                                 |         eax = *(rax);
    0x004049a2 jmp 0x4049b3                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |     } else {
    0x004049a4 mov rax, qword [rdi]                                                                                                                                                                                  |         rax = *(rdi);
    0x004049a7 call qword [rax + 0x48]                                                                                                                                                                               |         eax = uint64_t (*rax + 0x48)() ();
    0x004049aa cmp eax, 0xffffffff                                                                                                                                                                                   |         
                                                                                                                                                                                                                     |         if (eax == 0xffffffff) {
    0x004049ad je 0x404a7f                                                                                                                                                                                           |             goto label_6;
                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                     |     }
    0x004049b3 mov byte [rbx + 8], 0                                                                                                                                                                                 |     *((rbx + 8)) = 0;
    0x004049b7 cmp eax, 0x80                                                                                                                                                                                         |     
                                                                                                                                                                                                                     |     if (eax >= 0x80) {
    0x004049bc jl 0x404a2c                                                                                                                                                                                           |         
    0x004049be mov rdi, qword [rbx]                                                                                                                                                                                  |         rdi = *(rbx);
    0x004049c1 mov rax, qword [rdi]                                                                                                                                                                                  |         rax = *(rdi);
    0x004049c4 lea rsi, [rsp + 4]                                                                                                                                                                                    |         rsi = rsp + 4;
    0x004049c9 mov edx, 4                                                                                                                                                                                            |         edx = 4;
    0x004049ce call qword [rax + 0x40]                                                                                                                                                                               |         rax = uint64_t (*rax + 0x40)() ();
    0x004049d1 xor edi, edi                                                                                                                                                                                          |         edi = 0;
    0x004049d3 mov ecx, 0                                                                                                                                                                                            |         ecx = 0;
    0x004049d8 mov esi, 0                                                                                                                                                                                            |         esi = 0;
    0x004049dd mov edx, 0                                                                                                                                                                                            |         edx = 0;
    0x004049e2 cmp rax, 4                                                                                                                                                                                            |         
                                                                                                                                                                                                                     |         if (rax == 4) {
    0x004049e6 jne 0x404a09                                                                                                                                                                                          |             
    0x004049e8 mov byte [rbx + 8], 1                                                                                                                                                                                 |             *((rbx + 8)) = 1;
    0x004049ec movzx ecx, byte [rsp + 5]                                                                                                                                                                             |             ecx = *((rsp + 5));
    0x004049f1 movzx esi, byte [rsp + 6]                                                                                                                                                                             |             esi = *((rsp + 6));
    0x004049f6 movzx edx, byte [rsp + 7]                                                                                                                                                                             |             edx = *((rsp + 7));
    0x004049fb movzx edi, byte [rsp + 4]                                                                                                                                                                             |             edi = *((rsp + 4));
    0x00404a00 shl edi, 0x18                                                                                                                                                                                         |             edi <<= 0x18;
    0x00404a03 shl ecx, 0x10                                                                                                                                                                                         |             ecx <<= 0x10;
    0x00404a06 shl esi, 8                                                                                                                                                                                            |             esi <<= 8;
                                                                                                                                                                                                                     |         }
    0x00404a09 or ecx, edi                                                                                                                                                                                           |         ecx |= edi;
    0x00404a0b or esi, ecx                                                                                                                                                                                           |         esi |= ecx;
    0x00404a0d and esi, 0x7fffff00                                                                                                                                                                                   |         esi &= 0x7fffff00;
    0x00404a13 or edx, esi                                                                                                                                                                                           |         edx |= esi;
    0x00404a15 and ecx, 0x7fff0000                                                                                                                                                                                   |         ecx &= 0x7fff0000;
    0x00404a1b and edi, 0x7f000000                                                                                                                                                                                   |         edi &= 0x7f000000;
    0x00404a21 cmp byte [rbx + 8], 0                                                                                                                                                                                 |         
                                                                                                                                                                                                                     |         if (*((rbx + 8)) != 0) {
    0x00404a25 jne 0x404a91                                                                                                                                                                                          |             goto label_7;
                                                                                                                                                                                                                     |         }
    0x00404a27 jmp 0x404be5                                                                                                                                                                                          |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404a2c mov rdi, qword [rbx]                                                                                                                                                                                  |     rdi = *(rbx);
    0x00404a2f mov rax, qword [rdi + 0x18]                                                                                                                                                                           |     rax = *((rdi + 0x18));
    0x00404a33 cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (rax != *((rdi + 0x20))) {
    0x00404a37 je 0x404a46                                                                                                                                                                                           |         
    0x00404a39 lea rcx, [rax + 1]                                                                                                                                                                                    |         rcx = rax + 1;
    0x00404a3d mov qword [rdi + 0x18], rcx                                                                                                                                                                           |         *((rdi + 0x18)) = rcx;
    0x00404a41 movzx eax, byte [rax]                                                                                                                                                                                 |         eax = *(rax);
    0x00404a44 jmp 0x404a55                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |     } else {
    0x00404a46 mov rax, qword [rdi]                                                                                                                                                                                  |         rax = *(rdi);
    0x00404a49 call qword [rax + 0x50]                                                                                                                                                                               |         eax = uint64_t (*rax + 0x50)() ();
    0x00404a4c cmp eax, 0xffffffff                                                                                                                                                                                   |         
                                                                                                                                                                                                                     |         if (eax == 0xffffffff) {
    0x00404a4f je 0x404bf7                                                                                                                                                                                           |             goto label_8;
                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                     |     }
    0x00404a55 mov byte [rbx + 8], 1                                                                                                                                                                                 |     *((rbx + 8)) = 1;
    0x00404a59 movsx edx, al                                                                                                                                                                                         |     edx = (int32_t) al;
                                                                                                                                                                                                                     | label_4:
    0x00404a5c mov esi, edx                                                                                                                                                                                          |     esi = edx;
    0x00404a5e and esi, 0xffffff00                                                                                                                                                                                   |     esi &= 0xffffff00;
    0x00404a64 mov ecx, edx                                                                                                                                                                                          |     ecx = edx;
    0x00404a66 and ecx, 0xffff0000                                                                                                                                                                                   |     ecx &= 0xffff0000;
    0x00404a6c mov edi, edx                                                                                                                                                                                          |     edi = edx;
    0x00404a6e and edi, 0xff000000                                                                                                                                                                                   |     edi &= 0xff000000;
    0x00404a74 cmp byte [rbx + 8], 0                                                                                                                                                                                 |     
                                                                                                                                                                                                                     |     if (*((rbx + 8)) == 0) {
    0x00404a78 jne 0x404a91                                                                                                                                                                                          |         
    0x00404a7a jmp 0x404be5                                                                                                                                                                                          |         goto label_5;
                                                                                                                                                                                                                     | label_6:
    0x00404a7f xor edi, edi                                                                                                                                                                                          |         edi = 0;
    0x00404a81 xor ecx, ecx                                                                                                                                                                                          |         ecx = 0;
    0x00404a83 xor esi, esi                                                                                                                                                                                          |         esi = 0;
    0x00404a85 xor edx, edx                                                                                                                                                                                          |         edx = 0;
    0x00404a87 cmp byte [rbx + 8], 0                                                                                                                                                                                 |         
                                                                                                                                                                                                                     |         if (*((rbx + 8)) == 0) {
    0x00404a8b je 0x404be5                                                                                                                                                                                           |             goto label_5;
                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                     | label_7:
    0x00404a91 and ecx, 0xff0000                                                                                                                                                                                     |     ecx &= 0xff0000;
    0x00404a97 or ecx, edi                                                                                                                                                                                           |     ecx |= edi;
    0x00404a99 and esi, 0xff00                                                                                                                                                                                       |     esi &= 0xff00;
    0x00404a9f movzx r13d, dl                                                                                                                                                                                        |     r13d = (int32_t) dl;
    0x00404aa3 or r13d, esi                                                                                                                                                                                          |     r13d |= esi;
    0x00404aa6 or r13d, ecx                                                                                                                                                                                          |     r13d |= ecx;
    0x00404aa9 cmp r13d, 0x1000000                                                                                                                                                                                   |     
    0x00404ab0 mov r12d, 0x1000000                                                                                                                                                                                   |     r12d = 0x1000000;
                                                                                                                                                                                                                     |     if (r13d < 0x1000000) {
    0x00404ab6 cmovl r12d, r13d                                                                                                                                                                                      |         r12d = r13d;
                                                                                                                                                                                                                     |     }
    0x00404aba cmp r12d, 0xffffffff                                                                                                                                                                                  |     
                                                                                                                                                                                                                     |     if (r12d == 0xffffffff) {
    0x00404abe je 0x404bfe                                                                                                                                                                                           |         goto label_9;
                                                                                                                                                                                                                     |     }
    0x00404ac4 movsxd r15, r12d                                                                                                                                                                                      |     r15 = (int64_t) r12d;
    0x00404ac7 mov rdi, r14                                                                                                                                                                                          |     
    0x00404aca mov rsi, r15                                                                                                                                                                                          |     
    0x00404acd xor edx, edx                                                                                                                                                                                          |     
    0x00404acf call 0x408160                                                                                                                                                                                         |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r15, 0);
    0x00404ad4 test r13d, r13d                                                                                                                                                                                       |     
                                                                                                                                                                                                                     |     if (r13d == 0) {
    0x00404ad7 je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404add cmp qword [r14 + 0x20], 0x17                                                                                                                                                                          |     
    0x00404ae2 mov rbp, r14                                                                                                                                                                                          |     
                                                                                                                                                                                                                     |     if (*((r14 + 0x20)) != 0x17) {
    0x00404ae5 je 0x404aea                                                                                                                                                                                           |         
    0x00404ae7 mov rbp, qword [r14]                                                                                                                                                                                  |         rbp = *(r14);
                                                                                                                                                                                                                     |     }
    0x00404aea cmp byte [rbx + 8], 0                                                                                                                                                                                 |     
                                                                                                                                                                                                                     |     if (*((rbx + 8)) == 0) {
    0x00404aee je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404af4 mov qword [rsp + 8], r15                                                                                                                                                                              |     *((rsp + 8)) = r15;
    0x00404af9 mov qword [rsp + 0x10], r14                                                                                                                                                                           |     *((rsp + 0x10)) = r14;
    0x00404afe mov r15d, r12d                                                                                                                                                                                        |     r15d = r12d;
    0x00404b01 mov al, 1                                                                                                                                                                                             |     al = 1;
    0x00404b03 xor r14d, r14d                                                                                                                                                                                        |     r14d = 0;
    0x00404b06 jmp 0x404b30                                                                                                                                                                                          |     goto label_10;
                                                                                                                                                                                                                     | label_0:
    0x00404b10 lea rcx, [rax + 1]                                                                                                                                                                                    |     rcx = rax + 1;
    0x00404b14 mov qword [rdi + 0x18], rcx                                                                                                                                                                           |     *((rdi + 0x18)) = rcx;
    0x00404b18 movzx eax, byte [rax]                                                                                                                                                                                 |     eax = *(rax);
                                                                                                                                                                                                                     | label_1:
    0x00404b1b mov byte [rbx + 8], 1                                                                                                                                                                                 |     *((rbx + 8)) = 1;
    0x00404b1f mov byte [rbp + r14], al                                                                                                                                                                              |     *((rbp + r14)) = al;
                                                                                                                                                                                                                     |     do {
                                                                                                                                                                                                                     | label_2:
    0x00404b24 movzx eax, byte [rbx + 8]                                                                                                                                                                             |         eax = *((rbx + 8));
    0x00404b28 inc r14                                                                                                                                                                                               |         r14++;
    0x00404b2b cmp r15, r14                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |         if (r15 == r14) {
    0x00404b2e je 0x404b52                                                                                                                                                                                           |             goto label_11;
                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                     | label_10:
    0x00404b30 test al, al                                                                                                                                                                                           |         
    0x00404b32 je 0x404b24                                                                                                                                                                                           |         
                                                                                                                                                                                                                     |     } while (al == 0);
    0x00404b34 mov byte [rbx + 8], 0                                                                                                                                                                                 |     *((rbx + 8)) = 0;
    0x00404b38 mov rdi, qword [rbx]                                                                                                                                                                                  |     rdi = *(rbx);
    0x00404b3b mov rax, qword [rdi + 0x18]                                                                                                                                                                           |     rax = *((rdi + 0x18));
    0x00404b3f cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (rax != *((rdi + 0x20))) {
    0x00404b43 jne 0x404b10                                                                                                                                                                                          |         goto label_0;
                                                                                                                                                                                                                     |     }
    0x00404b45 mov rax, qword [rdi]                                                                                                                                                                                  |     rax = *(rdi);
    0x00404b48 call qword [rax + 0x50]                                                                                                                                                                               |     eax = uint64_t (*rax + 0x50)() ();
    0x00404b4b cmp eax, 0xffffffff                                                                                                                                                                                   |     
                                                                                                                                                                                                                     |     if (eax != 0xffffffff) {
    0x00404b4e jne 0x404b1b                                                                                                                                                                                          |         goto label_1;
                                                                                                                                                                                                                     |     }
    0x00404b50 jmp 0x404b24                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                     | label_11:
    0x00404b52 cmp r13d, 0x1000001                                                                                                                                                                                   |     
    0x00404b59 mov r14, qword [rsp + 0x10]                                                                                                                                                                           |     r14 = *((rsp + 0x10));
    0x00404b5e mov rbp, qword [rsp + 8]                                                                                                                                                                              |     rbp = *((rsp + 8));
                                                                                                                                                                                                                     |     if (r13d < 0x1000001) {
    0x00404b63 jl 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b69 test al, al                                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (al == 0) {
    0x00404b6b je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b6d mov esi, r13d                                                                                                                                                                                         |     
    0x00404b70 mov rdi, r14                                                                                                                                                                                          |     
    0x00404b73 xor edx, edx                                                                                                                                                                                          |     
    0x00404b75 call 0x408160                                                                                                                                                                                         |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x00404b7a cmp qword [r14 + 0x20], 0x17                                                                                                                                                                          |     
                                                                                                                                                                                                                     |     if (*((r14 + 0x20)) != 0x17) {
    0x00404b7f je 0x404b84                                                                                                                                                                                           |         
    0x00404b81 mov r14, qword [r14]                                                                                                                                                                                  |         r14 = *(r14);
                                                                                                                                                                                                                     |     }
    0x00404b84 sub r13d, r12d                                                                                                                                                                                        |     r13d -= r12d;
                                                                                                                                                                                                                     |     if (r13d == 0) {
    0x00404b87 je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b89 cmp byte [rbx + 8], 0                                                                                                                                                                                 |     
                                                                                                                                                                                                                     |     if (*((rbx + 8)) == 0) {
    0x00404b8d je 0x404be5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b8f add r14, rbp                                                                                                                                                                                          |     r14 += rbp;
    0x00404b92 mov r15d, r13d                                                                                                                                                                                        |     r15d = r13d;
    0x00404b95 dec r15                                                                                                                                                                                               |     r15--;
    0x00404b98 mov al, 1                                                                                                                                                                                             |     al = 1;
    0x00404b9a xor ebp, ebp                                                                                                                                                                                          |     ebp = 0;
    0x00404b9c test al, al                                                                                                                                                                                           |     
    0x00404b9e je 0x404bd3                                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     while (al != 0) {
    0x00404ba0 mov byte [rbx + 8], 0                                                                                                                                                                                 |         *((rbx + 8)) = 0;
    0x00404ba4 mov rdi, qword [rbx]                                                                                                                                                                                  |         rdi = *(rbx);
    0x00404ba7 mov rax, qword [rdi + 0x18]                                                                                                                                                                           |         rax = *((rdi + 0x18));
    0x00404bab cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |         
                                                                                                                                                                                                                     |         if (rax != *((rdi + 0x20))) {
    0x00404baf je 0x404bc0                                                                                                                                                                                           |             
    0x00404bb1 lea rcx, [rax + 1]                                                                                                                                                                                    |             rcx = rax + 1;
    0x00404bb5 mov qword [rdi + 0x18], rcx                                                                                                                                                                           |             *((rdi + 0x18)) = rcx;
    0x00404bb9 movzx eax, byte [rax]                                                                                                                                                                                 |             eax = *(rax);
    0x00404bbc jmp 0x404bcb                                                                                                                                                                                          |             
                                                                                                                                                                                                                     |         } else {
    0x00404bc0 mov rax, qword [rdi]                                                                                                                                                                                  |             rax = *(rdi);
    0x00404bc3 call qword [rax + 0x50]                                                                                                                                                                               |             eax = uint64_t (*rax + 0x50)() ();
    0x00404bc6 cmp eax, 0xffffffff                                                                                                                                                                                   |             
                                                                                                                                                                                                                     |             if (eax == 0xffffffff) {
    0x00404bc9 je 0x404bd3                                                                                                                                                                                           |                 goto label_3;
                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                     |         }
    0x00404bcb mov byte [rbx + 8], 1                                                                                                                                                                                 |         *((rbx + 8)) = 1;
    0x00404bcf mov byte [r14 + rbp], al                                                                                                                                                                              |         *((r14 + rbp)) = al;
                                                                                                                                                                                                                     | label_3:
    0x00404bd3 cmp r15, rbp                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |         if (r15 == rbp) {
    0x00404bd6 je 0x404be5                                                                                                                                                                                           |             goto label_5;
                                                                                                                                                                                                                     |         }
    0x00404bd8 movzx eax, byte [rbx + 8]                                                                                                                                                                             |         eax = *((rbx + 8));
    0x00404bdc inc rbp                                                                                                                                                                                               |         rbp++;
    0x00404bdf test al, al                                                                                                                                                                                           |         
    0x00404be1 jne 0x404ba0                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |     }
    0x00404be3 jmp 0x404bd3                                                                                                                                                                                          |     goto label_3;
                                                                                                                                                                                                                     | label_5:
    0x00404be5 mov rax, rbx                                                                                                                                                                                          |     rax = rbx;
    0x00404be8 add rsp, 0x18                                                                                                                                                                                         |     
    0x00404bec pop rbx                                                                                                                                                                                               |     
    0x00404bed pop r12                                                                                                                                                                                               |     
    0x00404bef pop r13                                                                                                                                                                                               |     
    0x00404bf1 pop r14                                                                                                                                                                                               |     
    0x00404bf3 pop r15                                                                                                                                                                                               |     
    0x00404bf5 pop rbp                                                                                                                                                                                               |     
    0x00404bf6 ret                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                     | label_8:
    0x00404bf7 xor edx, edx                                                                                                                                                                                          |     edx = 0;
    0x00404bf9 jmp 0x404a5c                                                                                                                                                                                          |     goto label_4;
                                                                                                                                                                                                                     | label_9:
    0x00404bfe mov edi, 0x410b0d                                                                                                                                                                                     |     
    0x00404c03 call 0x405800                                                                                                                                                                                         |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                                                     | }