LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: pass1MatchExpr
long pass1MatchExpr(long test, long clauses, long cont)
{
    long x5, x4, clauseBlocks, x3, x2, contBlocks, explicitCont, x1, labeledClauses;
    goto L1;
L1:
    labeledClauses = pass1LabeledClauses(clauses);
    goto L2;
L2:
    x1 = pass1ExplicitCont(cont);
    goto L3;
L3:
    switch (runtime_class(x1)) {
    case CLASS_Pair:
        explicitCont = prim_fetch(x1, runtime_makeNumber(0));
        contBlocks = prim_fetch(x1, runtime_makeNumber(1));
        goto L4;
    default:
        runtime_matchFailure(__LINE__);
    }
L4:
    clauseBlocks = pass1ClauseBlocks(labeledClauses, explicitCont);
    goto L6;
L5:
    x3 = FiMatch(test, x2);
    x4 = append(contBlocks, clauseBlocks);
    goto L7;
L6:
    x2 = pass1TransformedClauses(labeledClauses);
    goto L5;
L7:
    x5 = Triple(nil, x3, x4);
    return x5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2810
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x25f0
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5690
subw $0x1f, %ax
jne 0x2574
jmp 0x252f
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x48(%rbp)
jmp 0x2580
movl $0x165, %edi            # imm = 0x165
callq 0x5c50
jmp 0x2580
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x28b0
movq %rax, -0x30(%rbp)
jmp 0x25b7
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2970
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12a0
movq %rax, -0x28(%rbp)
jmp 0x25c6
movq -0x60(%rbp), %rdi
callq 0x29a0
movq %rax, -0x40(%rbp)
jmp 0x2593
leaq 0x26c7b(%rip), %rax     # 0x29248
movq (%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1240
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: pass1LabeledClauses
long pass1LabeledClauses(long clauses)
{
    long x2, x1, moreClauses, clause;
    goto L1;
L1:
    switch (runtime_class(clauses)) {
    case CLASS_Cons:
        clause = prim_fetch(clauses, runtime_makeNumber(0));
        moreClauses = prim_fetch(clauses, runtime_makeNumber(1));
        goto L2;
    default:
        goto L3;
    }
L2:
    x1 = prim_genLabel();
    x2 = Pair(x1, clause);
    return x2;
L3:
    return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5690
subw $0x3, %ax
jne 0x2872
jmp 0x282d
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x28(%rbp)
jmp 0x2874
jmp 0x2898
callq 0x5d60
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28a6
leaq 0x269a9(%rip), %rax     # 0x29248
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: pass1ClauseBlocks
long pass1ClauseBlocks(long labeledClauses, long cont)
{
    long x2, x1, moreLabeledClauses, labeledClause;
    goto L1;
L1:
    switch (runtime_class(labeledClauses)) {
    case CLASS_Cons:
        labeledClause = prim_fetch(labeledClauses, runtime_makeNumber(0));
        moreLabeledClauses = prim_fetch(labeledClauses, runtime_makeNumber(1));
        goto L2;
    default:
        goto L3;
    }
L2:
    x1 = pass1OneClauseBlocks(labeledClause, cont);
    goto L4;
L3:
    return nil;
L4:
    x2 = pass1ClauseBlocks(moreLabeledClauses, cont);
    goto L5;
L5:
    return append(x1, x2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5690
subw $0x3, %ax
jne 0x2916
jmp 0x28d1
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, %edi
callq 0x57a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, -0x30(%rbp)
jmp 0x2918
jmp 0x292b
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2d00
movq %rax, -0x28(%rbp)
jmp 0x293b
leaq 0x26916(%rip), %rax     # 0x29248
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x295d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28b0
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/bootstrap1.c
// Function: compiler_init
void compiler_init(void)
{
    runtime_classArities[31] = 2;
    runtime_classArities[32] = 3;
    runtime_classArities[33] = 0;
    runtime_classArities[34] = 1;
    runtime_classArities[35] = 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6115(%rip), %rax      # 0x9170
movb $0x2, 0x1f(%rax)
leaq 0x610a(%rip), %rax      # 0x9170
movb $0x3, 0x20(%rax)
leaq 0x60ff(%rip), %rax      # 0x9170
movb $0x0, 0x21(%rax)
leaq 0x60f4(%rip), %rax      # 0x9170
movb $0x1, 0x22(%rax)
leaq 0x60e9(%rip), %rax      # 0x9170
movb $0x3, 0x23(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/hic.c
// Function: main
int main(void)
{
    long hi;
    long fi;

    require64BitLongs();

    runtime_init();
    compiler_init();

    hi = parse();
    fi = compile(hi);

    print(fi);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x5f10
callq 0x5e10
callq 0x3050
callq 0x4210
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4280
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: nrClasses
static int nrClasses(long defs)
{
    long def, id, args;
    int nr = 0;
    forEach(defs, def) {
        if (match(def, CLASS_FiDefineCons, &id, &args))
            nr++;
    }
    return nr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x3, %esi
leaq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x47d0
movq -0x10(%rbp), %rdi
movl $0x14, %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x47ce
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x478b
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: match
static int match(long x, unsigned short class, ...)
{
    va_list ap;
    long *p;
    int arity, i, matched;

    va_start(ap, class);

    matched = (runtime_class(x) == class);
    arity = runtime_classArities[class];
    for (i = 0; i < arity; i++) {
        p = va_arg(ap, long *);
        if (matched)
            *p = prim_fetch(x, runtime_makeNumber(i));
    }

    va_end(ap);

    return matched;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x481e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
callq 0x5690
movzwl %ax, %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movzwl -0xa(%rbp), %eax
movl %eax, %ecx
leaq 0x48dd(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x3c(%rbp), %eax
jge 0x4956
leaq -0x30(%rbp), %rax
movq %rax, -0x110(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x104(%rbp)
cmpl $0x28, %eax
ja 0x48e8
movq -0x110(%rbp), %rcx
movl -0x104(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x118(%rbp)
jmp 0x4905
movq -0x110(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x4946
movq -0x8(%rbp), %rax
movq %rax, -0x120(%rbp)
movslq -0x40(%rbp), %rdi
callq 0x57a0
movq -0x120(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4948
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x48a1
movl -0x44(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prFuncSpec
static void prFuncSpec(long name, long args)
{
    pr("long "), prStr(name), pr("(");
    if (length(args) > 0)
        prTypedIds(args);
    else
        pr("void");
    pr(")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1cc7(%rip), %rdi      # 0x667e
callq 0x4750
movq -0x8(%rbp), %rdi
callq 0x4e00
leaq 0x1d68(%rip), %rdi      # 0x6734
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4d10
cmpl $0x0, %eax
jle 0x49ea
movq -0x10(%rbp), %rdi
callq 0x4e30
jmp 0x49f6
leaq 0x1c84(%rip), %rdi      # 0x6675
callq 0x4750
leaq 0x1c8e(%rip), %rdi      # 0x668b
callq 0x4750
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prVariables
static void prVariables(long blocks)
{
    long id, block, var, allVars = nil, arg, args, stmts, stmt, transfer;
    long expr;
    const char *sep = "";

    forEach(blocks, block) {
        if (match(block, CLASS_FiBlock, &id, &args, &stmts, &transfer)) {
            forEach(args, arg)
                allVars = prim_cons(arg, allVars);
            forEach(stmts, stmt)
                if (match(stmt, CLASS_FiStmt, &id, &expr))
                    allVars = prim_cons(id, allVars);
        }
    }

    if (allVars == nil)
        return;

    pr("    long ");
    forEach(allVars, var)
        pr(sep), prId(var), sep = ", ";
    pr(";\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x247f2(%rip), %rax     # 0x29248
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x1b39(%rip), %rax      # 0x659d
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movl $0x3, %esi
leaq -0x18(%rbp), %rdx
leaq -0x68(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4b4e
movq -0x18(%rbp), %rdi
movl $0x15, %esi
leaq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
leaq -0x50(%rbp), %r9
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4b49
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
movl $0x3, %esi
leaq -0x30(%rbp), %rdx
leaq -0x70(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4af2
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5cc0
movq %rax, -0x28(%rbp)
jmp 0x4ac2
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movl $0x3, %esi
leaq -0x48(%rbp), %rdx
leaq -0x78(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4b47
movq -0x48(%rbp), %rdi
movl $0x16, %esi
leaq -0x10(%rbp), %rdx
leaq -0x58(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4b45
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5cc0
movq %rax, -0x28(%rbp)
jmp 0x4afa
jmp 0x4b49
jmp 0x4a70
movq -0x28(%rbp), %rax
leaq 0x246ef(%rip), %rcx     # 0x29248
cmpq (%rcx), %rax
jne 0x4b60
jmp 0x4bbc
leaq 0x1b13(%rip), %rdi      # 0x667a
callq 0x4750
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movl $0x3, %esi
leaq -0x20(%rbp), %rdx
leaq -0x80(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4bb0
movq -0x60(%rbp), %rdi
callq 0x4750
movq -0x20(%rbp), %rdi
callq 0x4970
leaq 0x1a46(%rip), %rax      # 0x65f0
movq %rax, -0x60(%rbp)
jmp 0x4b74
leaq 0x1bd8(%rip), %rdi      # 0x678f
callq 0x4750
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prBlocks
static void prBlocks(long blocks)
{
    long id, args, stmts, transfer, expr, block, stmt;
    int flag = 0;

    forEach(blocks, block) {
        if (match(block, CLASS_FiBlock, &id, &args, &stmts, &transfer)) {
            if (!flag)
                pr("    goto "), prId(id), pr(";\n"), flag = 1;
            prId(id), pr(":\n");
            forEach(stmts, stmt)
                if (match(stmt, CLASS_FiStmt, &id, &expr))
                    pr("    "), prId(id), pr(" = "), prExpr(expr), pr(";\n");
            prTransfer(transfer, blocks);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl $0x3, %esi
leaq -0x38(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4d04
movq -0x38(%rbp), %rdi
movl $0x15, %esi
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
leaq -0x28(%rbp), %r9
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4cff
cmpl $0x0, -0x44(%rbp)
jne 0x4c63
leaq 0x1b0f(%rip), %rdi      # 0x6751
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x1b38(%rip), %rdi      # 0x678f
callq 0x4750
movl $0x1, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x1af3(%rip), %rdi      # 0x6766
callq 0x4750
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movl $0x3, %esi
leaq -0x40(%rbp), %rdx
leaq -0x58(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4cf2
movq -0x40(%rbp), %rdi
movl $0x16, %esi
leaq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4cf0
leaq 0x1a30(%rip), %rdi      # 0x66f1
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x195b(%rip), %rdi      # 0x6631
callq 0x4750
movq -0x30(%rbp), %rdi
callq 0x4ea0
leaq 0x1aa4(%rip), %rdi      # 0x678f
callq 0x4750
jmp 0x4c80
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5030
jmp 0x4beb
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: length
static int length(long args)
{
    long arg;
    int len = 0;
    forEach(args, arg)
        len++;
    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3, %esi
leaq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4d53
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4d2b
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prIds
static void prIds(long ids)
{
    long id;
    const char *sep = "";

    forEach(ids, id)
        pr(sep), prId(id), sep = ", ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x182a(%rip), %rax      # 0x659d
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3, %esi
leaq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4dbb
movq -0x18(%rbp), %rdi
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x183b(%rip), %rax      # 0x65f0
movq %rax, -0x18(%rbp)
jmp 0x4d7f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prTypedIds
static void prTypedIds(long ids)
{
    long id;
    const char *sep = "";

    forEach(ids, id)
        pr(sep), pr("long "), prId(id), sep = ", ";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x175a(%rip), %rax      # 0x659d
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3, %esi
leaq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4e97
movq -0x18(%rbp), %rdi
callq 0x4750
leaq 0x1802(%rip), %rdi      # 0x667e
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x175f(%rip), %rax      # 0x65f0
movq %rax, -0x18(%rbp)
jmp 0x4e4f
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: prExpr
static void prExpr(long expr)
{
    long id, args, name;

    if (match(expr, CLASS_FiPrimApp, &id, &args))
        pr("prim_"), prId(id), pr("("), prIds(args), pr(")");
    else if (match(expr, CLASS_FiConsApp, &id, &args))
        prId(id), pr("("), prIds(args), pr(")");
    else if (match(expr, CLASS_Fixnum))
       pr("runtime_makeNumber("), prNum(expr), pr(")");
    else if (match(expr, CLASS_String))
        pr("runtime_makeString(\""), prStr(expr), pr("\")");
    else if (match(expr, CLASS_Id, &name))
        prId(expr);
    else {
        fprintf(stderr, "Expression class: %d.\n", (int)runtime_class(expr));
        die("Unknown expression class.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1e, %esi
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4f04
leaq 0x17b4(%rip), %rdi      # 0x6684
callq 0x4750
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x184f(%rip), %rdi      # 0x6734
callq 0x4750
movq -0x18(%rbp), %rdi
callq 0x4d60
leaq 0x1791(%rip), %rdi      # 0x668b
callq 0x4750
jmp 0x5024
movq -0x8(%rbp), %rdi
movl $0x1d, %esi
leaq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4f50
movq -0x10(%rbp), %rdi
callq 0x4970
leaq 0x1803(%rip), %rdi      # 0x6734
callq 0x4750
movq -0x18(%rbp), %rdi
callq 0x4d60
leaq 0x1745(%rip), %rdi      # 0x668b
callq 0x4750
jmp 0x5022
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4f88
leaq 0x16cc(%rip), %rdi      # 0x6635
callq 0x4750
movq -0x8(%rbp), %rdi
callq 0x4dd0
leaq 0x170d(%rip), %rdi      # 0x668b
callq 0x4750
jmp 0x5020
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4fc0
leaq 0x16a5(%rip), %rdi      # 0x6649
callq 0x4750
movq -0x8(%rbp), %rdi
callq 0x4e00
leaq 0x16d1(%rip), %rdi      # 0x668a
callq 0x4750
jmp 0x501e
movq -0x8(%rbp), %rdi
movl $0x4, %esi
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x4fe4
movq -0x8(%rbp), %rdi
callq 0x4970
jmp 0x501c
movq 0x400d(%rip), %rax      # 0x8ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5690
movq -0x28(%rbp), %rdi
movzwl %ax, %edx
leaq 0x1684(%rip), %rsi      # 0x668d
movb $0x0, %al
callq 0x1090
leaq 0x168d(%rip), %rdi      # 0x66a4
callq 0x5ed0
jmp 0x501e
jmp 0x5020
jmp 0x5022
jmp 0x5024
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/printer.c
// Function: findArgs
static long findArgs(long key, long blocks)
{
    const char *keyString;
    long id, args, stmts, transfer, block;

    keyString = runtime_stringValue(key);
    forEach(blocks, block) {
        if (match(block, CLASS_FiBlock, &id, &args, &stmts, &transfer))
            if (!strcmp(runtime_stringValue(idName(id)), keyString))
                return args;
    }

    die("Failed to find arguments for block.");
    return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5650
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl $0x3, %esi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x5577
movq -0x48(%rbp), %rdi
movl $0x15, %esi
leaq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x38(%rbp), %r8
leaq -0x40(%rbp), %r9
movb $0x0, %al
callq 0x47e0
cmpl $0x0, %eax
je 0x5575
movq -0x28(%rbp), %rdi
callq 0x4a10
movq %rax, %rdi
callq 0x5650
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x5573
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5591
jmp 0x5575
jmp 0x5505
leaq 0x121b(%rip), %rdi      # 0x6799
callq 0x5ed0
leaq 0x23cbe(%rip), %rax     # 0x29248
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: makeString
static long makeString(const char *s)
{
    unsigned long align;
    unsigned long size;
    unsigned long len;
    unsigned long i;

    len = strlen(s);
    align = sizeof(long);
    size = sizeof(long) + len + 1;
    i = storeAlloc(align, size);
    *(long *)(store.data + i) = makeNumber((long)len);
    memmove(store.data + i + sizeof(long), s, len + 1);

    return (long)(i << 16 | CLASS_String);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movq %rax, -0x20(%rbp)
movq $0x8, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5970
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x57c0
movq %rax, %rdx
movq 0x23c03(%rip), %rax     # 0x29218
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx)
movq 0x23bf4(%rip), %rdi     # 0x29218
addq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
callq 0x10d0
movq -0x28(%rbp), %rax
shlq $0x10, %rax
orq $0x1, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: fixnumValue
static long fixnumValue(long n)
{
    unsigned long bits;

    bits = (unsigned long)n >> 16;
    if (n < 0)
        bits |= (unsigned long)0xffff << 48;

    return (long)bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x10, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x571d
movabsq $-0x1000000000000, %rax # imm = 0xFFFF000000000000
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: prim_fetch
long prim_fetch(long m, long k)
{
    long *tuple;
    unsigned char arity;
    long i;

    /* TODO What sanity checks do we want here? */

    arity = runtime_classArities[runtime_class(m)];
    i = fixnumValue(k);

    if (i >= arity)
        die("Fetching slot that does not exist.");

    tuple = storeAddr(m);
    return tuple[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5690
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x3a1b(%rip), %rax      # 0x9170
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
callq 0x56f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl -0x19(%rbp), %ecx
cmpq %rcx, %rax
jl 0x5781
leaq 0x1051(%rip), %rdi      # 0x67cd
callq 0x5ed0
movq -0x8(%rbp), %rdi
callq 0x56b0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: prim_die
long prim_die(long e)
{
    const char *s;

    mustBe(CLASS_String, e);

    s = storeAddr(e) + sizeof(long);
    die(s);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
callq 0x5820
movq -0x8(%rbp), %rdi
callq 0x56b0
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5ed0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_makeTuple0
long runtime_makeTuple0(unsigned short class)
{
    if (runtime_classArities[class] != 0) {
        fprintf(stderr, "Class: %d Arity: %d\n", (int)class, 0);
        die("Arity error while making tuple.");
    }

    return (long)class;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x38f4(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x58af
movq 0x376c(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xf56(%rip), %rsi       # 0x67f0
xorl %ecx, %ecx
movb $0x0, %al
callq 0x1090
leaq 0xf5b(%rip), %rdi       # 0x6805
callq 0x5ed0
movzwl -0x2(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_makeTuple1
long runtime_makeTuple1(unsigned short class, long a)
{
    unsigned long align;
    unsigned long size;
    unsigned long i;
    long *tuple;

    if (runtime_classArities[class] != 1) {
        fprintf(stderr, "Class: %d Arity: %d\n", (int)class, 1);
        die("Arity error while making tuple.");
    }

    align = sizeof(long);
    size = sizeof(long);
    i = storeAlloc(align, size);
    tuple = store.data + i;

    tuple[0] = a;

    return (long)(i << 16 | class);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x3890(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x5916
movq 0x3708(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xef2(%rip), %rsi       # 0x67f0
movl $0x1, %ecx
movb $0x0, %al
callq 0x1090
leaq 0xef4(%rip), %rdi       # 0x6805
callq 0x5ed0
movq $0x8, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5970
movq %rax, -0x28(%rbp)
movq 0x238da(%rip), %rax     # 0x29218
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
shlq $0x10, %rax
movzwl -0x2(%rbp), %ecx
orq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: storeAlloc
static long storeAlloc(unsigned long align, unsigned long size)
{
    unsigned long i;

    i = align * (store.firstFree + align - 1) / align;
    if (i + size > store.size)
        die("Out of memory.");

    store.firstFree = i + size;

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x23885(%rip), %rcx     # 0x29210
addq -0x8(%rbp), %rcx
subq $0x1, %rcx
imulq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x8(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
cmpq 0x23856(%rip), %rax     # 0x29208
jbe 0x59c0
leaq 0xe95(%rip), %rdi       # 0x6850
callq 0x5ed0
movq -0x18(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, 0x23841(%rip)     # 0x29210
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_makeTuple2
long runtime_makeTuple2(unsigned short class, long a, long b)
{
    unsigned long align;
    unsigned long size;
    unsigned long i;
    long *tuple;

    if (runtime_classArities[class] != 2) {
        fprintf(stderr, "Class: %d Arity: %d\n", (int)class, 2);
        die("Arity error while making tuple.");
    }

    align = sizeof(long);
    size = 2 * sizeof(long);
    i = storeAlloc(align, size);
    tuple = store.data + i;

    tuple[0] = a;
    tuple[1] = b;

    return (long)(i << 16 | class);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x376c(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
cmpl $0x2, %eax
je 0x5a3a
movq 0x35e4(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xdce(%rip), %rsi       # 0x67f0
movl $0x2, %ecx
movb $0x0, %al
callq 0x1090
leaq 0xdd0(%rip), %rdi       # 0x6805
callq 0x5ed0
movq $0x8, -0x20(%rbp)
movq $0x10, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5970
movq %rax, -0x30(%rbp)
movq 0x237b6(%rip), %rax     # 0x29218
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
shlq $0x10, %rax
movzwl -0x2(%rbp), %ecx
orq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_makeTuple3
long runtime_makeTuple3(unsigned short class, long a, long b, long c)
{
    unsigned long align;
    unsigned long size;
    unsigned long i;
    long *tuple;

    if (runtime_classArities[class] != 3) {
        fprintf(stderr, "Class: %d Arity: %d\n", (int)class, 3);
        die("Arity error while making tuple.");
    }

    align = sizeof(long);
    size = 3 * sizeof(long);
    i = storeAlloc(align, size);
    tuple = store.data + i;

    tuple[0] = a;
    tuple[1] = b;
    tuple[2] = c;

    return (long)(i << 16 | class);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x36a8(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
cmpl $0x3, %eax
je 0x5afe
movq 0x3520(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xd0a(%rip), %rsi       # 0x67f0
movl $0x3, %ecx
movb $0x0, %al
callq 0x1090
leaq 0xd0c(%rip), %rdi       # 0x6805
callq 0x5ed0
movq $0x8, -0x28(%rbp)
movq $0x18, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5970
movq %rax, -0x38(%rbp)
movq 0x236f2(%rip), %rax     # 0x29218
addq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
shlq $0x10, %rax
movzwl -0x2(%rbp), %ecx
orq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_makeTuple4
long runtime_makeTuple4(unsigned short class, long a, long b, long c, long d)
{
    unsigned long align;
    unsigned long size;
    unsigned long i;
    long *tuple;

    if (runtime_classArities[class] != 4) {
        fprintf(stderr, "Class: %d Arity: %d\n", (int)class, 4);
        die("Arity error while making tuple.");
    }

    align = sizeof(long);
    size = 4 * sizeof(long);
    i = storeAlloc(align, size);
    tuple = store.data + i;

    tuple[0] = a;
    tuple[1] = b;
    tuple[2] = c;
    tuple[3] = d;

    return (long)(i << 16 | class);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x35d4(%rip), %rax      # 0x9170
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
je 0x5bd2
movq 0x344c(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
leaq 0xc36(%rip), %rsi       # 0x67f0
movl $0x4, %ecx
movb $0x0, %al
callq 0x1090
leaq 0xc38(%rip), %rdi       # 0x6805
callq 0x5ed0
movq $0x8, -0x30(%rbp)
movq $0x20, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x5970
movq %rax, -0x40(%rbp)
movq 0x2361e(%rip), %rax     # 0x29218
addq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rax
shlq $0x10, %rax
movzwl -0x2(%rbp), %ecx
orq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_matchFailure
void runtime_matchFailure(int line)
{
    char buf[256];
    snprintf(buf, sizeof(buf), "Match failure. Line: %d. Class: %d",
        line, (int)runtime_class(classArgSave));
    die(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl %edi, -0x4(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x114(%rbp)
movq 0x23584(%rip), %rdi     # 0x29200
callq 0x5690
movq -0x120(%rbp), %rdi
movl -0x114(%rbp), %ecx
movzwl %ax, %r8d
movl $0x100, %esi            # imm = 0x100
leaq 0xb87(%rip), %rdx       # 0x6825
movb $0x0, %al
callq 0x1060
leaq -0x110(%rbp), %rdi
callq 0x5ed0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_isPrim
int runtime_isPrim(const char *name)
{
    int i;
    for (i = 0; i < ARRAY_SIZE(prims); i++)
        if (!strcmp(prims[i], name))
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x5, %rax
jae 0x5e00
movslq -0x14(%rbp), %rcx
leaq 0x13398(%rip), %rax     # 0x19170
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x5df3
movl $0x1, -0x4(%rbp)
jmp 0x5e07
jmp 0x5df5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5dc3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: runtime_init
void runtime_init(void)
{
    storeInit(128 * 1024 * 1024);
    runtime_0 = runtime_makeNumber(0);
    runtime_1 = runtime_makeNumber(1);
    runtime_2 = runtime_makeNumber(2);
    runtime_3 = runtime_makeNumber(3);
    nil = runtime_makeTuple0(CLASS_Nil);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x8000000, %edi        # imm = 0x8000000
callq 0x5e80
xorl %eax, %eax
movl %eax, %edi
callq 0x57a0
movq %rax, 0x233fa(%rip)     # 0x29228
movl $0x1, %edi
callq 0x57a0
movq %rax, 0x233f1(%rip)     # 0x29230
movl $0x2, %edi
callq 0x57a0
movq %rax, 0x233e8(%rip)     # 0x29238
movl $0x3, %edi
callq 0x57a0
movq %rax, 0x233df(%rip)     # 0x29240
movl $0x2, %edi
callq 0x5860
movq %rax, 0x233d6(%rip)     # 0x29248
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ebb[P]chisa/runtime.c
// Function: storeInit
static void storeInit(unsigned long size)
{
    store.size = size;
    store.firstFree = 0;
    store.data = malloc(size);
    if (store.data == NULL)
        die("Failed to allocate memory.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x23371(%rip)     # 0x29208
movq $0x0, 0x2336e(%rip) # 0x29210
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, 0x23366(%rip)     # 0x29218
cmpq $0x0, 0x2335e(%rip)     # 0x29218
jne 0x5ec8
leaq 0x9bb(%rip), %rdi       # 0x687e
callq 0x5ed0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/8-Synchronization/normal_strtok.c
// Function: main
int main(void)
{
	char buf[STR_MAX];
	char *token;
	int i = 0;

	sprintf(buf, "Linux is a cool operating system");

	token = strtok((char *) buf, " ");		// 1st step for strtok()
	do
	{
		printf("Token %d = %s\n", i++, token);
	}
	while((token = strtok(NULL, " ")) != NULL);	// later steps for strtok()

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl $0x0, -0x4(%rbp)
movl $0x0, -0x41c(%rbp)
leaq -0x410(%rbp), %rdi
leaq 0xe7a(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
leaq -0x410(%rbp), %rdi
leaq 0xe86(%rip), %rsi       # 0x2025
callq 0x1040
movq %rax, -0x418(%rbp)
movl -0x41c(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x41c(%rbp)
movq -0x418(%rbp), %rdx
leaq 0xe5d(%rip), %rdi       # 0x2027
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
movl %eax, %edi
leaq 0xe49(%rip), %rsi       # 0x2025
callq 0x1040
movq %rax, -0x418(%rbp)
cmpq $0x0, %rax
jne 0x11ab
xorl %eax, %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_init
void dthread_init(void) {
    threads = (queue *)malloc(sizeof(queue));
    td_cur = (dthread *)malloc(sizeof(dthread));
    init_threads(threads);

    //initialising the current thread with main thread details
    td_cur->tid = tid_count++;
    td_cur->status = RUNNING;
    td_cur->state = JOINABLE;
    td_cur->start_routine = NULL;
    td_cur->args = NULL;
    td_cur->retval = NULL;
    td_cur->signal = -1;
    sigsetjmp(td_cur->context, 1);


    //initialising signal for timer
    struct sigaction sa;
    sigset_t mask;
    sigemptyset(&mask);
    sigaddset(&mask,SIGVTALRM);
    //whenever sigvtalrm is raised, scheduler is called
    sa.sa_handler = &scheduler;
    sa.sa_flags = 0;
    sa.sa_mask = mask;
    sigaction (SIGVTALRM, &sa, NULL);
    atexit(dthread_cleanup);
    start_timer(&timer);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x18, %edi
callq 0x10c0
movq %rax, 0x3e7c(%rip)      # 0x50b8
movl $0x100, %edi            # imm = 0x100
callq 0x10c0
movq %rax, 0x3e73(%rip)      # 0x50c0
movq 0x3e64(%rip), %rdi      # 0x50b8
callq 0x1a40
movq 0x3e68(%rip), %rcx      # 0x50c8
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x3e5a(%rip)      # 0x50c8
movq 0x3e4b(%rip), %rax      # 0x50c0
movq %rcx, (%rax)
movq 0x3e41(%rip), %rax      # 0x50c0
movl $0x2, 0xc(%rax)
movq 0x3e33(%rip), %rax      # 0x50c0
movl $0x1, 0x8(%rax)
movq 0x3e25(%rip), %rax      # 0x50c0
movq $0x0, 0x18(%rax)
movq 0x3e16(%rip), %rax      # 0x50c0
movq $0x0, 0x20(%rax)
movq 0x3e07(%rip), %rax      # 0x50c0
movq $0x0, 0x28(%rax)
movq 0x3df8(%rip), %rax      # 0x50c0
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
movq 0x3de7(%rip), %rdi      # 0x50c0
addq $0x30, %rdi
movl $0x1, %esi
callq 0x1100
leaq -0x118(%rbp), %rdi
callq 0x10a0
leaq -0x118(%rbp), %rdi
movl $0x1a, %esi
callq 0x1110
leaq 0x175(%rip), %rax       # 0x1480
movq %rax, -0x98(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
leaq -0x118(%rbp), %rsi
movl $0x80, %edx
callq 0x10b0
movl $0x1a, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
leaq 0x1f(%rip), %rdi        # 0x1370
callq 0x2300
leaq 0x3d73(%rip), %rdi      # 0x50d0
callq 0x13d0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_cleanup
void dthread_cleanup() {
    dthread *td;
    int count = threads->count;
    for(int i = 0; i < count; i++){
        td = dequeue(threads);
        free(td);
    }
    //final threads remove
    free(threads);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3d39(%rip), %rax      # 0x50b8
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13b8
movq 0x3d1d(%rip), %rdi      # 0x50b8
callq 0x1b00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1040
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x138c
movq 0x3cf9(%rip), %rdi      # 0x50b8
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: start_timer
void start_timer(struct itimerval *timer) {
    timer->it_value.tv_sec = 0;
    timer->it_value.tv_usec = ALARM;
    timer->it_interval.tv_sec = 0;
    timer->it_interval.tv_usec = ALARM;
    setitimer(ITIMER_VIRTUAL, timer, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x7d0, 0x18(%rax)      # imm = 0x7D0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x7d0, 0x8(%rax)       # imm = 0x7D0
movq -0x8(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: fn
void fn(void) {
    td_cur->retval = td_cur->start_routine(td_cur->args);
    td_cur->status = TERMINATED;
    raise(SIGVTALRM);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3c85(%rip), %rax      # 0x50c0
movq 0x18(%rax), %rax
movq 0x3c7a(%rip), %rcx      # 0x50c0
movq 0x20(%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq 0x3c6a(%rip), %rax      # 0x50c0
movq %rcx, 0x28(%rax)
movq 0x3c5f(%rip), %rax      # 0x50c0
movl $0x3, 0xc(%rax)
movl $0x1a, %edi
callq 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: scheduler
void scheduler(int sig) {
    stop_timer(&timer);
    dthread_t temp_tid = td_cur->tid;
    if(sigsetjmp(td_cur->context, 1) == 1) {
        return;
    }
    
    enqueue(threads, td_cur);
    if(td_cur->status == RUNNING) {
        td_cur->status = READY;
    }

    //getting the next thread details:
    //in loop, to check if the thread is already terminated or not
    dthread *temp;
    int threads_count = threads->count;
    for(int i = 0; i < threads_count; i++) {
        temp = dequeue(threads);
        if(temp->status == READY) {
            td_cur = temp;
            td_cur->status = RUNNING;
            break;
        }
        else if(temp->status == TERMINATED) {
            enqueue(threads, temp);
        }
    }
    if(td_cur->tid == temp_tid) {
        exit(0);
    }
    if(td_cur->signal != -1) {
        raise(td_cur->signal);
        td_cur->signal = -1;
    }

    start_timer(&timer);
    siglongjmp(td_cur->context, 1);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x3c3e(%rip), %rdi      # 0x50d0
callq 0x15e0
movq 0x3c22(%rip), %rax      # 0x50c0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x3c14(%rip), %rdi      # 0x50c0
addq $0x30, %rdi
movl $0x1, %esi
callq 0x1100
cmpl $0x1, %eax
jne 0x14c5
addq $0x20, %rsp
popq %rbp
retq
movq 0x3bec(%rip), %rdi      # 0x50b8
movq 0x3bed(%rip), %rsi      # 0x50c0
callq 0x1a70
movq 0x3be1(%rip), %rax      # 0x50c0
cmpl $0x2, 0xc(%rax)
jne 0x14f3
movq 0x3bd4(%rip), %rax      # 0x50c0
movl $0x1, 0xc(%rax)
movq 0x3bbe(%rip), %rax      # 0x50b8
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x156d
movq 0x3ba2(%rip), %rdi      # 0x50b8
callq 0x1b00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x1544
movq -0x18(%rbp), %rax
movq %rax, 0x3b8c(%rip)      # 0x50c0
movq 0x3b85(%rip), %rax      # 0x50c0
movl $0x2, 0xc(%rax)
jmp 0x156d
movq -0x18(%rbp), %rax
cmpl $0x3, 0xc(%rax)
jne 0x155e
movq 0x3b63(%rip), %rdi      # 0x50b8
movq -0x18(%rbp), %rsi
callq 0x1a70
jmp 0x1560
jmp 0x1562
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1507
movq 0x3b4c(%rip), %rax      # 0x50c0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x1584
xorl %edi, %edi
callq 0x10f0
movq 0x3b35(%rip), %rax      # 0x50c0
cmpl $-0x1, 0xf8(%rax)
je 0x15b7
movq 0x3b25(%rip), %rax      # 0x50c0
movl 0xf8(%rax), %edi
callq 0x1030
movq 0x3b13(%rip), %rax      # 0x50c0
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
leaq 0x3b12(%rip), %rdi      # 0x50d0
callq 0x13d0
movq 0x3af6(%rip), %rdi      # 0x50c0
addq $0x30, %rdi
movl $0x1, %esi
callq 0x1080
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: stop_timer
void stop_timer(struct itimerval *timer) {
    timer->it_value.tv_sec = 0;
    timer->it_value.tv_usec = 0;
    timer->it_interval.tv_sec = 0;
    timer->it_interval.tv_usec = 0;
    setitimer(ITIMER_VIRTUAL, timer, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: i64_ptr_mangle
static long int i64_ptr_mangle(long int p) {
    long int ret;
    asm(" mov %1, %%rax;\n"
        " xor %%fs:0x30, %%rax;"
        " rol $0x11, %%rax;"
        " mov %%rax, %0;"
        : "=r"(ret)
        : "r"(p)
        : "%rax"
    );
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, %rax
xorq %fs:0x30, %rax
rolq $0x11, %rax
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_join
int dthread_join(dthread_t thread, void **retval) {

    //find the node having that particular thread id
    
    dthread *temp;
    if(thread == td_cur->tid) {
        return EDEADLK;
    }
    temp = get_node_by_tid(threads,thread);
    if(temp == NULL) {
        return ESRCH;
    }

    //check if the thread is already joined or not
    if(temp->state == JOINED) {
        return EINVAL;
    }
    temp->state = JOINED;

    //othewise loop until the process is terminated
    while(1) {
        if (temp->status == TERMINATED) {
            break;
        }
    }
    //updating the retval  with the routine return value
    if(retval) {
        *retval = temp->retval;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38a5(%rip), %rcx      # 0x50c0
cmpq (%rcx), %rax
jne 0x1829
movl $0x23, -0x4(%rbp)
jmp 0x1896
movq 0x3888(%rip), %rdi      # 0x50b8
movq -0x10(%rbp), %rsi
callq 0x1c00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x184d
movl $0x3, -0x4(%rbp)
jmp 0x1896
movq -0x20(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x1860
movl $0x16, -0x4(%rbp)
jmp 0x1896
movq -0x20(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpl $0x3, 0xc(%rax)
jne 0x1877
jmp 0x1879
jmp 0x186b
cmpq $0x0, -0x18(%rbp)
je 0x188f
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/many-one/dthread.c
// Function: dthread_exit
void dthread_exit(void *retval) {
    // changing the retval for the current running thread.
    td_cur->retval = retval;
    td_cur->status = TERMINATED;
    
    //raising the signal to call the scheduler 
    raise(SIGVTALRM);
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq 0x3809(%rip), %rax      # 0x50c0
movq %rcx, 0x28(%rax)
movq 0x37fe(%rip), %rax      # 0x50c0
movl $0x3, 0xc(%rax)
movl $0x1a, %edi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)