LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x57c7
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5767
movl (%rbx), %eax
leaq 0x6959(%rip), %rcx      # 0xc0bc
cmpl (%rcx), %eax
jne 0x57a4
leaq 0x10(%rbp), %rax
movl (%rbx), %edi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2db4
leaq 0x2ebe(%rip), %rdi      # 0x8650
movq %rax, %rsi
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
cmpl $0x0, 0x10(%rbx)
jle 0x57c7
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x57ad
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x58de
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x10(%rbp), %r15
movl %esi, %r12d
addl %ebx, %r12d
je 0x580a
movl $0x20, %edi
callq 0x2040
decl %r12d
jne 0x57fb
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x5740
leaq 0x2b57(%rip), %rdi      # 0x838c
xorl %eax, %eax
callq 0x2090
cmpl $0x0, 0x20(%r14)
jle 0x5885
xorl %r12d, %r12d
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x5740
movl $0x20, %edi
callq 0x2040
incq %r12
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jl 0x5846
movl $0xa, %edi
callq 0x2040
cmpl $0x0, 0x20(%r14)
jle 0x58d2
incl %ebx
xorl %r12d, %r12d
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdi
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movl %ebx, %esi
callq 0x57d0
incq %r12
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jl 0x589b
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/parser.c
// Function: 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
cmpl $0x0, 0x20(%rdi)
jle 0x5973
cmpl $0x0, 0x20(%rbx)
jle 0x5968
xorl %r15d, %r15d
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 0x5910
incq %r15
movslq 0x20(%rbx), %rax
cmpq %rax, %r15
jl 0x5933
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
je 0x5987
movl (%rbx), %eax
leaq 0x6739(%rip), %rcx      # 0xc0bc
cmpl (%rcx), %eax
jne 0x59c5
movl (%rbx), %edi
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x2db4
leaq 0x2c9f(%rip), %rdi      # 0x8650
movq %rax, %rsi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2090
cmpl $0x0, 0x10(%rbx)
jle 0x5968
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
incq %r14
movslq 0x10(%rbx), %rax
cmpq %rax, %r14
jl 0x59ce
jmp 0x5968
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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, %r13
movq (%rdi), %rax
xorl %ebx, %ebx
movq %rax, %r14
testq %rax, %rax
je 0x60d6
movq (%r14), %rdi
movq %r12, %rsi
callq 0x20c0
testl %eax, %eax
je 0x610c
incl %ebx
movq 0x28(%r14), %rax
testq %rax, %rax
jne 0x60b4
movl $0x30, %edi
callq 0x2100
leaq 0x28(%r14), %rcx
testq %r14, %r14
cmoveq %r13, %rcx
movq %rax, (%rcx)
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x28(%rax)
movl %ebx, 0x18(%rax)
incl %ebx
jmp 0x610e
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_O1/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
movq %rax, %r13
testq %rax, %rax
je 0x615e
movq 0x8(%r13), %rdi
movq %r15, %rsi
callq 0x20c0
testl %eax, %eax
je 0x618c
incl %ebx
movq 0x18(%r13), %rax
testq %rax, %rax
jne 0x613b
movl $0x20, %edi
callq 0x2100
leaq 0x18(%r13), %rcx
testq %r13, %r13
cmoveq %r12, %rcx
movq %rax, (%rcx)
movq %r15, 0x8(%rax)
movq %r14, (%rax)
movq $0x0, 0x18(%rax)
movl %ebx, 0x10(%rax)
incl %ebx
jmp 0x618e
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_O1/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, %r14
movq (%rdi), %rax
xorl %ebx, %ebx
movq %rax, %r15
testq %rax, %rax
je 0x61e9
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0x20c0
testl %eax, %eax
je 0x6227
incl %ebx
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x61c6
movl $0x30, %edi
callq 0x2100
leaq 0x28(%r15), %rcx
testq %r15, %r15
cmoveq %r14, %rcx
movq %rax, (%rcx)
movq %r13, 0x8(%rax)
movq %r12, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x28(%rax)
movl %ebx, 0x20(%rax)
incl %ebx
jmp 0x6229
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_O1/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 (%rdi), %rdi
testq %rdi, %rdi
je 0x625c
movq 0x28(%rdi), %rax
movq %rax, (%rbx)
callq 0x2030
movq (%rbx), %rdi
jmp 0x6246
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 (%rdi), %rdi
testq %rdi, %rdi
je 0x628e
movq 0x18(%rdi), %rax
movq %rax, (%rbx)
callq 0x2030
movq (%rbx), %rdi
jmp 0x6278
movq $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq (%rdi), %r14
testq %r14, %r14
je 0x630d
leaq 0x13045(%rip), %r15     # 0x19300
leaq 0x1305e(%rip), %r12     # 0x19320
movq 0x28(%r14), %rax
movq %rax, (%rbx)
movq 0x10(%r14), %rdi
cmpq %r15, %rdi
sete %al
cmpq %r12, %rdi
sete %cl
orb %al, %cl
jne 0x62fd
testq %rdi, %rdi
je 0x62f5
movq 0x18(%rdi), %rax
movq %rax, 0x10(%r14)
callq 0x2030
movq 0x10(%r14), %rdi
jmp 0x62dd
movq $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x2030
movq (%rbx), %r14
testq %r14, %r14
jne 0x62c2
movq $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x6337
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x632a
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x6352
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x6345
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x636d
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
jne 0x6360
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x639b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x639d
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x6382
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x63d0
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x63d2
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x63b7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x6404
movq %rsi, %r14
movq %rdi, %rbx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x20c0
testl %eax, %eax
je 0x6406
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x63ec
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/tables.c
// Function: DecompressAndPatchParseTable
void DecompressAndPatchParseTable(LR_TABLE* parser, int gotoTable[], int gotoSz, int actionTable[], int actionSz)
{
     parser->gotoTable = (int*)malloc(parser->numStates * parser->numSymbols * sizeof(int));
     parser->actionTable = (ACTION*)malloc(parser->numStates * parser->numTokens * sizeof(ACTION));

     DecompressGotoTable(gotoTable, parser->gotoTable, gotoSz, parser->numStates * parser->numSymbols);
     DecompressActionTable(actionTable, parser->actionTable, actionSz, parser->numStates * parser->numTokens);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movslq 0x8(%rdi), %r14
movslq 0x4(%rdi), %r12
imulq %r14, %r12
movq %r12, %rdi
shlq $0x2, %rdi
callq 0x2100
movq %rax, %r13
movq %rax, 0x18(%r15)
movslq (%r15), %rbx
imulq %r14, %rbx
movq %rbx, %rdi
shlq $0x3, %rdi
callq 0x2100
movq %rax, %r14
movq %rax, 0x10(%r15)
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movl %r12d, %ecx
callq 0x648e
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x656b
// File: /workspace/github_c_makefile_star2_O1/gregtour[P]minimal-compiler/tables.c
// Function: DecompressGotoTable
void DecompressGotoTable(int* source_data, int* 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;
    int copy_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] = source_data[read_index];
                index++; read_index++;
                lengthRep--;
            }
            lengthRep = 0;
            mode = 1;
        } 
        else if (mode == 1) 
        {
            lengthRep = source_data[read_index];
            read_index++;
            copy_value = source_data[read_index];
            read_index++;
            while (lengthRep && index < total_size)
            {
                dest_data[index] = copy_value;
                index++;
                lengthRep--;
            }
            lengthRep = 0;
            mode = 0;
        }
    }
}

