LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
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 0x93ea(%rip), %rax      # 0xf0b4
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)
// File: /workspace/github_c_makefile_star2_O0/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
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 0x936e(%rip), %rax      # 0xf0b8
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
subl $0x2, %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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
addq %rcx, %rdi
movl -0x10(%rbp), %esi
subl -0xc(%rbp), %esi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x47d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x5e4b
movl -0x18(%rbp), %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)
jmp 0x5eba
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -0x20(%rbp)
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0x5680(%rip), %rdi      # 0xb4e9
movb $0x0, %al
callq 0x2070
leaq 0x568c(%rip), %rdi      # 0xb503
movb $0x0, %al
callq 0x2070
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x5eac
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %esi
leaq 0x567c(%rip), %rdi      # 0xb51f
movb $0x0, %al
callq 0x2070
jmp 0x5e7e
leaq 0x5526(%rip), %rdi      # 0xb3d9
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
addq %rcx, %rdi
movl -0x10(%rbp), %esi
subl -0xc(%rbp), %esi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x47d0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x5f7b
movl -0x18(%rbp), %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)
jmp 0x5fc0
leaq 0x913a(%rip), %rax      # 0xf0bc
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 $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/lexer.c
// Function: isSpace
int isSpace(char c)
{
    return (c == ' ' ||
            c == '\t' ||
            c == '\r' ||
            c == '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2(%rbp)
je 0x60b1
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x2(%rbp)
je 0x60b1
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x2(%rbp)
je 0x60b1
movsbl -0x1(%rbp), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4998(%rip), %rdi      # 0xb58b
movb $0x0, %al
callq 0x2070
leaq 0x499a(%rip), %rdi      # 0xb59b
movb $0x0, %al
callq 0x2070
cmpq $0x0, -0x8(%rbp)
je 0x6cc0
movq -0x8(%rbp), %rax
movl (%rax), %esi
leaq 0x498b(%rip), %rdi      # 0xb5ab
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
movl (%rax), %eax
leaq 0x8484(%rip), %rcx      # 0xf0b8
cmpl (%rcx), %eax
jne 0x6c46
leaq 0x4975(%rip), %rdi      # 0xb5b4
movb $0x0, %al
callq 0x2070
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x6c82
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x4946(%rip), %rdi      # 0xb5b6
movb $0x0, %al
callq 0x2070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6c4d
movq -0x8(%rbp), %rax
movl (%rax), %eax
leaq 0x8429(%rip), %rcx      # 0xf0b8
cmpl (%rcx), %eax
jne 0x6ca1
leaq 0x491a(%rip), %rdi      # 0xb5b4
movb $0x0, %al
callq 0x2070
leaq 0x4731(%rip), %rdi      # 0xb3d9
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c08
leaq 0x4712(%rip), %rdi      # 0xb3d9
movb $0x0, %al
callq 0x2070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6d2e
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6d23
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x6cf0
movq -0x10(%rbp), %rdi
callq 0x2030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq 0x152b1(%rip), %rdi     # 0x1c360
callq 0x90b0
leaq 0x152ad(%rip), %rdi     # 0x1c368
callq 0x9110
leaq 0x15291(%rip), %rax     # 0x1c358
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x711d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70f5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6ce0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x710d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x76f0
jmp 0x710f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x70ce
leaq 0x15234(%rip), %rdi     # 0x1c358
callq 0x9050
leaq 0x15230(%rip), %rax     # 0x1c360
movq $0x0, (%rax)
leaq 0x1522a(%rip), %rax     # 0x1c368
movq $0x0, (%rax)
leaq 0x1520c(%rip), %rax     # 0x1c358
movq $0x0, (%rax)
leaq 0x151f6(%rip), %rax     # 0x1c350
cmpq $0x0, (%rax)
je 0x71c8
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x151d7(%rip), %rcx     # 0x1c348
cmpl (%rcx), %eax
jae 0x719d
leaq 0x151d4(%rip), %rax     # 0x1c350
movq (%rax), %rdi
movl -0xc(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rdi
addq $0x18, %rdi
callq 0x90b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7167
leaq 0x151ac(%rip), %rax     # 0x1c350
movq (%rax), %rdi
callq 0x2030
leaq 0x1519d(%rip), %rax     # 0x1c350
movq $0x0, (%rax)
leaq 0x1518f(%rip), %rax     # 0x1c350
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x10(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x7231
movl -0x10(%rbp), %eax
xorl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x7273
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x7273
cmpl $0x0, -0x10(%rbp)
jle 0x7273
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl (%rcx), %eax
jg 0x7273
movq -0x18(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0xc(%rbp), %ecx
imull (%rdx), %ecx
addl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl -0x8(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x72b1
movl -0x8(%rbp), %eax
xorl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x72f3
movq -0x18(%rbp), %rcx
movl -0x4(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x72f3
cmpl $0x0, -0x8(%rbp)
jle 0x72f3
movq -0x18(%rbp), %rcx
movl -0x8(%rbp), %eax
cmpl 0x4(%rcx), %eax
jg 0x72f3
movq -0x18(%rbp), %rdx
movq 0x18(%rdx), %rax
movl -0x4(%rbp), %ecx
imull 0x4(%rdx), %ecx
addl -0x8(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x1502d(%rip)     # 0x1c340
je 0x7357
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq 0x15017(%rip), %rax     # 0x1c340
movq %rcx, 0x10(%rax)
movq 0x1500c(%rip), %rcx     # 0x1c340
movq 0x15005(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x14ff6(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rax, 0x14feb(%rip)     # 0x1c340
jmp 0x737e
movl $0x20, %edi
callq 0x20e0
movq %rax, 0x14fd8(%rip)     # 0x1c340
movq %rax, 0x14fc9(%rip)     # 0x1c338
movq 0x14fca(%rip), %rax     # 0x1c340
movq $0x0, 0x18(%rax)
movq 0x14fbb(%rip), %rax     # 0x1c340
movq $0x0, 0x10(%rax)
movq 0x14fac(%rip), %rax     # 0x1c340
movq $0x0, (%rax)
movq 0x14f9e(%rip), %rax     # 0x1c340
movl $0x0, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq 0x14f8d(%rip), %rax     # 0x1c340
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x14f6c(%rip)     # 0x1c340
je 0x7418
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq 0x14f56(%rip), %rax     # 0x1c340
movq %rcx, 0x10(%rax)
movq 0x14f4b(%rip), %rcx     # 0x1c340
movq 0x14f44(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x14f35(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rax, 0x14f2a(%rip)     # 0x1c340
jmp 0x743f
movl $0x20, %edi
callq 0x20e0
movq %rax, 0x14f17(%rip)     # 0x1c340
movq %rax, 0x14f08(%rip)     # 0x1c338
movq 0x14f09(%rip), %rax     # 0x1c340
movq $0x0, 0x18(%rax)
movq 0x14efa(%rip), %rax     # 0x1c340
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x14ee7(%rip), %rax     # 0x1c340
movq %rcx, (%rax)
movq 0x14edd(%rip), %rax     # 0x1c340
movl $0x1, 0x8(%rax)
movq 0x14ecf(%rip), %rax     # 0x1c340
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x14eac(%rip)     # 0x1c340
je 0x74d8
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq 0x14e96(%rip), %rax     # 0x1c340
movq %rcx, 0x10(%rax)
movq 0x14e8b(%rip), %rcx     # 0x1c340
movq 0x14e84(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x14e75(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rax
movq %rax, 0x14e6a(%rip)     # 0x1c340
jmp 0x74ff
movl $0x20, %edi
callq 0x20e0
movq %rax, 0x14e57(%rip)     # 0x1c340
movq %rax, 0x14e48(%rip)     # 0x1c338
movq 0x14e49(%rip), %rax     # 0x1c340
movq $0x0, 0x18(%rax)
movq 0x14e3a(%rip), %rax     # 0x1c340
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x14e27(%rip), %rax     # 0x1c340
movq %rcx, (%rax)
movq 0x14e1d(%rip), %rax     # 0x1c340
movl $0x2, 0x8(%rax)
movq 0x14e0f(%rip), %rax     # 0x1c340
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
movq $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0xffffffff, 0xc(%rdi)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x14dd4(%rip)     # 0x1c340
je 0x75a7
movq -0x10(%rbp), %rax
movq 0x14dc7(%rip), %rcx     # 0x1c340
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
movq $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0xffffffff, 0xc(%rdi)  # imm = 0xFFFFFFFF
cmpq $0x0, 0x14d60(%rip)     # 0x1c340
je 0x7684
movq -0x10(%rbp), %rax
movq 0x14d4f(%rip), %rcx     # 0x1c340
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x14d1a(%rip), %rax     # 0x1c340
cmpq $0x0, 0x18(%rax)
je 0x7660
movq 0x14d0c(%rip), %rax     # 0x1c340
movq 0x18(%rax), %rax
movq %rax, 0x14d01(%rip)     # 0x1c340
movq 0x14cfa(%rip), %rax     # 0x1c340
movq 0x10(%rax), %rdi
callq 0x2030
movq 0x14cea(%rip), %rax     # 0x1c340
movq $0x0, 0x10(%rax)
jmp 0x7682
movq 0x14cd9(%rip), %rdi     # 0x1c340
callq 0x2030
movq $0x0, 0x14cc9(%rip) # 0x1c340
movq $0x0, 0x14cb6(%rip) # 0x1c338
jmp 0x7684
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
cmpq $0x0, 0x14c98(%rip)     # 0x1c338
je 0x76e4
leaq -0x40(%rbp), %rdi
callq 0x75b0
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x2, -0x18(%rbp)
jne 0x76e2
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x76f0
jmp 0x7698
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7759
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7759
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x7741
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x76f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7715
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x776b
cmpq $0x0, -0x8(%rbp)
je 0x7769
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x776b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7847
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
addl $0x1, %esi
leaq 0x3dae(%rip), %rdi      # 0xb55e
movb $0x0, %al
callq 0x2070
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7800
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x77fe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x3dca(%rip), %rdi      # 0xb5b6
movb $0x0, %al
callq 0x2070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x77c9
jmp 0x7839
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x4290
movq %rax, %rsi
leaq 0x3e13(%rip), %rdi      # 0xb645
movb $0x0, %al
callq 0x2070
leaq 0x3b99(%rip), %rdi      # 0xb3d9
movb $0x0, %al
callq 0x2070
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/parser.c
// Function: PrintParseTreeNode
void PrintParseTreeNode(SYNTAX_TREE* ast, GRAMMAR_TABLE g)
{
    if (!ast) return;
    if (ast->string && ast->token != gSymbolEndLine)
    {
        int i;
        for (i = 0; i < ast->length; i++)
            printf("%c", ast->string[i]);
    }
    else
    {
        printf("%s", GetElement(ast->token, g));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x80b0
jmp 0x8143
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x810a
movq -0x8(%rbp), %rax
movl (%rax), %eax
leaq 0x6fe4(%rip), %rcx      # 0xf0ac
cmpl (%rcx), %eax
je 0x810a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x8108
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x34c0(%rip), %rdi      # 0xb5b6
movb $0x0, %al
callq 0x2070
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x80d3
jmp 0x8143
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x4290
movq %rax, %rsi
leaq 0x3509(%rip), %rdi      # 0xb645
movb $0x0, %al
callq 0x2070
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/parser.c
// Function: PrintParseTreeRecurse
void PrintParseTreeRecurse(SYNTAX_TREE*  ast,
                           unsigned int  indent,
                           GRAMMAR_TABLE g)
{
    if (ast->children)
    {
		unsigned int u;
        int i;

        for (u = 0; u < indent*2; u++)
        {
            printf(" ");
        }
            
        PrintParseTreeNode(ast, g);
        
        printf(" ::= ");
        
        for (i = 0; i < ast->numChildren; i++)
        {
            PrintParseTreeNode(ast->children[i], g);
            printf(" ");
        }
        
        printf("\n");
        
        for (i = 0; i < ast->numChildren; i++)
        {
            PrintParseTreeRecurse(ast->children[i], indent+1, g);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x829a
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x81a2
leaq 0x3422(%rip), %rdi      # 0xb5b2
movb $0x0, %al
callq 0x2070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x817d
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8090
leaq 0x3244(%rip), %rdi      # 0xb413
movb $0x0, %al
callq 0x2070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x8234
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8090
leaq 0x3390(%rip), %rdi      # 0xb5b2
movb $0x0, %al
callq 0x2070
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x81dd
leaq 0x319e(%rip), %rdi      # 0xb3d9
movb $0x0, %al
callq 0x2070
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x8298
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8249
jmp 0x829a
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/parser.c
// Function: PrintParseTreeFormat
void PrintParseTreeFormat(SYNTAX_TREE*  ast,
                          GRAMMAR_TABLE grammar)
{
    if (ast->numChildren > 0) {
        int i;
        for (i = 0; i < ast->numChildren; i++)
            PrintParseTreeFormat(ast->children[i], grammar);
    } else {
        if (ast->string && ast->token != gSymbolEndLine)
        {
            int i;
            for (i = 0; i < ast->length; i++)
                printf("%c", ast->string[i]);
        }
        else
        {
            printf("%s", GetElement(ast->token, grammar));
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jle 0x8373
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x836e
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x8300
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8325
jmp 0x8408
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x83cd
movq -0x8(%rbp), %rax
movl (%rax), %eax
leaq 0x6d21(%rip), %rcx      # 0xf0ac
cmpl (%rcx), %eax
je 0x83cd
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x83cb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x31fd(%rip), %rdi      # 0xb5b6
movb $0x0, %al
callq 0x2070
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x8396
jmp 0x8406
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x4290
movq %rax, %rsi
leaq 0x3246(%rip), %rdi      # 0xb645
movb $0x0, %al
callq 0x2070
jmp 0x8408
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: AddSourceToList
int AddSourceToList(SOURCE** list, const char* filename, L_TOKEN* lexing, SYNTAX_TREE* syntax)
{
    SOURCE* iterator;
    unsigned int index = 0;

    iterator = *list;
    while (iterator)
    {
        if (strcmp(iterator->filename, filename) == 0)
        { 
            return 0;
        }

        index++;
        if (iterator->next == NULL) break;
        iterator = iterator->next;
    }

    if (iterator)
    {
        iterator->next = (SOURCE*)malloc(sizeof(SOURCE));
        iterator = iterator->next;
    } else {
        *list = (SOURCE*)malloc(sizeof(SOURCE));
        iterator = *list;
    }

    iterator->filename = filename;
    iterator->lexing = lexing;
    iterator->syntax = syntax;
    iterator->next = NULL;
    iterator->index = index;
    return (index + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8d96
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x8d72
movl $0x0, -0x4(%rbp)
jmp 0x8e21
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8d88
jmp 0x8d96
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x8d4a
cmpq $0x0, -0x30(%rbp)
je 0x8dc0
movl $0x30, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x8ddf
movl $0x30, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x28(%rax)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: AddVariableToList
int AddVariableToList(VARLIST** list, TYPE type, const char* name)
{
    VARLIST* iterator;
    unsigned int index = 0;

    iterator = *list;
    while (iterator)
    {
        if (strcmp(iterator->identifier, name) == 0)
        { 
            return 0;
        }

        index++;
        if (iterator->next == NULL) break;
        iterator = iterator->next;
    }

    if (iterator)
    {
        iterator->next = (VARLIST*)malloc(sizeof(VARLIST));
        iterator = iterator->next;
    } else {
        *list = (VARLIST*)malloc(sizeof(VARLIST));
        iterator = *list;
    }

    iterator->identifier = name;
    iterator->type = type;
    iterator->next = NULL;
    iterator->index = index;
    return (index + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8ea3
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x8e7f
movl $0x0, -0x4(%rbp)
jmp 0x8f22
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x8e95
jmp 0x8ea3
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8e56
cmpq $0x0, -0x28(%rbp)
je 0x8ecd
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8eec
movl $0x20, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: AddFunctionToList
int AddFunctionToList(FUNCTION** list, TYPE type, const char* name, VARLIST* params, SYNTAX_BLOCK* source)
{
    FUNCTION* iterator;
    unsigned int index = 0;

    iterator = *list;
    while (iterator)
    {
        if (strcmp(iterator->identifier, name) == 0)
        { 
            return 0;
        }

        index++;
        if (iterator->next == NULL) break;
        iterator = iterator->next;
    }

    if (iterator)
    {
        iterator->next = (FUNCTION*)malloc(sizeof(FUNCTION));
        iterator = iterator->next;
    } else {
        *list = (FUNCTION*)malloc(sizeof(FUNCTION));
        iterator = *list;
    }

    iterator->identifier = name;
    iterator->type = type;
    iterator->parameters = params;
    iterator->block = source;
    iterator->next = NULL;
    iterator->index = index;
    return (index + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x8fab
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x8f87
movl $0x0, -0x4(%rbp)
jmp 0x9042
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x8f9d
jmp 0x8fab
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x8f5e
cmpq $0x0, -0x38(%rbp)
je 0x8fd5
movl $0x30, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x8ff4
movl $0x30, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x28(%rax)
movl -0x3c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: FreeSourceList
int FreeSourceList(SOURCE** list)
{
    int count = 0;

    SOURCE* itr;
    itr = *list;
    while (itr)
    {
        *list = itr->next;
        free(itr);
        itr = *list;
    }

    *list = NULL;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x909a
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x906e
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: FreeVariableList
int FreeVariableList(VARLIST** list)
{
    int count = 0;
    VARLIST* itr;
    itr = *list;
    while (itr)
    {
        *list = itr->next;
        free(itr);
        itr = *list;
    }

    *list = NULL;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x90fa
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x90ce
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: FreeFunctionList
int FreeFunctionList(FUNCTION** list)
{
    int count = 0;
    FUNCTION* itr;
    itr = *list;
    while (itr)
    {
        *list = itr->next;
        if (itr->parameters != &lStringParam &&
            itr->parameters != &lIntegerParam)
        {
            FreeVariableList(&itr->parameters);
        }
        free(itr);
        itr = *list;
    }

    *list = NULL;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9189
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
leaq 0x131a1(%rip), %rcx     # 0x1c2f0
cmpq %rcx, 0x10(%rax)
je 0x9173
movq -0x18(%rbp), %rax
leaq 0x131b0(%rip), %rcx     # 0x1c310
cmpq %rcx, 0x10(%rax)
je 0x9173
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x90b0
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x912e
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: SourceCount
unsigned int SourceCount(SOURCE* list)
{
    unsigned int count = 0;
    while (list)
    {
        count++;
        list = list->next;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x91cd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x91af
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: VariableCount
unsigned int VariableCount(VARLIST* list)
{
    unsigned int count = 0;
    while (list)
    {
        count++;
        list = list->next;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x920d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x91ef
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: FunctionCount
unsigned int FunctionCount(FUNCTION* list)
{
    unsigned int count = 0;
    while (list)
    {
        count++;
        list = list->next;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x924d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x922f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: GetVariableFromList
VARLIST*  GetVariableFromList(VARLIST* variableList, const char* identifier)
{
    while (variableList)
    {
        if (strcmp(variableList->identifier, identifier) == 0)
            return variableList;
        variableList = variableList->next;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x92a5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x9297
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x92ad
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9270
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: GetFunctionFromList
FUNCTION* GetFunctionFromList(FUNCTION* functionList, const char* identifier)
{
    while (functionList)
    {
        if (strcmp(functionList->identifier, identifier) == 0)
            return functionList;
        functionList = functionList->next;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9305
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x92f7
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x930d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x92d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/tables.c
// Function: GetSourceFromList
SOURCE* GetSourceFromList(SOURCE* sourceList, const char* identifier)
{
    while (sourceList)
    {
        if (strcmp(sourceList->filename, identifier) == 0)
            return sourceList;
        sourceList = sourceList->next;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9364
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x20a0
cmpl $0x0, %eax
jne 0x9356
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x936c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9330
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)