LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/gregtour[P]minimal-compiler/parser.c
// Function: PrintErrorInput
void PrintErrorInput(L_TOKEN* input, GRAMMAR_TABLE g)
{
    int i;
    if (input)
    {
        printf("Syntax error on line %i: ", (input->line+1));
        if (input->string)
        {
            for (i = 0; i < input->length; i++)
            {
                printf("%c", input->string[i]);
            }
        }
        else
        {
            printf("%s", GetElement(input->token, g));
        }
        printf("\n");
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4d80
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x14(%rdi), %esi
incl %esi
leaq 0x27d4(%rip), %rdi      # 0x7527
xorl %eax, %eax
callq 0x2090
cmpq $0x0, 0x8(%rbx)
je 0x4d81
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x4db6
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
jmp 0x4d64
retq
leaq 0x10(%rbp), %rax
movl (%rbx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2e94
leaq 0x28a4(%rip), %rdi      # 0x7650
movq %rax, %rsi
xorl %eax, %eax
callq 0x2090
pushq $0xa
popq %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0x53b8
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
movl (%rdi), %edi
je 0x53c1
leaq 0x5d27(%rip), %rax      # 0xb0bc
cmpl (%rax), %edi
je 0x53c1
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x53b8
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
jmp 0x539c
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2e94
leaq 0x2266(%rip), %rdi      # 0x7650
movq %rax, %rsi
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x28(%rdi)
je 0x550e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rbp), %r12
leal (%rbx,%rbx), %r13d
pushq $0x20
popq %r15
subl $0x1, %r13d
jb 0x5439
movl %r15d, %edi
callq 0x2040
jmp 0x5429
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5372
leaq 0x1f25(%rip), %rdi      # 0x738c
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x2090
pushq $0x20
popq %r15
movslq 0x20(%r14), %rax
cmpq %rax, %r13
jge 0x54b7
movq 0x28(%r14), %rax
movq (%rax,%r13,8), %rdi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5372
movl %r15d, %edi
callq 0x2040
incq %r13
jmp 0x5475
pushq $0xa
popq %rdi
callq 0x2040
incl %ebx
xorl %r15d, %r15d
movslq 0x20(%r14), %rax
cmpq %rax, %r15
jge 0x5500
movq 0x28(%r14), %rax
movq (%rax,%r15,8), %rdi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebx, %esi
callq 0x53fc
incq %r15
jmp 0x54c4
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/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rbp), %r14
movl 0x20(%rdi), %eax
testl %eax, %eax
jle 0x5596
xorl %r15d, %r15d
cltq
cmpq %rax, %r15
jge 0x55c9
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5540
incq %r15
movl 0x20(%rbx), %eax
jmp 0x555e
cmpq $0x0, 0x8(%rbx)
movl (%rbx), %edi
je 0x55d4
leaq 0x5b16(%rip), %rax      # 0xb0bc
cmpl (%rax), %edi
je 0x55d4
xorl %r14d, %r14d
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jge 0x55c9
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
jmp 0x55ad
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2e94
leaq 0x2054(%rip), %rdi      # 0x7650
movq %rax, %rsi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x5b65
movq %rax, %r13
movq (%rax), %rdi
movq %r12, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5b8b
incl %ebx
movq 0x28(%r13), %rax
testq %rax, %rax
jne 0x5b3c
addq $0x28, %r13
movq %r13, %r14
pushq $0x30
popq %rdi
callq 0x2100
movq %rax, (%r14)
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
andq $0x0, 0x28(%rax)
movl %ebx, 0x18(%rax)
incl %ebx
jmp 0x5b8d
xorl %ebx, %ebx
movl %ebx, %eax
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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movq (%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x5be4
movq %rax, %r13
movq 0x8(%rax), %rdi
movq %r15, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5c03
incl %ebx
movq 0x18(%r13), %rax
testq %rax, %rax
jne 0x5bba
addq $0x18, %r13
movq %r13, %r12
pushq $0x20
popq %rdi
callq 0x2100
movq %rax, (%r12)
movq %r15, 0x8(%rax)
movq %r14, (%rax)
andq $0x0, 0x18(%rax)
movl %ebx, 0x10(%rax)
incl %ebx
jmp 0x5c05
xorl %ebx, %ebx
movl %ebx, %eax
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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq (%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x5c67
movq %rax, %r14
movq 0x8(%rax), %rdi
movq %r13, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5c95
incl %ebx
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0x5c3d
addq $0x28, %r14
movq %r14, %r15
pushq $0x30
popq %rdi
callq 0x2100
movq %rax, (%r15)
movq %r13, 0x8(%rax)
movq %r12, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
andq $0x0, 0x28(%rax)
movl %ebx, 0x20(%rax)
incl %ebx
jmp 0x5c97
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %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/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5cc7
movq 0x28(%rdi), %rax
movq %rax, (%rbx)
callq 0x2030
jmp 0x5cb1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5cef
movq 0x18(%rdi), %rax
movq %rax, (%rbx)
callq 0x2030
jmp 0x5cd9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x125f3(%rip), %r15     # 0x18300
leaq 0x1260c(%rip), %r12     # 0x18320
movq (%rbx), %r14
testq %r14, %r14
je 0x5d4a
movq 0x28(%r14), %rax
movq %rax, (%rbx)
movq 0x10(%r14), %rax
cmpq %r15, %rax
sete %cl
cmpq %r12, %rax
sete %al
orb %cl, %al
jne 0x5d40
leaq 0x10(%r14), %rdi
callq 0x5cd0
movq %r14, %rdi
callq 0x2030
jmp 0x5d14
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testq %rdi, %rdi
je 0x5d68
incl %eax
movq 0x28(%rdi), %rdi
jmp 0x5d5b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testq %rdi, %rdi
je 0x5d7d
incl %eax
movq 0x18(%rdi), %rdi
jmp 0x5d70
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
testq %rdi, %rdi
je 0x5d92
incl %eax
movq 0x28(%rdi), %rdi
jmp 0x5d85
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x5dbc
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5dbc
movq 0x18(%rbx), %rbx
jmp 0x5da1
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x5dec
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5dec
movq 0x28(%rbx), %rbx
jmp 0x5dd1
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rbx, %rbx
je 0x5e1b
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x5e1b
movq 0x28(%rbx), %rbx
jmp 0x5e01
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/gregtour[P]minimal-compiler/tables.c
// Function: DecompressActionTable
void DecompressActionTable(int* source_data, ACTION* dest_data, unsigned int compressed_size, unsigned int total_size)
{
    unsigned int mode = 0;
    unsigned int index = 0;
    unsigned int read_index = 0;
    int lengthRep = 0;
    ACTION copy_value;
    copy_value.type = 0;
    copy_value.value = 0;

    while (/*read_index < compressed_size &&*/ index < total_size)
    {
        if (mode == 0)
        {
            lengthRep = source_data[read_index];
            read_index++;
            while (lengthRep && /*read_index < compressed_size &&*/
                    index < total_size)
            {
                dest_data[index].type = source_data[read_index];
                read_index++;
                dest_data[index].value = source_data[read_index];
                read_index++;
                index++;
                lengthRep--;
            }
            lengthRep = 0;
            mode = 1;
        } 
        else if (mode == 1) 
        {
            lengthRep = source_data[read_index];
            read_index++;
            copy_value.type = source_data[read_index];
            read_index++;
            copy_value.value = source_data[read_index];
            read_index++;
            while (lengthRep && index < total_size)
            {
                dest_data[index].type = copy_value.type;
                dest_data[index].value = copy_value.value;
                index++;
                lengthRep--;
            }
            lengthRep = 0;
            mode = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movl %ecx, %eax
xorl %r11d, %r11d
movl $0x1, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl %ecx, %r8d
jae 0x5fa8
movl %r9d, %r10d
movl (%rdi,%r10,4), %r10d
movl %r8d, %r8d
testl %r11d, %r11d
je 0x5f6d
leal 0x1(%r9), %r11d
movl (%rdi,%r11,4), %r11d
leal 0x2(%r9), %ebx
movl (%rdi,%rbx,4), %ebx
addl $-0x1, %r10d
jae 0x5f64
cmpq %rax, %r8
jae 0x5f64
movl %r11d, (%rsi,%r8,8)
movl %ebx, 0x4(%rsi,%r8,8)
incq %r8
jmp 0x5f4b
addl $0x3, %r9d
xorl %r11d, %r11d
jmp 0x5f28
addl $0x2, %r9d
movl %r9d, %r11d
leal -0x1(%r11), %r9d
addl $-0x1, %r10d
jae 0x5fa3
cmpq %rax, %r8
jae 0x5fa3
movl %r9d, %r9d
movl (%rdi,%r9,4), %r9d
movl %r9d, (%rsi,%r8,8)
movl %r11d, %r9d
movl (%rdi,%r9,4), %r9d
movl %r9d, 0x4(%rsi,%r8,8)
incq %r8
addl $0x2, %r11d
jmp 0x5f74
movl %edx, %r11d
jmp 0x5f28
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/gregtour[P]minimal-compiler/typechecker.c
// Function: LinkFunctionRoot
void LinkFunctionRoot(TYPE type, const char* identifier, SYNTAX_TREE* parameters, SYNTAX_TREE* source)
{
    VARLIST* paramList = NULL;
    printf("Linking function %s %s.\n", TypeString(type), identifier);

    // parse function parameters
    if (parameters && parameters->production != PROD_PARAM_STAR)
        // <param*> ::= <epsilon>
    {
        while (parameters)
        {
            const char* identifier;
            TYPE type;
            int result;

            Assert(parameters->children && parameters->numChildren >= 3);
            Assert(parameters->children[0] && parameters->children[0]->string);
            Assert(parameters->children[2]->token == SYMBOL_TYPE);

            identifier = parameters->children[0]->string;
            type = DeriveType(parameters->children[2]);

            result = AddVariableToList(&paramList, type, identifier);
            if (result == 0)
            {
                CompilerError("Parameter variable redefined.");
            }

            // (a) <param*> ::= <identifier> : <type>
            // (b) <param*> ::= <identifier> : <type> , <param*>
            if (parameters->production == PROD_PARAM_STAR_IDENTIFIER_B)
            {   parameters = parameters->children[4]; }
            else 
            {   parameters = NULL; }
        }
    }

    Assert(source->token == SYMBOL_BLOCK);
    // check for redundant functions and link global methods
    if (AddFunctionToList(&gPrgrmFunctions, type, identifier, paramList, (SYNTAX_BLOCK*)source) == 0)
    {
        if (paramList)
        {
            FreeVariableList(&paramList);
        }

        CompilerError("Function redefined.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
andq $0x0, -0x30(%rbp)
callq 0x5fac
leaq 0x19bf(%rip), %rdi      # 0x79c3
xorl %ebx, %ebx
movq %rax, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2090
testq %r12, %r12
je 0x6085
cmpl $0xe, 0x4(%r12)
jne 0x6024
xorl %ebx, %ebx
jmp 0x6085
movq %r13, -0x38(%rbp)
leaq -0x30(%rbp), %r13
movabsq $0x100000004, %rbx      # imm = 0x100000004
movq 0x28(%r12), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5b9e
testl %eax, %eax
jne 0x6067
leaq 0x1984(%rip), %rdi      # 0x79dc
leaq 0x199b(%rip), %rsi      # 0x79fa
pushq $0x2c
popq %rdx
callq 0x4784
cmpl $0xd, 0x4(%r12)
jne 0x607d
movq 0x28(%r12), %rax
movq 0x20(%rax), %r12
testq %r12, %r12
jne 0x6036
movq -0x30(%rbp), %rbx
movq -0x38(%rbp), %r13
leaq 0x122ec(%rip), %rdi     # 0x18378
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x5c16
testl %eax, %eax
jne 0x60c7
cmpq $0x0, -0x30(%rbp)
je 0x60b1
leaq -0x30(%rbp), %rdi
callq 0x5cd0
leaq 0x1950(%rip), %rdi      # 0x7a08
leaq 0x193b(%rip), %rsi      # 0x79fa
pushq $0x41
popq %rdx
callq 0x4784
addq $0x18, %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/typechecker.c
// Function: LinkVariableRoot
void LinkVariableRoot(TYPE type, const char* identifier)
{
    if (type.basic == TYPE_VOID)
    {
        CompilerError("Global variable defined as void.");
        return;
    }

    printf("Linking variable %s %s.\n", TypeString(type), identifier);
    if (AddVariableToList(&gPrgrmVariables, type, identifier) == 0)
    {
        CompilerError("Global variable redefined.");
    }
}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
jne 0x6101
leaq 0x1926(%rip), %rdi      # 0x7a1c
leaq 0x18fd(%rip), %rsi      # 0x79fa
pushq $0x4a
jmp 0x6152
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5fac
leaq 0x1923(%rip), %rdi      # 0x7a3d
movq %rax, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2090
leaq 0x12242(%rip), %rdi     # 0x18370
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5b9e
testl %eax, %eax
popq %rbx
popq %r14
popq %rbp
je 0x6142
retq
leaq 0x190d(%rip), %rdi      # 0x7a56
leaq 0x18aa(%rip), %rsi      # 0x79fa
pushq $0x51
popq %rdx
jmp 0x4784
// File: /workspace/github_c_makefile_star2_O2/gregtour[P]minimal-compiler/typechecker.c
// Function: LinkSourceRoot
void LinkSourceRoot(const char* sourceFile, SYNTAX_TREE** tree)
{
    printf("Linking source file %s.\n", sourceFile);
    
    // allow for linking multiple source files in one project
    if (AddSourceToList(&gPrgrmSources, sourceFile, NULL, NULL) != 0)
    {
        SOURCE* source = GetSourceFromList(gPrgrmSources, sourceFile);

        source->lexing = LexSource(sourceFile, 
                                   &source->buffer, 
                                   CONTEXT_FREE_GRAMMAR);
        if (source->lexing == NULL) {
            printf("Error lexing source '%s'.\n", sourceFile);
            FreeLexing(source->lexing, source->buffer);
            return;
        }

        source->syntax = ParseSource(source->lexing,
                                     PARSE_TABLE,
                                     CONTEXT_FREE_GRAMMAR);
        if (source->syntax == NULL) {
            printf("Error parsing source '%s'.\n", sourceFile);
            FreeLexing(source->lexing, source->buffer);
            source->lexing = NULL;
            return;
        }

        PrePassReductions(&source->syntax);
        SourceReductions(&source->syntax);
        // add to intermediate framework
        FirstPassStaticAnalyzer(source->syntax);
    }
    
    // link standard library
    // if (IsLibraryDefinition(sourceFile))
    // {
    //    LinkLibrary(sourceFile);
    // }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x1902(%rip), %rdi      # 0x7a71
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2090
leaq 0x121e8(%rip), %r14     # 0x18368
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x5b1c
testl %eax, %eax
je 0x6293
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x5df4
movq %rax, %r14
leaq 0x20(%rax), %rsi
leaq 0x5870(%rip), %r15      # 0xba20
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3eff
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x6248
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x40(%rsp)
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
leaq 0x12047(%rip), %rcx     # 0x18248
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x4faf
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6270
addq $0x10, %r14
movq %r14, %rdi
callq 0x5610
movq %r14, %rdi
callq 0x57e3
movq (%r14), %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5802
leaq 0x183b(%rip), %rdi      # 0x7a8a
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2090
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4699
leaq 0x182e(%rip), %rdi      # 0x7aa5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2090
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
callq 0x4699
andq $0x0, 0x8(%r14)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/htsfile.c
// Function: error
void HTS_FORMAT(HTS_PRINTF_FMT, 1, 2) error(const char *format, ...)
{
    int err = errno;
    va_list args;
    va_start(args, format);
    fflush(stdout);
    fprintf(stderr, "htsfile: ");
    vfprintf(stderr, format, args);
    if (err) fprintf(stderr, ": %s\n", strerror(err));
    else fprintf(stderr, "\n");
    fflush(stderr);
    va_end(args);
    status = EXIT_FAILURE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %rsi, 0x8(%r15)
movq %rdx, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %r8, 0x20(%r15)
movq %r9, 0x28(%r15)
testb %al, %al
je 0x5b60
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
callq 0x4050
movl (%rax), %ebp
movq %rsp, %r14
movq %r15, 0x10(%r14)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0xa9422(%rip), %rax     # 0xaefb0
movq (%rax), %rdi
callq 0x45c0
movq 0xa9433(%rip), %r15     # 0xaefd0
movq (%r15), %rcx
leaq 0x7c45d(%rip), %rdi     # 0x82004
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x49f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x46d0
movq (%r15), %rbx
testl %ebp, %ebp
jne 0x5bf2
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4670
movq (%r15), %rdi
callq 0x45c0
movl $0x1, 0xa9988(%rip)     # 0xaf56c
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x4150
leaq 0x8525f(%rip), %rsi     # 0x8ae5f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4750
jmp 0x5bd2
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/htsfile.c
// Function: view_raw
static void view_raw(hFILE *fp, const char *filename)
{
    int c, prev;
    for (prev = '\n'; (c = hgetc(fp)) != EOF; prev = c)
        if (isprint(c) || c == '\n' || c == '\t') putchar(c);
        else if (c == '\r') fputs("\\r", stdout);
        else if (c == '\0') fputs("\\0", stdout);
        else printf("\\x%02x", c);

    if (prev != '\n') putchar('\n');

    if (herrno(fp)) {
        errno = herrno(fp);
        error("reading \"%s\" failed", filename);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq %rdi, %r14
pushq $0xa
popq %r15
movq 0xa8ba5(%rip), %rbx     # 0xaefb0
leaq 0x7bfb0(%rip), %r12     # 0x823c2
leaq 0x7bfaf(%rip), %r13     # 0x823c8
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
jbe 0x6430
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r14)
movzbl (%rax), %ebp
jmp 0x643f
movq %r14, %rdi
callq 0x66b5
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x64a2
callq 0x4520
leal -0x9(%rbp), %ecx
cmpl $0x2, %ecx
jb 0x646e
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
jne 0x646e
testl %ebp, %ebp
je 0x647a
cmpl $0xd, %ebp
jne 0x648e
movq (%rbx), %rsi
movq %r12, %rdi
jmp 0x6484
movl %ebp, %edi
callq 0x4700
movl %ebp, %r15d
jmp 0x6419
movq (%rbx), %rsi
leaq 0x7bf41(%rip), %rdi     # 0x823c5
callq 0x4570
movl %ebp, %r15d
jmp 0x6419
movq %r13, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4060
movl %ebp, %r15d
jmp 0x6419
cmpl $0xa, %r15d
je 0x64b0
pushq $0xa
popq %rdi
callq 0x4700
movl 0x34(%r14), %ebx
testl %ebx, %ebx
je 0x64df
callq 0x4050
movl %ebx, (%rax)
leaq 0x7bee8(%rip), %rdi     # 0x823ae
movq (%rsp), %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5afc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/openshmem-org[P]openshmem-examples/c/finc.c
// Function: main
int
main()
{
    int me;
    int old;

    shmem_init();
    me = shmem_my_pe();

    old = -1;
    dst = 22;
    shmem_barrier_all();

    if (me == 0) {
        old = shmem_int_atomic_fetch_inc(&dst, 1);
    }
    shmem_barrier_all();

    printf("%d: old = %d, dst = %d\n", me, old, dst);

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
callq 0x1080
callq 0x1060
movl %eax, %ebx
movl $0x16, 0x2eb7(%rip)     # 0x405c
callq 0x1070
testl %ebx, %ebx
je 0x11b3
pushq $-0x1
popq %rbp
jmp 0x11c4
leaq 0x2ea2(%rip), %rdi      # 0x405c
pushq $0x1
popq %rsi
callq 0x1040
movl %eax, %ebp
callq 0x1070
movl 0x2e8d(%rip), %ecx      # 0x405c
leaq 0xe2e(%rip), %rdi       # 0x2004
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1030
callq 0x1050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sushant8421[P]create_your_own_shell/move.c
// Function: main
int main(int ac, char* av[])
{
    char *file= av[1];
    char *location= av[2];
    char newplace[50];

    if(ac!=3)
        formatError();
    else
    {
        if(location[0]=='/')             
        {
            strcat(location,"/");          
            strcat(location,file);
            if(rename(file, location) != 0)
                printf("Error:\nDirectory not found\n");
        }
        else
        {
            DIR *isD;
            isD = opendir(location);                // check if argument is a DIR in CWD

            if(isD==NULL)
            {
                if( rename(file,location)!= 0)
                    printf("Error: File not moved\n");
            }
            else
            {
                char *ptrL;
                ptrL = getcwd(newplace, 50);        // get current working directory path 
                strcat(newplace,"/");               
                strcat(newplace,location);          // attach mv location to path ptrL
                strcat(newplace,"/");
                strcat(newplace, file);             // keep original file name
                if(rename(file,ptrL)!=-1){
                    //printf("Successful\n");
                }
                else
                    printf("Error:\nDirectory not found in CWD\n");
                closedir(isD);
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x3, %edi
jne 0x12ba
movq 0x8(%rsi), %rbx
movq 0x10(%rsi), %r15
cmpb $0x2f, (%r15)
jne 0x120d
movq %r15, %rdi
callq 0x1050
movw $0x2f, (%r15,%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1090
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
testl %eax, %eax
je 0x12a9
leaq 0xe34(%rip), %rdi       # 0x203c
jmp 0x12a4
movq %r15, %rdi
callq 0x1040
testq %rax, %rax
je 0x128e
movq %rax, %r14
leaq -0x70(%rbp), %r12
pushq $0x32
popq %rsi
movq %r12, %rdi
callq 0x1060
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0x1050
movw $0x2f, %r13w
movw %r13w, -0x70(%rbp,%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1090
movq %r12, %rdi
callq 0x1050
movw %r13w, -0x70(%rbp,%rax)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1090
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x1080
cmpl $-0x1, %eax
jne 0x1284
leaq 0xd85(%rip), %rdi       # 0x2004
callq 0x1030
movq %r14, %rdi
callq 0x1070
jmp 0x12a9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
testl %eax, %eax
je 0x12a9
leaq 0xd82(%rip), %rdi       # 0x2026
callq 0x1030
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12bf
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: createList
List createList()
{
    List head;
    head=(List)malloc(sizeof(Node));
    if(head==NULL)
    {
        fatal("memory alloc failed!");
    }
    head->next=NULL;
    return head;
}

// Assembly:
pushq %rax
pushq $0x10
popq %rdi
callq 0x1070
testq %rax, %rax
je 0x11b1
andq $0x0, 0x8(%rax)
popq %rcx
retq
leaq 0xe4c(%rip), %rdi       # 0x2004
callq 0x11bd
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: delete2
void delete2(Node* node)
{
    assert(node!=NULL);
    Node* next=node->next;
    if(next==NULL)
    {
        free(node);
        node=NULL;
    }
    else
    {
        node->next=next->next;
        node->value=next->value;
        free(next);
        next=NULL;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x12f5
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x12ea
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movl (%rax), %ecx
movl %ecx, (%rdi)
jmp 0x12ed
movq %rdi, %rax
movq %rax, %rdi
jmp 0x1030
pushq %rax
leaq 0xd7f(%rip), %rdi       # 0x207c
leaq 0xd20(%rip), %rsi       # 0x2024
leaq 0xd7c(%rip), %rcx       # 0x2087
pushq $0x4d
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: findPrev
Node* findPrev(Node* node, List list)
{
    assert(list!=NULL);
    Node* current=list->next;
    while(current!=NULL && current->next!=node)
    {
        current=current->next;
    }
    return current;
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1373
movq 0x8(%rsi), %rcx
movq %rcx, %rax
testq %rcx, %rcx
je 0x1371
movq 0x8(%rax), %rcx
cmpq %rdi, %rcx
jne 0x1360
popq %rcx
retq
leaq 0xc9f(%rip), %rdi       # 0x2019
leaq 0xca3(%rip), %rsi       # 0x2024
leaq 0xd25(%rip), %rcx       # 0x20ad
pushq $0x6e
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: sort
List sort(List list)
{
    Node* tail = NULL;
    while(tail != list->next)
    {
        Node* pre = list;
        Node* cur = pre->next;
        while(cur != tail && cur->next != tail)
        {
            Node *tmp=cur->next;
            if( cur->value > tmp->value )
            {
                //swap current and next node
                pre->next = tmp;
                cur->next = tmp->next;
                pre->next->next = cur;
            }
            pre = pre->next;
            cur = pre->next;
        }
        tail = cur;
    }
    return list;
}

// Assembly:
movq %rdi, %rax
xorl %ecx, %ecx
movq 0x8(%rax), %rdx
cmpq %rdx, %rcx
je 0x13e8
movq %rax, %r8
cmpq %rcx, %rdx
je 0x139a
movq %rdx, %rsi
movq 0x8(%rdx), %rdx
cmpq %rcx, %rdx
je 0x13e3
movq %r8, %rdi
movl (%rsi), %r9d
movq %rsi, %r8
cmpl (%rdx), %r9d
jle 0x13a6
movq %rdx, 0x8(%rdi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rsi)
movq 0x8(%rdi), %rdx
movq %rsi, 0x8(%rdx)
movq 0x8(%rdi), %r8
movq 0x8(%r8), %rdx
jmp 0x13a6
movq %rsi, %rcx
jmp 0x139a
retq
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: reverse
List reverse(List list)
{
    assert(list!=NULL);
    if(list->next==NULL)
    {
        return list;
    }
    Node* p;
    Node* q;
    Node* tmp;
    p=list->next;
    q=p->next;
    p->next=NULL;
    while(q!=NULL)
    {
        tmp=q->next;
        q->next=p;
        p=q;
        q=tmp;
    }
    list->next=p;
    return list;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1416
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1411
xorl %ecx, %ecx
movq %rcx, %rdx
movq %rax, %rcx
movq 0x8(%rax), %rax
movq %rdx, 0x8(%rcx)
testq %rax, %rax
jne 0x13fa
movq %rcx, 0x8(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0xbfc(%rip), %rdi       # 0x2019
leaq 0xc00(%rip), %rsi       # 0x2024
leaq 0xc9f(%rip), %rcx       # 0x20ca
movl $0x94, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/mcxiaoke[P]dsaac/ch3/list_simple/list.c
// Function: main
int main(int argc, char **argv)
{
    List list=createList();
    int i;
    Node* lastNode=list;
    for(i=0; i<10; i++)
    {
        Node* node=(Node*)malloc(sizeof(Node));
        if(node==NULL)
        {
            fatal("memory allocate failed.");
        }
        Node* current=insert(rand()%100, lastNode, list);
        //Node* current=insert(i, lastNode, list);
        lastNode=current;
    }
    print(list);
    sort(list);
    print(list);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0xa
popq %rbp
callq 0x119c
movq %rax, %rbx
pushq $0x64
popq %r15
movq %rax, %r14
subl $0x1, %ebp
jb 0x1529
callq 0x1090
cltd
idivl %r15d
movl %edx, %edi
movq %r14, %rsi
callq 0x1313
jmp 0x150c
movq %rbx, %rdi
callq 0x1435
movq %rbx, %rdi
callq 0x1395
movq %rbx, %rdi
callq 0x1435
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/kilobyte[P]colormatch/nearest256.c
// Function: main
int main()
{
    for (int c = 0; c < 16777216; ++c)
    {
        nt[c] = closest(c);
        if (!(c&0xff))
            printf("%06X\n", c);
    }

    int fd = creat("best.rgb", 0666);
    write(fd, nt, sizeof(nt));
    close(fd);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2ea2(%rip), %r15      # 0x4090
leaq 0xe0f(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
cmpq $0x1000000, %r14        # imm = 0x1000000
je 0x124f
xorl %ebp, %ebp
movl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpl $0x100, %ebp            # imm = 0x100
je 0x1234
movl %ebp, %edi
callq 0x1b48
movl %eax, %edi
movl %r14d, %esi
callq 0x1b00
cmpl %r12d, %eax
cmovll %eax, %r12d
cmovll %ebp, %r13d
incl %ebp
jmp 0x120c
movb %r13b, (%r14,%r15)
testb %r14b, %r14b
jne 0x124a
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
incq %r14
jmp 0x11f8
leaq 0xdb4(%rip), %rdi       # 0x200a
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x10b0
movl %eax, %ebx
leaq 0x2e27(%rip), %rsi      # 0x4090
movl $0x1000000, %edx        # imm = 0x1000000
movl %eax, %edi
callq 0x1040
movl %ebx, %edi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ZmengXu[P]boxMesh/boxMesh.C
// Function: main
int main(int argc, char *argv[])
{
    int Nx, Ny, Nz;
    double Lx, Ly, Lz;
    if ( argc != 7 ) // argc should be 2 for correct execution
        // We print argv[0] assuming it is the program name
        cout << "usage: " << argv[0] << " Nx Ny Nz Lx Ly Lz\n";
    else
    {
        Nx = atoi(argv[1]);
        Ny = atoi(argv[2]);
        Nz = atoi(argv[3]);
        Lx = atof(argv[4]);
        Ly = atof(argv[5]);
        Lz = atof(argv[6]);

        struct stat info;
        if( stat("constant/polyMesh", &info)==0 )   // Check if directory exists.
        boxMesh(Nx,Ny,Nz,Lx,Ly,Lz);
        else
            cout << "Please create directory constant/polyMesh first\n";
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %r14
cmpl $0x7, %edi
jne 0x4856
movq 0x8(%r14), %rdi
callq 0x2200
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x2200
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x2200
movl %eax, %r12d
movq 0x20(%r14), %rdi
callq 0x2180
movsd %xmm0, -0x38(%rbp)
movq 0x28(%r14), %rdi
callq 0x2180
movsd %xmm0, -0x30(%rbp)
movq 0x30(%r14), %rdi
callq 0x2180
movsd %xmm0, -0x28(%rbp)
leaq 0x1dc8(%rip), %rdi      # 0x65fe
leaq -0xc8(%rbp), %rsi
callq 0x2130
testl %eax, %eax
je 0x4895
movq 0x4773(%rip), %rdi      # 0x8fc0
leaq 0x1dbc(%rip), %rsi      # 0x6610
jmp 0x487e
movq 0x4763(%rip), %rdi      # 0x8fc0
leaq 0x1d7e(%rip), %rsi      # 0x65e2
callq 0x2140
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2140
leaq 0x1d6f(%rip), %rsi      # 0x65ea
movq %rax, %rdi
callq 0x2140
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
movl %r15d, %esi
movl %r12d, %edx
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
callq 0x46c8
jmp 0x4883
nop
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.14/condvar.c
// Function: main
int main(){
	int i, flag_is_set;
	pthread_t thread_id;
	char option;

	initialize_flag();

	pthread_create(&thread_id, NULL, &thread_function, NULL);

	printf("Presione enter para empezar a generar listas aleatorias...\n");

	getchar();

	do{
		set_thread_flag();

		pthread_mutex_lock (&thread_flag_mutex);
		while(thread_flag)
			pthread_cond_wait(&thread_flag_cv, &thread_flag_mutex);
		pthread_mutex_unlock (&thread_flag_mutex);

		for(i = 0; i < TAM; ++i)
			printf("%d, ", lista_random[i]);

		printf("\nGenerar otra?: (s/n)\n");
		scanf("%c", &option);
		getchar();
		printf("\n");

	}while(option == 's');

	printf("\nPrograma finalizado!\n");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x137b
leaq 0xd1(%rip), %rdx        # 0x12fa
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10c0
leaq 0xdcf(%rip), %rdi       # 0x200c
callq 0x1040
callq 0x1090
leaq 0x2e62(%rip), %rbx      # 0x40b0
leaq 0x2ebb(%rip), %r12      # 0x4110
leaq 0xda8(%rip), %r14       # 0x2004
leaq 0x2e7d(%rip), %r15      # 0x40e0
callq 0x13a4
movq %rbx, %rdi
callq 0x10f0
cmpl $0x0, 0x2e61(%rip)      # 0x40d8
je 0x1286
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1050
jmp 0x1270
movq %rbx, %rdi
callq 0x10b0
xorl %r13d, %r13d
cmpq $0x50, %r13
je 0x12ac
movl (%r13,%r12), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1060
addq $0x4, %r13
jmp 0x1291
leaq 0xd94(%rip), %rdi       # 0x2047
callq 0x1040
leaq 0xd4a(%rip), %rdi       # 0x2009
leaq -0x29(%rbp), %rsi
xorl %eax, %eax
callq 0x10d0
callq 0x1090
pushq $0xa
popq %rdi
callq 0x1030
cmpb $0x73, -0x29(%rbp)
je 0x1263
leaq 0xd79(%rip), %rdi       # 0x205d
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.14/condvar.c
// Function: do_work
void do_work(){
	int i;
	for(i = 0; i < TAM; ++i)
		lista_random[i] = rand() % 100;
	clear_thread_flag();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
pushq $0x64
popq %r14
leaq 0x2dbd(%rip), %r15      # 0x4110
cmpq $0x50, %rbx
je 0x136c
callq 0x1100
cltd
idivl %r14d
movl %edx, (%rbx,%r15)
addq $0x4, %rbx
jmp 0x1353
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13dd
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.14/condvar.c
// Function: set_thread_flag
void set_thread_flag ()
{
	/* Lock the mutex before accessing the flag value. */
	int val = pthread_mutex_trylock (&thread_flag_mutex);
	/* Set the flag value, and then signal in case thread_function is
	blocked, waiting for the flag to become set. However,
	thread_function can’t actually check the flag until the mutex is
	unlocked. */
	thread_flag = 1;
	pthread_cond_signal (&thread_flag_cv);
	/* Unlock the mutex. */
	pthread_mutex_unlock (&thread_flag_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2cff(%rip), %rbx      # 0x40b0
movq %rbx, %rdi
callq 0x1070
movl $0x1, 0x2d15(%rip)      # 0x40d8
leaq 0x2d16(%rip), %rdi      # 0x40e0
callq 0x1080
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.14/condvar.c
// Function: clear_thread_flag
void clear_thread_flag ()
{
	/* Lock the mutex before accessing the flag value. */
	pthread_mutex_trylock (&thread_flag_mutex);
	/* Set the flag value, and then signal in case thread_function is
	blocked, waiting for the flag to become set. However,
	thread_function can’t actually check the flag until the mutex is
	unlocked. */
	thread_flag = 0;
	pthread_cond_signal (&thread_flag_cv);
	/* Unlock the mutex. */
	pthread_mutex_unlock (&thread_flag_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x2cc6(%rip), %rbx      # 0x40b0
movq %rbx, %rdi
callq 0x1070
andl $0x0, 0x2cdf(%rip)      # 0x40d8
leaq 0x2ce0(%rip), %rdi      # 0x40e0
callq 0x1080
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O2/agraf[P]kvmbench/ht.c
// Function: pin_thread
int pin_thread(pthread_t t, int core_id) {
    cpu_set_t cpuset;

    CPU_ZERO(&cpuset);
    CPU_SET(core_id, &cpuset);

    return pthread_setaffinity_np(t, sizeof(cpu_set_t), &cpuset);
}

// Assembly:
subq $0x88, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpl $0x3ff, %esi            # imm = 0x3FF
ja 0x1284
pushq $0x1
popq %rax
movl %esi, %ecx
shlq %cl, %rax
shrl $0x6, %esi
orq %rax, (%rsp,%rsi,8)
movq %rsp, %rdx
movl $0x80, %esi
callq 0x1040
addq $0x88, %rsp
retq