LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_2a.h
// Function: desc2a_set_N
static inline void desc2a_set_N(uint8_t *p_desc, uint32_t i_N)
{
    if (!desc2a_get_picture_and_timing_info_present(p_desc))
        return;
    if (desc2a_get_90khz_flag(p_desc))
        return;
    p_desc[4] = (i_N >> 24) & 0xff;
    p_desc[5] = (i_N >> 16) & 0xff;
    p_desc[6] = (i_N >>  8) & 0xff;
    p_desc[7] =  i_N        & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15920
testb $0x1, %al
jne 0x1554e
jmp 0x155ac
movq -0x8(%rbp), %rdi
callq 0x15940
testb $0x1, %al
jne 0x1555d
jmp 0x1555f
jmp 0x155ac
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_2a.h
// Function: desc2a_set_K
static inline void desc2a_set_K(uint8_t *p_desc, uint32_t i_K)
{
    if (!desc2a_get_picture_and_timing_info_present(p_desc))
        return;
    if (desc2a_get_90khz_flag(p_desc))
        return;
    p_desc[ 8] = (i_K >> 24) & 0xff;
    p_desc[ 9] = (i_K >> 16) & 0xff;
    p_desc[10] = (i_K >>  8) & 0xff;
    p_desc[11] =  i_K        & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15920
testb $0x1, %al
jne 0x155de
jmp 0x1563c
movq -0x8(%rbp), %rdi
callq 0x15940
testb $0x1, %al
jne 0x155ed
jmp 0x155ef
jmp 0x1563c
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x8(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xb(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/psi/desc_2a.h
// Function: desc2a_set_num_units_in_tick
static inline void desc2a_set_num_units_in_tick(uint8_t *p_desc, uint32_t i_num_units_in_tick)
{
    uint8_t ofs;
    if (!desc2a_get_picture_and_timing_info_present(p_desc))
        return;
    ofs = desc2a_get_90khz_flag(p_desc) == 0 ? 12 : 4;
    p_desc[ofs+0] = (i_num_units_in_tick >> 24) & 0xff;
    p_desc[ofs+1] = (i_num_units_in_tick >> 16) & 0xff;
    p_desc[ofs+2] = (i_num_units_in_tick >>  8) & 0xff;
    p_desc[ofs+3] =  i_num_units_in_tick        & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x15920
testb $0x1, %al
jne 0x15671
jmp 0x15707
movq -0x8(%rbp), %rdi
callq 0x15940
andb $0x1, %al
movzbl %al, %edx
movl $0x4, %eax
movl $0xc, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_7c.h
// Function: desc7c_set_aac_type_flag
static inline void desc7c_set_aac_type_flag(uint8_t *p_desc, bool b_aac_type_flag)
{
    uint8_t i_desc_len = desc_get_length(p_desc);
    if (i_desc_len == 1 && b_aac_type_flag) {
        i_desc_len += 2;
        desc_set_length(p_desc, i_desc_len);
    }
    if (i_desc_len > 1 && !b_aac_type_flag) {
        i_desc_len -= 2;
        desc_set_length(p_desc, i_desc_len);
    }
    if (i_desc_len > 1)
        p_desc[3] = b_aac_type_flag ? 0x80 : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5bb0
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
cmpl $0x1, %eax
jne 0x15d26
testb $0x1, -0x9(%rbp)
je 0x15d26
movzbl -0xa(%rbp), %eax
addl $0x2, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xa(%rbp), %esi
callq 0x5ca0
movzbl -0xa(%rbp), %eax
cmpl $0x1, %eax
jle 0x15d4c
testb $0x1, -0x9(%rbp)
jne 0x15d4c
movzbl -0xa(%rbp), %eax
subl $0x2, %eax
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xa(%rbp), %esi
callq 0x5ca0
movzbl -0xa(%rbp), %eax
cmpl $0x1, %eax
jle 0x15d6e
movb -0x9(%rbp), %dl
xorl %eax, %eax
movl $0x80, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/si/sit.h
// Function: sit_init
static inline void sit_init(uint8_t *p_sit)
{
    psi_init(p_sit, true);
    psi_set_tableid(p_sit, SIT_TABLE_ID);
    p_sit[1] |= 0xe0;
    psi_set_tableidext(p_sit, 0xffff);
    psi_set_section(p_sit, 0);
    psi_set_lastsection(p_sit, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x5410
movq -0x8(%rbp), %rdi
movl $0x7f, %esi
callq 0x5450
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
orl $0xe0, %ecx
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rdi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x4fb0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5040
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_gen_si.c
// Function: build_desc63
static void build_desc63(uint8_t *desc) {
    desc63_init(desc);
    desc63_set_peak_rate(desc, 5000);
    desc63_set_min_overall_smoothing_rate(desc, 7000);
    desc63_set_max_overall_smoothing_buffer(desc, 1000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x161f0
movq -0x8(%rbp), %rdi
movl $0x1388, %esi           # imm = 0x1388
callq 0x16240
movq -0x8(%rbp), %rdi
movl $0x1b58, %esi           # imm = 0x1B58
callq 0x16290
movq -0x8(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x162e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/si/sit.h
// Function: sit_get_service
static inline uint8_t *sit_get_service(uint8_t *p_sit, uint8_t n)
{
    uint16_t i_section_size = psi_get_length(p_sit) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    uint8_t *p_sit_n = p_sit + SIT_HEADER_SIZE + sit_get_desclength(p_sit);
    if (p_sit_n - p_sit > i_section_size) return NULL;

    while (n) {
        if (p_sit_n + SIT_SERVICE_SIZE - p_sit > i_section_size) return NULL;
        p_sit_n += SIT_SERVICE_SIZE + sitn_get_desclength(p_sit_n);
        n--;
    }
    if (p_sit_n - p_sit >= i_section_size) return NULL;
    return p_sit_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5490
movzwl %ax, %eax
addl $0x3, %eax
subl $0x4, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0xa, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x15fd0
movw %ax, %cx
movq -0x28(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x1606f
movq $0x0, -0x8(%rbp)
jmp 0x160e6
jmp 0x16071
cmpb $0x0, -0x11(%rbp)
je 0x160c0
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x16099
movq $0x0, -0x8(%rbp)
jmp 0x160e6
movq -0x20(%rbp), %rdi
callq 0x16320
movzwl %ax, %ecx
addl $0x4, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16071
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jl 0x160de
movq $0x0, -0x8(%rbp)
jmp 0x160e6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/si/desc_63.h
// Function: desc63_init
static inline void desc63_init(uint8_t *p_desc)
{
    desc_set_tag(p_desc, 0x63);
    desc_set_length(p_desc, DESC63_HEADER_SIZE - DESC_HEADER_SIZE);
    p_desc[2] = 0xc0;
    p_desc[5] = 0xc0;
    p_desc[8] = 0xc0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x63, %esi
callq 0x5c80
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x5ca0
movq -0x8(%rbp), %rax
movb $-0x40, 0x2(%rax)
movq -0x8(%rbp), %rax
movb $-0x40, 0x5(%rax)
movq -0x8(%rbp), %rax
movb $-0x40, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_init
static inline void scte35_init(uint8_t *p_scte35)
{
    psi_set_tableid(p_scte35, SCTE35_TABLE_ID);
    psi_init(p_scte35, false);
    p_scte35[1] &= ~0x40; /* private indicator */
    p_scte35[3] = 0;
    p_scte35[4] = 0;
    p_scte35[9] = 0;
    p_scte35[10] = 0xff;
    p_scte35[11] = 0xf0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfc, %esi
callq 0x5450
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x5410
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %ecx
andl $-0x41, %ecx
movb %cl, 0x1(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x9(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0xa(%rax)
movq -0x8(%rbp), %rax
movb $-0x10, 0xb(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_set_pts_adjustment
static inline void scte35_set_pts_adjustment(uint8_t *p_scte35,
                                             uint64_t i_adjustment)
{
    p_scte35[4] &= ~0x1;
    p_scte35[4] |= (i_adjustment >> 32) & 0x1;
    p_scte35[5] = (i_adjustment >> 24) & 0xff;
    p_scte35[6] = (i_adjustment >> 16) & 0xff;
    p_scte35[7] = (i_adjustment >> 8) & 0xff;
    p_scte35[8] = i_adjustment & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %ecx
andl $-0x2, %ecx
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rdx
shrq $0x20, %rdx
andq $0x1, %rdx
movq -0x8(%rbp), %rax
movzbl 0x4(%rax), %ecx
orq %rdx, %rcx
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x8(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_null_init
static inline void scte35_null_init(uint8_t *p_scte35)
{
    scte35_init(p_scte35);
    scte35_set_command_type(p_scte35, SCTE35_NULL_COMMAND);
    scte35_set_command_length(p_scte35, SCTE35_NULL_HEADER_SIZE);
    scte35_set_desclength(p_scte35, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16350
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x16b60
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x16b80
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x16490
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_set_desclength
static inline void scte35_set_desclength(uint8_t *p_scte35, uint16_t i_length)
{
    uint8_t *pi_desclength = scte35_get_command(p_scte35) +
                             scte35_get_command_length(p_scte35);
    pi_desclength[0] = (i_length >> 8) & 0xff;
    pi_desclength[1] = i_length & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bf0
movw %ax, %cx
movq -0x20(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_get_descl
static inline uint8_t *scte35_get_descl(const uint8_t *p_scte35)
{
    uint16_t i_command_length = scte35_get_command_length(p_scte35);
    if (i_command_length == 0xfff)
        return NULL;
    return scte35_get_command(p_scte35) + i_command_length +
           SCTE35_HEADER2_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16bf0
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0xfff, %eax            # imm = 0xFFF
jne 0x1652e
movq $0x0, -0x8(%rbp)
jmp 0x16549
movq -0x10(%rbp), %rdi
callq 0x16bd0
movzwl -0x12(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_init
static inline void scte35_insert_init(uint8_t *p_scte35, uint16_t i_length)
{
    scte35_init(p_scte35);
    scte35_set_command_type(p_scte35, SCTE35_INSERT_COMMAND);
    scte35_set_command_length(p_scte35,
                              SCTE35_INSERT_HEADER_SIZE + i_length);
    scte35_set_desclength(p_scte35, 0);

    uint8_t *p_command = scte35_get_command(p_scte35);
    p_command[4] = 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16350
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x16b60
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %eax
addl $0x5, %eax
movzwl %ax, %esi
callq 0x16b80
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x16490
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb $-0x1, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_cancel
static inline void scte35_insert_set_cancel(const uint8_t *p_scte35,
                                            bool b_cancel)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    if (b_cancel)
        p_command[4] |= 0x80;
    else {
        p_command[4] &= ~0x80;
        p_command[5] = 0xff;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1660a
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x4(%rax)
jmp 0x16623
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movb %cl, 0x4(%rax)
movq -0x18(%rbp), %rax
movb $-0x1, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_event_id
static inline void scte35_insert_set_event_id(uint8_t *p_scte35,
                                              uint32_t i_event_id)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    p_command[0] = (i_event_id >> 24) & 0xff;
    p_command[1] = (i_event_id >> 16) & 0xff;
    p_command[2] = (i_event_id >> 8) & 0xff;
    p_command[3] = i_event_id & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_out_of_network
static inline void scte35_insert_set_out_of_network(const uint8_t *p_scte35,
                                                    bool b_out_of_network)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    if (b_out_of_network)
        p_command[5] |= 0x80;
    else
        p_command[5] &= ~0x80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x166da
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x5(%rax)
jmp 0x166eb
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movb %cl, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_program_splice
static inline void scte35_insert_set_program_splice(const uint8_t *p_scte35,
                                                    bool b_program_splice)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    if (b_program_splice)
        p_command[5] |= 0x40;
    else
        p_command[5] &= ~0x40;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x16737
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x5(%rax)
jmp 0x16745
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
andl $-0x41, %ecx
movb %cl, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_duration
static inline void scte35_insert_set_duration(const uint8_t *p_scte35,
                                              bool b_duration)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    if (b_duration)
        p_command[5] |= 0x20;
    else
        p_command[5] &= ~0x20;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x16787
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x5(%rax)
jmp 0x16795
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
andl $-0x21, %ecx
movb %cl, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_set_splice_immediate
static inline void scte35_insert_set_splice_immediate(const uint8_t *p_scte35,
                                                      bool b_splice_immediate)
{
    uint8_t *p_command = scte35_get_command(p_scte35);
    if (b_splice_immediate)
        p_command[5] |= 0x10;
    else
        p_command[5] &= ~0x10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16bd0
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x167d7
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x5(%rax)
jmp 0x167e5
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %ecx
andl $-0x11, %ecx
movb %cl, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_splice_time_set_pts_time
static inline void scte35_splice_time_set_pts_time(uint8_t *p_splice_time,
                                                   uint64_t i_pts_time)
{
    p_splice_time[0] &= ~0x1;
    p_splice_time[0] |= (i_pts_time >> 32) & 0x1;
    p_splice_time[1] = (i_pts_time >> 24) & 0xff;
    p_splice_time[2] = (i_pts_time >> 16) & 0xff;
    p_splice_time[3] = (i_pts_time >> 8) & 0xff;
    p_splice_time[4] = i_pts_time & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
andl $-0x2, %ecx
movb %cl, (%rax)
movq -0x10(%rbp), %rdx
shrq $0x20, %rdx
andq $0x1, %rdx
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
orq %rdx, %rcx
movb %cl, (%rax)
movq -0x10(%rbp), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_get_break_duration
static inline uint8_t *scte35_insert_get_break_duration(const uint8_t *p_scte35)
{
    if (!scte35_insert_has_program_splice(p_scte35))
        return scte35_insert_get_component(p_scte35,
                scte35_insert_get_component_count(p_scte35) + 1);

    if (scte35_insert_has_splice_immediate(p_scte35))
        return scte35_get_command(p_scte35) + SCTE35_INSERT_HEADER_SIZE +
               SCTE35_INSERT_HEADER2_SIZE;

    uint8_t *p_splice_time = scte35_insert_get_splice_time(p_scte35);
    return p_splice_time + scte35_splice_time_size(p_splice_time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16c20
testb $0x1, %al
jne 0x16952
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16d70
movq -0x20(%rbp), %rdi
movzbl %al, %eax
addl $0x1, %eax
movzbl %al, %esi
callq 0x16c60
movq %rax, -0x8(%rbp)
jmp 0x169a9
movq -0x10(%rbp), %rdi
callq 0x16da0
testb $0x1, %al
jne 0x16961
jmp 0x16978
movq -0x10(%rbp), %rdi
callq 0x16bd0
addq $0x5, %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x169a9
movq -0x10(%rbp), %rdi
callq 0x167f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16de0
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/scte/35.h
// Function: scte35_insert_get_component
static inline uint8_t *scte35_insert_get_component(const uint8_t *p_scte35,
                                                   uint8_t n)
{
    uint16_t i_section_size = psi_get_length(p_scte35) + PSI_HEADER_SIZE
                               - PSI_CRC_SIZE;
    bool b_splice_immediate = scte35_insert_has_splice_immediate(p_scte35);
    uint8_t *p_scte35_n = scte35_get_command(p_scte35) +
        SCTE35_INSERT_HEADER_SIZE + SCTE35_INSERT_HEADER2_SIZE +
        SCTE35_INSERT_COMPONENT_COUNT_SIZE;
    if (p_scte35_n - p_scte35 > i_section_size)
        return NULL;

    while (n) {
        if (p_scte35_n + SCTE35_INSERT_COMPONENT_HEADER_SIZE - p_scte35 >
                i_section_size)
            return NULL;
        p_scte35_n += SCTE35_INSERT_COMPONENT_HEADER_SIZE +
            (b_splice_immediate ?
             scte35_splice_time_size(
                 scte35_insert_component_get_splice_time(p_scte35_n)) :
             0);
        n--;
    }
    if (p_scte35_n - p_scte35 >= i_section_size) return NULL;
    return p_scte35_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5490
movzwl %ax, %eax
addl $0x3, %eax
subl $0x4, %eax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16da0
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16bd0
addq $0x5, %rax
addq $0x1, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x16cd0
movq $0x0, -0x8(%rbp)
jmp 0x16d64
jmp 0x16cd2
cmpb $0x0, -0x11(%rbp)
je 0x16d3e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x16cfa
movq $0x0, -0x8(%rbp)
jmp 0x16d64
testb $0x1, -0x15(%rbp)
je 0x16d19
movq -0x20(%rbp), %rdi
callq 0x16e10
movq %rax, %rdi
callq 0x16de0
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x16d20
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x16d20
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
jmp 0x16cd2
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jl 0x16d5c
movq $0x0, -0x8(%rbp)
jmp 0x16d64
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/cat.c
// Function: main
int main(int argc, char **argv) {
	if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
		printf("cat [FILE]...\n- to read stdin\n");
	} else if (strcmp(argv[1],"-") == 0) {
		char ch;
		while ((ch = getc(stdin)) != EOF) {
			putc(ch, stdout);
		}
	} else {
		int i;
		for (i = 1; i < argc; i++) {
			FILE *fp;
			char ch;
			fp = fopen(argv[i], "r");
			if (fp) {
				while ((ch = getc(fp)) != EOF) {
					putc(ch, stdout);
				}
				fclose(fp);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe4f(%rip), %rsi       # 0x2004
callq 0x1050
cmpl $0x0, %eax
je 0x11d8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe39(%rip), %rsi       # 0x2007
callq 0x1050
cmpl $0x0, %eax
jne 0x11eb
leaq 0xe2f(%rip), %rdi       # 0x200e
movb $0x0, %al
callq 0x1040
jmp 0x12ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe33(%rip), %rsi       # 0x202d
callq 0x1050
cmpl $0x0, %eax
jne 0x1237
jmp 0x1206
movq 0x2dd3(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1080
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1235
movsbl -0x11(%rbp), %edi
movq 0x2dad(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1060
jmp 0x1206
jmp 0x12ac
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12aa
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xdd6(%rip), %rsi       # 0x202f
callq 0x1070
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x129d
jmp 0x126b
movq -0x20(%rbp), %rdi
callq 0x1080
movb %al, -0x21(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1294
movsbl -0x21(%rbp), %edi
movq 0x2d4e(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1060
jmp 0x126b
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x129f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x123e
jmp 0x12ac
jmp 0x12ae
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tylerneylon[P]APIsWithLua/ch1/loadmodule.c
// Function: main
int main() {
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);
  luaL_dofile(L, "mymodule.lua");
  lua_setglobal(L, "mymodule");
  lua_settop(L, 0);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x21310
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x216d0
movq -0x10(%rbp), %rdi
leaq 0x2da08(%rip), %rsi     # 0x33004
xorl %eax, %eax
movl %eax, %edx
callq 0x207e0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x5634
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %esi
movq %r9, %r8
callq 0x7d70
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movq -0x10(%rbp), %rdi
leaq 0x2d9cf(%rip), %rsi     # 0x33011
callq 0x7340
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5920
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/waveinfo/waveinfo.c
// Function: main
int
main(int argc,char **argv)
    {
    int argIndex = 1;

    char *in;
    WAVE *w;

    argIndex = processOptions(argc,argv);

    if (argc-argIndex == 1)
        {
        in = argv[argIndex];
        }
    else
        {
        printf("usage: waveheader <wave file>\n");
        exit(-1);
        }

    w = readWave(in);

    displayWave(w);

    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12d0
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x14(%rbp), %eax
cmpl $0x1, %eax
jne 0x1299
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x12b1
leaq 0x1d74(%rip), %rdi      # 0x3014
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1130
movq -0x20(%rbp), %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1ce0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/include/tt/common/heap.h
// Function: tt_heap_insert
static inline int tt_heap_insert(struct tt_heap *heap, const void *v)
{
	if (heap->__heaplen == heap->cap)
		return TT_EOVERFLOW;
	heap->num._set(&heap->num, heap_ptr(heap, heap->__heaplen), v);
	heap->__heaplen++;
	heap->_adjust(heap, heap->__heaplen - 1);
	return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl 0x30(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x15c9
movl $0xfffffffd, 0x14(%rsp) # imm = 0xFFFFFFFD
jmp 0x162c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rsi
movq 0x8(%rsp), %rcx
movl 0x30(%rcx), %ecx
movq 0x8(%rsp), %rdx
imull (%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rsi
movq (%rsp), %rdx
callq *%rax
movq 0x8(%rsp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rcx
movl 0x30(%rcx), %esi
subl $0x1, %esi
callq *%rax
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/tudurom[P]disputils/pfd.c
// Function: window_exists
bool
window_exists(xcb_window_t win) {
	xcb_get_geometry_reply_t *r =
		xcb_get_geometry_reply(conn,
				xcb_get_geometry(conn, win), NULL);

	return r != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x2dbe(%rip), %rax      # 0x4130
movq %rax, -0x20(%rbp)
movq 0x2db3(%rip), %rdi      # 0x4130
movl -0x4(%rbp), %esi
callq 0x1110
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: stk_reg_destroy
void stk_reg_destroy(reghash_t *h)
{
	khint_t k;
	if (h == 0) return;
	for (k = 0; k < kh_end(h); ++k) {
		if (kh_exist(h, k)) {
			free(kh_val(h, k).a);
			free((char*)kh_key(h, k));
		}
	}
	kh_destroy(reg, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d25
jmp 0x2da1
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x2d98
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x2d8b
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x2040
jmp 0x2d8d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d2c
movq -0x8(%rbp), %rdi
callq 0x2db0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: stk_listhet
int stk_listhet(int argc, char *argv[])
{
	gzFile fp;
	kseq_t *seq;
	int i, l;
	if (argc == 1) {
		fprintf(stderr, "Usage: seqtk listhet <in.fa>\n");
		return 1;
	}
	fp = (strcmp(argv[1], "-") == 0)? gzdopen(fileno(stdin), "r") : gzopen(argv[1], "r");
	if (fp == 0) {
		fprintf(stderr, "[E::%s] failed to open the input file/stream.\n", __func__);
		return 1;
	}
	seq = kseq_init(fp);
	while ((l = kseq_read(seq)) >= 0) {
		for (i = 0; i < l; ++i) {
			int b = seq->seq.s[i];
			if (bitcnt_table[seq_nt16_table[b]] == 2)
				printf("%s\t%d\t%c\n", seq->name.s, i+1, b);
		}
	}
	kseq_destroy(seq);
	gzclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x6259
movq 0xadbc(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x7870(%rip), %rsi      # 0xdab6
movb $0x0, %al
callq 0x2190
movl $0x1, -0x4(%rbp)
jmp 0x638c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x822e(%rip), %rsi      # 0xe496
callq 0x2170
cmpl $0x0, %eax
jne 0x6295
movq 0xad4f(%rip), %rax      # 0x10fc8
movq (%rax), %rdi
callq 0x21b0
movl %eax, %edi
leaq 0x6ff6(%rip), %rsi      # 0xd280
callq 0x20b0
movq %rax, -0x38(%rbp)
jmp 0x62ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x6fdc(%rip), %rsi      # 0xd280
callq 0x2220
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x62e7
movq 0xad35(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq 0x71ac(%rip), %rsi      # 0xd479
leaq 0x7800(%rip), %rdx      # 0xdad4
movb $0x0, %al
callq 0x2190
movl $0x1, -0x4(%rbp)
jmp 0x638c
movq -0x18(%rbp), %rdi
callq 0x38f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3930
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x6373
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x6371
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0xae2e(%rip), %rax      # 0x11160
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0xb051(%rip), %rax      # 0x11390
cmpl $0x2, (%rax,%rcx,4)
jne 0x6364
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl -0x2c(%rbp), %ecx
leaq 0x7783(%rip), %rdi      # 0xdae0
movb $0x0, %al
callq 0x20f0
jmp 0x6366
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x630c
jmp 0x62f4
movq -0x20(%rbp), %rdi
callq 0x3d40
movq -0x18(%rbp), %rdi
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: print_seq
static void print_seq(FILE *fpout, const kseq_t *ks, int begin, int end)
{
	int i;
	if (begin >= end) return; // FIXME: why may this happen? Understand it!
	fprintf(fpout, "%c%s:%d-%d", ks->qual.l? '@' : '>', ks->name.s, begin+1, end);
	for (i = begin; i < end && i < ks->seq.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->seq.s[i], fpout);
	}
	fputc('\n', fpout);
	if (ks->qual.l == 0) return;
	fputs("+\n", fpout);
	for (i = begin; i < end && i < ks->qual.l; ++i) {
		if ((i - begin)%60 == 0) fputc('\n', fpout);
		fputc(ks->qual.s[i], fpout);
	}
	fputc('\n', fpout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x6873
jmp 0x69d4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movl $0x3e, %edx
movl $0x40, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl -0x14(%rbp), %r8d
addl $0x1, %r8d
movl -0x18(%rbp), %r9d
leaq 0x7d9d(%rip), %rsi      # 0xe648
movb $0x0, %al
callq 0x2190
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x1d(%rbp)
jge 0x68d7
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x68e0
jmp 0x6925
movl -0x1c(%rbp), %eax
subl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x6901
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2140
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x2140
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x68b8
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2140
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x6943
jmp 0x69d4
movq -0x8(%rbp), %rsi
leaq 0x7d05(%rip), %rdi      # 0xe653
callq 0x2110
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x1e(%rbp)
jge 0x6978
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x48(%rcx), %rax
setb %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x6981
jmp 0x69c6
movl -0x1c(%rbp), %eax
subl -0x14(%rbp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x69a2
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2140
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x2140
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6959
movq -0x8(%rbp), %rsi
movl $0xa, %edi
callq 0x2140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: cpy_kseq
static void cpy_kseq(kseq_t *dst, const kseq_t *src)
{
	cpy_kstr(&dst->name, &src->name);
	cpy_kstr(&dst->seq,  &src->seq);
	cpy_kstr(&dst->qual, &src->qual);
	cpy_kstr(&dst->comment, &src->comment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbbb0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0xbbb0
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0xbbb0
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0xbbb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: stk_printseq_renamed
static inline void stk_printseq_renamed(const kseq_t *s, int line_len, const char *prefix, int64_t n)
{
	putchar(s->qual.l? '@' : '>');
	if (n >= 0) {
		if (prefix) fputs(prefix, stdout);
		printf("%lld", (long long)n);
	} else fputs(s->name.s, stdout);
	if (s->comment.l) {
	//	putchar(' '); fputs(s->comment.s, stdout);
	}
	stk_printstr(&s->seq, line_len);
	if (s->qual.l) {
		putchar('+');
		stk_printstr(&s->qual, line_len);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
movl $0x3e, %edi
movl $0x40, %eax
cmpq $0x0, %rcx
cmovnel %eax, %edi
callq 0x2050
cmpq $0x0, -0x20(%rbp)
jl 0x96ca
cmpq $0x0, -0x18(%rbp)
je 0x96b6
movq -0x18(%rbp), %rdi
movq 0x7912(%rip), %rax      # 0x10fc0
movq (%rax), %rsi
callq 0x2110
movq -0x20(%rbp), %rsi
leaq 0x4f9a(%rip), %rdi      # 0xe65b
movb $0x0, %al
callq 0x20f0
jmp 0x96e1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x78e7(%rip), %rax      # 0x10fc0
movq (%rax), %rsi
callq 0x2110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x96ee
jmp 0x96ee
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %esi
callq 0xc0e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x9723
movl $0x2b, %edi
callq 0x2050
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movl -0xc(%rbp), %esi
callq 0xc0e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: cpy_kstr
static void cpy_kstr(kstring_t *dst, const kstring_t *src)
{
	if (src->l == 0) return;
	if (src->l + 1 > dst->m) {
		dst->m = src->l + 1;
		kroundup32(dst->m);
		dst->s = realloc(dst->s, dst->m);
	}
	dst->l = src->l;
	memcpy(dst->s, src->s, src->l + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbbcf
jmp 0xbce0
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xbcb2
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
addq $0x1, %rdx
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aokad[P]sequeeze/seqtk.c
// Function: stk_printstr
static void stk_printstr(const kstring_t *s, unsigned line_len)
{
	if (line_len != UINT_MAX && line_len != 0) {
		int i, rest = s->l;
		for (i = 0; i < s->l; i += line_len, rest -= line_len) {
			putchar('\n');
			if (rest > line_len) fwrite(s->s + i, 1, line_len, stdout);
			else fwrite(s->s + i, 1, rest, stdout);
		}
		putchar('\n');
	} else {
		putchar('\n');
		puts(s->s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0xc1ab
cmpl $0x0, -0xc(%rbp)
je 0xc1ab
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xc19f
movl $0xa, %edi
callq 0x2050
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0xc15d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %eax
movl %eax, %edx
movq 0x4e72(%rip), %rax      # 0x10fc0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2260
jmp 0xc184
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x10(%rbp), %rax
addq %rax, %rdi
movslq -0x14(%rbp), %rdx
movq 0x4e49(%rip), %rax      # 0x10fc0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2260
jmp 0xc186
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0xc114
movl $0xa, %edi
callq 0x2050
jmp 0xc1c2
movl $0xa, %edi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2080
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/5-Signal/pause.c
// Function: main
int main(void)
{
	signal(SIGINT, sig_handler);
	pause();
	printf("Ctrl+C received. Bye!\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2, %edi
leaq -0x4b(%rip), %rsi       # 0x1160
callq 0x1040
callq 0x1050
leaq 0xe59(%rip), %rdi       # 0x2015
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/maandree[P]libkeccak/digest.c
// Function: libkeccak_fast_update
int
libkeccak_fast_update(struct libkeccak_state *restrict state, const void *restrict msg, size_t msglen)
{
	size_t len;
	auto unsigned char *restrict new;

	if (__builtin_expect(state->mptr + msglen > state->mlen, 0)) {
		state->mlen += msglen;
		new = realloc(state->M, state->mlen * sizeof(char));
		if (!new) {
			state->mlen -= msglen;
			return -1;
		}
		state->M = new;
	}

	__builtin_memcpy(state->M + state->mptr, msg, msglen * sizeof(char));
	state->mptr += msglen;
	len = state->mptr;
	len -= state->mptr % (size_t)(state->r >> 3);
	state->mptr -= len;

	libkeccak_absorption_phase(state, state->M, len);
	__builtin_memmove(state->M, state->M + len, state->mptr * sizeof(char));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
addq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x110(%rcx), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x2912
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x110(%rax), %rcx
movq %rcx, 0x110(%rax)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rsi
shlq $0x0, %rsi
callq 0x10c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2903
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x110(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29ee
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x108(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
shlq $0x0, %rdx
callq 0x10a0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x108(%rax), %rcx
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0xc8(%rcx), %rcx
sarq $0x3, %rcx
xorl %edx, %edx
divq %rcx
movq -0x28(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x108(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x15a0
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdx
shlq $0x0, %rdx
callq 0x10d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)