LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
movl $0x18, %edi
callq 0x21f0
movq %rax, %rbx
movl %r15d, (%rax)
movq $0x0, 0x10(%rax)
movl %ebp, 0x4(%rax)
testq %r14, %r14
je 0x3fb1
movq %r14, %rdi
callq 0x2110
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x21f0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movb $0x0, (%r15,%r12)
jmp 0x3fb4
xorl %r15d, %r15d
movq %r15, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2a2c
movb (%rbx), %cl
movzbl %cl, %edi
testq %rax, %rax
je 0x3ffb
popq %rbx
jmp 0x2a2c
callq 0x2a48
movl (%rbx), %ecx
testq %rax, %rax
je 0x4010
movzbl %cl, %edi
popq %rbx
jmp 0x2a48
cmpl $0x70, %ecx
je 0x4023
cmpl $0x71, %ecx
jne 0x402c
leaq 0x258e(%rip), %rax      # 0x65af
jmp 0x4030
leaq 0x257d(%rip), %rax      # 0x65a7
jmp 0x4030
movq 0x8(%rbx), %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x47d0(%rip), %r15d     # 0x9178
movq 0x6881(%rip), %r14      # 0xb230
testq %r14, %r14
jne 0x49d5
leaq (,%r15,8), %rsi
movl $0x1, %edi
callq 0x21b0
movq %rax, %r14
movq %rax, 0x6860(%rip)      # 0xb230
testq %rax, %rax
je 0x4a32
movq %rbx, %rdi
callq 0x22b0
testq %rax, %rax
je 0x4a32
movq %rax, %rbx
movl 0x6855(%rip), %eax      # 0xb240
cmpl %r15d, %eax
jne 0x4a1d
movq (%r14), %rdi
callq 0x2040
movq 0x6831(%rip), %rdi      # 0xb230
leaq 0x8(%rdi), %rsi
decl %r15d
leaq (,%r15,8), %rdx
callq 0x2240
movq 0x6816(%rip), %r14      # 0xb230
movl %r15d, %eax
cltq
movq %rbx, (%r14,%rax,8)
incl %eax
movl %eax, 0x6815(%rip)      # 0xb240
movl $0x1, %eax
jmp 0x4a34
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4abb
movl %edi, %ebx
movq 0x67df(%rip), %r14      # 0xb230
movl 0x67e8(%rip), %r12d     # 0xb240
testq %r14, %r14
je 0x4aa5
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x21f0
testq %rax, %rax
je 0x4abb
movq %rax, %r15
cmpl %ebx, %r12d
movl %ebx, %eax
cmovll %r12d, %eax
movslq 0x46f8(%rip), %rcx      # 0x9178
movslq %eax, %rdx
subq %rdx, %rcx
leaq (%r14,%rcx,8), %rsi
shlq $0x3, %rdx
movq %r15, %rdi
callq 0x21e0
movq %r14, %rdi
callq 0x2040
movq %r15, 0x678b(%rip)      # 0xb230
movl %ebx, 0x46cd(%rip)      # 0x9178
movl $0x1, %ebp
cmpl %ebx, %r12d
jle 0x4abb
movl %ebx, 0x6785(%rip)      # 0xb240
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b92(%rip), %rsi      # 0x6664
callq 0x2280
testq %rax, %rax
je 0x4b25
movq %rax, %rbx
cmpl $0x0, 0x675a(%rip)      # 0xb240
jle 0x4b19
leaq 0x1578(%rip), %r14      # 0x6067
xorl %r15d, %r15d
movq 0x6737(%rip), %rax      # 0xb230
movq (%rax,%r15,8), %rdx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x21c0
incq %r15
movslq 0x672c(%rip), %rax      # 0xb240
cmpq %rax, %r15
jl 0x4af2
movq %rbx, %rdi
callq 0x2100
xorl %eax, %eax
jmp 0x4b2a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x48, %rsp
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
callq 0x2110
movq %rax, %r12
addq %rax, %rbx
cmpq %rbp, %rbx
jb 0x4c8b
leaq -0x1(%rbx), %rax
leaq -0x1(%rbp), %rcx
cmpq %rcx, %rax
cmovbq %rax, %rcx
addq %rcx, %r14
subq %rbx, %r14
subq %rcx, %rbx
addq %rbx, %r15
movq %rcx, %rbx
addq %r12, %r14
cmpq %r14, %rbp
cmovbq %rbp, %r14
movq %rsp, %rbp
movb $0x0, 0x4(%rbp)
movl $0x47305b1b, (%rbp)     # imm = 0x47305B1B
movq %rbp, %rdi
callq 0x2110
xorl %edi, %edi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4d4d
movq %r13, %rdi
callq 0x2110
xorl %edi, %edi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4d4d
subq %r12, %r14
xorl %edi, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20f0
cmpq $-0x1, %rax
je 0x4d4d
movq %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 0x4d4d
leaq 0x195d(%rip), %rdx      # 0x6681
movq %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 $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21f0
movq %rax, %r14
movl $0x10000, %edi          # imm = 0x10000
callq 0x21f0
movq %rax, (%r14)
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21e0
xorl %eax, %eax
movq %rax, 0x16(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%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_O3/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 0x1727(%rip), %rsi      # 0x64e8
callq 0x2280
testq %rax, %rax
je 0x4e7e
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2220
movq %rbx, %rdi
callq 0x21d0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2220
movl $0x10000, %r13d         # imm = 0x10000
movl $0x1, %edi
movl $0x10000, %esi          # imm = 0x10000
callq 0x21b0
movq %rax, %r14
cmpq %r13, %r15
cmovaeq %r13, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x20d0
movq %rbx, %rdi
callq 0x2100
movl $0x128, %edi            # imm = 0x128
callq 0x21f0
movq %rax, %rbx
movl $0x10000, %edi          # imm = 0x10000
callq 0x21f0
movq %rax, (%rbx)
movl $0x10000, %edx          # imm = 0x10000
movq %rax, %rdi
movq %r14, %rsi
callq 0x21e0
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 0x4e80
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f06
movq %rdi, %rbx
leaq 0x17d5(%rip), %rcx      # 0x668c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x4f08
movzwl 0xa(%rbx), %edi
movzwl 0xc(%rbx), %esi
movzwl 0xe(%rbx), %edx
addq (%rbx), %rsi
callq 0x20f0
jmp 0x4f02
movzwl 0xa(%rbx), %edi
callq 0x2170
movw %ax, 0x8(%rbx)
jmp 0x4f06
movzwl 0xa(%rbx), %edi
movzwl 0xc(%rbx), %esi
movzwl 0xe(%rbx), %edx
addq (%rbx), %rsi
callq 0x2190
movw %ax, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b5f
movzwl 0x16(%rbx), %ecx
addq $0x28, %rbx
leaq 0x17ef(%rip), %rdx      # 0x6848
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_O3/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 0x24ed(%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 0x2cf3
movq %rsp, %rsi
movl $0x100000, %edx         # imm = 0x100000
movl %ebx, %edi
callq 0x20d0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x2d12
movl %ebx, %edi
addq $0x100000, %rsp         # imm = 0x100000
popq %rbx
jmp 0x2150
leaq 0x5bd(%rip), %rdi       # 0x32b7
leaq 0x5be(%rip), %rsi       # 0x32bf
leaq 0x5c5(%rip), %rcx       # 0x32cd
movl $0x14, %edx
callq 0x2130
leaq 0x5d9(%rip), %rdi       # 0x32f2
leaq 0x59f(%rip), %rsi       # 0x32bf
leaq 0x5a6(%rip), %rcx       # 0x32cd
movl $0x15, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/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 0x245a(%rip), %rdi      # 0x51a0
xorl %esi, %esi
xorl %eax, %eax
callq 0x2230
testl %eax, %eax
js 0x2daf
movl %eax, %ebp
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %eax, %edi
callq 0x2170
testl %eax, %eax
js 0x2d90
movq %rsp, %r14
testl %eax, %eax
jne 0x2d7a
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 0x2d6b
leaq 0x5b9(%rip), %rdi       # 0x3350
leaq 0x521(%rip), %rsi       # 0x32bf
leaq 0x578(%rip), %rcx       # 0x331d
movl $0x22, %edx
callq 0x2130
leaq 0x501(%rip), %rdi       # 0x32b7
leaq 0x502(%rip), %rsi       # 0x32bf
leaq 0x559(%rip), %rcx       # 0x331d
movl $0x1e, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O3/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 0x294(%rip), %rcx       # 0x1588
movq %rcx, 0x2e25(%rip)      # 0x4120
leaq 0x48b(%rip), %rcx       # 0x178d
movq %rcx, 0x2e1f(%rip)      # 0x4128
leaq 0x497(%rip), %rcx       # 0x17a7
movq %rcx, 0x2e19(%rip)      # 0x4130
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r14
movq 0x28(%r14), %r15
movq 0x40(%r14), %rbx
testq %r15, %r15
je 0x17d5
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x1040
incq %r12
cmpq %r12, %r15
jne 0x17c4
movq %rbx, %rdi
callq 0x1040
movq 0x48(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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 0x2109
testq %rax, %rax
je 0x153c
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
je 0x1523
addq $0x10, %rbx
movl 0x8(%r14), %edi
callq 0x2234
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %edx
movq %rax, %rsi
callq 0x1f37
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_O3/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 0x1d1cf
testl %eax, %eax
js 0x6307
movzwl 0x10(%rbx), %ecx
testl $0x704, %ecx            # imm = 0x704
jne 0x62e7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x653d
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 0x6529
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 0x6529
addl $0x21, %eax
movl %eax, %edi
callq 0x46d0
addq $0x28, %r14
decl %ebx
jne 0x64ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdx, %rdx
je 0x1241
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movq %rdx, %r12
movl %r15d, %edi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1070
testq %rax, %rax
jg 0x1237
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1245
xorl %eax, %eax
addq %rax, %r14
subq %rax, %r12
jne 0x1218
jmp 0x124c
xorl %ebx, %ebx
jmp 0x124c
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2e28(%rip), %eax      # 0x4094
testl %eax, %eax
js 0x12a8
movq %rdi, %r14
imulq $0x64, %rax, %r12
addq $0x64, %r12
leaq 0x2e16(%rip), %r15      # 0x4098
xorl %ebx, %ebx
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1090
testl %eax, %eax
je 0x12ac
addq $-0x64, %r13
addq $0x64, %r15
movq %r12, %rax
addq %r13, %rax
jne 0x1287
jmp 0x12ba
xorl %ebx, %ebx
jmp 0x12ba
leaq 0x2de1(%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_O3/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 0x2dac(%rip), %r12      # 0x4094
testq %r12, %r12
jle 0x131a
imulq $0x64, %r12, %r14
leaq 0x2da0(%rip), %r15      # 0x4098
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1090
testl %eax, %eax
je 0x1358
addq $-0x64, %r13
addq $0x64, %r15
movq %r14, %rax
addq %r13, %rax
jne 0x12fb
incl %r12d
movl %r12d, 0x2d70(%rip)     # 0x4094
leaq 0x2d69(%rip), %r14      # 0x4094
movslq %r12d, %rax
imulq $0x64, %rax, %rax
leaq (%rax,%r14), %rdi
addq $0x36, %rdi
movq -0x30(%rbp), %rsi
callq 0x1050
movslq 0x2d4a(%rip), %rax      # 0x4094
imulq $0x64, %rax, %rax
leaq (%rax,%r14), %r15
addq $0x4, %r15
jmp 0x136f
leaq 0x2d35(%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_O3/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 0x52c98(%rip), %rcx     # 0x67000
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_O3/stetre[P]moonnuklear/src/atlas.c
// Function: Cursor
static int Cursor(lua_State *L)
    {
    ud_t *ud;
    nk_atlas_t *atlas = checkatlas(L, 1, &ud);
    enum nk_style_cursor what = checkstylecursor(L, 2);
    pushatlascursor(L, ud, &atlas->cursors[what]);
    return 1;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x52a11(%rip), %rcx     # 0x67000
leaq 0x8(%rsp), %r14
movl $0x1, %esi
movq %r14, %rdx
callq 0x120d0
movq %rax, %r15
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x132f0
movq (%r14), %rsi
movl %eax, %eax
leaq (%rax,%rax,4), %rax
leaq (%r15,%rax,8), %rdx
addq $0x48, %rdx
movq %rbx, %rdi
callq 0x13c20
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/atlas.c
// Function: Init
static int Init(lua_State *L)
    {
    ud_t *ud;
    nk_atlas_t *atlas;
    atlas = (nk_atlas_t*)Malloc(L, sizeof(nk_atlas_t));
    nk_font_atlas_init_default(atlas);
    //void nk_font_atlas_init(nk_atlas_t*, nk_allocator_t*);
    //void nk_font_atlas_init_custom(nk_atlas_t*, nk_allocator_t*, nk_allocator_t*);
    ud = newuserdata(L, atlas, ATLAS_MT, "atlas");
    ud->parent_ud = NULL;
    ud->destructor = freefont_atlas;
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x190, %esi            # imm = 0x190
callq 0x13a00
movq %rax, %r14
movq %rax, %rdi
callq 0x129d0
leaq 0x5299f(%rip), %rdx     # 0x67000
leaq 0x529a4(%rip), %rcx     # 0x6700c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x7d(%rip), %rcx        # 0x146ff
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/atlas.c
// Function: freefont_atlas
static int freefont_atlas(lua_State *L, ud_t *ud)
    {
    nk_atlas_t *atlas = (nk_atlas_t*)ud->handle;
    freechildren(L, FONT_MT, ud);
    freechildren(L, CURSOR_MT, ud);
    if(!freeuserdata(L, ud, "atlas")) return 0;
    nk_font_atlas_clear(atlas);
    Free(L, atlas);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rbx
leaq 0x5299d(%rip), %rsi     # 0x670b1
movq %r15, %rdx
callq 0x121c0
leaq 0x5299f(%rip), %rsi     # 0x670c2
movq %r14, %rdi
movq %r15, %rdx
callq 0x121c0
leaq 0x528d7(%rip), %rdx     # 0x6700c
movq %r14, %rdi
movq %r15, %rsi
callq 0x13d00
testl %eax, %eax
je 0x14757
movq %rbx, %rdi
callq 0x13b00
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/buffer.c
// Function: Init
static int Init(lua_State *L)
    {
    ud_t *ud;
    nk_buffer_t *buffer = checkbuffer(L, 1, &ud);
    void *ptr = checklightuserdata(L, 2);
    nk_size size = luaL_checkinteger(L, 3);
    if(size <= 0) return argerrorc(L, 3, ERR_VALUE);
    if(!IsFixed(ud))
        return luaL_argerror(L, 1, "not a fixed buffer");
    if(IsInitialized(ud))
        nk_buffer_free(buffer);
    nk_buffer_init_fixed(buffer, ptr, size);
    MarkInitialized(ud);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x528ae(%rip), %rcx     # 0x670d5
movq %rsp, %rdx
movl $0x1, %esi
callq 0x120d0
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13800
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
testq %rax, %rax
je 0x14878
movq %rax, %r12
movq (%rsp), %rax
movl 0x70(%rax), %eax
testb $0x4, %al
jne 0x14894
leaq 0x52885(%rip), %rdx     # 0x670f3
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x1488d
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x12460
jmp 0x148b8
testb $0x8, %al
je 0x148a0
movq %r14, %rdi
callq 0x13d60
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x12680
movq (%rsp), %rax
orl $0x8, 0x70(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/buffer.c
// Function: Buffer_ptr
static int Buffer_ptr(lua_State *L)
    {
    nk_buffer_t *buffer = checkbuffer(L, 1, NULL);
    void *ptr = nk_buffer_memory(buffer);
    if(!ptr) return 0;
    lua_pushlightuserdata(L, ptr);
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x52803(%rip), %rcx     # 0x670d5
xorl %r14d, %r14d
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %rdi
callq 0x13080
testq %rax, %rax
je 0x148ff
movq %rbx, %rdi
movq %rax, %rsi
callq 0x13450
movl $0x1, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/buffer.c
// Function: New
static int New(lua_State *L)
    {
    enum nk_allocation_type type = checkallocationtype(L, 1);
    switch(type)
        {
        case NK_BUFFER_DYNAMIC: return CreateDefault(L);
        case NK_BUFFER_FIXED: return CreateFixed(L);
        default: break;
        }
    return unexpected(L);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x13, %esi
movl $0x1, %edx
callq 0x132f0
testl %eax, %eax
je 0x1497a
cmpl $0x1, %eax
jne 0x149de
movl $0x78, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
movq %rax, %rdi
callq 0x130a0
leaq 0x52785(%rip), %rdx     # 0x670d5
leaq 0x527a8(%rip), %rcx     # 0x670ff
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x15c(%rip), %rcx       # 0x14acd
movq %rcx, 0x8(%rax)
jmp 0x14a47
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13df0
testl %eax, %eax
jle 0x14a03
movq %rbx, %rdi
movl $0x2, %esi
callq 0x13800
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12f30
testq %rax, %rax
je 0x14a55
movq %rax, %r12
movl $0x78, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
testq %r15, %r15
je 0x14a13
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x12680
movl $0xc, %ebp
jmp 0x14a18
leaq 0x5273a(%rip), %rsi     # 0x6711f
leaq 0x5274d(%rip), %rdx     # 0x67139
movq %rbx, %rdi
movl $0x56, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x139b0
movl $0x78, %esi
movq %rbx, %rdi
callq 0x13a00
movq %rax, %r14
movl $0x4, %ebp
leaq 0x526b6(%rip), %rdx     # 0x670d5
leaq 0x526d9(%rip), %rcx     # 0x670ff
movq %rbx, %rdi
movq %r14, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x8d(%rip), %rcx        # 0x14acd
movq %rcx, 0x8(%rax)
orl %ebp, 0x70(%rax)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x13ac0
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x12460
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/buffer.c
// Function: Clear_buffers
static int Clear_buffers(lua_State *L)
    {
    nk_buffer_t *buffer;
    int arg = 1;
    while(!lua_isnoneornil(L, arg))
        {
        buffer = checkbuffer(L, arg++, NULL);
        nk_buffer_clear(buffer);
        }
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x13df0
testl %eax, %eax
jle 0x14ac5
movl $0x2, %r14d
leaq 0x5263b(%rip), %r15     # 0x670d5
leal -0x1(%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x120d0
movq %rax, %rdi
callq 0x12e10
movq %rbx, %rdi
movl %r14d, %esi
callq 0x13df0
incl %r14d
testl %eax, %eax
jg 0x14a9a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/buffer.c
// Function: freebuffer
static int freebuffer(lua_State *L, ud_t *ud)
    {
    nk_buffer_t *buffer = (nk_buffer_t*)ud->handle;
    int is_initialized = IsInitialized(ud);
    if(!freeuserdata(L, ud, "buffer")) return 0;
    if(is_initialized) nk_buffer_free(buffer);
    Free(L, buffer);
    return 0;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rbx
movl 0x70(%rsi), %ebp
leaq 0x5261e(%rip), %rdx     # 0x670ff
callq 0x13d00
testl %eax, %eax
je 0x14b03
testb $0x8, %bpl
je 0x14af8
movq %rbx, %rdi
callq 0x13d60
movq %r14, %rdi
movq %rbx, %rsi
callq 0x130d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: moonnuklear_newanvasc
int newcanvas(lua_State *L, nk_canvas_t *canvas)
    {
    ud_t *ud = userdata(canvas);
    if(ud) /* already in */
        pushcanvas(L, canvas);
    else /* new */
        {
        ud = newuserdata(L, canvas, CANVAS_MT, "canvas");
        ud->parent_ud = NULL;
        ud->destructor = freecanvas;
        }
    return 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x132d0
testq %rax, %rax
je 0x14b30
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13c10
jmp 0x14b5c
leaq 0x5260b(%rip), %rdx     # 0x67142
leaq 0x52610(%rip), %rcx     # 0x6714e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13e90
movq $0x0, 0x10(%rax)
leaq 0x11(%rip), %rcx        # 0x14b69
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_line
static int Stroke_line(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float x0 = luaL_checknumber(L, 2);
    float y0 = luaL_checknumber(L, 3);
    float x1 = luaL_checknumber(L, 4);
    float y1 = luaL_checknumber(L, 5);
    float line_thickness = luaL_checknumber(L, 6);
    if(echeckcolor(L, 7, &color)) return argerror(L, 7);
    nk_stroke_line(canvas, x0, y0, x1, y1, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x52520(%rip), %rcx     # 0x67142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x7, %esi
callq 0x12100
testl %eax, %eax
je 0x14ccb
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x7, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x14cf8
cvtsd2ss 0x8(%rsp), %xmm4
cvtsd2ss 0x10(%rsp), %xmm3
cvtsd2ss 0x18(%rsp), %xmm2
cvtsd2ss 0x20(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x28(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x12880
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_curve
static int Stroke_curve(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float ax = luaL_checknumber(L, 2);
    float ay = luaL_checknumber(L, 3);
    float ctrl0x = luaL_checknumber(L, 4);
    float ctrl0y = luaL_checknumber(L, 5);
    float ctrl1x = luaL_checknumber(L, 6);
    float ctrl1y = luaL_checknumber(L, 7);
    float bx = luaL_checknumber(L, 8);
    float by = luaL_checknumber(L, 9);
    float line_thickness = luaL_checknumber(L, 10);
    if(echeckcolor(L, 11, &color)) return argerror(L, 11);
    nk_stroke_curve(canvas, ax, ay, ctrl0x, ctrl0y, ctrl1x, ctrl1y, bx, by, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
leaq 0x5242b(%rip), %rcx     # 0x67142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x58(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x50(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x48(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
movl $0x7, %esi
callq 0x12870
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl $0x8, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x9, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0xa, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
leaq 0x14(%rsp), %rdx
movq %r14, %rdi
movl $0xb, %esi
callq 0x12100
testl %eax, %eax
je 0x14e0c
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0xb, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x14e58
cvtsd2ss 0x18(%rsp), %xmm8
cvtsd2ss 0x20(%rsp), %xmm7
cvtsd2ss 0x28(%rsp), %xmm6
cvtsd2ss 0x30(%rsp), %xmm5
cvtsd2ss 0x38(%rsp), %xmm4
cvtsd2ss 0x40(%rsp), %xmm3
cvtsd2ss 0x48(%rsp), %xmm2
cvtsd2ss 0x50(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x58(%rsp), %xmm0
movl 0x14(%rsp), %esi
movss %xmm8, (%rsp)
movq %r15, %rdi
callq 0x13cc0
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_rect
static int Stroke_rect(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float rounding, line_thickness;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    rounding = luaL_checknumber(L, 3);
    line_thickness = luaL_checknumber(L, 4);
    if(echeckcolor(L, 5, &color)) return argerror(L, 5);
    nk_stroke_rect(canvas, r, rounding, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x522cd(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x14eb3
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x14f03
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12100
testl %eax, %eax
je 0x14f13
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x5, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x8(%rsp), %xmm3
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0x4(%rsp), %esi
movq %r14, %rdi
callq 0x12060
xorl %eax, %eax
jmp 0x14f0b
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_circle
static int Stroke_circle(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float line_thickness;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    line_thickness = luaL_checknumber(L, 3);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_stroke_circle(canvas, r, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x521f6(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x14f8a
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x14fc7
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x14fd7
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x13fa0
xorl %eax, %eax
jmp 0x14fcf
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Stroke_triangle
static int Stroke_triangle(lua_State *L)
    {
    nk_color_t color;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    float x0 = luaL_checknumber(L, 2);
    float y0 = luaL_checknumber(L, 3);
    float x1 = luaL_checknumber(L, 4);
    float y1 = luaL_checknumber(L, 5);
    float x2 = luaL_checknumber(L, 6);
    float y2 = luaL_checknumber(L, 7);
    float line_thickness = luaL_checknumber(L, 8);
    if(echeckcolor(L, 9, &color)) return argerror(L, 9);
    nk_stroke_triangle(canvas, x0, y0, x1, y1, x2, y2, line_thickness, color);
    return 0;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
leaq 0x52028(%rip), %rcx     # 0x67142
xorl %ebx, %ebx
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
callq 0x12870
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x30(%rsp)
movq %r14, %rdi
movl $0x4, %esi
callq 0x12870
movsd %xmm0, 0x28(%rsp)
movq %r14, %rdi
movl $0x5, %esi
callq 0x12870
movsd %xmm0, 0x20(%rsp)
movq %r14, %rdi
movl $0x6, %esi
callq 0x12870
movsd %xmm0, 0x18(%rsp)
movq %r14, %rdi
movl $0x7, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
movl $0x8, %esi
callq 0x12870
movsd %xmm0, 0x8(%rsp)
leaq 0x4(%rsp), %rdx
movq %r14, %rdi
movl $0x9, %esi
callq 0x12100
testl %eax, %eax
je 0x151e9
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %r14, %rdi
movl $0x9, %esi
movq %rax, %rdx
callq 0x12460
movl %eax, %ebx
jmp 0x15222
cvtsd2ss 0x8(%rsp), %xmm6
cvtsd2ss 0x10(%rsp), %xmm5
cvtsd2ss 0x18(%rsp), %xmm4
cvtsd2ss 0x20(%rsp), %xmm3
cvtsd2ss 0x28(%rsp), %xmm2
cvtsd2ss 0x30(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsd2ss 0x38(%rsp), %xmm0
movl 0x4(%rsp), %esi
movq %r15, %rdi
callq 0x13ae0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_rect
static int Fill_rect(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t color;
    float rounding;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    rounding = luaL_checknumber(L, 3);
    if(echeckcolor(L, 4, &color)) return argerror(L, 4);
    nk_fill_rect(canvas, r, rounding, color);
    return 0;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x51d71(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movq %rax, %r14
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
movq %rbx, %rdi
testl %eax, %eax
je 0x1540f
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x2, %esi
jmp 0x1544c
movl $0x3, %esi
callq 0x12870
movsd %xmm0, 0x10(%rsp)
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
je 0x1545c
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl $0x4, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cvtsd2ss 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movl 0xc(%rsp), %esi
movq %r14, %rdi
callq 0x12de0
xorl %eax, %eax
jmp 0x15454
// File: /workspace/github_c_makefile_star2_O3/stetre[P]moonnuklear/src/canvas.c
// Function: Fill_rect_multi_color
static int Fill_rect_multi_color(lua_State *L)
    {
    nk_rect_t r;
    nk_color_t left, top, right, bottom;
    nk_canvas_t *canvas = checkcanvas(L, 1, NULL);
    if(echeckrect(L, 2, &r)) return argerror(L, 2);
    if(echeckcolor(L, 3, &left)) return argerror(L, 3);
    if(echeckcolor(L, 4, &top)) return argerror(L, 4);
    if(echeckcolor(L, 5, &right)) return argerror(L, 5);
    if(echeckcolor(L, 6, &bottom)) return argerror(L, 6);
    (void)canvas;
    return 0;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x51cb4(%rip), %rcx     # 0x67142
movl $0x1, %esi
xorl %edx, %edx
callq 0x120d0
movl $0x2, %ebp
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x139f0
testl %eax, %eax
jne 0x15521
movl $0x3, %ebp
leaq 0x14(%rsp), %rdx
movq %rbx, %rdi
movl $0x3, %esi
callq 0x12100
testl %eax, %eax
jne 0x15521
movl $0x4, %ebp
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x4, %esi
callq 0x12100
testl %eax, %eax
jne 0x15521
movl $0x5, %ebp
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movl $0x5, %esi
callq 0x12100
testl %eax, %eax
jne 0x15521
movl $0x6, %ebp
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x6, %esi
callq 0x12100
testl %eax, %eax
je 0x15544
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x12630
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x12460
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x1553d