LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x4(%rcx), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull (%rcx), %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
imull 0x4(%rax), %ecx
callq 0x9440
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x24(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
imull (%rax), %ecx
callq 0x9590
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/typechecker.c
// Function: TypeString
const char* TypeString(TYPE typeIdentifier)
{
    switch (typeIdentifier.basic)
    {
    case TYPE_INTEGER: return "INT";
    case TYPE_STRING: return "STRING";
    case TYPE_INT_ARRAY: return "INT[]";
    case TYPE_VOID: return "VOID";
    }
    return "N/A";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x978d
movq -0x18(%rbp), %rax
leaq 0x2120(%rip), %rcx      # 0xb870
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2170(%rip), %rax      # 0xb8d0
movq %rax, -0x8(%rbp)
jmp 0x9798
leaq 0x2167(%rip), %rax      # 0xb8d4
movq %rax, -0x8(%rbp)
jmp 0x9798
leaq 0x2161(%rip), %rax      # 0xb8db
movq %rax, -0x8(%rbp)
jmp 0x9798
leaq 0x215a(%rip), %rax      # 0xb8e1
movq %rax, -0x8(%rbp)
jmp 0x9798
leaq 0x2152(%rip), %rax      # 0xb8e6
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x9930
leaq 0x2026(%rip), %rdi      # 0xb943
leaq 0x1ffd(%rip), %rsi      # 0xb921
movl $0x4a, %edx
callq 0x6e20
jmp 0x997f
movq -0x8(%rbp), %rdi
callq 0x9730
movq %rax, %rsi
movq -0x10(%rbp), %rdx
leaq 0x201d(%rip), %rdi      # 0xb964
movb $0x0, %al
callq 0x2070
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rsi
leaq 0x12a03(%rip), %rdi     # 0x1c360
callq 0x8e30
cmpl $0x0, %eax
jne 0x997f
leaq 0x200f(%rip), %rdi      # 0xb97d
leaq 0x1fac(%rip), %rsi      # 0xb921
movl $0x51, %edx
callq 0x6e20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/typechecker.c
// Function: IsBinaryOperator
int IsBinaryOperator(int productionNum)
{
    switch (productionNum)
    {
    case PROD_CONDITION_AND:
    case PROD_CONDITION_OR:
    case PROD_COMPARISON_EQUAL_TO:
    case PROD_COMPARISON_UNEQUAL_TO:
    case PROD_COMPARISON_LESS:
    case PROD_COMPARISON_GREATER:
    case PROD_COMPARISON_L_EQUAL:
    case PROD_COMPARISON_G_EQUAL:
    case PROD_ARITHMETIC_ADD:
    case PROD_ARITHMETIC_SUBTRACT:
    case PROD_TERM_MULTIPLY:
    case PROD_TERM_DIVIDE:
    case PROD_TERM_MODULUS:
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x24, %eax
subl $0x2, %eax
jb 0xa74e
jmp 0xa727
movl -0xc(%rbp), %eax
addl $-0x29, %eax
subl $0x6, %eax
jb 0xa74e
jmp 0xa734
movl -0xc(%rbp), %eax
addl $-0x30, %eax
subl $0x2, %eax
jb 0xa74e
jmp 0xa741
movl -0xc(%rbp), %eax
addl $-0x33, %eax
subl $0x2, %eax
ja 0xa757
jmp 0xa74e
movl $0x1, -0x4(%rbp)
jmp 0xa75e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/typechecker.c
// Function: IsIntegerOnlyOperator
int IsIntegerOnlyOperator(int productionNum)
{
    switch (productionNum)
    {
    case PROD_COMPARISON_LESS:
    case PROD_COMPARISON_GREATER:
    case PROD_COMPARISON_L_EQUAL:
    case PROD_COMPARISON_G_EQUAL:
    case PROD_ARITHMETIC_SUBTRACT:
    case PROD_TERM_MULTIPLY:
    case PROD_TERM_DIVIDE:
    case PROD_TERM_MODULUS:
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x2b, %eax
subl $0x4, %eax
jb 0xa79e
jmp 0xa787
movl -0xc(%rbp), %eax
subl $0x31, %eax
je 0xa79e
jmp 0xa791
movl -0xc(%rbp), %eax
addl $-0x33, %eax
subl $0x2, %eax
ja 0xa7a7
jmp 0xa79e
movl $0x1, -0x4(%rbp)
jmp 0xa7ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gregtour[P]minimal-compiler/typechecker.c
// Function: CanCoerceToType
int CanCoerceToType(TYPE dest, TYPE source)
{
    switch (dest.basic)
    {
    case TYPE_INTEGER:
        if (source.basic == TYPE_INTEGER)
            return 0;
        else
            return 1;
    case TYPE_STRING:
        return 0;
    case TYPE_INT_ARRAY:
        if (source.basic == TYPE_INT_ARRAY)
            return 0;
        else
            return 1;
    case TYPE_VOID:
        if (source.basic == TYPE_VOID)
            return 0;
        else
            return 1;
    case TYPE_NON_VOID:
        if (source.basic != TYPE_VOID)
            return 0;
        else
            return 1;
        break;
    case TYPE_ANY:
        return 0;
        break;
    }

    CompilerError("Unknown type encountered.");
    Assert(0);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0xc(%rbp)
movq %rsi, -0x14(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x8, %rax
ja 0xa8fa
movq -0x20(%rbp), %rax
leaq 0x1030(%rip), %rcx      # 0xb8ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x1, -0x10(%rbp)
jne 0xa897
movl $0x0, -0x4(%rbp)
jmp 0xa919
movl $0x1, -0x4(%rbp)
jmp 0xa919
movl $0x0, -0x4(%rbp)
jmp 0xa919
cmpl $0x3, -0x10(%rbp)
jne 0xa8b8
movl $0x0, -0x4(%rbp)
jmp 0xa919
movl $0x1, -0x4(%rbp)
jmp 0xa919
cmpl $0x0, -0x10(%rbp)
jne 0xa8d0
movl $0x0, -0x4(%rbp)
jmp 0xa919
movl $0x1, -0x4(%rbp)
jmp 0xa919
cmpl $0x0, -0x10(%rbp)
je 0xa8e8
movl $0x0, -0x4(%rbp)
jmp 0xa919
movl $0x1, -0x4(%rbp)
jmp 0xa919
movl $0x0, -0x4(%rbp)
jmp 0xa919
leaq 0x12e7(%rip), %rdi      # 0xbbe8
leaq 0x1019(%rip), %rsi      # 0xb921
movl $0x1f2, %edx            # imm = 0x1F2
callq 0x6e20
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x5b38
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x4050
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x121424(%rip), %rax    # 0x126fb8
movq (%rax), %rdi
callq 0x45a0
movq 0x121435(%rip), %rax    # 0x126fd8
movq (%rax), %rdi
leaq 0xfe457(%rip), %rsi     # 0x104004
movb $0x0, %al
callq 0x4720
movq 0x12141d(%rip), %rax    # 0x126fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x46a0
cmpl $0x0, -0xc(%rbp)
je 0x5c04
movq 0x121400(%rip), %rax    # 0x126fd8
movq (%rax), %rax
movq %rax, -0xe8(%rbp)
movl -0xc(%rbp), %edi
callq 0x4130
movq -0xe8(%rbp), %rdi
movq %rax, %rdx
leaq 0x1077e5(%rip), %rsi    # 0x10d3e0
movb $0x0, %al
callq 0x4720
jmp 0x5c1c
movq 0x1213cd(%rip), %rax    # 0x126fd8
movq (%rax), %rdi
leaq 0x10014e(%rip), %rsi    # 0x105d63
movb $0x0, %al
callq 0x4720
movq 0x1213b5(%rip), %rax    # 0x126fd8
movq (%rax), %rdi
callq 0x45a0
movl $0x1, 0x1262d7(%rip)    # 0x12bf0c
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htsfile.c
// Function: view_sam
static void view_sam(samFile *in, const char *filename)
{
    bam1_t *b = NULL;
    sam_hdr_t *hdr = NULL;
    samFile *out = NULL;

    hdr = sam_hdr_read(in);
    if (hdr == NULL) {
        errno = 0; error("reading headers from \"%s\" failed", filename);
        goto clean;
    }

    out = hts_open("-", "w");
    if (out == NULL) { error("reopening standard output failed"); goto clean; }

    if (show_headers) {
        if (sam_hdr_write(out, hdr) != 0) {
            error("writing headers to standard output failed");
            goto clean;
        }
    }

    if (mode == view_all) {
        int ret;

        b = bam_init1();
        if (b == NULL) { error("can't create record"); goto clean; }

        while ((ret = sam_read1(in, hdr, b)) >= 0) {
            if (sam_write1(out, hdr, b) < 0) {
                error("writing to standard output failed");
                goto clean;
            }
        }

        if (ret < -1) { error("reading \"%s\" failed", filename); goto clean; }
    }

 clean:
    sam_hdr_destroy(hdr);
    bam_destroy1(b);
    if (out) hts_close(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x27950
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x62fe
callq 0x4050
movl $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xfe01a(%rip), %rdi     # 0x10430c
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
leaq 0x100d23(%rip), %rdi    # 0x107028
leaq 0xfdd20(%rip), %rsi     # 0x10402c
callq 0xe260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x632f
leaq 0xfe00a(%rip), %rdi     # 0x10432d
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
cmpl $0x0, 0x1211fa(%rip)    # 0x127530
je 0x635f
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x28960
cmpl $0x0, %eax
je 0x635d
leaq 0xfdffd(%rip), %rdi     # 0x10434e
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
jmp 0x635f
cmpl $0x2, 0x125b9e(%rip)    # 0x12bf04
jne 0x63e7
callq 0x22e30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6388
leaq 0xfdff9(%rip), %rdi     # 0x104378
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
jmp 0x638a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2ca90
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jl 0x63cb
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2f850
cmpl $0x0, %eax
jge 0x63c9
leaq 0xfdfcc(%rip), %rdi     # 0x10438c
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
jmp 0x638a
cmpl $-0x1, -0x2c(%rbp)
jge 0x63e5
movq -0x10(%rbp), %rsi
leaq 0xfdfd2(%rip), %rdi     # 0x1043ae
movb $0x0, %al
callq 0x5b00
jmp 0x63e9
jmp 0x63e7
jmp 0x63e9
movq -0x20(%rbp), %rdi
callq 0x21ef0
movq -0x18(%rbp), %rdi
callq 0x23070
cmpq $0x0, -0x28(%rbp)
je 0x640b
movq -0x28(%rbp), %rdi
callq 0x10380
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htsfile.c
// Function: view_vcf
static void view_vcf(vcfFile *in, const char *filename)
{
    bcf1_t *rec = NULL;
    bcf_hdr_t *hdr = NULL;
    vcfFile *out = NULL;

    hdr = bcf_hdr_read(in);
    if (hdr == NULL) {
        errno = 0; error("reading headers from \"%s\" failed", filename);
        goto clean;
    }

    out = hts_open("-", "w");
    if (out == NULL) { error("reopening standard output failed"); goto clean; }

    if (show_headers) {
        if (bcf_hdr_write(out, hdr) != 0) {
            error("writing headers to standard output failed");
            goto clean;
        }
    }

    if (mode == view_all) {
        int ret;

        rec = bcf_init();
        if (rec == NULL) { error("can't create record"); goto clean; }

        while ((ret = bcf_read(in, hdr, rec)) >= 0) {
            if (bcf_write(out, hdr, rec) < 0) {
                error("writing to standard output failed");
                goto clean;
            }
        }

        if (ret < -1) { error("reading \"%s\" failed", filename); goto clean; }
    }

 clean:
    if (hdr) bcf_hdr_destroy(hdr);
    if (rec) bcf_destroy(rec);
    if (out) hts_close(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x44370
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x647e
callq 0x4050
movl $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xfde9a(%rip), %rdi     # 0x10430c
movb $0x0, %al
callq 0x5b00
jmp 0x6569
leaq 0x100ba3(%rip), %rdi    # 0x107028
leaq 0xfdba0(%rip), %rsi     # 0x10402c
callq 0xe260
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x64af
leaq 0xfde8a(%rip), %rdi     # 0x10432d
movb $0x0, %al
callq 0x5b00
jmp 0x6569
cmpl $0x0, 0x12107a(%rip)    # 0x127530
je 0x64df
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44ad0
cmpl $0x0, %eax
je 0x64dd
leaq 0xfde7d(%rip), %rdi     # 0x10434e
movb $0x0, %al
callq 0x5b00
jmp 0x6569
jmp 0x64df
cmpl $0x2, 0x125a1e(%rip)    # 0x12bf04
jne 0x6567
callq 0x44f70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6508
leaq 0xfde79(%rip), %rdi     # 0x104378
movb $0x0, %al
callq 0x5b00
jmp 0x6569
jmp 0x650a
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x45960
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jl 0x654b
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x474c0
cmpl $0x0, %eax
jge 0x6549
leaq 0xfde4c(%rip), %rdi     # 0x10438c
movb $0x0, %al
callq 0x5b00
jmp 0x6569
jmp 0x650a
cmpl $-0x1, -0x2c(%rbp)
jge 0x6565
movq -0x10(%rbp), %rsi
leaq 0xfde52(%rip), %rdi     # 0x1043ae
movb $0x0, %al
callq 0x5b00
jmp 0x6569
jmp 0x6567
jmp 0x6569
cmpq $0x0, -0x20(%rbp)
je 0x6579
movq -0x20(%rbp), %rdi
callq 0x44110
cmpq $0x0, -0x18(%rbp)
je 0x6589
movq -0x18(%rbp), %rdi
callq 0x45360
cmpq $0x0, -0x28(%rbp)
je 0x6599
movq -0x28(%rbp), %rdi
callq 0x10380
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x68a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x665a
callq 0x4500
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x65f2
cmpl $0xa, -0x14(%rbp)
je 0x65f2
cmpl $0x9, -0x14(%rbp)
jne 0x65fc
movl -0x14(%rbp), %edi
callq 0x46d0
jmp 0x664d
cmpl $0xd, -0x14(%rbp)
jne 0x661a
movq 0x1209af(%rip), %rax    # 0x126fb8
movq (%rax), %rsi
leaq 0xfddaf(%rip), %rdi     # 0x1043c2
callq 0x4550
jmp 0x664b
cmpl $0x0, -0x14(%rbp)
jne 0x6638
movq 0x120991(%rip), %rax    # 0x126fb8
movq (%rax), %rsi
leaq 0xfdd94(%rip), %rdi     # 0x1043c5
callq 0x4550
jmp 0x6649
movl -0x14(%rbp), %esi
leaq 0xfdd86(%rip), %rdi     # 0x1043c8
movb $0x0, %al
callq 0x4060
jmp 0x664b
jmp 0x664d
jmp 0x664f
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x65b7
cmpl $0xa, -0x18(%rbp)
je 0x666a
movl $0xa, %edi
callq 0x46d0
movq -0x8(%rbp), %rdi
callq 0x68f0
cmpl $0x0, %eax
je 0x66a0
movq -0x8(%rbp), %rdi
callq 0x68f0
movl %eax, -0x1c(%rbp)
callq 0x4050
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rsi
leaq 0xfdd15(%rip), %rdi     # 0x1043ae
movb $0x0, %al
callq 0x5b00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1080
callq 0x1060
movl %eax, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x16, 0x2ea0(%rip)     # 0x405c
callq 0x1070
cmpl $0x0, 0x10(%rsp)
jne 0x11dd
leaq 0x2e8d(%rip), %rdi      # 0x405c
movl $0x1, %esi
callq 0x1040
movl %eax, 0xc(%rsp)
callq 0x1070
movl 0x10(%rsp), %esi
movl 0xc(%rsp), %edx
movl 0x2e6c(%rip), %ecx      # 0x405c
leaq 0xe0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x11de
callq 0x12f0
jmp 0x12dd
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x122c
movq -0x20(%rbp), %rdi
leaq 0xe0f(%rip), %rsi       # 0x2004
callq 0x1080
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x1227
leaq 0xde6(%rip), %rdi       # 0x2006
movb $0x0, %al
callq 0x1040
jmp 0x12db
movq -0x20(%rbp), %rdi
callq 0x1030
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x1262
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x1260
leaq 0xdc9(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1040
jmp 0x12d9
leaq -0x60(%rbp), %rdi
movl $0x32, %esi
callq 0x1050
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
leaq 0xd85(%rip), %rsi       # 0x2004
callq 0x1080
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1080
leaq -0x60(%rbp), %rdi
leaq 0xd68(%rip), %rsi       # 0x2004
callq 0x1080
leaq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
movq -0x18(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1070
cmpl $-0x1, %eax
je 0x12c2
jmp 0x12d0
leaq 0xd70(%rip), %rdi       # 0x2039
movb $0x0, %al
callq 0x1040
movq -0x68(%rbp), %rdi
callq 0x1060
jmp 0x12db
jmp 0x12dd
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1060
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11b9
leaq 0xe50(%rip), %rdi       # 0x2004
callq 0x11d0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1475
jmp 0x1494
leaq 0xc00(%rip), %rdi       # 0x207c
leaq 0xba1(%rip), %rsi       # 0x2024
movl $0x4d, %edx
leaq 0xbf8(%rip), %rcx       # 0x2087
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14ba
movq -0x8(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x14e7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq $0x0, -0x10(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15a9
jmp 0x15c8
leaq 0xa69(%rip), %rdi       # 0x2019
leaq 0xa6d(%rip), %rsi       # 0x2024
movl $0x6e, %edx
leaq 0xaea(%rip), %rcx       # 0x20ad
callq 0x1050
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x15f2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x15fb
jmp 0x1609
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15d4
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x1710
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x29(%rbp)
je 0x1697
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x16a0
jmp 0x1703
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x16e6
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1676
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1650
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1735
jmp 0x1754
leaq 0x8dd(%rip), %rdi       # 0x2019
leaq 0x8e1(%rip), %rsi       # 0x2024
movl $0x94, %edx
leaq 0x97b(%rip), %rcx       # 0x20ca
callq 0x1050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1769
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17d2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x17be
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x178d
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1190
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x19d8
movl $0x10, %edi
callq 0x1060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x19a5
leaq 0x778(%rip), %rdi       # 0x2118
callq 0x11d0
callq 0x1080
movl $0x64, %ecx
cltd
idivl %ecx
movl %edx, %edi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x14f0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x197e
movq -0x18(%rbp), %rdi
callq 0x17e0
movq -0x18(%rbp), %rdi
callq 0x1640
movq -0x18(%rbp), %rdi
callq 0x17e0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x1000000, -0x8(%rbp)  # imm = 0x1000000
jge 0x1242
movl -0x8(%rbp), %edi
callq 0x1280
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0x3e7c(%rip), %rax      # 0x5090
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x1235
movl -0x8(%rbp), %esi
leaq 0x1dd6(%rip), %rdi      # 0x3004
movb $0x0, %al
callq 0x1060
jmp 0x1237
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11f6
leaq 0x1dc1(%rip), %rdi      # 0x300a
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x10b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0x3e30(%rip), %rsi      # 0x5090
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x1040
movl -0xc(%rbp), %edi
callq 0x1070
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kilobyte[P]colormatch/nearest256.c
// Function: closest
static int closest(int rgb)
{
    int best=0, bd = 0x7fffffff;

    for (int i = 0; i < 256; ++i)
    {
        int d = color_diff(col256_to_rgb(i), rgb);
        if (d < bd)
            best = i, bd = d;
    }
    return best;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jge 0x12df
movl -0x10(%rbp), %edi
callq 0x1f80
movl %eax, %edi
movl -0x4(%rbp), %esi
callq 0x1f30
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x12d2
movl -0x10(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x12d4
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12a0
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x7, -0x8(%rbp)
je 0x5d65
movq 0x728a(%rip), %rdi      # 0xcfc0
leaq 0x38a5(%rip), %rsi      # 0x95e2
callq 0x21b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x388f(%rip), %rsi      # 0x95ea
callq 0x21b0
jmp 0x5e17
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22e0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x22e0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2250
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2250
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2250
movsd %xmm0, -0x38(%rbp)
leaq 0x382c(%rip), %rdi      # 0x95fe
leaq -0xc8(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x5e02
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x5be0
jmp 0x5e15
movq 0x71b7(%rip), %rdi      # 0xcfc0
leaq 0x3800(%rip), %rsi      # 0x9610
callq 0x21b0
jmp 0x5e17
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x13b0
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xed(%rip), %rdx        # 0x1300
movq %rcx, %rsi
callq 0x10a0
leaq 0xde2(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
callq 0x1070
callq 0x13e0
leaq 0x2e66(%rip), %rdi      # 0x40a0
callq 0x10d0
cmpl $0x0, 0x2e82(%rip)      # 0x40c8
je 0x125d
leaq 0x2e81(%rip), %rdi      # 0x40d0
leaq 0x2e4a(%rip), %rsi      # 0x40a0
callq 0x1030
jmp 0x123f
leaq 0x2e3c(%rip), %rdi      # 0x40a0
callq 0x1090
movl $0x0, -0x8(%rbp)
cmpl $0x14, -0x8(%rbp)
jge 0x129d
movslq -0x8(%rbp), %rcx
leaq 0x2e7f(%rip), %rax      # 0x4100
movl (%rax,%rcx,4), %esi
leaq 0xdb5(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1040
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1270
leaq 0xda1(%rip), %rdi       # 0x2045
movb $0x0, %al
callq 0x1040
leaq 0xdaa(%rip), %rdi       # 0x205c
leaq -0x19(%rbp), %rsi
movb $0x0, %al
callq 0x10b0
callq 0x1070
leaq 0xdab(%rip), %rdi       # 0x2074
movb $0x0, %al
callq 0x1040
movsbl -0x19(%rbp), %eax
cmpl $0x73, %eax
je 0x122e
leaq 0xd7b(%rip), %rdi       # 0x205f
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.14/condvar.c
// Function: thread_function
void* thread_function (void* thread_arg)
{
	/* Loop infinitely. */
	while (1) {
		/* Lock the mutex before accessing the flag value. */
		pthread_mutex_lock (&thread_flag_mutex);
		while (!thread_flag)
			/* The flag is clear. Wait for a signal on the condition
			variable, indicating that the flag value has changed. When the
			signal arrives and this thread unblocks, loop and check the
			flag again. */
			pthread_cond_wait (&thread_flag_cv, &thread_flag_mutex);
		/* When we’ve gotten here, we know the flag must be set. Unlock
		the mutex. */
		pthread_mutex_unlock (&thread_flag_mutex);
		/* Do some work. */
		do_work ();
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2d8d(%rip), %rdi      # 0x40a0
callq 0x10d0
cmpl $0x0, 0x2da9(%rip)      # 0x40c8
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x132a
jmp 0x133f
leaq 0x2d9f(%rip), %rdi      # 0x40d0
leaq 0x2d68(%rip), %rsi      # 0x40a0
callq 0x1030
jmp 0x1318
leaq 0x2d5a(%rip), %rdi      # 0x40a0
callq 0x1090
callq 0x1360
jmp 0x130c
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x14, -0x4(%rbp)
jge 0x139b
callq 0x10e0
movl $0x64, %ecx
cltd
idivl %ecx
movslq -0x4(%rbp), %rcx
leaq 0x2d73(%rip), %rax      # 0x4100
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x136f
callq 0x1420
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
leaq 0x2cb1(%rip), %rdi      # 0x40a0
callq 0x1050
movl %eax, -0x4(%rbp)
movl $0x1, 0x2cc7(%rip)      # 0x40c8
leaq 0x2cc8(%rip), %rdi      # 0x40d0
callq 0x1060
leaq 0x2c8c(%rip), %rdi      # 0x40a0
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1070
movslq -0xc(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x12aa
movq -0x98(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x98(%rbp), %rcx
shrq $0x6, %rcx
orq -0x90(%rbp,%rcx,8), %rax
movq %rax, -0x90(%rbp,%rcx,8)
movq %rax, -0xa8(%rbp)
jmp 0x12b5
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0x12b5
movq -0xa8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80, %esi
leaq -0x90(%rbp), %rdx
callq 0x1030
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/ht.c
// Function: spawn_thread
static void spawn_thread(pthread_t *pt, char *spawned, int is_store, uintptr_t idx)
{
    results[idx].is_store = is_store;

    pthread_create(pt, NULL, is_store ? thread_store : thread_mul, (void*)idx);
    if (opt_pinned) {
        pin_thread(*pt, idx);
    }
    *spawned = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq 0x2687(%rip), %rax      # 0x40c8
movq -0x20(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq 0x1c3(%rip), %rdx       # 0x1c20
leaq 0x3c(%rip), %rax        # 0x1aa0
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x10d0
cmpl $0x0, 0x2629(%rip)      # 0x40a8
je 0x1a93
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
callq 0x1230
movq -0x10(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/ht.c
// Function: thread_store
static void *thread_store(void *opaque)
{
    uint64_t idx = (unsigned long)opaque;
    int64_t d = idx + 3;
    uint64_t loops = 0;
    int i;
    char ref[] = { d, d, d, d,
                   d, d, d, d,
                   d, d, d, d,
                   d, d, d, d,
                   d, d, d, d,
                   d, d, d, d,
                   d, d, d, d,
                   d, d, d, d };

    while (!running);

    while (1) {
        for (i = 0; i < 16; i++) {
            ref[i] = d;
            asm("" : : "m"(ref));
        }
        loops += 16;
        if (!(loops & 0xffff)) {
            results[idx].result = loops;
        }
    }

    return (void*)d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x50(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4f(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4e(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4d(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4b(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x4a(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x49(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x48(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x47(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x46(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x45(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x44(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x43(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x42(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x41(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x40(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3f(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3e(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3d(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3b(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x3a(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x38(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x37(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x36(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x35(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x34(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x33(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x32(%rbp)
movq -0x18(%rbp), %rax
movb %al, -0x31(%rbp)
movl 0x250e(%rip), %eax      # 0x40b8
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1bb8
jmp 0x1bba
jmp 0x1ba4
jmp 0x1bbc
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jge 0x1be2
movq -0x18(%rbp), %rax
movb %al, %cl
movslq -0x24(%rbp), %rax
movb %cl, -0x50(%rbp,%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1bc3
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpq $0x0, %rax
jne 0x1c17
movq -0x20(%rbp), %rcx
movq 0x24bf(%rip), %rax      # 0x40c8
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x1bbc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/agraf[P]kvmbench/ht.c
// Function: thread_mul
static void *thread_mul(void *opaque)
{
    uint64_t idx = (unsigned long)opaque;
    int64_t d = idx;
    uint64_t loops = 0;

    while (!running);

    while (1) {
        int i;

        for (i = 0; i < 16; i++) {
            d = d * (int64_t)idx;
            asm("" : : "r"(d));
        }
        loops += 16;
        if (!(loops & 0xffff)) {
            results[idx].result = loops;
        }
    }

    return (void*)(unsigned long)d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl 0x2472(%rip), %eax      # 0x40b8
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1c54
jmp 0x1c56
jmp 0x1c40
jmp 0x1c58
movl $0x0, -0x24(%rbp)
cmpl $0x10, -0x24(%rbp)
jge 0x1c81
movq -0x18(%rbp), %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c5f
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpq $0x0, %rax
jne 0x1cb6
movq -0x20(%rbp), %rcx
movq 0x2420(%rip), %rax      # 0x40c8
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
jmp 0x1c58
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./db_construction_parameters.h
// Function: DbConstructionParameters::DbConstructionParameters()
DbConstructionParameters(){
    _db_filename = "";
    _input_filename = "";
    _hash_size = 8;
    _repeat_flag = 0;
    _maximal_span = 70;
    _min_accessible_length = 5;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x33d0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x28(%rbp)
callq 0x33d0
movq -0x20(%rbp), %rdi
leaq 0x34807(%rip), %rsi     # 0x38823
callq 0x33c0
jmp 0x4023
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq 0x347f1(%rip), %rsi     # 0x38823
callq 0x33c0
jmp 0x4039
movq -0x30(%rbp), %rax
movl $0x8, 0x40(%rax)
movl $0x0, 0x44(%rax)
movl $0x46, 0x48(%rax)
movl $0x5, 0x4c(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3190
movq -0x20(%rbp), %rdi
callq 0x3190
movq -0x10(%rbp), %rdi
callq 0x34d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fukunagatsu[P]RIblast/./rna_interaction_search_parameters.h
// Function: RnaInteractionSearchParameters::RnaInteractionSearchParameters()
RnaInteractionSearchParameters(){
    _db_filename = "";
    _input_filename = "";
    _hash_size = 0;
    _repeat_flag = 0;
    _maximal_span = 0;
    _min_accessible_length = 0;
    _output_style = 0;
    _max_seed_length = 20;
    _hybrid_energy_threshold = -6.0;
    _interaction_energy_threshold = -4;
    _final_threshold = -8.0;
    _drop_out_length_wo_gap = 5;
    _drop_out_length_w_gap = 16;
    _min_helix_length = 3;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x33d0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x30(%rbp)
callq 0x33d0
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x28(%rbp)
callq 0x33d0
movq -0x20(%rbp), %rdi
leaq 0x34686(%rip), %rsi     # 0x38823
callq 0x33c0
jmp 0x41a4
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
leaq 0x34670(%rip), %rsi     # 0x38823
callq 0x33c0
jmp 0x41ba
movq -0x38(%rbp), %rax
movl $0x0, 0x64(%rax)
movl $0x0, 0x68(%rax)
movl $0x0, 0x6c(%rax)
movl $0x0, 0x70(%rax)
movl $0x0, 0x60(%rax)
movl $0x14, 0x74(%rax)
movsd 0x33e28(%rip), %xmm0    # 0x38018
movsd %xmm0, 0x80(%rax)
movsd 0x33e10(%rip), %xmm0    # 0x38010
movsd %xmm0, 0x78(%rax)
movsd 0x33dfb(%rip), %xmm0    # 0x38008
movsd %xmm0, 0x88(%rax)
movl $0x5, 0x90(%rax)
movl $0x10, 0x94(%rax)
movl $0x3, 0x98(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3190
movq -0x30(%rbp), %rdi
callq 0x3190
movq -0x20(%rbp), %rdi
callq 0x3190
movq -0x10(%rbp), %rdi
callq 0x34d0
nopl (%rax)