; assembly                                                                                                       | /* r2dec pseudo code output */
                                                                                                                     | /* baltzo_localdatetime.t/assume @ 0x4575d0 */
                                                                                                                     | #include <stdint.h>
                                                                                                                     |  
    ; (fcn) method.BloombergLP::bslx::MarshallingUtil.getArrayUint40_unsigned_long_long__char_const__int_ ()         | uint64_t method_BloombergLP::bslx::MarshallingUtil_getArrayUint40_unsigned_long_long_char_const_int_ (int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                     |     rdx = arg3;
                                                                                                                     |     rsi = arg2;
                                                                                                                     |     rdi = arg1;
                                                                                                                     |     /* BloombergLP::bslx::MarshallingUtil::getArrayUint40(unsigned long long*, char const*, int) */
    0x004575d0 test edx, edx                                                                                         |     
                                                                                                                     |     if (edx == 0) {
    0x004575d2 je 0x457690                                                                                           |         goto label_0;
                                                                                                                     |     }
    0x004575d8 mov ecx, edx                                                                                          |     ecx = edx;
    0x004575da lea rdx, [rcx*8 - 8]                                                                                  |     rdx = rcx*8 - 8;
    0x004575e2 test dl, 8                                                                                            |     
                                                                                                                     |     if ((dl & 8) == 0) {
    0x004575e5 jne 0x457619                                                                                          |         
    0x004575e7 mov qword [rdi], 0                                                                                    |         *(rdi) = 0;
    0x004575ee mov al, byte [rsi]                                                                                    |         al = *(rsi);
    0x004575f0 mov byte [rdi + 4], al                                                                                |         *((rdi + 4)) = al;
    0x004575f3 mov al, byte [rsi + 1]                                                                                |         al = *((rsi + 1));
    0x004575f6 mov byte [rdi + 3], al                                                                                |         *((rdi + 3)) = al;
    0x004575f9 mov al, byte [rsi + 2]                                                                                |         al = *((rsi + 2));
    0x004575fc mov byte [rdi + 2], al                                                                                |         *((rdi + 2)) = al;
    0x004575ff mov al, byte [rsi + 3]                                                                                |         al = *((rsi + 3));
    0x00457602 mov byte [rdi + 1], al                                                                                |         *((rdi + 1)) = al;
    0x00457605 mov al, byte [rsi + 4]                                                                                |         al = *((rsi + 4));
    0x00457608 mov byte [rdi], al                                                                                    |         *(rdi) = al;
    0x0045760a add rsi, 5                                                                                            |         rsi += 5;
    0x0045760e lea rax, [rdi + 8]                                                                                    |         rax = rdi + 8;
    0x00457612 test rdx, rdx                                                                                         |         
                                                                                                                     |         if (rdx != 0) {
    0x00457615 jne 0x457621                                                                                          |             goto label_1;
                                                                                                                     |         }
    0x00457617 jmp 0x457690                                                                                          |         goto label_0;
                                                                                                                     |     }
    0x00457619 mov rax, rdi                                                                                          |     rax = rdi;
    0x0045761c test rdx, rdx                                                                                         |     
                                                                                                                     |     if (rdx == 0) {
    0x0045761f je 0x457690                                                                                           |         goto label_0;
                                                                                                                     |     }
                                                                                                                     | label_1:
    0x00457621 lea rcx, [rdi + rcx*8]                                                                                |     rcx = rdi + rcx*8;
    0x00457625 nop word cs:[rax + rax]                                                                               |     
    0x0045762f nop                                                                                                   |     
                                                                                                                     |     do {
    0x00457630 mov qword [rax], 0                                                                                    |         *(rax) = 0;
    0x00457637 movzx edx, byte [rsi]                                                                                 |         edx = *(rsi);
    0x0045763a mov byte [rax + 4], dl                                                                                |         *((rax + 4)) = dl;
    0x0045763d movzx edx, byte [rsi + 1]                                                                             |         edx = *((rsi + 1));
    0x00457641 mov byte [rax + 3], dl                                                                                |         *((rax + 3)) = dl;
    0x00457644 movzx edx, byte [rsi + 2]                                                                             |         edx = *((rsi + 2));
    0x00457648 mov byte [rax + 2], dl                                                                                |         *((rax + 2)) = dl;
    0x0045764b movzx edx, byte [rsi + 3]                                                                             |         edx = *((rsi + 3));
    0x0045764f mov byte [rax + 1], dl                                                                                |         *((rax + 1)) = dl;
    0x00457652 movzx edx, byte [rsi + 4]                                                                             |         edx = *((rsi + 4));
    0x00457656 mov byte [rax], dl                                                                                    |         *(rax) = dl;
    0x00457658 mov qword [rax + 8], 0                                                                                |         *((rax + 8)) = 0;
    0x00457660 movzx edx, byte [rsi + 5]                                                                             |         edx = *((rsi + 5));
    0x00457664 mov byte [rax + 0xc], dl                                                                              |         *((rax + 0xc)) = dl;
    0x00457667 movzx edx, byte [rsi + 6]                                                                             |         edx = *((rsi + 6));
    0x0045766b mov byte [rax + 0xb], dl                                                                              |         *((rax + 0xb)) = dl;
    0x0045766e movzx edx, byte [rsi + 7]                                                                             |         edx = *((rsi + 7));
    0x00457672 mov byte [rax + 0xa], dl                                                                              |         *((rax + 0xa)) = dl;
    0x00457675 movzx edx, byte [rsi + 8]                                                                             |         edx = *((rsi + 8));
    0x00457679 mov byte [rax + 9], dl                                                                                |         *((rax + 9)) = dl;
    0x0045767c movzx edx, byte [rsi + 9]                                                                             |         edx = *((rsi + 9));
    0x00457680 mov byte [rax + 8], dl                                                                                |         *((rax + 8)) = dl;
    0x00457683 add rax, 0x10                                                                                         |         rax += 0x10;
    0x00457687 add rsi, 0xa                                                                                          |         rsi += 0xa;
    0x0045768b cmp rax, rcx                                                                                          |         
    0x0045768e jne 0x457630                                                                                          |         
                                                                                                                     |     } while (rax != rcx);
                                                                                                                     | label_0:
    0x00457690 ret                                                                                                   |     return rax;
                                                                                                                     | }