; assembly                                                                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                                                                         | /* bslx_genericinstream.t/none @ 0x434240 */
                                                                                                                                                                                                                                         | #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_ch_2;
                                                                                                                                                                                                                                         |     int64_t var_dh;
                                                                                                                                                                                                                                         |     int64_t var_eh;
                                                                                                                                                                                                                                         |     int64_t var_fh;
                                                                                                                                                                                                                                         |     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> >&) */
    0x00434240 push rbp                                                                                                                                                                                                                  |     
    0x00434241 push r15                                                                                                                                                                                                                  |     
    0x00434243 push r14                                                                                                                                                                                                                  |     
    0x00434245 push r13                                                                                                                                                                                                                  |     
    0x00434247 push r12                                                                                                                                                                                                                  |     
    0x00434249 push rbx                                                                                                                                                                                                                  |     
    0x0043424a sub rsp, 0x18                                                                                                                                                                                                             |     
    0x0043424e mov rbx, rdi                                                                                                                                                                                                              |     rbx = rdi;
    0x00434251 cmp byte [rdi + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rdi + 8)) == 0) {
    0x00434255 je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043425b mov r14, rsi                                                                                                                                                                                                              |     r14 = rsi;
    0x0043425e mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x00434262 mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x00434265 mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x00434269 cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x0043426d je 0x434274                                                                                                                                                                                                               |         
    0x0043426f movzx eax, byte [rax]                                                                                                                                                                                                     |         eax = *(rax);
    0x00434272 jmp 0x434283                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } else {
    0x00434274 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x00434277 call qword [rax + 0x48]                                                                                                                                                                                                   |         eax = uint64_t (*rax + 0x48)() ();
    0x0043427a cmp eax, 0xffffffff                                                                                                                                                                                                       |         
                                                                                                                                                                                                                                         |         if (eax == 0xffffffff) {
    0x0043427d je 0x43434f                                                                                                                                                                                                               |             goto label_6;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
    0x00434283 mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x00434287 cmp eax, 0x80                                                                                                                                                                                                             |     
                                                                                                                                                                                                                                         |     if (eax >= 0x80) {
    0x0043428c jl 0x4342fc                                                                                                                                                                                                               |         
    0x0043428e mov rdi, qword [rbx]                                                                                                                                                                                                      |         rdi = *(rbx);
    0x00434291 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x00434294 lea rsi, [rsp + 0xc]                                                                                                                                                                                                      |         rsi = rsp + 0xc;
    0x00434299 mov edx, 4                                                                                                                                                                                                                |         edx = 4;
    0x0043429e call qword [rax + 0x40]                                                                                                                                                                                                   |         rax = uint64_t (*rax + 0x40)() ();
    0x004342a1 xor edi, edi                                                                                                                                                                                                              |         edi = 0;
    0x004342a3 mov ecx, 0                                                                                                                                                                                                                |         ecx = 0;
    0x004342a8 mov esi, 0                                                                                                                                                                                                                |         esi = 0;
    0x004342ad mov edx, 0                                                                                                                                                                                                                |         edx = 0;
    0x004342b2 cmp rax, 4                                                                                                                                                                                                                |         
                                                                                                                                                                                                                                         |         if (rax == 4) {
    0x004342b6 jne 0x4342d9                                                                                                                                                                                                              |             
    0x004342b8 mov byte [rbx + 8], 1                                                                                                                                                                                                     |             *((rbx + 8)) = 1;
    0x004342bc movzx ecx, byte [rsp + 0xd]                                                                                                                                                                                               |             ecx = *((rsp + 0xd));
    0x004342c1 movzx esi, byte [rsp + 0xe]                                                                                                                                                                                               |             esi = *((rsp + 0xe));
    0x004342c6 movzx edx, byte [rsp + 0xf]                                                                                                                                                                                               |             edx = *((rsp + 0xf));
    0x004342cb movzx edi, byte [rsp + 0xc]                                                                                                                                                                                               |             edi = *((rsp + 0xc));
    0x004342d0 shl edi, 0x18                                                                                                                                                                                                             |             edi <<= 0x18;
    0x004342d3 shl ecx, 0x10                                                                                                                                                                                                             |             ecx <<= 0x10;
    0x004342d6 shl esi, 8                                                                                                                                                                                                                |             esi <<= 8;
                                                                                                                                                                                                                                         |         }
    0x004342d9 or ecx, edi                                                                                                                                                                                                               |         ecx |= edi;
    0x004342db or esi, ecx                                                                                                                                                                                                               |         esi |= ecx;
    0x004342dd and esi, 0x7fffff00                                                                                                                                                                                                       |         esi &= 0x7fffff00;
    0x004342e3 or edx, esi                                                                                                                                                                                                               |         edx |= esi;
    0x004342e5 and ecx, 0x7fff0000                                                                                                                                                                                                       |         ecx &= 0x7fff0000;
    0x004342eb and edi, 0x7f000000                                                                                                                                                                                                       |         edi &= 0x7f000000;
    0x004342f1 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |         
                                                                                                                                                                                                                                         |         if (*((rbx + 8)) != 0) {
    0x004342f5 jne 0x434361                                                                                                                                                                                                              |             goto label_7;
                                                                                                                                                                                                                                         |         }
    0x004342f7 jmp 0x4344a5                                                                                                                                                                                                              |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x004342fc mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x004342ff mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x00434303 cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x00434307 je 0x434316                                                                                                                                                                                                               |         
    0x00434309 lea rcx, [rax + 1]                                                                                                                                                                                                        |         rcx = rax + 1;
    0x0043430d mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |         *((rdi + 0x18)) = rcx;
    0x00434311 movzx eax, byte [rax]                                                                                                                                                                                                     |         eax = *(rax);
    0x00434314 jmp 0x434325                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } else {
    0x00434316 mov rax, qword [rdi]                                                                                                                                                                                                      |         rax = *(rdi);
    0x00434319 call qword [rax + 0x50]                                                                                                                                                                                                   |         eax = uint64_t (*rax + 0x50)() ();
    0x0043431c cmp eax, 0xffffffff                                                                                                                                                                                                       |         
                                                                                                                                                                                                                                         |         if (eax == 0xffffffff) {
    0x0043431f je 0x4344b7                                                                                                                                                                                                               |             goto label_8;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
    0x00434325 mov byte [rbx + 8], 1                                                                                                                                                                                                     |     *((rbx + 8)) = 1;
    0x00434329 movsx edx, al                                                                                                                                                                                                             |     edx = (int32_t) al;
                                                                                                                                                                                                                                         | label_4:
    0x0043432c mov esi, edx                                                                                                                                                                                                              |     esi = edx;
    0x0043432e and esi, 0xffffff00                                                                                                                                                                                                       |     esi &= 0xffffff00;
    0x00434334 mov ecx, edx                                                                                                                                                                                                              |     ecx = edx;
    0x00434336 and ecx, 0xffff0000                                                                                                                                                                                                       |     ecx &= 0xffff0000;
    0x0043433c mov edi, edx                                                                                                                                                                                                              |     edi = edx;
    0x0043433e and edi, 0xff000000                                                                                                                                                                                                       |     edi &= 0xff000000;
    0x00434344 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x00434348 jne 0x434361                                                                                                                                                                                                              |         
    0x0043434a jmp 0x4344a5                                                                                                                                                                                                              |         goto label_5;
                                                                                                                                                                                                                                         | label_6:
    0x0043434f xor edi, edi                                                                                                                                                                                                              |         edi = 0;
    0x00434351 xor ecx, ecx                                                                                                                                                                                                              |         ecx = 0;
    0x00434353 xor esi, esi                                                                                                                                                                                                              |         esi = 0;
    0x00434355 xor edx, edx                                                                                                                                                                                                              |         edx = 0;
    0x00434357 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |         
                                                                                                                                                                                                                                         |         if (*((rbx + 8)) == 0) {
    0x0043435b je 0x4344a5                                                                                                                                                                                                               |             goto label_5;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         |     }
                                                                                                                                                                                                                                         | label_7:
    0x00434361 and ecx, 0xff0000                                                                                                                                                                                                         |     ecx &= 0xff0000;
    0x00434367 or ecx, edi                                                                                                                                                                                                               |     ecx |= edi;
    0x00434369 and esi, 0xff00                                                                                                                                                                                                           |     esi &= 0xff00;
    0x0043436f movzx r13d, dl                                                                                                                                                                                                            |     r13d = (int32_t) dl;
    0x00434373 or r13d, esi                                                                                                                                                                                                              |     r13d |= esi;
    0x00434376 or r13d, ecx                                                                                                                                                                                                              |     r13d |= ecx;
    0x00434379 cmp r13d, 0x1000000                                                                                                                                                                                                       |     
    0x00434380 mov r12d, 0x1000000                                                                                                                                                                                                       |     r12d = 0x1000000;
                                                                                                                                                                                                                                         |     if (r13d < 0x1000000) {
    0x00434386 cmovl r12d, r13d                                                                                                                                                                                                          |         r12d = r13d;
                                                                                                                                                                                                                                         |     }
    0x0043438a cmp r12d, 0xffffffff                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                         |     if (r12d == 0xffffffff) {
    0x0043438e je 0x4344be                                                                                                                                                                                                               |         goto label_9;
                                                                                                                                                                                                                                         |     }
    0x00434394 movsxd r15, r12d                                                                                                                                                                                                          |     r15 = (int64_t) r12d;
    0x00434397 mov rdi, r14                                                                                                                                                                                                              |     
    0x0043439a mov rsi, r15                                                                                                                                                                                                              |     
    0x0043439d xor edx, edx                                                                                                                                                                                                              |     
    0x0043439f call 0x437630                                                                                                                                                                                                             |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r15, 0);
    0x004343a4 test r13d, r13d                                                                                                                                                                                                           |     
                                                                                                                                                                                                                                         |     if (r13d == 0) {
    0x004343a7 je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x004343ad cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                              |     
    0x004343b2 mov rbp, r14                                                                                                                                                                                                              |     
                                                                                                                                                                                                                                         |     if (*((r14 + 0x20)) != 0x17) {
    0x004343b5 je 0x4343ba                                                                                                                                                                                                               |         
    0x004343b7 mov rbp, qword [r14]                                                                                                                                                                                                      |         rbp = *(r14);
                                                                                                                                                                                                                                         |     }
    0x004343ba cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x004343be je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x004343c4 mov qword [rsp + 0x10], r14                                                                                                                                                                                               |     *((rsp + 0x10)) = r14;
    0x004343c9 mov al, 1                                                                                                                                                                                                                 |     al = 1;
    0x004343cb xor r14d, r14d                                                                                                                                                                                                            |     r14d = 0;
    0x004343ce jmp 0x4343f0                                                                                                                                                                                                              |     goto label_10;
                                                                                                                                                                                                                                         | label_0:
    0x004343d0 lea rcx, [rax + 1]                                                                                                                                                                                                        |     rcx = rax + 1;
    0x004343d4 mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |     *((rdi + 0x18)) = rcx;
    0x004343d8 movzx eax, byte [rax]                                                                                                                                                                                                     |     eax = *(rax);
                                                                                                                                                                                                                                         | label_1:
    0x004343db mov byte [rbx + 8], 1                                                                                                                                                                                                     |     *((rbx + 8)) = 1;
    0x004343df mov byte [rbp + r14], al                                                                                                                                                                                                  |     *((rbp + r14)) = al;
                                                                                                                                                                                                                                         |     do {
                                                                                                                                                                                                                                         | label_2:
    0x004343e4 movzx eax, byte [rbx + 8]                                                                                                                                                                                                 |         eax = *((rbx + 8));
    0x004343e8 inc r14                                                                                                                                                                                                                   |         r14++;
    0x004343eb cmp r15, r14                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |         if (r15 == r14) {
    0x004343ee je 0x434412                                                                                                                                                                                                               |             goto label_11;
                                                                                                                                                                                                                                         |         }
                                                                                                                                                                                                                                         | label_10:
    0x004343f0 test al, al                                                                                                                                                                                                               |         
    0x004343f2 je 0x4343e4                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                         |     } while (al == 0);
    0x004343f4 mov byte [rbx + 8], 0                                                                                                                                                                                                     |     *((rbx + 8)) = 0;
    0x004343f8 mov rdi, qword [rbx]                                                                                                                                                                                                      |     rdi = *(rbx);
    0x004343fb mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |     rax = *((rdi + 0x18));
    0x004343ff cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (rax != *((rdi + 0x20))) {
    0x00434403 jne 0x4343d0                                                                                                                                                                                                              |         goto label_0;
                                                                                                                                                                                                                                         |     }
    0x00434405 mov rax, qword [rdi]                                                                                                                                                                                                      |     rax = *(rdi);
    0x00434408 call qword [rax + 0x50]                                                                                                                                                                                                   |     eax = uint64_t (*rax + 0x50)() ();
    0x0043440b cmp eax, 0xffffffff                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                         |     if (eax != 0xffffffff) {
    0x0043440e jne 0x4343db                                                                                                                                                                                                              |         goto label_1;
                                                                                                                                                                                                                                         |     }
    0x00434410 jmp 0x4343e4                                                                                                                                                                                                              |     goto label_2;
                                                                                                                                                                                                                                         | label_11:
    0x00434412 cmp r13d, 0x1000001                                                                                                                                                                                                       |     
    0x00434419 mov r14, qword [rsp + 0x10]                                                                                                                                                                                               |     r14 = *((rsp + 0x10));
                                                                                                                                                                                                                                         |     if (r13d < 0x1000001) {
    0x0043441e jl 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x00434424 test al, al                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (al == 0) {
    0x00434426 je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043442c mov esi, r13d                                                                                                                                                                                                             |     
    0x0043442f mov rdi, r14                                                                                                                                                                                                              |     
    0x00434432 xor edx, edx                                                                                                                                                                                                              |     
    0x00434434 call 0x437630                                                                                                                                                                                                             |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, r13d, 0);
    0x00434439 cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                              |     
                                                                                                                                                                                                                                         |     if (*((r14 + 0x20)) != 0x17) {
    0x0043443e je 0x434443                                                                                                                                                                                                               |         
    0x00434440 mov r14, qword [r14]                                                                                                                                                                                                      |         r14 = *(r14);
                                                                                                                                                                                                                                         |     }
    0x00434443 cmp r13d, r12d                                                                                                                                                                                                            |     
                                                                                                                                                                                                                                         |     if (r13d == r12d) {
    0x00434446 je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x00434448 cmp byte [rbx + 8], 0                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                         |     if (*((rbx + 8)) == 0) {
    0x0043444c je 0x4344a5                                                                                                                                                                                                               |         goto label_5;
                                                                                                                                                                                                                                         |     }
    0x0043444e movsxd rbp, r13d                                                                                                                                                                                                          |     rbp = (int64_t) r13d;
    0x00434451 dec rbp                                                                                                                                                                                                                   |     rbp--;
    0x00434454 mov al, 1                                                                                                                                                                                                                 |     al = 1;
    0x00434456 test al, al                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                         |     if (al == 0) {
    0x00434458 je 0x434493                                                                                                                                                                                                               |         goto label_3;
                                                                                                                                                                                                                                         |     }
    0x0043445a nop word [rax + rax]                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                         |     do {
    0x00434460 mov byte [rbx + 8], 0                                                                                                                                                                                                     |         *((rbx + 8)) = 0;
    0x00434464 mov rdi, qword [rbx]                                                                                                                                                                                                      |         rdi = *(rbx);
    0x00434467 mov rax, qword [rdi + 0x18]                                                                                                                                                                                               |         rax = *((rdi + 0x18));
    0x0043446b cmp rax, qword [rdi + 0x20]                                                                                                                                                                                               |         
                                                                                                                                                                                                                                         |         if (rax != *((rdi + 0x20))) {
    0x0043446f je 0x434480                                                                                                                                                                                                               |             
    0x00434471 lea rcx, [rax + 1]                                                                                                                                                                                                        |             rcx = rax + 1;
    0x00434475 mov qword [rdi + 0x18], rcx                                                                                                                                                                                               |             *((rdi + 0x18)) = rcx;
    0x00434479 movzx eax, byte [rax]                                                                                                                                                                                                     |             eax = *(rax);
    0x0043447c jmp 0x43448b                                                                                                                                                                                                              |             
                                                                                                                                                                                                                                         |         } else {
    0x00434480 mov rax, qword [rdi]                                                                                                                                                                                                      |             rax = *(rdi);
    0x00434483 call qword [rax + 0x50]                                                                                                                                                                                                   |             eax = uint64_t (*rax + 0x50)() ();
    0x00434486 cmp eax, 0xffffffff                                                                                                                                                                                                       |             
                                                                                                                                                                                                                                         |             if (eax == 0xffffffff) {
    0x00434489 je 0x434493                                                                                                                                                                                                               |                 goto label_3;
                                                                                                                                                                                                                                         |             }
                                                                                                                                                                                                                                         |         }
    0x0043448b mov byte [rbx + 8], 1                                                                                                                                                                                                     |         *((rbx + 8)) = 1;
    0x0043448f mov byte [r14 + r15], al                                                                                                                                                                                                  |         *((r14 + r15)) = al;
                                                                                                                                                                                                                                         | label_3:
    0x00434493 cmp rbp, r15                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |         if (rbp == r15) {
    0x00434496 je 0x4344a5                                                                                                                                                                                                               |             goto label_5;
                                                                                                                                                                                                                                         |         }
    0x00434498 movzx eax, byte [rbx + 8]                                                                                                                                                                                                 |         eax = *((rbx + 8));
    0x0043449c inc r15                                                                                                                                                                                                                   |         r15++;
    0x0043449f test al, al                                                                                                                                                                                                               |         
    0x004344a1 jne 0x434460                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } while (al != 0);
    0x004344a3 jmp 0x434493                                                                                                                                                                                                              |     goto label_3;
                                                                                                                                                                                                                                         | label_5:
    0x004344a5 mov rax, rbx                                                                                                                                                                                                              |     rax = rbx;
    0x004344a8 add rsp, 0x18                                                                                                                                                                                                             |     
    0x004344ac pop rbx                                                                                                                                                                                                                   |     
    0x004344ad pop r12                                                                                                                                                                                                                   |     
    0x004344af pop r13                                                                                                                                                                                                                   |     
    0x004344b1 pop r14                                                                                                                                                                                                                   |     
    0x004344b3 pop r15                                                                                                                                                                                                                   |     
    0x004344b5 pop rbp                                                                                                                                                                                                                   |     
    0x004344b6 ret                                                                                                                                                                                                                       |     return rax;
                                                                                                                                                                                                                                         | label_8:
    0x004344b7 xor edx, edx                                                                                                                                                                                                              |     edx = 0;
    0x004344b9 jmp 0x43432c                                                                                                                                                                                                              |     goto label_4;
                                                                                                                                                                                                                                         | label_9:
    0x004344be mov edi, 0x45c72d                                                                                                                                                                                                         |     
    0x004344c3 call 0x434cd0                                                                                                                                                                                                             |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                                                                         | }