; assembly                                                                                                                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                                                                                                                         | /* bdlt_fixutil.t/assume @ 0x43b640 */
                                                                                                                                                                                                                                         | #include <stdint.h>
                                                                                                                                                                                                                                         |  
    ; (fcn) method.BloombergLP::bdlt::FixUtil.generate_std::__1::basic_string_char__std::__1::char_traits_char___std::__1::allocator_char_____BloombergLP::bdlt::Date_const__BloombergLP::bdlt::FixUtilConfiguration_const_ ()           | uint64_t method_BloombergLP::bdlt::FixUtil_generate_std::_1::basic_string_char_std::_1::char_traits_char_std::_1::allocator_char_BloombergLP::bdlt::Date_const_BloombergLP::bdlt::FixUtilConfiguration_const_ (int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                         |     rsi = arg2;
                                                                                                                                                                                                                                         |     rdi = arg1;
                                                                                                                                                                                                                                         |     /* BloombergLP::bdlt::FixUtil::generate(std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >*, BloombergLP::bdlt::Date const&, BloombergLP::bdlt::FixUtilConfiguration const&) */
    0x0043b640 push r15                                                                                                                                                                                                                  |     
    0x0043b642 push r14                                                                                                                                                                                                                  |     
    0x0043b644 push r12                                                                                                                                                                                                                  |     
    0x0043b646 push rbx                                                                                                                                                                                                                  |     
    0x0043b647 push rax                                                                                                                                                                                                                  |     
    0x0043b648 mov r15, rsi                                                                                                                                                                                                              |     r15 = rsi;
    0x0043b64b mov r14, rdi                                                                                                                                                                                                              |     r14 = rdi;
    0x0043b64e mov esi, 8                                                                                                                                                                                                                |     esi = 8;
    0x0043b653 xor edx, edx                                                                                                                                                                                                              |     edx = 0;
    0x0043b655 call 0x4045a0                                                                                                                                                                                                             |     std::_1::basic_string<char,std::_1::char_traits<char>,std::_1::allocator<char>>::resize(unsigned long,char) ();
    0x0043b65a test byte [r14], 1                                                                                                                                                                                                        |     
                                                                                                                                                                                                                                         |     if ((*(r14) & 1) == 0) {
    0x0043b65e jne 0x43b666                                                                                                                                                                                                              |         
    0x0043b660 lea rbx, [r14 + 1]                                                                                                                                                                                                        |         rbx = r14 + 1;
    0x0043b664 jmp 0x43b66a                                                                                                                                                                                                              |         
                                                                                                                                                                                                                                         |     } else {
    0x0043b666 mov rbx, qword [r14 + 0x10]                                                                                                                                                                                               |         rbx = *((r14 + 0x10));
                                                                                                                                                                                                                                         |     }
    0x0043b66a mov edi, dword [r15]                                                                                                                                                                                                      |     
    0x0043b66d call 0x43d0a0                                                                                                                                                                                                             |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToYear(int) (*(r15), rsi);
    0x0043b672 mov ecx, eax                                                                                                                                                                                                              |     ecx = eax;
    0x0043b674 mov r12d, 0xcccccccd                                                                                                                                                                                                      |     r12d = 0xcccccccd;
    0x0043b67a imul rdx, rcx, 0x51eb851f                                                                                                                                                                                                 |     rdx = rcx * 0x51eb851f;
    0x0043b681 imul rsi, rcx, 0x10624dd3                                                                                                                                                                                                 |     rsi = rcx * 0x10624dd3;
    0x0043b688 imul rcx, r12                                                                                                                                                                                                             |     rcx *= r12;
    0x0043b68c shr rcx, 0x23                                                                                                                                                                                                             |     rcx >>= 0x23;
    0x0043b690 lea edi, [rcx + rcx]                                                                                                                                                                                                      |     edi = rcx + rcx;
    0x0043b693 lea edi, [rdi + rdi*4]                                                                                                                                                                                                    |     edi = rdi * 5;
    0x0043b696 sub eax, edi                                                                                                                                                                                                              |     eax -= edi;
    0x0043b698 or al, 0x30                                                                                                                                                                                                               |     al |= 0x30;
    0x0043b69a mov byte [rbx + 3], al                                                                                                                                                                                                    |     *((rbx + 3)) = al;
    0x0043b69d mov rax, rcx                                                                                                                                                                                                              |     rax = rcx;
    0x0043b6a0 imul rax, r12                                                                                                                                                                                                             |     rax *= r12;
    0x0043b6a4 shr rax, 0x23                                                                                                                                                                                                             |     rax >>= 0x23;
    0x0043b6a8 add eax, eax                                                                                                                                                                                                              |     eax += eax;
    0x0043b6aa lea eax, [rax + rax*4]                                                                                                                                                                                                    |     eax = rax * 5;
    0x0043b6ad sub ecx, eax                                                                                                                                                                                                              |     ecx -= eax;
    0x0043b6af or cl, 0x30                                                                                                                                                                                                               |     cl |= 0x30;
    0x0043b6b2 mov byte [rbx + 2], cl                                                                                                                                                                                                    |     *((rbx + 2)) = cl;
    0x0043b6b5 shr rdx, 0x25                                                                                                                                                                                                             |     rdx >>= 0x25;
    0x0043b6b9 mov rax, rdx                                                                                                                                                                                                              |     rax = rdx;
    0x0043b6bc imul rax, r12                                                                                                                                                                                                             |     rax *= r12;
    0x0043b6c0 shr rax, 0x23                                                                                                                                                                                                             |     rax >>= 0x23;
    0x0043b6c4 add eax, eax                                                                                                                                                                                                              |     eax += eax;
    0x0043b6c6 lea eax, [rax + rax*4]                                                                                                                                                                                                    |     eax = rax * 5;
    0x0043b6c9 sub edx, eax                                                                                                                                                                                                              |     edx -= eax;
    0x0043b6cb or dl, 0x30                                                                                                                                                                                                               |     dl |= 0x30;
    0x0043b6ce mov byte [rbx + 1], dl                                                                                                                                                                                                    |     *((rbx + 1)) = dl;
    0x0043b6d1 shr rsi, 0x26                                                                                                                                                                                                             |     rsi >>= 0x26;
    0x0043b6d5 mov rax, rsi                                                                                                                                                                                                              |     rax = rsi;
    0x0043b6d8 imul rax, r12                                                                                                                                                                                                             |     rax *= r12;
    0x0043b6dc shr rax, 0x23                                                                                                                                                                                                             |     rax >>= 0x23;
    0x0043b6e0 add eax, eax                                                                                                                                                                                                              |     eax += eax;
    0x0043b6e2 lea eax, [rax + rax*4]                                                                                                                                                                                                    |     eax = rax * 5;
    0x0043b6e5 sub esi, eax                                                                                                                                                                                                              |     esi -= eax;
    0x0043b6e7 or sil, 0x30                                                                                                                                                                                                              |     sil |= 0x30;
    0x0043b6eb mov byte [rbx], sil                                                                                                                                                                                                       |     *(rbx) = sil;
    0x0043b6ee mov edi, dword [r15]                                                                                                                                                                                                      |     
    0x0043b6f1 call 0x43d060                                                                                                                                                                                                             |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToMonth(int) (*(r15), rsi);
    0x0043b6f6 mov ecx, eax                                                                                                                                                                                                              |     ecx = eax;
    0x0043b6f8 imul rcx, r12                                                                                                                                                                                                             |     rcx *= r12;
    0x0043b6fc shr rcx, 0x23                                                                                                                                                                                                             |     rcx >>= 0x23;
    0x0043b700 lea edx, [rcx + rcx]                                                                                                                                                                                                      |     edx = rcx + rcx;
    0x0043b703 lea edx, [rdx + rdx*4]                                                                                                                                                                                                    |     edx = rdx * 5;
    0x0043b706 sub eax, edx                                                                                                                                                                                                              |     eax -= edx;
    0x0043b708 or al, 0x30                                                                                                                                                                                                               |     al |= 0x30;
    0x0043b70a mov byte [rbx + 5], al                                                                                                                                                                                                    |     *((rbx + 5)) = al;
    0x0043b70d mov rax, rcx                                                                                                                                                                                                              |     rax = rcx;
    0x0043b710 imul rax, r12                                                                                                                                                                                                             |     rax *= r12;
    0x0043b714 shr rax, 0x23                                                                                                                                                                                                             |     rax >>= 0x23;
    0x0043b718 add eax, eax                                                                                                                                                                                                              |     eax += eax;
    0x0043b71a lea eax, [rax + rax*4]                                                                                                                                                                                                    |     eax = rax * 5;
    0x0043b71d sub ecx, eax                                                                                                                                                                                                              |     ecx -= eax;
    0x0043b71f or cl, 0x30                                                                                                                                                                                                               |     cl |= 0x30;
    0x0043b722 mov byte [rbx + 4], cl                                                                                                                                                                                                    |     *((rbx + 4)) = cl;
    0x0043b725 mov edi, dword [r15]                                                                                                                                                                                                      |     
    0x0043b728 call 0x43d020                                                                                                                                                                                                             |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToDay(int) (*(r15), rsi);
    0x0043b72d mov ecx, eax                                                                                                                                                                                                              |     ecx = eax;
    0x0043b72f imul rcx, r12                                                                                                                                                                                                             |     rcx *= r12;
    0x0043b733 shr rcx, 0x23                                                                                                                                                                                                             |     rcx >>= 0x23;
    0x0043b737 lea edx, [rcx + rcx]                                                                                                                                                                                                      |     edx = rcx + rcx;
    0x0043b73a lea edx, [rdx + rdx*4]                                                                                                                                                                                                    |     edx = rdx * 5;
    0x0043b73d sub eax, edx                                                                                                                                                                                                              |     eax -= edx;
    0x0043b73f or al, 0x30                                                                                                                                                                                                               |     al |= 0x30;
    0x0043b741 mov byte [rbx + 7], al                                                                                                                                                                                                    |     *((rbx + 7)) = al;
    0x0043b744 mov rax, rcx                                                                                                                                                                                                              |     rax = rcx;
    0x0043b747 imul rax, r12                                                                                                                                                                                                             |     rax *= r12;
    0x0043b74b shr rax, 0x23                                                                                                                                                                                                             |     rax >>= 0x23;
    0x0043b74f add eax, eax                                                                                                                                                                                                              |     eax += eax;
    0x0043b751 lea eax, [rax + rax*4]                                                                                                                                                                                                    |     eax = rax * 5;
    0x0043b754 sub ecx, eax                                                                                                                                                                                                              |     ecx -= eax;
    0x0043b756 or cl, 0x30                                                                                                                                                                                                               |     cl |= 0x30;
    0x0043b759 mov byte [rbx + 6], cl                                                                                                                                                                                                    |     *((rbx + 6)) = cl;
    0x0043b75c mov esi, 8                                                                                                                                                                                                                |     esi = 8;
    0x0043b761 mov rdi, r14                                                                                                                                                                                                              |     rdi = r14;
    0x0043b764 xor edx, edx                                                                                                                                                                                                              |     edx = 0;
    0x0043b766 call 0x4045a0                                                                                                                                                                                                             |     std::_1::basic_string<char,std::_1::char_traits<char>,std::_1::allocator<char>>::resize(unsigned long,char) ();
    0x0043b76b mov eax, 8                                                                                                                                                                                                                |     eax = 8;
    0x0043b770 add rsp, 8                                                                                                                                                                                                                |     
    0x0043b774 pop rbx                                                                                                                                                                                                                   |     
    0x0043b775 pop r12                                                                                                                                                                                                                   |     
    0x0043b777 pop r14                                                                                                                                                                                                                   |     
    0x0043b779 pop r15                                                                                                                                                                                                                   |     
    0x0043b77b ret                                                                                                                                                                                                                       |     return rax;
                                                                                                                                                                                                                                         | }