LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/smoke.c
// Function: test_combinatorics
void test_combinatorics() {
    test_case cases[] = {
            {"fac(0)", 1},
            {"fac(0.2)", 1},
            {"fac(1)", 1},
            {"fac(2)", 2},
            {"fac(3)", 6},
            {"fac(4.8)", 24},
            {"fac(10)", 3628800},

            {"ncr(0,0)", 1},
            {"ncr(10,1)", 10},
            {"ncr(10,0)", 1},
            {"ncr(10,10)", 1},
            {"ncr(16,7)", 11440},
            {"ncr(16,9)", 11440},
            {"ncr(100,95)", 75287520},

            {"npr(0,0)", 1},
            {"npr(10,1)", 10},
            {"npr(10,0)", 1},
            {"npr(10,10)", 3628800},
            {"npr(20,5)", 1860480},
            {"npr(100,4)", 94109400},
    };


    int i;
    for (i = 0; i < sizeof(cases) / sizeof(test_case); ++i) {
        const char *expr = cases[i].expr;
        const double answer = cases[i].answer;

        int err;
        const double ev = te_interp(expr, &err);
        lok(!err);
        lfequal(ev, answer);

        if (err) {
            printf("FAILED: %s (%d)\n", expr, err);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x8, %r14d
leaq 0x5d93(%rip), %r12      # 0xb970
leaq 0x4(%rsp), %rbx
leaq 0x27d2(%rip), %r15      # 0x83bb
leaq 0x27bd(%rip), %r13      # 0x83ad
movq -0x8(%r14,%r12), %rbp
movsd (%r14,%r12), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6e05
movl 0x64ea(%rip), %eax      # 0xc0fc
incl %eax
movl %eax, 0x64e2(%rip)      # 0xc0fc
cmpl $0x0, 0x4(%rsp)
je 0x5c4b
incl 0x64d9(%rip)            # 0xc100
movq %r13, %rdi
movq %r15, %rsi
movl $0x2ab, %edx            # imm = 0x2AB
xorl %eax, %eax
movsd %xmm0, 0x8(%rsp)
callq 0x3090
movsd 0x8(%rsp), %xmm0
movl 0x64b1(%rip), %eax      # 0xc0fc
incl %eax
movl %eax, 0x64a9(%rip)      # 0xc0fc
movapd %xmm0, %xmm3
movsd 0x10(%rsp), %xmm1
subsd %xmm1, %xmm3
movapd %xmm3, %xmm2
andpd 0x23a3(%rip), %xmm2     # 0x8010
ucomisd 0x23cb(%rip), %xmm2     # 0x8040
ja 0x5c7d
ucomisd %xmm3, %xmm3
jnp 0x5c99
incl 0x647d(%rip)            # 0xc100
leaq 0x2739(%rip), %rdi      # 0x83c3
movq %r15, %rsi
movl $0x2ac, %edx            # imm = 0x2AC
movb $0x2, %al
callq 0x3090
movl 0x4(%rsp), %edx
testl %edx, %edx
je 0x5cb2
leaq 0x272d(%rip), %rdi      # 0x83d5
movq %rbp, %rsi
xorl %eax, %eax
callq 0x3090
addq $0x10, %r14
cmpq $0x148, %r14            # imm = 0x148
jne 0x5bf0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_free_parameters
void te_free_parameters(te_expr *n) {
    if (!n) return;
    switch (TYPE_MASK(n->type)) {
        case TE_FUNCTION7: case TE_CLOSURE7: te_free(n->parameters[6]);     /* Falls through. */
        case TE_FUNCTION6: case TE_CLOSURE6: te_free(n->parameters[5]);     /* Falls through. */
        case TE_FUNCTION5: case TE_CLOSURE5: te_free(n->parameters[4]);     /* Falls through. */
        case TE_FUNCTION4: case TE_CLOSURE4: te_free(n->parameters[3]);     /* Falls through. */
        case TE_FUNCTION3: case TE_CLOSURE3: te_free(n->parameters[2]);     /* Falls through. */
        case TE_FUNCTION2: case TE_CLOSURE2: te_free(n->parameters[1]);     /* Falls through. */
        case TE_FUNCTION1: case TE_CLOSURE1: te_free(n->parameters[0]);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6327
movq %rdi, %rbx
movl (%rdi), %eax
andl $0x1f, %eax
addl $-0x9, %eax
cmpl $0xe, %eax
ja 0x6327
leaq 0x26bc(%rip), %rcx      # 0x8924
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x628a
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x62a3
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x62bc
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x62d5
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x62ee
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x6307
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x6327
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_compile
te_expr *te_compile(const char *expression, const te_variable *variables, int var_count, int *error) {
    state s;
    s.start = s.next = expression;
    s.lookup = variables;
    s.lookup_len = var_count;

    next_token(&s);
    te_expr *root = list(&s);
    if (root == NULL) {
        if (error) *error = -1;
        return NULL;
    }

    if (s.type != TOK_END) {
        te_free(root);
        if (error) {
            *error = (s.next - s.start);
            if (*error == 0) *error = 1;
        }
        return 0;
    } else {
        optimize(root);
        if (error) *error = 0;
        return root;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsp, %r14
movq %rdi, 0x8(%r14)
movq %rdi, (%r14)
movq %rsi, 0x28(%r14)
movl %edx, 0x30(%r14)
movq %r14, %rdi
callq 0x6347
movq %r14, %rdi
callq 0x6cd3
testq %rax, %rax
je 0x6c8d
movq %rax, %r14
cmpl $0x1a, 0x10(%rsp)
jne 0x6c9c
movq %r14, %rdi
callq 0x6d7a
xorl %eax, %eax
jmp 0x6c95
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
testq %rbx, %rbx
jne 0x6cc1
jmp 0x6cc3
movq %r14, %rdi
callq 0x6240
movq %r14, %rdi
callq 0x3030
testq %rbx, %rbx
je 0x6cce
movl 0x8(%rsp), %eax
subl (%rsp), %eax
cmpl $0x1, %eax
adcl $0x0, %eax
xorl %r14d, %r14d
movl %eax, (%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x6cc3
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: list
static te_expr *list(state *s) {
    /* <list>      =    <expr> {"," <expr>} */
    te_expr *ret = expr(s);
    CHECK_NULL(ret);

    while (s->type == TOK_SEP) {
        next_token(s);
        te_expr *e = expr(s);
        CHECK_NULL(e, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, e);
        CHECK_NULL(ret, te_free(e), te_free(prev));

        ret->function = comma;
    }

    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x716f
testq %rax, %rax
je 0x6d6c
movq %rax, %rbx
cmpl $0x1b, 0x10(%r14)
jne 0x6d47
leaq 0x5bb(%rip), %r12       # 0x72b8
movq %r14, %rdi
callq 0x6347
movq %r14, %rdi
callq 0x716f
testq %rax, %rax
je 0x6d5c
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x30d0
testq %rax, %rax
je 0x6d4c
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x2a, (%rax)
movq %r12, 0x8(%rax)
cmpl $0x1b, 0x10(%r14)
movq %rax, %rbx
je 0x6cfd
jmp 0x6d6e
movq %rbx, %rax
jmp 0x6d6e
movq %r15, %rdi
callq 0x6240
movq %r15, %rdi
callq 0x3030
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: optimize
static void optimize(te_expr *n) {
    /* Evaluates as much as possible. */
    if (n->type == TE_CONSTANT) return;
    if (n->type == TE_VARIABLE) return;

    /* Only optimize out functions flagged as pure. */
    if (IS_PURE(n->type)) {
        const int arity = ARITY(n->type);
        int known = 1;
        int i;
        for (i = 0; i < arity; ++i) {
            optimize(n->parameters[i]);
            if (((te_expr*)(n->parameters[i]))->type != TE_CONSTANT) {
                known = 0;
            }
        }
        if (known) {
            const double value = te_eval(n);
            te_free_parameters(n);
            n->type = TE_CONSTANT;
            n->value = value;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %r14d
testb $0x20, %r14b
je 0x6df8
movq %rdi, %rbx
testb $0x18, %r14b
sete %al
andq $0x7, %r14
sete %cl
orb %al, %cl
jne 0x6dd1
movl $0x1, %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx,%r12,8), %rdi
callq 0x6d7a
movq 0x10(%rbx,%r12,8), %rax
cmpl $0x1, (%rax)
cmovnel %r15d, %ebp
incq %r12
cmpq %r14, %r12
jb 0x6daf
testl %ebp, %ebp
je 0x6df8
movq %rbx, %rdi
callq 0x664d
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6240
movl $0x1, (%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: te_interp
double te_interp(const char *expression, int *error) {
    te_expr *n = te_compile(expression, 0, 0, error);

    double ret;
    if (n) {
        ret = te_eval(n);
        te_free(n);
    } else {
        ret = NAN;
    }
    return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
xorl %esi, %esi
xorl %edx, %edx
callq 0x6c46
testq %rax, %rax
je 0x6e44
movq %rax, %rbx
movq %rax, %rdi
callq 0x664d
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
movsd 0x8(%rsp), %xmm0
jmp 0x6e4c
movsd 0x1c54(%rip), %xmm0     # 0x8aa0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: pn
static void pn (const te_expr *n, int depth) {
    int i, arity;
    printf("%*s", depth, "");

    switch(TYPE_MASK(n->type)) {
    case TE_CONSTANT: printf("%f\n", n->value); break;
    case TE_VARIABLE: printf("bound %p\n", n->bound); break;

    case TE_FUNCTION0: case TE_FUNCTION1: case TE_FUNCTION2: case TE_FUNCTION3:
    case TE_FUNCTION4: case TE_FUNCTION5: case TE_FUNCTION6: case TE_FUNCTION7:
    case TE_CLOSURE0: case TE_CLOSURE1: case TE_CLOSURE2: case TE_CLOSURE3:
    case TE_CLOSURE4: case TE_CLOSURE5: case TE_CLOSURE6: case TE_CLOSURE7:
         arity = ARITY(n->type);
         printf("f%d", arity);
         for(i = 0; i < arity; i++) {
             printf(" %p", n->parameters[i]);
         }
         printf("\n");
         for(i = 0; i < arity; i++) {
             pn(n->parameters[i], depth + 1);
         }
         break;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1cec(%rip), %rdi      # 0x8b59
leaq 0x1546(%rip), %rdx      # 0x83ba
xorl %eax, %eax
callq 0x3090
movl (%rbx), %r14d
movl %r14d, %eax
andl $0x1f, %eax
leal -0x8(%rax), %ecx
cmpl $0x10, %ecx
jae 0x6f29
movl %r14d, %eax
andl $0x18, %eax
andl $0x7, %r14d
testl %eax, %eax
cmovel %eax, %r14d
leaq 0x1cc4(%rip), %rdi      # 0x8b6b
movl %r14d, %esi
xorl %eax, %eax
callq 0x3090
testl %r14d, %r14d
je 0x6f11
movl %r14d, %r12d
leaq 0x1caf(%rip), %r15      # 0x8b6f
xorl %r13d, %r13d
movq 0x10(%rbx,%r13,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3090
incq %r13
cmpq %r13, %r12
jne 0x6ec3
movl $0xa, %edi
callq 0x3040
testl %r14d, %r14d
je 0x6f02
incl %ebp
xorl %r14d, %r14d
movq 0x10(%rbx,%r14,8), %rdi
movl %ebp, %esi
callq 0x6e56
incq %r14
cmpq %r14, %r12
jne 0x6eee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3040
testl %eax, %eax
je 0x6f53
cmpl $0x1, %eax
jne 0x6f02
movsd 0x8(%rbx), %xmm0
leaq 0x1c1f(%rip), %rdi      # 0x8b5d
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
movq 0x8(%rbx), %rsi
leaq 0x1c03(%rip), %rdi      # 0x8b61
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: fac
static double fac(double a) {/* simplest version of fac */
    if (a < 0.0)
        return NAN;
    if (a > UINT_MAX)
        return INFINITY;
    unsigned int ua = (unsigned int)(a);
    unsigned long int result = 1, i;
    for (i = 1; i <= ua; i++) {
        if (i > ULONG_MAX / result)
            return INFINITY;
        result *= i;
    }
    return (double)result;
}

// Assembly:
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6f93
movsd 0x1b0e(%rip), %xmm0     # 0x8aa0
retq
movsd 0x1b15(%rip), %xmm0     # 0x8ab0
ucomisd 0x1b15(%rip), %xmm1     # 0x8ab8
ja 0x6ffa
cvttsd2si %xmm1, %rax
testl %eax, %eax
je 0x6ffb
movl %eax, %esi
negq %rsi
movl $0x1, %edi
movl $0x1, %ecx
movq %rcx, %rax
mulq %rdi
jo 0x6ffa
imulq %rdi, %rcx
leaq (%rsi,%rdi), %rax
incq %rax
incq %rdi
cmpq $0x1, %rax
jne 0x6fbd
movq %rcx, %xmm1
punpckldq 0x1aea(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1af2(%rip), %xmm1     # 0x8ae0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
retq
movsd 0x1045(%rip), %xmm0     # 0x8048
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: ncr
static double ncr(double n, double r) {
    if (n < 0.0 || r < 0.0 || n < r) return NAN;
    if (n > UINT_MAX || r > UINT_MAX) return INFINITY;
    unsigned long int un = (unsigned int)(n), ur = (unsigned int)(r), i;
    unsigned long int result = 1;
    if (ur > un / 2) ur = un - ur;
    for (i = 1; i <= ur; i++) {
        if (result > ULONG_MAX / (un - ur + i))
            return INFINITY;
        result *= un - ur + i;
        result /= i;
    }
    return result;
}

// Assembly:
movapd %xmm0, %xmm2
ucomisd %xmm0, %xmm1
movsd 0x1a8c(%rip), %xmm0     # 0x8aa0
ja 0x70c1
xorpd %xmm3, %xmm3
ucomisd %xmm2, %xmm3
ja 0x70c1
ucomisd %xmm1, %xmm3
ja 0x70c1
ucomisd 0x1a7e(%rip), %xmm2     # 0x8ab8
movsd 0x1a6e(%rip), %xmm0     # 0x8ab0
ja 0x70c1
ucomisd 0x1a6c(%rip), %xmm1     # 0x8ab8
ja 0x70c1
cvttsd2si %xmm2, %rax
movl %eax, %edi
cvttsd2si %xmm1, %rcx
movl %ecx, %edx
shrl %eax
movq %rdi, %r8
subq %rdx, %r8
cmpl %ecx, %eax
cmovaeq %rdx, %r8
testq %r8, %r8
je 0x70c2
subq %r8, %rdi
movl $0x1, %ecx
movl $0x1, %r9d
leaq (%rdi,%r9), %rsi
movq %rsi, %rax
mulq %rcx
jo 0x70c1
imulq %rsi, %rcx
movq %rcx, %rax
xorl %edx, %edx
divq %r9
incq %r9
movq %rax, %rcx
cmpq %r8, %r9
jbe 0x707d
movq %rcx, %xmm1
punpckldq 0x1a23(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1a2b(%rip), %xmm1     # 0x8ae0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
retq
movsd 0xf7e(%rip), %xmm0      # 0x8048
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: expr
static te_expr *expr(state *s) {
    /* <expr>      =    <term> {("+" | "-") <term>} */
    te_expr *ret = term(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *te = term(s);
        CHECK_NULL(te, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, te);
        CHECK_NULL(ret, te_free(te), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x72bc
testq %rax, %rax
je 0x7226
movq %rax, %rbx
cmpl $0x20, 0x10(%r14)
jne 0x7201
leaq -0xb63(%rip), %r12      # 0x6639
leaq -0xb65(%rip), %r13      # 0x663e
movq 0x18(%r14), %rbp
cmpq %r12, %rbp
setne %al
cmpq %r13, %rbp
setne %cl
testb %cl, %al
jne 0x7201
movq %r14, %rdi
callq 0x6347
movq %r14, %rdi
callq 0x72bc
testq %rax, %rax
je 0x7216
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x30d0
testq %rax, %rax
je 0x7206
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x2a, (%rax)
movq %rbp, 0x8(%rax)
cmpl $0x20, 0x10(%r14)
movq %rax, %rbx
je 0x71a3
jmp 0x7228
movq %rbx, %rax
jmp 0x7228
movq %r15, %rdi
callq 0x6240
movq %r15, %rdi
callq 0x3030
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: new_expr
static te_expr *new_expr(const int type, const te_expr *parameters[]) {
    const int arity = ARITY(type);
    const int psize = sizeof(void*) * arity;
    const int size = (sizeof(te_expr) - sizeof(void*)) + psize + (IS_CLOSURE(type) ? sizeof(void*) : 0);
    te_expr *ret = malloc(size);
    CHECK_NULL(ret);

    memset(ret, 0, size);
    if (arity && parameters) {
        memcpy(ret->parameters, parameters, psize);
    }
    ret->type = type;
    ret->bound = 0;
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
movl %edi, %eax
andl $0x18, %eax
movl %edi, %r15d
andl $0x7, %r15d
testl %eax, %eax
cmovel %eax, %r15d
movl %edi, %eax
shrl %eax
andl $0x8, %eax
leal (%rax,%r15,8), %esi
addl $0x10, %esi
movl $0x1, %edi
callq 0x30d0
movq %rax, %r12
testq %rax, %rax
je 0x72a9
testl %r15d, %r15d
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x729c
shll $0x3, %r15d
movq %r12, %rdi
addq $0x10, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x30f0
movl %ebx, (%r12)
movq $0x0, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: term
static te_expr *term(state *s) {
    /* <term>      =    <factor> {("*" | "/" | "%") <factor>} */
    te_expr *ret = factor(s);
    CHECK_NULL(ret);

    while (s->type == TOK_INFIX && (s->function == mul || s->function == divide || s->function == fmod)) {
        te_fun2 t = s->function;
        next_token(s);
        te_expr *f = factor(s);
        CHECK_NULL(f, te_free(ret));

        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, f);
        CHECK_NULL(ret, te_free(f), te_free(prev));

        ret->function = t;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x738a
testq %rax, %rax
je 0x7379
movq %rax, %rbx
cmpl $0x20, 0x10(%r14)
jne 0x7354
movq 0x4cf7(%rip), %r12      # 0xbfe0
leaq -0xcad(%rip), %r13      # 0x6643
movq 0x18(%r14), %rbp
cmpq %r12, %rbp
je 0x730a
cmpq %r13, %rbp
je 0x730a
leaq -0xcbd(%rip), %rax      # 0x6648
cmpq %rax, %rbp
jne 0x7354
movq %r14, %rdi
callq 0x6347
movq %r14, %rdi
callq 0x738a
testq %rax, %rax
je 0x7369
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x30d0
testq %rax, %rax
je 0x7359
movq %rbx, 0x10(%rax)
movq %r15, 0x18(%rax)
movl $0x2a, (%rax)
movq %rbp, 0x8(%rax)
cmpl $0x20, 0x10(%r14)
movq %rax, %rbx
je 0x72f0
jmp 0x737b
movq %rbx, %rax
jmp 0x737b
movq %r15, %rdi
callq 0x6240
movq %r15, %rdi
callq 0x3030
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/codeplea[P]tinyexpr/tinyexpr.c
// Function: factor
static te_expr *factor(state *s) {
    /* <factor>    =    <power> {"^" <power>} */
    te_expr *ret = power(s);
    CHECK_NULL(ret);

    int neg = 0;

    if (ret->type == (TE_FUNCTION1 | TE_FLAG_PURE) && ret->function == negate) {
        te_expr *se = ret->parameters[0];
        free(ret);
        ret = se;
        neg = 1;
    }

    te_expr *insertion = 0;

    while (s->type == TOK_INFIX && (s->function == pow)) {
        te_fun2 t = s->function;
        next_token(s);

        if (insertion) {
            /* Make exponentiation go right-to-left. */
            te_expr *p = power(s);
            CHECK_NULL(p, te_free(ret));

            te_expr *insert = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, insertion->parameters[1], p);
            CHECK_NULL(insert, te_free(p), te_free(ret));

            insert->function = t;
            insertion->parameters[1] = insert;
            insertion = insert;
        } else {
            te_expr *p = power(s);
            CHECK_NULL(p, te_free(ret));

            te_expr *prev = ret;
            ret = NEW_EXPR(TE_FUNCTION2 | TE_FLAG_PURE, ret, p);
            CHECK_NULL(ret, te_free(p), te_free(prev));

            ret->function = t;
            insertion = ret;
        }
    }

    if (neg) {
        te_expr *prev = ret;
        ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, ret);
        CHECK_NULL(ret, te_free(prev));

        ret->function = negate;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x74f3
testq %rax, %rax
je 0x74df
movq %rax, %rbx
movb $0x1, %cl
cmpl $0x29, (%rax)
jne 0x73ce
leaq 0x1f7(%rip), %rax       # 0x75ae
cmpq %rax, 0x8(%rbx)
jne 0x73ce
movq 0x10(%rbx), %r15
movq %rbx, %rdi
callq 0x3030
xorl %ecx, %ecx
movq %r15, %rbx
movl %ecx, 0x4(%rsp)
cmpl $0x20, 0x10(%r14)
jne 0x7485
xorl %r15d, %r15d
movq 0x4bf1(%rip), %r13      # 0xbfd8
cmpq %r13, 0x18(%r14)
jne 0x7485
movq %r14, %rdi
callq 0x6347
movq %r14, %rdi
callq 0x74f3
movq %rax, %r12
testq %r15, %r15
je 0x7449
testq %r12, %r12
je 0x74ca
movq 0x18(%r15), %rbp
movl $0x1, %edi
movl $0x20, %esi
callq 0x30d0
testq %rax, %rax
je 0x74ba
movq %rbp, 0x10(%rax)
movq %r12, 0x18(%rax)
movl $0x2a, (%rax)
movq %r13, 0x8(%rax)
movq %rax, 0x18(%r15)
movq %rax, %r15
jmp 0x747a
testq %r12, %r12
je 0x74ca
movl $0x1, %edi
movl $0x20, %esi
callq 0x30d0
testq %rax, %rax
je 0x74ba
movq %rax, %r15
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
movl $0x2a, (%rax)
movq %r13, 0x8(%rax)
movq %rax, %rbx
cmpl $0x20, 0x10(%r14)
je 0x73e7
cmpb $0x0, 0x4(%rsp)
jne 0x74e1
movl $0x1, %edi
movl $0x18, %esi
callq 0x30d0
testq %rax, %rax
je 0x74ca
movq %rbx, 0x10(%rax)
movl $0x29, (%rax)
leaq 0xfd(%rip), %rcx        # 0x75ae
movq %rcx, 0x8(%rax)
movq %rax, %rbx
jmp 0x74e1
movq %r12, %rdi
callq 0x6240
movq %r12, %rdi
callq 0x3030
testq %rbx, %rbx
je 0x74df
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
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/codeplea[P]tinyexpr/tinyexpr.c
// Function: power
static te_expr *power(state *s) {
    /* <power>     =    {("-" | "+")} <base> */
    int sign = 1;
    while (s->type == TOK_INFIX && (s->function == add || s->function == sub)) {
        if (s->function == sub) sign = -sign;
        next_token(s);
    }

    te_expr *ret;

    if (sign == 1) {
        ret = base(s);
    } else {
        te_expr *b = base(s);
        CHECK_NULL(b);

        ret = NEW_EXPR(TE_FUNCTION1 | TE_FLAG_PURE, b);
        CHECK_NULL(ret, te_free(b));

        ret->function = negate;
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x20, 0x10(%rdi)
jne 0x7547
movl $0x1, %ebp
leaq -0xed6(%rip), %r14      # 0x6639
leaq -0xed8(%rip), %r15      # 0x663e
movq 0x18(%rbx), %rax
cmpq %r14, %rax
setne %cl
cmpq %r15, %rax
setne %dl
testb %dl, %cl
jne 0x7542
movl %ebp, %ecx
negl %ecx
cmpq %r15, %rax
cmovel %ecx, %ebp
movq %rbx, %rdi
callq 0x6347
cmpl $0x20, 0x10(%rbx)
je 0x7516
cmpl $0x1, %ebp
jne 0x7556
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x75b6
movq %rbx, %rdi
callq 0x75b6
testq %rax, %rax
je 0x75a1
movq %rax, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x30d0
testq %rax, %rax
je 0x7591
movq %rbx, 0x10(%rax)
movl $0x29, (%rax)
leaq 0x23(%rip), %rcx        # 0x75ae
movq %rcx, 0x8(%rax)
jmp 0x75a3
movq %rbx, %rdi
callq 0x6240
movq %rbx, %rdi
callq 0x3030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: StrNCaseCmp
int StrNCaseCmp(const char *a, const char *b, unsigned int n)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i < n && i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
testl %edx, %edx
je 0x1319
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1040
movq %rax, %r15
movq %r14, %rdi
callq 0x1040
movq %rax, %r12
callq 0x1030
movq (%rax), %rcx
movl %ebp, %edx
movl %r12d, %esi
movl %r15d, %edi
xorl %r8d, %r8d
movsbq (%r14,%r8), %rax
movsbq (%rbx,%r8), %r9
movl (%rcx,%r9,4), %r9d
cmpl %r9d, (%rcx,%rax,4)
jl 0x131c
jg 0x1323
leaq 0x1(%r8), %r9
xorl %eax, %eax
cmpq %rdx, %r9
jae 0x1328
cmpq %rsi, %r8
jae 0x1328
cmpq %rdi, %r8
movq %r9, %r8
jb 0x12e9
jmp 0x1328
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1328
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: IsEquate
int IsEquate(void)
{
   char *e;
   char *p;
   e = strchr(Line,'=');
   if (e)
   {
      p = strchr(Line,';');
      if (p && p < e) return -1; // '=' after comment character
      p = strchr(Line,'*');
      if (p && p < e) return -1; // ignore * = syntax for PC setting
      return e-Line;
   }
   return -1; // no equate character found
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5174(%rip), %rdi      # 0x64b0
movl $0x3d, %esi
callq 0x1050
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x13a2
movq %rax, %r14
leaq 0x5156(%rip), %rdi      # 0x64b0
movl $0x3b, %esi
callq 0x1050
testq %rax, %rax
setne %cl
cmpq %r14, %rax
setb %al
testb %al, %cl
jne 0x13a2
leaq 0x5135(%rip), %rdi      # 0x64b0
movl $0x2a, %esi
callq 0x1050
testq %rax, %rax
setne %cl
cmpq %r14, %rax
setb %al
testb %al, %cl
jne 0x13a2
leaq 0x5114(%rip), %rax      # 0x64b0
subl %eax, %r14d
movl %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: IsInstruction
int IsInstruction(int *l)
{
   int i,j,ll;
   char c;

   if (Line[0] == '*') return -1;
   if (Line[0] == ';') return -1;
   ll = strlen(Line);
   if (ll < 4) return -1;
   *l = 0;
   for (j=0 ; j < ll-3 ; ++j)
   {
      if (Line[j] == ';') return -1;
      if (Line[j] == '"') return -1;
      if (Line[j] ==  39) return -1;
      if (j > 0)
      {
         c = Line[j-1];
         if (c != ' ') continue;
      }
      for (i = 0 ; i < (int) DIMOP ; ++i)
      {
         *l = strlen(Mat[i].Mne);
         if (strlen(Line+j) >= (size_t) *l)
         {
            if (!StrNCaseCmp(Line+j,Mat[i].Mne,*l)
            && Line[j+ *l] <= ' ') return j;
         }
      }
   }
   return -1; // No mnemonic
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x50f2(%rip), %eax      # 0x64b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2a, %eax
je 0x14b6
cmpl $0x3b, %eax
je 0x14b6
movq %rdi, %r14
leaq 0x50d1(%rip), %rdi      # 0x64b0
callq 0x1040
movq %rax, %rcx
cmpl $0x4, %ecx
jl 0x14b6
movl $0x0, (%r14)
addl $-0x3, %ecx
xorl %ebx, %ebx
movq %rcx, (%rsp)
leaq 0x50a9(%rip), %rax      # 0x64b0
movzbl (%rbx,%rax), %eax
cmpq $0x3b, %rax
ja 0x1425
movabsq $0x800008400000000, %rdx # imm = 0x800008400000000
btq %rax, %rdx
jb 0x14af
testq %rbx, %rbx
je 0x1438
leaq 0x507f(%rip), %rax      # 0x64b0
cmpb $0x20, -0x1(%rbx,%rax)
jne 0x149f
leaq 0x5071(%rip), %rax      # 0x64b0
leaq (%rax,%rbx), %r13
xorl %r15d, %r15d
leaq 0x2c53(%rip), %rax      # 0x40a0
leaq (%rax,%r15), %r12
movq %r12, %rdi
callq 0x1040
movq %rax, %rbp
movl %ebp, (%r14)
movq %r13, %rdi
callq 0x1040
movslq %ebp, %rcx
cmpq %rcx, %rax
jb 0x1492
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x12ac
testl %eax, %eax
jne 0x1492
addl %ebx, %ebp
movslq %ebp, %rax
leaq 0x5024(%rip), %rcx      # 0x64b0
cmpb $0x21, (%rax,%rcx)
jl 0x14b6
addq $0x28, %r15
cmpq $0x2300, %r15           # imm = 0x2300
jne 0x1446
incq %rbx
movq (%rsp), %rcx
cmpq %rcx, %rbx
jne 0x1400
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x14b6
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: IsPseudo
int IsPseudo(int *l)
{
   int i,j,ll;
   char c;

   if (Line[0] == '*') return -1;
   if (Line[0] == ';') return -1;
   ll = strlen(Line);
   if (ll < 4) return -1;
   *l = 0;
   for (j=0 ; j < ll-3 ; ++j)
   {
      if (Line[j] == ';') return -1;
      if (Line[j] == '"') return -1;
      if (Line[j] ==  39) return -1;
      if (j > 0)
      {
         c = Line[j-1];
         if (c != ' ') continue;
      }
      for (i = 0 ; i < PSEUDOS ; ++i)
      {
         *l = strlen(PseudoTab[i]);
         if (strlen(Line+j) >= (size_t) *l)
         {
            if (!StrNCaseCmp(Line+j,PseudoTab[i],*l)
            && Line[j+ *l] <= ' ') return j;
         }
      }
   }
   return -1; // No pseudo
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x4fd7(%rip), %eax      # 0x64b0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x2a, %eax
je 0x15d1
cmpl $0x3b, %eax
je 0x15d1
movq %rdi, %r14
leaq 0x4fb6(%rip), %rdi      # 0x64b0
callq 0x1040
movq %rax, %rcx
cmpl $0x4, %ecx
jl 0x15d1
movl $0x0, (%r14)
addl $-0x3, %ecx
xorl %ebx, %ebx
movq %rcx, (%rsp)
leaq 0x4f8e(%rip), %rax      # 0x64b0
movzbl (%rbx,%rax), %eax
cmpq $0x3b, %rax
ja 0x1540
movabsq $0x800008400000000, %rdx # imm = 0x800008400000000
btq %rax, %rdx
jb 0x15ca
testq %rbx, %rbx
je 0x1553
leaq 0x4f64(%rip), %rax      # 0x64b0
cmpb $0x20, -0x1(%rbx,%rax)
jne 0x15ba
leaq 0x4f56(%rip), %rax      # 0x64b0
leaq (%rax,%rbx), %r13
xorl %r15d, %r15d
leaq 0x4e38(%rip), %rax      # 0x63a0
movq (%r15,%rax), %r12
movq %r12, %rdi
callq 0x1040
movq %rax, %rbp
movl %ebp, (%r14)
movq %r13, %rdi
callq 0x1040
movslq %ebp, %rcx
cmpq %rcx, %rax
jb 0x15ad
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x12ac
testl %eax, %eax
jne 0x15ad
addl %ebx, %ebp
movslq %ebp, %rax
leaq 0x4f09(%rip), %rcx      # 0x64b0
cmpb $0x21, (%rax,%rcx)
jl 0x15d1
addq $0x8, %r15
cmpq $0xf8, %r15
jne 0x1561
incq %rbx
movq (%rsp), %rcx
cmpq %rcx, %rbx
jne 0x151b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x15d1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: Usage
void Usage(void)
{
   fprintf(stderr,"Usage: form9 [options] <in >out\n");
   fprintf(stderr,"Options:\n");
   fprintf(stderr,"   -l print mnemonics in lower case\n");
   fprintf(stderr,"   -u print mnemonics in upper case\n");
   fprintf(stderr,"   -o print pseudos   in lower case\n");
   fprintf(stderr,"   -p print pseudos   in upper case\n");
   fprintf(stderr,"   -m col   mnemonic/pseudo  column ( 8)\n");
   fprintf(stderr,"   -a col   argument/operand column (16)\n");
   fprintf(stderr,"   -e col   equate column           (16)\n");
   fprintf(stderr,"   -c col  code line comment column (32)\n");
   exit(1);
}

// Assembly:
pushq %rbx
movq 0x2a0e(%rip), %rbx      # 0x3ff8
movq (%rbx), %rcx
leaq 0xab7(%rip), %rdi       # 0x20ab
movl $0x20, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xabf(%rip), %rdi       # 0x20cc
movl $0x9, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xab0(%rip), %rdi       # 0x20d6
movl $0x24, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xabc(%rip), %rdi       # 0x20fb
movl $0x24, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xac8(%rip), %rdi       # 0x2120
movl $0x24, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xad4(%rip), %rdi       # 0x2145
movl $0x24, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xae0(%rip), %rdi       # 0x216a
movl $0x29, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xaf1(%rip), %rdi       # 0x2194
movl $0x29, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xb02(%rip), %rdi       # 0x21be
movl $0x29, %esi
movl $0x1, %edx
callq 0x10d0
movq (%rbx), %rcx
leaq 0xb13(%rip), %rdi       # 0x21e8
movl $0x29, %esi
movl $0x1, %edx
callq 0x10d0
movl $0x1, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: MoveLine
int MoveLine(int i, int col)
{
   int l;
   if (col >= 0)
   {
      l = strlen(Line)-i+1;
      if (col > i)
      {
         memmove(Line+col,Line+i,l);
         memset(Line+i,' ',col-i);
         return col; // moved to this column
      }
      while (col < i)
      {
         if (i > 0 && Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
      return i; // moved to this column
   }
   return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
testl %esi, %esi
js 0x1788
movl %esi, %ebx
leaq 0x4da3(%rip), %r15      # 0x64b0
movq %r15, %rdi
callq 0x1040
subl %r14d, %eax
incl %eax
movl %ebx, %ebp
subl %r14d, %ebp
jle 0x174c
movslq %r14d, %r14
movl %ebx, %edi
addq %r15, %rdi
addq %r15, %r14
movslq %eax, %rdx
movq %r14, %rsi
callq 0x10a0
movslq %ebp, %rdx
movq %r14, %rdi
movl $0x20, %esi
callq 0x1070
movl %ebx, %r14d
jmp 0x1788
jae 0x1788
movslq %eax, %r12
leal -0x1(%r14), %r13d
cmpb $0x20, (%r13,%r15)
jne 0x1788
cmpl $0x2, %r14d
jl 0x176e
leal -0x2(%r14), %eax
cmpb $0x20, (%rax,%r15)
jne 0x1788
leaq (%r15,%r13), %rdi
leaq 0x1(%rdi), %rsi
movq %r12, %rdx
callq 0x10a0
movl %r13d, %r14d
cmpl %ebx, %r13d
jg 0x1751
jmp 0x1747
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: MoveOperand
void MoveOperand(int i)
{
   int l;
   if (ocol >= 0)
   {
      while (Line[i] == ' ') ++i;
      l = strlen(Line)-i+1;
      if (ocol > i)
      {
         memmove(Line+ocol,Line+i,l);
         memset(Line+i,' ',ocol-i);
      }
      while (ocol < i)
      {
         if (Line[i-1] != ' ') break;
         if (i > 1 && Line[i-2] != ' ') break;
         --i;
         memmove(Line+i,Line+i+1,l);
      }
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x28e5(%rip), %r12      # 0x4094
testq %r12, %r12
js 0x1884
movl %edi, %r14d
movslq %edi, %r13
xorl %ebp, %ebp
leaq 0x4ce9(%rip), %rax      # 0x64b0
movq %r13, %rcx
addq %rbp, %rcx
incq %rbp
cmpb $0x20, (%rax,%rcx)
je 0x17c7
leal -0x1(%r14), %r15d
addq %rbp, %r15
leaq 0x4ccc(%rip), %rbx      # 0x64b0
movq %rbx, %rdi
callq 0x1040
movq %r14, %rcx
negl %r14d
addq %rax, %r14
subq %rbp, %r14
addq $0x2, %r14
cmpl %r15d, %r12d
jle 0x183f
leaq (%rbx,%r13), %rax
leaq (%rax,%rbp), %rsi
decq %rsi
movq %rsi, 0x10(%rsp)
leaq (%rbx,%r12), %rdi
movslq %r14d, %rdx
movq %rcx, 0x8(%rsp)
callq 0x10a0
movl %r12d, %eax
subl 0x8(%rsp), %eax
subl %ebp, %eax
incl %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rdi
movl $0x20, %esi
callq 0x1070
cmpl %r15d, %r12d
jge 0x1884
leaq -0x1(,%rbp), %rsi
addq %r13, %rsi
movslq %r14d, %r14
cmpb $0x20, -0x1(%rsi,%rbx)
jne 0x1884
cmpq $0x2, %rsi
jl 0x1866
cmpb $0x20, -0x2(%rsi,%rbx)
jne 0x1884
leaq -0x1(%rsi), %r15
leaq (%rsi,%rbx), %rdi
decq %rdi
addq %rbx, %rsi
movq %r14, %rdx
callq 0x10a0
movq %r15, %rsi
cmpq %r12, %r15
jg 0x1852
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Edilbert[P]BS9/form9.c
// Function: MoveComment
void MoveComment(int i)
{
   char *p;
   int j;

   p = strchr(Line+i,';');
   if (!p) p = strchr(Line+i,'*');
   if (p)
   {
      j = p - Line;
      if (p[1] != ' ') MoveLine(j+1,j+2);
      MoveLine(j,ccol);
   }
}

// Assembly:
pushq %rbx
movslq %edi, %rax
leaq 0x4c12(%rip), %rbx      # 0x64b0
addq %rax, %rbx
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x1050
testq %rax, %rax
jne 0x18c5
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x1050
testq %rax, %rax
je 0x18ef
leaq 0x4be4(%rip), %rcx      # 0x64b0
movl %eax, %ebx
subl %ecx, %ebx
cmpb $0x20, 0x1(%rax)
je 0x18e1
leal 0x1(%rbx), %edi
leal 0x2(%rbx), %esi
callq 0x16ee
movl 0x27b5(%rip), %esi      # 0x409c
movl %ebx, %edi
popq %rbx
jmp 0x16ee
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/fileloader.c
// Function: free_buffer
void free_buffer(arraylist_t *buffer) {
    line_t *line = NULL;

    if(!buffer) return;

    for(size_t i = 0; i < buffer->size; i++) {
        line = get_line(buffer, i);
        free(line->line);
        free(line->source);
        free(line);
    }
    arraylist_free(buffer, 0);
}

// Assembly:
testq %rdi, %rdi
je 0x2af7
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2ae8
xorl %r15d, %r15d
testl %r15d, %r15d
js 0x2ac3
movl %r15d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %rbx, %rdi
callq 0x6d0c
movq %rax, %r14
jmp 0x2ac6
xorl %r14d, %r14d
movq (%r14), %rdi
callq 0x2030
movq 0x8(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
incq %r15
cmpq 0x8(%rbx), %r15
jb 0x2aa8
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x6d97
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_variable_declaration_parsing
static void test_variable_declaration_parsing(char *line) {
	arraylist_t *list = NULL;

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	list = get_variables_from_declaration(0, line);
	if(list != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_variables(list, 0);
		field_list_free(list);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8616(%rip), %rdi      # 0xd423
leaq 0x8622(%rip), %rsi      # 0xd436
leaq 0x8204(%rip), %rdx      # 0xd01f
leaq 0x8203(%rip), %r8       # 0xd025
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20d0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x8934
testq %rax, %rax
je 0x4e6d
movq %rax, %rbx
leaq 0x85f7(%rip), %rdi      # 0xd43c
leaq 0x85ea(%rip), %rsi      # 0xd436
leaq 0x81d2(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4e91
movq %rbx, %rdi
popq %rbx
jmp 0x6953
leaq 0x85d6(%rip), %rdi      # 0xd44a
leaq 0x85bb(%rip), %rsi      # 0xd436
leaq 0x8197(%rip), %rdx      # 0xd019
leaq 0x819c(%rip), %rcx      # 0xd025
xorl %eax, %eax
popq %rbx
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/test.c
// Function: print_variables
static void print_variables(arraylist_t *variables, unsigned int tabs) {
	field_t *variable = NULL;
	if(variables != NULL) {
		for(unsigned int i = 0 ; i < variables->size ; i++) {
			variable = arraylist_get(variables, i);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");

			printf(" %s%2d:  %sName:       %s%s\n",
				COLOR_MAGENTA, i,
				COLOR_CYAN, FORMAT_RESET, variable->name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sType:       %s%s\n", COLOR_CYAN, FORMAT_RESET, variable->type.name);

			for(unsigned int j = 0 ; j < tabs ; j++)
				printf("\t");
			printf("      %sIs pointer: %s%d\n", COLOR_CYAN, FORMAT_RESET, variable->type.is_pointer);
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x4fc8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x4fba
movl %esi, %r13d
leaq 0x8168(%rip), %rbp      # 0xd025
xorl %esi, %esi
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x6d0c
movq %rax, %r12
movl %r13d, %ebx
testl %r13d, %r13d
je 0x4f4a
movl $0x9, %edi
callq 0x2040
decl %ebx
jne 0x4ed5
movq (%r12), %r9
leaq 0x8570(%rip), %rdi      # 0xd45e
leaq 0x8586(%rip), %rsi      # 0xd47b
movl %r15d, %edx
leaq 0x8582(%rip), %rcx      # 0xd481
movq %rbp, %r8
xorl %eax, %eax
callq 0x20d0
movl %r13d, %ebx
movl $0x9, %edi
callq 0x2040
decl %ebx
jne 0x4f0c
movq 0x10(%r12), %rcx
leaq 0x8561(%rip), %rdi      # 0xd487
leaq 0x8554(%rip), %rsi      # 0xd481
movq %rbp, %rdx
xorl %eax, %eax
callq 0x20d0
movl %r13d, %ebx
movl $0x9, %edi
callq 0x2040
decl %ebx
jne 0x4f3a
jmp 0x4f8c
movq (%r12), %r9
leaq 0x8509(%rip), %rdi      # 0xd45e
leaq 0x851f(%rip), %rsi      # 0xd47b
movl %r15d, %edx
leaq 0x851b(%rip), %rbx      # 0xd481
movq %rbx, %rcx
movq %rbp, %r8
xorl %eax, %eax
callq 0x20d0
movq 0x10(%r12), %rcx
leaq 0x8508(%rip), %rdi      # 0xd487
movq %rbx, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x20d0
movsbl 0x18(%r12), %ecx
leaq 0x8508(%rip), %rdi      # 0xd4a1
leaq 0x84e1(%rip), %rsi      # 0xd481
movq %rbp, %rdx
xorl %eax, %eax
callq 0x20d0
incl %r15d
movq %r15, %rsi
cmpq %r15, 0x8(%r14)
ja 0x4ec2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/test.c
// Function: test_function_declaration_parsing
static void test_function_declaration_parsing(char *line) {
	function_t *function = get_function_from_declaration(0, line);

	printf("%sInput: %s\"%s\"%s\n", COLOR_BLUE, COLOR_YELLOW, line, FORMAT_RESET);
	if(function != NULL) {
		printf("%sOutput: %s\n", COLOR_BLUE, FORMAT_RESET);
		print_function(function, 0);
		function_free(function);
	} else
		printf("%sOutput: %sNULL%s\n", COLOR_BLUE, COLOR_RED, FORMAT_RESET);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0xac6b
movq %rax, %rbx
leaq 0x843f(%rip), %rdi      # 0xd423
leaq 0x844b(%rip), %rsi      # 0xd436
leaq 0x802d(%rip), %rdx      # 0xd01f
leaq 0x802c(%rip), %r8       # 0xd025
movq %r14, %rcx
xorl %eax, %eax
callq 0x20d0
testq %rbx, %rbx
je 0x503d
leaq 0x842d(%rip), %rdi      # 0xd43c
leaq 0x8420(%rip), %rsi      # 0xd436
leaq 0x8008(%rip), %rdx      # 0xd025
xorl %eax, %eax
callq 0x20d0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5067
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb760
leaq 0x8406(%rip), %rdi      # 0xd44a
leaq 0x83eb(%rip), %rsi      # 0xd436
leaq 0x7fc7(%rip), %rdx      # 0xd019
leaq 0x7fcc(%rip), %rcx      # 0xd025
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20d0
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/display.c
// Function: print_message
void print_message(char *file, int line_index, char *line, const char *message, const char *type, const char *color) {
	if(line == NULL)
		printf("%s[%s]%s At %s%s:%d%s: %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message);
	else
		printf("%s[%s]%s At %s%s:%d%s: %s\n  %s\n", color, type, FORMAT_RESET, COLOR_CYAN_BOLD, file, line_index, FORMAT_RESET, message, line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r14
movq %rcx, %r11
movl %esi, %r10d
movq %rdi, %r9
testq %rdx, %rdx
je 0x58aa
movq %rdx, %rbx
leaq 0x7794(%rip), %rcx      # 0xd025
leaq 0x8e82(%rip), %rdi      # 0xe71a
leaq 0x7fe4(%rip), %r8       # 0xd883
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
pushq %rbx
jmp 0x58cb
subq $0x8, %rsp
leaq 0x7770(%rip), %rcx      # 0xd025
leaq 0x8e43(%rip), %rdi      # 0xe6ff
leaq 0x7fc0(%rip), %r8       # 0xd883
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
pushq %r11
pushq %rcx
pushq %r10
callq 0x20d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_conf_file
void exclude_conf_file(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return;

    rule_t *e;

    e = malloc(sizeof(rule_t));
    e->name = malloc(sizeof(char) * 1048);

    strcpy(e->name, "conf_inc_");
    strcat(e->name, name);

    e->enable = 1;
    e->value = 0;
    arraylist_add(conf, e);
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x5b56
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x10, %edi
callq 0x2140
movq %rax, %r15
movl $0x418, %edi            # imm = 0x418
callq 0x2140
movq %rax, (%r15)
movabsq $0x636e695f666e6f63, %rcx # imm = 0x636E695F666E6F63
movq %rcx, (%rax)
movw $0x5f, 0x8(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
movq $0x1, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6c26
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: find_rule_index
int find_rule_index(arraylist_t *conf, char *name){
    if(strlen(name) <= 0) return -2;

    for(size_t i = 0; i < conf->size; i++){
        if(strcmp(name, ((rule_t*)(conf->array[i]))->name) == 0){
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x0, (%rsi)
je 0x5b9a
movq 0x8(%rdi), %r15
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x5ba4
movq %rsi, %r14
movq (%rdi), %r13
xorl %r12d, %r12d
movq (%r13,%r12,8), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
je 0x5ba1
incq %r12
cmpq %r12, %r15
jne 0x5b7c
jmp 0x5ba4
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x5ba4
movl %r12d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/System-Glitch[P]ESGILinter-C/src/conf.c
// Function: exclude_file
void exclude_file(FILE *src, arraylist_t *conf){
    if(src == NULL) return;
    char *line;
    int found;
    char *tmp;
    char *get;
    rule_t *e;

    line = malloc(sizeof(char) * 1048);
    tmp = malloc(sizeof(char) * 1048);

    get = fgets(line, 1048, src);
    if(get == NULL) { //Unexpected EOF reached
        free(line);
        free(tmp);
        return;
    }

    while(!is_whitespace(line[0]) && line[0] != '#'){
        strcpy(tmp, "exfile_");
        if(line[1] == ' '){
            strcat(tmp, line+2);
        }else{
            strcat(tmp, line+1);
        }
        strformat(tmp, 1048);

        found = find_rule_index(conf, tmp);
        if(found == -1 ){
            e = malloc(sizeof(rule_t));
            e->name = malloc(sizeof(char) * 1048);
            strcpy(e->name, tmp);
            e->value = 0;
            e->enable = 0;
            arraylist_add(conf, e);
        }
        get = fgets(line, 1048, src);
        if(get == NULL) break;
    }
    free(line);
    free(tmp);
}

// Assembly:
testq %rdi, %rdi
je 0x5ecf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
movl $0x418, %edi            # imm = 0x418
callq 0x2140
movq %rax, %r12
movl $0x418, %edi            # imm = 0x418
callq 0x2140
movq %rax, %r15
movq %r12, %rdi
movl $0x418, %esi            # imm = 0x418
movq %r14, %rdx
callq 0x2110
testq %rax, %rax
je 0x5eb1
leaq 0x1(%r12), %rbp
movq %r12, %rbx
addq $0x2, %rbx
movq %rbx, (%rsp)
movsbl (%r12), %edi
callq 0x7f3a
testb %al, %al
jne 0x5eb1
cmpb $0x23, (%r12)
je 0x5eb1
cmpb $0x20, (%rbp)
movabsq $0x5f656c69667865, %rax # imm = 0x5F656C69667865
movq %rax, (%r15)
movq %rbp, %rsi
cmoveq %rbx, %rsi
movq %r15, %rdi
callq 0x2180
movl $0x418, %esi            # imm = 0x418
movq %r15, %rdi
callq 0x818e
movq %r13, %rdi
movq %r15, %rsi
callq 0x5b57
cmpl $-0x1, %eax
jne 0x5e98
movl $0x10, %edi
callq 0x2140
movq %r14, %rbx
movq %r13, %r14
movq %rax, %r13
movl $0x418, %edi            # imm = 0x418
callq 0x2140
movq %rax, (%r13)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2080
movq $0x0, 0x8(%r13)
movq %r14, %rdi
movq %r13, %rsi
movq %r14, %r13
movq %rbx, %r14
movq (%rsp), %rbx
callq 0x6c26
movq %r12, %rdi
movl $0x418, %esi            # imm = 0x418
movq %r14, %rdx
callq 0x2110
testq %rax, %rax
jne 0x5df5
movq %r12, %rdi
callq 0x2030
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2030
retq