LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/bench/bulk_insert/main.c
// Function: printperf
static void
printperf(struct bulkinsert_state * C)
{
	struct timeval tv_now;
	double T;
	uint64_t N;

	/* Get current time. */
	if (monoclock_get(&tv_now)) {
		warnp("Error reading clock");
		return;
	}

	/* Compute time difference. */
	T = timeval_diff(C->tv_saved, tv_now);

	/* Compute number of requests between then and now. */
	N = C->Ndone - C->Ndone_saved;

	/* Everything completed before now was before 10 s. */
	if (T > 10.0) {
		T = 10.0;
		N -= 1;
	}

	/* Avoid microsecond precision rounding resulting in divide-by-0. */
	if (T < 0.000001)
		T = 0.000001;

	/*
	 * Print requests per second.  Skip this if we handled less than 4096
	 * requests, since that could be a burst of responses from a single
	 * bundle.
	 */
	if (N >= 4096)
		printf("%zu %.0f\n", C->Ndone_saved, (double)N / T);

	/* We've printed this performance point. */
	C->Ndone_saved = 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3e00
testl %eax, %eax
je 0x291c
callq 0x2090
cmpl $0x0, (%rax)
je 0x29bb
movq %rax, %rbx
leaq 0x77cb(%rip), %rdi      # 0xa0d5
xorl %eax, %eax
callq 0x50e4
movl $0x0, (%rbx)
jmp 0x29c9
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq 0x30(%rbx), %rax
cvtsi2sd %rax, %xmm1
subq 0x38(%rbx), %rcx
cvtsi2sd %rcx, %xmm0
mulsd 0x76c9(%rip), %xmm0     # 0xa008
addsd %xmm1, %xmm0
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rsi
subq %rsi, %rax
xorl %ecx, %ecx
ucomisd 0x76b8(%rip), %xmm0     # 0xa010
seta %cl
subq %rcx, %rax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x29b1
movsd 0x76a2(%rip), %xmm1     # 0xa010
minsd %xmm0, %xmm1
movsd 0x768e(%rip), %xmm2     # 0xa008
maxsd %xmm1, %xmm2
movq %rax, %xmm1
punpckldq 0x7695(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x769d(%rip), %xmm1     # 0xa030
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
divsd %xmm2, %xmm0
leaq 0x773f(%rip), %rdi      # 0xa0e9
movb $0x1, %al
callq 0x2130
movq $0x0, 0x28(%rbx)
jmp 0x29c9
leaq 0x7713(%rip), %rdi      # 0xa0d5
xorl %eax, %eax
callq 0x5203
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: read_piped_input
void read_piped_input ()
{
    int read_bytes;

    piped_input_len = 0;

    int flags = fcntl(0, F_GETFD, 0);
    fcntl(0, F_SETFL, flags | O_NONBLOCK);

    while (piped_input_len < PIPED_INPUT_SIZE) {
        read_bytes = read(0,
                          &(piped_input[piped_input_len]),
                          PIPED_INPUT_SIZE - piped_input_len);
        if (read_bytes <= 0)
            break;
        piped_input_len += read_bytes;
    }

    fclose(stdin);
    freopen("/dev/tty", "r+b", stdin);
}

// Assembly:
pushq %rbx
movq $0x0, 0x6d98(%rip) # 0x91a0
xorl %edi, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x20e0
orl $0x800, %eax            # imm = 0x800
xorl %edi, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x20e0
movq 0x6d6c(%rip), %rax      # 0x91a0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x2475
leaq 0x6d6d(%rip), %rbx      # 0x91b0
leaq (%rbx,%rax), %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
xorl %edi, %edi
callq 0x21a0
testl %eax, %eax
jle 0x2475
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq 0x6d3a(%rip), %rax      # 0x91a0
movq %rax, 0x6d33(%rip)      # 0x91a0
cmpq $0x2000, %rax           # imm = 0x2000
jb 0x2443
movq 0x6b54(%rip), %rbx      # 0x8fd0
movq (%rbx), %rdi
callq 0x2100
movq (%rbx), %rdx
leaq 0x3b76(%rip), %rdi      # 0x6004
leaq 0x3b78(%rip), %rsi      # 0x600d
popq %rbx
jmp 0x2160
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: debug_step
int debug_step (struct _vm * vm)
{
    int depth = 0;
    int error = 0;

    if (vm_opcode(vm) == OP_CALL)
        depth = 1;
    else
        return debug_next(vm);

    while (depth > 0) {
        error = debug_next(vm);
        if (error)
            return error;
        if (vm_opcode(vm) == OP_CALL)
            depth++;
        else if (vm_opcode(vm) == OP_RET)
            depth--;
    }

    return debug_next(vm);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5256
cmpb $0x27, %al
jne 0x2542
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x24d1
testl %eax, %eax
jne 0x2550
movq %rbx, %rdi
callq 0x5256
movl $0x1, %ecx
cmpb $0x27, %al
je 0x253e
movq %rbx, %rdi
callq 0x5256
xorl %ecx, %ecx
cmpb $0x29, %al
sete %cl
negl %ecx
addl %ecx, %ebp
jg 0x2510
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24d1
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: debug_memory
int debug_memory (struct _vm * vm, const char * command)
{
    int address = vm->regs[REG_SP];
    int length  = 8;
    int matched;
    int i;

    matched = sscanf(command, "m %x %d", &address, &length);
    if (matched == -1) {
        matched = sscanf(command, "memory %x %d", &address, &length);
    }

    printf("%04x: ", address);
    for (i = 0; i < length; i++) {
        if (address + i >= 0x10000)
            break;
        printf("%02x", vm->mem[address + i]);
        if (((i + 1) % 16 == 0) && (i + 1 < length))
            printf("\n%04x: ", address + i + 1);
        else if ((i + 1) % 8 == 0)
            printf("  ");
        else if ((i + 1) % 2 == 0)
            printf(" ");
    }

    printf("\n");

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x1a(%rdi), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movq %rsp, %rcx
movl $0x8, (%rcx)
leaq 0x3a8e(%rip), %rsi      # 0x6011
movq %r14, %rdi
xorl %eax, %eax
callq 0x2220
cmpl $-0x1, %eax
jne 0x25ab
leaq 0x3a80(%rip), %rsi      # 0x6019
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2220
movl 0x4(%rsp), %esi
leaq 0x3a76(%rip), %rdi      # 0x602c
xorl %eax, %eax
callq 0x2130
cmpl $0x0, (%rsp)
jle 0x2652
leaq 0x3a58(%rip), %r14      # 0x6026
leaq 0x3a56(%rip), %r15      # 0x602b
leaq 0x3a57(%rip), %r12      # 0x6033
xorl %r13d, %r13d
movslq 0x4(%rsp), %rax
leal (%rax,%r13), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
jg 0x2652
movq %r13, %rbp
addq (%rbx), %rax
movzbl (%r13,%rax), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2130
incq %r13
testb $0xf, %r13b
jne 0x262a
cmpl (%rsp), %r13d
jge 0x262a
movl 0x4(%rsp), %eax
leal (%rax,%rbp), %esi
incl %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2130
jmp 0x264c
testb $0x7, %r13b
je 0x2642
testb $0x1, %bpl
je 0x264c
movl $0x20, %edi
callq 0x2050
jmp 0x264c
movq %r12, %rdi
xorl %eax, %eax
callq 0x2130
cmpl (%rsp), %r13d
jl 0x25df
movl $0xa, %edi
callq 0x2050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: set_breakpoint
void set_breakpoint (const char * command)
{
    int break_i;
    uint16_t addr;

    if (    (sscanf(command, "b %hx", &addr) == -1)
         && (sscanf(command, "break %hx", &addr) == -1))
        return;

    for (break_i = 0; break_i < BREAKPOINTS_SIZE; break_i++) {
        if (breakpoints[break_i] == -1) {
            breakpoints[break_i] = addr;
            printf("breakpoint set: %hx\n", addr);
            if (break_i < BREAKPOINTS_SIZE - 1)
                breakpoints[break_i + 1] = -1;
            return;
        }
    }

    printf("breakpoint not set, max breakpoints already set\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x39bb(%rip), %rsi      # 0x6036
leaq 0x6(%rsp), %rdx
xorl %eax, %eax
callq 0x2220
cmpl $-0x1, %eax
jne 0x26a7
leaq 0x39a9(%rip), %rsi      # 0x603c
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2220
cmpl $-0x1, %eax
je 0x26f4
xorl %ebx, %ebx
leaq 0x8b10(%rip), %r14      # 0xb1c0
cmpl $-0x1, (%r14,%rbx,4)
je 0x26ce
incq %rbx
cmpq $0x20, %rbx
jne 0x26b0
leaq 0x3a1a(%rip), %rdi      # 0x60e1
callq 0x20b0
jmp 0x26f4
movzwl 0x6(%rsp), %esi
movl %esi, (%r14,%rbx,4)
leaq 0x3968(%rip), %rdi      # 0x6046
xorl %eax, %eax
callq 0x2130
cmpq $0x1f, %rbx
je 0x26f4
movl $0xffffffff, 0x4(%r14,%rbx,4) # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: debug_continue
void debug_continue (struct _vm * vm)
{
    int break_i;
    int breakpoint_found = 0;

    if (vm->halted) {
        printf("VM Halted\n");
        return;
    }
    while ((vm->halted == 0) && (breakpoint_found == 0)) {
        vm_step(vm);
        for (break_i = 0; break_i < BREAKPOINTS_SIZE; break_i++) {
            if (breakpoints[break_i] == -1)
                break;
            if (breakpoints[break_i] == vm->regs[REG_IP]) {
                printf("breakpoint: %s\n", vm_ins_str(vm));
                breakpoint_found = 1;
                break;
            }
        }
    }
}

// Assembly:
cmpl $0x0, 0x24(%rdi)
je 0x270e
leaq 0x3a08(%rip), %rdi      # 0x6111
jmp 0x20b0
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x24(%rdi)
jne 0x2775
leaq 0x8a9d(%rip), %r15      # 0xb1c0
leaq 0x3931(%rip), %r14      # 0x605b
movq %rbx, %rdi
callq 0x5261
xorl %ecx, %ecx
movl (%rcx,%r15), %edx
xorl %eax, %eax
cmpl $-0x1, %edx
je 0x2770
movzwl 0x16(%rbx), %esi
cmpl %esi, %edx
je 0x2756
addq $0x4, %rcx
cmpq $0x80, %rcx
jne 0x2734
jmp 0x2770
movq %rbx, %rdi
callq 0x5203
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x2130
movl $0x1, %eax
orl 0x24(%rbx), %eax
je 0x272a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/debugger.c
// Function: dump_core
void dump_core (struct _vm * vm)
{
    FILE * fh;

    fh = fopen("core", "wb");
    if (fh == NULL) {
        fprintf(stderr, "could not open file core\n");
        return;
    }

    fwrite (vm->mem, 1, 65536, fh);

    fclose(fh);

    printf("core written to file 'core'\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x38e2(%rip), %rdi      # 0x606b
leaq 0x38e0(%rip), %rsi      # 0x6070
callq 0x2290
testq %rax, %rax
je 0x27cd
movq %rax, %rbx
movq (%r14), %rdi
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0x2100
leaq 0x395a(%rip), %rdi      # 0x611b
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20b0
callq 0x22f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/token.c
// Function: token_create
struct _token * token_create (int type, const char * str, int line)
{
    struct _token * token = (struct _token *) malloc(sizeof(struct _token));
    token->type = type;
    token->next = NULL;
    token->line = line;

    if (str == NULL)
        token->str = NULL;
    else {
        token->str = (char *) malloc(strlen(str) + 1);
        strcpy(token->str, str);
        token->str[strlen(str)] = '\0';
    }

    return token;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
movl $0x18, %edi
callq 0x2200
movq %rax, %rbx
movl %r15d, (%rax)
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
testq %r14, %r14
je 0x4041
movq %r14, %rdi
callq 0x2110
leaq 0x1(%rax), %rdi
callq 0x2200
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movq %r14, %rdi
callq 0x2110
movb $0x0, (%r15,%rax)
jmp 0x4049
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/token.c
// Function: token_str
const char * token_str (struct _token * token)
{
    if (ins_reg_str(token->type) != NULL)
        return ins_reg_str(token->type);
    if (ins_opcode_str(token->type) != NULL)
        return ins_opcode_str(token->type);
    if (token->type == TOK_NEWLINE)
        return "NEWLINE";
    if (token->type == TOK_COMMA)
        return ",";
    return token->str;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %edi
callq 0x2a48
movb (%rbx), %cl
movzbl %cl, %edi
testq %rax, %rax
je 0x408e
popq %rbx
jmp 0x2a48
callq 0x2a64
movl (%rbx), %ecx
testq %rax, %rax
je 0x40a3
movzbl %cl, %edi
popq %rbx
jmp 0x2a64
cmpl $0x70, %ecx
je 0x40b6
cmpl $0x71, %ecx
jne 0x40bf
leaq 0x24bc(%rip), %rax      # 0x6570
jmp 0x40c3
leaq 0x24ab(%rip), %rax      # 0x6568
jmp 0x40c3
movq 0x8(%rbx), %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: linenoiseAddCompletion
void linenoiseAddCompletion(linenoiseCompletions *lc, char *str) {
    size_t len = strlen(str);
    char *copy = malloc(len+1);
    memcpy(copy,str,len+1);
    lc->cvec = realloc(lc->cvec,sizeof(char*)*(lc->len+1));
    lc->cvec[lc->len++] = copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2110
leaq 0x1(%rax), %r15
movq %r15, %rdi
callq 0x2200
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x21f0
movq (%r14), %rax
movq 0x8(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2240
movq %rax, 0x8(%r14)
movq (%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%r14)
movq %r12, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: linenoiseHistoryAdd
int linenoiseHistoryAdd(const char *line) {
    char *linecopy;

    if (history_max_len == 0) return 0;
    if (history == NULL) {
        history = malloc(sizeof(char*)*history_max_len);
        if (history == NULL) return 0;
        memset(history,0,(sizeof(char*)*history_max_len));
    }
    linecopy = strdup(line);
    if (!linecopy) return 0;
    if (history_len == history_max_len) {
        free(history[0]);
        memmove(history,history+1,sizeof(char*)*(history_max_len-1));
        history_len--;
    }
    history[history_len] = linecopy;
    history_len++;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x467e(%rip), %ebx      # 0x9180
cmpq $0x0, 0x6736(%rip)      # 0xb240
jne 0x4b35
leaq (,%rbx,8), %r15
movq %r15, %rdi
callq 0x2200
movq %rax, 0x671d(%rip)      # 0xb240
testq %rax, %rax
je 0x4ba1
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2150
movq %r14, %rdi
callq 0x22c0
testq %rax, %rax
je 0x4ba1
movq %rax, %r14
movl 0x6705(%rip), %ebp      # 0xb250
cmpl %ebx, %ebp
jne 0x4b7f
movq 0x66ea(%rip), %rax      # 0xb240
movq (%rax), %rdi
callq 0x2040
movq 0x66db(%rip), %rdi      # 0xb240
leaq 0x8(%rdi), %rsi
decl %ebx
shlq $0x3, %rbx
movq %rbx, %rdx
callq 0x2250
decl %ebp
movl %ebp, 0x66d1(%rip)      # 0xb250
movq 0x66ba(%rip), %rax      # 0xb240
movslq 0x66c3(%rip), %rcx      # 0xb250
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x66b6(%rip)      # 0xb250
movl $0x1, %eax
jmp 0x4ba3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: linenoiseHistorySetMaxLen
int linenoiseHistorySetMaxLen(int len) {
    char **new;

    if (len < 1) return 0;
    if (history) {
        int tocopy = history_len;

        new = malloc(sizeof(char*)*len);
        if (new == NULL) return 0;
        if (len < tocopy) tocopy = len;
        memcpy(new,history+(history_max_len-tocopy), sizeof(char*)*tocopy);
        free(history);
        history = new;
    }
    history_max_len = len;
    if (history_len > history_max_len)
        history_len = history_max_len;
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testl %edi, %edi
jle 0x4c30
movl %edi, %ebx
movq 0x667b(%rip), %r14      # 0xb240
testq %r14, %r14
je 0x4c17
movl 0x667f(%rip), %r12d     # 0xb250
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x2200
testq %rax, %rax
je 0x4c30
movq %rax, %r15
cmpl %ebx, %r12d
cmovgel %ebx, %r12d
movslq 0x458e(%rip), %rax      # 0x9180
movslq %r12d, %rdx
subq %rdx, %rax
leaq (%r14,%rax,8), %rsi
shlq $0x3, %rdx
movq %r15, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x2040
movq %r15, 0x6629(%rip)      # 0xb240
movl %ebx, 0x4563(%rip)      # 0x9180
movl $0x1, %ebp
cmpl %ebx, 0x6628(%rip)      # 0xb250
jle 0x4c30
movl %ebx, 0x6620(%rip)      # 0xb250
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: linenoiseHistorySave
int linenoiseHistorySave(char *filename) {
    FILE *fp = fopen(filename,"w");
    int j;
    
    if (fp == NULL) return -1;
    for (j = 0; j < history_len; j++)
        fprintf(fp,"%s\n",history[j]);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x19bd(%rip), %rsi      # 0x6604
callq 0x2290
testq %rax, %rax
je 0x4c9a
movq %rax, %rbx
cmpl $0x0, 0x65f5(%rip)      # 0xb250
jle 0x4c8e
leaq 0x1403(%rip), %r14      # 0x6067
xorl %r15d, %r15d
movq 0x65d2(%rip), %rax      # 0xb240
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x21d0
incq %r15
movslq 0x65c7(%rip), %rax      # 0xb250
cmpq %rax, %r15
jl 0x4c67
movq %rbx, %rdi
callq 0x2100
xorl %eax, %eax
jmp 0x4c9f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: linenoiseHistoryLoad
int linenoiseHistoryLoad(char *filename) {
    FILE *fp = fopen(filename,"r");
    char buf[LINENOISE_MAX_LINE];
    
    if (fp == NULL) return -1;

    while (fgets(buf,LINENOISE_MAX_LINE,fp) != NULL) {
        char *p;
        
        p = strchr(buf,'\r');
        if (!p) p = strchr(buf,'\n');
        if (p) *p = '\0';
        linenoiseHistoryAdd(buf);
    }
    fclose(fp);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
leaq 0x182d(%rip), %rsi      # 0x64e3
callq 0x2290
testq %rax, %rax
je 0x4d2b
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdx
callq 0x21b0
testq %rax, %rax
je 0x4d1f
movq %rsp, %r14
movq %r14, %rdi
movl $0xd, %esi
callq 0x2120
testq %rax, %rax
jne 0x4cfa
movq %r14, %rdi
movl $0xa, %esi
callq 0x2120
testq %rax, %rax
je 0x4d02
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x4af2
movq %r14, %rdi
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdx
callq 0x21b0
testq %rax, %rax
jne 0x4cdb
movq %rbx, %rdi
callq 0x2100
xorl %eax, %eax
jmp 0x4d30
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: refreshLine
static void refreshLine(int fd, const char *prompt, char *buf, size_t len, size_t pos, size_t cols) {
    char seq[64];
    size_t plen = strlen(prompt);
    
    while((plen+pos) >= cols) {
        buf++;
        len--;
        pos--;
    }
    while (plen+len > cols) {
        len--;
    }

    /* Cursor to left edge */
    snprintf(seq,64,"\x1b[0G");
    if (write(fd,seq,strlen(seq)) == -1) return;
    /* Write the prompt and the current buffer content */
    if (write(fd,prompt,strlen(prompt)) == -1) return;
    if (write(fd,buf,len) == -1) return;
    /* Erase to right */
    snprintf(seq,64,"\x1b[0K");
    if (write(fd,seq,strlen(seq)) == -1) return;
    /* Move cursor to original position. */
    snprintf(seq,64,"\x1b[0G\x1b[%dC", (int)(pos+plen));
    if (write(fd,seq,strlen(seq)) == -1) return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
callq 0x2110
movq %rax, %r12
leaq (%rax,%r15), %rbx
cmpq %rbp, %rbx
jb 0x4e05
leaq (%r12,%r15), %rax
leaq (%r12,%r15), %rcx
decq %rcx
leaq -0x1(%rbp), %rbx
cmpq %rbx, %rcx
cmovbq %rcx, %rbx
addq %rbx, %r14
subq %rax, %r14
subq %rbx, %rax
addq %rax, %r13
movq %r13, (%rsp)
addq %r12, %r14
cmpq %r14, %rbp
cmovbq %rbp, %r14
leaq 0x10(%rsp), %r15
movb $0x0, 0x4(%r15)
movl $0x47305b1b, (%r15)     # imm = 0x47305B1B
movq %r15, %rdi
callq 0x2110
xorl %edi, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4ed8
movq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2110
xorl %edi, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4ed8
subq %r12, %r14
xorl %edi, %edi
movq (%rsp), %rsi
movq %r14, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4ed8
leaq 0x10(%rsp), %r14
movb $0x0, 0x4(%r14)
movl $0x4b305b1b, (%r14)     # imm = 0x4B305B1B
movq %r14, %rdi
callq 0x2110
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4ed8
leaq 0x1774(%rip), %rdx      # 0x6621
leaq 0x10(%rsp), %r14
movl $0x40, %esi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2140
movq %r14, %rdi
callq 0x2110
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x20f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/linenoise.c
// Function: freeCompletions
static void freeCompletions(linenoiseCompletions *lc) {
    size_t i;
    for (i = 0; i < lc->len; i++)
        free(lc->cvec[i]);
    if (lc->cvec != NULL)
        free(lc->cvec);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x4f0c
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
cmpq (%rbx), %r14
jb 0x4ef7
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x4f21
popq %rbx
popq %r14
jmp 0x2040
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_create
struct _vm * vm_create (unsigned char * mem)
{
    struct _vm * vm;
    int i;

    vm = (struct _vm *) malloc(sizeof(struct _vm));
    vm->mem = (unsigned char *) malloc(VM_MEMSIZE);
    memcpy(vm->mem, mem, VM_MEMSIZE);

    for (i = 0; i < 11; i++) vm->regs[i] = 0;
    vm->regs[REG_IP] = 0;
    vm->regs[REG_SP] = 0xfff8;
    vm->flags = 0;
    vm->halted = 0;

    return vm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x128, %edi            # imm = 0x128
callq 0x2200
movq %rax, %r14
movl $0x10000, %edi          # imm = 0x10000
callq 0x2200
movq %rax, (%r14)
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x16(%r14)
movw $0x0, 0x16(%r14)
movw $0xfff8, 0x1a(%r14)     # imm = 0xFFF8
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_load
struct _vm * vm_load (const char * filename)
{
    unsigned char * mem;
    FILE * fh;
    size_t filesize;
    struct _vm * vm;

    fh = fopen(filename, "rb");
    if (fh == NULL)
        return NULL;

    fseek(fh, 0, SEEK_END);
    filesize = ftell(fh);
    fseek(fh, 0, SEEK_SET);

    mem = (unsigned char *) malloc(VM_MEMSIZE);
    memset(mem, 0, VM_MEMSIZE);

    if (filesize > VM_MEMSIZE)
        filesize = VM_MEMSIZE;

    fread(mem, 1, filesize, fh);

    fclose(fh);

    vm = vm_create(mem);

    free(mem);

    return vm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leaq 0x1554(%rip), %rsi      # 0x64e8
callq 0x2290
testq %rax, %rax
je 0x505b
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2230
movq %rbx, %rdi
callq 0x21e0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2230
movl $0x10000, %r13d         # imm = 0x10000
movl $0x10000, %edi          # imm = 0x10000
callq 0x2200
movq %rax, %r14
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rdi
xorl %esi, %esi
callq 0x2150
cmpq %r13, %r15
cmovaeq %r13, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x20d0
movq %rbx, %rdi
callq 0x2100
movl $0x128, %edi            # imm = 0x128
callq 0x2200
movq %rax, %rbx
movl $0x10000, %edi          # imm = 0x10000
callq 0x2200
movq %rax, (%rbx)
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq %r12, 0x16(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movw $0xfff8, 0x1a(%rbx)     # imm = 0xFFF8
movq %r12, 0x20(%rbx)
movq %r14, %rdi
callq 0x2040
jmp 0x505d
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_syscall
void vm_syscall (struct _vm * vm)
{
    switch (vm->regs[REG_0]) {
    case VM_SYSCALL_OPEN  : vm_syscall_open(vm);  break;
    case VM_SYSCALL_READ  : vm_syscall_read(vm);  break;
    case VM_SYSCALL_WRITE : vm_syscall_write(vm); break;
    case VM_SYSCALL_CLOSE : vm_syscall_close(vm); break;
    }
}

// Assembly:
pushq %rbx
movzwl 0x8(%rdi), %eax
cmpq $0x3, %rax
ja 0x50e3
movq %rdi, %rbx
leaq 0x1598(%rip), %rcx      # 0x662c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x50e5
movzwl 0xa(%rbx), %edi
movzwl 0xc(%rbx), %esi
movzwl 0xe(%rbx), %edx
addq (%rbx), %rsi
callq 0x20f0
jmp 0x50df
movzwl 0xa(%rbx), %edi
callq 0x2180
movw %ax, 0x8(%rbx)
jmp 0x50e3
movzwl 0xa(%rbx), %edi
movzwl 0xc(%rbx), %esi
movzwl 0xe(%rbx), %edx
addq (%rbx), %rsi
callq 0x21a0
movw %ax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_syscall_write
void vm_syscall_write (struct _vm * vm)
{
    uint16_t r1 = vm->regs[REG_1];
    uint16_t r2 = vm->regs[REG_2];
    uint16_t r3 = vm->regs[REG_3];
    void * buf  = &(vm->mem[r2]);

    vm->regs[REG_0] = write(r1, buf, r3);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl 0xa(%rdi), %edi
movzwl 0xc(%rbx), %esi
movzwl 0xe(%rbx), %edx
addq (%rbx), %rsi
callq 0x20f0
movw %ax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_registers_str
const char * vm_registers_str (struct _vm * vm)
{
    snprintf(vm->debug_str, 256,
             "r0=%04x r1=%04x r2=%04x r3=%04x r4=%04x r5=%04x\n"
             "r6=%04x r7=%04x rsp=%04x rbp=%04x\n"
             "rip=%04x flags=%d",
             vm->regs[REG_0], vm->regs[REG_1], vm->regs[REG_2],
             vm->regs[REG_3], vm->regs[REG_4], vm->regs[REG_5],
             vm->regs[REG_6], vm->regs[REG_7], vm->regs[REG_SP],
             vm->regs[REG_BP], vm->regs[REG_IP], vm->flags);
    return vm->debug_str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x28(%rdi), %rbx
movzwl 0x8(%rdi), %ecx
movzwl 0xa(%rdi), %r8d
movzwl 0xc(%rdi), %r9d
movzwl 0xe(%rdi), %eax
movq %rax, 0x10(%rsp)
movzwl 0x10(%rdi), %eax
movq %rax, 0x8(%rsp)
movzwl 0x12(%rdi), %r14d
movzwl 0x14(%rdi), %r15d
movzwl 0x1c(%rdi), %r12d
movzwl 0x1a(%rdi), %r13d
movzwl 0x18(%rdi), %ebp
movzwl 0x16(%rdi), %r10d
movl 0x20(%rdi), %r11d
subq $0x8, %rsp
leaq 0x15bb(%rip), %rdx      # 0x6784
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq 0x48(%rsp)
pushq 0x58(%rsp)
callq 0x2140
addq $0x50, %rsp
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/endeav0r[P]hvm/src/vm.c
// Function: vm_ins_str
const char * vm_ins_str (struct _vm * vm)
{
    char tmp[256];
    struct _instruction * ins;
    ins = (struct _instruction *) &(vm->mem[vm->regs[REG_IP]]);
    ins_str(ins, tmp, 256);
    snprintf(vm->debug_str, 256, "%04x %s", vm->regs[REG_IP], tmp);
    return vm->debug_str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movzwl 0x16(%rdi), %edi
addq (%rbx), %rdi
movq %rsp, %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rsi
callq 0x2b7b
movzwl 0x16(%rbx), %ecx
addq $0x28, %rbx
leaq 0x15b2(%rip), %rdx      # 0x67e8
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
movq %r14, %r8
xorl %eax, %eax
callq 0x2140
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/read2.c
// Function: testcase_prepare
void testcase_prepare(unsigned long nr_tasks)
{
	char buf[FILESIZE];
	int fd = mkstemp(tmpfile);

	memset(buf, 0, sizeof(buf));
	assert(fd >= 0);
	assert(write(fd, buf, sizeof(buf)) == sizeof(buf));
	close(fd);
}

// Assembly:
pushq %rbx
subq $0x100000, %rsp         # imm = 0x100000
leaq 0x2585(%rip), %rdi      # 0x51a0
callq 0x21f0
movl %eax, %ebx
movq %rsp, %rdi
movl $0x100000, %edx         # imm = 0x100000
xorl %esi, %esi
callq 0x2140
testl %ebx, %ebx
js 0x2c5b
movq %rsp, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2c7a
movl %ebx, %edi
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
jmp 0x2150
leaq 0x615(%rip), %rdi       # 0x3277
leaq 0x616(%rip), %rsi       # 0x327f
leaq 0x61d(%rip), %rcx       # 0x328d
movl $0x14, %edx
callq 0x2130
leaq 0x631(%rip), %rdi       # 0x32b2
leaq 0x5f7(%rip), %rsi       # 0x327f
leaq 0x5fe(%rip), %rcx       # 0x328d
movl $0x15, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/read2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDONLY);

	assert(fd >= 0);

	while (1) {
		int ret = read(fd, buf, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %rbx
leaq 0x24f2(%rip), %rdi      # 0x51a0
xorl %esi, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2d17
movl %eax, %ebp
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %eax, %edi
callq 0x2170
testl %eax, %eax
js 0x2cf8
movq %rsp, %r14
testl %eax, %eax
jne 0x2ce2
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2120
incq (%rbx)
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r14, %rsi
callq 0x2170
testl %eax, %eax
jns 0x2cd3
leaq 0x611(%rip), %rdi       # 0x3310
leaq 0x579(%rip), %rsi       # 0x327f
leaq 0x5d0(%rip), %rcx       # 0x32dd
movl $0x22, %edx
callq 0x2130
leaq 0x559(%rip), %rdi       # 0x3277
leaq 0x55a(%rip), %rsi       # 0x327f
leaq 0x5b1(%rip), %rcx       # 0x32dd
movl $0x1e, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/png.c
// Function: init
extern image_type_t *init(void)
{
	static image_type_t png;
	png.type = "PNG";
	png.is_type = is_png;
	png.read = read_png;
	png.write = write_png;
	png.info = info_png;
	png.free = free_png;
	return &png;
}

// Assembly:
leaq 0xd3d(%rip), %rax       # 0x2000
movq %rax, 0x2e3e(%rip)      # 0x4108
leaq 0x2e37(%rip), %rax      # 0x4108
leaq 0x40(%rip), %rcx        # 0x1318
movq %rcx, 0x2e31(%rip)      # 0x4110
leaq 0x8a(%rip), %rcx        # 0x1370
movq %rcx, 0x2e2b(%rip)      # 0x4118
leaq 0x298(%rip), %rcx       # 0x158c
movq %rcx, 0x2e25(%rip)      # 0x4120
leaq 0x499(%rip), %rcx       # 0x179b
movq %rcx, 0x2e1f(%rip)      # 0x4128
leaq 0x4a5(%rip), %rcx       # 0x17b5
movq %rcx, 0x2e19(%rip)      # 0x4130
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/png.c
// Function: is_png
static bool is_png(char *file_name)
{
	FILE *fp = fopen(file_name, "rb");
	if (!fp)
		return false;

	uint8_t header[8];
	fread(header, 1, sizeof header, fp);
	fclose(fp);

	return !png_sig_cmp(header, 0, sizeof header);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xce1(%rip), %rsi       # 0x2004
callq 0x1110
testq %rax, %rax
je 0x1366
movq %rax, %rbx
movq %rsp, %r14
movl $0x1, %esi
movl $0x8, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x10a0
movq %rbx, %rdi
callq 0x10b0
movl $0x8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1100
testl %eax, %eax
sete %al
jmp 0x1368
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/albinoloverats[P]hide/src/png.c
// Function: free_png
static void free_png(image_info_t image_info)
{
	for (uint64_t y = 0; y < image_info.height; y++)
		free(image_info.buffer[y]);
	free(image_info.buffer);
	free(image_info.extra);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %rbx
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x17e3
movq 0x40(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1040
incq %r12
cmpq %r12, %r14
jne 0x17d2
movq 0x40(%rbx), %rdi
callq 0x1040
movq 0x48(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/orestesleal[P]base64/b16dec.c
// Function: main
int main(int argc, char *argv[])
{
	struct finfo *fd;
	char *dec_buf;
	int ofd;
	size_t wr;
	size_t dec; /* number of decoded bytes */
	int flags = O_CREAT | O_RDWR;
	int perms = S_IRUSR | O_TRUNC | S_IWUSR;

	if (argv[1]) {
		/* load the encoded file */
		if ((fd = get_file(argv[1])) == NULL) {
			fprintf(stderr, "get_file() failed loading %s in main memory\n", argv[1]);
			exit(EXIT_FAILURE);
		}

		if (argv[2]) {
			/* allocate buffer and decode */
			dec_buf = alloc(fd->size); 

			/*  decode the base32 string on 'dec_buf' */
			dec = b16_dec(fd->addr, dec_buf, fd->size); 

            if ((ofd = open(argv[2], flags, perms)) == -1) {
            	fprintf(stderr, "open(2) error, can't create or truncate %s\n", argv[2]);
	        	exit(EXIT_FAILURE);
			}

			/* write the contents of `dec_buf` into the file requested on argv[2] */
			if ((wr = write(ofd, dec_buf, dec)) == -1) {
				fprintf(stderr, "write(2) error, can't write to %s\n", argv[2]);
				exit(EXIT_FAILURE);
			}
			close(ofd);
			free(dec_buf);
        }
		free(fd);
	}
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x152b
movq %rsi, %rbx
callq 0x2115
testq %rax, %rax
je 0x153c
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x1523
addq $0x10, %rbx
movl 0x8(%r14), %edi
callq 0x2240
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %edx
movq %rax, %rsi
callq 0x1f58
movl %eax, %r13d
movq (%rbx), %rdi
movl $0x42, %esi
movl $0x380, %edx            # imm = 0x380
xorl %eax, %eax
callq 0x10c0
cmpl $-0x1, %eax
je 0x1548
movl %eax, %r12d
movl %r13d, %edx
movl %eax, %edi
movq %r15, %rsi
callq 0x1040
cmpq $-0x1, %rax
je 0x1550
movl %r12d, %edi
callq 0x1070
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1154
movq %rbx, %rdi
callq 0x112a
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/pileup.c
// Function: readaln
static int readaln(void *data, bam1_t *b) {
    ptest_t *g = (ptest_t*)data;
    int ret;

    while (1) {
        ret = sam_read1(g->fp, g->fp_hdr, b);
        if (ret < 0) break;
        if ( b->core.flag & (BAM_FUNMAP | BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP) ) continue;
        break;
    }

    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
callq 0x1da59
testl %eax, %eax
js 0x6300
movzwl 0x10(%rbx), %ecx
testl $0x704, %ecx            # imm = 0x704
jne 0x62e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/pileup.c
// Function: print_pileup_qual
static void print_pileup_qual(const bam_pileup1_t *p, int n) {
    int i;

    for (i = 0; i < n; i++, p++) {
        uint8_t *qual = bam_get_qual(p->b);
        uint8_t q = '~';
        if (p->qpos < p->b->core.l_qseq &&
            qual[p->qpos]+33 < '~')
            q = qual[p->qpos]+33;
        putchar(q);
    }
}

// Assembly:
testl %esi, %esi
jle 0x654a
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%r14), %rdx
movl 0x18(%rdx), %ecx
movslq 0x8(%r14), %rax
movl $0x7e, %edi
cmpl %ecx, %eax
jge 0x6536
movl 0x14(%rdx), %esi
shll $0x2, %esi
addq 0x38(%rdx), %rsi
movzwl 0x12(%rdx), %edx
incl %ecx
sarl %ecx
movslq %ecx, %rcx
addq %rdx, %rcx
addq %rsi, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
ja 0x6536
addl $0x21, %eax
movl %eax, %edi
callq 0x46d0
addq $0x28, %r14
decl %ebx
jne 0x64fa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_06/setbits.c
// Function: setbits
unsigned int setbits(int x, int p, int n, int y)
{
  ++p; // First position is 0

  unsigned int mask1 = (~(~(~0 << n) << p) & x);
  unsigned int mask2 = (~(~0 << n) & y) << p;

  return mask1 | mask2;
}

// Assembly:
movl %ecx, %r8d
movl %edx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
leal 0x1(%rsi), %ecx
movl %eax, %edx
shll %cl, %edx
andl %r8d, %eax
shll %cl, %eax
notl %edx
andl %edi, %edx
orl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_08/getopt.c
// Function: main
int main(int argc, char *argv[])
{
	int c;
	int flag = 0, error = 0;
	char *name = NULL;
	int i;

	while ((c = getopt(argc, argv, ":af:")) != -1) {
		switch(c) {
		case 'a':
			flag++;
			break;
		case 'f':
			name = optarg;
			break;
		case ':':       /* missing operand? */
			fprintf(stderr,
				"option -%c requires an operand\n",
				optopt);
			error++;
			break;
		case '?':	/* invalid option? */
			fprintf(stderr,
				"unrecognized option '-%c'\n",
				optopt);
			error++;
		}
	}
	if (error) {
		fprintf(stderr,
			"usage: %s [-a] [-f <name>] [<arg> ...]\n",
			argv[0]);
		return -1;
	}

	/* Print the parsing result */
	if (flag)
		printf("-a\n");
	if (name)
		printf("-f=%s\n", name);
	for (i = optind; i < argc; i++)
		printf("argv[%d]=%s\n", i - optind, argv[i]);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
xorl %r13d, %r13d
leaq 0xe1e(%rip), %r12       # 0x2004
xorl %ebp, %ebp
xorl %r15d, %r15d
movl %ebx, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1060
cmpl $0x60, %eax
jle 0x120c
cmpl $0x66, %eax
je 0x1222
cmpl $0x61, %eax
jne 0x11eb
incl %r13d
jmp 0x11eb
cmpl $-0x1, %eax
je 0x1237
cmpl $0x3a, %eax
je 0x122e
cmpl $0x3f, %eax
jne 0x11eb
callq 0x1080
jmp 0x1233
movq 0x2da7(%rip), %rax      # 0x3fd0
movq (%rax), %r15
jmp 0x11eb
callq 0x10a1
incl %ebp
jmp 0x11eb
testl %ebp, %ebp
jne 0x12b4
testl %r13d, %r13d
je 0x124c
leaq 0xe39(%rip), %rdi       # 0x2080
callq 0x1030
testq %r15, %r15
je 0x1262
leaq 0xe14(%rip), %rdi       # 0x206c
movq %r15, %rsi
xorl %eax, %eax
callq 0x1040
movq 0x2d5f(%rip), %r15      # 0x3fc8
movl (%r15), %r12d
xorl %ebp, %ebp
cmpl %ebx, %r12d
jge 0x12a3
movslq %r12d, %rax
leaq (%r14,%rax,8), %r13
leaq 0xdf2(%rip), %r14       # 0x2073
xorl %ebp, %ebp
movl %r12d, %esi
subl (%r15), %esi
movq (%r13), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
addq $0x8, %r13
incl %r12d
cmpl %r12d, %ebx
jne 0x1283
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x10c2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x12a3
// File: /workspace/github_c_makefile_star2_O1/Marinouel[P]Network-Lab/serv4.c
// Function: writen
ssize_t writen(int fd, const void *vptr, size_t n)                    //function from the lessons-> writen
{
  size_t nleft;
  ssize_t nwritten;
  const char *ptr;
  ptr = vptr;
  nleft = n;
  while (nleft > 0) {
    if  ((nwritten = write(fd, ptr, nleft)) <= 0 ){ 
      if (errno == EINTR) 
        nwritten = 0;
            else 
              return -1; /* error */ 
    } 
    nleft -= nwritten;
        ptr += nwritten;
  } 
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1248
movq %rsi, %r14
movl %edi, %r15d
movq %rbx, %r12
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1070
testq %rax, %rax
jg 0x1237
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1241
xorl %eax, %eax
addq %rax, %r14
subq %rax, %r12
jne 0x1218
jmp 0x1248
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Marinouel[P]Network-Lab/serv4.c
// Function: get
char *get(char *key)
{ 
  /** Returns the value associated with the key, or NULL
  * if the key is not in the store. **/
  
  int i=0;        //counter
  int flag=0;     //if not exists the key 
  char p[50];     // value whitch returns if we didn't find the key 
  int pos=0;      //variable to store the position


   for( i = 0; i<=netlab.next ; i++)     //while we have positions to check, we continue 
   {
      if ((strcmp(netlab.keyvalue[i][0], key)) == 0)   //if the comparations return 0 then we have found the key 
      {
           return netlab.keyvalue[i][1];              //return the value of the key, the second value from the cell
      }
   }

   return NULL;   //return nothing
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2e2c(%rip), %eax      # 0x4094
testl %eax, %eax
js 0x12a4
movq %rdi, %r14
imulq $0x64, %rax, %r12
addq $0x64, %r12
leaq 0x2e1a(%rip), %r15      # 0x4098
xorl %ebx, %ebx
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1090
testl %eax, %eax
je 0x12a8
addq $-0x64, %r13
addq $0x64, %r15
movq %r12, %rax
addq %r13, %rax
jne 0x1283
jmp 0x12b6
xorl %ebx, %ebx
jmp 0x12b6
leaq 0x2de5(%rip), %rbx      # 0x4094
subq %r13, %rbx
addq $0x36, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/Marinouel[P]Network-Lab/serv4.c
// Function: put
void put(char *key, char *value)
{
  /* Puts the <key,value> pair into the store. If the key already existed, its previous 
  * value is discarded and replaced by the new one. */

  int x;
  int flag=0;

      for (x=0;x<netlab.next ;x++) // check all the positions
      {   
          if (strcmp(netlab.keyvalue[x][0], key)== 0) //if you find the key update
          {
    
               strcpy(netlab.keyvalue[x][1], value);
               strcpy(netlab.keyvalue[x][0], key);
               flag=1;
               return;
          } 
      }

     if (flag == 0) //if the value doesn't exist, then we store it in the array
     {
          netlab.next++;   //put it in the next empty cell
          strcpy(netlab.keyvalue[netlab.next][1], value);
          strcpy(netlab.keyvalue[netlab.next][0], key);
          return;
    }       
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movslq 0x2db0(%rip), %r12      # 0x4094
testq %r12, %r12
jle 0x1316
imulq $0x64, %r12, %r14
leaq 0x2da4(%rip), %r15      # 0x4098
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
je 0x1354
addq $0x64, %r15
addq $-0x64, %r13
movq %r14, %rax
addq %r13, %rax
jne 0x12f7
incl %r12d
movl %r12d, 0x2d74(%rip)     # 0x4094
leaq 0x2d6d(%rip), %r14      # 0x4094
movslq %r12d, %rax
imulq $0x64, %rax, %rax
leaq (%rax,%r14), %rdi
addq $0x36, %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movslq 0x2d4e(%rip), %rax      # 0x4094
imulq $0x64, %rax, %rax
leaq (%rax,%r14), %r15
addq $0x4, %r15
jmp 0x136b
leaq 0x2d39(%rip), %rdi      # 0x4094
subq %r13, %rdi
addq $0x36, %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: Font_atlas_add
static int Font_atlas_add(lua_State *L)
    {
    int err;
    ud_t *ud;
    nk_font_t* font;
    nk_atlas_t *atlas = checkatlas(L, 1, &ud);
    float height = luaL_checknumber(L, 2);
    const char *file_path = luaL_optstring(L, 3, NULL);
    nk_font_config_t *config = echeckfontconfig(L, 4, height, &err);
    if(err)
        { if(err == ERR_NOTPRESENT) lua_pop(L, 1); else return argerror(L, 4); }
    if(file_path)
        font = nk_font_atlas_add_from_file(atlas, file_path, height, config);
    else
        font = nk_font_atlas_add_default(atlas, height, config);
    //Not currently used:
    //nk_font_t* nk_font_atlas_add(atlas, const nk_font_config_t*);
    //nk_font_t* nk_font_atlas_add_from_memory(atlas, void*, nk_size, float, const nk_font_config_t*);
    //nk_font_t *nk_font_atlas_add_compressed(atlas, void*, nk_size, float, const nk_font_config_t*);
    //nk_font_t* nk_font_atlas_add_compressed_base85(atlas, const char*, float, const nk_font_config_t*);
    if(!font) return errorc(L, ERR_FAILED);
    pushatlasfont(L, ud, font, config);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x53c98(%rip), %rcx     # 0x68000
leaq 0x10(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12870
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x128c0
movq %rax, %r12
leaq 0x1c(%rsp), %r13
movq %rbx, %rdi
movl $0x4, %esi
movss 0xc(%rsp), %xmm0
movq %r13, %rdx
callq 0x131f0
movq %rax, %r14
movl (%r13), %eax
testl %eax, %eax
je 0x143dd
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0x143f8
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x12180
movq %r15, %rdi
testq %r12, %r12
je 0x14416
movq %r12, %rsi
movss 0xc(%rsp), %xmm0
movq %r14, %rdx
callq 0x136b0
jmp 0x14424
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x1445a
movss 0xc(%rsp), %xmm0
movq %r14, %rsi
callq 0x12e70
testq %rax, %rax
je 0x14443
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x12570
movl $0x1, %eax
jmp 0x1445a
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
callq 0x13ac0
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x139b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: Font_atlas_bake
static int Font_atlas_bake(lua_State *L)
    {
    ud_t *ud;
    int width, height;
    size_t len = 0;
    nk_atlas_t *atlas = checkatlas(L, 1, &ud);
    enum nk_font_atlas_format fmt = checkfontatlasformat(L, 2);
    const void* pixels = nk_font_atlas_bake(atlas, &width, &height, fmt);
    switch(fmt)
        {
        case NK_FONT_ATLAS_ALPHA8: len = width*height; break;
        case NK_FONT_ATLAS_RGBA32: len = width*height*4; break;
        }
    lua_pushlstring(L, (char*)pixels, len);
    lua_pushinteger(L, width);
    lua_pushinteger(L, height);
    return 3;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x53b86(%rip), %rcx     # 0x68000
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x132f0
movl %eax, %ebp
leaq 0x4(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
movl %eax, %ecx
callq 0x12790
cmpl $0x1, %ebp
je 0x144ca
testl %ebp, %ebp
jne 0x144da
movslq 0x4(%rsp), %rcx
movslq (%rsp), %rdx
imulq %rcx, %rdx
jmp 0x144dc
movl 0x4(%rsp), %ecx
imull (%rsp), %ecx
shll $0x2, %ecx
movslq %ecx, %rdx
jmp 0x144dc
xorl %edx, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13670
movslq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x12b60
movslq (%rsp), %rsi
movq %rbx, %rdi
callq 0x12b60
movl $0x3, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/stetre[P]moonnuklear/src/atlas.c
// Function: Font_atlas_end
static int Font_atlas_end(lua_State *L)
    {
    nk_handle_t tex;
    nk_draw_null_texture_t dnt;
    nk_atlas_t *atlas = checkatlas(L, 1, NULL);
    tex.id = luaL_checkinteger(L, 2);
    nk_font_atlas_end(atlas, tex, &dnt);
    lua_pushinteger(L, dnt.texture.id);
    pushvec2(L, &dnt.uv);
    return 2;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x53adf(%rip), %rcx     # 0x68000
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x12f30
movl %eax, %esi
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x12d00
movslq (%r15), %rsi
movq %rbx, %rdi
callq 0x12b60
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x126b0
movl $0x2, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq