LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Joy-Division[P]tools-mgs/txp-convert.c
// Function: buildSingleFrameRgba
unsigned char *buildSingleFrameRgba(textureHeader *textures, frameHeader frame) {
	unsigned int x, y, mempointer = 0, framesize = frame.width * frame.height;
	unsigned char *retframe = malloc(framesize * 4), pixel;
	for(y = frame.sourcey; y < frame.sourcey+frame.height; y++) {
		for(x = frame.sourcex; x < frame.sourcex+frame.width; x++) {
			pixel = frame.texpixels[x+y*textures[frame.sourcetexture].width];
			retframe[mempointer] = frame.palpixels[pixel].red;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].green;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].blue;
			mempointer++;
			retframe[mempointer] = frame.palpixels[pixel].alpha;
			mempointer++;
		}
	}
	return retframe;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x34(%rsp), %ebp
movl 0x38(%rsp), %r14d
movl %ebp, %edi
imull %r14d, %edi
shll $0x2, %edi
callq 0x10f0
movl 0x3c(%rsp), %ecx
movl 0x40(%rsp), %edx
addl %edx, %r14d
addl %ecx, %ebp
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %edi
imulq $0x28, %rdi, %rdi
addq %rbx, %rdi
addq $0x8, %rdi
xorl %r8d, %r8d
movq 0x58(%rsp), %r9
cmpl %r14d, %edx
jae 0xaade
movl %ecx, %r10d
cmpl %ebp, %r10d
jae 0xaada
movl (%rdi), %r11d
imull %edx, %r11d
addl %r10d, %r11d
movzbl (%rsi,%r11), %r11d
movb (%r9,%r11,4), %bl
movl %r8d, %r15d
movb %bl, (%rax,%r15)
leal 0x1(%r8), %ebx
movb 0x1(%r9,%r11,4), %r15b
movb %r15b, (%rax,%rbx)
leal 0x2(%r8), %ebx
movb 0x2(%r9,%r11,4), %r15b
movb %r15b, (%rax,%rbx)
leal 0x3(%r8), %ebx
movb 0x3(%r9,%r11,4), %r11b
movb %r11b, (%rax,%rbx)
addl $0x4, %r8d
incl %r10d
jmp 0xaa8b
incl %edx
jmp 0xaa83
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/tracegen.c
// Function: validate
int validate(int fn,int M, int N, int A[N][M], int B[M][N]) {
    int C[M][N];
    memset(C,0,sizeof(C));
    correctTrans(M,N,A,C);
    for(int i=0;i<M;i++) {
        for(int j=0;j<N;j++) {
            if(B[i][j]!=C[i][j]) {
                printf("Validation failed on function %d! Expected %d but got %d at B[%d][%d]\n",fn,C[i][j],B[i][j],i,j);
                return 0;
            }
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, -0x30(%rbp)
movl %edx, %r12d
movl %esi, %ebx
movl %edi, -0x34(%rbp)
movl %edx, %eax
movq %rax, -0x40(%rbp)
movl %esi, %edx
imulq %rax, %rdx
leaq 0xf(,%rdx,4), %rax
andq $-0x10, %rax
movq %rsp, %r14
subq %rax, %r14
movq %r14, %rsp
shlq $0x2, %rdx
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movl %ebx, %edi
movl %r12d, %esi
movq -0x30(%rbp), %rdx
movq %r14, %rcx
callq 0x5613
movq -0x40(%rbp), %rsi
testl %r12d, %r12d
cmovlel %r13d, %r12d
testl %ebx, %ebx
movl $0x0, %eax
movl %ebx, -0x30(%rbp)
cmovgl %ebx, %eax
shlq $0x2, %rsi
cmpq %rax, %r13
je 0x12b8
xorl %r9d, %r9d
cmpq %r9, %r12
je 0x1299
movl (%r15,%r9,4), %ecx
movl (%r14,%r9,4), %edx
cmpl %edx, %ecx
jne 0x12a4
incq %r9
jmp 0x1283
incq %r13
addq %rsi, %r14
addq %rsi, %r15
jmp 0x127b
leaq 0x4d59(%rip), %rdi      # 0x6004
movl -0x34(%rbp), %esi
movl %r13d, %r8d
xorl %eax, %eax
callq 0x1050
movslq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq %rcx, %r13
setge %al
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/cachelab.c
// Function: printSummary
void printSummary(int hits, int misses, int evictions)
{
    printf("hits:%d misses:%d evictions:%d\n", hits, misses, evictions);
    FILE* output_fp = fopen(".csim_results", "w");
    assert(output_fp);
    fprintf(output_fp, "%d %d %d\n", hits, misses, evictions);
    fclose(output_fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %r15d
leaq 0xc34(%rip), %rdi       # 0x60ba
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1050
leaq 0xc3e(%rip), %rdi       # 0x60da
leaq 0xbb7(%rip), %rsi       # 0x605a
callq 0x10b0
testq %rax, %rax
je 0x54da
movq %rax, %r12
leaq 0xc67(%rip), %rsi       # 0x611e
movq %rax, %rdi
movl %r15d, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1090
movq %r12, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1040
leaq 0xc07(%rip), %rdi       # 0x60e8
leaq 0xc0a(%rip), %rsi       # 0x60f2
leaq 0xc0e(%rip), %rcx       # 0x60fd
pushq $0x15
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/cachelab.c
// Function: initMatrix
void initMatrix(int M, int N, int A[N][M], int B[M][N])
{
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
            B[j][i]=rand();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movl %edi, %r12d
movl %edi, %eax
movq %rax, -0x30(%rbp)
movl %esi, %r13d
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1080
testl %r12d, %r12d
movl $0x0, %eax
cmovlel %eax, %r12d
testl %r15d, %r15d
cmovlel %eax, %r15d
movq %r15, -0x38(%rbp)
xorl %eax, %eax
shlq $0x2, %r13
shlq $0x2, -0x30(%rbp)
cmpq -0x38(%rbp), %rax
je 0x5590
movq %rax, -0x40(%rbp)
movq %rbx, -0x48(%rbp)
xorl %r15d, %r15d
cmpq %r15, %r12
je 0x557b
callq 0x10f0
movl %eax, (%r14,%r15,4)
callq 0x10f0
movl %eax, (%rbx)
incq %r15
addq %r13, %rbx
jmp 0x555e
movq -0x40(%rbp), %rax
incq %rax
movq -0x48(%rbp), %rbx
addq $0x4, %rbx
addq -0x30(%rbp), %r14
jmp 0x554d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/cachelab.c
// Function: randMatrix
void randMatrix(int M, int N, int A[N][M]) {
    int i, j;
    srand(time(NULL));
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            // A[i][j] = i+j;  /* The matrix created this way is symmetric */
            A[i][j]=rand();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r12d
movl %edi, %r15d
movl %edi, %r14d
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1080
testl %r15d, %r15d
cmovlel %r13d, %r15d
testl %r12d, %r12d
cmovlel %r13d, %r12d
movq %r12, -0x30(%rbp)
shlq $0x2, %r14
cmpq -0x30(%rbp), %r13
je 0x5604
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x55fc
callq 0x10f0
movl %eax, (%rbx,%r12,4)
incq %r12
jmp 0x55e9
incq %r13
addq %r14, %rbx
jmp 0x55e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/cachelab.c
// Function: correctTrans
void correctTrans(int M, int N, int A[N][M], int B[M][N])
{
    int i, j, tmp;
    for (i = 0; i < N; i++){
        for (j = 0; j < M; j++){
            tmp = A[i][j];
            B[j][i] = tmp;
        }
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %edi, %eax
movl %esi, %r8d
xorl %r9d, %r9d
testl %edi, %edi
cmovlel %r9d, %edi
testl %esi, %esi
cmovlel %r9d, %esi
shlq $0x2, %r8
shlq $0x2, %rax
cmpq %rsi, %r9
je 0x565f
movq %rcx, %r10
xorl %r11d, %r11d
cmpq %r11, %rdi
je 0x5653
movl (%rdx,%r11,4), %ebx
movl %ebx, (%r10)
incq %r11
addq %r8, %r10
jmp 0x563f
incq %r9
addq $0x4, %rcx
addq %rax, %rdx
jmp 0x5634
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/YanjieZe[P]CacheLab/cachelab.c
// Function: registerTransFunction
void registerTransFunction(void (*trans)(int M, int N, int[N][M], int[M][N]), 
                           char* desc)
{
    func_list[func_counter].func_ptr = trans;
    func_list[func_counter].description = desc;
    func_list[func_counter].correct = 0;
    func_list[func_counter].num_hits = 0;
    func_list[func_counter].num_misses = 0;
    func_list[func_counter].num_evictions =0;
    func_counter++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x82d13(%rip), %rax     # 0x88380
leal 0x1(%rax), %ecx
shlq $0x5, %rax
leaq 0x82d15(%rip), %rdx     # 0x88390
movq %rdi, (%rax,%rdx)
movq %rsi, 0x8(%rax,%rdx)
movb $0x0, 0x10(%rax,%rdx)
andq $0x0, 0x14(%rax,%rdx)
andl $0x0, 0x1c(%rax,%rdx)
movl %ecx, 0x82ce6(%rip)     # 0x88380
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x261c
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x2621
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O2/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 0x266b
movq %r15, %rdi
callq 0x224d
testl %eax, %eax
jne 0x266b
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x2676
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_O2/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 0x26e2
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x26e7
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O2/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 0x27e0
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x27e5
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O2/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 0x282e
movq %r14, %rdi
callq 0x224d
testl %eax, %eax
je 0x2833
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x224d
// File: /workspace/github_c_makefile_star2_O2/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 0x287b
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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x43fa(%rip), %rsi      # 0x7145
callq 0x2120
testq %rax, %rax
je 0x2e7c
movq %rax, %rbx
leaq 0x1560d(%rip), %rax     # 0x18370
movq (%rax), %rdi
callq 0x5d6a
leal (,%rax,8), %eax
movl %eax, -0x2c(%rbp)
leaq 0x43cc(%rip), %rdi      # 0x7148
pushq $0x22
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43d6(%rip), %rdi      # 0x716b
pushq $0x20
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43e2(%rip), %rdi      # 0x718c
pushq $0xe
popq %r15
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43fb(%rip), %r13      # 0x71be
pushq $0x2
popq %r12
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43bc(%rip), %rdi      # 0x719b
pushq $0x7
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43af(%rip), %rdi      # 0x71a3
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x43a9(%rip), %rsi      # 0x71b2
xorl %r15d, %r15d
movq %rbx, %rdi
movl -0x2c(%rbp), %edx
xorl %eax, %eax
callq 0x20e0
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
leaq 0x4390(%rip), %rdi      # 0x71c1
pushq $0x7
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
movq %rbx, %rdi
callq 0x2ce4
callq 0x2d09
leaq 0x4376(%rip), %rdi      # 0x71c9
pushq $0x13
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2130
movq %rbx, %rdi
callq 0x2070
jmp 0x2e80
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2ea3
btl $0xd, %edi
jb 0x2eb4
xorl %eax, %eax
retq
movl $0xffffefff, %eax       # imm = 0xFFFFEFFF
movabsq $0x8, %rcx
jmp 0x2ec3
movl $0xffffcfff, %eax       # imm = 0xFFFFCFFF
movabsq $0x18, %rcx
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
andl %edi, %eax
movq (%rdx,%rcx), %rcx
movl $0x1, %esi
xorl %edx, %edx
cmpl %eax, %esi
jge 0x2f02
cmpq $0xfff, %rdx            # imm = 0xFFF
jg 0x2f02
movq %rdx, %rdi
leaq 0x1(%rdi), %rdx
cmpq $0x1000, %rdi           # imm = 0x1000
je 0x2efe
cmpb $0x0, (%rcx,%rdi)
movq %rdx, %rdi
jne 0x2ee8
incl %esi
jmp 0x2ed8
addq %rdx, %rcx
xorl %eax, %eax
cmpq $0x1000, %rdx           # imm = 0x1000
cmovlq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x38(%rbp), %rax
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x2f3a
cmpl %edi, (%rax)
jne 0x2f31
testl %esi, %esi
je 0x2f3c
decl %esi
incq %rdx
addq $0x10, %rax
jmp 0x2f22
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x8(%rdx), %rax
movl (%rdx), %r9d
xorl %r8d, %r8d
testl %esi, %esi
movl $0x0, %r10d
cmovgl %esi, %r10d
movl %esi, %r11d
movl $0x1, %ecx
leaq (%rax,%r8), %rbx
cmpl %r9d, %ecx
jg 0x2fbb
cmpq $0xfff, %r8             # imm = 0xFFF
jg 0x2fbb
xorl %r14d, %r14d
cmpq %r14, %r10
je 0x2f8e
movb (%rdi,%r14), %r15b
cmpb (%rbx,%r14), %r15b
jne 0x2f91
incq %r14
jmp 0x2f7a
movl %r10d, %r14d
cmpl %esi, %r14d
jne 0x2f9d
cmpb $0x0, (%rbx,%r11)
je 0x2ff0
leaq 0x1(%r8), %rbx
cmpq $0x1000, %r8            # imm = 0x1000
je 0x2fb4
cmpb $0x0, (%rax,%r8)
movq %rbx, %r8
jne 0x2f9d
incl %ecx
movq %rbx, %r8
jmp 0x2f65
xorl %eax, %eax
cmpq $0xfff, %r8             # imm = 0xFFF
jg 0x2ff8
movslq %esi, %rsi
xorl %eax, %eax
cmpq %rsi, %rax
jge 0x2fea
leaq (%r8,%rax), %r9
cmpq $0xfff, %r9             # imm = 0xFFF
jg 0x2fea
movb (%rdi,%rax), %r9b
movb %r9b, (%rbx,%rax)
incq %rax
jmp 0x2fcb
movb $0x0, (%rax,%rbx)
incl (%rdx)
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq 0x18(%rdx), %r8
movl 0x10(%rdx), %eax
movslq %esi, %r10
movl $0x1, %ecx
xorl %r9d, %r9d
cmpl %eax, %ecx
jg 0x3084
cmpq $0xfff, %r9             # imm = 0xFFF
jg 0x3084
leaq (%r8,%r9), %r11
xorl %ebx, %ebx
cmpl %esi, %ebx
jge 0x305b
movslq %ebx, %r15
xorl %r14d, %r14d
cmpb $0x5c, (%rdi,%r15)
sete %r14b
addl %ebx, %r14d
movslq %r14d, %rbx
movb (%rdi,%rbx), %r15b
cmpb (%r11,%rbx), %r15b
jne 0x3058
incl %r14d
movl %r14d, %ebx
jmp 0x302d
movl %r14d, %ebx
cmpl %esi, %ebx
jne 0x3066
cmpb $0x0, (%r11,%r10)
je 0x30ce
leaq 0x1(%r9), %r11
cmpq $0x1000, %r9            # imm = 0x1000
je 0x307d
cmpb $0x0, (%r8,%r9)
movq %r11, %r9
jne 0x3066
incl %ecx
movq %r11, %r9
jmp 0x301a
xorl %eax, %eax
cmpq $0xfff, %r9             # imm = 0xFFF
jg 0x30d6
xorl %eax, %eax
cmpl %esi, %eax
jge 0x30c6
cmpq $0xfff, %r9             # imm = 0xFFF
jg 0x30c6
movslq %eax, %r10
xorl %r11d, %r11d
cmpb $0x5c, (%rdi,%r10)
sete %r11b
leal (%rax,%r11), %r10d
movslq %r10d, %r10
movb (%rdi,%r10), %r10b
movb %r10b, (%r8,%r9)
incq %r9
addl %r11d, %eax
incl %eax
jmp 0x3091
movb $0x0, (%r8,%r9)
incl 0x10(%rdx)
orl $0x2000, %ecx           # imm = 0x2000
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x28(%rbp), %rdx
movl 0x20(%rbp), %r8d
movslq %esi, %r9
movl $0x1, %ecx
xorl %eax, %eax
xorl %r10d, %r10d
cmpl %r8d, %ecx
jg 0x316e
cmpq $0xfff, %r10            # imm = 0xFFF
jg 0x316e
leaq (%rdx,%r10), %r11
xorl %ebx, %ebx
cmpl %esi, %ebx
jge 0x313d
movslq %ebx, %r15
xorl %r14d, %r14d
cmpb $0x5c, (%rdi,%r15)
sete %r14b
addl %ebx, %r14d
movslq %r14d, %rbx
movb (%rdi,%rbx), %r15b
cmpb (%r11,%rbx), %r15b
jne 0x313a
incl %r14d
movl %r14d, %ebx
jmp 0x310f
movl %r14d, %ebx
cmpl %esi, %ebx
jne 0x3148
cmpb $0x0, (%r11,%r9)
je 0x3166
leaq 0x1(%r10), %r11
cmpq $0x1000, %r10           # imm = 0x1000
je 0x315f
cmpb $0x0, (%rdx,%r10)
movq %r11, %r10
jne 0x3148
incl %ecx
movq %r11, %r10
jmp 0x30fb
orl $0x2000, %ecx           # imm = 0x2000
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, (%rbx)
andl $0x0, 0x10(%rbx)
pushq $0x8
popq %r14
xorl %r15d, %r15d
movslq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
cmpq %rax, %r15
jge 0x31c1
movq (%rdi,%r14), %rdi
callq 0x2030
incq %r15
addq $0x10, %r14
jmp 0x31a2
callq 0x2030
andl $0x0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3ba5
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 0x3b84
movslq 0x10(%rbx), %r13
movq %r13, %rdi
incq %rdi
callq 0x2100
xorl %ecx, %ecx
testl %r13d, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
cmpq %rcx, %rdx
je 0x3b7c
movb (%r12,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x3b6a
movb $0x0, (%rax,%rdx)
movq %rax, 0x8(%rbx)
cmpq $0x0, (%r15)
je 0x3b91
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_O2/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
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x74fb(%rip), %rcx      # 0xb0b8
movl (%rcx), %ecx
movl %ecx, (%rax)
andq $0x0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
andq $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x74cc(%rip), %rcx      # 0xb0bc
movl (%rcx), %ecx
movl %ecx, (%rax)
andq $0x0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movl %ebx, 0x14(%rax)
andq $0x0, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x748f(%rip), %rcx      # 0xb0c0
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)
andq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x7448(%rip), %rcx      # 0xb0c4
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)
andq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x7401(%rip), %rcx      # 0xb0c8
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)
andq $0x0, 0x18(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x2c(%rbp)
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x2100
movq %rax, %r12
movslq %r15d, %r15
leaq (%rbx,%r15), %r13
movl %r14d, -0x30(%rbp)
subl %r15d, %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 %r13, %rdi
movl %r14d, %esi
callq 0x30dd
testl %eax, %eax
je 0x3d72
movl %eax, (%r12)
movq %r13, 0x8(%r12)
movl %r14d, 0x10(%r12)
movl -0x2c(%rbp), %eax
movl %eax, 0x14(%r12)
andq $0x0, 0x18(%r12)
jmp 0x3dca
movq %r12, %rdi
callq 0x2030
movl -0x2c(%rbp), %esi
incl %esi
leaq 0x3766(%rip), %rdi      # 0x74ec
xorl %eax, %eax
callq 0x2090
leaq 0x3772(%rip), %rdi      # 0x7506
xorl %eax, %eax
callq 0x2090
movslq -0x30(%rbp), %r12
leaq 0x377c(%rip), %r14      # 0x7522
cmpq %r12, %r15
jge 0x3dbf
movsbl (%rbx,%r15), %esi
incq %r15
movq %r14, %rdi
xorl %eax, %eax
callq 0x2090
jmp 0x3da6
pushq $0xa
popq %rdi
callq 0x2040
xorl %r12d, %r12d
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_O2/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
pushq $0x20
popq %rdi
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 0x30dd
testl %eax, %eax
jne 0x3e3e
leaq 0x7290(%rip), %rax      # 0xb0cc
movl (%rax), %eax
movl %eax, (%r12)
movq %r15, 0x8(%r12)
movl %r14d, 0x10(%r12)
movl %ebx, 0x14(%r12)
andq $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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2f94(%rip), %rdi      # 0x7595
callq 0x2050
leaq 0x2f97(%rip), %rdi      # 0x75a4
callq 0x2050
leaq 0x6aaf(%rip), %r13      # 0xb0c8
pushq $0x22
popq %r15
pushq $0xa
popq %r12
testq %rbx, %rbx
je 0x4683
movl (%rbx), %esi
leaq 0x2f25(%rip), %rdi      # 0x7554
xorl %eax, %eax
callq 0x2090
movl (%rbx), %eax
cmpl (%r13), %eax
jne 0x4646
movl %r15d, %edi
callq 0x2040
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x4665
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
jmp 0x4649
movl (%rbx), %eax
cmpl (%r13), %eax
jne 0x4675
movl %r15d, %edi
callq 0x2040
movl %r12d, %edi
callq 0x2040
movq 0x18(%rbx), %rbx
jmp 0x4621
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
testq %r14, %r14
je 0x46c8
movq 0x8(%r14), %rdi
movq 0x18(%r14), %r15
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
jmp 0x46a9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2030
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x139aa(%rip), %rbx     # 0x18370
movq %rbx, %rdi
callq 0x5cd0
leaq 0x139a3(%rip), %r14     # 0x18378
movq %r14, %rdi
callq 0x5cf8
leaq 0x13984(%rip), %r15     # 0x18368
movq (%r15), %r15
testq %r15, %r15
je 0x4a12
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x49fe
movq 0x20(%r15), %rsi
callq 0x4699
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x4a0c
callq 0x4cee
addq $0x28, %r15
jmp 0x49e4
leaq 0x1394f(%rip), %r15     # 0x18368
movq %r15, %rdi
callq 0x5ca8
andq $0x0, (%rbx)
andq $0x0, (%r14)
andq $0x0, (%r15)
leaq 0x1392c(%rip), %rbx     # 0x18360
xorl %eax, %eax
cmpq %rax, (%rbx)
je 0x4a6f
pushq $0x18
popq %r14
xorl %r15d, %r15d
leaq 0x1390f(%rip), %r12     # 0x18358
movl (%r12), %eax
movq (%rbx), %rdi
cmpq %rax, %r15
jae 0x4a66
addq %r14, %rdi
callq 0x5cd0
incq %r15
addq $0x38, %r14
jmp 0x4a49
callq 0x2030
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4ac0
andl $0xffffdfff, %esi       # imm = 0xFFFFDFFF
jle 0x4ac0
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
movl $0x0, %ecx
cmpl %edi, 0x8(%rdx)
jle 0x4ad9
movl (%rdx), %ecx
cmpl %ecx, %esi
jle 0x4ac4
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x4ad9
xorl %ecx, %ecx
jmp 0x4ada
movq 0x10(%rdx), %rdx
imull %edi, %ecx
addl %esi, %ecx
movl -0x8(%rdx,%rcx,8), %eax
movl -0x4(%rdx,%rcx,8), %ecx
shlq $0x20, %rcx
popq %rbp
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4b11
andl $0xffffefff, %esi       # imm = 0xFFFFEFFF
jle 0x4b11
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
cmpl %edi, 0x8(%rdx)
jle 0x4b10
movl 0x4(%rdx), %ecx
cmpl %ecx, %esi
jg 0x4b10
movq 0x18(%rdx), %rax
imull %edi, %ecx
addl %esi, %ecx
movl -0x4(%rax,%rcx,4), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1382e(%rip), %r14     # 0x18350
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x10(%r14), %rcx
testq %r14, %r14
leaq 0x13810(%rip), %rdx     # 0x18348
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %r14, 0x18(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x13801(%rip)     # 0x18350
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
movl %ebx, 0xc(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x137e0(%rip), %r14     # 0x18350
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x10(%r14), %rcx
testq %r14, %r14
leaq 0x137c2(%rip), %rdx     # 0x18348
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %r14, 0x18(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x137b3(%rip)     # 0x18350
movq %rbx, (%rax)
movabsq $-0xffffffff, %rcx      # imm = 0xFFFFFFFF00000001
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1378c(%rip), %r14     # 0x18350
pushq $0x20
popq %rdi
callq 0x2100
leaq 0x10(%r14), %rcx
testq %r14, %r14
leaq 0x1376e(%rip), %rdx     # 0x18348
cmovneq %rcx, %rdx
movq %rax, (%rdx)
movq %r14, 0x18(%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x1375f(%rip)     # 0x18350
movq %rbx, (%rax)
movabsq $-0xfffffffe, %rcx      # imm = 0xFFFFFFFF00000002
movq %rcx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdi)
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x8(%rdi)
movq 0x13729(%rip), %rcx     # 0x18350
testq %rcx, %rcx
je 0x4c39
movups (%rcx), %xmm0
movups %xmm0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rdi)
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq %rax, 0x8(%rdi)
movq 0x136f3(%rip), %rdi     # 0x18350
testq %rdi, %rdi
je 0x4cad
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4c95
movq %rax, 0x136d1(%rip)     # 0x18350
movq 0x10(%rax), %rdi
callq 0x2030
movq 0x136c1(%rip), %rax     # 0x18350
addq $0x10, %rax
jmp 0x4ca9
callq 0x2030
andq $0x0, 0x136ae(%rip)     # 0x18350
leaq 0x1369f(%rip), %rax     # 0x18348
andq $0x0, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x28, %rsp
leaq -0x28(%rbp), %rbx
cmpq $0x0, 0x1367c(%rip)     # 0x18348
je 0x4ce7
movq %rbx, %rdi
callq 0x4c3b
cmpl $0x2, -0x20(%rbp)
jne 0x4cc4
movq -0x28(%rbp), %rdi
callq 0x4cee
jmp 0x4cc4
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4d33
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x4d27
xorl %r14d, %r14d
movslq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
cmpq %rax, %r14
jge 0x4d22
movq (%rdi,%r14,8), %rdi
callq 0x4cee
incq %r14
jmp 0x4d07
callq 0x2030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2030
retq