; assembly                                                                                                                                                                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                 | /* bblb_schedulegenerationutil.t/none @ 0x40b5f0 */
                                                                                                                                                                                                                                                                                 | #include <stdint.h>
                                                                                                                                                                                                                                                                                 |  
    ; (fcn) method.BloombergLP::bblb::ScheduleGenerationUtil.generateFromDayInterval_bsl::vector_BloombergLP::bdlt::Date__bsl::allocator_BloombergLP::bdlt::Date_____BloombergLP::bdlt::Date_const__BloombergLP::bdlt::Date_const__BloombergLP::bdlt::Date_const__int_ ()        | int64_t method_BloombergLP::bblb::ScheduleGenerationUtil_generateFromDayInterval_bsl::vector_BloombergLP::bdlt::Date_bsl::allocator_BloombergLP::bdlt::Date_BloombergLP::bdlt::Date_const_BloombergLP::bdlt::Date_const_BloombergLP::bdlt::Date_const_int_ (int64_t arg5, int64_t arg4, int64_t arg3, int64_t arg2, uint32_t arg1) {
                                                                                                                                                                                                                                                                                 |     r8 = arg5;
                                                                                                                                                                                                                                                                                 |     rcx = arg4;
                                                                                                                                                                                                                                                                                 |     rdx = arg3;
                                                                                                                                                                                                                                                                                 |     rsi = arg2;
                                                                                                                                                                                                                                                                                 |     rdi = arg1;
                                                                                                                                                                                                                                                                                 |     /* BloombergLP::bblb::ScheduleGenerationUtil::generateFromDayInterval(bsl::vector<BloombergLP::bdlt::Date, bsl::allocator<BloombergLP::bdlt::Date> >*, BloombergLP::bdlt::Date const&, BloombergLP::bdlt::Date const&, BloombergLP::bdlt::Date const&, int) */
    0x0040b5f0 push rbp                                                                                                                                                                                                                                                          |     
    0x0040b5f1 push r15                                                                                                                                                                                                                                                          |     
    0x0040b5f3 push r14                                                                                                                                                                                                                                                          |     
    0x0040b5f5 push r13                                                                                                                                                                                                                                                          |     
    0x0040b5f7 push r12                                                                                                                                                                                                                                                          |     
    0x0040b5f9 push rbx                                                                                                                                                                                                                                                          |     
    0x0040b5fa push rax                                                                                                                                                                                                                                                          |     
    0x0040b5fb mov r15d, r8d                                                                                                                                                                                                                                                     |     r15d = r8d;
    0x0040b5fe mov r14, rcx                                                                                                                                                                                                                                                      |     r14 = rcx;
    0x0040b601 mov rcx, rdx                                                                                                                                                                                                                                                      |     rcx = rdx;
    0x0040b604 mov r12, rdi                                                                                                                                                                                                                                                      |     r12 = rdi;
    0x0040b607 mov rax, qword [rdi]                                                                                                                                                                                                                                              |     rax = *(rdi);
    0x0040b60a cmp qword [rdi + 8], rax                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                 |     if (*((rdi + 8)) != rax) {
    0x0040b60e je 0x40b615                                                                                                                                                                                                                                                       |         
    0x0040b610 mov qword [r12 + 8], rax                                                                                                                                                                                                                                          |         *((r12 + 8)) = rax;
                                                                                                                                                                                                                                                                                 |     }
    0x0040b615 mov esi, dword [rsi]                                                                                                                                                                                                                                              |     esi = *(rsi);
    0x0040b617 mov edi, dword [r14]                                                                                                                                                                                                                                              |     edi = *(r14);
    0x0040b61a sub esi, edi                                                                                                                                                                                                                                                      |     esi -= edi;
                                                                                                                                                                                                                                                                                 |     if (esi > 0) {
    0x0040b61c jle 0x40b634                                                                                                                                                                                                                                                      |         
    0x0040b61e mov eax, esi                                                                                                                                                                                                                                                      |         eax = esi;
    0x0040b620 cdq                                                                                                                                                                                                                                                               |         edx:eax = (int64_t) eax;
    0x0040b621 idiv r15d                                                                                                                                                                                                                                                         |         eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |         edx = edx:eax % r15d;
    0x0040b624 test edx, edx                                                                                                                                                                                                                                                     |         
                                                                                                                                                                                                                                                                                 |         if (edx != 0) {
    0x0040b626 je 0x40b634                                                                                                                                                                                                                                                       |             
    0x0040b628 mov eax, esi                                                                                                                                                                                                                                                      |             eax = esi;
    0x0040b62a cdq                                                                                                                                                                                                                                                               |             edx:eax = (int64_t) eax;
    0x0040b62b idiv r15d                                                                                                                                                                                                                                                         |             eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |             edx = edx:eax % r15d;
    0x0040b62e mov ebp, eax                                                                                                                                                                                                                                                      |             
    0x0040b630 inc ebp                                                                                                                                                                                                                                                           |             ebp++;
    0x0040b632 jmp 0x40b63c                                                                                                                                                                                                                                                      |             
                                                                                                                                                                                                                                                                                 |         }
                                                                                                                                                                                                                                                                                 |     } else {
    0x0040b634 mov eax, esi                                                                                                                                                                                                                                                      |         eax = esi;
    0x0040b636 cdq                                                                                                                                                                                                                                                               |         edx:eax = (int64_t) eax;
    0x0040b637 idiv r15d                                                                                                                                                                                                                                                         |         eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |         edx = edx:eax % r15d;
    0x0040b63a mov ebp, eax                                                                                                                                                                                                                                                      |         
                                                                                                                                                                                                                                                                                 |     }
    0x0040b63c mov ecx, dword [rcx]                                                                                                                                                                                                                                              |     ecx = *(rcx);
    0x0040b63e sub ecx, edi                                                                                                                                                                                                                                                      |     ecx -= edi;
    0x0040b640 js 0x40b64c                                                                                                                                                                                                                                                       |     
                                                                                                                                                                                                                                                                                 |     while (edx == 0) {
    0x0040b642 mov eax, ecx                                                                                                                                                                                                                                                      |         eax = ecx;
    0x0040b644 cdq                                                                                                                                                                                                                                                               |         edx:eax = (int64_t) eax;
    0x0040b645 idiv r15d                                                                                                                                                                                                                                                         |         eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |         edx = edx:eax % r15d;
    0x0040b648 mov ebx, eax                                                                                                                                                                                                                                                      |         ebx = eax;
    0x0040b64a jmp 0x40b660                                                                                                                                                                                                                                                      |         goto label_0;
    0x0040b64c mov eax, ecx                                                                                                                                                                                                                                                      |         eax = ecx;
    0x0040b64e cdq                                                                                                                                                                                                                                                               |         edx:eax = (int64_t) eax;
    0x0040b64f idiv r15d                                                                                                                                                                                                                                                         |         eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |         edx = edx:eax % r15d;
    0x0040b652 test edx, edx                                                                                                                                                                                                                                                     |         
    0x0040b654 je 0x40b642                                                                                                                                                                                                                                                       |         
                                                                                                                                                                                                                                                                                 |     }
    0x0040b656 mov eax, ecx                                                                                                                                                                                                                                                      |     eax = ecx;
    0x0040b658 cdq                                                                                                                                                                                                                                                               |     edx:eax = (int64_t) eax;
    0x0040b659 idiv r15d                                                                                                                                                                                                                                                         |     eax = edx:eax / r15d;
                                                                                                                                                                                                                                                                                 |     edx = edx:eax % r15d;
    0x0040b65c mov ebx, eax                                                                                                                                                                                                                                                      |     ebx = eax;
    0x0040b65e dec ebx                                                                                                                                                                                                                                                           |     ebx--;
                                                                                                                                                                                                                                                                                 | label_0:
    0x0040b660 mov eax, ebx                                                                                                                                                                                                                                                      |     eax = ebx;
    0x0040b662 sub eax, ebp                                                                                                                                                                                                                                                      |     eax -= ebp;
    0x0040b664 mov esi, eax                                                                                                                                                                                                                                                      |     esi = eax;
    0x0040b666 neg esi                                                                                                                                                                                                                                                           |     esi = -esi;
                                                                                                                                                                                                                                                                                 |     if (eax < 0) {
    0x0040b668 cmovl esi, eax                                                                                                                                                                                                                                                    |         esi = eax;
                                                                                                                                                                                                                                                                                 |     }
    0x0040b66b inc esi                                                                                                                                                                                                                                                           |     esi++;
    0x0040b66d mov rdi, r12                                                                                                                                                                                                                                                      |     
    0x0040b670 call 0x40c1a0                                                                                                                                                                                                                                                     |     bsl::vector<BloombergLP::bdlt::Date,bsl::allocator<BloombergLP::bdlt::Date>>::reserve(unsigned long) (r12, rsi);
    0x0040b675 sub ebx, ebp                                                                                                                                                                                                                                                      |     ebx -= ebp;
                                                                                                                                                                                                                                                                                 |     if (ebx < 0) {
    0x0040b677 jl 0x40b6aa                                                                                                                                                                                                                                                       |         goto label_1;
                                                                                                                                                                                                                                                                                 |     }
    0x0040b679 inc ebx                                                                                                                                                                                                                                                           |     ebx++;
    0x0040b67b imul ebp, r15d                                                                                                                                                                                                                                                    |     ebp *= r15d;
    0x0040b67f mov r13, rsp                                                                                                                                                                                                                                                      |     r13 = rsp;
    0x0040b682 nop word cs:[rax + rax]                                                                                                                                                                                                                                           |     
    0x0040b68c nop dword [rax]                                                                                                                                                                                                                                                   |     
                                                                                                                                                                                                                                                                                 |     do {
    0x0040b690 mov eax, dword [r14]                                                                                                                                                                                                                                              |         eax = *(r14);
    0x0040b693 add eax, ebp                                                                                                                                                                                                                                                      |         eax += ebp;
    0x0040b695 mov dword [rsp], eax                                                                                                                                                                                                                                              |         *(rsp) = eax;
    0x0040b698 mov rdi, r12                                                                                                                                                                                                                                                      |         
    0x0040b69b mov rsi, r13                                                                                                                                                                                                                                                      |         
    0x0040b69e call 0x40a680                                                                                                                                                                                                                                                     |         bsl::vector<BloombergLP::bdlt::Date,bsl::allocator<BloombergLP::bdlt::Date>>::push_back(BloombergLP::bdlt::Date&&) (r12, r13);
    0x0040b6a3 add ebp, r15d                                                                                                                                                                                                                                                     |         ebp += r15d;
    0x0040b6a6 dec ebx                                                                                                                                                                                                                                                           |         ebx--;
    0x0040b6a8 jne 0x40b690                                                                                                                                                                                                                                                      |         
                                                                                                                                                                                                                                                                                 |     } while (ebx != 0);
                                                                                                                                                                                                                                                                                 | label_1:
    0x0040b6aa add rsp, 8                                                                                                                                                                                                                                                        |     
    0x0040b6ae pop rbx                                                                                                                                                                                                                                                           |     
    0x0040b6af pop r12                                                                                                                                                                                                                                                           |     
    0x0040b6b1 pop r13                                                                                                                                                                                                                                                           |     
    0x0040b6b3 pop r14                                                                                                                                                                                                                                                           |     
    0x0040b6b5 pop r15                                                                                                                                                                                                                                                           |     
    0x0040b6b7 pop rbp                                                                                                                                                                                                                                                           |     
    0x0040b6b8 ret                                                                                                                                                                                                                                                               |     return rax;
                                                                                                                                                                                                                                                                                 | }