LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceTypeDeclarationB
int ReduceTypeDeclarationB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* type1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(type1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a30
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2a3c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a50
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2a5c
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceGstmtC
int ReduceGstmtC(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 4);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* type1 = node->children[2];
    SYNTAX_TREE* block1 = node->children[3];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(type1));
    error = (error ? error : ProcessNode(block1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2ac0
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2acc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2ae0
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2aec
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2b00
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x2b0c
movq -0x20(%rbp), %rdi
callq 0x2260
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceGstmtD
int ReduceGstmtD(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 7);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* param_1 = node->children[2];
    SYNTAX_TREE* type1 = node->children[5];
    SYNTAX_TREE* block1 = node->children[6];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(param_1));
    error = (error ? error : ProcessNode(type1));
    error = (error ? error : ProcessNode(block1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2b80
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x2b8c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2ba0
movl -0x2c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x2bac
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2bc0
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x2bcc
movq -0x20(%rbp), %rdi
callq 0x2260
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x2be0
movl -0x2c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x2bec
movq -0x28(%rbp), %rdi
callq 0x2260
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceParamStarB
int ReduceParamStarB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 5);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* type1 = node->children[2];
    SYNTAX_TREE* param_1 = node->children[4];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(type1));
    error = (error ? error : ProcessNode(param_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2cd0
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x2cdc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2cf0
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2cfc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x2d10
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x2d1c
movq -0x20(%rbp), %rdi
callq 0x2260
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceBlockA
int ReduceBlockA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* fstmt1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(fstmt1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2d80
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2d8c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceBlockB
int ReduceBlockB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* fstmt_1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(fstmt_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2dd1
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x2ddd
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtStarA
int ReduceFstmtStarA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* fstmt1 = node->children[0];
    SYNTAX_TREE* fstmt_1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(fstmt1));
    error = (error ? error : ProcessNode(fstmt_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2eb0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2ebc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2ed0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2edc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtB
int ReduceFstmtB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 4);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* expr1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(expr1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2fa0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2fac
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2fc0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2fcc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtC
int ReduceFstmtC(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 7);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* expr1 = node->children[2];
    SYNTAX_TREE* expr2 = node->children[5];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(expr1));
    error = (error ? error : ProcessNode(expr2));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3030
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x303c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3050
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x305c
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3070
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x307c
movq -0x20(%rbp), %rdi
callq 0x2260
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtD
int ReduceFstmtD(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* expr1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(expr1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x30c0
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x30cc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtE
int ReduceFstmtE(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 6);
    SYNTAX_TREE* expr1 = node->children[2];
    SYNTAX_TREE* block1 = node->children[4];
    SYNTAX_TREE* else1 = node->children[5];

    int error = 0;
    error = (error ? error : ProcessNode(expr1));
    error = (error ? error : ProcessNode(block1));
    error = (error ? error : ProcessNode(else1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3131
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x313d
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3151
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x315d
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x3171
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x317d
movq -0x20(%rbp), %rdi
callq 0x2260
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceElseA
int ReduceElseA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* block1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(block1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x31c1
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x31cd
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtF
int ReduceFstmtF(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 5);
    SYNTAX_TREE* expr1 = node->children[2];
    SYNTAX_TREE* block1 = node->children[4];

    int error = 0;
    error = (error ? error : ProcessNode(expr1));
    error = (error ? error : ProcessNode(block1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3241
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x324d
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3261
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x326d
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFstmtJ
int ReduceFstmtJ(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* expr1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(expr1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3311
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x331d
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceArgStarB
int ReduceArgStarB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* expr1 = node->children[0];
    SYNTAX_TREE* arg_1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(expr1));
    error = (error ? error : ProcessNode(arg_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x33c0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x33cc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x33e0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x33ec
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceExpr
int ReduceExpr(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* condition1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(condition1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3450
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x345c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceConditionA
int ReduceConditionA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* condition1 = node->children[0];
    SYNTAX_TREE* logic1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(condition1));
    error = (error ? error : ProcessNode(logic1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x34b0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x34bc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x34d0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x34dc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceLogicA
int ReduceLogicA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* comparison1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(comparison1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x35f1
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x35fd
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceLogicB
int ReduceLogicB(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* comparison1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(comparison1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3640
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x364c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceComparisonA
int ReduceComparisonA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* comparison1 = node->children[0];
    SYNTAX_TREE* arithmetic1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(comparison1));
    error = (error ? error : ProcessNode(arithmetic1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x36a0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x36ac
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x36c0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x36cc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceComparisonG
int ReduceComparisonG(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* arithmetic1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(arithmetic1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3990
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x399c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceArithmeticA
int ReduceArithmeticA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* arithmetic1 = node->children[0];
    SYNTAX_TREE* term1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(arithmetic1));
    error = (error ? error : ProcessNode(term1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x39f0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x39fc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3a10
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3a1c
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceArithmeticC
int ReduceArithmeticC(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* term1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(term1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3ae0
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3aec
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceTermA
int ReduceTermA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* term1 = node->children[0];
    SYNTAX_TREE* factor1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(term1));
    error = (error ? error : ProcessNode(factor1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3b40
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3b4c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3b60
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3b6c
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceTermD
int ReduceTermD(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* factor1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(factor1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3cb0
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3cbc
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFactorA
int ReduceFactorA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 2);
    SYNTAX_TREE* factor1 = node->children[1];

    int error = 0;
    error = (error ? error : ProcessNode(factor1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3d01
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3d0d
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFinalC
int ReduceFinalC(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 4);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* expr1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(expr1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3ea0
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3eac
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3ec0
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3ecc
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFinalD
int ReduceFinalD(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 4);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* arg_1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(arg_1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3f20
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3f2c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3f40
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3f4c
movq -0x18(%rbp), %rdi
callq 0x2260
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFinalE
int ReduceFinalE(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* integer1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(integer1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3f90
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x3f9c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceFinalG
int ReduceFinalG(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 1);
    SYNTAX_TREE* boolean1 = node->children[0];

    int error = 0;
    error = (error ? error : ProcessNode(boolean1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4030
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x403c
movq -0x10(%rbp), %rdi
callq 0x2260
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/generator.c
// Function: EmitCodeLibrary
int EmitCodeLibrary(FILE* output)
{
    FILE* input;

    input = fopen("library.s", "rb");
    if (input == NULL)
    {
        return 1;
    }

    fclose(input);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x7035(%rip), %rdi      # 0xb138
leaq 0x7038(%rip), %rsi      # 0xb142
callq 0x2100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4123
movl $0x1, -0x4(%rbp)
jmp 0x4133
movq -0x18(%rbp), %rdi
callq 0x2050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/generator.c
// Function: OutputProgram
int OutputProgram(const char* destination)
{
    FILE* output;
    int nbytes;

    output = fopen(destination, "wb");
    if (output == NULL)
    {
        return 1;
    }

    nbytes = 8 * VariableCount(gPrgrmVariables);
    fprintf(output, "# Program assembly from min comp\r\n");
    fprintf(output, "# Target: 32-bit Unix assembly\r\n");
    fprintf(output, ".global main\r\n");
    fprintf(output, "\r\n");
    fprintf(output, ".data\r\n");
    fprintf(output, "static_heap:\r\n");
    fprintf(output, ".space %i, 0\r\n", nbytes);
    fprintf(output, "\r\n");
    /* output static strings and static data */

    fprintf(output, ".text\r\n");

    EmitCodeMain(output);
    EmitCodeLibrary(output);
    EmitCodeProgram(output);

    fprintf(output, "# End Of Assembly\r\n");
    fprintf(output, "\r\n");
    fclose(output);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6fee(%rip), %rsi      # 0xb145
callq 0x2100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4173
movl $0x1, -0x4(%rbp)
jmp 0x427c
leaq 0x181e6(%rip), %rax     # 0x1c360
movq (%rax), %rdi
callq 0x91e0
shll $0x3, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6fb5(%rip), %rsi      # 0xb148
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6fc6(%rip), %rsi      # 0xb16b
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6fd5(%rip), %rsi      # 0xb18c
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6ff5(%rip), %rsi      # 0xb1be
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6fc0(%rip), %rsi      # 0xb19b
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6fb6(%rip), %rsi      # 0xb1a3
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x6fb0(%rip), %rsi      # 0xb1b2
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6faa(%rip), %rsi      # 0xb1be
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6f9b(%rip), %rsi      # 0xb1c1
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x40b0
movq -0x18(%rbp), %rdi
callq 0x40f0
movq -0x18(%rbp), %rdi
callq 0x40e0
movq -0x18(%rbp), %rdi
leaq 0x6f76(%rip), %rsi      # 0xb1c9
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
leaq 0x6f59(%rip), %rsi      # 0xb1be
movb $0x0, %al
callq 0x20c0
movq -0x18(%rbp), %rdi
callq 0x2050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/grammar.c
// Function: GetElement
char* GetElement(int i, GRAMMAR_TABLE grammar)
{
    char* search;
    char* end;
    int   index;

    if (i & K_SYMBOL) {
        search = grammar.symbols;
        end = grammar.symbols + SYMBOL_BUFFER_SIZE;
        i ^= K_SYMBOL;
    } else if (i & K_TOKEN) {
        search = grammar.tokens;
        end = grammar.tokens + TOKEN_BUFFER_SIZE;
        i ^= K_TOKEN;
    } else {
        return 0;
    }

    index = 1;
    while (index < i &&
           search < end)
    {
        while (search[0] != 0 && search != end)
            search++;
        search++;
        index++;
    }

    if (search < end)
        return search;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x42d3
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
xorl $0x1000, %eax           # imm = 0x1000
movl %eax, -0xc(%rbp)
jmp 0x4316
movl -0xc(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x4307
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
xorl $0x2000, %eax           # imm = 0x2000
movl %eax, -0xc(%rbp)
jmp 0x4314
movq $0x0, -0x8(%rbp)
jmp 0x43ac
jmp 0x4316
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %ecx
xorl %eax, %eax
cmpl -0xc(%rbp), %ecx
movb %al, -0x31(%rbp)
jge 0x4338
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4341
jmp 0x4390
jmp 0x4343
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
je 0x4362
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x436b
jmp 0x4379
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4343
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x431d
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x43a4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x43ac
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/grammar.c
// Function: GetRule
RULE* GetRule(int lhs, int n, GRAMMAR_TABLE grammar)
{
    int r;
    for (r = 0; r < grammar.numRules; r++)
    {
        if (grammar.rules[r].lhs == lhs) {
            if (n == 0)
                return grammar.rules + r;
            n--;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x20(%rcx), %eax
jge 0x4434
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x4427
cmpl $0x0, -0x10(%rbp)
jne 0x441e
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x443c
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4429
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43d9
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/grammar.c
// Function: FindToken
int FindToken(char*          string,
              int            len,
              GRAMMAR_TABLE  grammar)
{
    int   j;
    char* search = grammar.tokens;
    char* end = grammar.tokens + TOKEN_BUFFER_SIZE;
    int   index = 1;
    while (index <= grammar.numTokens &&
           search < end)
    {
        for (j = 0; j < len; j++)
        {
            if (string[j] == '\\') j++;
#ifdef CASE_SENSITIVE_KEYWORDS
            if (string[j] != search[j])
                break;
#else
            if (toupper(string[j]) != toupper(search[j]))
                break;
#endif
        }
        if (j == len && search[j] == 0)
        {
            return index | K_TOKEN;
        }
        while (search[0] != 0 && search != end)
            search++;
        search++;
        index++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x18(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x18(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x38(%rbp), %rdx
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl 0x10(%rdx), %ecx
movb %al, -0x39(%rbp)
jg 0x481f
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x482b
jmp 0x48f7
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x487f
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x4854
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4872
jmp 0x487f
jmp 0x4874
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4832
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x48a5
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x48a5
movl -0x2c(%rbp), %eax
orl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x4(%rbp)
jmp 0x48fe
jmp 0x48a7
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x48c6
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x48cf
jmp 0x48dd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x48a7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4800
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/grammar.c
// Function: FreeGrammarTable
void FreeGrammarTable(GRAMMAR_TABLE* table)
{
    int i;

    free(table->symbols);
    free(table->tokens);
    table->numSymbols = 0;
    table->numTokens = 0;

    for (i = 0; i < table->numRules; i++)
    {
        free(table->rules[i].rhs);
    }
    free(table->rules);
    table->numRules = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x4985
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4952
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/lexer.c
// Function: LexAddBlock
void LexAddBlock(L_TOKEN** start,
                 L_TOKEN** end,
                 L_TOKEN*  next)
{
    if (next) {
        if (next->string)
        {
            // use null terminated strings
            char* buffer = (char*)malloc(sizeof(char) * (next->length + 1));
            int i;
#ifdef CASE_SENSITIVE
            for (i = 0; i < next->length; i++)
                buffer[i] = next->string[i];
#else
            if (next->token == gSymbolIdentifier) {
                for (i = 0; i < next->length; i++)
                    buffer[i] = tolower(next->string[i]);
            } else {
                for (i = 0; i < next->length; i++)
                    buffer[i] = next->string[i];
            }
#endif
            buffer[i] = '\0';
            next->string = buffer;
        }

        if (*start)
            (*end)->next = next;
        else
            *start = next;
        *end = next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5b55
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5b24
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x20e0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x5b0c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5adb
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5b3f
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x5b4a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/lexer.c
// Function: EOFSYMBOL
L_TOKEN* EOFSYMBOL(int line)
{
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    // end of file
    block->token = gSymbolEOF;
    block->string = 0;
    block->length = 0;
    block->line = line;
    block->next = 0;

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
leaq 0x9528(%rip), %rax      # 0xf0a8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/lexer.c
// Function: NEWLINE
L_TOKEN* NEWLINE(int line)
{
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    // end line
    block->token = gSymbolEndLine;
    block->string = 0;
    block->length = 0;
    block->line = line;
    block->next = 0;

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x10(%rbp)
leaq 0x94cc(%rip), %rax      # 0xf0ac
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/lexer.c
// Function: INTEGER
L_TOKEN* INTEGER(char* source,
                 int   start,
                 int   end,
                 int   line)
{
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    // number
    block->token = gSymbolInteger;
    block->string = source + start;
    block->length = end - start;
    block->line = line;
    block->next = 0;

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
leaq 0x9466(%rip), %rax      # 0xf0b0
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)