// Assembly:
testl %ecx, %ecx
je 0x656a
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %ecx, %eax
xorl %r8d, %r8d
xorl %edx, %edx
xorl %r9d, %r9d
leal 0x1(%r8), %r10d
movl %r8d, %r11d
movl (%rdi,%r11,4), %r11d
testl %r9d, %r9d
jne 0x650e
movl $0x1, %r9d
testl %r11d, %r11d
je 0x655b
cmpl %ecx, %edx
jae 0x655b
movl %edx, %ebx
incq %rbx
movl $0x1, %r14d
subl %r11d, %r14d
xorl %r11d, %r11d
movl %r10d, %r8d
movl %r11d, %r10d
movl %r8d, %r11d
movl (%rdi,%r11,4), %r11d
movl %r11d, -0x4(%rsi,%rbx,4)
incl %r8d
leal -0x1(%r10), %r11d
cmpl %r10d, %r14d
je 0x6509
leaq 0x1(%rbx), %r10
cmpq %rax, %rbx
movq %r10, %rbx
jb 0x64e2
subl %r11d, %edx
jmp 0x655e
addl $0x2, %r8d
xorl %r9d, %r9d
testl %r11d, %r11d
je 0x655e
cmpl %ecx, %edx
jae 0x655e
movl %r10d, %r9d
movl (%rdi,%r9,4), %r9d
movl %edx, %r10d
incq %r10
movl $0x1, %ebx
subl %r11d, %ebx
xorl %r11d, %r11d
movl %r11d, %r14d
movl %r9d, -0x4(%rsi,%r10,4)
leal -0x1(%r14), %r11d
cmpl %r14d, %ebx
je 0x6553
leaq 0x1(%r10), %r14
cmpq %rax, %r10
movq %r14, %r10
jb 0x6536
subl %r11d, %edx
xorl %r9d, %r9d
jmp 0x655e
movl %r10d, %r8d
cmpl %ecx, %edx
jb 0x64a7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testl %ecx, %ecx
je 0x6667
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %eax
xorl %ebx, %ebx
xorl %edx, %edx
xorl %r9d, %r9d
leal 0x1(%rbx), %r10d
movl %ebx, %r8d
movl (%rdi,%r8,4), %r11d
testl %r9d, %r9d
jne 0x65fa
movl $0x1, %r9d
testl %r11d, %r11d
je 0x6653
cmpl %ecx, %edx
jae 0x6653
movl %edx, %ebx
incq %rbx
movl $0x1, %r14d
subl %r11d, %r14d
xorl %r11d, %r11d
movl %r10d, %r8d
movl %r11d, %r10d
movl %r8d, %r11d
movl (%rdi,%r11,4), %r11d
movl %r11d, -0x8(%rsi,%rbx,8)
leal 0x1(%r8), %r11d
movl (%rdi,%r11,4), %r11d
movl %r11d, -0x4(%rsi,%rbx,8)
leal -0x1(%r10), %r11d
addl $0x2, %r8d
cmpl %r10d, %r14d
je 0x65f5
leaq 0x1(%rbx), %r10
cmpq %rax, %rbx
movq %r10, %rbx
jb 0x65c0
subl %r11d, %edx
jmp 0x6656
leal 0x3(%rbx), %r8d
xorl %r9d, %r9d
testl %r11d, %r11d
je 0x6656
cmpl %ecx, %edx
jae 0x6656
movl %r10d, %r9d
movl (%rdi,%r9,4), %r9d
addl $0x2, %ebx
movl (%rdi,%rbx,4), %r10d
movl %edx, %ebx
incq %rbx
movl $0x1, %r14d
subl %r11d, %r14d
xorl %r11d, %r11d
movl %r11d, %r15d
movl %r9d, -0x8(%rsi,%rbx,8)
movl %r10d, -0x4(%rsi,%rbx,8)
leal -0x1(%r15), %r11d
cmpl %r15d, %r14d
je 0x664b
leaq 0x1(%rbx), %r15
cmpq %rax, %rbx
movq %r15, %rbx
jb 0x6629
subl %r11d, %edx
xorl %r9d, %r9d
jmp 0x6656
movl %r10d, %r8d
movl %r8d, %ebx
cmpl %ecx, %edx
jb 0x6585
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x67de
leaq 0x22ab(%rip), %rdi      # 0x8a78
leaq 0x2282(%rip), %rsi      # 0x8a56
movl $0x4a, %edx
jmp 0x4a54
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, %rcx
shrq $0x22, %rcx
jne 0x6801
leaq 0x55dd(%rip), %rcx      # 0xbdd8
movq (%rcx,%rax,8), %rsi
jmp 0x6808
leaq 0x2213(%rip), %rsi      # 0x8a1b
leaq 0x228a(%rip), %rdi      # 0x8a99
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2090
leaq 0x12b50(%rip), %rdi     # 0x19370
movq %r14, %rsi
movq %rbx, %rdx
callq 0x611f
testl %eax, %eax
popq %rbx
popq %r14
popq %rbp
je 0x6834
retq
leaq 0x2277(%rip), %rdi      # 0x8ab2
leaq 0x2214(%rip), %rsi      # 0x8a56
movl $0x51, %edx
jmp 0x4a54
// File: /workspace/github_c_makefile_star2_O1/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 0x226a(%rip), %rdi      # 0x8acd
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2090
leaq 0x12af4(%rip), %r14     # 0x19368
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6094
testl %eax, %eax
je 0x698a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x63da
movq %rax, %r14
leaq 0x20(%rax), %rsi
leaq 0x617c(%rip), %r15      # 0xca20
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 0x4031
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x693c
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x40(%rsp)
movups %xmm1, 0x30(%rsp)
movups %xmm0, 0x20(%rsp)
leaq 0x12953(%rip), %rcx     # 0x19248
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rax, %rdi
callq 0x535a
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6964
addq $0x10, %r14
movq %r14, %rdi
callq 0x59f0
movq %r14, %rdi
callq 0x5bd1
movq (%r14), %rdi
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5bf0
leaq 0x21a3(%rip), %rdi      # 0x8ae6
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 0x4961
leaq 0x2196(%rip), %rdi      # 0x8b01
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2090
movq 0x8(%r14), %rdi
movq 0x20(%r14), %rsi
callq 0x4961
movq $0x0, 0x8(%r14)
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4a84
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 0xcb4fe(%rip), %rax     # 0xcffb0
movq (%rax), %rdi
callq 0x45c0
movq 0xcb50f(%rip), %r15     # 0xcffd0
movq (%r15), %rcx
leaq 0xa5539(%rip), %rdi     # 0xaa004
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 0x4b16
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x4670
movq (%r15), %rdi
callq 0x45c0
movl $0x1, 0xcba64(%rip)     # 0xd056c
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x4150
leaq 0xae58b(%rip), %rsi     # 0xb30af
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4750
jmp 0x4af6
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xa, %r15d
movq 0xc96df(%rip), %rbx     # 0xcffb0
leaq 0xa3aea(%rip), %r12     # 0xaa3c2
leaq 0xa3ae9(%rip), %r13     # 0xaa3c8
movq 0x8(%r14), %rax
cmpq %rax, 0x10(%r14)
jbe 0x68f6
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%r14)
movzbl (%rax), %ebp
jmp 0x6900
movq %r14, %rdi
callq 0x6bd0
movl %eax, %ebp
cmpl $-0x1, %ebp
je 0x6968
callq 0x4520
leal -0x9(%rbp), %ecx
cmpl $0x2, %ecx
jb 0x6934
movq (%rax), %rax
movslq %ebp, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
jne 0x6934
testl %ebp, %ebp
je 0x6940
cmpl $0xd, %ebp
jne 0x6954
movq (%rbx), %rsi
movq %r12, %rdi
jmp 0x694a
movl %ebp, %edi
callq 0x4700
movl %ebp, %r15d
jmp 0x68df
movq (%rbx), %rsi
leaq 0xa3a7b(%rip), %rdi     # 0xaa3c5
callq 0x4570
movl %ebp, %r15d
jmp 0x68df
movq %r13, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x4060
movl %ebp, %r15d
jmp 0x68df
cmpl $0xa, %r15d
je 0x6978
movl $0xa, %edi
callq 0x4700
movl 0x34(%r14), %ebx
testl %ebx, %ebx
jne 0x698f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4050
movl %ebx, (%rax)
leaq 0xa3a11(%rip), %rdi     # 0xaa3ae
movq (%rsp), %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4a20
nop
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebx, %ebx
jne 0x11c6
leaq 0x2ea2(%rip), %rdi      # 0x405c
movl $0x1, %esi
callq 0x1040
movl %eax, %ebp
callq 0x1070
movl 0x2e8b(%rip), %ecx      # 0x405c
leaq 0xe2c(%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_O1/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 0x12bc
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 0x12ab
leaq 0xe34(%rip), %rdi       # 0x203c
jmp 0x12a6
movq %r15, %rdi
callq 0x1040
testq %rax, %rax
je 0x1290
movq %rax, %r14
leaq -0x70(%rbp), %r12
movl $0x32, %esi
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 0x1286
leaq 0xd83(%rip), %rdi       # 0x2004
callq 0x1030
movq %r14, %rdi
callq 0x1070
jmp 0x12ab
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1080
testl %eax, %eax
je 0x12ab
leaq 0xd80(%rip), %rdi       # 0x2026
callq 0x1030
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd94(%rip), %rdi       # 0x2057
callq 0x1030
movl $0x1, %edi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1070
testq %rax, %rax
je 0x11b6
movq $0x0, 0x8(%rax)
popq %rcx
retq
leaq 0xf49(%rip), %rdi       # 0x2106
leaq 0xe40(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1050
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O1/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 0x1318
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x130d
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movl (%rax), %ecx
movl %ecx, (%rdi)
jmp 0x1310
movq %rdi, %rax
movq %rax, %rdi
jmp 0x1030
pushq %rax
leaq 0xd5c(%rip), %rdi       # 0x207c
leaq 0xcfd(%rip), %rsi       # 0x2024
leaq 0xd59(%rip), %rcx       # 0x2087
movl $0x4d, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x13ba
movq 0x8(%rsi), %rcx
movq %rcx, %rax
testq %rcx, %rcx
je 0x13b8
movq 0x8(%rax), %rcx
cmpq %rdi, %rcx
jne 0x13a7
popq %rcx
retq
leaq 0xc58(%rip), %rdi       # 0x2019
leaq 0xc5c(%rip), %rsi       # 0x2024
leaq 0xcde(%rip), %rcx       # 0x20ad
movl $0x6e, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x1430
xorl %ecx, %ecx
movq %rsi, %rdx
movq %rax, %rsi
movq 0x8(%rdx), %rdi
cmpq %rcx, %rdi
je 0x1424
movl (%rdx), %r8d
cmpl (%rdi), %r8d
jle 0x1417
movq %rdi, 0x8(%rsi)
movq 0x8(%rdi), %rdi
movq %rdi, 0x8(%rdx)
movq 0x8(%rsi), %rdi
movq %rdx, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq 0x8(%rsi), %rdx
cmpq %rcx, %rdx
jne 0x13f2
movq 0x8(%rax), %rsi
movq %rdx, %rcx
cmpq %rsi, %rdx
jne 0x13ec
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1472
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x146d
movq 0x8(%rax), %rcx
movq $0x0, 0x8(%rax)
testq %rcx, %rcx
je 0x1466
movq %rcx, %rdx
movq 0x8(%rcx), %rcx
movq %rax, 0x8(%rdx)
movq %rdx, %rax
testq %rcx, %rcx
jne 0x1451
jmp 0x1469
movq %rax, %rdx
movq %rdx, 0x8(%rdi)
movq %rdi, %rax
popq %rcx
retq
leaq 0xba0(%rip), %rdi       # 0x2019
leaq 0xba4(%rip), %rsi       # 0x2024
leaq 0xc43(%rip), %rcx       # 0x20ca
movl $0x94, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl $0xa, %ebp
callq 0x119c
movq %rax, %rbx
movq %rax, %r14
callq 0x1090
movslq %eax, %rdi
imulq $0x51eb851f, %rdi, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
imull $0x64, %eax, %eax
subl %eax, %edi
movq %r14, %rsi
callq 0x1338
movq %rax, %r14
decl %ebp
jne 0x1575
movq %rbx, %rdi
callq 0x1491
movq %rbx, %rdi
callq 0x13de
movq %rbx, %rdi
callq 0x1491
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x1be4
movl %eax, %edi
movl %r14d, %esi
callq 0x1b9b
cmpl %r13d, %eax
cmovll %eax, %r13d
cmovll %ebp, %r12d
incl %ebp
cmpl $0x100, %ebp            # imm = 0x100
jne 0x1203
movb %r12b, (%r14,%r15)
testb %r14b, %r14b
jne 0x123f
movq %rbx, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x1060
incq %r14
cmpq $0x1000000, %r14        # imm = 0x1000000
jne 0x11f8
leaq 0xdb8(%rip), %rdi       # 0x200a
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x10b0
movl %eax, %ebx
leaq 0x2e2b(%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_O1/ZmengXu[P]boxMesh/boxMesh.C
// Function: boxMesh(int, int, int, double, double, double)
void boxMesh(int Nx, int Ny, int Nz, double Lx, double Ly, double Lz)
{
    /* Create files
        constant/polyMesh/boundary
        constant/polyMesh/faces
        constant/polyMesh/neighbour
        constant/polyMesh/owner
        constant/polyMesh/points
    that would be created by calling OpenFOAM's blockMesh using the following
    blockMeshDict dictionary:

        vertices
        (
            (0     0     0    )
            (Nx*Lx 0     0    )
            (Nx*Lx Ny*Ly 0    )
            (0     Ny*Ly 0    )
            (0     0     Nz*Lz)
            (Nx*Lx 0     Nz*Lz)
            (Nx*Lx Ny*Ly Nz*Lz)
            (0     Ny*Ly Nz*Lz)
        );

        blocks
        (
            hex (0 1 2 3 4 5 6 7) (Nx Ny Nz) simpleGrading (1 1 1)
        );

        edges
        (
        );

        boundary
        (
        );

        mergePatchPairs
        (
        );
    */

    // Calculate number of points, faces and cells
    int nPoints        = (Nx+1)*(Ny+1)*(Nz+1);
    int nCells         = Nx*Ny*Nz;
    int nFaces         = Nx*Ny*(Nz+1)+Nx*Nz*(Ny+1)+Ny*Nz*(Nx+1);
    int nExternalFaces = 2*(Nx*Ny+Nx*Nz+Ny*Nz);

    // Write files
    writeBoundary(nFaces, nExternalFaces);
    writeFaces(nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writeNeighbour(nPoints, nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writeOwner(nPoints, nCells, nFaces, nExternalFaces, Nx, Ny, Nz);
    writePoints(nPoints, Nx, Ny, Nz, Lx, Ly, Lz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm2, -0x58(%rbp)
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movl %edx, %r12d
movl %edi, %r15d
leal 0x1(%r15), %r13d
leal 0x1(%rsi), %eax
movl %eax, %edx
imull %r13d, %edx
leal 0x1(%r12), %ecx
imull %ecx, %edx
movl %edx, -0x2c(%rbp)
movl %esi, %r14d
movq %rsi, -0x38(%rbp)
imull %edi, %r14d
imull %r14d, %ecx
movl %r12d, %ebx
imull %edi, %ebx
imull %ebx, %eax
addl %r14d, %ebx
imull %r12d, %r14d
addl %ecx, %eax
movl %r12d, %ecx
imull %esi, %ecx
imull %ecx, %r13d
addl %eax, %r13d
addl %ecx, %ebx
addl %ebx, %ebx
movl %r13d, %edi
movl %ebx, %esi
callq 0x244c
movl %r14d, %edi
movl %r13d, %esi
movl %ebx, %edx
movq %r15, -0x40(%rbp)
movl %r15d, %ecx
movq -0x38(%rbp), %r8
movl %r12d, %r9d
callq 0x288d
movl %r12d, (%rsp)
movl -0x2c(%rbp), %edi
movl %r14d, %esi
movl %r13d, %edx
movl %ebx, %ecx
movl %r15d, %r8d
movq -0x38(%rbp), %r15
movl %r15d, %r9d
callq 0x394b
movl %r12d, (%rsp)
movl -0x2c(%rbp), %r12d
movl %r12d, %edi
movl %r14d, %esi
movl %r13d, %edx
movl %ebx, %ecx
movq -0x40(%rbp), %r14
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x414e
movl %r12d, %edi
movl %r14d, %esi
movl %r15d, %edx
movsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
movsd -0x58(%rbp), %xmm2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4d36
// File: /workspace/github_c_makefile_star2_O1/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 0x546f
movq 0x8(%r14), %rdi
callq 0x2220
movl %eax, %ebx
movq 0x10(%r14), %rdi
callq 0x2220
movl %eax, %r15d
movq 0x18(%r14), %rdi
callq 0x2220
movl %eax, %r12d
movq 0x20(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x38(%rbp)
movq 0x28(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x30(%rbp)
movq 0x30(%r14), %rdi
callq 0x2190
movsd %xmm0, -0x28(%rbp)
leaq 0x11d3(%rip), %rdi      # 0x661a
leaq -0xc8(%rbp), %rsi
callq 0x2140
testl %eax, %eax
je 0x54ae
movq 0x3b62(%rip), %rdi      # 0x8fc0
leaq 0x11c7(%rip), %rsi      # 0x662c
movl $0x30, %edx
jmp 0x54f6
movq 0x3b4a(%rip), %rbx      # 0x8fc0
leaq 0x1181(%rip), %rsi      # 0x65fe
movl $0x7, %edx
movq %rbx, %rdi
callq 0x2180
movq (%r14), %r14
testq %r14, %r14
je 0x54cc
movq %r14, %rdi
callq 0x20a0
movq 0x3b1f(%rip), %rdi      # 0x8fc0
movq %r14, %rsi
movq %rax, %rdx
callq 0x2180
jmp 0x54e3
movl %ebx, %edi
movl %r15d, %esi
movl %r12d, %edx
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm2
callq 0x52d9
jmp 0x54fb
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2280
movq 0x3ad6(%rip), %rdi      # 0x8fc0
leaq 0x1115(%rip), %rsi      # 0x6606
movl $0x13, %edx
callq 0x2180
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x2e8c(%rip), %rbx      # 0x40b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10e0
leaq 0x2eab(%rip), %r14      # 0x40e0
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movl $0x0, 0x2e8f(%rip)      # 0x40d8
leaq 0xc2(%rip), %rdx        # 0x1312
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x10c0
leaq 0xda8(%rip), %rdi       # 0x200c
callq 0x1040
callq 0x1090
leaq 0x2e9b(%rip), %r13      # 0x4110
leaq 0xd88(%rip), %r15       # 0x2004
callq 0x13c7
movq %rbx, %rdi
callq 0x10f0
cmpl $0x0, 0x2e48(%rip)      # 0x40d8
je 0x129f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1050
jmp 0x1289
movq %rbx, %rdi
callq 0x10b0
xorl %r12d, %r12d
movl (%r12,%r13), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1060
addq $0x4, %r12
cmpq $0x50, %r12
jne 0x12aa
leaq 0xd7e(%rip), %rdi       # 0x2047
callq 0x1040
leaq 0xd34(%rip), %rdi       # 0x2009
leaq -0x29(%rbp), %rsi
xorl %eax, %eax
callq 0x10d0
callq 0x1090
movl $0xa, %edi
callq 0x1030
cmpb $0x73, -0x29(%rbp)
je 0x127c
leaq 0xd61(%rip), %rdi       # 0x205d
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq