; assembly                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                     | /* bslx_streambufinstream.t/none @ 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_ch;
                                                                                                                                                                                                                     |     int64_t var_dh;
                                                                                                                                                                                                                     |     int64_t var_eh;
                                                                                                                                                                                                                     |     int64_t var_fh;
                                                                                                                                                                                                                     |     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 0x404bd5                                                                                                                                                                                           |         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 + 0xc]                                                                                                                                                                                  |         rsi = rsp + 0xc;
    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 + 0xd]                                                                                                                                                                           |             ecx = *((rsp + 0xd));
    0x004049f1 movzx esi, byte [rsp + 0xe]                                                                                                                                                                           |             esi = *((rsp + 0xe));
    0x004049f6 movzx edx, byte [rsp + 0xf]                                                                                                                                                                           |             edx = *((rsp + 0xf));
    0x004049fb movzx edi, byte [rsp + 0xc]                                                                                                                                                                           |             edi = *((rsp + 0xc));
    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 0x404bd5                                                                                                                                                                                          |         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 0x404be7                                                                                                                                                                                           |             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 0x404bd5                                                                                                                                                                                          |         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 0x404bd5                                                                                                                                                                                           |             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 0x404bee                                                                                                                                                                                           |         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 0x404bd5                                                                                                                                                                                           |         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 0x404bd5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404af4 mov qword [rsp + 0x10], r14                                                                                                                                                                           |     *((rsp + 0x10)) = r14;
    0x00404af9 mov al, 1                                                                                                                                                                                             |     al = 1;
    0x00404afb xor r14d, r14d                                                                                                                                                                                        |     r14d = 0;
    0x00404afe jmp 0x404b20                                                                                                                                                                                          |     goto label_10;
                                                                                                                                                                                                                     | label_0:
    0x00404b00 lea rcx, [rax + 1]                                                                                                                                                                                    |     rcx = rax + 1;
    0x00404b04 mov qword [rdi + 0x18], rcx                                                                                                                                                                           |     *((rdi + 0x18)) = rcx;
    0x00404b08 movzx eax, byte [rax]                                                                                                                                                                                 |     eax = *(rax);
                                                                                                                                                                                                                     | label_1:
    0x00404b0b mov byte [rbx + 8], 1                                                                                                                                                                                 |     *((rbx + 8)) = 1;
    0x00404b0f mov byte [rbp + r14], al                                                                                                                                                                              |     *((rbp + r14)) = al;
                                                                                                                                                                                                                     |     do {
                                                                                                                                                                                                                     | label_2:
    0x00404b14 movzx eax, byte [rbx + 8]                                                                                                                                                                             |         eax = *((rbx + 8));
    0x00404b18 inc r14                                                                                                                                                                                               |         r14++;
    0x00404b1b cmp r15, r14                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |         if (r15 == r14) {
    0x00404b1e je 0x404b42                                                                                                                                                                                           |             goto label_11;
                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                     | label_10:
    0x00404b20 test al, al                                                                                                                                                                                           |         
    0x00404b22 je 0x404b14                                                                                                                                                                                           |         
                                                                                                                                                                                                                     |     } while (al == 0);
    0x00404b24 mov byte [rbx + 8], 0                                                                                                                                                                                 |     *((rbx + 8)) = 0;
    0x00404b28 mov rdi, qword [rbx]                                                                                                                                                                                  |     rdi = *(rbx);
    0x00404b2b mov rax, qword [rdi + 0x18]                                                                                                                                                                           |     rax = *((rdi + 0x18));
    0x00404b2f cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (rax != *((rdi + 0x20))) {
    0x00404b33 jne 0x404b00                                                                                                                                                                                          |         goto label_0;
                                                                                                                                                                                                                     |     }
    0x00404b35 mov rax, qword [rdi]                                                                                                                                                                                  |     rax = *(rdi);
    0x00404b38 call qword [rax + 0x50]                                                                                                                                                                               |     eax = uint64_t (*rax + 0x50)() ();
    0x00404b3b cmp eax, 0xffffffff                                                                                                                                                                                   |     
                                                                                                                                                                                                                     |     if (eax != 0xffffffff) {
    0x00404b3e jne 0x404b0b                                                                                                                                                                                          |         goto label_1;
                                                                                                                                                                                                                     |     }
    0x00404b40 jmp 0x404b14                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                     | label_11:
    0x00404b42 cmp r13d, 0x1000001                                                                                                                                                                                   |     
    0x00404b49 mov r14, qword [rsp + 0x10]                                                                                                                                                                           |     r14 = *((rsp + 0x10));
                                                                                                                                                                                                                     |     if (r13d < 0x1000001) {
    0x00404b4e jl 0x404bd5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b54 test al, al                                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (al == 0) {
    0x00404b56 je 0x404bd5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b5c mov esi, r13d                                                                                                                                                                                         |     
    0x00404b5f mov rdi, r14                                                                                                                                                                                          |     
    0x00404b62 xor edx, edx                                                                                                                                                                                          |     
    0x00404b64 call 0x408160                                                                                                                                                                                         |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x00404b69 cmp qword [r14 + 0x20], 0x17                                                                                                                                                                          |     
                                                                                                                                                                                                                     |     if (*((r14 + 0x20)) != 0x17) {
    0x00404b6e je 0x404b73                                                                                                                                                                                           |         
    0x00404b70 mov r14, qword [r14]                                                                                                                                                                                  |         r14 = *(r14);
                                                                                                                                                                                                                     |     }
    0x00404b73 cmp r13d, r12d                                                                                                                                                                                        |     
                                                                                                                                                                                                                     |     if (r13d == r12d) {
    0x00404b76 je 0x404bd5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b78 cmp byte [rbx + 8], 0                                                                                                                                                                                 |     
                                                                                                                                                                                                                     |     if (*((rbx + 8)) == 0) {
    0x00404b7c je 0x404bd5                                                                                                                                                                                           |         goto label_5;
                                                                                                                                                                                                                     |     }
    0x00404b7e movsxd rbp, r13d                                                                                                                                                                                      |     rbp = (int64_t) r13d;
    0x00404b81 dec rbp                                                                                                                                                                                               |     rbp--;
    0x00404b84 mov al, 1                                                                                                                                                                                             |     al = 1;
    0x00404b86 test al, al                                                                                                                                                                                           |     
                                                                                                                                                                                                                     |     if (al == 0) {
    0x00404b88 je 0x404bc3                                                                                                                                                                                           |         goto label_3;
                                                                                                                                                                                                                     |     }
    0x00404b8a nop word [rax + rax]                                                                                                                                                                                  |     
                                                                                                                                                                                                                     |     do {
    0x00404b90 mov byte [rbx + 8], 0                                                                                                                                                                                 |         *((rbx + 8)) = 0;
    0x00404b94 mov rdi, qword [rbx]                                                                                                                                                                                  |         rdi = *(rbx);
    0x00404b97 mov rax, qword [rdi + 0x18]                                                                                                                                                                           |         rax = *((rdi + 0x18));
    0x00404b9b cmp rax, qword [rdi + 0x20]                                                                                                                                                                           |         
                                                                                                                                                                                                                     |         if (rax != *((rdi + 0x20))) {
    0x00404b9f je 0x404bb0                                                                                                                                                                                           |             
    0x00404ba1 lea rcx, [rax + 1]                                                                                                                                                                                    |             rcx = rax + 1;
    0x00404ba5 mov qword [rdi + 0x18], rcx                                                                                                                                                                           |             *((rdi + 0x18)) = rcx;
    0x00404ba9 movzx eax, byte [rax]                                                                                                                                                                                 |             eax = *(rax);
    0x00404bac jmp 0x404bbb                                                                                                                                                                                          |             
                                                                                                                                                                                                                     |         } else {
    0x00404bb0 mov rax, qword [rdi]                                                                                                                                                                                  |             rax = *(rdi);
    0x00404bb3 call qword [rax + 0x50]                                                                                                                                                                               |             eax = uint64_t (*rax + 0x50)() ();
    0x00404bb6 cmp eax, 0xffffffff                                                                                                                                                                                   |             
                                                                                                                                                                                                                     |             if (eax == 0xffffffff) {
    0x00404bb9 je 0x404bc3                                                                                                                                                                                           |                 goto label_3;
                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                     |         }
    0x00404bbb mov byte [rbx + 8], 1                                                                                                                                                                                 |         *((rbx + 8)) = 1;
    0x00404bbf mov byte [r14 + r15], al                                                                                                                                                                              |         *((r14 + r15)) = al;
                                                                                                                                                                                                                     | label_3:
    0x00404bc3 cmp rbp, r15                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |         if (rbp == r15) {
    0x00404bc6 je 0x404bd5                                                                                                                                                                                           |             goto label_5;
                                                                                                                                                                                                                     |         }
    0x00404bc8 movzx eax, byte [rbx + 8]                                                                                                                                                                             |         eax = *((rbx + 8));
    0x00404bcc inc r15                                                                                                                                                                                               |         r15++;
    0x00404bcf test al, al                                                                                                                                                                                           |         
    0x00404bd1 jne 0x404b90                                                                                                                                                                                          |         
                                                                                                                                                                                                                     |     } while (al != 0);
    0x00404bd3 jmp 0x404bc3                                                                                                                                                                                          |     goto label_3;
                                                                                                                                                                                                                     | label_5:
    0x00404bd5 mov rax, rbx                                                                                                                                                                                          |     rax = rbx;
    0x00404bd8 add rsp, 0x18                                                                                                                                                                                         |     
    0x00404bdc pop rbx                                                                                                                                                                                               |     
    0x00404bdd pop r12                                                                                                                                                                                               |     
    0x00404bdf pop r13                                                                                                                                                                                               |     
    0x00404be1 pop r14                                                                                                                                                                                               |     
    0x00404be3 pop r15                                                                                                                                                                                               |     
    0x00404be5 pop rbp                                                                                                                                                                                               |     
    0x00404be6 ret                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                     | label_8:
    0x00404be7 xor edx, edx                                                                                                                                                                                          |     edx = 0;
    0x00404be9 jmp 0x404a5c                                                                                                                                                                                          |     goto label_4;
                                                                                                                                                                                                                     | label_9:
    0x00404bee mov edi, 0x410aeb                                                                                                                                                                                     |     
    0x00404bf3 call 0x405800                                                                                                                                                                                         |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                                                     | }