; assembly                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                             | /* balxml_encoder.t/assume @ 0x4e8710 */
                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                             |  
    ; (fcn) method.int_BloombergLP::bdlde::Base64Encoder::endConvert_std::__1::ostreambuf_iterator_char__std::__1.char_traits_char______std::__1::ostreambuf_iterator_char__std::__1::char_traits_char_____int__int_ ()      | int32_t method_int_BloombergLP::bdlde::Base64Encoder::endConvert_std::_1::ostreambuf_iterator_char_std::_1_char_traits_char_std::_1::ostreambuf_iterator_char_std::_1::char_traits_char_int_int_ (int64_t arg4, int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                             |     rcx = arg4;
                                                                                                                                                                                                                             |     rdx = arg3;
                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                             |     /* int BloombergLP::bdlde::Base64Encoder::endConvert<std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> > >(std::__1::ostreambuf_iterator<char, std::__1::char_traits<char> >, int*, int) */
    0x004e8710 push rbp                                                                                                                                                                                                      |     
    0x004e8711 push r15                                                                                                                                                                                                      |     
    0x004e8713 push r14                                                                                                                                                                                                      |     
    0x004e8715 push r13                                                                                                                                                                                                      |     
    0x004e8717 push r12                                                                                                                                                                                                      |     
    0x004e8719 push rbx                                                                                                                                                                                                      |     
    0x004e871a push rax                                                                                                                                                                                                      |     
    0x004e871b mov r14, rdx                                                                                                                                                                                                  |     r14 = rdx;
    0x004e871e mov rbx, rdi                                                                                                                                                                                                  |     rbx = rdi;
    0x004e8721 mov qword [rsp], rsi                                                                                                                                                                                          |     *(rsp) = rsi;
    0x004e8725 mov al, byte [rdi]                                                                                                                                                                                            |     al = *(rdi);
    0x004e8727 cmp al, 0xff                                                                                                                                                                                                  |     
                                                                                                                                                                                                                             |     if (al != 0xff) {
    0x004e8729 je 0x4e8770                                                                                                                                                                                                   |         
    0x004e872b mov r8d, ecx                                                                                                                                                                                                  |         r8d = ecx;
    0x004e872e cmp al, 1                                                                                                                                                                                                     |         
                                                                                                                                                                                                                             |         if (al != 1) {
    0x004e8730 jne 0x4e8784                                                                                                                                                                                                  |             goto label_1;
                                                                                                                                                                                                                             |         }
    0x004e8732 mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |         eax = *((rbx + 0x14));
    0x004e8735 test eax, eax                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (eax != 0) {
    0x004e8737 jne 0x4e8787                                                                                                                                                                                                  |             goto label_2;
                                                                                                                                                                                                                             |         }
    0x004e8739 mov ecx, dword [rbx + 4]                                                                                                                                                                                      |         ecx = *((rbx + 4));
    0x004e873c mov eax, dword [rbx + 0xc]                                                                                                                                                                                    |         eax = *((rbx + 0xc));
    0x004e873f test ecx, ecx                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (ecx != 0) {
    0x004e8741 je 0x4e8759                                                                                                                                                                                                   |             
    0x004e8743 lea esi, [rcx + 2]                                                                                                                                                                                            |             esi = rcx + 2;
    0x004e8746 xor edx, edx                                                                                                                                                                                                  |             edx = 0;
    0x004e8748 div esi                                                                                                                                                                                                       |             eax = edx:eax / esi;
                                                                                                                                                                                                                             |             edx = edx:eax % esi;
    0x004e874a xor esi, esi                                                                                                                                                                                                  |             esi = 0;
    0x004e874c cmp edx, ecx                                                                                                                                                                                                  |             
    0x004e874e setg sil                                                                                                                                                                                                      |             sil = (edx > ecx) ? 1 : 0;
    0x004e8752 imul eax, ecx                                                                                                                                                                                                 |             eax *= ecx;
    0x004e8755 add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e8757 sub eax, esi                                                                                                                                                                                                  |             eax -= esi;
                                                                                                                                                                                                                             |         }
    0x004e8759 test al, 3                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if ((al & 3) == 0) {
    0x004e875b je 0x4e8770                                                                                                                                                                                                   |             goto label_3;
                                                                                                                                                                                                                             |         }
    0x004e875d mov r12d, dword [rbx + 0xc]                                                                                                                                                                                   |         r12d = *((rbx + 0xc));
    0x004e8761 add r8d, r12d                                                                                                                                                                                                 |         r8d += r12d;
    0x004e8764 lea r13, [rbx + 0x14]                                                                                                                                                                                         |         r13 = rbx + 0x14;
    0x004e8768 mov ebp, r8d                                                                                                                                                                                                  |         
    0x004e876b jmp 0x4e87f7                                                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                             | label_3:
    0x004e8770 mov byte [rbx], 0xff                                                                                                                                                                                          |     *(rbx) = 0xff;
    0x004e8773 mov dword [r14], 0                                                                                                                                                                                            |     *(r14) = 0;
    0x004e877a mov ecx, 0xffffffff                                                                                                                                                                                           |     ecx = 0xffffffff;
    0x004e877f jmp 0x4e8881                                                                                                                                                                                                  |     goto label_5;
                                                                                                                                                                                                                             | label_1:
    0x004e8784 mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |     eax = *((rbx + 0x14));
                                                                                                                                                                                                                             | label_2:
    0x004e8787 mov r12d, dword [rbx + 0xc]                                                                                                                                                                                   |     r12d = *((rbx + 0xc));
    0x004e878b movsxd rdx, eax                                                                                                                                                                                               |     rdx = (int64_t) eax;
    0x004e878e imul rcx, rdx, 0x2aaaaaab                                                                                                                                                                                     |     rcx = rdx * 0x2aaaaaab;
    0x004e8795 mov rsi, rcx                                                                                                                                                                                                  |     rsi = rcx;
    0x004e8798 shr rsi, 0x3f                                                                                                                                                                                                 |     rsi >>= 0x3f;
    0x004e879c shr rcx, 0x20                                                                                                                                                                                                 |     rcx >>= 0x20;
    0x004e87a0 add ecx, esi                                                                                                                                                                                                  |     ecx += esi;
    0x004e87a2 add ecx, ecx                                                                                                                                                                                                  |     ecx += ecx;
    0x004e87a4 lea ecx, [rcx + rcx*2]                                                                                                                                                                                        |     ecx = rcx * 3;
    0x004e87a7 sub edx, ecx                                                                                                                                                                                                  |     edx -= ecx;
                                                                                                                                                                                                                             |     if (edx != 0) {
    0x004e87a9 je 0x4e87ba                                                                                                                                                                                                   |         
    0x004e87ab mov ecx, 6                                                                                                                                                                                                    |         ecx = 6;
    0x004e87b0 sub ecx, edx                                                                                                                                                                                                  |         ecx -= edx;
    0x004e87b2 shl dword [rbx + 0x10], cl                                                                                                                                                                                    |         *((rbx + 0x10)) <<= cl;
    0x004e87b5 add eax, ecx                                                                                                                                                                                                  |         eax += ecx;
    0x004e87b7 mov dword [rbx + 0x14], eax                                                                                                                                                                                   |         *((rbx + 0x14)) = eax;
                                                                                                                                                                                                                             |     }
    0x004e87ba lea ebp, [r12 + r8]                                                                                                                                                                                           |     ebp = r12 + r8;
    0x004e87be lea r13, [rbx + 0x14]                                                                                                                                                                                         |     r13 = rbx + 0x14;
    0x004e87c2 cmp eax, 6                                                                                                                                                                                                    |     
                                                                                                                                                                                                                             |     if (eax < 6) {
    0x004e87c5 jl 0x4e87ee                                                                                                                                                                                                   |         goto label_6;
                                                                                                                                                                                                                             |     }
    0x004e87c7 test r8d, r8d                                                                                                                                                                                                 |     
                                                                                                                                                                                                                             |     if (r8d == 0) {
    0x004e87ca je 0x4e87ea                                                                                                                                                                                                   |         goto label_7;
                                                                                                                                                                                                                             |     }
    0x004e87cc mov r15, rsp                                                                                                                                                                                                  |     r15 = rsp;
    0x004e87cf nop                                                                                                                                                                                                           |     
                                                                                                                                                                                                                             |     do {
    0x004e87d0 mov rdi, rbx                                                                                                                                                                                                  |         
    0x004e87d3 mov rsi, r15                                                                                                                                                                                                  |         
    0x004e87d6 mov edx, ebp                                                                                                                                                                                                  |         
    0x004e87d8 call 0x4e8600                                                                                                                                                                                                 |         voidBloombergLP::bdlde::Base64Encoder::encode<std::_1::ostreambuf_iterator<char,std::_1::char_traits<char>>>(std::_1::ostreambuf_iterator<char,std::_1::char_traits<char>>*,int) (rbx, r15, ebp);
    0x004e87dd mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |         eax = *((rbx + 0x14));
    0x004e87e0 cmp eax, 6                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if (eax < 6) {
    0x004e87e3 jl 0x4e87ee                                                                                                                                                                                                   |             goto label_6;
                                                                                                                                                                                                                             |         }
    0x004e87e5 cmp dword [rbx + 0xc], ebp                                                                                                                                                                                    |         
    0x004e87e8 jne 0x4e87d0                                                                                                                                                                                                  |         
                                                                                                                                                                                                                             |     } while (*((rbx + 0xc)) != ebp);
                                                                                                                                                                                                                             |     do {
                                                                                                                                                                                                                             | label_7:
    0x004e87ea mov ecx, ebp                                                                                                                                                                                                  |         ecx = ebp;
    0x004e87ec jmp 0x4e8843                                                                                                                                                                                                  |         goto label_8;
                                                                                                                                                                                                                             | label_6:
    0x004e87ee test eax, eax                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (eax != 0) {
    0x004e87f0 je 0x4e87f7                                                                                                                                                                                                   |             
    0x004e87f2 mov ecx, dword [rbx + 0xc]                                                                                                                                                                                    |             ecx = *((rbx + 0xc));
    0x004e87f5 jmp 0x4e8843                                                                                                                                                                                                  |             goto label_8;
                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                             | label_4:
    0x004e87f7 mov r15, rsp                                                                                                                                                                                                  |         r15 = rsp;
    0x004e87fa nop word [rax + rax]                                                                                                                                                                                          |         
                                                                                                                                                                                                                             | label_0:
    0x004e8800 mov esi, dword [rbx + 4]                                                                                                                                                                                      |         esi = *((rbx + 4));
    0x004e8803 mov ecx, dword [rbx + 0xc]                                                                                                                                                                                    |         ecx = *((rbx + 0xc));
    0x004e8806 mov eax, ecx                                                                                                                                                                                                  |         eax = *((rbx + 0xc));
    0x004e8808 test esi, esi                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (esi != 0) {
    0x004e880a je 0x4e8824                                                                                                                                                                                                   |             
    0x004e880c lea edi, [rsi + 2]                                                                                                                                                                                            |             edi = rsi + 2;
    0x004e880f mov eax, ecx                                                                                                                                                                                                  |             eax = ecx;
    0x004e8811 xor edx, edx                                                                                                                                                                                                  |             edx = 0;
    0x004e8813 div edi                                                                                                                                                                                                       |             eax = edx:eax / edi;
                                                                                                                                                                                                                             |             edx = edx:eax % edi;
    0x004e8815 xor edi, edi                                                                                                                                                                                                  |             edi = 0;
    0x004e8817 cmp edx, esi                                                                                                                                                                                                  |             
    0x004e8819 setg dil                                                                                                                                                                                                      |             dil = (edx > esi) ? 1 : 0;
    0x004e881d imul eax, esi                                                                                                                                                                                                 |             eax *= esi;
    0x004e8820 add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e8822 sub eax, edi                                                                                                                                                                                                  |             eax -= edi;
                                                                                                                                                                                                                             |         }
    0x004e8824 test al, 3                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if ((al & 3) == 0) {
    0x004e8826 je 0x4e8840                                                                                                                                                                                                   |             goto label_9;
                                                                                                                                                                                                                             |         }
    0x004e8828 cmp ecx, ebp                                                                                                                                                                                                  |         
    0x004e882a je 0x4e87ea                                                                                                                                                                                                   |         
                                                                                                                                                                                                                             |     } while (ecx == ebp);
    0x004e882c mov rdi, rbx                                                                                                                                                                                                  |     
    0x004e882f mov rsi, r15                                                                                                                                                                                                  |     
    0x004e8832 mov edx, 0x3d                                                                                                                                                                                                 |     
    0x004e8837 mov ecx, ebp                                                                                                                                                                                                  |     
    0x004e8839 call 0x4e88a0                                                                                                                                                                                                 |     voidBloombergLP::bdlde::Base64Encoder::append<std::_1::ostreambuf_iterator<char,std::_1::char_traits<char>>>(std::_1::ostreambuf_iterator<char,std::_1::char_traits<char>>*,char,int) (rbx, r15, 0x3d, ebp);
    0x004e883e jmp 0x4e8800                                                                                                                                                                                                  |     goto label_0;
                                                                                                                                                                                                                             | label_9:
    0x004e8840 mov byte [rbx], 1                                                                                                                                                                                             |     *(rbx) = 1;
                                                                                                                                                                                                                             | label_8:
    0x004e8843 sub ecx, r12d                                                                                                                                                                                                 |     ecx -= r12d;
    0x004e8846 mov dword [r14], ecx                                                                                                                                                                                          |     *(r14) = ecx;
    0x004e8849 mov ecx, 1                                                                                                                                                                                                    |     ecx = 1;
    0x004e884e cmp byte [rbx], 1                                                                                                                                                                                             |     
                                                                                                                                                                                                                             |     if (*(rbx) == 1) {
    0x004e8851 jne 0x4e8881                                                                                                                                                                                                  |         
    0x004e8853 cmp dword [r13], 0                                                                                                                                                                                            |         
                                                                                                                                                                                                                             |         if (*(r13) != 0) {
    0x004e8858 jne 0x4e8881                                                                                                                                                                                                  |             goto label_5;
                                                                                                                                                                                                                             |         }
    0x004e885a mov ecx, dword [rbx + 4]                                                                                                                                                                                      |         ecx = *((rbx + 4));
    0x004e885d mov eax, dword [rbx + 0xc]                                                                                                                                                                                    |         eax = *((rbx + 0xc));
    0x004e8860 test ecx, ecx                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (ecx != 0) {
    0x004e8862 je 0x4e887a                                                                                                                                                                                                   |             
    0x004e8864 lea esi, [rcx + 2]                                                                                                                                                                                            |             esi = rcx + 2;
    0x004e8867 xor edx, edx                                                                                                                                                                                                  |             edx = 0;
    0x004e8869 div esi                                                                                                                                                                                                       |             eax = edx:eax / esi;
                                                                                                                                                                                                                             |             edx = edx:eax % esi;
    0x004e886b xor esi, esi                                                                                                                                                                                                  |             esi = 0;
    0x004e886d cmp edx, ecx                                                                                                                                                                                                  |             
    0x004e886f setg sil                                                                                                                                                                                                      |             sil = (edx > ecx) ? 1 : 0;
    0x004e8873 imul eax, ecx                                                                                                                                                                                                 |             eax *= ecx;
    0x004e8876 add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e8878 sub eax, esi                                                                                                                                                                                                  |             eax -= esi;
                                                                                                                                                                                                                             |         }
    0x004e887a xor ecx, ecx                                                                                                                                                                                                  |         ecx = 0;
    0x004e887c test al, 3                                                                                                                                                                                                    |         
    0x004e887e setne cl                                                                                                                                                                                                      |         cl = ((al & 3) != 0) ? 1 : 0;
                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                             | label_5:
    0x004e8881 mov eax, ecx                                                                                                                                                                                                  |     eax = ecx;
    0x004e8883 add rsp, 8                                                                                                                                                                                                    |     
    0x004e8887 pop rbx                                                                                                                                                                                                       |     
    0x004e8888 pop r12                                                                                                                                                                                                       |     
    0x004e888a pop r13                                                                                                                                                                                                       |     
    0x004e888c pop r14                                                                                                                                                                                                       |     
    0x004e888e pop r15                                                                                                                                                                                                       |     
    0x004e8890 pop rbp                                                                                                                                                                                                       |     
    0x004e8891 ret                                                                                                                                                                                                           |     return eax;
                                                                                                                                                                                                                             | }