; assembly                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                             | /* bdlt_fixutil.t/assume @ 0x43b2d0 */
                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::bdlt::FixUtil.generate_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____BloombergLP::bdlt::Date_const__BloombergLP::bdlt::FixUtilConfiguration_const_ ()         | uint64_t method_BloombergLP::bdlt::FixUtil_generate_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_BloombergLP::bdlt::Date_const_BloombergLP::bdlt::FixUtilConfiguration_const_ (int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                             |     /* BloombergLP::bdlt::FixUtil::generate(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >*, BloombergLP::bdlt::Date const&, BloombergLP::bdlt::FixUtilConfiguration const&) */
    0x0043b2d0 push r15                                                                                                                                                                                                      |     
    0x0043b2d2 push r14                                                                                                                                                                                                      |     
    0x0043b2d4 push r12                                                                                                                                                                                                      |     
    0x0043b2d6 push rbx                                                                                                                                                                                                      |     
    0x0043b2d7 push rax                                                                                                                                                                                                      |     
    0x0043b2d8 mov r15, rsi                                                                                                                                                                                                  |     r15 = rsi;
    0x0043b2db mov r14, rdi                                                                                                                                                                                                  |     r14 = rdi;
    0x0043b2de mov esi, 8                                                                                                                                                                                                    |     
    0x0043b2e3 xor edx, edx                                                                                                                                                                                                  |     
    0x0043b2e5 call 0x443660                                                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (rdi, 8, 0);
    0x0043b2ea cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                  |     
                                                                                                                                                                                                                             |     if (*((r14 + 0x20)) == 0x17) {
    0x0043b2ef jne 0x43b2f6                                                                                                                                                                                                  |         
    0x0043b2f1 mov rbx, r14                                                                                                                                                                                                  |         rbx = r14;
    0x0043b2f4 jmp 0x43b2f9                                                                                                                                                                                                  |         
                                                                                                                                                                                                                             |     } else {
    0x0043b2f6 mov rbx, qword [r14]                                                                                                                                                                                          |         rbx = *(r14);
                                                                                                                                                                                                                             |     }
    0x0043b2f9 mov edi, dword [r15]                                                                                                                                                                                          |     
    0x0043b2fc call 0x43d0a0                                                                                                                                                                                                 |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToYear(int) (*(r15), rsi);
    0x0043b301 mov ecx, eax                                                                                                                                                                                                  |     ecx = eax;
    0x0043b303 mov r12d, 0xcccccccd                                                                                                                                                                                          |     r12d = 0xcccccccd;
    0x0043b309 imul rdx, rcx, 0x51eb851f                                                                                                                                                                                     |     rdx = rcx * 0x51eb851f;
    0x0043b310 imul rsi, rcx, 0x10624dd3                                                                                                                                                                                     |     rsi = rcx * 0x10624dd3;
    0x0043b317 imul rcx, r12                                                                                                                                                                                                 |     rcx *= r12;
    0x0043b31b shr rcx, 0x23                                                                                                                                                                                                 |     rcx >>= 0x23;
    0x0043b31f lea edi, [rcx + rcx]                                                                                                                                                                                          |     edi = rcx + rcx;
    0x0043b322 lea edi, [rdi + rdi*4]                                                                                                                                                                                        |     edi = rdi * 5;
    0x0043b325 sub eax, edi                                                                                                                                                                                                  |     eax -= edi;
    0x0043b327 or al, 0x30                                                                                                                                                                                                   |     al |= 0x30;
    0x0043b329 mov byte [rbx + 3], al                                                                                                                                                                                        |     *((rbx + 3)) = al;
    0x0043b32c mov rax, rcx                                                                                                                                                                                                  |     rax = rcx;
    0x0043b32f imul rax, r12                                                                                                                                                                                                 |     rax *= r12;
    0x0043b333 shr rax, 0x23                                                                                                                                                                                                 |     rax >>= 0x23;
    0x0043b337 add eax, eax                                                                                                                                                                                                  |     eax += eax;
    0x0043b339 lea eax, [rax + rax*4]                                                                                                                                                                                        |     eax = rax * 5;
    0x0043b33c sub ecx, eax                                                                                                                                                                                                  |     ecx -= eax;
    0x0043b33e or cl, 0x30                                                                                                                                                                                                   |     cl |= 0x30;
    0x0043b341 mov byte [rbx + 2], cl                                                                                                                                                                                        |     *((rbx + 2)) = cl;
    0x0043b344 shr rdx, 0x25                                                                                                                                                                                                 |     rdx >>= 0x25;
    0x0043b348 mov rax, rdx                                                                                                                                                                                                  |     rax = rdx;
    0x0043b34b imul rax, r12                                                                                                                                                                                                 |     rax *= r12;
    0x0043b34f shr rax, 0x23                                                                                                                                                                                                 |     rax >>= 0x23;
    0x0043b353 add eax, eax                                                                                                                                                                                                  |     eax += eax;
    0x0043b355 lea eax, [rax + rax*4]                                                                                                                                                                                        |     eax = rax * 5;
    0x0043b358 sub edx, eax                                                                                                                                                                                                  |     edx -= eax;
    0x0043b35a or dl, 0x30                                                                                                                                                                                                   |     dl |= 0x30;
    0x0043b35d mov byte [rbx + 1], dl                                                                                                                                                                                        |     *((rbx + 1)) = dl;
    0x0043b360 shr rsi, 0x26                                                                                                                                                                                                 |     rsi >>= 0x26;
    0x0043b364 mov rax, rsi                                                                                                                                                                                                  |     rax = rsi;
    0x0043b367 imul rax, r12                                                                                                                                                                                                 |     rax *= r12;
    0x0043b36b shr rax, 0x23                                                                                                                                                                                                 |     rax >>= 0x23;
    0x0043b36f add eax, eax                                                                                                                                                                                                  |     eax += eax;
    0x0043b371 lea eax, [rax + rax*4]                                                                                                                                                                                        |     eax = rax * 5;
    0x0043b374 sub esi, eax                                                                                                                                                                                                  |     esi -= eax;
    0x0043b376 or sil, 0x30                                                                                                                                                                                                  |     sil |= 0x30;
    0x0043b37a mov byte [rbx], sil                                                                                                                                                                                           |     *(rbx) = sil;
    0x0043b37d mov edi, dword [r15]                                                                                                                                                                                          |     
    0x0043b380 call 0x43d060                                                                                                                                                                                                 |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToMonth(int) (*(r15), rsi);
    0x0043b385 mov ecx, eax                                                                                                                                                                                                  |     ecx = eax;
    0x0043b387 imul rcx, r12                                                                                                                                                                                                 |     rcx *= r12;
    0x0043b38b shr rcx, 0x23                                                                                                                                                                                                 |     rcx >>= 0x23;
    0x0043b38f lea edx, [rcx + rcx]                                                                                                                                                                                          |     edx = rcx + rcx;
    0x0043b392 lea edx, [rdx + rdx*4]                                                                                                                                                                                        |     edx = rdx * 5;
    0x0043b395 sub eax, edx                                                                                                                                                                                                  |     eax -= edx;
    0x0043b397 or al, 0x30                                                                                                                                                                                                   |     al |= 0x30;
    0x0043b399 mov byte [rbx + 5], al                                                                                                                                                                                        |     *((rbx + 5)) = al;
    0x0043b39c mov rax, rcx                                                                                                                                                                                                  |     rax = rcx;
    0x0043b39f imul rax, r12                                                                                                                                                                                                 |     rax *= r12;
    0x0043b3a3 shr rax, 0x23                                                                                                                                                                                                 |     rax >>= 0x23;
    0x0043b3a7 add eax, eax                                                                                                                                                                                                  |     eax += eax;
    0x0043b3a9 lea eax, [rax + rax*4]                                                                                                                                                                                        |     eax = rax * 5;
    0x0043b3ac sub ecx, eax                                                                                                                                                                                                  |     ecx -= eax;
    0x0043b3ae or cl, 0x30                                                                                                                                                                                                   |     cl |= 0x30;
    0x0043b3b1 mov byte [rbx + 4], cl                                                                                                                                                                                        |     *((rbx + 4)) = cl;
    0x0043b3b4 mov edi, dword [r15]                                                                                                                                                                                          |     
    0x0043b3b7 call 0x43d020                                                                                                                                                                                                 |     eax = BloombergLP::bdlt::PosixDateImpUtil::serialToDay(int) (*(r15), rsi);
    0x0043b3bc mov ecx, eax                                                                                                                                                                                                  |     ecx = eax;
    0x0043b3be imul rcx, r12                                                                                                                                                                                                 |     rcx *= r12;
    0x0043b3c2 shr rcx, 0x23                                                                                                                                                                                                 |     rcx >>= 0x23;
    0x0043b3c6 lea edx, [rcx + rcx]                                                                                                                                                                                          |     edx = rcx + rcx;
    0x0043b3c9 lea edx, [rdx + rdx*4]                                                                                                                                                                                        |     edx = rdx * 5;
    0x0043b3cc sub eax, edx                                                                                                                                                                                                  |     eax -= edx;
    0x0043b3ce or al, 0x30                                                                                                                                                                                                   |     al |= 0x30;
    0x0043b3d0 mov byte [rbx + 7], al                                                                                                                                                                                        |     *((rbx + 7)) = al;
    0x0043b3d3 mov rax, rcx                                                                                                                                                                                                  |     rax = rcx;
    0x0043b3d6 imul rax, r12                                                                                                                                                                                                 |     rax *= r12;
    0x0043b3da shr rax, 0x23                                                                                                                                                                                                 |     rax >>= 0x23;
    0x0043b3de add eax, eax                                                                                                                                                                                                  |     eax += eax;
    0x0043b3e0 lea eax, [rax + rax*4]                                                                                                                                                                                        |     eax = rax * 5;
    0x0043b3e3 sub ecx, eax                                                                                                                                                                                                  |     ecx -= eax;
    0x0043b3e5 or cl, 0x30                                                                                                                                                                                                   |     cl |= 0x30;
    0x0043b3e8 mov byte [rbx + 6], cl                                                                                                                                                                                        |     *((rbx + 6)) = cl;
    0x0043b3eb mov esi, 8                                                                                                                                                                                                    |     
    0x0043b3f0 mov rdi, r14                                                                                                                                                                                                  |     
    0x0043b3f3 xor edx, edx                                                                                                                                                                                                  |     
    0x0043b3f5 call 0x443660                                                                                                                                                                                                 |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateResizeRaw(unsigned long,char) (r14, 8, 0);
    0x0043b3fa mov eax, 8                                                                                                                                                                                                    |     eax = 8;
    0x0043b3ff add rsp, 8                                                                                                                                                                                                    |     
    0x0043b403 pop rbx                                                                                                                                                                                                       |     
    0x0043b404 pop r12                                                                                                                                                                                                       |     
    0x0043b406 pop r14                                                                                                                                                                                                       |     
    0x0043b408 pop r15                                                                                                                                                                                                       |     
    0x0043b40a ret                                                                                                                                                                                                           |     return rax;
                                                                                                                                                                                                                             | }