LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/akumrao[P]videoAnalyzer/encoder/../core/bs.h
// Function: bs_write_te(bs_s*, int, int, char const*)
static inline void
bs_write_te(bs_t *s, int x, int val, const char str[]) {
    myPrintf( "bs_write_te %d %s\n", val,str);
    if (x == 1)
    {
        _bs_write(s, 1, ~val);
    }
    else if (x > 1)
    {
        _bs_write_ue(s, val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x1405e(%rip), %rdi     # 0x2db5b
movl %edx, %esi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x4a56
cmpl $0x1, %r15d
jne 0x19b64
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
jae 0x19c24
movb 0x18(%rbx), %cl
decb %cl
movl $0x1, %edx
shll %cl, %edx
movb (%rax), %cl
movl %edx, %esi
notb %sil
andb %cl, %sil
orb %dl, %cl
testb $0x1, %r14b
movzbl %cl, %ecx
movzbl %sil, %edx
cmovel %ecx, %edx
movb %dl, (%rax)
decl 0x18(%rbx)
jne 0x19c24
leaq 0x8(%rbx), %rax
addq $0x18, %rbx
incq (%rax)
movl $0x8, (%rbx)
jmp 0x19c24
jle 0x19c24
testl %r14d, %r14d
je 0x19c07
incl %r14d
movl %r14d, %ecx
shrl $0x10, %ecx
xorl %edx, %edx
cmpl $0x10000, %r14d         # imm = 0x10000
setae %dl
cmovbl %r14d, %ecx
shll $0x4, %edx
leal 0x8(%rdx), %eax
movl %ecx, %esi
shrl $0x8, %esi
cmpl $0x100, %ecx            # imm = 0x100
cmovbl %edx, %eax
cmovbl %ecx, %esi
leaq 0x120e6(%rip), %rcx     # 0x2bc90
addl (%rcx,%rsi,4), %eax
jle 0x19c24
addl %eax, %eax
movq 0x8(%rbx), %rdx
cmpq 0x10(%rbx), %rdx
jae 0x19c24
movb 0x18(%rbx), %cl
decb %cl
movl $0x1, %esi
shll %cl, %esi
leal -0x2(%rax), %ecx
movzbl %cl, %ecx
movb (%rdx), %dil
movl %esi, %r8d
notb %r8b
andb %dil, %r8b
orb %sil, %dil
btl %ecx, %r14d
movzbl %dil, %ecx
movzbl %r8b, %esi
cmovbl %ecx, %esi
movb %sil, (%rdx)
decl 0x18(%rbx)
jne 0x19bfe
incq 0x8(%rbx)
movl $0x8, 0x18(%rbx)
decl %eax
cmpl $0x1, %eax
ja 0x19bb1
jmp 0x19c24
movq 0x8(%rbx), %rax
cmpq 0x10(%rbx), %rax
jae 0x19c24
movb 0x18(%rbx), %cl
decb %cl
movl $0x1, %edx
shll %cl, %edx
orb %dl, (%rax)
jmp 0x19b45
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_skip(x264_t*, x264_macroblock_t*, int)
void x264_cabac_mb_skip(x264_t *h, x264_macroblock_t *mb, int b_skip) {LOG_CALL;
    x264_macroblock_t *mba = mb->context->mba;
    x264_macroblock_t *mbb = mb->context->mbb;
    int i_ctxIdxInc = 0;

    if (mba != NULL && !IS_SKIP(mba->i_type))
    {
        i_ctxIdxInc++;
    }
    if (mbb != NULL && !IS_SKIP(mbb->i_type))
    {
        i_ctxIdxInc++;
    }

    if (h->sh.i_type == SLICE_TYPE_P)
    {
        x264_cabac_encode_decision(&h->cabac, 11 + i_ctxIdxInc, b_skip ? 1 : 0);
    } else /* SLICE_TYPE_B */
    {
        x264_cabac_encode_decision(&h->cabac, 24 + i_ctxIdxInc, b_skip ? 1 : 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xc911(%rip), %rdi      # 0x271b4
leaq 0x12eba(%rip), %rsi     # 0x2d764
leaq 0x131da(%rip), %rdx     # 0x2da8b
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x4a56
movq 0x10(%r12), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
testq %rcx, %rcx
je 0x1a8e1
movl 0x18(%rcx), %ecx
cmpl $0x5, %ecx
setne %dl
cmpl $0x11, %ecx
setne %cl
andb %dl, %cl
movzbl %cl, %r15d
testq %rax, %rax
je 0x1a8f6
movl 0x18(%rax), %eax
cmpl $0x5, %eax
je 0x1a8f6
cmpl $0x11, %eax
je 0x1a8f6
incl %r15d
xorl %edx, %edx
testl %r14d, %r14d
setne %dl
leal 0x18(%r15), %eax
addl $0xb, %r15d
cmpl $0x0, 0x10db00(%rbx)
cmovnel %eax, %r15d
leaq 0x10db60(%rbx), %rdi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3efb
// File: /workspace/github_c_makefile_star2_O3/akumrao[P]videoAnalyzer/encoder/macroblock.c
// Function: x264_cabac_mb_mvd(x264_t*, int, int, int)
static void x264_cabac_mb_mvd(x264_t *h, int i_ctx, int i_ctx_inc, int mvd) {LOG_CALL;
    int i_abs = abs(mvd);
    int i_prefix = X264_MIN(i_abs, 9);
    int i;

    for (i = 0; i < i_prefix; i++)
    {
        x264_cabac_encode_decision(&h->cabac, i_ctx + i_ctx_inc, 1);
        if (i_ctx_inc < 3)
        {
            i_ctx_inc = 3;
        } else if (i_ctx_inc < 6)
        {
            i_ctx_inc++;
        }
    }
    if (i_prefix < 9)
    {
        x264_cabac_encode_decision(&h->cabac, i_ctx + i_ctx_inc, 0);
    }

    if (i_prefix >= 9)
    {
        int k = 3;
        int i_suffix = i_abs - 9;

        while (i_suffix >= (1 << k))
        {
            x264_cabac_encode_bypass(&h->cabac, 1);
            i_suffix -= 1 << k;
            k++;
        }
        x264_cabac_encode_bypass(&h->cabac, 0);
        while (k--)
        {
            x264_cabac_encode_bypass(&h->cabac, (i_suffix >> k)&0x01);
        }
    }

    /* sign */
    if (mvd > 0)
    {
        x264_cabac_encode_bypass(&h->cabac, 0);
    } else if (mvd < 0)
    {
        x264_cabac_encode_bypass(&h->cabac, 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0xb317(%rip), %rdi      # 0x271b4
leaq 0x118c0(%rip), %rsi     # 0x2d764
leaq 0x11e71(%rip), %rdx     # 0x2dd1c
xorl %eax, %eax
callq 0x4a56
movl %r14d, %eax
negl %eax
cmovsl %r14d, %eax
movq %rax, -0x40(%rbp)
movq %rbx, -0x38(%rbp)
movl %r14d, -0x2c(%rbp)
jae 0x1bf1a
leaq 0x10db60(%rbx), %r13
movl %r14d, %eax
negl %eax
cmovsl %r14d, %eax
cmpl $0x9, %eax
movl $0x9, %r14d
cmovbl %eax, %r14d
movl $0x3, %ebx
leal (%r12,%r15), %esi
movq %r13, %rdi
movl $0x1, %edx
callq 0x3efb
xorl %esi, %esi
cmpl $0x6, %r12d
setl %sil
addl %r12d, %esi
cmpl $0x3, %r12d
cmovll %ebx, %esi
movl %esi, %r12d
decl %r14d
jne 0x1beeb
jmp 0x1bf1d
movl %r12d, %esi
movq -0x40(%rbp), %rax
cmpl $0x8, %eax
ja 0x1bf3d
movq -0x38(%rbp), %rbx
leaq 0x10db60(%rbx), %rdi
addl %r15d, %esi
xorl %edx, %edx
callq 0x3efb
jmp 0x1bfb5
leal -0x9(%rax), %r13d
movl $0x3, %r14d
cmpl $0x11, %eax
movq -0x38(%rbp), %rbx
jb 0x1bf89
leaq 0x10db60(%rbx), %r15
movl $0x3, %r12d
movl $0x8, %eax
subl %eax, %r13d
movq %r15, %rdi
movl $0x1, %esi
callq 0x414e
movl $0x2, %eax
movl %r12d, %ecx
shll %cl, %eax
leal 0x1(%r12), %r14d
movl %r14d, %r12d
cmpl %eax, %r13d
jge 0x1bf62
leaq 0x10db60(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x414e
decl %r14d
xorl %esi, %esi
btl %r14d, %r13d
setb %sil
movq %r15, %rdi
callq 0x414e
addl $-0x1, %r14d
jb 0x1bf9d
xorl %esi, %esi
cmpl $0x0, -0x2c(%rbp)
jle 0x1bfda
addq $0x10db60, %rbx         # imm = 0x10DB60
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x414e
js 0x1bfeb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
jmp 0x1bfbd
// File: /workspace/github_c_makefile_star2_O3/akumrao[P]videoAnalyzer/encoder/ratecontrol.c
// Function: x264_ratecontrol_new(x264_param_t*)
x264_ratecontrol_t *x264_ratecontrol_new( x264_param_t *param )
{
    x264_ratecontrol_t *rc = (x264_ratecontrol_t *)x264_malloc( sizeof( x264_ratecontrol_t ) );

    rc->fps = param->f_fps > 0.1 ? param->f_fps : 25.0;
    rc->i_iframe = param->i_iframe;
    rc->i_bitrate = param->i_bitrate * 1000;

    rc->i_qp_last = 26;
    rc->i_qp      = param->i_qp_constant;

    rc->i_frames  = 0;
    rc->i_size    = 0;

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x28, %edi
callq 0x467e
movss 0x14(%rbx), %xmm0
cvtss2sd %xmm0, %xmm1
ucomisd 0xec60(%rip), %xmm1     # 0x2e340
ja 0x1f6ea
movss 0xec5e(%rip), %xmm0     # 0x2e348
movss %xmm0, (%rax)
movl 0x20(%rbx), %ecx
movl %ecx, 0x4(%rax)
imull $0x3e8, 0x38(%rbx), %ecx # imm = 0x3E8
movl %ecx, 0x8(%rax)
movl $0x1a, 0xc(%rax)
movl 0x34(%rbx), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JulStrat[P]bams/./sh_merge.h
// Function: merge
void *
merge(const void *arr_a, size_t num_el_a,
      const void *arr_b, size_t num_el_b,
      size_t el_size, int (*compare) (const void *, const void *))
{
    char *ac = (char *) arr_a;
    char *bc = (char *) arr_b;
    char *ah = ac + (num_el_a * el_size);
    char *bh = bc + (num_el_b * el_size);
    char *r = NULL;
    char *rc = NULL;

    ASSERT_MERGE_ARGS();

    r = (char *) malloc((num_el_a + num_el_b) * el_size);
    if (!r || !((num_el_a + num_el_b) * el_size)) {
        return NULL;
    }
    rc = r;

    while ((ac < ah) && (bc < bh)) {
        if ((*compare) (ac, bc) > 0) {
            memcpy(rc, bc, el_size);
            bc += el_size;
        } else {
            memcpy(rc, ac, el_size);
            ac += el_size;
        }
        rc += el_size;
    }

    if (ac < ah) {
        memcpy(rc, ac, ah - ac);
    } else if (bc < bh) {
        memcpy(rc, bc, bh - bc);
    }

    return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %r8, %r8
je 0x1441
movq %r9, %r13
testq %r9, %r9
je 0x144a
movq %r8, %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq (%rcx,%rsi), %r12
imulq %r8, %r12
movq %r12, %rdi
movq %rcx, 0x10(%rsp)
callq 0x1130
movq %rax, (%rsp)
testq %rax, %rax
sete %al
testq %r12, %r12
sete %cl
orb %al, %cl
je 0x138b
xorl %eax, %eax
jmp 0x1432
imulq %rbp, %r14
leaq (%r15,%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
imulq %rbp, %rcx
leaq (%rbx,%rcx), %r12
testq %r14, %r14
setg %al
testq %rcx, %rcx
setg %cl
movl %eax, %edx
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1406
movq (%rsp), %r14
movq %r15, %rdi
movq %rbx, %rsi
callq *%r13
movq %r14, %rdi
testl %eax, %eax
jle 0x13de
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x1110
addq %rbp, %rbx
jmp 0x13ec
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1110
addq %rbp, %r15
addq %rbp, %r14
cmpq %r12, %rbx
setb %cl
cmpq 0x8(%rsp), %r15
setb %al
jae 0x140a
cmpq %r12, %rbx
jb 0x13be
jmp 0x140a
movq (%rsp), %r14
orb %al, %cl
testb $0x1, %cl
je 0x142e
testb %al, %al
cmovneq %r15, %rbx
cmovneq 0x8(%rsp), %r12
subq %rbx, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1110
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c30(%rip), %rdi      # 0x3078
jmp 0x1451
leaq 0x1ca6(%rip), %rdi      # 0x30f7
leaq 0x1c2d(%rip), %rsi      # 0x3085
leaq 0x1c33(%rip), %rcx      # 0x3092
movl $0x62, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/JulStrat[P]bams/tests/test_merge.c
// Function: merge_suite
SUITE(merge_suite)
{
    int i;
    int c;

    for (i = 0; i < TEST_NUM; i++) {
        c = (rand() % ARR_SZ);
        if ((c < 0) || (c > ARR_SZ))
            continue;
        RUN_TEST1(do_merge_test, c);
    }

    RUN_TEST1(do_merge_test, 0);
    RUN_TEST1(do_merge_test, ARR_SZ);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x80, %ebp
leaq 0x1b78(%rip), %rbx      # 0x316b
callq 0x1190
movslq %eax, %r14
imulq $-0x7892bc03, %r14, %rax # imm = 0x876D43FD
shrq $0x20, %rax
addl %r14d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0xe, %eax
addl %ecx, %eax
imull $0x78fb, %eax, %eax     # imm = 0x78FB
subl %eax, %r14d
js 0x163a
movq %rbx, %rdi
callq 0x1688
cmpl $0x1, %eax
jne 0x163a
movl %r14d, %edi
callq 0x1861
movl %eax, %edi
callq 0x1ad2
decl %ebp
jne 0x15f3
leaq 0x1b26(%rip), %rdi      # 0x316b
callq 0x1688
cmpl $0x1, %eax
jne 0x165d
xorl %edi, %edi
callq 0x1861
movl %eax, %edi
callq 0x1ad2
leaq 0x1b07(%rip), %rdi      # 0x316b
callq 0x1688
cmpl $0x1, %eax
jne 0x1683
movl $0x78fb, %edi           # imm = 0x78FB
callq 0x1861
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ad2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JulStrat[P]bams/tests/test_merge.c
// Function: merge_into_suite
SUITE(merge_into_suite)
{
    int i;
    int c;

    for (i = 0; i < TEST_NUM; i++) {
        c = (rand() % ARR_SZ);
        if ((c < 0) || (c > ARR_SZ))
            continue;
        RUN_TEST1(do_merge_into_test, c);
    }

    RUN_TEST1(do_merge_into_test, 0);
    RUN_TEST1(do_merge_into_test, ARR_SZ);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0x80, %ebp
leaq 0x141d(%rip), %rbx      # 0x3179
callq 0x1190
movslq %eax, %r14
imulq $-0x7892bc03, %r14, %rax # imm = 0x876D43FD
shrq $0x20, %rax
addl %r14d, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0xe, %eax
addl %ecx, %eax
imull $0x78fb, %eax, %eax     # imm = 0x78FB
subl %eax, %r14d
js 0x1da3
movq %rbx, %rdi
callq 0x1688
cmpl $0x1, %eax
jne 0x1da3
movl %r14d, %edi
callq 0x1df1
movl %eax, %edi
callq 0x1ad2
decl %ebp
jne 0x1d5c
leaq 0x13cb(%rip), %rdi      # 0x3179
callq 0x1688
cmpl $0x1, %eax
jne 0x1dc6
xorl %edi, %edi
callq 0x1df1
movl %eax, %edi
callq 0x1ad2
leaq 0x13ac(%rip), %rdi      # 0x3179
callq 0x1688
cmpl $0x1, %eax
jne 0x1dec
movl $0x78fb, %edi           # imm = 0x78FB
callq 0x1df1
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ad2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/JulStrat[P]bams/tests/test_merge.c
// Function: main
int
main(int argc, char *argv[])
{
    GREATEST_MAIN_BEGIN();
#if defined(__STDC_VERSION__)
    printf("Compiler Standard version - %ld\n", __STDC_VERSION__);
#endif

    srand(time(NULL));

    RUN_SUITE(merge_suite);
    RUN_SUITE(merge_into_suite);

    GREATEST_MAIN_END();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0x22bb
cmpl $0x2, %ebp
jl 0x297b
movb 0x20c6b(%rip), %al      # 0x23511
movl $0x1, %edi
movb 0x20c5f(%rip), %cl      # 0x23510
leaq 0x758(%rip), %rdx       # 0x3010
leaq 0x7a1(%rip), %rsi       # 0x3060
movslq %edi, %r8
movq (%rbx,%r8,8), %r14
cmpb $0x2d, (%r14)
jne 0x2971
movzbl 0x1(%r14), %r15d
leal -0x65(%r15), %r8d
cmpl $0x13, %r8d
ja 0x2928
movslq (%rdx,%r8,4), %r8
addq %rdx, %r8
jmpq *%r8
leal 0x1(%rdi), %r8d
cmpl %ebp, %r8d
jge 0x2a28
leal -0x73(%r15), %r9d
cmpl $0x5, %r9d
ja 0x29de
movslq (%rsi,%r9,4), %r9
addq %rsi, %r9
jmpq *%r9
movslq %r8d, %rdi
movq (%rbx,%rdi,8), %rdi
movq %rdi, 0x20c7c(%rip)     # 0x23598
jmp 0x296e
incb %al
movb %al, 0x20beb(%rip)      # 0x23511
jmp 0x2971
cmpl $0x61, %r15d
jne 0x29de
orb $0x4, %cl
jmp 0x2948
orb $0x2, %cl
jmp 0x2948
movb $0x1, 0x20bd0(%rip)     # 0x23513
jmp 0x2971
orb $0x1, %cl
movb %cl, 0x20bc2(%rip)      # 0x23510
jmp 0x2971
movslq %r8d, %rdi
movq (%rbx,%rdi,8), %rdi
movq %rdi, 0x20c42(%rip)     # 0x235a0
jmp 0x296e
movslq %r8d, %rdi
movq (%rbx,%rdi,8), %rdi
movq %rdi, 0x20c3a(%rip)     # 0x235a8
movl %r8d, %edi
incl %edi
cmpl %ebp, %edi
jl 0x28bf
leaq 0x93a(%rip), %rdi       # 0x32bc
movl $0x313ee, %esi          # imm = 0x313EE
xorl %eax, %eax
callq 0x1090
xorl %edi, %edi
callq 0x1120
movl %eax, %edi
callq 0x10e0
leaq -0x13c0(%rip), %rdi     # 0x15e3
leaq 0x933(%rip), %rsi       # 0x32dd
callq 0x2316
leaq -0xc6a(%rip), %rdi      # 0x1d4c
leaq 0x92c(%rip), %rsi       # 0x32e9
callq 0x2316
callq 0x2514
xorl %eax, %eax
cmpl $0x0, 0x20b7c(%rip)     # 0x2354c
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa14(%rip), %rdi       # 0x33f9
movl $0x6, %edx
movq %r14, %rsi
callq 0x1050
testl %eax, %eax
je 0x2a3a
subl $0x2d, %r15d
jne 0x2a01
movzbl 0x2(%r14), %r15d
negl %r15d
testl %r15d, %r15d
je 0x297b
movq 0x25c4(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
leaq 0x9e2(%rip), %rsi       # 0x3400
movq %r14, %rdx
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rdi
callq 0x2a49
movl $0x1, %edi
callq 0x1170
movq (%rbx), %rdi
callq 0x2a49
xorl %edi, %edi
callq 0x1170
// File: /workspace/github_c_makefile_star2_O3/millimat[P]Soft-Heap/softheap.c
// Function: meld
softheap *meld(softheap *P, softheap *Q) {
  // Do not allow melding if the soft heaps don't seem to have the same error parameter.
  double max_eps = max(P->epsilon, Q->epsilon), min_eps = min(P->epsilon, Q->epsilon);
  double eps_off = 1 - min_eps/max_eps; 
  if(eps_off > 0.001) error(1,0, "Tried to combine soft heaps with different epsilons");

  // If both softheaps empty, just destroy one and return the other
  if(empty(P) && empty(Q)) {
    free(P);
    return Q;
  }

  softheap *result;
  if(P->rank >= Q->rank) { // meld Q into P
    merge_into(Q, P);
    repeated_combine(P, Q->rank, P->r);
    free(Q);
    result = P;
  } else { // meld P into Q
    merge_into(P, Q);
    repeated_combine(Q, P->rank, Q->r);
    free(P);
    result = Q;
  }

  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
movsd 0x10(%rsi), %xmm1
movapd %xmm1, %xmm2
cmplesd %xmm0, %xmm2
movapd %xmm2, %xmm3
andpd %xmm0, %xmm3
andnpd %xmm1, %xmm2
orpd %xmm3, %xmm2
movapd %xmm0, %xmm3
cmplesd %xmm1, %xmm3
andpd %xmm3, %xmm0
andnpd %xmm1, %xmm3
orpd %xmm0, %xmm3
divsd %xmm2, %xmm3
movsd 0x9e1(%rip), %xmm0      # 0x22e0
subsd %xmm3, %xmm0
ucomisd 0x9ed(%rip), %xmm0      # 0x22f8
jbe 0x1922
leaq 0xa29(%rip), %rdx       # 0x233d
movl $0x1, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x1930
cmpq $0x0, (%r14)
je 0x196d
movl 0x8(%rbx), %eax
cmpl 0x8(%r14), %eax
jge 0x1949
movq %r14, %rsi
callq 0x197e
movq %r14, %r15
movq %rbx, %r14
jmp 0x195a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x197e
movq %rbx, %r15
movq %r14, %rbx
movl 0x8(%r14), %esi
movl 0x18(%r15), %edx
movq %r15, %rdi
callq 0x19bc
movq %r15, %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/millimat[P]Soft-Heap/softheap.c
// Function: merge_into
static void merge_into(softheap *P, softheap *Q) {
  tree *currP = P->first, *currQ = Q->first;

  while(currP != NULL) {
    while(currQ->rank < currP->rank) currQ = currQ->next;
    // currQ is now the first tree in Q with rank >= currP. Insert currP before it.
    tree *next = currP->next;
    insert_tree(Q, currP, currQ);
    currP = next;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x19bb
movq (%rsi), %rax
movl 0x20(%rdi), %ecx
cmpl %ecx, 0x20(%rax)
jge 0x1994
movq 0x8(%rax), %rax
jmp 0x1989
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rdi)
movq (%rax), %rdx
leaq 0x8(%rdx), %r8
testq %rdx, %rdx
cmoveq %rsi, %r8
movq %rdi, (%r8)
movq %rdx, (%rdi)
movq %rdi, (%rax)
movq %rcx, %rdi
testq %rcx, %rcx
jne 0x1986
retq
// File: /workspace/github_c_makefile_star2_O3/millimat[P]Soft-Heap/softheap.c
// Function: repeated_combine
static void repeated_combine(softheap *Q, int smaller_rank, int r) {
  tree *curr = Q->first;

  while(curr->next != NULL) {
    bool two = (curr->rank == curr->next->rank);
    bool three = (two && curr->next->next != NULL && curr->rank == curr->next->next->rank);

    if(!two) { // only one tree of this rank
      if(curr->rank > smaller_rank) break; // no more combines to do and no carries
      else curr = curr->next;
    } else if(!three) { // exactly two trees of this rank
      // combine them to make a carry, then delete curr->next. 
      // carry may need to be merged with its next tree, so do not advance curr.
      curr->root = combine(curr->root, curr->next->root, r);
      curr->rank = curr->root->rank;
      tree *tofree = curr->next;
      remove_tree(Q, curr->next); // will change what curr->next points to
      free(tofree);
    } else { // exactly three trees of this rank
      // skip the first so that we can combine the second and third to form a carry
      curr = curr->next;
    }
  }

  if(curr->rank > Q->rank) Q->rank = curr->rank; // Q might have a new highest-rank tree
  update_suffix_min(curr); // this is final tree affected by merge, so update sufmin backwds from here
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, (%rsp)
movl %esi, 0x4(%rsp)
movq %rdi, %r14
movq (%rdi), %r12
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x1abb
leaq 0x8(%r12), %r13
movl 0x20(%r12), %ecx
cmpl 0x20(%rax), %ecx
jne 0x1aa1
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x1a07
cmpl 0x20(%rdx), %ecx
je 0x1aa7
movq 0x18(%r12), %rbp
movq 0x18(%rax), %rbx
movl $0x30, %edi
callq 0x10c0
movq %rax, %r15
movq %rbp, (%rax)
movq %rbx, 0x8(%rax)
movl 0x24(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x24(%r15)
movl $0x0, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movl $0x1, %eax
cmpl (%rsp), %ecx
jl 0x1a5c
movl 0x28(%rbp), %eax
leal (%rax,%rax,2), %ecx
leal (%rax,%rax,2), %eax
incl %eax
shrl $0x1f, %eax
addl %ecx, %eax
incl %eax
sarl %eax
movl %eax, 0x28(%r15)
movq %r15, %rdi
callq 0x1c8b
movq %r15, 0x18(%r12)
movl 0x24(%r15), %eax
movl %eax, 0x20(%r12)
movq (%r13), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x1a97
movq %rax, (%rcx)
callq 0x1030
movq %r12, %rax
jmp 0x1aa7
cmpl 0x4(%rsp), %ecx
jg 0x1abb
movq %rax, %r12
leaq 0x8(%rax), %r13
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x19e7
movl 0x20(%r12), %eax
cmpl 0x8(%r14), %eax
jle 0x1aca
movl %eax, 0x8(%r14)
movq 0x8(%r12), %rcx
movq %r12, %rax
testq %rcx, %rcx
je 0x1aee
movq 0x18(%r12), %rax
movl 0x20(%rax), %edx
movq 0x10(%rcx), %rax
movq 0x18(%rax), %rcx
cmpl 0x20(%rcx), %edx
cmovleq %r12, %rax
movq %rax, 0x10(%r12)
movq (%r12), %r12
testq %r12, %r12
jne 0x1aca
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/millimat[P]Soft-Heap/softheap.c
// Function: extract_min_with_ckey
int extract_min_with_ckey(softheap *P, int *ckey_into) {
  if(empty(P)) error(1,0, "Tried to extract an element from an empty soft heap");

  tree *T = P->first->sufmin; // tree with lowest root ckey
  node *x = T->root;
  int e = extract_elem(x);
  *ckey_into = x->ckey;

  if(x->nelems <= x->size / 2) { // x is deficient; rescue it if possible
    if(!leaf(x)) {
      sift(x);
      update_suffix_min(T);
    } else if(x->nelems == 0) { // x is a leaf and empty; it must be destroyed
      free(x);
      remove_tree(P, T);

      if(T->next == NULL) { // we removed the highest-ranked tree; reset heap rank and clean up
        if(T->prev == NULL) P->rank = -1; // Heap now empty. Rank -1 is sentinel for future melds
        else P->rank = T->prev->rank;
      }

      if(T->prev != NULL) update_suffix_min(T->prev);
      free(T);
    }
  }

  return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
jne 0x1b46
leaq 0x83c(%rip), %rdx       # 0x2371
movl $0x1, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10e0
movq (%r14), %rax
movq 0x10(%rax), %rbx
movq 0x18(%rbx), %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x1c32
movl (%rdi), %ebp
movq 0x8(%rdi), %rax
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x1b71
cmpq $0x0, 0x8(%rax)
jne 0x1b75
movq %rax, 0x18(%r15)
callq 0x1030
decl 0x2c(%r15)
movl 0x20(%r15), %eax
movl %eax, (%r12)
movl 0x28(%r15), %ecx
movl 0x2c(%r15), %eax
movl %ecx, %edx
shrl $0x1f, %edx
addl %ecx, %edx
sarl %edx
cmpl %edx, %eax
jg 0x1bde
cmpq $0x0, (%r15)
jne 0x1ba8
cmpq $0x0, 0x8(%r15)
je 0x1be9
movq %r15, %rdi
callq 0x1c8b
movq 0x8(%rbx), %rcx
movq %rbx, %rax
testq %rcx, %rcx
je 0x1bd2
movq 0x18(%rbx), %rax
movl 0x20(%rax), %edx
movq 0x10(%rcx), %rax
movq 0x18(%rax), %rcx
cmpl 0x20(%rcx), %edx
cmovleq %rbx, %rax
movq %rax, 0x10(%rbx)
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x1bb0
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x1bde
movq %r15, %rdi
callq 0x1030
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0x1c17
movq %rax, (%rcx)
movq (%rbx), %rax
jmp 0x1c5b
movq (%rbx), %rax
testq %rax, %rax
je 0x1c28
movl 0x20(%rax), %ecx
movl %ecx, 0x8(%r14)
jmp 0x1c60
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
jmp 0x1c51
leaq 0x76c(%rip), %rdi       # 0x23a5
leaq 0x776(%rip), %rsi       # 0x23b6
leaq 0x77a(%rip), %rcx       # 0x23c1
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x1080
movq %rbx, %rdi
callq 0x1030
jmp 0x1bde
testq %rax, %rax
je 0x1c51
movq 0x8(%rax), %rdx
movq %rax, %rcx
testq %rdx, %rdx
je 0x1c82
movq 0x18(%rax), %rcx
movl 0x20(%rcx), %esi
movq 0x10(%rdx), %rcx
movq 0x18(%rcx), %rdx
cmpl 0x20(%rdx), %esi
cmovleq %rax, %rcx
movq %rcx, 0x10(%rax)
movq (%rax), %rax
jmp 0x1c5b
// File: /workspace/github_c_makefile_star2_O3/millimat[P]Soft-Heap/softheap.c
// Function: sift
static void sift(node *x) {
  while(x->nelems < x->size && !leaf(x)) {
    // For simplicity, switch left and right children so that left child exists & has smaller ckey
    if(x->left == NULL || (x->right != NULL && x->left->ckey > x->right->ckey)) swapLR(x);
    moveList(x->left, x); // concat left's list to x's to replenish x
    x->ckey = x->left->ckey;

    // if left was a leaf, it can't be repaired, so destroy it
    if(leaf(x->left)) {
      free(x->left);
      x->left = NULL;
    } else {
      sift(x->left);
    }
  } // Repeat as necessary until x is repaired or until x is a leaf and no more repairs are possible
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x2c(%rdi), %eax
cmpl 0x28(%rdi), %eax
jge 0x1d3d
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
testq %rdx, %rdx
je 0x1cc0
testq %rcx, %rcx
je 0x1cbb
movl 0x20(%rdx), %esi
cmpl 0x20(%rcx), %esi
jg 0x1cc5
movq %rdx, %rcx
jmp 0x1ccc
testq %rcx, %rcx
je 0x1d3d
movq %rcx, (%rbx)
movq %rdx, 0x8(%rbx)
movq 0x10(%rcx), %rdx
testq %rdx, %rdx
je 0x1d45
leaq 0x10(%rcx), %rsi
movq 0x18(%rbx), %rdi
leaq 0x8(%rdi), %r8
testq %rdi, %rdi
cmoveq %r14, %r8
movq %rdx, (%r8)
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rbx)
addl 0x2c(%rcx), %eax
movl %eax, 0x2c(%rbx)
movl $0x0, 0x2c(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq (%rbx), %rdi
movl 0x20(%rdi), %eax
movl %eax, 0x20(%rbx)
cmpq $0x0, (%rdi)
jne 0x1d1c
cmpq $0x0, 0x8(%rdi)
je 0x1d2f
callq 0x1c8b
movl 0x2c(%rbx), %eax
cmpl 0x28(%rbx), %eax
jl 0x1ca2
jmp 0x1d3d
callq 0x1030
movq $0x0, (%rbx)
jmp 0x1d21
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x68e(%rip), %rdi       # 0x23da
leaq 0x663(%rip), %rsi       # 0x23b6
leaq 0x693(%rip), %rcx       # 0x23ed
movl $0xf8, %edx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/./common.h
// Function: stress_wait_until_signalized
void
stress_wait_until_signalized()
{
	struct sigaction action;
	memset(&action, 0, sizeof(struct sigaction));
	action.sa_handler = stress_handle_sigint;
	sigaction(SIGINT, &action, NULL);

	printf("[%d] Waiting for SIGINT\n", getpid());
	sleep(36000);
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
leaq 0x10(%rsp), %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10f0
leaq -0x33(%rip), %rax       # 0x1a62
movq %rax, -0x8(%rbx)
leaq 0x8(%rsp), %rsi
movl $0x2, %edi
xorl %edx, %edx
callq 0x1080
callq 0x10b0
leaq 0x63e(%rip), %rdi       # 0x20f4
movl %eax, %esi
xorl %eax, %eax
callq 0x10e0
movl $0x8ca0, %edi           # imm = 0x8CA0
callq 0x11c0
addq $0xa0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/./common.h
// Function: stress_write_n
ssize_t
stress_write_n(int fd, const void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nwritten;
	const char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nwritten = write(fd, ptr, nleft);
		if (nwritten < 0) {
			if (errno == EINTR) {
				nwritten = 0;
				break;
			}

			return nwritten;
		}

		nleft -= nwritten;
		ptr += nwritten;
	}

	return n - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1b07
movq %rsi, %r15
movl %edi, %ebp
movq %rbx, %r14
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x10a0
movq %rax, %r12
testq %rax, %rax
js 0x1b1c
addq %r12, %r15
subq %r12, %r14
jne 0x1aea
xorl %r14d, %r14d
subq %r14, %rbx
movq %rbx, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1040
cmpl $0x4, (%rax)
je 0x1b0a
jmp 0x1b10
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/./common.h
// Function: stress_read_n
ssize_t
stress_read_n(int fd, void* vptr, size_t n)
{
	size_t nleft;
	ssize_t nread;
	char* ptr;

	ptr = vptr;
	nleft = n;

	while (nleft > 0) {
		nread = read(fd, ptr, nleft);
		if (nread < 0) {
			if (errno == EINTR) {
				nread = 0;
				break;
			}

			return nread;
		}

		nleft -= nread;
		ptr += nread;
	}

	return n - nleft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1b5d
movq %rsi, %r15
movl %edi, %ebp
movq %rbx, %r14
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1110
movq %rax, %r12
testq %rax, %rax
js 0x1b72
addq %r12, %r15
subq %r12, %r14
jne 0x1b40
xorl %r14d, %r14d
subq %r14, %rbx
movq %rbx, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1040
cmpl $0x4, (%rax)
je 0x1b60
jmp 0x1b66
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/locks-fcntl.c
// Function: create_file
void
create_file(const char* base, const int i)
{
	FILE* fp;
	char* filename;
	struct flock lock = { 0 };

	lock.l_type = F_WRLCK;

	_STRESS_MUST(asprintf(&filename, "%s/file%d", base, i) > 0,
	             "Couldn't create name for file %d",
	             i);
	_STRESS_MUST(
	  (fp = fopen(filename, "a")), "Couldn't create file %s", filename);

	_STRESS_MUST_P(fcntl(fileno(fp), F_SETLKW, &lock) != -1,
	               "fcntl",
	               "Couldn't acquire lock on %s",
	               filename);

	fprintf(fp, "dummy");
	free(filename);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movw $0x1, 0x10(%rsp)
leaq 0x56a(%rip), %rsi       # 0x210d
leaq 0x8(%rsp), %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1150
testl %eax, %eax
jle 0x1c17
movq 0x8(%rsp), %rdi
leaq 0x589(%rip), %rsi       # 0x214a
callq 0x1160
testq %rax, %rax
je 0x1c1e
movq %rax, %rbx
movq %rax, %rdi
callq 0x1140
leaq 0x10(%rsp), %rdx
movl %eax, %edi
movl $0x7, %esi
xorl %eax, %eax
callq 0x1090
cmpl $-0x1, %eax
je 0x1c28
leaq 0x5a2(%rip), %rdi       # 0x2197
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11b0
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbx
retq
movl %ebx, %edi
callq 0x141c
leaq 0x8(%rsp), %rdi
callq 0x15d3
leaq 0x8(%rsp), %rdi
callq 0x14d2
// File: /workspace/github_c_makefile_star2_O3/cirocosta[P]stress/src/locks-fcntl.c
// Function: create_files
void
create_files(int n)
{
	struct stat st = { 0 };
	int i = 0;

	printf("creating directory for files at '%s'\n", files_directory);
	_STRESS_MUST(stat(files_directory, &st) == -1,
	             "Directory %s already exists. Please delete it and rerun.",
	             files_directory);
	_STRESS_MUST(mkdir(files_directory, 0700) != -1,
	             "Couldn't create %s directory",
	             files_directory);

	printf("%d files will be created\n", n);
	for (; i++ < n;) {
		create_file(files_directory, i);
	}

	printf("\nDone.\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl %edi, %ebx
movq %rsp, %r14
movl $0x90, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x10f0
leaq 0x544(%rip), %rdi       # 0x219d
leaq 0x3c0(%rip), %r15       # 0x2020
movq %r15, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r15, %rdi
movq %r14, %rsi
callq 0x1130
cmpl $-0x1, %eax
jne 0x1ce9
leaq 0x39f(%rip), %rdi       # 0x2020
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1060
cmpl $-0x1, %eax
je 0x1cee
leaq 0x582(%rip), %rdi       # 0x2219
movl %ebx, %esi
xorl %eax, %eax
callq 0x10e0
testl %ebx, %ebx
jle 0x1cd1
negl %ebx
movl $0x1, %r15d
leaq 0x36d(%rip), %r14       # 0x2020
movq %r14, %rdi
movl %r15d, %esi
callq 0x1b7e
leal (%rbx,%r15), %eax
incl %eax
movl %r15d, %ecx
incl %ecx
movl %ecx, %r15d
cmpl $0x1, %eax
jne 0x1cb3
leaq 0x55b(%rip), %rdi       # 0x2233
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1070
callq 0x168c
callq 0x1745
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: usage()
static void usage() {
  fprintf(stderr, "Mkshape V.%s from <fisher@minster.york.ac.uk>\n", VERSION);
  fprintf(stderr,
          "Usage: mkshape -{cr} <alpha> <beta> <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -i <len> [-{lwx}] [-b nb]\n");
  fprintf(stderr, "       mkshape -h <len> [-{lw}] [-b nb]\n");
  exit(1);
}

// Assembly:
pushq %rbx
movq 0x344a(%rip), %rbx      # 0x4fe0
movq (%rbx), %rdi
leaq 0x1572(%rip), %rsi      # 0x3112
leaq 0x159a(%rip), %rdx      # 0x3141
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rcx
leaq 0x158d(%rip), %rdi      # 0x3145
movl $0x3b, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0x15b0(%rip), %rdi      # 0x3181
movl $0x29, %esi
movl $0x1, %edx
callq 0x1130
movq (%rbx), %rcx
leaq 0x15c1(%rip), %rdi      # 0x31ab
movl $0x28, %esi
movl $0x1, %edx
callq 0x1130
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: giveup(char const*, int)
static void giveup(const char* msg, int p1) {
  fprintf(stderr, "mkshape: ");
  fprintf(stderr, msg, p1);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x33cc(%rip), %r15      # 0x4fe0
movq (%r15), %rcx
leaq 0x15b6(%rip), %rdi      # 0x31d4
movl $0x9, %esi
movl $0x1, %edx
callq 0x1130
movq (%r15), %rdi
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x1120
movl $0x1, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/mkshape.C
// Function: fft(complex*, complex*, int)
static void fft(complex* data, complex* temp, int n) {
  if (n > 1) {
    int h = n / 2;
    for (int i = 0; i < h; i++) {
      int i2 = i * 2;
      temp[i] = data[i2];         /* even */
      temp[h + i] = data[i2 + 1]; /* odd	*/
    }
    fft(&temp[0], &data[0], h);
    fft(&temp[h], &data[h], h);
    int p = 0, t = SEQLEN / n;
    for (int i = 0; i < h; i++) {
      complex wkt = circle[p] * temp[h + i];
      data[i] = temp[i] + wkt;
      data[h + i] = temp[i] - wkt;
      p += t;
    }
  }
}

// Assembly:
cmpl $0x2, %edx
jl 0x1d78
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r15d
shrl %r15d
movq %r15, %r13
shlq $0x4, %r13
leaq (%rsi,%r13), %r12
xorl %eax, %eax
movups (%r14,%rax,2), %xmm0
movups %xmm0, (%rbx,%rax)
movupd 0x10(%r14,%rax,2), %xmm0
movupd %xmm0, (%r12,%rax)
addq $0x10, %rax
cmpq %rax, %r13
jne 0x1c85
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x1c53
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %r15d, %edx
callq 0x1c53
xorl %r12d, %r12d
movl $0x800, %eax            # imm = 0x800
xorl %edx, %edx
divl %ebp
movq %rax, 0x8(%rsp)
leaq (%r14,%r13), %rbp
addq $0x8, %rbp
movq %r13, 0x10(%rsp)
leaq (%rbx,%r13), %r15
addq $0x8, %r15
xorl %r13d, %r13d
movq %r13, %rax
shlq $0x4, %rax
leaq 0x33c8(%rip), %rcx      # 0x50c0
movsd (%rax,%rcx), %xmm0
movsd 0x8(%rax,%rcx), %xmm1
movsd -0x8(%r15,%r12), %xmm2
movsd (%r15,%r12), %xmm3
callq 0x1ff1
movsd (%rbx,%r12), %xmm2
addsd %xmm0, %xmm2
movsd 0x8(%rbx,%r12), %xmm3
addsd %xmm1, %xmm3
movsd %xmm2, (%r14,%r12)
movsd %xmm3, 0x8(%r14,%r12)
movsd (%rbx,%r12), %xmm2
movsd 0x8(%rbx,%r12), %xmm3
subsd %xmm0, %xmm2
subsd %xmm1, %xmm3
movsd %xmm2, -0x8(%rbp,%r12)
movsd %xmm3, (%rbp,%r12)
addq 0x8(%rsp), %r13
addq $0x10, %r12
cmpq %r12, 0x10(%rsp)
jne 0x1cea
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ulisses[P]ftp-client-server/servidorc2.c
// Function: main
int main(int args, char **argv) {
        Flag *tp = NULL;
        Flag *te = NULL;

        if((tp = contem(argv,"-tp"))==NULL) {
                errorMsg();
                exit(2);
        }

        if((te = contem(argv,"-te"))==NULL) {
                errorMsg();
                exit(3);
        }

        if(tp->bool && te->bool) {
                servidor(atoi(argv[te->pos+1]),atoi(argv[tp->pos+1]));
        }
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x853(%rip), %rsi       # 0x3188
movq %rbx, %rdi
callq 0x28c1
testq %rax, %rax
je 0x2971
movq %rax, %r14
leaq 0x840(%rip), %rsi       # 0x318c
movq %rbx, %rdi
callq 0x28c1
testq %rax, %rax
je 0x2980
cmpl $0x0, (%r14)
je 0x2964
cmpl $0x0, (%rax)
jne 0x298f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x28b0
movl $0x2, %edi
callq 0x11b0
callq 0x28b0
movl $0x3, %edi
callq 0x11b0
movslq 0x4(%rax), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1180
movl %eax, %r15d
movslq 0x4(%r14), %rax
movq 0x8(%rbx,%rax,8), %rdi
callq 0x1180
movl %r15d, %edi
movl %eax, %esi
callq 0x255e
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/cyvm.c
// Function: show_token_err
void show_token_err(struct cy_token *t, const char *fmt, ...)
{
	va_list args;

	fprintf(stderr, "Error @%d.%d: ", t->ln, t->tn);

	va_start(args, fmt);
	vfprintf(stderr, fmt, args);
	va_end(args);

	fprintf(stderr, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %r14
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x329f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x8d52(%rip), %r15      # 0xbff8
movq (%r15), %rax
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
leaq 0x4d6a(%rip), %rsi      # 0x8020
movq %rax, %rdi
xorl %eax, %eax
callq 0x3120
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x31d0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x30d0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/cyvm.c
// Function: main
int main(int argc, char **argv, char **env)
{
	struct cy_file *cf;
	struct cy_token mt;
	struct cy_value rv = {};

	init_resolver();

	if (argc < 2)
		goto usage;

	if (!strcmp(argv[1], "-c")) {
		show_commands();
		return 0;
	}

	if (!strcmp(argv[1], "-r")) {
		if (argc < 3)
			goto usage;

		init_args(argc - 2, argv + 2);
		init_envs(env);

		cf = cy_open(argv[2], &mt, false);
		if (!cf)
			return -1;

		return cy_call_cblock(&mt, cf, &rv) >= 0 ? 0 : 1;
	}

	if (!strcmp(argv[1], "-t")) {
		if (argc < 3)
			goto usage;

		cf = cy_open(argv[2], &mt, true);
		if (!cf)
			return -1;

		return 0;
	}

usage:
	fprintf(stderr, "Use -c, -r <filename> or -t <filename>\n");
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movl %edi, %r14d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
callq 0x3eb6
cmpl $0x2, %r14d
jl 0x3d64
movq 0x8(%rbx), %rax
cmpb $0x2d, (%rax)
jne 0x3d64
cmpb $0x63, 0x1(%rax)
jne 0x3c68
cmpb $0x0, 0x2(%rax)
je 0x3cb5
cmpb $0x72, 0x1(%rax)
jne 0x3c74
cmpb $0x0, 0x2(%rax)
je 0x3cc1
cmpb $0x74, 0x1(%rax)
jne 0x3d64
cmpl $0x2, %r14d
je 0x3d64
cmpb $0x0, 0x2(%rax)
jne 0x3d64
movq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %rsi
movl $0x1, %edx
callq 0x3f28
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
sbbl %eax, %eax
jmp 0x3d75
callq 0x3eef
xorl %eax, %eax
jmp 0x3d75
cmpl $0x2, %r14d
je 0x3d64
addl $-0x2, %r14d
movq 0x845a(%rip), %r13      # 0xc130
xorl %r15d, %r15d
leaq 0x8450(%rip), %r12      # 0xc130
movl $0x20, %edi
callq 0x3180
movl $0x2, 0x10(%rax)
movq 0x10(%rbx,%r15,8), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x842f(%rip)      # 0xc130
movq %r12, 0x8(%rax)
movq %r13, (%rax)
movq %rax, 0x8(%r13)
incq %r15
movq %rax, %r13
cmpq %r15, %r14
jne 0x3ce0
leaq 0x941a(%rip), %rax      # 0xd138
movq 0x8(%rax), %rdx
leaq 0x434a(%rip), %rdi      # 0x8073
leaq 0x8410(%rip), %rsi      # 0xc140
movl $0x1, %ecx
callq 0x5a48
movq 0x10(%rbx), %rdi
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x3f28
testq %rax, %rax
je 0x3d70
leaq 0x18(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x6450
shrl $0x1f, %eax
jmp 0x3d75
callq 0x3303
movl $0x1, %eax
jmp 0x3d75
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/resolver.c
// Function: cy_resolve
int cy_resolve(struct cy_token *t)
{
	if (try_resolve_command(t))
		return 1;

	if (try_resolve_sym(t))
		return 1;

	if (t->val[0] == '#') {
		t->typ = &comment;
		return 1;
	}

	show_token_err(t, "Can't resolve token value %s", t->val);
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movb (%r14), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x3db0
xorl %ecx, %ecx
movsbl %dl, %edx
shll %cl, %edx
addl %edx, %eax
movb 0x1(%r14,%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x3d9a
andl $0x1f, %eax
leaq 0x9259(%rip), %rcx      # 0xd010
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0x3dd5
movq (%r15), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0x3dfd
movq 0x20(%r15), %r15
jmp 0x3dbb
movq %rbx, %rdi
callq 0x48f0
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x3e22
movq (%rbx), %rdx
cmpb $0x23, (%rdx)
jne 0x3e0c
leaq 0x8359(%rip), %rcx      # 0xc150
movq %rcx, 0x8(%rbx)
jmp 0x3e22
addq $0x8, %r15
movq %r15, 0x8(%rbx)
movl $0x1, %eax
jmp 0x3e22
leaq 0x4265(%rip), %rsi      # 0x8078
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/resolver.c
// Function: init_resolver
void init_resolver(void)
{
	init_declare();
	init_show();
	init_aryth();
	init_list();
	init_map();
	init_string();
	init_cblocks();
	init_cond();
	init_misc();
	init_iter();
	init_stream();
}

// Assembly:
pushq %rax
callq 0x4b35
callq 0x5080
callq 0x4318
callq 0x54fa
callq 0x5be4
callq 0x5db4
callq 0x653e
callq 0x685d
callq 0x75b8
callq 0x7eb8
popq %rax
jmp 0x7a84
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/tokenizer.c
// Function: cy_open
struct cy_file *cy_open(const char *filename, struct cy_token *mt, bool verbose)
{
	int ret;
	struct cy_file *cf;
	static struct cy_type root_cblock = {};

	cf = cy_read(filename);
	if (!cf)
		return NULL;

	cf->verbose = verbose;
	cf->main = NULL;
	mt->typ = &root_cblock;
	ret = read_cblocks(mt, cf);
	if (ret < 0) {
		fprintf(stderr, "Can't parse file");
		return NULL;
	}

	return cf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x38, %edi
callq 0x3180
movq %rax, %rbx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x31a0
testl %eax, %eax
js 0x403a
movl %eax, %r15d
movl $0x400, %edi            # imm = 0x400
callq 0x3180
movq %rax, %r12
movq %rax, (%rbx)
movl $0x400, %edx            # imm = 0x400
movl %r15d, %edi
movq %rax, %rsi
callq 0x30e0
testl %eax, %eax
js 0x3fc8
movl %ebp, 0x4(%rsp)
xorl %r13d, %r13d
testl %eax, %eax
je 0x3fe9
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%rax,%r13), %rbp
leaq (%rax,%r13), %rsi
addq $0x400, %rsi            # imm = 0x400
movq %r12, %rdi
callq 0x3190
movq %rax, %r12
movq %rax, (%rbx)
leaq (%rax,%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
movl %r15d, %edi
callq 0x30e0
movq %rbp, %r13
testl %eax, %eax
jns 0x3f8a
movq %r12, %rdi
callq 0x3030
movq %rbx, %rdi
callq 0x3030
movl %r15d, %edi
callq 0x30c0
leaq 0x40d8(%rip), %rdi      # 0x80bf
jmp 0x4049
movl %r15d, %edi
callq 0x30c0
movq %r12, 0x8(%rbx)
addq %r12, %r13
movq %r13, 0x10(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x18(%rbx)
movl 0x4(%rsp), %eax
movb %al, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
leaq 0x90f0(%rip), %rax      # 0xd110
movq %rax, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4062
testl %eax, %eax
jns 0x4050
callq 0x331f
jmp 0x404e
movq %rbx, %rdi
callq 0x3030
leaq 0x4066(%rip), %rdi      # 0x80af
callq 0x31c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/tokenizer.c
// Function: cy_next
int cy_next(struct cy_file *cf, struct cy_token *t)
{
	struct list_head *n;

	if (cf->nxt == NULL)
		return 0;

	*t = cf->nxt->t;
	if (t->typ->eval != NULL)
		t->v.t = CY_V_NOVALUE;

	n = cf->nxt->l.next;
	if (n == &cf->main->h)
		cf->nxt = NULL;
	else
		cf->nxt = list_entry(n, struct cy_ctoken, l);

	return 1;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x4312
movups 0x10(%rax), %xmm0
movups 0x20(%rax), %xmm1
movups %xmm0, (%rsi)
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movq 0x8(%rsi), %rax
cmpq $0x0, 0x8(%rax)
je 0x42f6
movl $0x0, 0x18(%rsi)
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rax
xorl %ecx, %ecx
cmpq 0x28(%rdi), %rax
cmovneq %rax, %rcx
movq %rcx, 0x30(%rdi)
movl $0x1, %eax
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/xemul[P]cylang/aryth.c
// Function: eval_add
static int eval_add(struct cy_token *t, struct cy_file *f)
{
	struct cy_token a, b;

	if (eval_2arg_math(&a, &b, f) <= 0)
		return -1;

	if (a.v.t == CY_V_LIST)
		return cy_list_splice(&a.v, &b.v, &t->v);

	if (a.v.t == CY_V_NUMBER) {
		t->v.t = CY_V_NUMBER;
		t->v.v_i = a.v.v_i + b.v.v_i;
		return 1;
	}

	if (a.v.t == CY_V_STRING) {
		t->v.t = CY_V_STRING;
		t->v.v_str = xstrcat(a.v.v_str, b.v.v_str);
		return 1;
	}

	show_token_err(t, "Bad op for add");
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x481e
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jle 0x441b
movl 0x20(%rsp), %eax
cmpl $0x1, %eax
je 0x43ee
cmpl $0x2, %eax
je 0x438c
cmpl $0x3, %eax
jne 0x440a
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
addq $0x18, %rbx
movq %rbx, %rdx
callq 0x530c
movl %eax, %ebp
jmp 0x441b
movl $0x2, 0x18(%rbx)
movq 0x28(%rsp), %r15
movq 0x50(%rsp), %r14
movq %r15, %rdi
callq 0x3090
movq %rax, %r12
movq %r14, %rdi
callq 0x3090
movq %rax, %r13
addl %r12d, %eax
incl %eax
movslq %eax, %rdi
callq 0x3180
movq %rax, %rbp
movslq %r12d, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3150
addq %rbp, %r12
incl %r13d
movslq %r13d, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x3150
movq %rbp, 0x20(%rbx)
jmp 0x4403
movl $0x1, 0x18(%rbx)
movq 0x50(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rbx)
movl $0x1, %ebp
jmp 0x441b
leaq 0x3d16(%rip), %rsi      # 0x8127
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3240
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq