LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/mem.h
// Function: mem_unmap_all
void mem_unmap_all(mem_t* m) {
    for (int layer_index = 0; layer_index < MEM_NUM_LAYERS; layer_index++) {
        for (int page_index = 0; page_index < MEM_NUM_PAGES; page_index++) {
            mem_page_t* page = &m->layers[layer_index][page_index];
            page->read_ptr = 0; 
            page->write_ptr = 0;
        }
    }
    for (int page_index = 0; page_index < MEM_NUM_PAGES; page_index++) {
        _mem_update_page_table(m, page_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
xorps %xmm0, %xmm0
movq %rdi, %rcx
cmpq $0x4, %rax
je 0x410a
xorl %edx, %edx
cmpq $0x400, %rdx            # imm = 0x400
je 0x40fe
movups %xmm0, (%rcx,%rdx)
addq $0x10, %rdx
jmp 0x40eb
incq %rax
addq $0x400, %rcx            # imm = 0x400
jmp 0x40e3
xorl %r14d, %r14d
cmpl $0x40, %r14d
je 0x4123
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43bb
incl %r14d
jmp 0x410d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/mem.h
// Function: mem_map
static void _mem_map(mem_t* m, int layer, uint16_t addr, uint32_t size, const uint8_t* read_ptr, uint8_t* write_ptr) {
    CHIPS_ASSERT(m);
    CHIPS_ASSERT((layer >= 0) && (layer < MEM_NUM_LAYERS));
    CHIPS_ASSERT((addr & MEM_PAGE_MASK) == 0);
    CHIPS_ASSERT((size & MEM_PAGE_MASK) == 0);
    CHIPS_ASSERT(size <= MEM_ADDR_RANGE);
    const int num = size>>MEM_PAGE_SHIFT;
    CHIPS_ASSERT(num <= MEM_NUM_PAGES);
    for (int i = 0; i < num; i++) {
        const uint16_t offset = i * MEM_PAGE_SIZE;
        /* the page_index will wrap-around */
        const uint16_t page_index = ((addr+offset) & MEM_ADDR_MASK) >> MEM_PAGE_SHIFT;
        CHIPS_ASSERT(page_index <= MEM_NUM_PAGES);
        mem_page_t* page = &m->layers[layer][page_index];
        page->read_ptr = read_ptr + offset;
        if (0 != write_ptr) {
            page->write_ptr = write_ptr + offset;
        }
        else {
            page->write_ptr = m->junk_page;
        }
        _mem_update_page_table(m, page_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x40(%rbp)
movq %rdi, -0x30(%rbp)
testq %rdi, %rdi
je 0x422a
cmpl $0x4, %esi
jae 0x4249
testw $0x3ff, %dx             # imm = 0x3FF
jne 0x4268
movl %ecx, %r15d
testw $0x3ff, %r15w           # imm = 0x3FF
jne 0x4287
cmpl $0x10001, %r15d         # imm = 0x10001
jae 0x42a6
movq %r9, %rbx
shrl $0xa, %r15d
movl %esi, %r13d
movq -0x30(%rbp), %rax
leaq 0x1800(%rax), %rcx
movq %rcx, -0x38(%rbp)
movzwl %dx, %r12d
xorl %r14d, %r14d
shlq $0xa, %r13
addq %rax, %r13
subl $0x1, %r15d
jb 0x421b
leal (%r12,%r14), %eax
movzwl %ax, %esi
shrl $0xa, %esi
movl %r14d, %eax
andl $0xfc00, %eax           # imm = 0xFC00
movl %esi, %ecx
shll $0x4, %ecx
movq -0x40(%rbp), %rdx
addq %rax, %rdx
addq %rbx, %rax
testq %rbx, %rbx
movq %rdx, (%rcx,%r13)
cmoveq -0x38(%rbp), %rax
movq %rax, 0x8(%rcx,%r13)
movq -0x30(%rbp), %rdi
callq 0x43bb
addl $0x400, %r14d           # imm = 0x400
jmp 0x41d1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfce0(%rip), %rdi      # 0x13f11
leaq 0xfcdb(%rip), %rsi      # 0x13f13
leaq 0x1021c(%rip), %rcx     # 0x1445b
movl $0x12a, %edx            # imm = 0x12A
callq 0x30d0
leaq 0xfb84(%rip), %rdi      # 0x13dd4
leaq 0xfcbc(%rip), %rsi      # 0x13f13
leaq 0x101fd(%rip), %rcx     # 0x1445b
movl $0x12b, %edx            # imm = 0x12B
callq 0x30d0
leaq 0x10238(%rip), %rdi     # 0x144a7
leaq 0xfc9d(%rip), %rsi      # 0x13f13
leaq 0x101de(%rip), %rcx     # 0x1445b
movl $0x12c, %edx            # imm = 0x12C
callq 0x30d0
leaq 0x10235(%rip), %rdi     # 0x144c3
leaq 0xfc7e(%rip), %rsi      # 0x13f13
leaq 0x101bf(%rip), %rcx     # 0x1445b
movl $0x12d, %edx            # imm = 0x12D
callq 0x30d0
leaq 0x10232(%rip), %rdi     # 0x144df
leaq 0xfc5f(%rip), %rsi      # 0x13f13
leaq 0x101a0(%rip), %rcx     # 0x1445b
movl $0x12e, %edx            # imm = 0x12E
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/mem.h
// Function: mem_unmap_layer
void mem_unmap_layer(mem_t* m, int layer) {
    CHIPS_ASSERT(m);
    CHIPS_ASSERT((layer >= 0) && (layer < MEM_NUM_LAYERS));
    for (int page_index = 0; page_index < MEM_NUM_PAGES; page_index++) {
        mem_page_t* page = &m->layers[layer][page_index];
        page->read_ptr = 0; 
        page->write_ptr = 0;
        _mem_update_page_table(m, page_index);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x437d
cmpl $0x3, %esi
ja 0x439c
movq %rdi, %rbx
movl %esi, %r15d
shlq $0xa, %r15
addq %rdi, %r15
xorl %r14d, %r14d
cmpq $0x40, %r14
je 0x4372
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x43bb
incq %r14
addq $0x10, %r15
jmp 0x4351
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfb8d(%rip), %rdi      # 0x13f11
leaq 0xfb88(%rip), %rsi      # 0x13f13
leaq 0xfc88(%rip), %rcx      # 0x1401a
movl $0x152, %edx            # imm = 0x152
callq 0x30d0
leaq 0xfa31(%rip), %rdi      # 0x13dd4
leaq 0xfb69(%rip), %rsi      # 0x13f13
leaq 0xfc69(%rip), %rcx      # 0x1401a
movl $0x153, %edx            # imm = 0x153
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/mem.h
// Function: mem_update_page_table
static void _mem_update_page_table(mem_t* m, int page_index) {
    /* find highest priority layer which maps this memory page */
    int layer_index;
    for (layer_index = 0; layer_index < MEM_NUM_LAYERS; layer_index++) {
        if (m->layers[layer_index][page_index].read_ptr) {
            /* found highest priority layer with valid mapping */
            break;
        }
    }
    if (layer_index != MEM_NUM_LAYERS) { 
        /* found a valid mapping */
        m->page_table[page_index] = m->layers[layer_index][page_index];
    }
    else {
        /* no mapping exists for this page, set to special 'unmapped page' */
        m->page_table[page_index].read_ptr = m->unmapped_page;
        m->page_table[page_index].write_ptr = m->junk_page;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %rcx
xorl %edx, %edx
cmpq $0x1000, %rdx           # imm = 0x1000
je 0x43e5
cmpq $0x0, (%rcx,%rdx)
jne 0x4405
addq $0x400, %rdx            # imm = 0x400
jmp 0x43cc
leaq 0x1400(%rdi), %rcx
movq %rcx, 0x1000(%rdi,%rax)
leaq 0x1800(%rdi), %rcx
movq %rcx, 0x1008(%rdi,%rax)
jmp 0x4411
movups (%rdx,%rcx), %xmm0
movups %xmm0, 0x1000(%rdi,%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/mem.h
// Function: mem_layer_rd
uint8_t mem_layer_rd(mem_t* mem, int layer, uint16_t addr) {
    CHIPS_ASSERT((layer >= 0) && (layer < MEM_NUM_LAYERS));
    if (mem->layers[layer][addr>>MEM_PAGE_SHIFT].read_ptr) {
        return mem->layers[layer][addr>>MEM_PAGE_SHIFT].read_ptr[addr&MEM_PAGE_MASK];
    }
    else {
        return 0xFF;
    }
}

// Assembly:
cmpl $0x4, %esi
jae 0x44c8
movl %esi, %ecx
movzwl %dx, %eax
shlq $0xa, %rcx
addq %rcx, %rdi
movl %eax, %ecx
shrl $0x6, %ecx
andl $-0x10, %ecx
movq (%rcx,%rdi), %rcx
testq %rcx, %rcx
je 0x44c5
andl $0x3ff, %eax            # imm = 0x3FF
movb (%rcx,%rax), %al
retq
movb $-0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xf901(%rip), %rdi      # 0x13dd4
leaq 0xfa39(%rip), %rsi      # 0x13f13
leaq 0xfb84(%rip), %rcx      # 0x14065
movl $0x175, %edx            # imm = 0x175
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/z80.h
// Function: z80_init
void z80_init(z80_t* cpu, const z80_desc_t* desc) {
    CHIPS_ASSERT(_FA == 0);
    CHIPS_ASSERT(cpu && desc);
    CHIPS_ASSERT(desc->tick_cb);
    memset(cpu, 0, sizeof(*cpu));
    z80_reset(cpu);
    cpu->tick_cb = desc->tick_cb;
    cpu->user_data = desc->user_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x481b
testq %rsi, %rsi
je 0x481b
cmpq $0x0, (%rsi)
je 0x483a
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rdi)
movdqu %xmm0, (%rdi)
movdqu %xmm0, 0x40(%rdi)
movdqu %xmm0, 0x30(%rdi)
movdqu %xmm0, 0x20(%rdi)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rdi)
orq $-0x1, 0x18(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rdi)
popq %rbp
retq
leaq 0xf8a3(%rip), %rdi      # 0x140c5
leaq 0xf8a8(%rip), %rsi      # 0x140d1
leaq 0xf8ab(%rip), %rcx      # 0x140db
movl $0x2c7, %edx            # imm = 0x2C7
callq 0x30d0
leaq 0xf8c5(%rip), %rdi      # 0x14106
leaq 0xf889(%rip), %rsi      # 0x140d1
leaq 0xf88c(%rip), %rcx      # 0x140db
movl $0x2c8, %edx            # imm = 0x2C8
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/z80.h
// Function: z80_map_regs
static inline uint64_t _z80_map_regs(uint64_t r0, uint64_t r1, uint64_t r2) {
    uint64_t ws = r0;
    if (r2 & _BIT_USE_IX) {
        ws = (ws & ~(0xFFFFULL<<_HL)) | (((r1>>_IX)<<_HL) & (0xFFFFULL<<_HL));
    }
    else if (r2 & _BIT_USE_IY) {
        ws = (ws & ~(0xFFFFULL<<_HL)) | (((r1>>_IY)<<_HL) & (0xFFFFULL<<_HL));
    }
    return ws;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
testb $0x1, %dl
jne 0x1035d
testb $0x2, %dl
je 0x10377
movabsq $-0xffff0001, %rcx      # imm = 0xFFFFFFFF0000FFFF
andq %rcx, %rax
jmp 0x1036e
movabsq $-0xffff0001, %rcx      # imm = 0xFFFFFFFF0000FFFF
andq %rcx, %rax
shrq $0x10, %rsi
andl $0xffff0000, %esi       # imm = 0xFFFF0000
orq %rsi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/z80.h
// Function: z80_flush_r1
static inline uint64_t _z80_flush_r1(uint64_t ws, uint64_t r1, uint64_t map_bits) {
    if (map_bits & _BIT_USE_IX) {
        r1 = (r1 & ~(0xFFFFULL<<_IX)) | (((ws>>_HL)<<_IX) & (0xFFFFULL<<_IX));
    }
    else if (map_bits & _BIT_USE_IY) {
        r1 = (r1 & ~(0xFFFFULL<<_IY)) | (((ws>>_HL)<<_IY) & (0xFFFFULL<<_IY));
    }
    return r1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rax
testb $0x1, %dl
jne 0x1039f
testb $0x2, %dl
je 0x103b9
movabsq $-0xffff0001, %rcx      # imm = 0xFFFFFFFF0000FFFF
andq %rcx, %rax
andl $0xffff0000, %edi       # imm = 0xFFFF0000
jmp 0x103b6
movabsq $-0xffff00000001, %rcx  # imm = 0xFFFF0000FFFFFFFF
andq %rcx, %rax
andl $0xffff0000, %edi       # imm = 0xFFFF0000
shlq $0x10, %rdi
orq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/zx.h
// Function: zx_init_memory_map
static void _zx_init_memory_map(zx_t* sys) {
    mem_init(&sys->mem);
    if (sys->type == ZX_TYPE_128) {
        mem_map_ram(&sys->mem, 0, 0x4000, 0x4000, sys->ram[5]);
        mem_map_ram(&sys->mem, 0, 0x8000, 0x4000, sys->ram[2]);
        mem_map_ram(&sys->mem, 0, 0xC000, 0x4000, sys->ram[0]);
        mem_map_rom(&sys->mem, 0, 0x0000, 0x4000, sys->rom[0]);
    }
    else {
        mem_map_ram(&sys->mem, 0, 0x4000, 0x4000, sys->ram[0]);
        mem_map_ram(&sys->mem, 0, 0x8000, 0x4000, sys->ram[1]);
        mem_map_ram(&sys->mem, 0, 0xC000, 0x4000, sys->ram[2]);
        mem_map_rom(&sys->mem, 0, 0x0000, 0x4000, sys->rom[0]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1610(%rdi), %r14
movq %r14, %rdi
callq 0x3140
leaq 0x4230(%rbx), %r15
cmpl $0x1, 0x1114(%rbx)
jne 0x10d9e
leaq 0x18230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x4000, %ecx           # imm = 0x4000
callq 0x31d0
leaq 0xc230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
movl $0x4000, %ecx           # imm = 0x4000
callq 0x31d0
jmp 0x10dd7
movq %r14, %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x4000, %ecx           # imm = 0x4000
movq %r15, %r8
callq 0x31d0
leaq 0x8230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
movl $0x4000, %ecx           # imm = 0x4000
callq 0x31d0
leaq 0xc230(%rbx), %r15
addq $0x24230, %rbx          # imm = 0x24230
movq %r14, %rdi
xorl %esi, %esi
movl $0xc000, %edx           # imm = 0xC000
movl $0x4000, %ecx           # imm = 0x4000
movq %r15, %r8
callq 0x31d0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x4000, %ecx           # imm = 0x4000
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3050
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/zx.h
// Function: zx_reset
void zx_reset(zx_t* sys) {
    CHIPS_ASSERT(sys && sys->valid);
    z80_reset(&sys->cpu);
    beeper_reset(&sys->beeper);
    if (sys->type == ZX_TYPE_128) {
        ay38910_reset(&sys->ay);
    }
    sys->memory_paging_disabled = false;
    sys->kbd_joymask = 0;
    sys->joy_joymask = 0;
    sys->last_fe_out = 0;
    sys->scanline_counter = sys->scanline_period;
    sys->scanline_y = 0;
    sys->blink_counter = 0;
    if (sys->type == ZX_TYPE_48K) {
        sys->display_ram_bank = 0;
    }
    else {
        sys->display_ram_bank = 5;
    }
    _zx_init_memory_map(sys);
    z80_set_pc(&sys->cpu, 0x0000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10f37
movq %rdi, %rbx
cmpb $0x0, 0x1110(%rdi)
je 0x10f37
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rbx)
orq $-0x1, 0x18(%rbx)
movabsq $-0xffffffffff0020, %rax # imm = 0xFF0000000000FFE0
andq %rax, 0x20(%rbx)
andl $0x0, 0x50(%rbx)
movl 0x54(%rbx), %eax
movl %eax, 0x58(%rbx)
andl $0x0, 0x60(%rbx)
movl 0x1114(%rbx), %eax
cmpl $0x1, %eax
jne 0x10ee9
leaq 0x870(%rbx), %rdi
callq 0x3230
movl 0x1114(%rbx), %eax
andw $0x0, 0x111c(%rbx)
movb $0x0, 0x111e(%rbx)
andw $0x0, 0x1125(%rbx)
movl 0x1130(%rbx), %ecx
movl %ecx, 0x1134(%rbx)
andl $0x0, 0x1138(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,4), %eax
movl %eax, 0x113c(%rbx)
movq %rbx, %rdi
callq 0x10d3a
andw $0x0, 0x22(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x335f(%rip), %rdi      # 0x1429d
leaq 0x3225(%rip), %rsi      # 0x1416a
leaq 0x337b(%rip), %rcx      # 0x142c7
movl $0x133, %edx            # imm = 0x133
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/zx.h
// Function: zx_exec
void zx_exec(zx_t* sys, uint32_t micro_seconds) {
    CHIPS_ASSERT(sys && sys->valid);
    uint32_t ticks_to_run = clk_ticks_to_run(&sys->clk, micro_seconds);
    uint32_t ticks_executed = z80_exec(&sys->cpu, ticks_to_run);
    clk_ticks_executed(&sys->clk, ticks_executed);
    kbd_update(&sys->kbd, micro_seconds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x10fae
movq %rdi, %r14
cmpb $0x0, 0x1110(%rdi)
je 0x10fae
movl %esi, %ebx
leaq 0x1148(%r14), %rdi
callq 0x30c0
movq %r14, %rdi
movl %eax, %esi
callq 0x3030
xorl %ecx, %ecx
subl 0x1150(%r14), %eax
cmovlel %ecx, %eax
movl %eax, 0x1154(%r14)
addq $0x1158, %r14           # imm = 0x1158
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x31f0
leaq 0x32e8(%rip), %rdi      # 0x1429d
leaq 0x31ae(%rip), %rsi      # 0x1416a
leaq 0x331a(%rip), %rcx      # 0x142dd
movl $0x14b, %edx            # imm = 0x14B
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: retro_set_environment
void retro_set_environment(retro_environment_t const cb) {
    zx48k.env_cb = cb;

    bool yes = true;
    cb(RETRO_ENVIRONMENT_SET_SUPPORT_NO_GAME, &yes);

    struct retro_get_proc_address_interface get_proc_if = {zx48k_get_proc};
    cb(RETRO_ENVIRONMENT_SET_PROC_ADDRESS_CALLBACK, &get_proc_if);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rdi, 0x8ab35(%rip)     # 0x9c3a8
leaq -0x9(%rbp), %rsi
movb $0x1, (%rsi)
pushq $0x12
popq %rdi
callq *%rbx
leaq 0x13(%rip), %rax        # 0x11899
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
pushq $0x21
popq %rdi
callq *%rbx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: retro_init
void retro_init() {
    zx48k.log_cb = dummy_log;

    struct retro_log_callback log;

    if (zx48k.env_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &log)) {
        zx48k.log_cb = log.log;
    }

    zx48k_reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2e(%rip), %rax        # 0x11934
movq %rax, 0x8aa93(%rip)     # 0x9c3a0
pushq $0x1b
popq %rdi
leaq -0x8(%rbp), %rsi
callq *0x8aa8e(%rip)          # 0x9c3a8
testb %al, %al
je 0x11929
movq -0x8(%rbp), %rax
movq %rax, 0x8aa77(%rip)     # 0x9c3a0
callq 0x1193a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: zx48k_reset
static void zx48k_reset(void) {
    zx_init(&zx48k.zx, &(zx_desc_t) {
        .type = ZX_TYPE_48K,
        .joystick_type = ZX_JOYSTICKTYPE_KEMPSTON,
        .pixel_buffer = zx48k.pixel_buffer,
        .pixel_buffer_size = sizeof(zx48k.pixel_buffer),
        .user_data = NULL,
        .audio_cb = zx48k_audio_cb,
        .audio_num_samples = ZX_DEFAULT_AUDIO_SAMPLES,
        .audio_sample_rate = 44100,
        .rom_zx48k = rom,
        .rom_zx48k_size = rom_len
    });

    /* Keep these around for the video callback */
    zx48k.width = zx_display_width(&zx48k.zx);
    zx48k.height = zx_display_height(&zx48k.zx);

    /* Reset the keyboard and register our own keys */
    zx48k.key_states = 0;
    kbd_init(&zx48k.zx.kbd, 1);

    int code = 128;

    for (int col = 0; col < 8; col++) {
        for (int row = 0; row < 5; row++, code++) {
            kbd_register_key(&zx48k.zx.kbd, code, col, row, 0);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movabsq $0x100000000, %rax      # imm = 0x100000000
leaq -0x80(%rbp), %rsi
movq %rax, (%rsi)
leaq 0x3aa27(%rip), %rax     # 0x4c388
movq %rax, 0x8(%rsi)
leaq 0xa7e4(%rip), %rdi      # 0x1c150
movl $0x50000, 0x10(%rsi)    # imm = 0x50000
andq $0x0, 0x18(%rsi)
leaq 0x698(%rip), %rax       # 0x12017
movq %rax, 0x20(%rsi)
movsd 0x16b5(%rip), %xmm0     # 0x13040
movups %xmm0, 0x28(%rsi)
leaq 0x67aa(%rip), %rax      # 0x18140
movq %rax, 0x38(%rsi)
movl $0x4000, 0x40(%rsi)     # imm = 0x4000
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsi)
andq $0x0, 0x58(%rsi)
callq 0x3090
movabsq $0x10000000140, %rax    # imm = 0x10000000140
movq %rax, 0x8a9c5(%rip)     # 0x9c388
andq $0x0, 0x3a9b5(%rip)     # 0x4c380
leaq 0xb8d6(%rip), %rbx      # 0x1d2a8
xorl %r14d, %r14d
movl $0x4b8, %edx            # imm = 0x4B8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3100
movl $0x411b, 0xb8c2(%rip)   # imm = 0x411B
movl $0x80, %r12d
cmpl $0x8, %r14d
je 0x11a25
xorl %r15d, %r15d
leal (%r12,%r15), %esi
cmpl $0x5, %r15d
je 0x11a1d
movq %rbx, %rdi
movl %r14d, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x31a0
incl %r15d
jmp 0x119fd
incl %r14d
movl %esi, %r12d
jmp 0x119f4
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: retro_get_system_info
void retro_get_system_info(struct retro_system_info* const info) {
    info->library_name = "zx48k";
    info->library_version = "0.0.1";
    info->need_fullpath = false;
    info->block_extract = false;
    info->valid_extensions = "z80";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x29a0(%rip), %rax      # 0x14409
movq %rax, (%rdi)
leaq 0x299c(%rip), %rax      # 0x1440f
movq %rax, 0x8(%rdi)
andw $0x0, 0x18(%rdi)
leaq 0x2992(%rip), %rax      # 0x14415
movq %rax, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: retro_get_system_av_info
void retro_get_system_av_info(struct retro_system_av_info* const info) {
    info->geometry.base_width = zx48k.width;
    info->geometry.base_height = zx48k.height;
    info->geometry.max_width = zx48k.width;
    info->geometry.max_height = zx48k.height;
    info->geometry.aspect_ratio = 0.0f;
    info->timing.fps = ZX48K_FRAMES_PER_SECOND;
    info->timing.sample_rate = 44100.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8a8f5(%rip), %eax     # 0x9c388
movl %eax, (%rdi)
movl 0x8a8f1(%rip), %ecx     # 0x9c38c
movl %ecx, 0x4(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
andl $0x0, 0x10(%rdi)
movabsq $0x4049000000000000, %rax # imm = 0x4049000000000000
movq %rax, 0x18(%rdi)
movabsq $0x40e5888000000000, %rax # imm = 0x40E5888000000000
movq %rax, 0x20(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: retro_load_game
bool retro_load_game(struct retro_game_info const* const info) {
    if (info == NULL) {
        return false;
    }

    enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_XRGB8888;

    if (!zx48k.env_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt)) {
        zx48k.log_cb( RETRO_LOG_ERROR, "XRGB8888 is not supported\n" );
        return false;
    }

    bool const ok = zx48k_load(info->data, info->size);

    struct retro_memory_descriptor desc[4] = {
        {RETRO_MEMDESC_CONST,      zx48k.zx.rom[0], 0, 0x0000, 0, 0, 0x4000, NULL},
        {RETRO_MEMDESC_SYSTEM_RAM, zx48k.zx.ram[0], 0, 0x4000, 0, 0, 0x4000, NULL},
        {RETRO_MEMDESC_SYSTEM_RAM, zx48k.zx.ram[1], 0, 0x8000, 0, 0, 0x4000, NULL},
        {RETRO_MEMDESC_SYSTEM_RAM, zx48k.zx.ram[2], 0, 0xc000, 0, 0, 0x4000, NULL}
    };

    struct retro_memory_map memory_map = {desc, 4};
    zx48k.env_cb(RETRO_ENVIRONMENT_SET_MEMORY_MAPS, &memory_map);

    return ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
testq %rdi, %rdi
je 0x11bad
movq %rdi, %rbx
leaq -0x1c(%rbp), %rsi
movl $0x1, (%rsi)
pushq $0xa
popq %rdi
callq *0x8a86a(%rip)          # 0x9c3a8
testb %al, %al
je 0x11bb1
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rbx
movq 0x8a83f(%rip), %rdi     # 0x9c390
testq %rdi, %rdi
je 0x11b65
callq 0x3040
xorps %xmm0, %xmm0
movups %xmm0, 0x8a82b(%rip)    # 0x9c390
testq %r14, %r14
je 0x11bc7
leaq 0xa5df(%rip), %rdi      # 0x1c150
movq %r14, %rsi
movl %ebx, %edx
callq 0x3160
testb %al, %al
je 0x11bd0
movq %rbx, %rdi
callq 0x3190
testq %rax, %rax
je 0x11bd4
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3180
movq %r15, 0x8a7ec(%rip)     # 0x9c390
movq %rbx, 0x8a7ed(%rip)     # 0x9c398
jmp 0x11bcc
xorl %ebx, %ebx
jmp 0x11c1c
leaq 0x2888(%rip), %rsi      # 0x14440
xorl %ebx, %ebx
pushq $0x3
popq %rdi
xorl %eax, %eax
callq *0x8a7db(%rip)          # 0x9c3a0
jmp 0x11c1c
callq 0x1193a
movb $0x1, %bl
jmp 0x11be8
xorl %ebx, %ebx
jmp 0x11be8
leaq 0x29c0(%rip), %rsi      # 0x1459b
xorl %ebx, %ebx
pushq $0x3
popq %rdi
xorl %eax, %eax
callq *0x8a7b8(%rip)          # 0x9c3a0
leaq 0x6051(%rip), %rsi      # 0x17c40
leaq -0x130(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
callq 0x3180
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
movl $0x4, 0x8(%rsi)
movl $0x10024, %edi          # imm = 0x10024
callq *0x8a78c(%rip)          # 0x9c3a8
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: main_get_register
static uint64_t main_get_register(unsigned reg) {
    switch (reg) {
        case HC_Z80_A: return z80_a(&zx48k.zx.cpu);
        case HC_Z80_F: return z80_f(&zx48k.zx.cpu);
        case HC_Z80_BC: return z80_bc(&zx48k.zx.cpu);
        case HC_Z80_DE: return z80_de(&zx48k.zx.cpu);
        case HC_Z80_HL: return z80_hl(&zx48k.zx.cpu);
        case HC_Z80_IX: return z80_ix(&zx48k.zx.cpu);
        case HC_Z80_IY: return z80_iy(&zx48k.zx.cpu);
        case HC_Z80_AF2: return z80_af_(&zx48k.zx.cpu);
        case HC_Z80_BC2: return z80_bc_(&zx48k.zx.cpu);
        case HC_Z80_DE2: return z80_de_(&zx48k.zx.cpu);
        case HC_Z80_HL2: return z80_hl_(&zx48k.zx.cpu);
        case HC_Z80_I: return z80_i(&zx48k.zx.cpu);
        case HC_Z80_R: return z80_r(&zx48k.zx.cpu);
        case HC_Z80_SP: return z80_sp(&zx48k.zx.cpu);
        case HC_Z80_PC: return z80_pc(&zx48k.zx.cpu);
        case HC_Z80_IFF: return z80_iff1(&zx48k.zx.cpu) << 1 | z80_iff2(&zx48k.zx.cpu);
        case HC_Z80_IM: return z80_im(&zx48k.zx.cpu);
        case HC_Z80_WZ: return z80_wz(&zx48k.zx.cpu);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x11, %edi
ja 0x11eed
movl %edi, %eax
leaq 0x18d3(%rip), %rcx      # 0x13700
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0xa31b(%rip), %eax      # 0x1c158
jmp 0x11eff
movzbl 0xa32d(%rip), %eax      # 0x1c176
jmp 0x11eff
movzwl 0xa31d(%rip), %eax      # 0x1c172
jmp 0x11eff
movzbl 0xa314(%rip), %eax      # 0x1c175
jmp 0x11eff
movzwl 0xa2ed(%rip), %eax      # 0x1c15a
jmp 0x11eff
movzbl 0xa2fb(%rip), %eax      # 0x1c174
jmp 0x11eff
movzwl 0xa2df(%rip), %eax      # 0x1c164
jmp 0x11eff
movzwl 0xa2d0(%rip), %eax      # 0x1c15e
jmp 0x11eff
movl 0xa2da(%rip), %eax      # 0x1c170
movl %eax, %ecx
shrl %ecx
andl $0x2, %ecx
shrl $0x3, %eax
andl $0x1, %eax
orl %ecx, %eax
jmp 0x11eff
movzwl 0xa2ae(%rip), %eax      # 0x1c15c
jmp 0x11eff
movzwl 0xa2a9(%rip), %eax      # 0x1c160
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x11eff
movzbl 0xa292(%rip), %eax      # 0x1c159
jmp 0x11eff
movzwl 0xa29e(%rip), %eax      # 0x1c16e
jmp 0x11eff
movzwl 0xa293(%rip), %eax      # 0x1c16c
jmp 0x11eff
movzwl 0xa286(%rip), %eax      # 0x1c168
jmp 0x11eff
movzwl 0xa27f(%rip), %eax      # 0x1c16a
jmp 0x11eff
jmp 0x11eff
movzwl 0xa26c(%rip), %eax      # 0x1c162
jmp 0x11eff
movzwl 0xa267(%rip), %eax      # 0x1c166
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: main_set_register
static int main_set_register(unsigned reg, uint64_t value) {
    switch (reg) {
        case HC_Z80_A: z80_set_a(&zx48k.zx.cpu, value); break;
        case HC_Z80_F: z80_set_f(&zx48k.zx.cpu, value); break;
        case HC_Z80_BC: z80_set_bc(&zx48k.zx.cpu, value); break;
        case HC_Z80_DE: z80_set_de(&zx48k.zx.cpu, value); break;
        case HC_Z80_HL: z80_set_hl(&zx48k.zx.cpu, value); break;
        case HC_Z80_IX: z80_set_ix(&zx48k.zx.cpu, value); break;
        case HC_Z80_IY: z80_set_iy(&zx48k.zx.cpu, value); break;
        case HC_Z80_AF2: z80_set_af_(&zx48k.zx.cpu, value); break;
        case HC_Z80_BC2: z80_set_bc_(&zx48k.zx.cpu, value); break;
        case HC_Z80_DE2: z80_set_de_(&zx48k.zx.cpu, value); break;
        case HC_Z80_HL2: z80_set_hl_(&zx48k.zx.cpu, value); break;
        case HC_Z80_I: z80_set_i(&zx48k.zx.cpu, value); break;
        case HC_Z80_R: z80_set_r(&zx48k.zx.cpu, value); break;
        case HC_Z80_SP: z80_set_sp(&zx48k.zx.cpu, value); break;
        case HC_Z80_PC: z80_set_pc(&zx48k.zx.cpu, value); break;

        case HC_Z80_IFF:
        case HC_Z80_IM:
        case HC_Z80_WZ: return 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x11, %edi
ja 0x11fb3
movl %edi, %eax
leaq 0x1831(%rip), %rcx      # 0x13748
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x11fb8
movw %si, 0xa244(%rip)       # 0x1c172
jmp 0x11fb3
movb %sil, 0xa23b(%rip)      # 0x1c175
jmp 0x11fb3
movw %si, 0xa217(%rip)       # 0x1c15a
jmp 0x11fb3
movb %sil, 0xa228(%rip)      # 0x1c174
jmp 0x11fb3
movw %si, 0xa20f(%rip)       # 0x1c164
jmp 0x11fb3
movw %si, 0xa200(%rip)       # 0x1c15e
jmp 0x11fb3
movw %si, 0xa1f5(%rip)       # 0x1c15c
jmp 0x11fb3
rolw $0x8, %si
movw %si, 0xa1ec(%rip)       # 0x1c160
jmp 0x11fb3
movb %sil, 0xa1db(%rip)      # 0x1c158
jmp 0x11fb3
movb %sil, 0xa1d3(%rip)      # 0x1c159
jmp 0x11fb3
movw %si, 0xa1dd(%rip)       # 0x1c16c
jmp 0x11fb3
movw %si, 0xa1d0(%rip)       # 0x1c168
jmp 0x11fb3
movw %si, 0xa1c9(%rip)       # 0x1c16a
jmp 0x11fb3
movw %si, 0xa1b8(%rip)       # 0x1c162
jmp 0x11fb3
movw %si, 0xa1b3(%rip)       # 0x1c166
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/leiradel[P]zx48k-libretro/src/main.c
// Function: zx48k_audio_cb
static void zx48k_audio_cb(float const* const samples, int const num_samples, void* const ud) {
    static int16_t pcm16[ZX_MAX_AUDIO_SAMPLES * 2];

    (void)ud;

    for (int i = 0, j = 0; i < num_samples; i++, j += 2) {
        float sample = samples[i];

        if (sample < -1.0f) {
            sample = -1.0f;
        }
        else if (sample > 1.0f) {
            sample = 1.0f;
        }

        pcm16[j] = sample * 32767;
        pcm16[j + 1] = sample * 32767;
    }

    zx48k.audio_cb(pcm16, num_samples);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
movss 0xfdd(%rip), %xmm0      # 0x1300c
movss 0xfdd(%rip), %xmm1      # 0x13014
leaq 0x8a392(%rip), %rdx     # 0x9c3d0
movss 0xfca(%rip), %xmm2      # 0x13010
cmpq %rax, %rcx
je 0x1207c
movss (%rdi,%rax,4), %xmm4
ucomiss %xmm4, %xmm0
movaps %xmm0, %xmm3
ja 0x12063
ucomiss %xmm2, %xmm4
movaps %xmm4, %xmm3
jbe 0x12063
movaps %xmm2, %xmm3
mulss %xmm1, %xmm3
cvttss2si %xmm3, %r8d
movw %r8w, (%rdx,%rax,4)
movw %r8w, 0x2(%rdx,%rax,4)
incq %rax
jmp 0x12046
movq 0x8a335(%rip), %rax     # 0x9c3b8
movslq %esi, %rsi
leaq 0x8a343(%rip), %rdi     # 0x9c3d0
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/dlbeer[P]dhara/tools/gentab.c
// Function: main
int main(int argc, char **argv)
{
	uint32_t p;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <polynomial>\n", argv[0]);
		return -1;
	}

	if (parse_poly(argv[1], &p) < 0)
		return -1;

	fill_table(p);
	print_table();
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jle 0x123a
movq 0x8(%rsi), %rdx
incq %rdx
movzbl -0x1(%rdx), %ecx
cmpl $0x30, %ecx
je 0x1164
cmpl $0x78, %ecx
je 0x1164
xorl %eax, %eax
pushq $-0x30
popq %rsi
pushq $-0x37
popq %rdi
pushq $-0x57
popq %r8
testb %cl, %cl
je 0x11c2
leal -0x30(%rcx), %r10d
movl %esi, %r9d
cmpb $0xa, %r10b
jb 0x11b0
leal -0x41(%rcx), %r10d
movl %edi, %r9d
cmpb $0x6, %r10b
jb 0x11b0
leal -0x61(%rcx), %r10d
movl %r8d, %r9d
cmpb $0x6, %r10b
jae 0x1269
shll $0x4, %eax
movsbl %cl, %ecx
addl %r9d, %ecx
orl %ecx, %eax
movb (%rdx), %cl
incq %rdx
jmp 0x1181
xorl %ecx, %ecx
pushq $0x8
popq %rdx
leaq 0x2e82(%rip), %r15      # 0x4050
cmpq $0x100, %rcx            # imm = 0x100
je 0x11fb
movl %edx, %edi
movl %ecx, %esi
subl $0x1, %edi
jb 0x11f2
movl %esi, %r8d
shrl %r8d
andl $0x1, %esi
negl %esi
andl %eax, %esi
xorl %r8d, %esi
jmp 0x11db
movl %esi, (%r15,%rcx,4)
incq %rcx
jmp 0x11ce
xorl %ebx, %ebx
pushq $0xa
popq %rbp
pushq $0x20
popq %r12
leaq 0xe34(%rip), %r14       # 0x203f
xorl %r13d, %r13d
cmpq $0x100, %r13            # imm = 0x100
je 0x1258
movl (%r15), %esi
movl %r13d, %eax
notl %eax
testb $0x3, %al
movl %r12d, %edx
cmovel %ebp, %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incq %r13
addq $0x4, %r15
jmp 0x120e
movq 0x2db7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0xdb6(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d88(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xda2(%rip), %rsi       # 0x201c
jmp 0x124e
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/primatesv1gibbon80/ref/primate.cpp
// Function: GenerateRoundConstants()
void GenerateRoundConstants() //Generation of 5-bit round constant by using the primitive polynomial x^5+x^2+1 with initial value 1.
{
	//Round constants for p_1
	rc_p1[0]=1;
	//printf("\nRound constants for p_1: \n %.2x", rc_p1[0]);
	for(int i=1; i<p1rounds; i++){
		rc_p1[i] = ((rc_p1[i-1]<<1) ^ ((rc_p1[i-1]>>1)&1) ^ ((rc_p1[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p1[i]);
	}

	//Round constant for p_2
	rc_p2[0] = ((rc_p1[p1rounds-1]<<1) ^ ((rc_p1[p1rounds-1]>>1)&1) ^ ((rc_p1[p1rounds-1]>>4)&1))&31;
	//printf("\nRound constants for p_2: \n %.2x", rc_p2[0]);
	for(int i=1; i<p2rounds; i++){
		rc_p2[i] = ((rc_p2[i-1]<<1) ^ ((rc_p2[i-1]>>1)&1) ^ ((rc_p2[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p2[i]);
	}
	
	//Round constant for p_3
	rc_p3[0] = ((rc_p2[p2rounds-1]<<1) ^ ((rc_p2[p2rounds-1]>>1)&1) ^ ((rc_p2[p2rounds-1]>>4)&1))&31;
	//printf("\nRound constants for p_3: \n %.2x", rc_p3[0]);
	for(int i=1; i<p3rounds; i++){
		rc_p3[i] = ((rc_p3[i-1]<<1) ^ ((rc_p3[i-1]>>1)&1) ^ ((rc_p3[i-1]>>4)&1))&31;
		//printf("\n %.2x", rc_p3[i]);
	}
}

// Assembly:
movq 0x300b(%rip), %rax      # 0x4fc0
movb $0x1, (%rax)
pushq $0x1
popq %rcx
movb $0x1, %dl
cmpq $0xc, %rcx
je 0x1fea
leal (%rdx,%rdx), %esi
movl %edx, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %dl
andb $0x1, %dl
andb $0x1e, %sil
orb %dil, %sil
xorb %dl, %sil
movb %sil, (%rax,%rcx)
incq %rcx
movl %esi, %edx
jmp 0x1fbd
movb 0xb(%rax), %cl
leal (%rcx,%rcx), %eax
movl %ecx, %edx
shrb %dl
andb $0x1, %dl
shrb $0x4, %cl
andb $0x1, %cl
andb $0x1e, %al
orb %dl, %al
xorb %cl, %al
movq 0x2fd6(%rip), %rcx      # 0x4fe0
movb %al, (%rcx)
pushq $0x1
popq %rdx
cmpq $0x6, %rdx
je 0x203b
leal (%rax,%rax), %esi
movl %eax, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %al
andb $0x1, %al
andb $0x1e, %sil
orb %dil, %sil
xorb %al, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
movl %esi, %eax
jmp 0x200f
movb 0x5(%rcx), %cl
leal (%rcx,%rcx), %eax
movl %ecx, %edx
shrb %dl
andb $0x1, %dl
shrb $0x4, %cl
andb $0x1, %cl
andb $0x1e, %al
orb %dl, %al
xorb %cl, %al
movq 0x2f9d(%rip), %rcx      # 0x4ff8
movb %al, (%rcx)
pushq $0x1
popq %rdx
cmpq $0x6, %rdx
je 0x208c
leal (%rax,%rax), %esi
movl %eax, %edi
shrb %dil
andb $0x1, %dil
shrb $0x4, %al
andb $0x1, %al
andb $0x1e, %sil
orb %dil, %sil
xorb %al, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
movl %esi, %eax
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/norx6444v2/ref/norx.c
// Function: norx_merge
static NORX_INLINE void norx_merge(norx_state_t state, norx_state_t state1)
{
    size_t i;
    norx_word_t * S = state->S;
    norx_word_t * S1 = state1->S;

    S1[15] ^= MERGE_TAG;
    norx_permute(state1);

    for (i = 0; i < 16; ++i) {
        S[i] ^= S1[i];
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorb $0x20, 0x78(%rsi)
movq %rsi, %rdi
callq 0x1989
xorl %eax, %eax
cmpq $0x10, %rax
je 0x14ee
movq (%rbx,%rax,8), %rcx
xorq %rcx, (%r14,%rax,8)
incq %rax
jmp 0x14db
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/samples/testkey/testkey.cpp
// Function: TestKey::TestKey()
TestKey::TestKey()
{
	Point	 pos;

	pos.x = 85;
	pos.y = 28;

	wnd	= new GUI::Window("TestKey - by Robert Kausch 2000-2020", Point(80, 80), Size(300, 160));
	title	= new Titlebar(TB_MINBUTTON | TB_CLOSEBUTTON);
	text	= new Text("ASCII code: 000\nUnicode character: 00000\n\nScan code: 000\nVirtual keycode: 000", pos);

	Add(wnd);

	wnd->Add(title);
	wnd->Add(text);

	wnd->onEvent.Connect(&TestKey::EventProc, this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3290
movq %rsp, %rdi
callq 0x3180
leaq 0x457b(%rip), %rax      # 0x7af8
movq %rax, (%rbx)
movabsq $0x1c00000055, %rax     # imm = 0x1C00000055
movq %rax, 0x20(%rsp)
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x31c0
movq %rax, %r15
leaq 0x1a7b(%rip), %rsi      # 0x501e
movq %rsp, %rdi
callq 0x32a0
movabsq $0x5000000050, %rax     # imm = 0x5000000050
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
movabsq $0xa00000012c, %rax     # imm = 0xA00000012C
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rsi
movq %r15, %rdi
xorl %r8d, %r8d
callq 0x3110
movq %r15, 0x5b8(%rbx)
movq %rsp, %rdi
callq 0x3180
movl $0x5c8, %edi            # imm = 0x5C8
callq 0x31c0
movq %rax, %r15
pushq $0x5
popq %rsi
movq %rax, %rdi
callq 0x30c0
movq %r15, 0x5c0(%rbx)
movl $0x5c0, %edi            # imm = 0x5C0
callq 0x31c0
movq %rax, %r15
leaq 0x1a24(%rip), %rsi      # 0x5043
movq %rsp, %rdi
callq 0x32a0
leaq 0x18(%rsp), %rcx
andq $0x0, (%rcx)
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x3080
movq %r15, 0x5c8(%rbx)
movq %rsp, %rdi
callq 0x3180
movq 0x5b8(%rbx), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq 0x5b8(%rbx), %rdi
movq 0x5c0(%rbx), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x5b8(%rbx), %rdi
movq 0x5c8(%rbx), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movl $0x668, %edi            # imm = 0x668
addq 0x5b8(%rbx), %rdi
leaq 0x74(%rip), %rsi        # 0x370e
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3a62
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36be
movq %rax, %r14
movl $0x5c0, %esi            # imm = 0x5C0
jmp 0x36e4
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
jmp 0x36e4
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36df
movq %rax, %r14
movl $0x6d8, %esi            # imm = 0x6D8
movq %r15, %rdi
callq 0x3040
jmp 0x36fe
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x3706
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3100
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c/dip.c
// Function: main
int
main(void)
{
    double *f;
    int me;

    shmem_init();
    me = shmem_my_pe();

    f = (double *) shmem_malloc(sizeof(*f));

    *f = PI;
    shmem_barrier_all();

    if (me == 0) {
        shmem_double_p(f, E, 1);
    }

    shmem_barrier_all();


    if (me == 1) {
        printf("PE %d: %f, %s\n",
               me, *f, (fabs(*f - E) < epsilon) ? "OK" : "FAIL");
    }

    shmem_free(f);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1080
callq 0x1050
movl %eax, %ebp
pushq $0x8
popq %rdi
callq 0x1060
movq %rax, %rbx
movabsq $0x400921fb53c8d4f1, %rax # imm = 0x400921FB53C8D4F1
movq %rax, (%rbx)
callq 0x1070
testl %ebp, %ebp
jne 0x11ef
movsd 0xe24(%rip), %xmm0      # 0x2008
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x10a0
callq 0x1070
cmpl $0x1, %ebp
jne 0x1240
movsd (%rbx), %xmm0
movsd 0xe0b(%rip), %xmm1      # 0x2010
addsd %xmm0, %xmm1
andpd 0xe0f(%rip), %xmm1      # 0x2020
movsd 0xdff(%rip), %xmm2      # 0x2018
ucomisd %xmm1, %xmm2
leaq 0xe1b(%rip), %rax       # 0x203f
leaq 0xe17(%rip), %rdx       # 0x2042
cmovaq %rax, %rdx
leaq 0xdfa(%rip), %rdi       # 0x2030
pushq $0x1
popq %rsi
movb $0x1, %al
callq 0x1030
movq %rbx, %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/nasw-tab.c
// Function: ns_opt_init
void ns_opt_init(ns_opt_t *opt)
{
	memset(opt, 0, sizeof(*opt));
	opt->go = 11, opt->ge = 1;
	opt->io = 29;
	opt->fs = 17;
	opt->xdrop = 100;
	opt->end_bonus = 5;
	ns_opt_set_sp(opt, NS_S_MAMMAL);
	opt->sp_null_bonus = -7;
	opt->asize = 22;
	opt->ie_coef = .5f;
	opt->sc = ns_mat_blosum62;
	opt->nt4 = ns_tab_nt4;
	opt->aa20 = ns_tab_aa20;
	opt->codon = ns_tab_codon;
}

// Assembly:
andq $0x0, (%rdi)
movaps 0xe5ce(%rip), %xmm0     # 0x11cc0
movups %xmm0, 0x4(%rdi)
movaps 0xe5d3(%rip), %xmm0     # 0x11cd0
movups %xmm0, 0x24(%rdi)
movabsq $-0x6fffffffc, %rax     # imm = 0xFFFFFFF900000004
movq %rax, 0x34(%rdi)
movaps 0xe5ca(%rip), %xmm0     # 0x11ce0
movups %xmm0, 0x14(%rdi)
movl $0x3f000000, 0x3c(%rdi) # imm = 0x3F000000
leaq 0x14ad8(%rip), %rax     # 0x18200
movq %rax, 0x40(%rdi)
leaq 0x14cdd(%rip), %rax     # 0x18410
movq %rax, 0x48(%rdi)
leaq 0x14dd2(%rip), %rax     # 0x18510
movq %rax, 0x50(%rdi)
leaq 0x14fc7(%rip), %rax     # 0x18710
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/nasw-tab.c
// Function: ns_set_stop_sc
void ns_set_stop_sc(int32_t asize, int8_t *mat, int8_t pen)
{
	int32_t aa_stop = ns_tab_aa20['*'];
	int32_t i, score_ori = mat[aa_stop * asize + aa_stop];
	for (i = 0; i < asize; ++i)
		mat[aa_stop * asize + i] = mat[i * asize + aa_stop] = -pen;
	mat[aa_stop * asize + aa_stop] = score_ori;
}

// Assembly:
movzbl 0x14de5(%rip), %eax     # 0x1853a
movslq %edi, %rcx
movq %rax, %rdi
imulq %rcx, %rdi
movslq %edi, %r8
addq %rax, %r8
movb (%rsi,%r8), %r9b
negb %dl
xorl %r10d, %r10d
testl %ecx, %ecx
movl $0x0, %r11d
cmovgl %ecx, %r11d
addq %rsi, %rax
addq %rsi, %rdi
cmpq %r10, %r11
je 0x3793
movb %dl, (%rax)
movb %dl, (%rdi,%r10)
incq %r10
addq %rcx, %rax
jmp 0x3780
movb %r9b, (%rsi,%r8)
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/sys.c
// Function: mp_realtime
double mp_realtime(void)
{
	static double realtime0 = -1.0;
	struct timeval tp;
	double t;
	gettimeofday(&tp, NULL);
	t = tp.tv_sec + tp.tv_usec * 1e-6;
	if (realtime0 < 0.0) realtime0 = t;
	return t - realtime0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2140
cvtsi2sdq (%rbx), %xmm1
cvtsi2sdq 0x8(%rbx), %xmm0
mulsd 0xeb5a(%rip), %xmm0     # 0x12380
addsd %xmm1, %xmm0
movsd 0x14bb6(%rip), %xmm1    # 0x183e8
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x3848
movsd %xmm0, 0x14ba4(%rip)    # 0x183e8
movapd %xmm0, %xmm1
subsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/options.c
// Function: mp_mapopt_set_max_intron
void mp_mapopt_set_max_intron(mp_mapopt_t *mo, int64_t gsize)
{
	int64_t x;
	x = (int64_t)(sqrt((double)gsize) * MP_MAX_INTRON_COEF + 1.);
	if (x < mo->min_max_intron) x = mo->min_max_intron;
	if (x > mo->max_max_intron) x = mo->max_max_intron;
	mo->bw = mo->max_intron = x;
	if (mp_verbose >= 3)
		fprintf(stderr, "[M::%s] set max intron size to %d\n", __func__, mo->max_intron);
}

// Assembly:
pushq %rbx
cvtsi2sd %rsi, %xmm0
movq %rdi, %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3d77
sqrtsd %xmm0, %xmm0
jmp 0x3d7c
callq 0x2310
mulsd 0xe70c(%rip), %xmm0     # 0x12490
addsd 0xe70c(%rip), %xmm0     # 0x12498
cvttsd2si %xmm0, %rax
movslq 0x1c(%rbx), %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
movslq 0x20(%rbx), %rax
cmpq %rax, %rcx
cmovgeq %rax, %rcx
movl %ecx, 0x18(%rbx)
movl %ecx, 0x24(%rbx)
leaq 0x1463c(%rip), %rax     # 0x183f0
cmpl $0x3, (%rax)
jge 0x3dbb
popq %rbx
retq
movq 0x1422e(%rip), %rax     # 0x17ff0
movq (%rax), %rdi
leaq 0xe72d(%rip), %rsi      # 0x124f9
leaq 0xe749(%rip), %rdx      # 0x1251c
xorl %eax, %eax
popq %rbx
jmp 0x21e0
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/options.c
// Function: mp_mapopt_init
void mp_mapopt_init(mp_mapopt_t *mo)
{
	memset(mo, 0, sizeof(*mo));
	mo->flag = 0;
	mo->mini_batch_size = 2000000;
	mo->max_occ = 20000;
	mo->max_gap = 1000;
	mo->max_intron = 200000;
	mo->min_max_intron = 10000, mo->max_max_intron = 300000;
	mo->bw = mo->max_intron;
	mo->min_chn_cnt = 3;
	mo->max_chn_max_skip = 25;
	mo->max_chn_iter = 1000000;
	mo->min_chn_sc = 0;
	mo->chn_coef_log = 0.75f;
	mo->max_ext = 10000;
	mo->max_ava = 1000;
	mo->mask_level = 0.5f;
	mo->mask_len = INT32_MAX;
	mo->pri_ratio = 0.7f;
	mo->best_n = 30;
	mo->out_n = 1000;
	mo->out_sim = 0.99f;
	mo->out_cov = 0.1f;
	#if MP_BITS_PER_AA == 4
	mo->kmer2 = 5;
	#else
	mo->kmer2 = 7;
	#endif

	mo->go = 11, mo->ge = 1;
	mo->io = 29;
	mo->fs = 23;
	mo->io_end = 19;
	mo->ie_coef = .5f;
	mo->sp_model = NS_S_GENERIC;
	mo->sp_null_bonus = -7;
	mo->sp_max_bonus = 14;
	mo->sp_scale = 1.0f;
	mo->end_bonus = 5;
	mo->xdrop = 100;
	mo->asize = 22;
	memcpy(mo->mat, ns_mat_blosum62, 484);
	ns_set_stop_sc(mo->asize, mo->mat, mo->fs);

	mo->gff_delim = -1;
	mo->gff_prefix = "MP";
	mo->max_intron_flank = 200;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x290, %edx            # imm = 0x290
xorl %esi, %esi
callq 0x2160
movq $0x1e8480, 0x8(%rbx)    # imm = 0x1E8480
movaps 0xe623(%rip), %xmm0     # 0x12420
movups %xmm0, 0x10(%rbx)
movabsq $0x1900000003, %rax     # imm = 0x1900000003
movq %rax, 0x30(%rbx)
movl $0xf4240, 0x38(%rbx)    # imm = 0xF4240
movaps 0xe613(%rip), %xmm0     # 0x12430
movups %xmm0, 0x20(%rbx)
movsd 0xe617(%rip), %xmm0     # 0x12440
movsd %xmm0, 0x40(%rbx)
movl $0x7fffffff, 0x48(%rbx) # imm = 0x7FFFFFFF
movsd 0xe613(%rip), %xmm0     # 0x12450
movsd %xmm0, 0x4c(%rbx)
movl $0x3dcccccd, 0x54(%rbx) # imm = 0x3DCCCCCD
movaps 0xe610(%rip), %xmm0     # 0x12460
movups %xmm0, 0x58(%rbx)
movaps 0xe615(%rip), %xmm0     # 0x12470
movups %xmm0, 0x68(%rbx)
movaps 0xe61a(%rip), %xmm0     # 0x12480
movups %xmm0, 0x78(%rbx)
movabsq $0x643f800000, %rax     # imm = 0x643F800000
movq %rax, 0x88(%rbx)
movabsq $0x1600000005, %rax     # imm = 0x1600000005
movq %rax, 0x90(%rbx)
leaq 0xa8(%rbx), %r14
leaq 0x14366(%rip), %rsi     # 0x18200
movl $0x1e4, %edx            # imm = 0x1E4
movq %r14, %rdi
callq 0x21f0
pushq $0x16
popq %rdi
pushq $0x17
popq %rdx
movq %r14, %rsi
callq 0x374e
movabsq $0xc8ffffffff, %rax     # imm = 0xC8FFFFFFFF
movq %rax, 0x98(%rbx)
leaq 0xe668(%rip), %rax      # 0x12535
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/index.c
// Function: mp_idx_boff
uint32_t *mp_idx_boff(const mp_ntdb_t *db, int32_t bbit, uint32_t *n_boff)
{
	int32_t i;
	int64_t boff = 0;
	uint32_t *bo;
	bo = Kmalloc(0, uint32_t, db->n_ctg * 2 + 1);
	for (i = 0; i < db->n_ctg; ++i) {
		bo[i<<1|0] = boff;
		boff += (db->ctg[i].len + (1<<bbit) - 1) >> bbit;
		bo[i<<1|1] = boff;
		boff += (db->ctg[i].len + (1<<bbit) - 1) >> bbit;
	}
	assert(boff < UINT32_MAX);
	bo[db->n_ctg*2] = *n_boff = boff;
	return bo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq (%rdi), %rax
leaq 0x4(,%rax,8), %rsi
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x7460
pushq $0x1
popq %rdx
movl %edx, %esi
movl %ebp, %ecx
shll %cl, %esi
movslq %esi, %rsi
decq %rsi
movl %ebp, %ecx
pushq $0x4
popq %r8
movabsq $0x200000000, %r9       # imm = 0x200000000
xorl %r10d, %r10d
xorl %edi, %edi
movslq (%r14), %r11
cmpq %r11, %r10
jge 0x3f90
movq %r15, %r11
sarq $0x1e, %r11
movl %edi, (%rax,%r11)
movq 0x28(%r14), %r11
movq (%r11,%r8,2), %r11
addq %rsi, %r11
sarq %cl, %r11
addq %r11, %rdi
movslq %edx, %rdx
movl %edi, (%rax,%rdx,4)
addq %r11, %rdi
incq %r10
addl $0x2, %edx
addq %r9, %r15
addq $0xc, %r8
jmp 0x3f54
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rdi
jge 0x3fad
movl %edi, (%rbx)
movslq (%r14), %rcx
movl %edi, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe5bc(%rip), %rdi      # 0x12570
leaq 0xe5c7(%rip), %rsi      # 0x12582
leaq 0xe5c8(%rip), %rcx      # 0x1258a
pushq $0x17
popq %rdx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O2/lh3[P]miniprot/index.c
// Function: build_worker
static void build_worker(void *data, long j, int tid)
{
	worker_aux_t *aux = (worker_aux_t*)data;
	const mp_ntdb_t *nt = aux->mi->nt;
	const mp_idxopt_t *io = &aux->mi->opt;
	void *km = aux->km[tid], *km_tmp = aux->km_tmp[tid];
	int64_t len;
	uint8_t *seq;
	mp64_v a = {0,0,0};
	seq = Kmalloc(km_tmp, uint8_t, nt->ctg[j>>1].len);
	len = mp_ntseq_get(nt, j>>1, 0, -1, j&1, seq);
	mp_sketch_nt4(km_tmp, seq, len, io->min_aa_len, io->kmer, io->mod_bit, io->bbit, aux->mi->bo[j], &a);
	aux->a[j].m = aux->a[j].n = a.n;
	aux->a[j].a = Kmalloc(km, uint64_t, a.n);
	memcpy(aux->a[j].a, a.a, a.n * sizeof(uint64_t));
	kfree(km_tmp, a.a);
	kfree(km_tmp, seq);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %r12
movq 0x8(%rdi), %rax
movq 0x18(%r12), %rbp
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rdi), %rax
movq (%rax,%rcx,8), %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x28(%rbp), %rax
movq %rsi, %r14
sarq %r14
imulq $0x18, %r14, %rcx
movq 0x8(%rax,%rcx), %rsi
movq %rbx, %rdi
callq 0x7460
movl %r13d, %r8d
andl $0x1, %r8d
pushq $-0x1
popq %rcx
movq %rbp, %rdi
movl %r14d, %esi
xorl %edx, %edx
movq %rax, %r14
movq %rax, %r9
callq 0xade7
movl (%r12), %r10d
movl 0x4(%r12), %ecx
movl 0x8(%r12), %r8d
movl 0xc(%r12), %r9d
movq (%r15), %rdx
movq 0x30(%rdx), %rdx
movl (%rdx,%r13,4), %r11d
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %r12
movq %rax, %rdx
leaq 0x18(%rsp), %r14
pushq %r14
pushq %r11
pushq %r10
callq 0xbe61
addq $0x20, %rsp
movslq (%r14), %rsi
movq 0x18(%r15), %rax
shlq $0x4, %r13
movl %esi, (%rax,%r13)
movl %esi, 0x4(%rax,%r13)
shlq $0x3, %rsi
movq 0x8(%rsp), %rdi
callq 0x7460
movq 0x18(%r15), %rcx
movq %rax, 0x8(%rcx,%r13)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x21f0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x736b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x736b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq