LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/johnvtan[P]ccccc/string.c
// Function: string_eq
int string_eq(string_t *s1, string_t *s2) {
    // I guess they might be equal if the user passes in two NULL pointers, but I'm going to say
    // that's invalid
    if (!s1 || !s2)
        return -1;
    
    if (s1->len != s2->len)
        return -1;

    // I'm pretty sure this handles empty string, but I'm not sure
    for (int i = 0; i < s1->len; i++) {
        if (s1->buf[i] != s2->buf[i]) {
            return -1;
        }
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
orb %cl, %dl
jne 0x4f16
movl 0x8(%rdi), %ecx
cmpl 0x8(%rsi), %ecx
jne 0x4f16
testl %ecx, %ecx
jle 0x4f14
movq (%rdi), %rdx
movq (%rsi), %rsi
movb (%rdx), %dil
cmpb (%rsi), %dil
jne 0x4f16
movl $0x1, %eax
movq %rax, %rdi
cmpq %rax, %rcx
je 0x4f0c
movb (%rdx,%rdi), %r8b
leaq 0x1(%rdi), %rax
cmpb (%rsi,%rdi), %r8b
je 0x4ef6
xorl %eax, %eax
cmpq %rcx, %rdi
sbbl %eax, %eax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/johnvtan[P]ccccc/tokenize.c
// Function: print_token
void print_token(token_t *token) {
    if (!token)
        return;

    if (token->type == TOK_INT_LIT) {
        printf("integer literal: %d\n", token->int_literal);
        return;
    }

    if (token->type == TOK_CHAR_LIT) {
        printf("char literal: %c\n", token->char_literal);
        return;
    }

    if (token->type == TOK_IDENT) {
        printf("identifier: %s\n", string_get(token->ident));
        return;
    }

    // try special chars and keywords now
    keyword_pair_t keyword;
    int i = 0;
    do {
        keyword = keywords[i++];
        if (token->type == keyword.type) {
            printf("keyword: %s\n", keyword.keyword);
            return;
        }
    } while (keyword.keyword);

    special_char_pair_t special;
    i = 0;
    do {
        special = special_chars[i++];
        if (token->type == special.type) {
            printf("special char: %c\n", special.c);
            return;
        }
    } while (special.c);

    printf("UNKNOWN TOKEN!!!!!!\n");
}

// Assembly:
testq %rdi, %rdi
je 0x51a6
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x51b4
cmpl $0x2, %eax
je 0x51a7
cmpl $0x3, %eax
jne 0x51c5
pushq %rax
movq 0x8(%rdi), %rdi
callq 0x4e85
leaq 0x1b11(%rip), %rdi      # 0x6cac
movq %rax, %rsi
xorl %eax, %eax
popq %rcx
jmp 0x1080
retq
movsbl 0x8(%rdi), %esi
leaq 0x1ae8(%rip), %rdi      # 0x6c9a
jmp 0x51be
movl 0x8(%rdi), %esi
leaq 0x1ac7(%rip), %rdi      # 0x6c85
xorl %eax, %eax
jmp 0x1080
movl $0x8, %ecx
leaq 0x4abf(%rip), %rdx      # 0x9c90
cmpl (%rcx,%rdx), %eax
je 0x5207
addq $0x10, %rcx
cmpq $0x168, %rcx            # imm = 0x168
jne 0x51d1
xorl %ecx, %ecx
leaq 0x1b94(%rip), %rdx      # 0x6d80
cmpl 0x4(%rdx,%rcx,8), %eax
je 0x521a
incq %rcx
cmpq $0x16, %rcx
jne 0x51ec
leaq 0x1b64(%rip), %rdi      # 0x6d66
jmp 0x1050
movq -0x8(%rcx,%rdx), %rsi
leaq 0x1aa9(%rip), %rdi      # 0x6cbc
xorl %eax, %eax
jmp 0x1080
movsbl (%rdx,%rcx,8), %esi
leaq 0x1aa4(%rip), %rdi      # 0x6cc9
jmp 0x51be
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: foptoa
char *foptoa(struct fctx *cctx, struct v *v) {
    struct v *c, *e, *n;
    for (c = cctx->env; c; c = cdr(c)) {
        n = caar(c); e = cdar(c);
        if ((v == (fwordp(v) ? e : car(e))))
            return str(n);
    }
    return "<undef>";
}

// Assembly:
movq 0x148(%rdi), %rcx
leaq 0xaadf(%rip), %rax      # 0xc3cc
testq %rcx, %rcx
je 0x194a
pushq %rbp
movq %rsp, %rbp
movl $0x10f, %edx            # imm = 0x10F
movq 0x8(%rcx), %r8
testq %r8, %r8
je 0x190e
movq 0x8(%r8), %rdi
movq 0x10(%r8), %r8
jmp 0x1913
xorl %edi, %edi
xorl %r8d, %r8d
testq %rsi, %rsi
je 0x1927
movl (%rsi), %r9d
andl %edx, %r9d
cmpl $0x100, %r9d            # imm = 0x100
je 0x1935
testq %r8, %r8
je 0x1932
movq 0x8(%r8), %r8
jmp 0x1935
xorl %r8d, %r8d
cmpq %rsi, %r8
je 0x1945
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0x18fb
jmp 0x1949
movq 0x8(%rdi), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: eval
v *
eval(ctx *cctx, v *e, v *env) 
{
    v *r = 0, *f;
    switch(e->tag) {
    case INT: case STR:
        r = e;
        break;
    case SYM:
        if (QUOTED(e)) {
            r = e;
        } else {
            if ((r = assq(e, env))) {
                r = cdr(r);
            } else {
                fprintf(stderr, "Undefined symbol \"%s\"\n", str(e));
            }
        }
        break;
    case FUNC:
        break;
    case CONS:
        if (QUOTED(e)) {
            r = evargs(cctx, e, env);
        } else {
            f = eval(cctx, car(e), env);
            r = apply(cctx, f, cdr(e), env);
        }
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl (%rsi), %eax
movl %eax, %ecx
andl $0xf, %ecx
leal -0x1(%rcx), %edx
cmpl $0x2, %edx
jb 0x20c2
testl %ecx, %ecx
je 0x2068
cmpl $0x3, %ecx
jne 0x20c0
testb %al, %al
js 0x20c2
testq %r14, %r14
je 0x20b8
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2062
cmpq %rbx, 0x8(%rax)
je 0x20b2
movq 0x10(%r14), %r14
jmp 0x204e
movq %rdi, %r15
testb %al, %al
js 0x209a
movq 0x8(%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x201e
movq 0x10(%rbx), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2458
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2332
movq 0x10(%rax), %rbx
jmp 0x20c2
movq %rbx, %rdi
callq 0x11a0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: evbind
v *
evbind(v *n, v *a, v *ev)
{
    if (ConsP(n)) {
        for (; n; n = cdr(n), a = cdr(a)) {
            ev = mkCons(mkCons(car(n), car(a)),ev);
        }
    } else {
        ev = mkCons(mkCons(n,a),ev);
    }
    return ev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
xorl %r13d, %r13d
testq %rdi, %rdi
je 0x2419
movq %rdi, %r14
testb $0xf, (%rdi)
jne 0x241c
testq %rbx, %rbx
movq %r15, -0x30(%rbp)
je 0x23c0
movq 0x8(%rbx), %r13
jmp 0x23c3
xorl %r13d, %r13d
movq 0x8(%r14), %r15
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
xorl %eax, %eax
movl %eax, (%r12)
movq %r15, 0x8(%r12)
movq %r13, 0x10(%r12)
movl $0x18, %edi
callq 0x10e0
xorl %ecx, %ecx
movl %ecx, (%rax)
movq %r12, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
testq %rbx, %rbx
je 0x2409
movq 0x10(%rbx), %rbx
jmp 0x240b
xorl %ebx, %ebx
movq 0x10(%r14), %r14
movq %rax, %r15
testq %r14, %r14
jne 0x23b1
jmp 0x2449
xorl %r14d, %r14d
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
movl %r13d, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movl $0x18, %edi
callq 0x10e0
movl %r13d, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: apply
v *
apply(ctx *cctx, v *fn, v *args, v *env) 
{
    v *r = 0, *benv;
    if (!fn)
        return 0;
    switch(fn->tag) {
    case OP:
        if (OP_ARGEVALP(fn))
            args = evargs(cctx,args,env);
        r = op(fn)(cctx, args, env);
        break;
    case FUNC:
        benv = env;
        if (FN_ARGEVALP(fn))
            args = evargs(cctx,args,env);
        if (FN_FUNCENVP(fn))
            benv = funcenv(fn);
        if (FN_ARGBINDP(fn))
            benv = evbind(car(func(fn)), args, benv);
        r = evlist(cctx, cdr(func(fn)),benv);
        break;
    default:
        fprintf(stderr, "Cannot apply to "); print(cctx, stderr, fn); fprintf(stderr, "\n"); 
        break;
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x252b
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, %ecx
andl $0xf, %ecx
cmpl $0x4, %ecx
je 0x24b7
cmpl $0x5, %ecx
jne 0x2520
testb $0x10, %al
je 0x249e
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x2332
movq %rax, %rdx
movq 0x8(%r15), %rax
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
testb $0x10, %al
je 0x24cf
movq %r14, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x2332
movq %rax, %rdx
movl (%r15), %eax
testb $0x20, %al
je 0x24d7
movq 0x10(%r15), %rbx
testb $0x40, %al
je 0x24fa
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x24ea
movq 0x8(%rax), %rdi
jmp 0x24ec
xorl %edi, %edi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x238d
movq %rax, %rbx
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x2509
movq 0x10(%rax), %rsi
jmp 0x250b
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x11c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: unique
v *
unique(ctx *cctx, char *s, int l) 
{
    v *v; char *cmp;
    for (v = cctx->sym; v; v = cdr(v)) {
        cmp = str(car(v));
        if (strlen(cmp) == l && strncasecmp(cmp, s, l) == 0) {
            return car(v);
        }
    }
    if (!v) {
        cctx->sym = mkCons((v = mkSym(s,l)), cctx->sym);
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
movslq %edx, %r15
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x2594
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %r12
movq 0x8(%r12), %r13
movq %r13, %rdi
callq 0x1050
cmpq %r15, %rax
jne 0x258b
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10f0
testl %eax, %eax
je 0x25f2
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2563
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
movl $0x3, (%rax)
leal 0x1(%r15), %eax
movslq %eax, %rdi
callq 0x10e0
movq %rax, %r13
movq %rax, 0x8(%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10d0
movb $0x0, (%r13,%r15)
movl $0x18, %edi
callq 0x10e0
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: nth
v *
_nth(v *v, int i, int f)
{
    struct v *r;
    if (f && !v) {
        v = mkCons(0,0);
    }
    while(v && (i-- > 0)) {
        if (!(v = cdr(r = v))) {
            if (f)
                rplacd(r, v = mkCons(0,0));
        }
    }
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
testl %edx, %edx
sete %al
testq %rdi, %rdi
setne %cl
orb %al, %cl
je 0x262c
movq %rdi, %r15
testq %rdi, %rdi
jne 0x2646
jmp 0x2681
movl $0x18, %edi
callq 0x10e0
movq %rax, %r15
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
incl %r14d
decl %r14d
testl %r14d, %r14d
jle 0x2684
movq 0x10(%r15), %rax
testl %ebx, %ebx
je 0x2679
testq %rax, %rax
jne 0x2679
movl $0x18, %edi
callq 0x10e0
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%r15)
movq %rax, %r15
testq %rax, %rax
jne 0x2649
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: nreverse
v *
nreverse(v *v)
{
    struct v *r = 0, *h, *l = v, *lt, *c, *p, *n, *t;
    int tq = 0;
    h = l;
    lt = c = cdr(l);
    if (c) {
        if (cdr(c)) {
            p = 0;
            do {
                n = cdr(c);
                rplacd(c,p);
                p = c;
                c = n;
            } while(cdr(c));
            rplacd(l, p);
            rplacd(lt, c);
        }
        /* swap head,c */
        tq = QUOTED(h);
        t = car(h);
        QUOTEV(h, QUOTED(c));
        rplaca(h, car(c));
        rplaca(c, t);
        QUOTEV(c, tq);
    }
    return h;
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
je 0x2713
movq 0x10(%rax), %rdx
testq %rdx, %rdx
je 0x2713
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdx), %rsi
testq %rsi, %rsi
je 0x26d5
xorl %edi, %edi
movq %rdx, %rcx
movq %rcx, %r8
movq %rsi, %rcx
movq %rdi, 0x10(%r8)
movq 0x10(%rsi), %rsi
movq %r8, %rdi
testq %rsi, %rsi
jne 0x26b5
movq %r8, 0x10(%rax)
movq %rcx, 0x10(%rdx)
jmp 0x26d8
movq %rdx, %rcx
movl (%rax), %edx
movq 0x8(%rax), %rsi
movl $0x80, %edi
movl (%rcx), %r8d
andl %edi, %r8d
movl $0xffffff7f, %r9d       # imm = 0xFFFFFF7F
movl %edx, %r10d
andl %r9d, %r10d
orl %r8d, %r10d
movl %r10d, (%rax)
movq 0x8(%rcx), %r8
movq %r8, 0x8(%rax)
movq %rsi, 0x8(%rcx)
andl %edi, %edx
andl (%rcx), %r9d
orl %edx, %r9d
movl %r9d, (%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./l1.c
// Function: sreverse
v *
sreverse(v *v)
{
    struct v *r = 0, *h, *e, *l = v, *n;
    if (!v)
        return v;
    h = l;
    n = cdr(l);
    rplacd(l,0); 
    while (e = n) {
        n = cdr(n);
        rplacd(e,h); 
        h = e;
    } 
    return h;
}

// Assembly:
testq %rdi, %rdi
je 0x2743
movq 0x10(%rdi), %rcx
movq $0x0, 0x10(%rdi)
testq %rcx, %rcx
je 0x2746
pushq %rbp
movq %rsp, %rbp
movq %rcx, %rax
movq 0x10(%rcx), %rcx
movq %rdi, 0x10(%rax)
movq %rax, %rdi
testq %rcx, %rcx
jne 0x272e
popq %rbp
retq
xorl %eax, %eax
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: comma
v *
comma(fctx *cctx, struct v *f, struct v *v) 
{
    struct v *e, *l = cdr(f); 
    rplaca(l,v);
    rplacd(f,e=mkCons(0,cdr(f)));
    FPRINTF(FDBG, "%-10s: @ ",""); 
    dbgfdef(cctx, car(f), cdr(f)); FPRINTF(FDBG, "\n");
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5426
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x5426
movq %rdx, 0x8(%r14)
movq 0x10(%rbx), %r15
jmp 0x542c
xorl %r14d, %r14d
xorl %r15d, %r15d
movl $0x18, %edi
callq 0x10e0
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
testq %rbx, %rbx
je 0x5451
movq %rax, 0x10(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: next
v *
next(fctx *cctx, int *imm) 
{
    char *b;
    v *w= 0, *s, *s2, *nm; char *e, *n; long v; int l;
    if ((s = cctx->peek)) {
        if(imm)
            *imm = cctx->peek_imm; 
        cctx->peek = 0;
        return s;
    }
    nm = s = word(cctx);
    n = str(s); l = strlen(n); 
    if (!(w = find(cctx, s))) {
        if (n[0] == '_' && l > 1) { /* search for maybe immediate version _<name> but return non-imm */
            if ((s2 = unique(&cctx->lctx, n+1, l-1))) {
                if ((w = find(cctx, s2))) {
                    *imm = 0;
                    goto doword;
                }
            }
        }
        if ((strchr("+-",n[0]) && isdigit(n[1])) ||
            isdigit(n[0])) {
            v = (long)strtoul(n, &e, 0);
            if (n + l == e) {
                s = mkInt(v);
            }
        }
        FPRINTF(FDBG, ">"); PRINT(LCTX,FDBG, s); FPRINTF(FDBG, "\n");
        if (imm)
            *imm = 0;
    } else {
        if (imm)
            *imm = FOP_IMMEDIATE(w);
        doword:
        s = cdr(w);
        FPRINTF(FDBG, ">["); PRINT(LCTX,FDBG, nm); FPRINTF(FDBG, "]\n");
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r13
movq 0x168(%rdi), %r14
testq %r14, %r14
je 0x551a
testq %rbx, %rbx
je 0x550a
movl 0x170(%r13), %eax
movl %eax, (%rbx)
movq $0x0, 0x168(%r13)
jmp 0x5652
movq %r13, %rdi
callq 0xbcf3
movq %rax, %r14
movq 0x8(%rax), %r15
movq %r15, %rdi
callq 0x1050
movq 0x148(%r13), %rdx
testq %rdx, %rdx
je 0x555c
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x5551
cmpq %r14, 0x8(%rcx)
jne 0x5556
jmp 0x55e3
testq %r14, %r14
je 0x555c
movq 0x10(%rdx), %rdx
jmp 0x5538
movb (%r15), %r12b
cmpb $0x5f, %r12b
sete %dl
cmpl $0x2, %eax
setge %cl
andb %dl, %cl
cmpb $0x1, %cl
movq %rax, -0x30(%rbp)
jne 0x55b3
leaq 0x1(%r15), %rsi
leal -0x1(%rax), %edx
movq %r13, %rdi
callq 0x2538
testq %rax, %rax
je 0x55b0
movq 0x148(%r13), %rdx
testq %rdx, %rdx
je 0x55b0
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x55aa
cmpq %rax, 0x8(%rcx)
je 0x564a
movq 0x10(%rdx), %rdx
jmp 0x5592
movb (%r15), %r12b
cmpb $0x2d, %r12b
ja 0x55f2
movzbl %r12b, %eax
movabsq $0x280000000001, %rcx   # imm = 0x280000000001
btq %rax, %rcx
jae 0x55f2
callq 0x1180
movq (%rax), %rcx
movsbq 0x1(%r15), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0x55f7
jmp 0x5605
testq %rbx, %rbx
je 0x564e
movl (%rcx), %eax
shrl $0x7, %eax
andl $0x1, %eax
jmp 0x564c
callq 0x1180
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x563d
leaq -0x38(%rbp), %r13
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x1130
movq %rax, %r12
movslq -0x30(%rbp), %rax
addq %r15, %rax
cmpq (%r13), %rax
jne 0x563d
movl $0x18, %edi
callq 0x10e0
movq %rax, %r14
movl $0x1, (%rax)
movq %r12, 0x8(%rax)
testq %rbx, %rbx
je 0x5652
movl $0x0, (%rbx)
jmp 0x5652
xorl %eax, %eax
movl %eax, (%rbx)
movq 0x10(%rcx), %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: fop_interpret
v *
fop_interpret(fctx *cctx)
{
    int lit, imm = 0; long val;
    struct v *v = next(cctx, &imm);
    if (v) {
        switch(v->tag) {
            
        case CONS:
            
            if ((cctx->w = v)) {
                if (imm || !FCTX_COMPILE(cctx)) {
                    return car(cctx->w);
                } else { /* compiling */
                    comma(cctx, cctx->here, v);
                }
            }
            return NEXT(cctx);
            break;
            
        case STR: case INT:
            
            if (FCTX_COMPILE(cctx)) {
                comma(cctx, cctx->here, g_LIT);
                comma(cctx, cctx->here, v);
            } else {
                PUSH(v);
            }
            return NEXT(cctx);
            break;
        
        case SYM:
            if (FCTX_COMPILE(cctx)) {
                comma(cctx, cctx->here, g_SYM);
                comma(cctx, cctx->here, v);
                return NEXT(cctx);
            }
            break;
            
        }
    }
    dbgprint(cctx," * ");

    if (cctx->fc >= 0) 
        return NEXT(cctx);
    else 
        return 0;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x1c(%rbp), %rsi
movl $0x0, (%rsi)
callq 0x54d9
testq %rax, %rax
je 0x5da3
movq %rax, %r14
movl (%rax), %eax
andl $0xf, %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x5d69
cmpl $0x3, %eax
je 0x5d9a
testl %eax, %eax
jne 0x5da3
movq %r14, 0x138(%rbx)
cmpl $0x0, -0x1c(%rbp)
jne 0x5d60
testb $0x1, 0x118(%rbx)
jne 0x5dd2
movq 0x8(%r14), %rax
jmp 0x5e1d
testb $0x1, 0x118(%rbx)
jne 0x5daf
movq 0x120(%rbx), %r15
movl $0x18, %edi
callq 0x10e0
movl $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x120(%rbx)
jmp 0x5de1
testb $0x1, 0x118(%rbx)
jne 0x5dbf
cmpq $0x0, 0x90(%rbx)
jns 0x5de1
jmp 0x5e1b
movq 0x158(%rbx), %rsi
movq 0xa50b(%rip), %rdx      # 0x102c8
jmp 0x5dcd
movq 0x158(%rbx), %rsi
movq 0xa503(%rip), %rdx      # 0x102d0
callq 0x5401
movq 0x158(%rbx), %rsi
movq %r14, %rdx
callq 0x5401
movq 0x130(%rbx), %rax
testq %rax, %rax
je 0x5e0e
movq 0x8(%rax), %rcx
movq %rcx, 0x138(%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x130(%rbx)
testq %rcx, %rcx
je 0x5e1b
movq 0x8(%rcx), %rax
jmp 0x5e1d
addq $0x130, %rbx            # imm = 0x130
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: key
int 
key(fctx *cctx)
{
    int c = EOF;
    if (cctx->fc >= 0) {
        while ((c = getc(cctx->f[cctx->fc])) == EOF) {
            fclose(cctx->f[cctx->fc--]);
            if (cctx->fc < 0)
                return c;
        }
    }
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x90(%rdi), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
js 0x5f17
movq %rdi, %r14
movq 0x10(%r14,%rax,8), %rdi
callq 0x1170
cmpl $-0x1, %eax
jne 0x5f15
movq 0x90(%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x90(%r14)
movq 0x10(%r14,%rax,8), %rdi
callq 0x1040
movq 0x90(%r14), %rax
testq %rax, %rax
jns 0x5edc
jmp 0x5f17
movl %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: fdef
v *
fdef(fctx *cctx, char *n, int cnt, ...) 
{
    va_list ap; int i, j; unsigned long b;
    va_start(ap, cnt);
    v *e, *l = mkCons(car(g_DOCOL), 0), *u;
    for (i = 0; i < cnt; i++) {
        e = (v *)va_arg(ap, v *);
        if ((b = ((unsigned long)e)-1) < 128) {
            for (j = 0, e = l; j < b; j++) {
                e = cdr(e);
            }
        }
        l = mkCons(e, l);
    }
    l = nreverse(mkCons(g_EXIT, l));
    u = unique(&cctx->lctx, n, strlen(n));
    cctx->env = mkCons(e = mkCons(u, l),cctx->env);
    va_end(ap);
    FOP_IMMEDIATE_VAL(e,1);
    CONS_WORD_VAL(l,1);
    dbgfdef(cctx, u, l);
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, -0x58(%rbp)
movq %rdi, -0x60(%rbp)
leaq -0x120(%rbp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x74d3
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %rdx, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, -0x50(%rbp)
movq 0x8dc4(%rip), %rax      # 0x102b8
testq %rax, %rax
je 0x74ff
movq 0x8(%rax), %rbx
jmp 0x7501
xorl %ebx, %ebx
movl $0x18, %edi
callq 0x10e0
movq %rax, %r15
movl $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0x75be
movl -0x50(%rbp), %r14d
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
xorl %ebx, %ebx
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x28, %r14d
ja 0x7557
movl %r14d, %eax
addq -0x68(%rbp), %rax
addl $0x8, %r14d
movl %r14d, -0x50(%rbp)
jmp 0x756a
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $0x8, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, -0x38(%rbp)
movq (%rax), %r12
leaq -0x1(%r12), %rax
cmpq $0x7f, %rax
ja 0x7597
movq %r15, %r12
testq %rax, %rax
je 0x7597
movq %r15, %r12
testq %r12, %r12
je 0x758f
movq 0x10(%r12), %r12
jmp 0x7592
xorl %r12d, %r12d
decq %rax
jne 0x7583
movl $0x18, %edi
callq 0x10e0
movq %rax, %r13
movl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
incl %ebx
movq %rax, %r15
cmpl -0x2c(%rbp), %ebx
jne 0x7540
jmp 0x75c1
movq %r15, %r13
movq 0x8cf8(%rip), %r14      # 0x102c0
movl $0x18, %edi
callq 0x10e0
movq %rax, %r15
xorl %ebx, %ebx
movl %ebx, (%rax)
movq %r14, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %rax, %rdi
callq 0x2692
movq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x1050
movq -0x60(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x2538
movq %rax, %r14
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
movl %ebx, (%rax)
movq %r14, 0x8(%rax)
movq %r15, 0x10(%rax)
movq 0x148(%r13), %r14
movl $0x18, %edi
callq 0x10e0
movl %ebx, (%rax)
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x148(%r13)
orb $-0x80, (%r12)
orb $0x1, 0x1(%r15)
movq %r15, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: word
v *
word(fctx *cctx)
{
    int c, l = 0, bc = 0; char *n = 0; v *s;
retry:
    while(strchr(" \n\t",(c = key(cctx))));
    if (c == '(') { /* eat comments */
        cctx->b[l++] = c; 
        if (strchr(" \t",(c = key(cctx)))) {
            l--; bc = 1;
            do { 
                c = key(cctx);
                switch(c) {
                case ')': bc--; break;
                case '(': bc++; break;
                };
            } while(!(bc <= 0 || c == EOF));
            goto retry;
        };
    } else if (c == '\\') {
        do {
            c = key(cctx);
        } while(!(c == '\n' || c == EOF));
        goto retry;
    } 
    do {
        cctx->b[l++] = c; 
        c = key(cctx);
    } while(!(c == ' ' || c == '\n' || c == EOF));
    s = unique(&cctx->lctx, cctx->b, l);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x98(%rdi), %rax
movq %rax, -0x30(%rbp)
leaq 0x6b2(%rip), %r15       # 0xc3c8
movabsq $0x100000201, %rbx      # imm = 0x100000201
movl $0x1, %r13d
movq %r14, %rdi
callq 0x5ec1
movl %eax, %r12d
movl $0x4, %edx
movq %r15, %rdi
movl %eax, %esi
callq 0x1090
testq %rax, %rax
jne 0xbd26
cmpl $0x28, %r12d
je 0xbd65
cmpl $0x5c, %r12d
jne 0xbdbb
movq %r14, %rdi
callq 0x5ec1
cmpl $-0x1, %eax
je 0xbd26
cmpl $0xa, %eax
jne 0xbd51
jmp 0xbd26
movb $0x28, 0x98(%r14)
movq %r14, %rdi
callq 0x5ec1
movl %eax, %r12d
cmpb $0x20, %r12b
ja 0xbdbe
movzbl %r12b, %eax
btq %rax, %rbx
jae 0xbdbe
movl $0x1, %r12d
movq %r14, %rdi
callq 0x5ec1
cmpl $0x28, %eax
je 0xbda5
cmpl $0x29, %eax
jne 0xbda8
decl %r12d
jmp 0xbda8
incl %r12d
cmpl $-0x1, %eax
je 0xbd26
testl %r12d, %r12d
jg 0xbd8e
jmp 0xbd26
xorl %r13d, %r13d
movabsq $0x200000801, %rbx      # imm = 0x200000801
movb %r12b, 0x98(%r14,%r13)
incq %r13
movq %r14, %rdi
callq 0x5ec1
movl %eax, %r12d
incl %eax
cmpl $0x21, %eax
ja 0xbdc8
btq %rax, %rbx
jae 0xbdc8
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movl %r13d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2538
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/./f1.c
// Function: find
v *
find(fctx *cctx, v *s)
{
    v *e = 0;
    if ((e = assq(s, cctx->env))) {
        return (e);
    }
    return 0;
}

// Assembly:
movq 0x148(%rdi), %rcx
testq %rcx, %rcx
je 0xbe3b
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rcx), %rax
testq %rax, %rax
je 0xbe27
movq 0x8(%rax), %rdx
jmp 0xbe29
xorl %edx, %edx
cmpq %rsi, %rdx
je 0xbe39
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
jne 0xbe18
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/eiselekd[P]MinimalLisp/f.c
// Function: main
int
main(int argc, char **argv) 
{
    fctx cctx; int c, i; FILE *f; char v[32];
    struct v *fx = 0, *r;
    memset(&cctx,0,sizeof(cctx));

    atexit(colreset);
    signal(SIGINT, sigint);
    
    /* input */
    cctx.f[cctx.fc = 0] = stdin;
    for (i = argc-1; i >= 1; i--) {
        if (f = fopen(argv[i],"r")) {
            cctx.f[++cctx.fc] = f;
        }
    }
    
    f_init(&cctx) ;
    
    r = mkCons(g_QUIT, 0);
    cctx.ip = r;
    fx = NEXT(&cctx);
    
    /* main loop */
    while(fx) {
        fx = fop(fx)(&cctx);
    }

    fprintf(FDBG, "[39m"); /* col def */
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x198(%rbp), %r15
xorl %r12d, %r12d
movl $0x178, %edx            # imm = 0x178
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
leaq -0x5d(%rip), %rdi       # 0xbe49
callq 0xbf80
leaq -0x74(%rip), %rsi       # 0xbe3e
movl $0x2, %edi
callq 0x10a0
movq 0x4115(%rip), %rax      # 0xffd8
movq (%rax), %rax
movq %rax, 0x10(%r15)
cmpl $0x2, %r14d
jl 0xbf06
movl %r14d, %r15d
incq %r15
xorl %r12d, %r12d
leaq 0x45f(%rip), %r14       # 0xc33f
movq -0x10(%rbx,%r15,8), %rdi
movq %r14, %rsi
callq 0x1120
testq %rax, %rax
je 0xbefd
movq %rax, -0x180(%rbp,%r12,8)
incq %r12
decq %r15
cmpq $0x2, %r15
ja 0xbee0
leaq -0x198(%rbp), %rbx
movq %r12, 0x90(%rbx)
movq %rbx, %rdi
callq 0x7661
movq 0x46d5(%rip), %rax      # 0x105f8
movq %rax, 0x138(%rbx)
movq $0x0, 0x130(%rbx)
testq %rax, %rax
je 0xbf4b
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xbf4b
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xbf3e
movq 0x407e(%rip), %rax      # 0xffd0
movq (%rax), %rcx
leaq 0x47d(%rip), %rdi       # 0xc3d9
movl $0x5, %esi
movl $0x1, %edx
callq 0x1160
xorl %eax, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_set.c
// Function: shmem_int_atomic_set
void shmem_int_atomic_set( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	*remote_ptr = val;
	__clear_spin_lock(x);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movl %edx, %esi
callq 0x1c3c
movq %rax, %r14
leaq 0x31b3(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1c3c
movq %rax, %rbx
movq %rax, %rdi
callq 0x3303
movl %ebp, (%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x32f4
nop
// File: /workspace/github_c_makefile_star2_O3/wtakuo[P]SVM/test2.c
// Function: vmtest
void vmtest (int n, vm_mode_t trace) {
    int codelen = sizeof(code)/sizeof(Bcode);
    Function f = new_function(1, 0, code + 10, codelen - 10);
    gv[0] = (Value)n;
    gv[1] = (Value)f;

    vm(code, codelen, vs_base, VS_SIZE, gv, GV_SIZE, trace);

    delete_function(f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movl %edi, %ebp
leaq 0x283f(%rip), %rdx      # 0x407a
movl $0x1, %edi
movl $0x15, %ecx
xorl %esi, %esi
callq 0x15b4
movq %rax, %r14
leaq 0x281a(%rip), %rdi      # 0x4070
movslq %ebp, %rax
movq %rax, 0x2840(%rip)      # 0x40a0
leaq 0x2839(%rip), %r8       # 0x40a0
movq %r14, 0x283a(%rip)      # 0x40a8
movl %ebx, (%rsp)
leaq 0x3068(%rip), %rdx      # 0x48e0
movl $0x1f, %esi
movl $0x100, %ecx            # imm = 0x100
movl $0x8, %r9d
callq 0x121c
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x15f7
// File: /workspace/github_c_makefile_star2_O3/c0stya[P]fslib/src/fssort.c
// Function: main
int main(int argc, char * argv[]) {
    struct _fst * fst = fst_create(); 
    const char * ifilename = NULL; 
    const char * ofilename = NULL;
    FILE * fin = stdin;
    FILE * fout = stdout;
    int sort_outer = 0;
    int c;

    while ( (c = getopt(argc, argv, "ioh")) != -1 ) {
        switch(c) {
            case 'i': 
                sort_outer = 0;
                break;
            case 'o': 
                sort_outer = 1;
                break;
            default:
                fprintf(stderr, "Usage: %s [-o] [input_file] [output_file]\n", argv[0]);
                exit(EXIT_SUCCESS);
        } 
    }

    if (optind < argc)
        ifilename = argv[optind];
    if (optind+1 < argc)
        ofilename = argv[optind+1];
    
    if (ifilename) {
        if (( fin = fopen(ifilename, "rb")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ifilename);
            exit(EXIT_FAILURE);
        }
    }

    if (ofilename) {
        if (( fout = fopen(ofilename, "w")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ofilename);
            exit(EXIT_FAILURE);
        }
    }

    fst_read(fst, fin);
    fst_arc_sort(fst, sort_outer);
    fst_write(fst, fout);
    fst_remove(fst);
    
    if (fin != stdout) {
        fclose(fin);
    }

    if (fout != stdout) {
        fclose(fout);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movl %edi, %ebx
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x2120
movq %rax, -0x38(%rbp)
movq 0x3d09(%rip), %rax      # 0x8fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq 0x3cf3(%rip), %rax      # 0x8fc8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
leaq 0x1493(%rip), %r15      # 0x6776
movl %r12d, %r14d
movl %ebx, %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x11b0
movl $0x0, %r12d
cmpl $0x69, %eax
je 0x52e3
cmpl $0x6f, %eax
jne 0x530b
movl $0x1, %r12d
jmp 0x52e3
cmpl $-0x1, %eax
jne 0x53e3
movq 0x3cbd(%rip), %rax      # 0x8fd8
movslq (%rax), %rax
cmpl %ebx, %eax
jge 0x5329
movq (%r13,%rax,8), %r15
jmp 0x532c
xorl %r15d, %r15d
incl %eax
cmpl %ebx, %eax
jge 0x533b
cltq
movq (%r13,%rax,8), %rbx
jmp 0x533d
xorl %ebx, %ebx
movq -0x30(%rbp), %r12
testq %r15, %r15
je 0x5361
leaq 0xd81(%rip), %rsi       # 0x60ce
movq %r15, %rdi
callq 0x1190
movq %rax, %r12
testq %rax, %rax
je 0x53eb
testq %rbx, %rbx
movq -0x40(%rbp), %r15
je 0x5381
leaq 0x1434(%rip), %rsi      # 0x67a5
movq %rbx, %rdi
callq 0x1190
movq %rax, %r15
testq %rax, %rax
je 0x53f3
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23e9
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2d78
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22ce
movq %rbx, %rdi
callq 0x222b
movq 0x3c13(%rip), %rbx      # 0x8fc8
cmpq (%rbx), %r12
je 0x53c5
movq %r12, %rdi
callq 0x1090
movq (%rbx), %r12
cmpq %r12, %r15
je 0x53d2
movq %r15, %rdi
callq 0x1090
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x132b
movq %r15, %rdi
callq 0x12dd
movq %rbx, %rdi
callq 0x1304
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_resolve_state[abi:cxx11](char)
string unq_resolve_state(char state){
    string ret = "";
    
    ret += state & NORMAL_DISPLAY ? "Normal," : "Deleted,";
    ret += state & MAIN_THREAD ? "Thread," : "";
    ret += state & THREAD_REPLY ? "Reply," : "";
    ret += state & SAGE_THREAD ? "Sage," : "";
    ret += state & LOCKED_THREAD ? "Locked," : "";

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x69700(%rip), %r14     # 0x77672
movq %r14, %rsi
movq %r14, %rdx
callq 0xedf0
testb $0x1, %bpl
leaq 0x63084(%rip), %rax     # 0x7100c
leaq 0x63075(%rip), %rsi     # 0x71004
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0xc790
testb $0x4, %bpl
leaq 0x6306f(%rip), %rsi     # 0x71015
cmoveq %r14, %rsi
movq %rbx, %rdi
callq 0xc790
testb $0x2, %bpl
leaq 0x63060(%rip), %rsi     # 0x7101d
cmoveq %r14, %rsi
movq %rbx, %rdi
callq 0xc790
testb $0x10, %bpl
leaq 0x63050(%rip), %rsi     # 0x71024
cmoveq %r14, %rsi
movq %rbx, %rdi
callq 0xc790
testb %bpl, %bpl
leaq 0x63040(%rip), %rsi     # 0x7102a
cmovnsq %r14, %rsi
movq %rbx, %rdi
callq 0xc790
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xe014
callq 0xc640
movq %r14, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_reset(unqlite*)
int unq_reset(unqlite *pDb){
    int rc = unq_write_int(pDb, "global_counter", 0, true);
    if (!rc) return 0;

    //construct the root thread
    cclong *key = new cclong(0);
    struct Thread *t = new Thread();
    t->threadID = 0;
    //t->state = 'r';
    t->nextThread = 0;
    t->childCount = 0;

    strcpy(t->content, "slogan");

    rc = unqlite_kv_store(pDb, key, 4, t, sizeof(struct Thread));
    if (rc != UNQLITE_OK)
        return 0;
    else{
        unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x63005(%rip), %rsi     # 0x71032
xorl %ebp, %ebp
xorl %edx, %edx
movl $0x1, %ecx
callq 0xe0b7
testl %eax, %eax
je 0xe0aa
movl $0x4, %edi
callq 0xc1d0
movq %rax, %r14
movl $0x0, (%rax)
movl $0xd0, %edi
callq 0xc1d0
movq %rax, %r15
xorl %ebp, %ebp
movl $0xd0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc360
movl $0x676f6c73, 0x1(%r15)  # imm = 0x676F6C73
movl $0x6e6167, 0x4(%r15)    # imm = 0x6E6167
movl $0xd0, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %r15, %rcx
callq 0x313f4
testl %eax, %eax
jne 0xe0aa
movq %rbx, %rdi
callq 0x3287e
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_write_int(unqlite*, char const*, int, bool)
int unq_write_int(unqlite *pDb, const char* key, int value, bool autoCommit){
    int* zzz = new cclong(value);
    int rc;
    rc = unqlite_kv_store(pDb, key, -1, zzz, 4);
    delete zzz;

    if (rc != UNQLITE_OK)
        return 0;
    else{
        if(autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movl $0x4, %edi
callq 0xc1d0
movq %rax, %r12
movl %r14d, (%rax)
movl $0x4, %r8d
movq %rbx, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rax, %rcx
callq 0x313f4
movl %eax, %r14d
movq %r12, %rdi
callq 0xc640
xorl %eax, %eax
testl %r14d, %r14d
sete %cl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0xe11e
movq %rbx, %rdi
callq 0x3287e
movl $0x1, %eax
jmp 0xe120
movb %cl, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_delete_thread(unqlite*, int)
int unq_delete_thread(unqlite *pDb, int tid){
    // cchan will never truely delete a thread, it just hides it
    struct Thread* t = unq_read_thread(pDb, tid);
    struct Thread* tp = unq_read_thread(pDb, t->prevThread);
    struct Thread* tn = unq_read_thread(pDb, t->nextThread);

    if (!(t->state & NORMAL_DISPLAY)) return 0;

    if (t->parentThread == 0 && t->state & MAIN_THREAD){
        tn->prevThread = t->prevThread;
        tp->nextThread = t->nextThread;

        if (t->prevThread == t->nextThread){
            //this happens only if the thread has one child reply
            tn->nextThread = tn->threadID;
            unq_write_thread(pDb, tn->threadID, tn, false);
        }
        else{
            unq_write_thread(pDb, tn->threadID, tn, false);
            unq_write_thread(pDb, tp->threadID, tp, false);
        }

        //t->state = 'd';
        //t->state -= NORMAL_DISPLAY;
        changeState(t, NORMAL_DISPLAY, false);
        unq_write_thread(pDb, t->threadID, t, false);
    }

    if (!(t->state & MAIN_THREAD)){
        changeState(t, NORMAL_DISPLAY, false);
        unq_write_thread(pDb, t->threadID, t, false);
    }

    unqlite_commit(pDb);

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xe181
movq %rax, %r14
movl 0xc0(%rax), %esi
movq %rbx, %rdi
callq 0xe181
movq %rax, %r15
movl 0xbc(%r14), %esi
movq %rbx, %rdi
callq 0xe181
movb (%r14), %dl
xorl %ecx, %ecx
testb $0x1, %dl
je 0xe33c
testb $0x4, %dl
je 0xe2fc
cmpl $0x0, 0xc8(%r14)
jne 0xe2fc
movl 0xc0(%r14), %edx
movl %edx, 0xc0(%rax)
movl 0xbc(%r14), %esi
movl %esi, 0xbc(%r15)
movl 0xb8(%rax), %ecx
cmpl %esi, %edx
jne 0xe281
movl %ecx, 0xbc(%rax)
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
movl $0xd0, %r8d
movq %rbx, %rdi
movl $0x4, %edx
movq %rax, %rcx
jmp 0xe2c4
leaq 0x4(%rsp), %r12
movl %ecx, (%r12)
movl $0xd0, %r8d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x4, %edx
movq %rax, %rcx
callq 0x313f4
movl 0xb8(%r15), %eax
movl %eax, (%r12)
leaq 0x4(%rsp), %rsi
movl $0xd0, %r8d
movq %rbx, %rdi
movl $0x4, %edx
movq %r15, %rcx
callq 0x313f4
movb (%r14), %al
testb $0x1, %al
je 0xe2d5
decb %al
movb %al, (%r14)
movl 0xb8(%r14), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0xd0, %r8d
movq %rbx, %rdi
movl $0x4, %edx
movq %r14, %rcx
callq 0x313f4
movb (%r14), %dl
testb $0x4, %dl
jne 0xe32f
testb $0x1, %dl
je 0xe30b
decb %dl
movb %dl, (%r14)
movl 0xb8(%r14), %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0xd0, %r8d
movq %rbx, %rdi
movl $0x4, %edx
movq %r14, %rcx
callq 0x313f4
movq %rbx, %rdi
callq 0x3287e
movl $0x1, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_write_thread(unqlite*, int, Thread*, bool)
int unq_write_thread(unqlite *pDb, cclong key, struct Thread* t, bool autoCommit){
    
    int k = key;
    int rc;
    rc = unqlite_kv_store(pDb, &k, 4, t, sizeof(struct Thread));

    if (rc != UNQLITE_OK)
        return 0;
    else{
        if (autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movl $0xd0, %r8d
movq %rax, %rsi
movl $0x4, %edx
callq 0x313f4
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0xe390
movq %rbx, %rdi
callq 0x3287e
movl $0x1, %eax
jmp 0xe392
movb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_write_string(unqlite*, char const*, char const*, bool)
int unq_write_string(unqlite *pDb, const char* key, const char* value, bool autoCommit){
    int rc;
    rc = unqlite_kv_store_fmt(pDb, key, -1, value); //simple
    if (rc != UNQLITE_OK)
        return 0;
    else{
        if (autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rcx
movq %rdi, %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x315a6
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %cl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0xe5c4
movq %rbx, %rdi
callq 0x3287e
movl $0x1, %eax
jmp 0xe5c6
movb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: displayReply(unqlite*, Thread*)
int displayReply(unqlite *pDb, struct Thread *t){
    cclong ct = t->childThread;
    struct Thread *r = unq_read_thread(pDb, ct); // beginning of the circle
    cclong rid = r->threadID; //the ID

    struct tm * timeinfo;
    timeinfo = localtime(&(r->date));
    fprintf(stdout, "  %d Reply(s)\n", r->childCount);
    fprintf(stdout, "  Reply-ID: %d, Author: %s, Date: %s  %s\n", rid, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));

    while (r->prevThread != rid){
        r = unq_read_thread(pDb, r->prevThread);
        timeinfo = localtime(&(r->date));
        fprintf(stdout, "  Reply-ID: %d, Author: %s, Date: %s  %s\n", r->threadID, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc4(%rsi), %esi
callq 0xe181
movq %rax, %r14
movl 0xb8(%rax), %ebp
leaq 0xa0(%rax), %rdi
callq 0xc770
movq %rax, %r15
movq 0x85546(%rip), %r12     # 0x93fa0
movq (%r12), %rdi
movl 0xcc(%r14), %edx
leaq 0x625d5(%rip), %rsi     # 0x71041
xorl %eax, %eax
callq 0xc260
movq (%r12), %r12
leaq 0x11(%r14), %r13
movq %r15, %rdi
callq 0xc520
movq %rax, %r15
leaq 0x1(%r14), %rsi
movq %rbx, %rdi
callq 0xeb44
leaq 0x625b7(%rip), %rsi     # 0x71050
movq %r12, %rdi
movl %ebp, %edx
movq %r13, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc260
movl 0xc0(%r14), %esi
cmpl %ebp, %esi
je 0xeb30
movq %rbx, %rdi
callq 0xe181
movq %rax, %r15
leaq 0xa0(%rax), %rdi
callq 0xc770
movq 0x854c9(%rip), %rcx     # 0x93fa0
movq (%rcx), %r12
movl 0xb8(%r15), %r13d
leaq 0x11(%r15), %rcx
movq %rcx, (%rsp)
movq %rax, %rdi
callq 0xc520
movl %ebp, %r14d
movq %rax, %rbp
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xeb44
movq %r12, %rdi
leaq 0x62543(%rip), %rsi     # 0x71050
movl %r13d, %edx
movq (%rsp), %rcx
movq %rbp, %r8
movl %r14d, %ebp
movq %rax, %r9
xorl %eax, %eax
callq 0xc260
movl 0xc0(%r15), %esi
cmpl %r14d, %esi
jne 0xeab9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_read_string(unqlite*, char const*)
const char* unq_read_string(unqlite *pDb, const char* key){
    unqlite_int64 nBytes;
    int rc;
    rc = unqlite_kv_fetch(pDb, key, -1, NULL, &nBytes);
    if (rc != UNQLITE_OK)
        return 0;

    char *zBuf = new char[++nBytes];
    if (zBuf == NULL) 
        return 0;

    rc = unqlite_kv_fetch(pDb, key, -1, zBuf, &nBytes);
    if (rc != UNQLITE_OK)
        return 0;

    zBuf[nBytes] = 0;

    return zBuf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq %rsp, %r8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x31b4f
testl %eax, %eax
jne 0xebb3
movq %rsp, %r12
movq (%r12), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r12)
cmpq $-0x1, %rax
movq $-0x1, %rdi
cmovgeq %rcx, %rdi
callq 0xc560
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rax, %rcx
movq %r12, %r8
callq 0x31b4f
testl %eax, %eax
je 0xebab
xorl %ebx, %ebx
jmp 0xebb3
movq (%rsp), %rax
movb $0x0, (%rbx,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: listThread(unqlite*)
int listThread(unqlite *pDb){
    struct Thread *r = unq_read_thread(pDb, 0); // get the root thread
    //iterThread(pDb, r);

    while (r->nextThread){
        r = unq_read_thread(pDb, r->nextThread);

        struct tm * timeinfo;
        timeinfo = localtime(&(r->date));
        fprintf(stdout, "ID: %d, Author: %s, Date: %s%s\n", r->threadID, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));

        if (r->childThread) displayReply(pDb, r);
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xe181
movl 0xbc(%rax), %esi
testl %esi, %esi
je 0xec65
movq %rbx, %rdi
callq 0xe181
movq %rax, %r15
leaq 0xa0(%rax), %rdi
callq 0xc770
movq 0x8539d(%rip), %rcx     # 0x93fa0
movq (%rcx), %r12
movl 0xb8(%r15), %ebp
leaq 0x11(%r15), %r13
movq %rax, %rdi
callq 0xc520
movq %rax, %r14
leaq 0x1(%r15), %rsi
movq %rbx, %rdi
callq 0xeb44
movq %r12, %rdi
leaq 0x62448(%rip), %rsi     # 0x7107a
movl %ebp, %edx
movq %r13, %rcx
movq %r14, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0xc260
cmpl $0x0, 0xc4(%r15)
je 0xec59
movq %rbx, %rdi
movq %r15, %rsi
callq 0xea22
movl 0xbc(%r15), %esi
jmp 0xebdd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/general.cpp
// Function: unq_read_thread_sp(unqlite*, int)
std::shared_ptr<struct Thread> unq_read_thread_sp(unqlite * pDb, int key)
{
    unqlite_int64 nBytes = sizeof(struct Thread);
    std::shared_ptr<struct Thread> ret = std::shared_ptr<struct Thread>(new Thread());

    unqlite_kv_fetch(pDb, &key, 4, ret.get(), &nBytes);

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xc(%rsp), %r12
movl %edx, (%r12)
leaq 0x10(%rsp), %r13
movq $0xd0, (%r13)
movl $0xd0, %edi
callq 0xc1d0
movq %rax, %rbp
movl $0xd0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0xc360
movq %rbp, (%rbx)
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0xee86
movq (%rbx), %rcx
movq %r15, %rdi
movq %r12, %rsi
movl $0x4, %edx
movq %r13, %r8
callq 0x31b4f
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0xed6e
callq 0xed76
movq %rbx, %rdi
callq 0xc760
// File: /workspace/github_c_makefile_star2_O3/coyove[P]chann/./src/helper.cpp
// Function: cck_extract_ssid[abi:cxx11](mg_connection*)
string cck_extract_ssid(mg_connection* conn){
    char ssid[128]; 
    mg_parse_header(mg_get_header(conn, "Cookie"), "ssid", ssid, sizeof(ssid));
    string ret(ssid);

    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x621cc(%rip), %rsi     # 0x71162
movq %rax, %rdi
callq 0x67c6a
leaq 0x621c4(%rip), %rsi     # 0x71169
movq %rsp, %r14
movl $0x80, %ecx
movq %rax, %rdi
movq %r14, %rdx
callq 0x6928c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xc460
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xedf0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq