LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r14d, %r14d
movl $0x1000, %edx           # imm = 0x1000
xorl %esi, %esi
callq 0x30d0
leaq 0x1000(%rbx), %rax
leaq 0x1400(%rbx), %rcx
leaq 0x1800(%rbx), %rdx
xorl %esi, %esi
cmpq $0x0, (%rbx,%rsi)
jne 0x4139
addq $0x400, %rsi            # imm = 0x400
cmpq $0x1000, %rsi           # imm = 0x1000
jne 0x4110
movq %r14, %rsi
shlq $0x4, %rsi
movq %rcx, (%rax,%rsi)
movq %rdx, 0x8(%rax,%rsi)
jmp 0x4148
movq %r14, %rdi
shlq $0x4, %rdi
movups (%rbx,%rsi), %xmm0
movups %xmm0, (%rax,%rdi)
incq %r14
addq $0x10, %rbx
cmpq $0x40, %r14
jne 0x410e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x4432
cmpl $0x3, %esi
ja 0x4451
movl %esi, %eax
leaq 0x1000(%rdi), %rcx
leaq 0x1400(%rdi), %rdx
leaq 0x1800(%rdi), %rsi
xorl %r8d, %r8d
shlq $0xa, %rax
addq %rdi, %rax
xorps %xmm0, %xmm0
movq %r8, %r9
shlq $0x4, %r9
movups %xmm0, (%r9,%rax)
xorl %r10d, %r10d
cmpq $0x0, (%rdi,%r10)
jne 0x4419
addq $0x400, %r10            # imm = 0x400
cmpq $0x1000, %r10           # imm = 0x1000
jne 0x43f7
movq %rdx, (%rcx,%r9)
movq %rsi, 0x8(%rcx,%r9)
jmp 0x4423
movups (%rdi,%r10), %xmm1
movups %xmm1, (%rcx,%r9)
incq %r8
addq $0x10, %rdi
cmpq $0x40, %r8
jne 0x43e8
popq %rbp
retq
leaq 0xfac8(%rip), %rdi      # 0x13f01
leaq 0xfac3(%rip), %rsi      # 0x13f03
leaq 0xfbc3(%rip), %rcx      # 0x1400a
movl $0x152, %edx            # imm = 0x152
callq 0x30b0
leaq 0xf96c(%rip), %rdi      # 0x13dc4
leaq 0xfaa4(%rip), %rsi      # 0x13f03
leaq 0xfba4(%rip), %rcx      # 0x1400a
movl $0x153, %edx            # imm = 0x153
callq 0x30b0
// File: /workspace/github_c_makefile_star2_O3/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 0x4525
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 0x4522
andl $0x3ff, %eax            # imm = 0x3FF
movb (%rcx,%rax), %al
retq
movb $-0x1, %al
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xf894(%rip), %rdi      # 0x13dc4
leaq 0xf9cc(%rip), %rsi      # 0x13f03
leaq 0xfb17(%rip), %rcx      # 0x14055
movl $0x175, %edx            # imm = 0x175
callq 0x30b0
// File: /workspace/github_c_makefile_star2_O3/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 0x487b
testq %rsi, %rsi
je 0x487b
cmpq $0x0, (%rsi)
je 0x489a
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)
movq $-0x1, 0x18(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x30(%rdi)
popq %rbp
retq
leaq 0xf833(%rip), %rdi      # 0x140b5
leaq 0xf838(%rip), %rsi      # 0x140c1
leaq 0xf83b(%rip), %rcx      # 0x140cb
movl $0x2c7, %edx            # imm = 0x2C7
callq 0x30b0
leaq 0xf855(%rip), %rdi      # 0x140f6
leaq 0xf819(%rip), %rsi      # 0x140c1
leaq 0xf81c(%rip), %rcx      # 0x140cb
movl $0x2c8, %edx            # imm = 0x2C8
callq 0x30b0
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1c00, %edx           # imm = 0x1C00
movq %r14, %rdi
xorl %esi, %esi
callq 0x30d0
leaq 0x2a10(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
movl $0xff, %esi
callq 0x30d0
movq %r14, %rdi
callq 0x3100
leaq 0x4230(%rbx), %r15
cmpl $0x1, 0x1114(%rbx)
jne 0x110f1
leaq 0x18230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x4000, %ecx           # imm = 0x4000
movq %r8, %r9
callq 0x418a
leaq 0xc230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
movl $0x4000, %ecx           # imm = 0x4000
movq %r8, %r9
callq 0x418a
movq %r14, %rdi
xorl %esi, %esi
movl $0xc000, %edx           # imm = 0xC000
movl $0x4000, %ecx           # imm = 0x4000
movq %r15, %r8
movq %r15, %r9
jmp 0x11142
movq %r14, %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
movl $0x4000, %ecx           # imm = 0x4000
movq %r15, %r8
movq %r15, %r9
callq 0x418a
leaq 0x8230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
movl $0x4000, %ecx           # imm = 0x4000
movq %r8, %r9
callq 0x418a
leaq 0xc230(%rbx), %r8
movq %r14, %rdi
xorl %esi, %esi
movl $0xc000, %edx           # imm = 0xC000
movl $0x4000, %ecx           # imm = 0x4000
movq %r8, %r9
callq 0x418a
addq $0x24230, %rbx          # imm = 0x24230
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x4000, %ecx           # imm = 0x4000
movq %rbx, %r8
xorl %r9d, %r9d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x418a
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x112d1
movq %rdi, %rbx
cmpb $0x0, 0x1110(%rdi)
je 0x112d1
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rbx)
movq $-0x1, 0x18(%rbx)
movabsq $-0xffffffffff0020, %rax # imm = 0xFF0000000000FFE0
andq %rax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x50(%rbx)
movl 0x54(%rbx), %ecx
movl %ecx, 0x58(%rbx)
movl %eax, 0x60(%rbx)
movl 0x1114(%rbx), %eax
cmpl $0x1, %eax
jne 0x1127f
leaq 0x870(%rbx), %rdi
pxor %xmm0, %xmm0
movdqu %xmm0, 0x890(%rbx)
movq $0x0, 0x89d(%rbx)
callq 0x33a0
xorl %eax, %eax
movb %al, 0x8e8(%rbx)
movb %al, 0x8ea(%rbx)
movb 0x8a2(%rbx), %al
andb $0x9, %al
cmpb $0x8, %al
setne 0x8e9(%rbx)
movl 0x1114(%rbx), %eax
xorl %r14d, %r14d
movw %r14w, 0x111c(%rbx)
movb $0x0, 0x111e(%rbx)
movw %r14w, 0x1125(%rbx)
movl 0x1130(%rbx), %ecx
movl %ecx, 0x1134(%rbx)
movl $0x0, 0x1138(%rbx)
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,4), %eax
movl %eax, 0x113c(%rbx)
movq %rbx, %rdi
callq 0x1104d
movw %r14w, 0x22(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2fb5(%rip), %rdi      # 0x1428d
leaq 0x2e7b(%rip), %rsi      # 0x1415a
leaq 0x2fd1(%rip), %rcx      # 0x142b7
movl $0x133, %edx            # imm = 0x133
callq 0x30b0
// File: /workspace/github_c_makefile_star2_O3/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 0x11348
movq %rdi, %r14
cmpb $0x0, 0x1110(%rdi)
je 0x11348
movl %esi, %ebx
leaq 0x1148(%r14), %rdi
callq 0x30a0
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 0x31a0
leaq 0x2f3e(%rip), %rdi      # 0x1428d
leaq 0x2e04(%rip), %rsi      # 0x1415a
leaq 0x2f70(%rip), %rcx      # 0x142cd
movl $0x14b, %edx            # imm = 0x14B
callq 0x30b0
// File: /workspace/github_c_makefile_star2_O3/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, 0x8a4df(%rip)     # 0x9c368
leaq -0x9(%rbp), %rsi
movb $0x1, (%rsi)
movl $0x12, %edi
callq *%rbx
leaq 0x15(%rip), %rax        # 0x11eb3
leaq -0x18(%rbp), %rsi
movq %rax, (%rsi)
movl $0x21, %edi
callq *%rbx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30(%rip), %rax        # 0x11f50
movq %rax, 0x8a439(%rip)     # 0x9c360
leaq -0x8(%rbp), %rsi
movl $0x1b, %edi
callq *0x8a432(%rip)          # 0x9c368
testb %al, %al
je 0x11f45
movq -0x8(%rbp), %rax
movq %rax, 0x8a41b(%rip)     # 0x9c360
callq 0x11f56
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3a3cb(%rip), %rax     # 0x4c348
movq %rax, 0x8(%rsi)
leaq 0xa188(%rip), %rdi      # 0x1c110
movl $0x50000, 0x10(%rsi)    # imm = 0x50000
xorl %ebx, %ebx
movq %rbx, 0x18(%rsi)
leaq 0x686(%rip), %rax       # 0x12622
movq %rax, 0x20(%rsi)
movsd 0x1bc8(%rip), %xmm0     # 0x13b70
movups %xmm0, 0x28(%rsi)
leaq 0x614d(%rip), %rax      # 0x18100
movq %rax, 0x38(%rsi)
movl $0x4000, 0x40(%rsi)     # imm = 0x4000
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsi)
movq %rbx, 0x58(%rsi)
callq 0x3070
movabsq $0x10000000140, %rax    # imm = 0x10000000140
movq %rax, 0x8a369(%rip)     # 0x9c348
movq %rbx, 0x3a35a(%rip)     # 0x4c340
leaq 0xb27b(%rip), %r14      # 0x1d268
movl $0x4b8, %edx            # imm = 0x4B8
movq %r14, %rdi
xorl %esi, %esi
callq 0x30d0
movl $0x411b, 0xb26a(%rip)   # imm = 0x411B
movl $0x80, %r12d
xorl %r15d, %r15d
leal (%r12,%r15), %esi
movq %r14, %rdi
movl %ebx, %edx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x3160
incl %r15d
cmpl $0x5, %r15d
jne 0x1200f
incl %ebx
addl %r15d, %r12d
cmpl $0x8, %ebx
jne 0x1200c
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x237f(%rip), %rax      # 0x143f9
movq %rax, (%rdi)
leaq 0x237b(%rip), %rax      # 0x143ff
movq %rax, 0x8(%rdi)
movw $0x0, 0x18(%rdi)
leaq 0x2370(%rip), %rax      # 0x14405
movq %rax, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8a2a3(%rip), %eax     # 0x9c348
movl %eax, (%rdi)
movl 0x8a29f(%rip), %ecx     # 0x9c34c
movl %ecx, 0x4(%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl $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_O3/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 0x121c6
movq %rdi, %rbx
leaq -0x1c(%rbp), %rsi
movl $0x1, (%rsi)
movl $0xa, %edi
callq *0x8a211(%rip)          # 0x9c368
testb %al, %al
je 0x121ca
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rbx
movq 0x8a1e6(%rip), %rdi     # 0x9c350
testq %rdi, %rdi
je 0x1217e
callq 0x3040
xorps %xmm0, %xmm0
movups %xmm0, 0x8a1d2(%rip)    # 0x9c350
testq %r14, %r14
je 0x121e2
leaq 0x9f86(%rip), %rdi      # 0x1c110
movq %r14, %rsi
movl %ebx, %edx
callq 0x3120
testb %al, %al
je 0x121eb
movq %rbx, %rdi
callq 0x3150
testq %rax, %rax
je 0x121ef
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3140
movq %r15, 0x8a193(%rip)     # 0x9c350
movq %rbx, 0x8a194(%rip)     # 0x9c358
jmp 0x121e7
xorl %ebx, %ebx
jmp 0x12239
leaq 0x225f(%rip), %rsi      # 0x14430
xorl %ebx, %ebx
movl $0x3, %edi
xorl %eax, %eax
callq *0x8a180(%rip)          # 0x9c360
jmp 0x12239
callq 0x11f56
movb $0x1, %bl
jmp 0x12205
xorl %ebx, %ebx
jmp 0x12205
leaq 0x2395(%rip), %rsi      # 0x1458b
xorl %ebx, %ebx
movl $0x3, %edi
xorl %eax, %eax
callq *0x8a15b(%rip)          # 0x9c360
leaq 0x5a34(%rip), %rsi      # 0x17c40
leaq -0x130(%rbp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
callq 0x3140
leaq -0x30(%rbp), %rsi
movq %r14, (%rsi)
movl $0x4, 0x8(%rsi)
movl $0x10024, %edi          # imm = 0x10024
callq *0x8a12f(%rip)          # 0x9c368
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x124f8
movl %edi, %eax
leaq 0x1288(%rip), %rcx      # 0x136c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzbl 0x9cd0(%rip), %eax      # 0x1c118
jmp 0x1250a
movzbl 0x9ce2(%rip), %eax      # 0x1c136
jmp 0x1250a
movzwl 0x9cd2(%rip), %eax      # 0x1c132
jmp 0x1250a
movzbl 0x9cc9(%rip), %eax      # 0x1c135
jmp 0x1250a
movzwl 0x9ca2(%rip), %eax      # 0x1c11a
jmp 0x1250a
movzbl 0x9cb0(%rip), %eax      # 0x1c134
jmp 0x1250a
movzwl 0x9c94(%rip), %eax      # 0x1c124
jmp 0x1250a
movzwl 0x9c85(%rip), %eax      # 0x1c11e
jmp 0x1250a
movl 0x9c8f(%rip), %eax      # 0x1c130
movl %eax, %ecx
shrl %ecx
andl $0x2, %ecx
shrl $0x3, %eax
andl $0x1, %eax
orl %ecx, %eax
jmp 0x1250a
movzwl 0x9c63(%rip), %eax      # 0x1c11c
jmp 0x1250a
movzwl 0x9c5e(%rip), %eax      # 0x1c120
rolw $0x8, %ax
movzwl %ax, %eax
jmp 0x1250a
movzbl 0x9c47(%rip), %eax      # 0x1c119
jmp 0x1250a
movzwl 0x9c53(%rip), %eax      # 0x1c12e
jmp 0x1250a
movzwl 0x9c48(%rip), %eax      # 0x1c12c
jmp 0x1250a
movzwl 0x9c3b(%rip), %eax      # 0x1c128
jmp 0x1250a
movzwl 0x9c34(%rip), %eax      # 0x1c12a
jmp 0x1250a
jmp 0x1250a
movzwl 0x9c21(%rip), %eax      # 0x1c122
jmp 0x1250a
movzwl 0x9c1c(%rip), %eax      # 0x1c126
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x125be
movl %edi, %eax
leaq 0x11e6(%rip), %rcx      # 0x13708
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x125c3
movw %si, 0x9bf9(%rip)       # 0x1c132
jmp 0x125be
movb %sil, 0x9bf0(%rip)      # 0x1c135
jmp 0x125be
movw %si, 0x9bcc(%rip)       # 0x1c11a
jmp 0x125be
movb %sil, 0x9bdd(%rip)      # 0x1c134
jmp 0x125be
movw %si, 0x9bc4(%rip)       # 0x1c124
jmp 0x125be
movw %si, 0x9bb5(%rip)       # 0x1c11e
jmp 0x125be
movw %si, 0x9baa(%rip)       # 0x1c11c
jmp 0x125be
rolw $0x8, %si
movw %si, 0x9ba1(%rip)       # 0x1c120
jmp 0x125be
movb %sil, 0x9b90(%rip)      # 0x1c118
jmp 0x125be
movb %sil, 0x9b88(%rip)      # 0x1c119
jmp 0x125be
movw %si, 0x9b92(%rip)       # 0x1c12c
jmp 0x125be
movw %si, 0x9b85(%rip)       # 0x1c128
jmp 0x125be
movw %si, 0x9b7e(%rip)       # 0x1c12a
jmp 0x125be
movw %si, 0x9b6d(%rip)       # 0x1c122
jmp 0x125be
movw %si, 0x9b68(%rip)       # 0x1c126
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x12682
pushq %rbp
movq %rsp, %rbp
movl %esi, %eax
xorl %ecx, %ecx
movss 0x9d6(%rip), %xmm0      # 0x1300c
movss 0x9d6(%rip), %xmm1      # 0x13014
leaq 0x89d4b(%rip), %rdx     # 0x9c390
movss 0x9c3(%rip), %xmm2      # 0x13010
movss (%rdi,%rcx,4), %xmm4
ucomiss %xmm4, %xmm0
movaps %xmm0, %xmm3
ja 0x12665
ucomiss %xmm2, %xmm4
movaps %xmm4, %xmm3
jbe 0x12665
movaps %xmm2, %xmm3
mulss %xmm1, %xmm3
cvttss2si %xmm3, %r8d
movw %r8w, (%rdx,%rcx,4)
movw %r8w, 0x2(%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x1264d
popq %rbp
movq 0x89cef(%rip), %rax     # 0x9c378
movslq %esi, %rsi
leaq 0x89cfd(%rip), %rdi     # 0x9c390
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
cmpl $0x1, %edi
jle 0x1252
movq 0x8(%rsi), %rdx
incq %rdx
movzbl -0x1(%rdx), %ecx
cmpl $0x30, %ecx
je 0x1181
cmpl $0x78, %ecx
je 0x1181
xorl %eax, %eax
testl %ecx, %ecx
je 0x11d9
leal -0x30(%rcx), %edi
movl $0xffffffd0, %esi       # imm = 0xFFFFFFD0
cmpb $0xa, %dil
jb 0x11c6
leal -0x41(%rcx), %edi
movl $0xffffffc9, %esi       # imm = 0xFFFFFFC9
cmpb $0x6, %dil
jb 0x11c6
leal -0x61(%rcx), %edi
movl $0xffffffa9, %esi       # imm = 0xFFFFFFA9
cmpb $0x6, %dil
jae 0x1261
shll $0x4, %eax
movsbl %cl, %ecx
addl %esi, %ecx
orl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x1198
xorl %ecx, %ecx
leaq 0x2e6e(%rip), %r15      # 0x4050
movl $0x8, %edx
movl %ecx, %esi
movl %esi, %edi
shrl %edi
andl $0x1, %esi
negl %esi
andl %eax, %esi
xorl %edi, %esi
decl %edx
jne 0x11e9
movl %esi, (%r15,%rcx,4)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x11e2
xorl %ebx, %ebx
movl $0xa, %ebp
leaq 0xe27(%rip), %r14       # 0x203f
xorl %r12d, %r12d
movl (%r15), %esi
movl %r12d, %eax
notl %eax
testb $0x3, %al
movl $0x20, %edx
cmovel %ebp, %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incq %r12
addq $0x4, %r15
cmpq $0x100, %r12            # imm = 0x100
jne 0x121b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rdi
callq 0x1060
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1247
movq 0x2d90(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdaa(%rip), %rsi       # 0x201c
xorl %eax, %eax
callq 0x1040
jmp 0x125a
// File: /workspace/github_c_makefile_star2_O3/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 0x2df5(%rip), %rax      # 0x5fc0
movb $0x1, (%rax)
movl $0x1, %ecx
movb $0x1, %dl
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
cmpq $0xc, %rcx
jne 0x31d5
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 0x2dc0(%rip), %rcx      # 0x5fe0
movb %al, (%rcx)
movl $0x1, %edx
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
cmpq $0x6, %rdx
jne 0x3227
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 0x2d87(%rip), %rcx      # 0x5ff8
movb %al, (%rcx)
movl $0x1, %edx
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
cmpq $0x6, %rdx
jne 0x3278
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3280
movq %rsp, %rdi
callq 0x3180
leaq 0x3581(%rip), %rax      # 0x6af8
movq %rax, (%rbx)
movabsq $0x1c00000055, %rax     # imm = 0x1C00000055
movq %rax, 0x20(%rsp)
movl $0x6d8, %edi            # imm = 0x6D8
callq 0x31c0
movq %rax, %r15
leaq 0x1a81(%rip), %rsi      # 0x501e
movq %rsp, %rdi
callq 0x3290
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
movq %rax, %rdi
movl $0x5, %esi
callq 0x30c0
movq %r15, 0x5c0(%rbx)
movl $0x5c0, %edi            # imm = 0x5C0
callq 0x31c0
movq %rax, %r15
leaq 0x1a28(%rip), %rsi      # 0x5043
movq %rsp, %rdi
callq 0x3290
leaq 0x18(%rsp), %rcx
movq $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 0x75(%rip), %rsi        # 0x370e
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3a7e
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36bd
movq %rax, %r14
movl $0x5c0, %esi            # imm = 0x5C0
jmp 0x36e3
movq %rax, %r14
movl $0x5c8, %esi            # imm = 0x5C8
jmp 0x36e3
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x36de
movq %rax, %r14
movl $0x6d8, %esi            # imm = 0x6D8
movq %r15, %rdi
callq 0x3040
jmp 0x36fd
movq %rax, %r14
movq %rsp, %rdi
callq 0x3180
jmp 0x3705
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3100
nop
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x8, %edi
callq 0x1060
movq %rax, %rbx
movabsq $0x400921fb53c8d4f1, %rax # imm = 0x400921FB53C8D4F1
movq %rax, (%rbx)
callq 0x1070
testl %ebp, %ebp
je 0x1233
callq 0x1070
cmpl $0x1, %ebp
jne 0x124d
movsd (%rbx), %xmm0
movsd 0xe14(%rip), %xmm1      # 0x2008
addsd %xmm0, %xmm1
andpd 0xe20(%rip), %xmm1      # 0x2020
movsd 0xe08(%rip), %xmm2      # 0x2010
ucomisd %xmm1, %xmm2
leaq 0xe2c(%rip), %rax       # 0x203f
leaq 0xe28(%rip), %rdx       # 0x2042
cmovaq %rax, %rdx
leaq 0xe0b(%rip), %rdi       # 0x2030
movl $0x1, %esi
movb $0x1, %al
callq 0x1030
jmp 0x124d
movsd 0xddd(%rip), %xmm0      # 0x2018
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10a0
callq 0x1070
movq %rbx, %rdi
callq 0x1090
callq 0x1040
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]miniprot/index.c
// Function: mp_idx_print_stat
void mp_idx_print_stat(const mp_idx_t *mi, int32_t max_occ)
{
	int64_t tot = 0, sum_large = 0;
	uint32_t i, n, n_occupied = 0, n_large = 0;
	n = mp_n_bucket(&mi->opt);
	for (i = 0; i < n - 1; ++i) {
		int64_t c = mi->ki[i+1] - mi->ki[i];
		if (c > 0) ++n_occupied;
		if (c > max_occ) ++n_large, sum_large += c;
		else tot += c;
	}
	fprintf(stderr, "[M::%s] %d distinct k-mers; mean occ of infrequent k-mers: %.2f; %d frequent k-mers accounting for %ld occurrences\n", __func__,
			n_occupied, (double)tot / (n_occupied - n_large), n_large, (long)sum_large);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x8(%rdi), %ecx
shll $0x2, %ecx
subl 0xc(%rdi), %ecx
jne 0x28c2
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
jmp 0x2938
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
shll %cl, %r8d
movq 0x28(%rdi), %rax
movslq %esi, %rdx
cmpl $-0x2, %r8d
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
cmovbl %r8d, %esi
notl %esi
movq (%rax), %rbx
xorl %edi, %edi
xorl %r11d, %r11d
xorl %r10d, %r10d
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %r9d, %r9d
movq 0x8(%rax,%r11,8), %r14
incq %r11
movq %r14, %r15
subq %rbx, %r15
xorl %ebx, %ebx
testq %r15, %r15
setg %bl
addl %ebx, %ecx
xorl %ebx, %ebx
cmpq %rdx, %r15
movl $0x0, %r12d
cmovgq %r15, %r12
setg %bl
cmovgq %rdi, %r15
addq %r12, %r9
addl %ebx, %r8d
addq %r15, %r10
movq %r14, %rbx
cmpq %r11, %rsi
jne 0x28f4
cvtsi2sd %r10, %xmm0
movq 0x166b1(%rip), %rax     # 0x18ff0
movl %ecx, %edx
subl %r8d, %edx
cvtsi2sd %rdx, %xmm1
movq (%rax), %rdi
divsd %xmm1, %xmm0
leaq 0x11ce9(%rip), %rsi     # 0x14640
leaq 0x11d56(%rip), %rdx     # 0x146b4
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, (%rdi)
movaps 0xf682(%rip), %xmm0     # 0x13cc0
movups %xmm0, 0x4(%rdi)
movaps 0xf687(%rip), %xmm0     # 0x13cd0
movups %xmm0, 0x24(%rdi)
movabsq $-0x6fffffffc, %rax     # imm = 0xFFFFFFF900000004
movq %rax, 0x34(%rdi)
movaps 0xf67e(%rip), %xmm0     # 0x13ce0
movups %xmm0, 0x14(%rdi)
movl $0x3f000000, 0x3c(%rdi) # imm = 0x3F000000
leaq 0x14b7c(%rip), %rax     # 0x191f0
movq %rax, 0x40(%rdi)
leaq 0x14d81(%rip), %rax     # 0x19400
movq %rax, 0x48(%rdi)
leaq 0x14e76(%rip), %rax     # 0x19500
movq %rax, 0x50(%rdi)
leaq 0x1506b(%rip), %rax     # 0x19700
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x14e89(%rip), %eax     # 0x1952a
movslq %edi, %r10
movq %rax, %r9
imulq %r10, %r9
leaq (%r9,%rax), %rcx
movb (%rsi,%rcx), %r8b
testl %r10d, %r10d
jle 0x46d9
negb %dl
movl %edi, %edi
movl %r9d, %r9d
addq %rsi, %rax
addq %rsi, %r9
xorl %r10d, %r10d
movb %dl, (%rax)
movb %dl, (%r9,%r10)
incq %r10
addq %rdi, %rax
cmpq %r10, %rdi
jne 0x46c8
movb %r8b, (%rsi,%rcx)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xfc12(%rip), %xmm0     # 0x14380
addsd %xmm1, %xmm0
movsd 0x14c5e(%rip), %xmm1    # 0x193d8
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x4790
movsd %xmm0, 0x14c4c(%rip)    # 0x193d8
movapd %xmm0, %xmm1
subsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d79
sqrtsd %xmm0, %xmm0
jmp 0x4d7e
callq 0x22f0
mulsd 0xf70a(%rip), %xmm0     # 0x14490
addsd 0xf70a(%rip), %xmm0     # 0x14498
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 0x1462a(%rip), %rax     # 0x193e0
cmpl $0x3, (%rax)
jge 0x4dbd
popq %rbx
retq
movq 0x1422c(%rip), %rax     # 0x18ff0
movq (%rax), %rdi
leaq 0xf72b(%rip), %rsi      # 0x144f9
leaq 0xf747(%rip), %rdx      # 0x1451c
xorl %eax, %eax
popq %rbx
jmp 0x21d0
// File: /workspace/github_c_makefile_star2_O3/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 0xf621(%rip), %xmm0     # 0x14420
movups %xmm0, 0x10(%rbx)
movabsq $0x1900000003, %rax     # imm = 0x1900000003
movq %rax, 0x30(%rbx)
movl $0xf4240, 0x38(%rbx)    # imm = 0xF4240
movaps 0xf611(%rip), %xmm0     # 0x14430
movups %xmm0, 0x20(%rbx)
movsd 0xf615(%rip), %xmm0     # 0x14440
movsd %xmm0, 0x40(%rbx)
movl $0x7fffffff, 0x48(%rbx) # imm = 0x7FFFFFFF
movsd 0xf611(%rip), %xmm0     # 0x14450
movsd %xmm0, 0x4c(%rbx)
movl $0x3dcccccd, 0x54(%rbx) # imm = 0x3DCCCCCD
movaps 0xf60e(%rip), %xmm0     # 0x14460
movups %xmm0, 0x58(%rbx)
movaps 0xf613(%rip), %xmm0     # 0x14470
movups %xmm0, 0x68(%rbx)
movaps 0xf618(%rip), %xmm0     # 0x14480
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 0x14354(%rip), %rsi     # 0x191f0
movl $0x1e4, %edx            # imm = 0x1E4
movq %r14, %rdi
callq 0x21e0
movl $0x16, %edi
movq %r14, %rsi
movl $0x17, %edx
callq 0x469a
movabsq $0xc8ffffffff, %rax     # imm = 0xC8FFFFFFFF
movq %rax, 0x98(%rbx)
leaq 0xf662(%rip), %rax      # 0x14535
movq %rax, 0xa0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x84a5
cmpl $0x0, (%r14)
jle 0x4f97
movq 0x28(%r14), %rdx
movl $0x1, %esi
movl $0x1, %edi
movl %ebp, %ecx
shll %cl, %edi
movslq %edi, %rdi
decq %rdi
movl %ebp, %ecx
addq $0x8, %rdx
xorl %r8d, %r8d
movabsq $0x200000000, %r9       # imm = 0x200000000
xorl %r10d, %r10d
xorl %r15d, %r15d
movq %r8, %r11
sarq $0x1e, %r11
movl %r15d, (%rax,%r11)
movq (%rdx), %r11
addq %rdi, %r11
sarq %cl, %r11
addq %r11, %r15
movslq %esi, %rsi
movl %r15d, (%rax,%rsi,4)
addq %r11, %r15
incq %r10
movslq (%r14), %r11
addl $0x2, %esi
addq %r9, %r8
addq $0x18, %rdx
cmpq %r11, %r10
jl 0x4f57
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %r15
jge 0x4fac
movl %r15d, (%rbx)
movslq (%r14), %rcx
movl %r15d, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf5bd(%rip), %rdi      # 0x14570
leaq 0xf5c8(%rip), %rsi      # 0x14582
leaq 0xf5c9(%rip), %rcx      # 0x1458a
movl $0x17, %edx
callq 0x2150
// File: /workspace/github_c_makefile_star2_O3/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
leaq (%r14,%r14,2), %rcx
movq 0x8(%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x84a5
movl %r13d, %r8d
andl $0x1, %r8d
movq %rbp, %rdi
movl %r14d, %esi
xorl %edx, %edx
movq $-0x1, %rcx
movq %rax, %r14
movq %rax, %r9
callq 0xc5f2
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 0xd744
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 0x84a5
movq 0x18(%r15), %rcx
movq %rax, 0x8(%rcx,%r13)
movq 0x8(%r14), %rsi
movslq (%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x21e0
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x83df
movq %rbx, %rdi
movq %r12, %rsi
callq 0x83df
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]miniprot/index.c
// Function: mp_idx_destroy
void mp_idx_destroy(mp_idx_t *mi)
{
	if (mi == 0) return;
	mp_ntseq_destroy(mi->nt);
	free(mi->ki); free(mi->bo); free(mi->kb);
	free(mi);
}

// Assembly:
testq %rdi, %rdi
je 0x5468
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xc585
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x30(%rbx), %rdi
callq 0x2050
movq 0x38(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]miniprot/index.c
// Function: mp_idx_dump
int mp_idx_dump(const char *fn, const mp_idx_t *mi)
{
	FILE *fp;
	fp = strcmp(fn, "-") == 0? stdout : fopen(fn, "wb");
	if (fp == 0) return -1;
	fwrite(MP_IDX_MAGIC, 1, 4, fp);
	fwrite(&mi->opt, sizeof(mi->opt), 1, fp);
	fwrite(&mi->n_kb, 8, 1, fp);
	mp_ntseq_dump(fp, mi->nt);
	fwrite(mi->ki, 8, mp_n_bucket(&mi->opt), fp);
	fwrite(mi->kb, 4, mi->n_kb, fp);
	if (fp != stdout) fclose(fp);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x2d, (%rdi)
jne 0x547f
cmpb $0x0, 0x1(%rdi)
je 0x5544
leaq 0xf240(%rip), %rsi      # 0x146c6
callq 0x22a0
movq %rax, %r14
testq %r14, %r14
je 0x5535
leaq 0xf22b(%rip), %rdi      # 0x146c9
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x22e0
movl $0x14, %esi
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x22e0
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22e0
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0xc96e
movq 0x28(%rbx), %rdi
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl $0x8, %esi
movq %r14, %rcx
callq 0x22e0
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x22e0
movq 0x13a9c(%rip), %rax     # 0x18fc0
xorl %ebx, %ebx
cmpq (%rax), %r14
je 0x553a
movq %r14, %rdi
callq 0x20f0
jmp 0x553a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13a75(%rip), %rax     # 0x18fc0
movq (%rax), %r14
jmp 0x548e
// File: /workspace/github_c_makefile_star2_O3/lh3[P]miniprot/index.c
// Function: mp_idx_restore
mp_idx_t *mp_idx_restore(const char *fn)
{
	FILE *fp;
	char magic[4];
	mp_idx_t *mi;

	fp = strcmp(fn, "-") == 0? stdin : fopen(fn, "rb");
	if (fp == 0) return 0;
	fread(magic, 1, 4, fp);
	if (strncmp(magic, MP_IDX_MAGIC, 4) != 0)
		return 0;
	mi = Kcalloc(0, mp_idx_t, 1);
	fread(&mi->opt, sizeof(mi->opt), 1, fp);
	ns_make_tables(mi->opt.trans_code);
	fread(&mi->n_kb, 8, 1, fp);
	mi->nt = mp_ntseq_restore(fp);
	mi->ki = Kmalloc(0, int64_t, mp_n_bucket(&mi->opt));
	mi->kb = Kmalloc(0, uint32_t, mi->n_kb);
	fread(mi->ki, 8, mp_n_bucket(&mi->opt), fp);
	fread(mi->kb, 4, mi->n_kb, fp);
	if (fp != stdin) fclose(fp);
	mi->bo = mp_idx_boff(mi->nt, mi->opt.bbit, &mi->n_block);
	if (mp_verbose >= 3)
		fprintf(stderr, "[M::%s@%.3f*%.2f] loaded the index\n", __func__, mp_realtime(), mp_percent_cpu());
	return mi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x2d, (%rdi)
jne 0x556b
cmpb $0x0, 0x1(%rdi)
je 0x56ab
leaq 0xf15c(%rip), %rsi      # 0x146ce
callq 0x22a0
movq %rax, %r14
testq %r14, %r14
je 0x55a1
leaq 0xc(%rsp), %rbx
movl $0x1, %esi
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x20a0
cmpl $0x349504d, (%rbx)      # imm = 0x349504D
je 0x55a8
xorl %ebx, %ebx
jmp 0x569e
movl $0x1, %esi
movl $0x40, %edx
xorl %edi, %edi
callq 0x8344
movq %rax, %rbx
movl $0x14, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rcx
callq 0x20a0
movl 0x10(%rbx), %edi
callq 0x441c
leaq 0x20(%rbx), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x20a0
movq %r14, %rdi
callq 0xca32
movq %rax, 0x18(%rbx)
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
movl $0x1, %r15d
movl $0x1, %esi
shll %cl, %esi
shlq $0x3, %rsi
xorl %edi, %edi
callq 0x84a5
movq %rax, 0x28(%rbx)
movq 0x20(%rbx), %rsi
shlq $0x2, %rsi
xorl %edi, %edi
callq 0x84a5
movq %rax, 0x38(%rbx)
movq 0x28(%rbx), %rdi
movl 0x8(%rbx), %ecx
shll $0x2, %ecx
subl 0xc(%rbx), %ecx
shll %cl, %r15d
movl $0x8, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20a0
movq 0x20(%rbx), %rdx
movq 0x38(%rbx), %rdi
movl $0x4, %esi
movq %r14, %rcx
callq 0x20a0
movq 0x13959(%rip), %rax     # 0x18fc8
cmpq (%rax), %r14
je 0x567c
movq %r14, %rdi
callq 0x20f0
movq 0x18(%rbx), %rdi
movl (%rbx), %esi
movq %rbx, %rdx
addq $0x14, %rdx
callq 0x4efc
movq %rax, 0x30(%rbx)
leaq 0x13d47(%rip), %rax     # 0x193e0
cmpl $0x3, (%rax)
jge 0x56ba
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x13916(%rip), %rax     # 0x18fc8
movq (%rax), %r14
jmp 0x557a
callq 0x2a46
jmp 0x569e