// File: /workspace/github_c_makefile_star2_O0/Jesskas[P]decompisas/source/fileformat/elf.c
// Function: parseElf64
void parseElf64(FILE* fp, long fileSize)
{
    const int sizeOfElfHeader = 0x40;
    struct ELF_Header_64      elfHeader64 = {{ 0 }};

    unsigned char* buffer = (unsigned char*)malloc(sizeOfElfHeader);
    fread(buffer, sizeof(unsigned char), sizeOfElfHeader, fp);
    char mag_str[4] = { buffer[0], buffer[1], buffer[2], buffer[3] };

    // 64-bit ELF Header
    memcpy(elfHeader64.ei_mag, mag_str, 4);
    elfHeader64.ei_class =      buffer[0x04];
    elfHeader64.ei_data =       buffer[0x05];
    elfHeader64.ei_version =    buffer[0x06];
    elfHeader64.ei_osabi =      buffer[0x07];
    elfHeader64.ei_abiversion = buffer[0x08];
    elfHeader64.e_type =    MAKE_SHORT(buffer[0x11], buffer[0x10]);
    elfHeader64.e_machine = MAKE_SHORT(buffer[0x13], buffer[0x12]);
    elfHeader64.e_version =
      MAKE_LONG(buffer[0x17], buffer[0x16], buffer[0x15], buffer[0x14]);
    /* 64-bit differences begin */
    elfHeader64.e_entry = (
    MAKE_LP1(buffer[0x1F], buffer[0x1E], buffer[0x1D], buffer[0x1C]) << 32)
    | (MAKE_LONG(buffer[0x1B], buffer[0x1A], buffer[0x19], buffer[0x18]));
    elfHeader64.e_phoff = (
    MAKE_LP1(buffer[0x27], buffer[0x26], buffer[0x25], buffer[0x24]) << 32)
    | MAKE_LONG(buffer[0x23], buffer[0x22], buffer[0x21], buffer[0x20]);
    elfHeader64.e_shoff = (
    MAKE_LP1(buffer[0x2F], buffer[0x2E], buffer[0x2D], buffer[0x2C]) << 32)
    | MAKE_LONG(buffer[0x2B], buffer[0x2A], buffer[0x29], buffer[0x28]);
    elfHeader64.e_flags =
      MAKE_LONG(buffer[0x33], buffer[0x32], buffer[0x31], buffer[0x30]);
    elfHeader64.e_ehsize =    MAKE_SHORT(buffer[0x35], buffer[0x34]);
    elfHeader64.e_phentsize = MAKE_SHORT(buffer[0x37], buffer[0x36]);
    elfHeader64.e_phnum =     MAKE_SHORT(buffer[0x39], buffer[0x38]);
    elfHeader64.e_shentsize = MAKE_SHORT(buffer[0x3B], buffer[0x3A]);
    elfHeader64.e_shnum =     MAKE_SHORT(buffer[0x3D], buffer[0x3C]);
    elfHeader64.e_shstrndx =  MAKE_SHORT(buffer[0x3F], buffer[0x3E]);
    free(buffer);


    // 64-bit Program Headers
    // if not there already, seek to program header offset found in elfHeader
    if (sizeOfElfHeader != elfHeader64.e_phoff) {
        if (fseek(fp, elfHeader64.e_phoff, SEEK_SET) != 0) {
            printf("[ELF] Error seeking to elfHeader64.e_phoff (parse).\n");
            // TODO: Clean exit in cases like this.
            exit(-1);
        }
    }
    if (elfHeader64.e_phentsize !=
            (unsigned short)sizeof(struct Program_Header_64)) {
        printf("[ELF Fatal Error] elfHeader64.e_phentsize == ");
        printf("sizeof(Program_Header_64)\n[Is file corrupt?]\n");
        // TODO: Clean exit in cases like this.
        exit(-1);
    }

    int i = 0;
    int sizeOfProgramHeaders = elfHeader64.e_phnum * elfHeader64.e_phentsize;
    buffer = (unsigned char*)malloc(sizeOfProgramHeaders);
    fread(buffer, sizeof(unsigned char), sizeOfProgramHeaders, fp);
    struct Program_Header_64* programHeaders =
        (struct Program_Header_64*)malloc(sizeOfProgramHeaders);

    for (i = 0; i < elfHeader64.e_phnum; i++) {
        int cur_phoff = (i * elfHeader64.e_phentsize);
        struct Program_Header_64 cur_programHeader = { 0 };

        cur_programHeader.p_type =
            MAKE_LONG(buffer[cur_phoff+0x03], buffer[cur_phoff+0x02],
                buffer[cur_phoff+0x01], buffer[cur_phoff+0x00]);
        cur_programHeader.p_flags =
            MAKE_LONG(buffer[cur_phoff+0x07], buffer[cur_phoff+0x06],
              buffer[cur_phoff+0x05], buffer[cur_phoff+0x04]);
        cur_programHeader.p_offset = (
            MAKE_LP1(buffer[cur_phoff+0x0F], buffer[cur_phoff+0x0E],
                buffer[cur_phoff+0x0D], buffer[cur_phoff+0x0C]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x0B], buffer[cur_phoff+0x0A],
                        buffer[cur_phoff+0x09], buffer[cur_phoff+0x08]));
        cur_programHeader.p_vaddr = (
            MAKE_LP1(buffer[cur_phoff+0x17], buffer[cur_phoff+0x16],
                buffer[cur_phoff+0x15], buffer[cur_phoff+0x14]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x13], buffer[cur_phoff+0x12],
                        buffer[cur_phoff+0x11], buffer[cur_phoff+0x10]));
        cur_programHeader.p_paddr = (
            MAKE_LP1(buffer[cur_phoff+0x1F], buffer[cur_phoff+0x1E],
                buffer[cur_phoff+0x1D], buffer[cur_phoff+0x1C]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x1B], buffer[cur_phoff+0x1A],
                        buffer[cur_phoff+0x19], buffer[cur_phoff+0x18]));
        cur_programHeader.p_filesz = (
            MAKE_LP1(buffer[cur_phoff+0x27], buffer[cur_phoff+0x26],
                buffer[cur_phoff+0x25], buffer[cur_phoff+0x24]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x23], buffer[cur_phoff+0x22],
                        buffer[cur_phoff+0x21], buffer[cur_phoff+0x20]));
        cur_programHeader.p_memsz = (
            MAKE_LP1(buffer[cur_phoff+0x2F], buffer[cur_phoff+0x2E],
                buffer[cur_phoff+0x2D], buffer[cur_phoff+0x2C]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x2B], buffer[cur_phoff+0x2A],
                        buffer[cur_phoff+0x29], buffer[cur_phoff+0x28]));
        cur_programHeader.p_align = (
            MAKE_LP1(buffer[cur_phoff+0x37], buffer[cur_phoff+0x36],
                buffer[cur_phoff+0x35], buffer[cur_phoff+0x34]) << 32)
                    | (MAKE_LONG(buffer[cur_phoff+0x33], buffer[cur_phoff+0x32],
                        buffer[cur_phoff+0x31], buffer[cur_phoff+0x30]));

        memcpy(&programHeaders[i], &cur_programHeader,
            elfHeader64.e_phentsize);
    }
    free(buffer);


    // 64-bit Section Headers
    if (fseek(fp, elfHeader64.e_shoff, SEEK_SET) != 0) {
        printf("[ELF] Error seeking to elfHeader64.e_shoff (parse).\n");
        // TODO: Clean exit in cases like this.
        free(programHeaders);
        exit(-1);
    }
    if (elfHeader64.e_shentsize !=
      (unsigned short)sizeof(struct Section_Header_64)) {
      printf("[ELF Fatal Error] elfHeader64.e_shentsize == ");
        printf("sizeof(Section_Header_64)\n[Is file corrupt?]\n");
        // TODO: Clean exit in cases like this.
        free(programHeaders);
        exit(-1);
    }

    int sizeOfSectionHeaders = elfHeader64.e_shnum * elfHeader64.e_shentsize;
    buffer = (unsigned char*)malloc(sizeOfSectionHeaders);
    fread(buffer, sizeof(unsigned char), sizeOfSectionHeaders, fp);
    struct Section_Header_64* sectionHeaders =
        (struct Section_Header_64*)malloc(sizeOfSectionHeaders);

    for (i = 0; i < elfHeader64.e_shnum; i++) {
        int cur_shoff = (i * elfHeader64.e_shentsize);
        struct Section_Header_64 cur_sectionHeader = { 0 };

        cur_sectionHeader.sh_name =
            MAKE_LONG(buffer[cur_shoff+0x03], buffer[cur_shoff+0x02],
                buffer[cur_shoff+0x01], buffer[cur_shoff+0x00]);
        cur_sectionHeader.sh_type =
            MAKE_LONG(buffer[cur_shoff+0x07], buffer[cur_shoff+0x06],
              buffer[cur_shoff+0x05], buffer[cur_shoff+0x04]);
        cur_sectionHeader.sh_flags = (
            MAKE_LP1(buffer[cur_shoff+0x0F], buffer[cur_shoff+0x0E],
                buffer[cur_shoff+0x0D], buffer[cur_shoff+0x0C]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x0B], buffer[cur_shoff+0x0A],
                        buffer[cur_shoff+0x09], buffer[cur_shoff+0x08]));
        cur_sectionHeader.sh_address = (
            MAKE_LP1(buffer[cur_shoff+0x17], buffer[cur_shoff+0x16],
                buffer[cur_shoff+0x15], buffer[cur_shoff+0x14]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x13], buffer[cur_shoff+0x12],
                        buffer[cur_shoff+0x11], buffer[cur_shoff+0x10]));
        cur_sectionHeader.sh_offset = (
            MAKE_LP1(buffer[cur_shoff+0x1F], buffer[cur_shoff+0x1E],
                buffer[cur_shoff+0x1D], buffer[cur_shoff+0x1C]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x1B], buffer[cur_shoff+0x1A],
                        buffer[cur_shoff+0x19], buffer[cur_shoff+0x18]));
        cur_sectionHeader.sh_size = (
            MAKE_LP1(buffer[cur_shoff+0x27], buffer[cur_shoff+0x26],
                buffer[cur_shoff+0x25], buffer[cur_shoff+0x24]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x23], buffer[cur_shoff+0x22],
                        buffer[cur_shoff+0x21], buffer[cur_shoff+0x20]));
        cur_sectionHeader.sh_link =
            MAKE_LONG(buffer[cur_shoff+0x2B], buffer[cur_shoff+0x2A],
                buffer[cur_shoff+0x29], buffer[cur_shoff+0x28]);
        cur_sectionHeader.sh_info =
            MAKE_LONG(buffer[cur_shoff+0x2F], buffer[cur_shoff+0x2E],
                buffer[cur_shoff+0x2D], buffer[cur_shoff+0x2C]);
        cur_sectionHeader.sh_addralign = (
            MAKE_LP1(buffer[cur_shoff+0x37], buffer[cur_shoff+0x36],
                buffer[cur_shoff+0x35], buffer[cur_shoff+0x34]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x33], buffer[cur_shoff+0x32],
                        buffer[cur_shoff+0x31], buffer[cur_shoff+0x30]));
        cur_sectionHeader.sh_entsize = (
            MAKE_LP1(buffer[cur_shoff+0x3F], buffer[cur_shoff+0x3E],
                buffer[cur_shoff+0x3D], buffer[cur_shoff+0x3C]) << 32)
                    | (MAKE_LONG(buffer[cur_shoff+0x3B], buffer[cur_shoff+0x3A],
                        buffer[cur_shoff+0x39], buffer[cur_shoff+0x38]));

        memcpy(&sectionHeaders[i], &cur_sectionHeader,
            elfHeader64.e_shentsize);
    }
    free(buffer);

    // Now, store the shstrtab
    int shstrtab_addr =
        sectionHeaders[elfHeader64.e_shstrndx].sh_offset;
    if (!shstrtab_addr || fseek(fp, shstrtab_addr, SEEK_SET) != 0) {
        printf("[ELF] Error seeking to shstrtab_addr (parse).\n");
        // TODO: Clean exit in cases like this.
        free(programHeaders);
        free(sectionHeaders);
        exit(-1);
    }
    int shstrtab_size = sectionHeaders[elfHeader64.e_shstrndx].sh_size;
    char* shstrtab = (char*)malloc(
      sizeof(char)*shstrtab_size);
    fread(shstrtab, sizeof(char), shstrtab_size, fp);

    printSectionHeader64(sectionHeaders[27], shstrtab);

    // cleanup
    free(programHeaders);
    free(sectionHeaders);
    free(shstrtab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x40, -0x14(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1060
movl $0x40, %edi
callq 0x10b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x40, %edx
callq 0x1040
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x64(%rbp)
movq -0x60(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x63(%rbp)
movq -0x60(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x62(%rbp)
movq -0x60(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x61(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x60(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x54(%rbp)
movq -0x60(%rbp), %rax
movb 0x5(%rax), %al
movb %al, -0x53(%rbp)
movq -0x60(%rbp), %rax
movb 0x6(%rax), %al
movb %al, -0x52(%rbp)
movq -0x60(%rbp), %rax
movb 0x7(%rax), %al
movb %al, -0x51(%rbp)
movq -0x60(%rbp), %rax
movb 0x8(%rax), %al
movb %al, -0x50(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x11(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x48(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x13(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x12(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x46(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x17(%rax), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movzbl 0x16(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x15(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x14(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x44(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x1f(%rax), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movzbl 0x1e(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x1d(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x1c(%rcx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movzbl 0x1b(%rcx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x1a(%rdx), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x19(%rdx), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x18(%rdx), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x27(%rax), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movzbl 0x26(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x25(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x24(%rcx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movzbl 0x23(%rcx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x22(%rdx), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x21(%rdx), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x20(%rdx), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x2f(%rax), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2e(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2d(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2c(%rcx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movzbl 0x2b(%rcx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x2a(%rdx), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x29(%rdx), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movzbl 0x28(%rdx), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x33(%rax), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movzbl 0x32(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x31(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x30(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x35(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x34(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x24(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x37(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x36(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x22(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x39(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x38(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x20(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x3b(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x3a(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x1e(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x3d(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x3c(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x1c(%rbp)
movq -0x60(%rbp), %rax
movzbl 0x3f(%rax), %eax
shll $0x8, %eax
movq -0x60(%rbp), %rcx
movzbl 0x3e(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1030
movl $0x40, %eax
cmpq -0x38(%rbp), %rax
je 0x24c6
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x10c0
cmpl $0x0, %eax
je 0x24c4
leaq 0xad1d(%rip), %rdi      # 0xd1d0
movb $0x0, %al
callq 0x1050
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10e0
jmp 0x24c6
movzwl -0x22(%rbp), %eax
cmpl $0x38, %eax
je 0x24f5
leaq 0xad2f(%rip), %rdi      # 0xd205
movb $0x0, %al
callq 0x1050
leaq 0xad4f(%rip), %rdi      # 0xd233
movb $0x0, %al
callq 0x1050
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10e0
movl $0x0, -0x68(%rbp)
movzwl -0x20(%rbp), %eax
movzwl -0x22(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x6c(%rbp)
movslq -0x6c(%rbp), %rdi
callq 0x10b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movslq -0x6c(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1040
movslq -0x6c(%rbp), %rdi
callq 0x10b0
movq %rax, -0x78(%rbp)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
movzwl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2aa7
movl -0x68(%rbp), %eax
movzwl -0x22(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0x7c(%rbp)
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x1060
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x0, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0xb8(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x6, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x5, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x4, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0xb4(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0xf, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0xe, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0xd, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0xc, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0xb, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0xa, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x9, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x8, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x17, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x16, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x15, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x14, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x13, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x12, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x11, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x10, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xa8(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x1f, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x1e, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x1d, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x1c, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x1b, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x1a, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x19, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x18, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x27, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x26, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x25, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x24, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x23, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x22, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x21, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x20, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x98(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x2f, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x2e, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x2d, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x2c, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x2b, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x2a, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x29, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x28, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rax
movl -0x7c(%rbp), %ecx
addl $0x37, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x36, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x35, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x34, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0x7c(%rbp), %edx
addl $0x33, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x32, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x31, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0x7c(%rbp), %esi
addl $0x30, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movslq -0x68(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movzwl -0x22(%rbp), %eax
movl %eax, %edx
leaq -0xb8(%rbp), %rsi
callq 0x10a0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2541
movq -0x60(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x10c0
cmpl $0x0, %eax
je 0x2ae5
leaq 0xa796(%rip), %rdi      # 0xd261
movb $0x0, %al
callq 0x1050
movq -0x78(%rbp), %rdi
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10e0
movzwl -0x1e(%rbp), %eax
cmpl $0x40, %eax
je 0x2b1d
leaq 0xa7a1(%rip), %rdi      # 0xd296
movb $0x0, %al
callq 0x1050
leaq 0xa7c1(%rip), %rdi      # 0xd2c4
movb $0x0, %al
callq 0x1050
movq -0x78(%rbp), %rdi
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10e0
movzwl -0x1c(%rbp), %eax
movzwl -0x1e(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0xbc(%rbp)
movslq -0xbc(%rbp), %rdi
callq 0x10b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movslq -0xbc(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1040
movslq -0xbc(%rbp), %rdi
callq 0x10b0
movq %rax, -0xc8(%rbp)
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
movzwl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x324f
movl -0x68(%rbp), %eax
movzwl -0x1e(%rbp), %ecx
imull %ecx, %eax
movl %eax, -0xcc(%rbp)
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1060
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x2, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x0, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0x110(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x7, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x6, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x5, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x4, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0x10c(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0xf, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0xe, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0xd, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0xc, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0xb, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0xa, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x9, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x8, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x108(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x17, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x16, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x15, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x14, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x13, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x12, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x11, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x10, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x100(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x1f, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x1e, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x1d, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x1c, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x1b, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x1a, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x19, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x18, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xf8(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x27, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x26, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x25, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x24, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x23, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x22, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x21, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x20, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xf0(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x2b, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x2a, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x29, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x28, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0xe8(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x2f, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x2e, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x2d, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x2c, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movl %eax, -0xe4(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x37, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x36, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x35, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x34, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x33, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x32, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x31, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x30, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xe0(%rbp)
movq -0x60(%rbp), %rax
movl -0xcc(%rbp), %ecx
addl $0x3f, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x3e, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x3d, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x3c, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
cltq
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl -0xcc(%rbp), %edx
addl $0x3b, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x3a, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x10, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x39, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
shll $0x8, %edx
orl %edx, %ecx
movq -0x60(%rbp), %rdx
movl -0xcc(%rbp), %esi
addl $0x38, %esi
movslq %esi, %rsi
movzbl (%rdx,%rsi), %edx
orl %edx, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rdi
movslq -0x68(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
movzwl -0x1e(%rbp), %eax
movl %eax, %edx
leaq -0x110(%rbp), %rsi
callq 0x10a0
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x2b71
movq -0x60(%rbp), %rdi
callq 0x1030
movq -0xc8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movl %eax, -0x114(%rbp)
cmpl $0x0, -0x114(%rbp)
je 0x3294
movq -0x8(%rbp), %rdi
movslq -0x114(%rbp), %rsi
xorl %edx, %edx
callq 0x10c0
cmpl $0x0, %eax
je 0x32c1
leaq 0x9f06(%rip), %rdi      # 0xd1a1
movb $0x0, %al
callq 0x1050
movq -0x78(%rbp), %rdi
callq 0x1030
movq -0xc8(%rbp), %rdi
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10e0
movq -0xc8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movl %eax, -0x118(%rbp)
movslq -0x118(%rbp), %rdi
shlq $0x0, %rdi
callq 0x10b0
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rdi
movslq -0x118(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x1040
movq -0xc8(%rbp), %rax
addq $0x6c0, %rax            # imm = 0x6C0
movq -0x120(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x3770
movq -0x78(%rbp), %rdi
callq 0x1030
movq -0xc8(%rbp), %rdi
callq 0x1030
movq -0x120(%rbp), %rdi
callq 0x1030
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop