; assembly                                                                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                                                                         | /* bslx_genericinstream.t/assume @ 0x434250 */
                                                                                                                                                                                                                                         | #include <stdint.h>
                                                                                                                                                                                                                                         |  
    ; (fcn) method.BloombergLP::bslx::GenericInStream_bsl::basic_stringbuf_char__std::__1::char_traits_char___bsl::allocator_char_____.getString_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char____ ()         | int64_t method_BloombergLP::bslx::GenericInStream_bsl::basic_stringbuf_char_std::_1::char_traits_char_bsl::allocator_char_getString_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_ (uint32_t arg2, uint32_t arg1) {
                                                                                                                                                                                                                                         |     int64_t var_4h;
                                                                                                                                                                                                                                         |     int64_t var_5h;
                                                                                                                                                                                                                                         |     int64_t var_6h;
                                                                                                                                                                                                                                         |     int64_t var_7h;
                                                                                                                                                                                                                                         |     int64_t var_8h;
                                                                                                                                                                                                                                         |     int64_t var_10h_2;
                                                                                                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                                                                                                         |     rdi = arg1;
                                                                                                                                                                                                                                         |     /* BloombergLP::bslx::GenericInStream<bsl::basic_stringbuf<char, std::__1::char_traits<char>, bsl::allocator<char> > >::getString(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >&) */
    0x00434250 push rbp                                                                                                                                                                                                                  |     
    0x00434251 push r15                                                                                                                                                                                                                  |     
    0x00434253 push r14                                                                                                                                                                                                                  |     
    0x00434255 push r13                                                                                                                                                                                                                  |     
    0x00434257 push r12                                                                                                                                                                                                                  |     
    0x00434259 push rbx                                                                                                                                                                                                                  |     
    0x0043425a sub rsp, 0x18                                                                                                                                                                                                             |     
    0x0043425e mov rbx, rdi                                                                                                                                                                                                              |     rbx = rdi;
    0x00434261 cmp byte [rdi + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rdi + 8)) == 0) {
    0x00434265 je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043426b mov r14, rsi                                                                                                                                                                                                              |     r14 = rsi;
    0x0043426e mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x00434272 mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x00434275 mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x00434279 cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x0043427d je 0x434284                                                                                                                                                                                                               |         
    0x0043427f movzx eax, byte [rax]                                                                                                                                                                                                     |         eax = *(rax);
    0x00434282 jmp 0x434293                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } else {
    0x00434284 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x00434287 call qword [rax + 0x48]                                                                                                                                                                                                   |         eax = uint64_t (*rax + 0x48)() ();
    0x0043428a cmp eax, 0xffffffff                                                                                                                                                                                                       |         
                                                                                                                                                                                                                                         |         if (eax == 0xffffffff) {
    0x0043428d je 0x43435f                                                                                                                                                                                                               |             goto label_6;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
    0x00434293 mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x00434297 cmp eax, 0x80                                                                                                                                                                                                             |     
                                                                                                                                                                                                                                         |     if (eax >= 0x80) {
    0x0043429c jl 0x43430c                                                                                                                                                                                                               |         
    0x0043429e mov rdi, qword [rbx]                                                                                                                                                                                                      |         rdi = *(rbx);
    0x004342a1 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x004342a4 lea rsi, [rsp + 4]                                                                                                                                                                                                        |         rsi = rsp + 4;
    0x004342a9 mov edx, 4                                                                                                                                                                                                                |         edx = 4;
    0x004342ae call qword [rax + 0x40]                                                                                                                                                                                                   |         rax = uint64_t (*rax + 0x40)() ();
    0x004342b1 xor edi, edi                                                                                                                                                                                                              |         edi = 0;
    0x004342b3 mov ecx, 0                                                                                                                                                                                                                |         ecx = 0;
    0x004342b8 mov esi, 0                                                                                                                                                                                                                |         esi = 0;
    0x004342bd mov edx, 0                                                                                                                                                                                                                |         edx = 0;
    0x004342c2 cmp rax, 4                                                                                                                                                                                                                |         
                                                                                                                                                                                                                                         |         if (rax == 4) {
    0x004342c6 jne 0x4342e9                                                                                                                                                                                                              |             
    0x004342c8 mov byte [rbx + 8], 1                                                                                                                                                                                                     |             *((rbx + 8)) = 1;
    0x004342cc movzx ecx, byte [rsp + 5]                                                                                                                                                                                                 |             ecx = *((rsp + 5));
    0x004342d1 movzx esi, byte [rsp + 6]                                                                                                                                                                                                 |             esi = *((rsp + 6));
    0x004342d6 movzx edx, byte [rsp + 7]                                                                                                                                                                                                 |             edx = *((rsp + 7));
    0x004342db movzx edi, byte [rsp + 4]                                                                                                                                                                                                 |             edi = *((rsp + 4));
    0x004342e0 shl edi, 0x18                                                                                                                                                                                                             |             edi <<= 0x18;
    0x004342e3 shl ecx, 0x10                                                                                                                                                                                                             |             ecx <<= 0x10;
    0x004342e6 shl esi, 8                                                                                                                                                                                                                |             esi <<= 8;
                                                                                                                                                                                                                                         |         }
    0x004342e9 or ecx, edi                                                                                                                                                                                                               |         ecx |= edi;
    0x004342eb or esi, ecx                                                                                                                                                                                                               |         esi |= ecx;
    0x004342ed and esi, 0x7fffff00                                                                                                                                                                                                       |         esi &= 0x7fffff00;
    0x004342f3 or edx, esi                                                                                                                                                                                                               |         edx |= esi;
    0x004342f5 and ecx, 0x7fff0000                                                                                                                                                                                                       |         ecx &= 0x7fff0000;
    0x004342fb and edi, 0x7f000000                                                                                                                                                                                                       |         edi &= 0x7f000000;
    0x00434301 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |         
                                                                                                                                                                                                                                         |         if (*((rbx + 8)) != 0) {
    0x00434305 jne 0x434371                                                                                                                                                                                                              |             goto label_7;
                                                                                                                                                                                                                                         |         }
    0x00434307 jmp 0x4344c5                                                                                                                                                                                                              |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043430c mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x0043430f mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x00434313 cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x00434317 je 0x434326                                                                                                                                                                                                               |         
    0x00434319 lea rcx, [rax + 1]                                                                                                                                                                                                        |         rcx = rax + 1;
    0x0043431d mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |         *((rdi + 0x18)) = rcx;
    0x00434321 movzx eax, byte [rax]                                                                                                                                                                                                     |         eax = *(rax);
    0x00434324 jmp 0x434335                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } else {
    0x00434326 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x00434329 call qword [rax + 0x50]                                                                                                                                                                                                   |         eax = uint64_t (*rax + 0x50)() ();
    0x0043432c cmp eax, 0xffffffff                                                                                                                                                                                                       |         
                                                                                                                                                                                                                                         |         if (eax == 0xffffffff) {
    0x0043432f je 0x4344d7                                                                                                                                                                                                               |             goto label_8;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
    0x00434335 mov byte [rbx + 8], 1                                                                                                                                                                                                     |     *((rbx + 8)) = 1;
    0x00434339 movsx edx, al                                                                                                                                                                                                             |     edx = (int32_t) al;
                                                                                                                                                                                                                                         | label_4:
    0x0043433c mov esi, edx                                                                                                                                                                                                              |     esi = edx;
    0x0043433e and esi, 0xffffff00                                                                                                                                                                                                       |     esi &= 0xffffff00;
    0x00434344 mov ecx, edx                                                                                                                                                                                                              |     ecx = edx;
    0x00434346 and ecx, 0xffff0000                                                                                                                                                                                                       |     ecx &= 0xffff0000;
    0x0043434c mov edi, edx                                                                                                                                                                                                              |     edi = edx;
    0x0043434e and edi, 0xff000000                                                                                                                                                                                                       |     edi &= 0xff000000;
    0x00434354 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x00434358 jne 0x434371                                                                                                                                                                                                              |         
    0x0043435a jmp 0x4344c5                                                                                                                                                                                                              |         goto label_5;
                                                                                                                                                                                                                                         | label_6:
    0x0043435f xor edi, edi                                                                                                                                                                                                              |         edi = 0;
    0x00434361 xor ecx, ecx                                                                                                                                                                                                              |         ecx = 0;
    0x00434363 xor esi, esi                                                                                                                                                                                                              |         esi = 0;
    0x00434365 xor edx, edx                                                                                                                                                                                                              |         edx = 0;
    0x00434367 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |         
                                                                                                                                                                                                                                         |         if (*((rbx + 8)) == 0) {
    0x0043436b je 0x4344c5                                                                                                                                                                                                               |             goto label_5;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
                                                                                                                                                                                                                                         | label_7:
    0x00434371 and ecx, 0xff0000                                                                                                                                                                                                         |     ecx &= 0xff0000;
    0x00434377 or ecx, edi                                                                                                                                                                                                               |     ecx |= edi;
    0x00434379 and esi, 0xff00                                                                                                                                                                                                           |     esi &= 0xff00;
    0x0043437f movzx r13d, dl                                                                                                                                                                                                            |     r13d = (int32_t) dl;
    0x00434383 or r13d, esi                                                                                                                                                                                                              |     r13d |= esi;
    0x00434386 or r13d, ecx                                                                                                                                                                                                              |     r13d |= ecx;
    0x00434389 cmp r13d, 0x1000000                                                                                                                                                                                                       |     
    0x00434390 mov r12d, 0x1000000                                                                                                                                                                                                       |     r12d = 0x1000000;
                                                                                                                                                                                                                                         |     if (r13d < 0x1000000) {
    0x00434396 cmovl r12d, r13d                                                                                                                                                                                                          |         r12d = r13d;
                                                                                                                                                                                                                                         |     }
    0x0043439a cmp r12d, 0xffffffff                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                         |     if (r12d == 0xffffffff) {
    0x0043439e je 0x4344de                                                                                                                                                                                                               |         goto label_9;
                                                                                                                                                                                                                                         |     }
    0x004343a4 movsxd r15, r12d                                                                                                                                                                                                          |     r15 = (int64_t) r12d;
    0x004343a7 mov rdi, r14                                                                                                                                                                                                              |     
    0x004343aa mov rsi, r15                                                                                                                                                                                                              |     
    0x004343ad xor edx, edx                                                                                                                                                                                                              |     
    0x004343af call 0x437650                                                                                                                                                                                                             |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r15, 0);
    0x004343b4 test r13d, r13d                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                         |     if (r13d == 0) {
    0x004343b7 je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x004343bd cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                              |     
    0x004343c2 mov rbp, r14                                                                                                                                                                                                              |     
                                                                                                                                                                                                                                         |     if (*((r14 + 0x20)) != 0x17) {
    0x004343c5 je 0x4343ca                                                                                                                                                                                                               |         
    0x004343c7 mov rbp, qword [r14]                                                                                                                                                                                                      |         rbp = *(r14);
                                                                                                                                                                                                                                         |     }
    0x004343ca cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x004343ce je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x004343d4 mov qword [rsp + 8], r15                                                                                                                                                                                                  |     *((rsp + 8)) = r15;
    0x004343d9 mov qword [rsp + 0x10], r14                                                                                                                                                                                               |     *((rsp + 0x10)) = r14;
    0x004343de mov r15d, r12d                                                                                                                                                                                                            |     r15d = r12d;
    0x004343e1 mov al, 1                                                                                                                                                                                                                 |     al = 1;
    0x004343e3 xor r14d, r14d                                                                                                                                                                                                            |     r14d = 0;
    0x004343e6 jmp 0x434410                                                                                                                                                                                                              |     goto label_10;
                                                                                                                                                                                                                                         | label_0:
    0x004343f0 lea rcx, [rax + 1]                                                                                                                                                                                                        |     rcx = rax + 1;
    0x004343f4 mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |     *((rdi + 0x18)) = rcx;
    0x004343f8 movzx eax, byte [rax]                                                                                                                                                                                                     |     eax = *(rax);
                                                                                                                                                                                                                                         | label_1:
    0x004343fb mov byte [rbx + 8], 1                                                                                                                                                                                                     |     *((rbx + 8)) = 1;
    0x004343ff mov byte [rbp + r14], al                                                                                                                                                                                                  |     *((rbp + r14)) = al;
                                                                                                                                                                                                                                         |     do {
                                                                                                                                                                                                                                         | label_2:
    0x00434404 movzx eax, byte [rbx + 8]                                                                                                                                                                                                 |         eax = *((rbx + 8));
    0x00434408 inc r14                                                                                                                                                                                                                   |         r14++;
    0x0043440b cmp r15, r14                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |         if (r15 == r14) {
    0x0043440e je 0x434432                                                                                                                                                                                                               |             goto label_11;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         | label_10:
    0x00434410 test al, al                                                                                                                                                                                                               |         
    0x00434412 je 0x434404                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                         |     } while (al == 0);
    0x00434414 mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x00434418 mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x0043441b mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x0043441f cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x00434423 jne 0x4343f0                                                                                                                                                                                                              |         goto label_0;
                                                                                                                                                                                                                                         |     }
    0x00434425 mov rax, qword [rdi]                                                                                                                                                                                                      |     rax = *(rdi);
    0x00434428 call qword [rax + 0x50]                                                                                                                                                                                                   |     eax = uint64_t (*rax + 0x50)() ();
    0x0043442b cmp eax, 0xffffffff                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                         |     if (eax != 0xffffffff) {
    0x0043442e jne 0x4343fb                                                                                                                                                                                                              |         goto label_1;
                                                                                                                                                                                                                                         |     }
    0x00434430 jmp 0x434404                                                                                                                                                                                                              |     goto label_2;
                                                                                                                                                                                                                                         | label_11:
    0x00434432 cmp r13d, 0x1000001                                                                                                                                                                                                       |     
    0x00434439 mov r14, qword [rsp + 0x10]                                                                                                                                                                                               |     r14 = *((rsp + 0x10));
    0x0043443e mov rbp, qword [rsp + 8]                                                                                                                                                                                                  |     rbp = *((rsp + 8));
                                                                                                                                                                                                                                         |     if (r13d < 0x1000001) {
    0x00434443 jl 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x00434449 test al, al                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (al == 0) {
    0x0043444b je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043444d mov esi, r13d                                                                                                                                                                                                             |     
    0x00434450 mov rdi, r14                                                                                                                                                                                                              |     
    0x00434453 xor edx, edx                                                                                                                                                                                                              |     
    0x00434455 call 0x437650                                                                                                                                                                                                             |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x0043445a cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                              |     
                                                                                                                                                                                                                                         |     if (*((r14 + 0x20)) != 0x17) {
    0x0043445f je 0x434464                                                                                                                                                                                                               |         
    0x00434461 mov r14, qword [r14]                                                                                                                                                                                                      |         r14 = *(r14);
                                                                                                                                                                                                                                         |     }
    0x00434464 sub r13d, r12d                                                                                                                                                                                                            |     r13d -= r12d;
                                                                                                                                                                                                                                         |     if (r13d == 0) {
    0x00434467 je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x00434469 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x0043446d je 0x4344c5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043446f add r14, rbp                                                                                                                                                                                                              |     r14 += rbp;
    0x00434472 mov r15d, r13d                                                                                                                                                                                                            |     r15d = r13d;
    0x00434475 dec r15                                                                                                                                                                                                                   |     r15--;
    0x00434478 mov al, 1                                                                                                                                                                                                                 |     al = 1;
    0x0043447a xor ebp, ebp                                                                                                                                                                                                              |     ebp = 0;
    0x0043447c test al, al                                                                                                                                                                                                               |     
    0x0043447e je 0x4344b3                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     while (al != 0) {
    0x00434480 mov byte [rbx + 8], 0                                                                                                                                                                                                     |         *((rbx + 8)) = 0;
    0x00434484 mov rdi, qword [rbx]                                                                                                                                                                                                      |         rdi = *(rbx);
    0x00434487 mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |         rax = *((rdi + 0x18));
    0x0043448b cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |         
                                                                                                                                                                                                                                         |         if (rax != *((rdi + 0x20))) {
    0x0043448f je 0x4344a0                                                                                                                                                                                                               |             
    0x00434491 lea rcx, [rax + 1]                                                                                                                                                                                                        |             rcx = rax + 1;
    0x00434495 mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |             *((rdi + 0x18)) = rcx;
    0x00434499 movzx eax, byte [rax]                                                                                                                                                                                                     |             eax = *(rax);
    0x0043449c jmp 0x4344ab                                                                                                                                                                                                              |             
                                                                                                                                                                                                                                         |         } else {
    0x004344a0 mov rax, qword [rdi]                                                                                                                                                                                                      |             rax = *(rdi);
    0x004344a3 call qword [rax + 0x50]                                                                                                                                                                                                   |             eax = uint64_t (*rax + 0x50)() ();
    0x004344a6 cmp eax, 0xffffffff                                                                                                                                                                                                       |             
                                                                                                                                                                                                                                         |             if (eax == 0xffffffff) {
    0x004344a9 je 0x4344b3                                                                                                                                                                                                               |                 goto label_3;
                                                                                                                                                                                                                                         |             }
                                                                                                                                                                                                                                         |         }
    0x004344ab mov byte [rbx + 8], 1                                                                                                                                                                                                     |         *((rbx + 8)) = 1;
    0x004344af mov byte [r14 + rbp], al                                                                                                                                                                                                  |         *((r14 + rbp)) = al;
                                                                                                                                                                                                                                         | label_3:
    0x004344b3 cmp r15, rbp                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |         if (r15 == rbp) {
    0x004344b6 je 0x4344c5                                                                                                                                                                                                               |             goto label_5;
                                                                                                                                                                                                                                         |         }
    0x004344b8 movzx eax, byte [rbx + 8]                                                                                                                                                                                                 |         eax = *((rbx + 8));
    0x004344bc inc rbp                                                                                                                                                                                                                   |         rbp++;
    0x004344bf test al, al                                                                                                                                                                                                               |         
    0x004344c1 jne 0x434480                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     }
    0x004344c3 jmp 0x4344b3                                                                                                                                                                                                              |     goto label_3;
                                                                                                                                                                                                                                         | label_5:
    0x004344c5 mov rax, rbx                                                                                                                                                                                                              |     rax = rbx;
    0x004344c8 add rsp, 0x18                                                                                                                                                                                                             |     
    0x004344cc pop rbx                                                                                                                                                                                                                   |     
    0x004344cd pop r12                                                                                                                                                                                                                   |     
    0x004344cf pop r13                                                                                                                                                                                                                   |     
    0x004344d1 pop r14                                                                                                                                                                                                                   |     
    0x004344d3 pop r15                                                                                                                                                                                                                   |     
    0x004344d5 pop rbp                                                                                                                                                                                                                   |     
    0x004344d6 ret                                                                                                                                                                                                                       |     return rax;
                                                                                                                                                                                                                                         | label_8:
    0x004344d7 xor edx, edx                                                                                                                                                                                                              |     edx = 0;
    0x004344d9 jmp 0x43433c                                                                                                                                                                                                              |     goto label_4;
                                                                                                                                                                                                                                         | label_9:
    0x004344de mov edi, 0x45c71f                                                                                                                                                                                                         |     
    0x004344e3 call 0x434cf0                                                                                                                                                                                                             |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                                                                         | }