; assembly                                                                                                                           | /* r2dec pseudo code output */
                                                                                                                                         | /* baljsn_datumutil.t/assume @ 0x44dd30 */
                                                                                                                                         | #include <stdint.h>
                                                                                                                                         |  
    ; (fcn) method.BloombergLP::bdld::DatumMapOwningKeysBuilder.append_BloombergLP::bdld::DatumMapEntry_const__unsigned_long_ ()         | int64_t method_BloombergLP::bdld::DatumMapOwningKeysBuilder_append_BloombergLP::bdld::DatumMapEntry_const_unsigned_long_ (int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                         |     void ** s1;
                                                                                                                                         |     int64_t var_sp_20h;
                                                                                                                                         |     rdx = arg3;
                                                                                                                                         |     rsi = arg2;
                                                                                                                                         |     rdi = arg1;
                                                                                                                                         |     /* BloombergLP::bdld::DatumMapOwningKeysBuilder::append(BloombergLP::bdld::DatumMapEntry const*, unsigned long) */
    0x0044dd30 push rbp                                                                                                                  |     
    0x0044dd31 push r15                                                                                                                  |     
    0x0044dd33 push r14                                                                                                                  |     
    0x0044dd35 push r13                                                                                                                  |     
    0x0044dd37 push r12                                                                                                                  |     
    0x0044dd39 push rbx                                                                                                                  |     
    0x0044dd3a sub rsp, 0x38                                                                                                             |     
    0x0044dd3e mov r14, rdx                                                                                                              |     r14 = rdx;
    0x0044dd41 mov rbx, rsi                                                                                                              |     rbx = rsi;
    0x0044dd44 mov r15, rdi                                                                                                              |     r15 = rdi;
    0x0044dd47 mov rax, qword [rdi + 0x20]                                                                                               |     rax = *((rdi + 0x20));
    0x0044dd4b test rax, rax                                                                                                             |     
                                                                                                                                         |     if (rax == 0) {
    0x0044dd4e je 0x44dd6d                                                                                                               |         goto label_0;
                                                                                                                                         |     }
    0x0044dd50 mov rcx, qword [r15 + 8]                                                                                                  |     rcx = *((r15 + 8));
    0x0044dd54 mov rcx, qword [rcx]                                                                                                      |     rcx = *(rcx);
    0x0044dd57 add rcx, r14                                                                                                              |     rcx += r14;
    0x0044dd5a mov rdx, rax                                                                                                              |     rdx = rax;
    0x0044dd5d nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044dd60 mov r13, rdx                                                                                                              |         r13 = rdx;
    0x0044dd63 add rdx, rdx                                                                                                              |         rdx += rdx;
    0x0044dd66 cmp r13, rcx                                                                                                              |         
    0x0044dd69 jb 0x44dd60                                                                                                               |         
                                                                                                                                         |     } while (r13 < rcx);
    0x0044dd6b jmp 0x44dd8b                                                                                                              |     goto label_1;
                                                                                                                                         | label_0:
    0x0044dd6d mov ecx, 1                                                                                                                |     ecx = 1;
    0x0044dd72 nop word cs:[rax + rax]                                                                                                   |     
    0x0044dd7c nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044dd80 mov r13, rcx                                                                                                              |         r13 = rcx;
    0x0044dd83 add rcx, rcx                                                                                                              |         rcx += rcx;
    0x0044dd86 cmp r13, r14                                                                                                              |         
    0x0044dd89 jb 0x44dd80                                                                                                               |         
                                                                                                                                         |     } while (r13 < r14);
                                                                                                                                         | label_1:
    0x0044dd8b lea rcx, [r14 - 1]                                                                                                        |     rcx = r14 - 1;
    0x0044dd8f mov edx, r14d                                                                                                             |     edx = r14d;
    0x0044dd92 and edx, 3                                                                                                                |     edx &= 3;
    0x0044dd95 cmp rcx, 3                                                                                                                |     
                                                                                                                                         |     if (rcx < 3) {
    0x0044dd99 jae 0x44dda1                                                                                                              |         
    0x0044dd9b xor ecx, ecx                                                                                                              |         ecx = 0;
    0x0044dd9d xor esi, esi                                                                                                              |         esi = 0;
    0x0044dd9f jmp 0x44ddcd                                                                                                              |         goto label_2;
                                                                                                                                         |     }
    0x0044dda1 mov rdi, r14                                                                                                              |     rdi = r14;
    0x0044dda4 and rdi, 0xfffffffffffffffc                                                                                               |     rdi &= 0xfffffffffffffffc;
    0x0044dda8 lea rbp, [rbx + 0x68]                                                                                                     |     rbp = rbx + 0x68;
    0x0044ddac xor ecx, ecx                                                                                                              |     ecx = 0;
    0x0044ddae xor esi, esi                                                                                                              |     esi = 0;
                                                                                                                                         |     do {
    0x0044ddb0 add rcx, qword [rbp - 0x60]                                                                                               |         rcx += *((rbp - 0x60));
    0x0044ddb4 add rcx, qword [rbp - 0x40]                                                                                               |         rcx += *((rbp - 0x40));
    0x0044ddb8 add rcx, qword [rbp - 0x20]                                                                                               |         rcx += *((rbp - 0x20));
    0x0044ddbc add rcx, qword [rbp]                                                                                                      |         rcx += *(rbp);
    0x0044ddc0 add rsi, 4                                                                                                                |         rsi += 4;
    0x0044ddc4 sub rbp, 0xffffffffffffff80                                                                                               |         rbp -= 0xffffffffffffff80;
    0x0044ddc8 cmp rdi, rsi                                                                                                              |         
    0x0044ddcb jne 0x44ddb0                                                                                                              |         
                                                                                                                                         |     } while (rdi != rsi);
                                                                                                                                         | label_2:
    0x0044ddcd test rdx, rdx                                                                                                             |     
                                                                                                                                         |     if (rdx == 0) {
    0x0044ddd0 je 0x44ddfd                                                                                                               |         goto label_3;
                                                                                                                                         |     }
    0x0044ddd2 shl rsi, 5                                                                                                                |     rsi <<= 5;
    0x0044ddd6 lea rsi, [rbx + rsi + 8]                                                                                                  |     rsi = rbx + rsi + 8;
    0x0044dddb shl rdx, 5                                                                                                                |     rdx <<= 5;
    0x0044dddf xor edi, edi                                                                                                              |     edi = 0;
    0x0044dde1 nop word cs:[rax + rax]                                                                                                   |     
    0x0044ddeb nop dword [rax + rax]                                                                                                     |     
                                                                                                                                         |     do {
    0x0044ddf0 add rcx, qword [rsi + rdi]                                                                                                |         rcx += *((rsi + rdi));
    0x0044ddf4 add rdi, 0x20                                                                                                             |         rdi += 0x20;
    0x0044ddf8 cmp rdx, rdi                                                                                                              |         
    0x0044ddfb jne 0x44ddf0                                                                                                              |         
                                                                                                                                         |     } while (rdx != rdi);
                                                                                                                                         | label_3:
    0x0044ddfd mov rdx, qword [r15 + 0x10]                                                                                               |     rdx = *((r15 + 0x10));
    0x0044de01 test rdx, rdx                                                                                                             |     
                                                                                                                                         |     if (rdx != 0) {
    0x0044de04 je 0x44de28                                                                                                               |         
    0x0044de06 mov rsi, qword [r15 + 8]                                                                                                  |         rsi = *((r15 + 8));
    0x0044de0a mov rsi, qword [rsi]                                                                                                      |         rsi = *(rsi);
    0x0044de0d test rsi, rsi                                                                                                             |         
                                                                                                                                         |         if (rsi != 0) {
    0x0044de10 je 0x44de28                                                                                                               |             
    0x0044de12 mov rdi, qword [r15]                                                                                                      |             rdi = *(r15);
    0x0044de15 shl rsi, 5                                                                                                                |             rsi <<= 5;
    0x0044de19 mov r12, qword [rsi + rdi - 0x20]                                                                                         |             r12 = *((rsi + rdi - 0x20));
    0x0044de1e add r12, qword [rsi + rdi - 0x18]                                                                                         |             r12 += *((rsi + rdi - 0x18));
    0x0044de23 sub r12, rdx                                                                                                              |             r12 -= rdx;
    0x0044de26 jmp 0x44de2b                                                                                                              |             
                                                                                                                                         |         }
                                                                                                                                         |     } else {
    0x0044de28 xor r12d, r12d                                                                                                            |         r12d = 0;
                                                                                                                                         |     }
    0x0044de2b mov rdx, qword [r15 + 0x28]                                                                                               |     rdx = *((r15 + 0x28));
    0x0044de2f test rdx, rdx                                                                                                             |     
                                                                                                                                         |     if (rdx == 0) {
    0x0044de32 je 0x44de4d                                                                                                               |         goto label_4;
                                                                                                                                         |     }
    0x0044de34 add rcx, r12                                                                                                              |     rcx += r12;
    0x0044de37 mov rsi, rdx                                                                                                              |     rsi = rdx;
    0x0044de3a nop word [rax + rax]                                                                                                      |     
                                                                                                                                         |     do {
    0x0044de40 mov rbp, rsi                                                                                                              |         
    0x0044de43 add rsi, rsi                                                                                                              |         rsi += rsi;
    0x0044de46 cmp rbp, rcx                                                                                                              |         
    0x0044de49 jb 0x44de40                                                                                                               |         
                                                                                                                                         |     } while (rbp < rcx);
    0x0044de4b jmp 0x44de6b                                                                                                              |     goto label_5;
                                                                                                                                         | label_4:
    0x0044de4d mov esi, 1                                                                                                                |     esi = 1;
    0x0044de52 nop word cs:[rax + rax]                                                                                                   |     
    0x0044de5c nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044de60 mov rbp, rsi                                                                                                              |         
    0x0044de63 add rsi, rsi                                                                                                              |         rsi += rsi;
    0x0044de66 cmp rbp, rcx                                                                                                              |         
    0x0044de69 jb 0x44de60                                                                                                               |         
                                                                                                                                         |     } while (rbp < rcx);
                                                                                                                                         | label_5:
    0x0044de6b or rdx, rax                                                                                                               |     rdx |= rax;
                                                                                                                                         |     if (rdx != 0) {
    0x0044de6e je 0x44de7e                                                                                                               |         
    0x0044de70 cmp r13, rax                                                                                                              |         
                                                                                                                                         |         if (r13 == rax) {
    0x0044de73 je 0x44df48                                                                                                               |             goto label_6;
                                                                                                                                         |         }
    0x0044de79 jmp 0x44df52                                                                                                              |         goto label_7;
                                                                                                                                         |     }
    0x0044de7e mov qword [r15 + 0x20], r13                                                                                               |     *((r15 + 0x20)) = r13;
    0x0044de82 mov qword [r15 + 0x28], rbp                                                                                               |     *((r15 + 0x28)) = rbp;
    0x0044de86 mov rcx, qword [r15 + 0x38]                                                                                               |     
    0x0044de8a mov rdi, r15                                                                                                              |     
    0x0044de8d mov rsi, r13                                                                                                              |     
    0x0044de90 mov rdx, rbp                                                                                                              |     
    0x0044de93 call 0x44a090                                                                                                             |     BloombergLP::bdld::Datum::createUninitializedMap(BloombergLP::bdld::DatumMutableMapOwningKeysRef*,unsigned long,unsigned long,BloombergLP::bslma::Allocator*) (r15, r13, rbp, *((r15 + 0x38)));
    0x0044de98 test r13, r13                                                                                                             |     
                                                                                                                                         |     if (r13 == 0) {
    0x0044de9b je 0x44df27                                                                                                               |         goto label_8;
                                                                                                                                         |     }
    0x0044dea1 mov rax, qword [r15]                                                                                                      |     rax = *(r15);
    0x0044dea4 lea rcx, [r13 - 1]                                                                                                        |     rcx = r13 - 1;
    0x0044dea8 mov rdx, r13                                                                                                              |     rdx = r13;
    0x0044deab and rdx, 7                                                                                                                |     rdx &= 7;
                                                                                                                                         |     if (rdx == 0) {
    0x0044deaf je 0x44dedd                                                                                                               |         goto label_9;
                                                                                                                                         |     }
    0x0044deb1 xor esi, esi                                                                                                              |     esi = 0;
    0x0044deb3 xorps xmm0, xmm0                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0044deb6 nop word cs:[rax + rax]                                                                                                   |     
                                                                                                                                         |     do {
    0x0044dec0 movups xmmword [rax], xmm0                                                                                                |         __asm ("movups xmmword [rax], xmm0");
    0x0044dec3 add rax, 0x20                                                                                                             |         rax += 0x20;
    0x0044dec7 inc rsi                                                                                                                   |         rsi++;
    0x0044deca cmp rdx, rsi                                                                                                              |         
    0x0044decd jne 0x44dec0                                                                                                              |         
                                                                                                                                         |     } while (rdx != rsi);
    0x0044decf mov rdx, r13                                                                                                              |     rdx = r13;
    0x0044ded2 sub rdx, rsi                                                                                                              |     rdx -= rsi;
    0x0044ded5 cmp rcx, 7                                                                                                                |     
                                                                                                                                         |     if (rcx < 7) {
    0x0044ded9 jae 0x44dee6                                                                                                              |         
    0x0044dedb jmp 0x44df27                                                                                                              |         goto label_8;
                                                                                                                                         | label_9:
    0x0044dedd mov rdx, r13                                                                                                              |         rdx = r13;
    0x0044dee0 cmp rcx, 7                                                                                                                |         
                                                                                                                                         |         if (rcx < 7) {
    0x0044dee4 jb 0x44df27                                                                                                               |             goto label_8;
                                                                                                                                         |         }
                                                                                                                                         |     }
    0x0044dee6 xorps xmm0, xmm0                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0044dee9 nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044def0 movups xmmword [rax], xmm0                                                                                                |         __asm ("movups xmmword [rax], xmm0");
    0x0044def3 movups xmmword [rax + 0x20], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x20], xmm0");
    0x0044def7 movups xmmword [rax + 0x40], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x40], xmm0");
    0x0044defb movups xmmword [rax + 0x60], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x60], xmm0");
    0x0044deff movups xmmword [rax + 0x80], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x80], xmm0");
    0x0044df06 movups xmmword [rax + 0xa0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xa0], xmm0");
    0x0044df0d movups xmmword [rax + 0xc0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xc0], xmm0");
    0x0044df14 movups xmmword [rax + 0xe0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xe0], xmm0");
    0x0044df1b add rax, 0x100                                                                                                            |         rax += 0x100;
    0x0044df21 add rdx, 0xfffffffffffffff8                                                                                               |         rdx += 0xfffffffffffffff8;
    0x0044df25 jne 0x44def0                                                                                                              |         
                                                                                                                                         |     } while (rdx != 0);
                                                                                                                                         | label_8:
    0x0044df27 mov rdi, qword [r15 + 0x10]                                                                                               |     
    0x0044df2b xor esi, esi                                                                                                              |     
    0x0044df2d mov rdx, rbp                                                                                                              |     
    0x0044df30 call 0x404540                                                                                                             |     memset (*((r15 + 0x10)), 0, rbp);
    0x0044df35 mov al, byte [r15 + 0x30]                                                                                                 |     al = *((r15 + 0x30));
    0x0044df39 mov rcx, qword [r15 + 0x18]                                                                                               |     rcx = *((r15 + 0x18));
    0x0044df3d mov byte [rcx], al                                                                                                        |     *(rcx) = al;
    0x0044df3f mov rax, qword [r15 + 0x20]                                                                                               |     rax = *((r15 + 0x20));
    0x0044df43 cmp r13, rax                                                                                                              |     
                                                                                                                                         |     if (r13 == rax) {
    0x0044df46 jne 0x44df52                                                                                                              |         
                                                                                                                                         | label_6:
    0x0044df48 cmp rbp, qword [r15 + 0x28]                                                                                               |         
                                                                                                                                         |         if (rbp == *((r15 + 0x28))) {
    0x0044df4c je 0x44e09c                                                                                                               |             goto label_10;
                                                                                                                                         |         }
                                                                                                                                         |     }
                                                                                                                                         | label_7:
    0x0044df52 mov qword [r15 + 0x20], r13                                                                                               |     *((r15 + 0x20)) = r13;
    0x0044df56 mov qword [r15 + 0x28], rbp                                                                                               |     *((r15 + 0x28)) = rbp;
    0x0044df5a xorps xmm0, xmm0                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0044df5d movaps xmmword [rsp + 0x10], xmm0                                                                                         |     *((rsp + 0x10)) = xmm0;
    0x0044df62 movaps xmmword [rsp], xmm0                                                                                                |     *(rsp) = xmm0;
    0x0044df66 mov rcx, qword [r15 + 0x38]                                                                                               |     
    0x0044df6a mov rdi, rsp                                                                                                              |     
    0x0044df6d mov rsi, r13                                                                                                              |     
    0x0044df70 mov rdx, rbp                                                                                                              |     
    0x0044df73 call 0x44a090                                                                                                             |     BloombergLP::bdld::Datum::createUninitializedMap(BloombergLP::bdld::DatumMutableMapOwningKeysRef*,unsigned long,unsigned long,BloombergLP::bslma::Allocator*) (rsp, r13, rbp, *((r15 + 0x38)));
    0x0044df78 test r13, r13                                                                                                             |     
                                                                                                                                         |     if (r13 == 0) {
    0x0044df7b je 0x44dff7                                                                                                               |         goto label_11;
                                                                                                                                         |     }
    0x0044df7d mov rax, qword [rsp]                                                                                                      |     rax = *(rsp);
    0x0044df81 lea rcx, [r13 - 1]                                                                                                        |     rcx = r13 - 1;
    0x0044df85 mov rdx, r13                                                                                                              |     rdx = r13;
    0x0044df88 and rdx, 7                                                                                                                |     rdx &= 7;
                                                                                                                                         |     if (rdx == 0) {
    0x0044df8c je 0x44dfb2                                                                                                               |         goto label_12;
                                                                                                                                         |     }
    0x0044df8e xor esi, esi                                                                                                              |     esi = 0;
    0x0044df90 xorps xmm0, xmm0                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0044df93 nop word cs:[rax + rax]                                                                                                   |     
    0x0044df9d nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044dfa0 movups xmmword [rax], xmm0                                                                                                |         __asm ("movups xmmword [rax], xmm0");
    0x0044dfa3 add rax, 0x20                                                                                                             |         rax += 0x20;
    0x0044dfa7 inc rsi                                                                                                                   |         rsi++;
    0x0044dfaa cmp rdx, rsi                                                                                                              |         
    0x0044dfad jne 0x44dfa0                                                                                                              |         
                                                                                                                                         |     } while (rdx != rsi);
    0x0044dfaf sub r13, rsi                                                                                                              |     r13 -= rsi;
                                                                                                                                         | label_12:
    0x0044dfb2 cmp rcx, 7                                                                                                                |     
                                                                                                                                         |     if (rcx < 7) {
    0x0044dfb6 jb 0x44dff7                                                                                                               |         goto label_11;
                                                                                                                                         |     }
    0x0044dfb8 xorps xmm0, xmm0                                                                                                          |     __asm ("xorps xmm0, xmm0");
    0x0044dfbb nop dword [rax + rax]                                                                                                     |     
                                                                                                                                         |     do {
    0x0044dfc0 movups xmmword [rax], xmm0                                                                                                |         __asm ("movups xmmword [rax], xmm0");
    0x0044dfc3 movups xmmword [rax + 0x20], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x20], xmm0");
    0x0044dfc7 movups xmmword [rax + 0x40], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x40], xmm0");
    0x0044dfcb movups xmmword [rax + 0x60], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x60], xmm0");
    0x0044dfcf movups xmmword [rax + 0x80], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0x80], xmm0");
    0x0044dfd6 movups xmmword [rax + 0xa0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xa0], xmm0");
    0x0044dfdd movups xmmword [rax + 0xc0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xc0], xmm0");
    0x0044dfe4 movups xmmword [rax + 0xe0], xmm0                                                                                         |         __asm ("movups xmmword [rax + 0xe0], xmm0");
    0x0044dfeb add rax, 0x100                                                                                                            |         rax += 0x100;
    0x0044dff1 add r13, 0xfffffffffffffff8                                                                                               |         r13 += 0xfffffffffffffff8;
    0x0044dff5 jne 0x44dfc0                                                                                                              |         
                                                                                                                                         |     } while (r13 != 0);
                                                                                                                                         | label_11:
    0x0044dff7 mov rdi, qword [rsp + 0x10]                                                                                               |     
    0x0044dffc xor esi, esi                                                                                                              |     
    0x0044dffe mov rdx, rbp                                                                                                              |     
    0x0044e001 call 0x404540                                                                                                             |     memset (*((rsp + 0x10)), 0, rbp);
    0x0044e006 mov rdi, qword [rsp + 0x10]                                                                                               |     
    0x0044e00b mov rsi, qword [r15 + 0x10]                                                                                               |     
    0x0044e00f mov rdx, r12                                                                                                              |     
    0x0044e012 call 0x404d10                                                                                                             |     memcpy (*((rsp + 0x10)), *((r15 + 0x10)), r12);
    0x0044e017 mov rax, qword [r15 + 8]                                                                                                  |     rax = *((r15 + 8));
    0x0044e01b mov rax, qword [rax]                                                                                                      |     rax = *(rax);
    0x0044e01e mov rcx, qword [rsp + 8]                                                                                                  |     rcx = *((rsp + 8));
    0x0044e023 mov qword [rcx], rax                                                                                                      |     *(rcx) = rax;
    0x0044e026 mov rax, qword [rsp + 8]                                                                                                  |     rax = *((rsp + 8));
    0x0044e02b cmp qword [rax], 0                                                                                                        |     
                                                                                                                                         |     if (*(rax) == 0) {
    0x0044e02f je 0x44e07c                                                                                                               |         goto label_13;
                                                                                                                                         |     }
    0x0044e031 mov eax, 0x10                                                                                                             |     eax = 0x10;
    0x0044e036 mov rcx, qword [rsp + 0x10]                                                                                               |     rcx = *((rsp + 0x10));
    0x0044e03b xor edx, edx                                                                                                              |     edx = 0;
    0x0044e03d nop dword [rax]                                                                                                           |     
                                                                                                                                         |     do {
    0x0044e040 mov rsi, qword [r15]                                                                                                      |         rsi = *(r15);
    0x0044e043 movsxd rdi, dword [rsi + rax - 8]                                                                                         |         rdi = *((rsi + rax - 8));
    0x0044e048 movaps xmm0, xmmword [rsi + rax]                                                                                          |         xmm0 = *((rsi + rax));
    0x0044e04c movaps xmmword [rsp + 0x20], xmm0                                                                                         |         *((rsp + 0x20)) = xmm0;
    0x0044e051 mov rsi, qword [rsp]                                                                                                      |         rsi = *(rsp);
    0x0044e055 mov qword [rsi + rax - 0x10], rcx                                                                                         |         *((rsi + rax - 0x10)) = rcx;
    0x0044e05a mov qword [rsi + rax - 8], rdi                                                                                            |         *((rsi + rax - 8)) = rdi;
    0x0044e05f movaps xmm0, xmmword [rsp + 0x20]                                                                                         |         xmm0 = *((rsp + 0x20));
    0x0044e064 movaps xmmword [rsi + rax], xmm0                                                                                          |         *((rsi + rax)) = xmm0;
    0x0044e068 add rcx, rdi                                                                                                              |         rcx += rdi;
    0x0044e06b inc rdx                                                                                                                   |         rdx++;
    0x0044e06e mov rsi, qword [rsp + 8]                                                                                                  |         rsi = *((rsp + 8));
    0x0044e073 add rax, 0x20                                                                                                             |         rax += 0x20;
    0x0044e077 cmp rdx, qword [rsi]                                                                                                      |         
    0x0044e07a jb 0x44e040                                                                                                               |         
                                                                                                                                         |     } while (rdx < *(rsi));
                                                                                                                                         | label_13:
    0x0044e07c mov rsi, qword [r15 + 8]                                                                                                  |     rsi = *((r15 + 8));
    0x0044e080 mov rdi, qword [r15 + 0x38]                                                                                               |     rdi = *((r15 + 0x38));
    0x0044e084 mov rax, qword [rdi]                                                                                                      |     rax = *(rdi);
    0x0044e087 call qword [rax + 0x18]                                                                                                   |     uint64_t (*rax + 0x18)() ();
    0x0044e08a movaps xmm0, xmmword [rsp]                                                                                                |     xmm0 = *(rsp);
    0x0044e08e movaps xmm1, xmmword [rsp + 0x10]                                                                                         |     xmm1 = *((rsp + 0x10));
    0x0044e093 movups xmmword [r15 + 0x10], xmm1                                                                                         |     __asm ("movups xmmword [r15 + 0x10], xmm1");
    0x0044e098 movups xmmword [r15], xmm0                                                                                                |     __asm ("movups xmmword [r15], xmm0");
                                                                                                                                         | label_10:
    0x0044e09c add r12, qword [r15 + 0x10]                                                                                               |     r12 += *((r15 + 0x10));
    0x0044e0a0 add rbx, 0x10                                                                                                             |     rbx += 0x10;
    0x0044e0a4 xor ebp, ebp                                                                                                              |     ebp = 0;
    0x0044e0a6 nop word cs:[rax + rax]                                                                                                   |     
                                                                                                                                         |     do {
    0x0044e0b0 mov rsi, qword [rbx - 0x10]                                                                                               |         
    0x0044e0b4 mov rdx, qword [rbx - 8]                                                                                                  |         
    0x0044e0b8 mov rdi, r12                                                                                                              |         
    0x0044e0bb call 0x404d10                                                                                                             |         memcpy (r12, *((rbx - 0x10)), *((rbx - 8)));
    0x0044e0c0 movsxd rax, dword [rbx - 8]                                                                                               |         rax = *((rbx - 8));
    0x0044e0c4 movaps xmm0, xmmword [rbx]                                                                                                |         xmm0 = *(rbx);
    0x0044e0c7 movaps xmmword [rsp], xmm0                                                                                                |         *(rsp) = xmm0;
    0x0044e0cb mov rcx, qword [r15]                                                                                                      |         rcx = *(r15);
    0x0044e0ce mov rdx, qword [r15 + 8]                                                                                                  |         rdx = *((r15 + 8));
    0x0044e0d2 mov rdx, qword [rdx]                                                                                                      |         rdx = *(rdx);
    0x0044e0d5 add rdx, rbp                                                                                                              |         rdx += rbp;
    0x0044e0d8 shl rdx, 5                                                                                                                |         rdx <<= 5;
    0x0044e0dc mov qword [rcx + rdx], r12                                                                                                |         *((rcx + rdx)) = r12;
    0x0044e0e0 mov qword [rcx + rdx + 8], rax                                                                                            |         *((rcx + rdx + 8)) = rax;
    0x0044e0e5 movaps xmm0, xmmword [rsp]                                                                                                |         xmm0 = *(rsp);
    0x0044e0e9 movaps xmmword [rcx + rdx + 0x10], xmm0                                                                                   |         *((rcx + rdx + 0x10)) = xmm0;
    0x0044e0ee add r12, qword [rbx - 8]                                                                                                  |         r12 += *((rbx - 8));
    0x0044e0f2 inc rbp                                                                                                                   |         rbp++;
    0x0044e0f5 add rbx, 0x20                                                                                                             |         rbx += 0x20;
    0x0044e0f9 cmp r14, rbp                                                                                                              |         
    0x0044e0fc jne 0x44e0b0                                                                                                              |         
                                                                                                                                         |     } while (r14 != rbp);
    0x0044e0fe mov rax, qword [r15 + 8]                                                                                                  |     rax = *((r15 + 8));
    0x0044e102 add qword [rax], r14                                                                                                      |     *(rax) += r14;
    0x0044e105 add rsp, 0x38                                                                                                             |     
    0x0044e109 pop rbx                                                                                                                   |     
    0x0044e10a pop r12                                                                                                                   |     
    0x0044e10c pop r13                                                                                                                   |     
    0x0044e10e pop r14                                                                                                                   |     
    0x0044e110 pop r15                                                                                                                   |     
    0x0044e112 pop rbp                                                                                                                   |     
    0x0044e113 ret                                                                                                                       |     return rax;
                                                                                                                                         | }