; assembly                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                             | /* bdlde_charconvertutf16.t/none @ 0x42da40 */
                                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                                             |  
                                                                                                                                                                                                                                             | uint16_t rotate_left16 (uint16_t value, uint32_t count) {
                                                                                                                                                                                                                                             |     const uint16_t mask = (CHAR_BIT * sizeof (value)) - 1;
                                                                                                                                                                                                                                             |     count &= mask;
                                                                                                                                                                                                                                             |     return (value << count) | (value >> (-count & mask));
                                                                                                                                                                                                                                             | }
                                                                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bdlde::CharConvertUtf16.utf16ToUtf8_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____unsigned_short_const__unsigned_long__char__BloombergLP::bdlde::ByteOrder::Enum_ ()          | uint32_t method_BloombergLP::bdlde::CharConvertUtf16_utf16ToUtf8_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_unsigned_short_const_unsigned_long_char_BloombergLP::bdlde::ByteOrder::Enum_ (int64_t arg5, uint32_t arg4, char * arg3, char * arg2, char * arg1) {
                                                                                                                                                                                                                                             |     r8 = arg5;
                                                                                                                                                                                                                                             |     rcx = arg4;
                                                                                                                                                                                                                                             |     rdx = arg3;
                                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                                             |     /* BloombergLP::bdlde::CharConvertUtf16::utf16ToUtf8(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >*, unsigned short const*, unsigned long*, char, BloombergLP::bdlde::ByteOrder::Enum) */
    0x0042da40 push rbp                                                                                                                                                                                                                      |     
    0x0042da41 push r15                                                                                                                                                                                                                      |     
    0x0042da43 push r14                                                                                                                                                                                                                      |     
    0x0042da45 push rbx                                                                                                                                                                                                                      |     
    0x0042da46 push rax                                                                                                                                                                                                                      |     
    0x0042da47 mov ebp, ecx                                                                                                                                                                                                                  |     
    0x0042da49 mov r14, rdx                                                                                                                                                                                                                  |     r14 = rdx;
    0x0042da4c mov r15, rsi                                                                                                                                                                                                                  |     r15 = rsi;
    0x0042da4f mov rbx, rdi                                                                                                                                                                                                                  |     rbx = rdi;
    0x0042da52 movzx eax, word [rsi]                                                                                                                                                                                                         |     eax = *(rsi);
    0x0042da55 xor esi, esi                                                                                                                                                                                                                  |     esi = 0;
    0x0042da57 test r8d, r8d                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (r8d == 0) {
    0x0042da5a je 0x42db14                                                                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                                                                             |     }
    0x0042da60 test ax, ax                                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (ax == 0) {
    0x0042da63 je 0x42dae4                                                                                                                                                                                                                   |         goto label_5;
                                                                                                                                                                                                                                             |     }
    0x0042da69 mov rcx, r15                                                                                                                                                                                                                  |     rcx = r15;
    0x0042da6c jmp 0x42da88                                                                                                                                                                                                                  |     goto label_6;
                                                                                                                                                                                                                                             | label_0:
    0x0042da70 cmp eax, 0x800                                                                                                                                                                                                                |     
    0x0042da75 sbb rsi, 0                                                                                                                                                                                                                    |     
    0x0042da79 add rsi, 3                                                                                                                                                                                                                    |     rsi += 3;
                                                                                                                                                                                                                                             |     do {
                                                                                                                                                                                                                                             | label_2:
    0x0042da7d movzx eax, word [rdx]                                                                                                                                                                                                         |         eax = *(rdx);
    0x0042da80 mov rcx, rdx                                                                                                                                                                                                                  |         rcx = rdx;
    0x0042da83 test ax, ax                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (ax == 0) {
    0x0042da86 je 0x42dae4                                                                                                                                                                                                                   |             goto label_5;
                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                             | label_6:
    0x0042da88 rol ax, 8                                                                                                                                                                                                                     |         ax = rotate_left16 (ax, 8);
    0x0042da8c cmp ax, 0x7f                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |         if (ax > 0x7f) {
    0x0042da90 ja 0x42daa0                                                                                                                                                                                                                   |             goto label_7;
                                                                                                                                                                                                                                             |         }
    0x0042da92 add rcx, 2                                                                                                                                                                                                                    |         rcx += 2;
    0x0042da96 inc rsi                                                                                                                                                                                                                       |         rsi++;
                                                                                                                                                                                                                                             | label_1:
    0x0042da99 mov rdx, rcx                                                                                                                                                                                                                  |         rdx = rcx;
    0x0042da9c jmp 0x42da7d                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } while (1);
                                                                                                                                                                                                                                             | label_7:
    0x0042daa0 movzx eax, ax                                                                                                                                                                                                                 |     eax = (int32_t) ax;
    0x0042daa3 mov edi, eax                                                                                                                                                                                                                  |     edi = eax;
    0x0042daa5 and edi, 0xf800                                                                                                                                                                                                               |     edi &= 0xf800;
    0x0042daab lea rdx, [rcx + 2]                                                                                                                                                                                                            |     rdx = rcx + 2;
    0x0042daaf cmp edi, 0xd800                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                             |     if (edi != 0xd800) {
    0x0042dab5 jne 0x42da70                                                                                                                                                                                                                  |         goto label_0;
                                                                                                                                                                                                                                             |     }
    0x0042dab7 and eax, 0xfc00                                                                                                                                                                                                               |     eax &= 0xfc00;
    0x0042dabc cmp eax, 0xd800                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                             |     if (eax == 0xd800) {
    0x0042dac1 jne 0x42dadf                                                                                                                                                                                                                  |         
    0x0042dac3 movzx eax, word [rdx]                                                                                                                                                                                                         |         eax = *(rdx);
    0x0042dac6 and eax, 0xfc                                                                                                                                                                                                                 |         eax &= 0xfc;
    0x0042dacb movzx eax, ax                                                                                                                                                                                                                 |         eax = (int32_t) ax;
    0x0042dace cmp eax, 0xdc                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                             |         if (eax != 0xdc) {
    0x0042dad3 jne 0x42dadf                                                                                                                                                                                                                  |             goto label_8;
                                                                                                                                                                                                                                             |         }
    0x0042dad5 add rcx, 4                                                                                                                                                                                                                    |         rcx += 4;
    0x0042dad9 add rsi, 4                                                                                                                                                                                                                    |         rsi += 4;
    0x0042dadd jmp 0x42da99                                                                                                                                                                                                                  |         goto label_1;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_8:
    0x0042dadf inc rsi                                                                                                                                                                                                                       |     rsi++;
    0x0042dae2 jmp 0x42da7d                                                                                                                                                                                                                  |     goto label_2;
                                                                                                                                                                                                                                             | label_5:
    0x0042dae4 inc rsi                                                                                                                                                                                                                       |     rsi++;
    0x0042dae7 cmp rsi, qword [rbx + 0x18]                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (rsi > *((rbx + 0x18))) {
    0x0042daeb jbe 0x42db01                                                                                                                                                                                                                  |         
    0x0042daed cmp rsi, 0xffffffffffffffff                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (rsi == -1) {
    0x0042daf1 je 0x42dc20                                                                                                                                                                                                                   |             goto label_9;
                                                                                                                                                                                                                                             |         }
    0x0042daf7 mov rdi, rbx                                                                                                                                                                                                                  |         
    0x0042dafa xor edx, edx                                                                                                                                                                                                                  |         
    0x0042dafc call 0x437b80                                                                                                                                                                                                                 |         ax = bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (rbx, rsi, 0);
                                                                                                                                                                                                                                             |     }
    0x0042db01 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (*((rbx + 0x20)) != 0x17) {
    0x0042db06 jne 0x42dbcf                                                                                                                                                                                                                  |         goto label_10;
                                                                                                                                                                                                                                             |     }
    0x0042db0c mov rdi, rbx                                                                                                                                                                                                                  |     rdi = rbx;
    0x0042db0f jmp 0x42dbd2                                                                                                                                                                                                                  |     goto label_11;
                                                                                                                                                                                                                                             | label_4:
    0x0042db14 test ax, ax                                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (ax == 0) {
    0x0042db17 je 0x42dbaa                                                                                                                                                                                                                   |         goto label_12;
                                                                                                                                                                                                                                             |     }
    0x0042db1d mov rcx, r15                                                                                                                                                                                                                  |     rcx = r15;
    0x0042db20 jmp 0x42db48                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     while (edi != 0xd800) {
    0x0042db30 cmp eax, 0x800                                                                                                                                                                                                                |         
    0x0042db35 sbb rsi, 0                                                                                                                                                                                                                    |         
    0x0042db39 add rsi, 3                                                                                                                                                                                                                    |         rsi += 3;
                                                                                                                                                                                                                                             | label_3:
    0x0042db3d movzx eax, word [rdx]                                                                                                                                                                                                         |         eax = *(rdx);
    0x0042db40 mov rcx, rdx                                                                                                                                                                                                                  |         rcx = rdx;
    0x0042db43 test ax, ax                                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (ax == 0) {
    0x0042db46 je 0x42dbaa                                                                                                                                                                                                                   |             goto label_12;
                                                                                                                                                                                                                                             |         }
    0x0042db48 cmp ax, 0x7f                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |         if (ax <= 0x7f) {
    0x0042db4c ja 0x42db60                                                                                                                                                                                                                   |             
    0x0042db4e add rcx, 2                                                                                                                                                                                                                    |             rcx += 2;
    0x0042db52 inc rsi                                                                                                                                                                                                                       |             rsi++;
    0x0042db55 jmp 0x42dba0                                                                                                                                                                                                                  |             goto label_13;
                                                                                                                                                                                                                                             |         }
    0x0042db60 movzx eax, ax                                                                                                                                                                                                                 |         eax = (int32_t) ax;
    0x0042db63 mov edi, eax                                                                                                                                                                                                                  |         edi = eax;
    0x0042db65 and edi, 0xf800                                                                                                                                                                                                               |         edi &= 0xf800;
    0x0042db6b lea rdx, [rcx + 2]                                                                                                                                                                                                            |         rdx = rcx + 2;
    0x0042db6f cmp edi, 0xd800                                                                                                                                                                                                               |         
    0x0042db75 jne 0x42db30                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     }
    0x0042db77 and eax, 0xfc00                                                                                                                                                                                                               |     eax &= 0xfc00;
    0x0042db7c cmp eax, 0xd800                                                                                                                                                                                                               |     
                                                                                                                                                                                                                                             |     if (eax == 0xd800) {
    0x0042db81 jne 0x42dba5                                                                                                                                                                                                                  |         
    0x0042db83 movzx eax, word [rdx]                                                                                                                                                                                                         |         eax = *(rdx);
    0x0042db86 and eax, 0xfc00                                                                                                                                                                                                               |         eax &= 0xfc00;
    0x0042db8b movzx eax, ax                                                                                                                                                                                                                 |         eax = (int32_t) ax;
    0x0042db8e cmp eax, 0xdc00                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                             |         if (eax != 0xdc00) {
    0x0042db93 jne 0x42dba5                                                                                                                                                                                                                  |             goto label_14;
                                                                                                                                                                                                                                             |         }
    0x0042db95 add rcx, 4                                                                                                                                                                                                                    |         rcx += 4;
    0x0042db99 add rsi, 4                                                                                                                                                                                                                    |         rsi += 4;
    0x0042db9d nop dword [rax]                                                                                                                                                                                                               |         
                                                                                                                                                                                                                                             | label_13:
    0x0042dba0 mov rdx, rcx                                                                                                                                                                                                                  |         rdx = rcx;
    0x0042dba3 jmp 0x42db3d                                                                                                                                                                                                                  |         goto label_3;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_14:
    0x0042dba5 inc rsi                                                                                                                                                                                                                       |     rsi++;
    0x0042dba8 jmp 0x42db3d                                                                                                                                                                                                                  |     goto label_3;
                                                                                                                                                                                                                                             | label_12:
    0x0042dbaa inc rsi                                                                                                                                                                                                                       |     rsi++;
    0x0042dbad cmp rsi, qword [rbx + 0x18]                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                             |     if (rsi > *((rbx + 0x18))) {
    0x0042dbb1 jbe 0x42dbc3                                                                                                                                                                                                                  |         
    0x0042dbb3 cmp rsi, 0xffffffffffffffff                                                                                                                                                                                                   |         
                                                                                                                                                                                                                                             |         if (rsi == -1) {
    0x0042dbb7 je 0x42dc20                                                                                                                                                                                                                   |             goto label_9;
                                                                                                                                                                                                                                             |         }
    0x0042dbb9 mov rdi, rbx                                                                                                                                                                                                                  |         
    0x0042dbbc xor edx, edx                                                                                                                                                                                                                  |         
    0x0042dbbe call 0x437b80                                                                                                                                                                                                                 |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (rbx, rsi, 0);
                                                                                                                                                                                                                                             |     }
    0x0042dbc3 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                             |     if (*((rbx + 0x20)) == 0x17) {
    0x0042dbc8 jne 0x42dbe6                                                                                                                                                                                                                  |         
    0x0042dbca mov rdi, rbx                                                                                                                                                                                                                  |         rdi = rbx;
    0x0042dbcd jmp 0x42dbe9                                                                                                                                                                                                                  |         goto label_15;
                                                                                                                                                                                                                                             | label_10:
    0x0042dbcf mov rdi, qword [rbx]                                                                                                                                                                                                          |         rdi = *(rbx);
                                                                                                                                                                                                                                             | label_11:
    0x0042dbd2 movsx r8d, bpl                                                                                                                                                                                                                |         r8d = (int32_t) bpl;
    0x0042dbd6 mov rcx, rsp                                                                                                                                                                                                                  |         rcx = rsp;
    0x0042dbd9 mov rsi, r15                                                                                                                                                                                                                  |         rsi = r15;
    0x0042dbdc mov rdx, r14                                                                                                                                                                                                                  |         rdx = r14;
    0x0042dbdf call 0x432d30                                                                                                                                                                                                                 |         int(anonymousnamespace)::localUtf16ToUtf8<unsignedshort,(anonymousnamespace)::NoOpCapacity,(anonymousnamespace)::Utf16::ZeroBasedEnd<unsignedshort>,(anonymousnamespace)::Swapper<unsignedshort>>(char*,(anonymousnamespace)::NoOpCapacity,unsignedshortconst*,(anonymousnamespace)::Utf16::ZeroBasedEnd<unsignedshort>,(anonymousnamespace)::Swapper<unsignedshort>,unsigned long*,unsigned long*,char) ();
    0x0042dbe4 jmp 0x42dbfb                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                             |     } else {
    0x0042dbe6 mov rdi, qword [rbx]                                                                                                                                                                                                          |         rdi = *(rbx);
                                                                                                                                                                                                                                             | label_15:
    0x0042dbe9 movsx r8d, bpl                                                                                                                                                                                                                |         r8d = (int32_t) bpl;
    0x0042dbed mov rcx, rsp                                                                                                                                                                                                                  |         rcx = rsp;
    0x0042dbf0 mov rsi, r15                                                                                                                                                                                                                  |         rsi = r15;
    0x0042dbf3 mov rdx, r14                                                                                                                                                                                                                  |         rdx = r14;
    0x0042dbf6 call 0x432ba0                                                                                                                                                                                                                 |         eax = int(anonymousnamespace)::localUtf16ToUtf8<unsignedshort,(anonymousnamespace)::NoOpCapacity,(anonymousnamespace)::Utf16::ZeroBasedEnd<unsignedshort>,(anonymousnamespace)::NoOpSwapper<unsignedshort>>(char*,(anonymousnamespace)::NoOpCapacity,unsignedshortconst*,(anonymousnamespace)::Utf16::ZeroBasedEnd<unsignedshort>,(anonymousnamespace)::NoOpSwapper<unsignedshort>,unsigned long*,unsigned long*,char) ();
                                                                                                                                                                                                                                             |     }
    0x0042dbfb mov rsi, qword [rsp]                                                                                                                                                                                                          |     rsi = *(rsp);
    0x0042dbff test rsi, rsi                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                             |     if (rsi != 0) {
    0x0042dc02 je 0x42dc20                                                                                                                                                                                                                   |         
    0x0042dc04 mov ebp, eax                                                                                                                                                                                                                  |         
    0x0042dc06 dec rsi                                                                                                                                                                                                                       |         rsi--;
    0x0042dc09 mov rdi, rbx                                                                                                                                                                                                                  |         
    0x0042dc0c xor edx, edx                                                                                                                                                                                                                  |         
    0x0042dc0e call 0x437b80                                                                                                                                                                                                                 |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (rbx, rsi, 0);
    0x0042dc13 mov eax, ebp                                                                                                                                                                                                                  |         eax = ebp;
    0x0042dc15 add rsp, 8                                                                                                                                                                                                                    |         
    0x0042dc19 pop rbx                                                                                                                                                                                                                       |         
    0x0042dc1a pop r14                                                                                                                                                                                                                       |         
    0x0042dc1c pop r15                                                                                                                                                                                                                       |         
    0x0042dc1e pop rbp                                                                                                                                                                                                                       |         
    0x0042dc1f ret                                                                                                                                                                                                                           |         return eax;
                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                             | label_9:
    0x0042dc20 mov edi, 0x45f3de                                                                                                                                                                                                             |     
    0x0042dc25 call 0x435240                                                                                                                                                                                                                 |     return BloombergLP::bslstl::StdExceptUtil::throwLengthError(char const*) ("string<...>::resize(n): string too long");
                                                                                                                                                                                                                                             | }