; assembly                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                             | /* balxml_encoder.t/none @ 0x4e8f10 */
                                                                                                                                                                                                                             | #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, uint32_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) */
    0x004e8f10 push rbp                                                                                                                                                                                                      |     
    0x004e8f11 push r15                                                                                                                                                                                                      |     
    0x004e8f13 push r14                                                                                                                                                                                                      |     
    0x004e8f15 push r13                                                                                                                                                                                                      |     
    0x004e8f17 push r12                                                                                                                                                                                                      |     
    0x004e8f19 push rbx                                                                                                                                                                                                      |     
    0x004e8f1a push rax                                                                                                                                                                                                      |     
    0x004e8f1b mov r14, rdx                                                                                                                                                                                                  |     r14 = rdx;
    0x004e8f1e mov rbx, rdi                                                                                                                                                                                                  |     rbx = rdi;
    0x004e8f21 mov qword [rsp], rsi                                                                                                                                                                                          |     *(rsp) = rsi;
    0x004e8f25 mov al, byte [rdi]                                                                                                                                                                                            |     al = *(rdi);
    0x004e8f27 cmp al, 0xff                                                                                                                                                                                                  |     
                                                                                                                                                                                                                             |     if (al != 0xff) {
    0x004e8f29 je 0x4e8f6f                                                                                                                                                                                                   |         
    0x004e8f2b mov r8d, ecx                                                                                                                                                                                                  |         r8d = ecx;
    0x004e8f2e cmp al, 1                                                                                                                                                                                                     |         
                                                                                                                                                                                                                             |         if (al != 1) {
    0x004e8f30 jne 0x4e8f83                                                                                                                                                                                                  |             goto label_1;
                                                                                                                                                                                                                             |         }
    0x004e8f32 mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |         eax = *((rbx + 0x14));
    0x004e8f35 test eax, eax                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (eax != 0) {
    0x004e8f37 jne 0x4e8f86                                                                                                                                                                                                  |             goto label_2;
                                                                                                                                                                                                                             |         }
    0x004e8f39 mov ecx, dword [rbx + 4]                                                                                                                                                                                      |         ecx = *((rbx + 4));
    0x004e8f3c mov eax, dword [rbx + 0xc]                                                                                                                                                                                    |         eax = *((rbx + 0xc));
    0x004e8f3f test ecx, ecx                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (ecx != 0) {
    0x004e8f41 je 0x4e8f58                                                                                                                                                                                                   |             
    0x004e8f43 lea esi, [rcx + 2]                                                                                                                                                                                            |             esi = rcx + 2;
    0x004e8f46 cdq                                                                                                                                                                                                           |             edx:eax = (int64_t) eax;
    0x004e8f47 idiv esi                                                                                                                                                                                                      |             eax = edx:eax / esi;
                                                                                                                                                                                                                             |             edx = edx:eax % esi;
    0x004e8f49 xor esi, esi                                                                                                                                                                                                  |             esi = 0;
    0x004e8f4b cmp edx, ecx                                                                                                                                                                                                  |             
    0x004e8f4d setg sil                                                                                                                                                                                                      |             sil = (edx > ecx) ? 1 : 0;
    0x004e8f51 imul eax, ecx                                                                                                                                                                                                 |             eax *= ecx;
    0x004e8f54 add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e8f56 sub eax, esi                                                                                                                                                                                                  |             eax -= esi;
                                                                                                                                                                                                                             |         }
    0x004e8f58 test al, 3                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if ((al & 3) == 0) {
    0x004e8f5a je 0x4e8f6f                                                                                                                                                                                                   |             goto label_3;
                                                                                                                                                                                                                             |         }
    0x004e8f5c mov r12d, dword [rbx + 0xc]                                                                                                                                                                                   |         r12d = *((rbx + 0xc));
    0x004e8f60 add r8d, r12d                                                                                                                                                                                                 |         r8d += r12d;
    0x004e8f63 lea r13, [rbx + 0x14]                                                                                                                                                                                         |         r13 = rbx + 0x14;
    0x004e8f67 mov ebp, r8d                                                                                                                                                                                                  |         
    0x004e8f6a jmp 0x4e8ff7                                                                                                                                                                                                  |         goto label_4;
                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                             | label_3:
    0x004e8f6f mov byte [rbx], 0xff                                                                                                                                                                                          |     *(rbx) = 0xff;
    0x004e8f72 mov dword [r14], 0                                                                                                                                                                                            |     *(r14) = 0;
    0x004e8f79 mov ecx, 0xffffffff                                                                                                                                                                                           |     ecx = 0xffffffff;
    0x004e8f7e jmp 0x4e907f                                                                                                                                                                                                  |     goto label_5;
                                                                                                                                                                                                                             | label_1:
    0x004e8f83 mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |     eax = *((rbx + 0x14));
                                                                                                                                                                                                                             | label_2:
    0x004e8f86 mov r12d, dword [rbx + 0xc]                                                                                                                                                                                   |     r12d = *((rbx + 0xc));
    0x004e8f8a movsxd rdx, eax                                                                                                                                                                                               |     rdx = (int64_t) eax;
    0x004e8f8d imul rcx, rdx, 0x2aaaaaab                                                                                                                                                                                     |     rcx = rdx * 0x2aaaaaab;
    0x004e8f94 mov rsi, rcx                                                                                                                                                                                                  |     rsi = rcx;
    0x004e8f97 shr rsi, 0x3f                                                                                                                                                                                                 |     rsi >>= 0x3f;
    0x004e8f9b shr rcx, 0x20                                                                                                                                                                                                 |     rcx >>= 0x20;
    0x004e8f9f add ecx, esi                                                                                                                                                                                                  |     ecx += esi;
    0x004e8fa1 add ecx, ecx                                                                                                                                                                                                  |     ecx += ecx;
    0x004e8fa3 lea ecx, [rcx + rcx*2]                                                                                                                                                                                        |     ecx = rcx * 3;
    0x004e8fa6 sub edx, ecx                                                                                                                                                                                                  |     edx -= ecx;
                                                                                                                                                                                                                             |     if (edx != 0) {
    0x004e8fa8 je 0x4e8fb9                                                                                                                                                                                                   |         
    0x004e8faa mov ecx, 6                                                                                                                                                                                                    |         ecx = 6;
    0x004e8faf sub ecx, edx                                                                                                                                                                                                  |         ecx -= edx;
    0x004e8fb1 shl dword [rbx + 0x10], cl                                                                                                                                                                                    |         *((rbx + 0x10)) <<= cl;
    0x004e8fb4 add eax, ecx                                                                                                                                                                                                  |         eax += ecx;
    0x004e8fb6 mov dword [rbx + 0x14], eax                                                                                                                                                                                   |         *((rbx + 0x14)) = eax;
                                                                                                                                                                                                                             |     }
    0x004e8fb9 lea ebp, [r12 + r8]                                                                                                                                                                                           |     ebp = r12 + r8;
    0x004e8fbd lea r13, [rbx + 0x14]                                                                                                                                                                                         |     r13 = rbx + 0x14;
    0x004e8fc1 cmp eax, 6                                                                                                                                                                                                    |     
                                                                                                                                                                                                                             |     if (eax < 6) {
    0x004e8fc4 jl 0x4e8fee                                                                                                                                                                                                   |         goto label_6;
                                                                                                                                                                                                                             |     }
    0x004e8fc6 test r8d, r8d                                                                                                                                                                                                 |     
                                                                                                                                                                                                                             |     if (r8d == 0) {
    0x004e8fc9 je 0x4e8fea                                                                                                                                                                                                   |         goto label_7;
                                                                                                                                                                                                                             |     }
    0x004e8fcb mov r15, rsp                                                                                                                                                                                                  |     r15 = rsp;
    0x004e8fce nop                                                                                                                                                                                                           |     
                                                                                                                                                                                                                             |     do {
    0x004e8fd0 mov rdi, rbx                                                                                                                                                                                                  |         
    0x004e8fd3 mov rsi, r15                                                                                                                                                                                                  |         
    0x004e8fd6 mov edx, ebp                                                                                                                                                                                                  |         
    0x004e8fd8 call 0x4e8e00                                                                                                                                                                                                 |         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);
    0x004e8fdd mov eax, dword [rbx + 0x14]                                                                                                                                                                                   |         eax = *((rbx + 0x14));
    0x004e8fe0 cmp eax, 6                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if (eax < 6) {
    0x004e8fe3 jl 0x4e8fee                                                                                                                                                                                                   |             goto label_6;
                                                                                                                                                                                                                             |         }
    0x004e8fe5 cmp dword [rbx + 0xc], ebp                                                                                                                                                                                    |         
    0x004e8fe8 jne 0x4e8fd0                                                                                                                                                                                                  |         
                                                                                                                                                                                                                             |     } while (*((rbx + 0xc)) != ebp);
                                                                                                                                                                                                                             |     do {
                                                                                                                                                                                                                             | label_7:
    0x004e8fea mov ecx, ebp                                                                                                                                                                                                  |         ecx = ebp;
    0x004e8fec jmp 0x4e9042                                                                                                                                                                                                  |         goto label_8;
                                                                                                                                                                                                                             | label_6:
    0x004e8fee test eax, eax                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (eax != 0) {
    0x004e8ff0 je 0x4e8ff7                                                                                                                                                                                                   |             
    0x004e8ff2 mov ecx, dword [rbx + 0xc]                                                                                                                                                                                    |             ecx = *((rbx + 0xc));
    0x004e8ff5 jmp 0x4e9042                                                                                                                                                                                                  |             goto label_8;
                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                             | label_4:
    0x004e8ff7 mov r15, rsp                                                                                                                                                                                                  |         r15 = rsp;
    0x004e8ffa nop word [rax + rax]                                                                                                                                                                                          |         
                                                                                                                                                                                                                             | label_0:
    0x004e9000 mov esi, dword [rbx + 4]                                                                                                                                                                                      |         esi = *((rbx + 4));
    0x004e9003 mov ecx, dword [rbx + 0xc]                                                                                                                                                                                    |         ecx = *((rbx + 0xc));
    0x004e9006 mov eax, ecx                                                                                                                                                                                                  |         eax = *((rbx + 0xc));
    0x004e9008 test esi, esi                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (esi != 0) {
    0x004e900a je 0x4e9023                                                                                                                                                                                                   |             
    0x004e900c lea edi, [rsi + 2]                                                                                                                                                                                            |             edi = rsi + 2;
    0x004e900f mov eax, ecx                                                                                                                                                                                                  |             eax = ecx;
    0x004e9011 cdq                                                                                                                                                                                                           |             edx:eax = (int64_t) eax;
    0x004e9012 idiv edi                                                                                                                                                                                                      |             eax = edx:eax / edi;
                                                                                                                                                                                                                             |             edx = edx:eax % edi;
    0x004e9014 xor edi, edi                                                                                                                                                                                                  |             edi = 0;
    0x004e9016 cmp edx, esi                                                                                                                                                                                                  |             
    0x004e9018 setg dil                                                                                                                                                                                                      |             dil = (edx > esi) ? 1 : 0;
    0x004e901c imul eax, esi                                                                                                                                                                                                 |             eax *= esi;
    0x004e901f add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e9021 sub eax, edi                                                                                                                                                                                                  |             eax -= edi;
                                                                                                                                                                                                                             |         }
    0x004e9023 test al, 3                                                                                                                                                                                                    |         
                                                                                                                                                                                                                             |         if ((al & 3) == 0) {
    0x004e9025 je 0x4e903f                                                                                                                                                                                                   |             goto label_9;
                                                                                                                                                                                                                             |         }
    0x004e9027 cmp ecx, ebp                                                                                                                                                                                                  |         
    0x004e9029 je 0x4e8fea                                                                                                                                                                                                   |         
                                                                                                                                                                                                                             |     } while (ecx == ebp);
    0x004e902b mov rdi, rbx                                                                                                                                                                                                  |     
    0x004e902e mov rsi, r15                                                                                                                                                                                                  |     
    0x004e9031 mov edx, 0x3d                                                                                                                                                                                                 |     
    0x004e9036 mov ecx, ebp                                                                                                                                                                                                  |     
    0x004e9038 call 0x4e9090                                                                                                                                                                                                 |     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);
    0x004e903d jmp 0x4e9000                                                                                                                                                                                                  |     goto label_0;
                                                                                                                                                                                                                             | label_9:
    0x004e903f mov byte [rbx], 1                                                                                                                                                                                             |     *(rbx) = 1;
                                                                                                                                                                                                                             | label_8:
    0x004e9042 sub ecx, r12d                                                                                                                                                                                                 |     ecx -= r12d;
    0x004e9045 mov dword [r14], ecx                                                                                                                                                                                          |     *(r14) = ecx;
    0x004e9048 mov ecx, 1                                                                                                                                                                                                    |     ecx = 1;
    0x004e904d cmp byte [rbx], 1                                                                                                                                                                                             |     
                                                                                                                                                                                                                             |     if (*(rbx) == 1) {
    0x004e9050 jne 0x4e907f                                                                                                                                                                                                  |         
    0x004e9052 cmp dword [r13], 0                                                                                                                                                                                            |         
                                                                                                                                                                                                                             |         if (*(r13) != 0) {
    0x004e9057 jne 0x4e907f                                                                                                                                                                                                  |             goto label_5;
                                                                                                                                                                                                                             |         }
    0x004e9059 mov ecx, dword [rbx + 4]                                                                                                                                                                                      |         ecx = *((rbx + 4));
    0x004e905c mov eax, dword [rbx + 0xc]                                                                                                                                                                                    |         eax = *((rbx + 0xc));
    0x004e905f test ecx, ecx                                                                                                                                                                                                 |         
                                                                                                                                                                                                                             |         if (ecx != 0) {
    0x004e9061 je 0x4e9078                                                                                                                                                                                                   |             
    0x004e9063 lea esi, [rcx + 2]                                                                                                                                                                                            |             esi = rcx + 2;
    0x004e9066 cdq                                                                                                                                                                                                           |             edx:eax = (int64_t) eax;
    0x004e9067 idiv esi                                                                                                                                                                                                      |             eax = edx:eax / esi;
                                                                                                                                                                                                                             |             edx = edx:eax % esi;
    0x004e9069 xor esi, esi                                                                                                                                                                                                  |             esi = 0;
    0x004e906b cmp edx, ecx                                                                                                                                                                                                  |             
    0x004e906d setg sil                                                                                                                                                                                                      |             sil = (edx > ecx) ? 1 : 0;
    0x004e9071 imul eax, ecx                                                                                                                                                                                                 |             eax *= ecx;
    0x004e9074 add eax, edx                                                                                                                                                                                                  |             eax += edx;
    0x004e9076 sub eax, esi                                                                                                                                                                                                  |             eax -= esi;
                                                                                                                                                                                                                             |         }
    0x004e9078 xor ecx, ecx                                                                                                                                                                                                  |         ecx = 0;
    0x004e907a test al, 3                                                                                                                                                                                                    |         
    0x004e907c setne cl                                                                                                                                                                                                      |         cl = ((al & 3) != 0) ? 1 : 0;
                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                             | label_5:
    0x004e907f mov eax, ecx                                                                                                                                                                                                  |     eax = ecx;
    0x004e9081 add rsp, 8                                                                                                                                                                                                    |     
    0x004e9085 pop rbx                                                                                                                                                                                                       |     
    0x004e9086 pop r12                                                                                                                                                                                                       |     
    0x004e9088 pop r13                                                                                                                                                                                                       |     
    0x004e908a pop r14                                                                                                                                                                                                       |     
    0x004e908c pop r15                                                                                                                                                                                                       |     
    0x004e908e pop rbp                                                                                                                                                                                                       |     
    0x004e908f ret                                                                                                                                                                                                           |     return eax;
                                                                                                                                                                                                                             | }