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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x2411
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceStringListA
int ReduceStringListA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* string1 = node->children[0];
    SYNTAX_TREE* string_list1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(string1));
    error = (error ? error : ProcessNode(string_list1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x245a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/autostubs.c
// Function: ReduceTypeDeclarationA
int ReduceTypeDeclarationA(SYNTAX_TREE* node)
{
    Assert(node->numChildren == 3);
    SYNTAX_TREE* identifier1 = node->children[0];
    SYNTAX_TREE* type_declaration1 = node->children[2];

    int error = 0;
    error = (error ? error : ProcessNode(identifier1));
    error = (error ? error : ProcessNode(type_declaration1));

    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x24ab
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x24da
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %r14
movq 0x18(%rax), %rbx
callq 0x224d
testl %eax, %eax
jne 0x250f
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x2518
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %r15
movq 0x28(%rax), %r14
movq 0x30(%rax), %rbx
callq 0x224d
testl %eax, %eax
jne 0x2552
movq %r15, %rdi
callq 0x224d
testl %eax, %eax
jne 0x255e
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x256d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %r14
movq 0x20(%rax), %rbx
callq 0x224d
testl %eax, %eax
jne 0x25d5
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x25de
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x269e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %r14
movq 0x28(%rax), %rbx
callq 0x224d
testl %eax, %eax
jne 0x26d3
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x26dc
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %r14
movq 0x28(%rax), %rbx
callq 0x224d
testl %eax, %eax
jne 0x2721
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x272a
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x2772
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x27dc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x28b6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rbx
callq 0x224d
testl %eax, %eax
je 0x2b75
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x54ff(%rip), %rsi      # 0x8145
callq 0x2120
testq %rax, %rax
je 0x2da2
movq %rax, %rbx
leaq 0x16712(%rip), %rax     # 0x19370
movq (%rax), %rdi
callq 0x633a
leal (,%rax,8), %r15d
leaq 0x54d3(%rip), %rdi      # 0x8148
movl $0x22, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x54dd(%rip), %rdi      # 0x816b
movl $0x20, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x54e5(%rip), %rdi      # 0x818c
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x54fe(%rip), %r14      # 0x81be
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2130
leaq 0x54bf(%rip), %rdi      # 0x819b
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x54ae(%rip), %rdi      # 0x81a3
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x54a4(%rip), %rsi      # 0x81b2
xorl %r12d, %r12d
movq %rbx, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x20e0
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2130
leaq 0x5487(%rip), %rdi      # 0x81c1
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
leaq 0x53dd(%rip), %rdi      # 0x8130
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
callq 0x2c05
leaq 0x5458(%rip), %rdi      # 0x81c9
movl $0x13, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2130
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x2130
movq %rbx, %rdi
callq 0x2070
jmp 0x2da8
movl $0x1, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
btl $0xc, %edi
jb 0x2dc3
btl $0xd, %edi
jb 0x2dcf
xorl %eax, %eax
retq
movl $0xffffefff, %eax       # imm = 0xFFFFEFFF
movl $0x8, %ecx
jmp 0x2dd9
movl $0xffffcfff, %eax       # imm = 0xFFFFCFFF
movl $0x18, %ecx
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
andl %edi, %eax
movq (%rdx,%rcx), %rcx
cmpl $0x2, %eax
jl 0x2e2c
movl $0x1, %esi
xorl %edx, %edx
movq %rdx, %rdi
leaq 0x1(%rdi), %rdx
cmpq $0x1000, %rdi           # imm = 0x1000
je 0x2e0c
cmpb $0x0, (%rcx,%rdi)
movq %rdx, %rdi
jne 0x2df6
incl %esi
leaq -0x1(%rdx), %r8
cmpq $0xfff, %r8             # imm = 0xFFF
setl %dil
cmpl %eax, %esi
jge 0x2e31
cmpq $0xfff, %r8             # imm = 0xFFF
jl 0x2df3
jmp 0x2e31
movb $0x1, %dil
xorl %edx, %edx
addq %rdx, %rcx
xorl %eax, %eax
testb %dil, %dil
cmovneq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq 0x30(%rbp), %rcx
testq %rcx, %rcx
jle 0x2e67
leaq 0x10(%rbp), %rax
movq 0x28(%rax), %rax
cmpl %edi, (%rax)
jne 0x2e5e
testl %esi, %esi
je 0x2e69
decl %esi
addq $0x10, %rax
decq %rcx
jne 0x2e54
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/grammar.c
// Function: AddSymbol
int AddSymbol(char*          string,
              int            len,
              GRAMMAR_TABLE* grammar)
{
    int   j;
    char* search = grammar->symbols;
    char* end = grammar->symbols + SYMBOL_BUFFER_SIZE;
    int   index = 1;
    while (index <= grammar->numSymbols &&
           search < end)
    {
        for (j = 0; j < len; j++)
        {
            if (string[j] != search[j])
                break;
        }
        if (j == len && search[j] == 0)
        {
            return index | K_SYMBOL;
        }
        while (search[0] != 0 && search != end)
            search++;
        search++;
        index++;
    }

    if (search < end)
    {
        for (j = 0; j < len && search < end; j++)
        {
            search[0] = string[j];
            search++;
        }
        search[0] = 0;
        grammar->numSymbols++;
        return index | K_SYMBOL;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdx), %rcx
movl (%rdx), %r9d
xorl %eax, %eax
movl %esi, %r8d
testl %r9d, %r9d
jle 0x2f19
movl $0x1, %r11d
xorl %r14d, %r14d
movq %rcx, %r15
movl $0x0, %r10d
testl %esi, %esi
jle 0x2ebb
xorl %r10d, %r10d
movb (%rdi,%r10), %bl
cmpb (%r15,%r10), %bl
jne 0x2ebb
incq %r10
cmpq %r10, %r8
jne 0x2ea6
movl %r8d, %r10d
cmpl %esi, %r10d
jne 0x2ece
movl %r10d, %r10d
cmpb $0x0, (%r15,%r10)
je 0x2f73
leaq 0x1(%r14), %rbx
cmpq $0x1000, %r14           # imm = 0x1000
je 0x2ee5
cmpb $0x0, (%rcx,%r14)
movq %rbx, %r14
jne 0x2ece
leal 0x1(%r11), %r10d
leaq -0x1(%rbx), %r13
cmpq $0xfff, %r13            # imm = 0xFFF
setl %r12b
cmpl %r9d, %r11d
jge 0x2f10
leaq (%rcx,%rbx), %r15
movl %r10d, %r11d
movq %rbx, %r14
cmpq $0xfff, %r13            # imm = 0xFFF
jl 0x2e99
orl $0x1000, %r10d          # imm = 0x1000
jmp 0x2f24
movb $0x1, %r12b
movl $0x1001, %r10d          # imm = 0x1001
xorl %ebx, %ebx
testb %r12b, %r12b
je 0x2f7d
addq %rbx, %rcx
testl %esi, %esi
setg %al
cmpq $0x1000, %rbx           # imm = 0x1000
setl %sil
andb %al, %sil
cmpb $0x1, %sil
jne 0x2f69
xorl %eax, %eax
movb (%rdi,%rax), %sil
movb %sil, (%rcx,%rax)
leaq 0x1(%rax), %rsi
cmpq %r8, %rsi
jae 0x2f66
addq %rbx, %rax
cmpq $0xfff, %rax            # imm = 0xFFF
movq %rsi, %rax
jl 0x2f47
addq %rsi, %rcx
movb $0x0, (%rcx)
incl (%rdx)
movl %r10d, %eax
jmp 0x2f7d
orl $0x1000, %r11d          # imm = 0x1000
movl %r11d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/grammar.c
// Function: AddToken
int AddToken(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++;
            if (string[j] != search[j])
                break;
        }
        if (j == len && search[j] == 0)
        {
            return index | K_TOKEN;
        }
        while (search[0] != 0 && search != end)
            search++;
        search++;
        index++;
    }

    if (search < end)
    {
        for (j = 0; j < len && search < end; j++)
        {
            if (string[j] == '\\') j++;
            search[0] = string[j];
            search++;
        }
        search[0] = 0;
        grammar->numTokens++;
        return index | K_TOKEN;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x18(%rdx), %rcx
movl 0x10(%rdx), %r9d
xorl %eax, %eax
testl %r9d, %r9d
jle 0x3046
movl $0x1, %r11d
xorl %ebx, %ebx
movq %rcx, %r14
movl $0x0, %r8d
testl %esi, %esi
jle 0x2fe5
xorl %r8d, %r8d
movslq %r8d, %r8
xorl %r10d, %r10d
cmpb $0x5c, (%rdi,%r8)
sete %r10b
addl %r10d, %r8d
movslq %r8d, %r10
movb (%rdi,%r10), %r15b
cmpb (%r14,%r10), %r15b
jne 0x2fe5
incl %r8d
cmpl %esi, %r8d
jl 0x2fbe
cmpl %esi, %r8d
jne 0x2ff8
movslq %r8d, %r8
cmpb $0x0, (%r14,%r8)
je 0x30ac
leaq 0x1(%rbx), %r10
cmpq $0x1000, %rbx           # imm = 0x1000
je 0x300e
cmpb $0x0, (%rcx,%rbx)
movq %r10, %rbx
jne 0x2ff8
leal 0x1(%r11), %r8d
leaq -0x1(%r10), %r12
cmpq $0xfff, %r12            # imm = 0xFFF
setl %r15b
cmpl %r9d, %r11d
jge 0x303d
leaq (%rcx,%r10), %r14
movl %r8d, %r11d
movq %r10, %rbx
cmpq $0xfff, %r12            # imm = 0xFFF
jl 0x2fb1
orl $0x2000, %r8d           # imm = 0x2000
jmp 0x3052
movb $0x1, %r15b
movl $0x2001, %r8d           # imm = 0x2001
xorl %r10d, %r10d
testb %r15b, %r15b
je 0x30c4
testl %esi, %esi
setg %al
cmpq $0x1000, %r10           # imm = 0x1000
setl %r9b
andb %al, %r9b
cmpb $0x1, %r9b
jne 0x30b8
xorl %eax, %eax
cltq
xorl %r11d, %r11d
cmpb $0x5c, (%rdi,%rax)
sete %r11b
leal (%rax,%r11), %r9d
movslq %r9d, %r9
movb (%rdi,%r9), %r9b
movb %r9b, (%rcx,%r10)
leaq 0x1(%r10), %r9
addl %r11d, %eax
incl %eax
cmpl %esi, %eax
jge 0x30a7
cmpq $0xfff, %r10            # imm = 0xFFF
movq %r9, %r10
jl 0x3072
addq %r9, %rcx
jmp 0x30bb
orl $0x2000, %r11d          # imm = 0x2000
movl %r11d, %eax
jmp 0x30c4
addq %r10, %rcx
movb $0x0, (%rcx)
incl 0x10(%rdx)
movl %r8d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
movl 0x20(%rbp), %ecx
testl %ecx, %ecx
jle 0x3158
movq 0x28(%rbp), %r8
movl $0x1, %edx
xorl %r9d, %r9d
movq %r8, %r10
movl $0x0, %eax
testl %esi, %esi
jle 0x3116
xorl %eax, %eax
cltq
xorl %r11d, %r11d
cmpb $0x5c, (%rdi,%rax)
sete %r11b
addl %r11d, %eax
movslq %eax, %r11
movb (%rdi,%r11), %bl
cmpb (%r10,%r11), %bl
jne 0x3116
incl %eax
cmpl %esi, %eax
jl 0x30f3
cmpl %esi, %eax
jne 0x3123
cltq
cmpb $0x0, (%r10,%rax)
je 0x315c
leaq 0x1(%r9), %r11
cmpq $0x1000, %r9            # imm = 0x1000
je 0x313a
cmpb $0x0, (%r8,%r9)
movq %r11, %r9
jne 0x3123
xorl %eax, %eax
cmpl %ecx, %edx
jge 0x3164
incl %edx
leaq (%r8,%r11), %r10
leaq -0x1(%r11), %rbx
movq %r11, %r9
cmpq $0xfff, %rbx            # imm = 0xFFF
jl 0x30e8
jmp 0x3164
xorl %eax, %eax
jmp 0x3164
orl $0x2000, %edx           # imm = 0x2000
movl %edx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2030
movq 0x18(%rbx), %rdi
callq 0x2030
xorl %eax, %eax
movl %eax, (%rbx)
movl %eax, 0x10(%rbx)
cmpl %eax, 0x20(%rbx)
jle 0x31b8
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2030
incq %r15
movslq 0x20(%rbx), %rax
addq $0x10, %r14
cmpq %rax, %r15
jl 0x319b
movq 0x28(%rbx), %rdi
callq 0x2030
movl $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdx, %rdx
je 0x3cb5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %r12
testq %r12, %r12
je 0x3c94
movslq 0x10(%rbx), %r13
leaq 0x1(%r13), %rdi
callq 0x2100
xorl %ecx, %ecx
testq %r13, %r13
jle 0x3c8c
movb (%r12,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r13
jne 0x3c7d
movb $0x0, (%rax,%rcx)
movq %rax, 0x8(%rbx)
cmpq $0x0, (%r15)
je 0x3ca1
movq (%r14), %r15
addq $0x18, %r15
movq %rbx, (%r15)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x20, %edi
callq 0x2100
leaq 0x83e9(%rip), %rcx      # 0xc0b8
movl (%rcx), %ecx
movl %ecx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x20, %edi
callq 0x2100
leaq 0x83b5(%rip), %rcx      # 0xc0bc
movl (%rcx), %ecx
movl %ecx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq %rcx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x20, %edi
callq 0x2100
leaq 0x8373(%rip), %rcx      # 0xc0c0
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq %r15d, %rcx
addq %rcx, %r12
movq %r12, 0x8(%rax)
subl %ecx, %r14d
movl %r14d, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: FLOAT
L_TOKEN* FLOAT(char* source,
               int   start,
               int   end,
               int   line)
{
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));
    
    // floating-point number
    block->token = gSymbolFloat;
    block->string = source + start;
    block->length = end - start;
    block->line = line;
    block->next = 0;

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x20, %edi
callq 0x2100
leaq 0x8327(%rip), %rcx      # 0xc0c4
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq %r15d, %rcx
addq %rcx, %r12
movq %r12, 0x8(%rax)
subl %ecx, %r14d
movl %r14d, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: STRING
L_TOKEN* STRING(char*         source,
                int           start,
                int           end,
                int           line)
{
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    // string
    block->token = gSymbolString;
    block->string = source + start + 1;
    block->length = end - start - 2;
    block->line = line;
    block->next = 0;

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movl $0x20, %edi
callq 0x2100
leaq 0x82db(%rip), %rcx      # 0xc0c8
movl (%rcx), %ecx
movl %ecx, (%rax)
movslq %r15d, %rcx
leaq (%r12,%rcx), %rdx
incq %rdx
movq %rdx, 0x8(%rax)
subl %ecx, %r14d
addl $-0x2, %r14d
movl %r14d, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: TOKEN
L_TOKEN* TOKEN(char*          source,
               int            start,
               int            end,
               int            line,
               GRAMMAR_TABLE  grammar)
{
    int token;
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    token = FindToken(&source[start], end - start, grammar);
    if (token) {
        // token
        block->token = token;
        block->string = source + start;
        block->length = end - start;
        block->line = line;
        block->next = 0;
    } else {
        // identifier
        free(block);
        block = NULL;
        printf("Syntax error on line %i, ", line+1);
        printf("Error, illegal identifier: ");
        while (start < end)
            printf("0x%X", source[start++]);
        printf("\n");
    }

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x20, %edi
callq 0x2100
movq %rax, %r13
movl %r15d, -0x2c(%rbp)
movslq %r15d, %rax
addq %rax, %rbx
movl %r14d, %r15d
subl %eax, %r15d
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movaps 0x30(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x30cd
testl %eax, %eax
je 0x3e9b
movl %eax, (%r13)
movq %rbx, 0x8(%r13)
movl %r15d, 0x10(%r13)
movl %r12d, 0x14(%r13)
movq $0x0, 0x18(%r13)
jmp 0x3ef9
movq %r13, %rdi
callq 0x2030
incl %r12d
leaq 0x463f(%rip), %rdi      # 0x84ec
movl %r12d, %esi
xorl %eax, %eax
callq 0x2090
leaq 0x4648(%rip), %rdi      # 0x8506
xorl %eax, %eax
callq 0x2090
subl -0x2c(%rbp), %r14d
jle 0x3eec
leaq 0x4650(%rip), %r15      # 0x8522
xorl %r12d, %r12d
movsbl (%rbx,%r12), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2090
incq %r12
cmpl %r12d, %r14d
jne 0x3ed5
movl $0xa, %edi
callq 0x2040
xorl %r13d, %r13d
movq %r13, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: IDENTIFIER
L_TOKEN* IDENTIFIER(char*          source,
                    int            start,
                    int            end,
                    int            line,
                    GRAMMAR_TABLE  grammar)
{
    int token;
    L_TOKEN* block = (L_TOKEN*)malloc(sizeof(L_TOKEN));

    token = FindToken(&source[start], end - start, grammar);
    if (token) {
        // token
        block->token = token;
        block->string = source + start;
        block->length = end - start;
        block->line = line;
        block->next = 0;
    } else {
        // identifier
        block->token = gSymbolIdentifier;
        block->string = source + start;
        block->length = end - start;
        block->line = line;
        block->next = 0;
    }

    return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r13d
movq %rdi, %r15
movl $0x20, %edi
callq 0x2100
movq %rax, %r12
movslq %r13d, %rax
addq %rax, %r15
subl %eax, %r14d
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
movaps 0x30(%rbp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movl %r14d, %esi
callq 0x30cd
testl %eax, %eax
jne 0x3f6f
leaq 0x815f(%rip), %rax      # 0xc0cc
movl (%rax), %eax
movl %eax, (%r12)
movq %r15, 0x8(%r12)
movl %r14d, 0x10(%r12)
movl %ebx, 0x14(%r12)
movq $0x0, 0x18(%r12)
movq %r12, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: PrintLexing
void PrintLexing(L_TOKEN* lexing)
{
    int i;
    printf("NUMBER  STRING\n");
    printf("--------------\n");
    
    while (lexing)
    {
        printf("0x%.4X  ", lexing->token);
        if (lexing->token == gSymbolString)
            printf("\"");
        for (i = 0; i < lexing->length; i++)
            printf("%c", lexing->string[i]);
        if (lexing->token == gSymbolString)
            printf("\"");
        printf("\n");
        lexing = lexing->next;
    }
    
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3cce(%rip), %rdi      # 0x8595
callq 0x2050
leaq 0x3cd1(%rip), %rdi      # 0x85a4
callq 0x2050
testq %rbx, %rbx
je 0x494f
leaq 0x3c70(%rip), %r14      # 0x8554
leaq 0x77dd(%rip), %r15      # 0xc0c8
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
movl (%rbx), %eax
cmpl (%r15), %eax
jne 0x4908
movl $0x22, %edi
callq 0x2040
cmpl $0x0, 0x10(%rbx)
jle 0x492b
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %edi
callq 0x2040
incq %r12
movslq 0x10(%rbx), %rax
cmpq %rax, %r12
jl 0x4911
movl (%rbx), %eax
cmpl (%r15), %eax
jne 0x493c
movl $0x22, %edi
callq 0x2040
movl $0xa, %edi
callq 0x2040
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x48eb
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/lexer.c
// Function: FreeLexing
void FreeLexing(L_TOKEN* lexing,
                char*    buffer)
{
    L_TOKEN* block;

    while (lexing)
    {
        block = lexing;
        lexing = lexing->next;
        if (block->string) {
            free(block->string);
        }
        free(block);
    }

    free(buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x4998
movq %rdi, %r14
movq 0x8(%r14), %rdi
movq 0x18(%r14), %r15
testq %rdi, %rdi
je 0x4988
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
testq %r15, %r15
jne 0x4976
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2030
nop
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/main.c
// Function: FreeCompiler
void FreeCompiler()
{
    SOURCE* srcItr;

    // free compiler data structures
    FreeVariableList(&gPrgrmVariables);
    FreeFunctionList(&gPrgrmFunctions);

    for (srcItr = gPrgrmSources; srcItr; srcItr = srcItr->next)
    {
        if (srcItr->lexing != NULL)
        {
            FreeLexing(srcItr->lexing, srcItr->buffer);
        }
        if (srcItr->syntax != NULL)
        {
            FreeParseTree(srcItr->syntax);
        }
    }

    FreeSourceList(&gPrgrmSources);

    // zero the pointer handles
    gPrgrmVariables = NULL;
    gPrgrmFunctions = NULL;
    gPrgrmSources = NULL;

    // clear the function table
    if (gPrgrmFunctionTable) 
    {
        unsigned int i;
        for (i = 0; i < gPrgrmFunctionCount; i++)
        {
            FreeVariableList(&gPrgrmFunctionTable[i].locals);
        }

        free(gPrgrmFunctionTable);
        gPrgrmFunctionTable = NULL;
        gPrgrmFunctionTable = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x146cf(%rip), %rbx     # 0x19370
movq %rbx, %rdi
callq 0x626c
leaq 0x146c8(%rip), %r14     # 0x19378
movq %r14, %rdi
callq 0x629e
leaq 0x146a9(%rip), %r15     # 0x19368
movq (%r15), %r12
testq %r12, %r12
je 0x4cf1
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x4cdb
movq 0x20(%r12), %rsi
callq 0x4961
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x4cea
callq 0x5055
movq 0x28(%r12), %r12
jmp 0x4cc2
movq %r15, %rdi
callq 0x623a
xorl %eax, %eax
movq %rax, (%rbx)
movq %rax, (%r14)
movq %rax, (%r15)
leaq 0x14655(%rip), %rbx     # 0x19360
cmpq %rax, (%rbx)
je 0x4d4f
leaq 0x14641(%rip), %r14     # 0x19358
cmpl $0x0, (%r14)
je 0x4d40
movl $0x18, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x626c
incq %r12
movl (%r14), %eax
addq $0x38, %r15
cmpq %rax, %r12
jb 0x4d26
movq (%rbx), %rdi
callq 0x2030
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: ActionTable
ACTION ActionTable(LR_TABLE table, int state, int token)
{
    ACTION action;
    action.type = ACTION_ERROR;

    if (token & K_TOKEN)
        token = token ^ K_TOKEN;

    if (state >= 0 && state < table.numStates
        && token > 0 && token <= table.numTokens)
    {
        action = table.actionTable[state * table.numTokens + token - 1];
    }

    return action;
}

// Assembly:
xorl %eax, %eax
testl %edi, %edi
js 0x4da0
andl $0xffffdfff, %esi       # imm = 0xFFFFDFFF
jle 0x4da0
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
movl $0x0, %ecx
cmpl %edi, 0x8(%rdx)
jle 0x4dbc
movl (%rdx), %eax
cmpl %eax, %esi
jle 0x4da4
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x4dbc
xorl %ecx, %ecx
jmp 0x4dbd
movq 0x10(%rdx), %rcx
imull %edi, %eax
addl %esi, %eax
movslq %eax, %rdx
movl -0x8(%rcx,%rdx,8), %eax
movl -0x4(%rcx,%rdx,8), %ecx
shlq $0x20, %rcx
popq %rbp
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: GotoTable
int GotoTable(LR_TABLE table, int state, int symbol)
{
    int nextState = -1;

    if (symbol & K_SYMBOL)
        symbol = symbol ^ K_SYMBOL;

    if (state >= 0 && state < table.numStates
        && symbol > 0 && symbol <= table.numSymbols)
    {
        nextState = table.gotoTable[state * table.numSymbols + symbol - 1];
    }

    return nextState;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %edi, %edi
js 0x4df7
andl $0xffffefff, %esi       # imm = 0xFFFFEFFF
jle 0x4df7
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
cmpl %edi, 0x8(%rdx)
jle 0x4df6
movl 0x4(%rdx), %ecx
cmpl %ecx, %esi
jg 0x4df6
movq 0x18(%rdx), %rax
imull %edi, %ecx
addl %esi, %ecx
movslq %ecx, %rcx
movl -0x4(%rax,%rcx,4), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: StackPushState
void StackPushState(int state)
{
    if (gParseTop) {
        gParseTop->next = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->next->prev = gParseTop;
        gParseTop = gParseTop->next;
    } else {
        gParseStack = gParseTop = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->prev = NULL;
    }
    gParseTop->next = NULL;
    gParseTop->token = NULL;
    gParseTop->type = 0;
    gParseTop->state = state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x14548(%rip), %r14     # 0x19350
movl $0x20, %edi
callq 0x2100
testq %r14, %r14
je 0x4e28
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rax)
movq %rax, 0x1452a(%rip)     # 0x19350
jmp 0x4e3e
movq %rax, 0x14521(%rip)     # 0x19350
movq %rax, 0x14512(%rip)     # 0x19348
movq $0x0, 0x18(%rax)
movq 0x1450b(%rip), %rax     # 0x19350
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movq %rcx, (%rax)
movq 0x144fb(%rip), %rax     # 0x19350
movl $0x0, 0x8(%rax)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: StackPushToken
void StackPushToken(L_TOKEN* token)
{
    if (gParseTop) {
        gParseTop->next = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->next->prev = gParseTop;
        gParseTop = gParseTop->next;
    } else {
        gParseStack = gParseTop = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->prev = NULL;
    }
    gParseTop->next = NULL;
    gParseTop->token = token;
    gParseTop->type = TOKEN_L_TOKEN;
    gParseTop->state = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x144db(%rip), %r14     # 0x19350
movl $0x20, %edi
callq 0x2100
testq %r14, %r14
je 0x4e95
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rax)
movq %rax, 0x144bd(%rip)     # 0x19350
jmp 0x4eab
movq %rax, 0x144b4(%rip)     # 0x19350
movq %rax, 0x144a5(%rip)     # 0x19348
movq $0x0, 0x18(%rax)
movq 0x1449e(%rip), %rax     # 0x19350
movq $0x0, 0x10(%rax)
movq %rbx, (%rax)
movq 0x1448c(%rip), %rax     # 0x19350
movabsq $-0xffffffff, %rcx      # imm = 0xFFFFFFFF00000001
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: StackPushTree
void StackPushTree(SYNTAX_TREE* tree)
{
    if (gParseTop) {
        gParseTop->next = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->next->prev = gParseTop;
        gParseTop = gParseTop->next;
    } else {
        gParseStack = gParseTop = (PARSE_STACK*)malloc(sizeof(PARSE_STACK));
        gParseTop->prev = NULL;
    }
    gParseTop->next = NULL;
    gParseTop->token = tree;
    gParseTop->type = TOKEN_SYNTAX_TREE;
    gParseTop->state = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x14468(%rip), %r14     # 0x19350
movl $0x20, %edi
callq 0x2100
testq %r14, %r14
je 0x4f08
movq %rax, 0x10(%r14)
movq %r14, 0x18(%rax)
movq %rax, 0x1444a(%rip)     # 0x19350
jmp 0x4f1e
movq %rax, 0x14441(%rip)     # 0x19350
movq %rax, 0x14432(%rip)     # 0x19348
movq $0x0, 0x18(%rax)
movq 0x1442b(%rip), %rax     # 0x19350
movq $0x0, 0x10(%rax)
movq %rbx, (%rax)
movq 0x14419(%rip), %rax     # 0x19350
movabsq $-0xfffffffe, %rcx      # imm = 0xFFFFFFFF00000002
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: StackPeek
PARSE_STACK StackPeek()
{
    PARSE_STACK r;
    r.token = NULL;
    r.type = 0;
    r.state = -1;
    
    if (gParseTop) {
        r = *gParseTop;
        r.next = NULL;
        r.prev = NULL;
    }
    
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq $0x0, (%rdi)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x8(%rdi)
movq 0x143e3(%rip), %rcx     # 0x19350
testq %rcx, %rcx
je 0x4f87
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: StackPop
PARSE_STACK StackPop()
{
    PARSE_STACK r;
    r.token = NULL;
    r.type = 0;
    r.state = -1;
    
    if (gParseTop) {
        r = *gParseTop;
        r.next = NULL;
        r.prev = NULL;
        if (gParseTop->prev) {
            gParseTop = gParseTop->prev;
            free(gParseTop->next);
            gParseTop->next = NULL;
        } else {
            free(gParseTop);
            gParseTop = NULL;
            gParseStack = NULL;
        }
    }
    
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, (%rdi)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x8(%rdi)
movq 0x143a2(%rip), %rdi     # 0x19350
testq %rdi, %rdi
je 0x500c
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4fee
movq %rax, 0x14378(%rip)     # 0x19350
movq 0x10(%rax), %rdi
callq 0x2030
movq 0x14368(%rip), %rax     # 0x19350
addq $0x10, %rax
jmp 0x5005
callq 0x2030
movq $0x0, 0x14352(%rip) # 0x19350
leaq 0x14343(%rip), %rax     # 0x19348
movq $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: FreeParseStack
void FreeParseStack()
{
    PARSE_STACK s;
    while (gParseStack)
    {
        s = StackPop();
        if (s.type == TOKEN_SYNTAX_TREE)
        {
            SYNTAX_TREE* astSection = (SYNTAX_TREE*)s.token;
            FreeParseTree(astSection);
        }
    }
}

// Assembly:
cmpq $0x0, 0x1432a(%rip)     # 0x19348
je 0x5054
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x4f89
cmpl $0x2, -0x20(%rbp)
jne 0x5044
movq -0x28(%rbp), %rdi
callq 0x5055
cmpq $0x0, 0x142fc(%rip)     # 0x19348
jne 0x502d
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: FreeParseTree
void FreeParseTree(SYNTAX_TREE* ast)
{
    if (ast && ast->children)
    {
        int i;
        for (i = 0; i < ast->numChildren; i++)
        {
            FreeParseTree(ast->children[i]);
        }
        
        free(ast->children);
        free(ast);
    }
    else if (ast)
    {
        free(ast);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x50a2
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x5096
cmpl $0x0, 0x20(%rbx)
jle 0x508d
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x5055
incq %r14
movslq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0x5074
movq 0x28(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: PrintErrorInput
void PrintErrorInput(L_TOKEN* input, GRAMMAR_TABLE g)
{
    int i;
    if (input)
    {
        printf("Syntax error on line %i: ", (input->line+1));
        if (input->string)
        {
            for (i = 0; i < input->length; i++)
            {
                printf("%c", input->string[i]);
            }
        }
        else
        {
            printf("%s", GetElement(input->token, g));
        }
        printf("\n");
    }
}

// Assembly:
testq %rdi, %rdi
je 0x50f5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %esi
incl %esi
leaq 0x3465(%rip), %rdi      # 0x8527
xorl %eax, %eax
callq 0x2090
cmpq $0x0, 0x8(%rbx)
je 0x50f6
cmpl $0x0, 0x10(%rbx)
jle 0x512b
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x50d9
jmp 0x512b
retq
leaq 0x10(%rbp), %rax
movl (%rbx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2db4
leaq 0x352f(%rip), %rdi      # 0x8650
movq %rax, %rsi
xorl %eax, %eax
callq 0x2090
movl $0xa, %edi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2040