LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x270d(%rip), %rsi      # 0x95e4
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6ef4
movq $0x0, -0x8(%rbp)
jmp 0x6f8f
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2220
movq -0x20(%rbp), %rdi
callq 0x21d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2220
movl $0x10000, %edi          # imm = 0x10000
callq 0x21f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x2150
cmpq $0x10000, -0x28(%rbp)   # imm = 0x10000
jbe 0x6f52
movq $0x10000, -0x28(%rbp)   # imm = 0x10000
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x20c0
movq -0x20(%rbp), %rdi
callq 0x20f0
movq -0x18(%rbp), %rdi
callq 0x6e20
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x8(%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x3, %rax
ja 0x702c
movq -0x10(%rbp), %rax
leaq 0x28a7(%rip), %rcx      # 0x98a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x7040
jmp 0x702c
movq -0x8(%rbp), %rdi
callq 0x7110
jmp 0x702c
movq -0x8(%rbp), %rdi
callq 0x7180
jmp 0x702c
movq -0x8(%rbp), %rdi
callq 0x71f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/endeav0r[P]hvm/src/vm.c
// Function: vm_syscall_open
void vm_syscall_open (struct _vm * vm)
{
    unsigned int flags = 0;
    uint16_t r1 = vm->regs[REG_1];
    uint16_t r2 = vm->regs[REG_2];
    uint16_t r3 = vm->regs[REG_3];
    char * filename = (char *) &(vm->mem[r1]);

    if (r2 & VM_OPEN_READ)
        flags |= O_RDONLY;
    if (r2 & VM_OPEN_WRITE)
        flags |= O_WRONLY;
    if (r2 & VM_OPEN_APPEND)
        flags |= O_APPEND;
    if (r2 & VM_OPEN_CREATE)
        flags |= O_CREAT;

    #ifdef DEBUG_SYSCALL
    printf("syscall open: (%x) %s %x %x\n", r1, filename, r2, r3);
    #endif

    vm->regs[REG_0] = open(filename, flags, r3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0xa(%rax), %ax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movw 0xc(%rax), %ax
movw %ax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movw 0xe(%rax), %ax
movw %ax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xe(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x709e
movl -0xc(%rbp), %eax
orl $0x0, %eax
movl %eax, -0xc(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x70b3
movl -0xc(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x70ca
movl -0xc(%rbp), %eax
orl $0x400, %eax            # imm = 0x400
movl %eax, -0xc(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x70df
movl -0xc(%rbp), %eax
orl $0x40, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movzwl -0x12(%rbp), %edx
movb $0x0, %al
callq 0x2280
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/endeav0r[P]hvm/src/vm.c
// Function: vm_syscall_read
void vm_syscall_read (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]);

    #ifdef DEBUG_SYSCALL
    printf("syscall read: %x %x %x\n", r1, r2, r3);
    #endif

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw 0xa(%rax), %ax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movw 0xc(%rax), %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0xe(%rax), %ax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzwl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movzwl -0xa(%rbp), %edi
movq -0x18(%rbp), %rsi
movzwl -0xe(%rbp), %eax
movl %eax, %edx
callq 0x2190
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x30(%rbp), %rax
movzwl 0x8(%rax), %ecx
movq -0x30(%rbp), %rax
movzwl 0xa(%rax), %r8d
movq -0x30(%rbp), %rax
movzwl 0xc(%rax), %r9d
movq -0x30(%rbp), %rax
movzwl 0xe(%rax), %eax
movq -0x30(%rbp), %rdx
movzwl 0x10(%rdx), %r13d
movq -0x30(%rbp), %rdx
movzwl 0x12(%rdx), %r12d
movq -0x30(%rbp), %rdx
movzwl 0x14(%rdx), %r15d
movq -0x30(%rbp), %rdx
movzwl 0x1c(%rdx), %r14d
movq -0x30(%rbp), %rdx
movzwl 0x1a(%rdx), %ebx
movq -0x30(%rbp), %rdx
movzwl 0x18(%rdx), %r11d
movq -0x30(%rbp), %rdx
movzwl 0x16(%rdx), %r10d
movq -0x30(%rbp), %rdx
movl 0x20(%rdx), %edx
movl %edx, -0x34(%rbp)
movl $0x100, %esi            # imm = 0x100
leaq 0x27f1(%rip), %rdx      # 0x9ab4
movl %eax, (%rsp)
movl -0x34(%rbp), %eax
movl %r13d, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movl %r15d, 0x18(%rsp)
movl %r14d, 0x20(%rsp)
movl %ebx, 0x28(%rsp)
movl %r11d, 0x30(%rsp)
movl %r10d, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movb $0x0, %al
callq 0x2140
movq -0x30(%rbp), %rax
addq $0x28, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movzwl 0x16(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x3090
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x8(%rbp), %rax
movzwl 0x16(%rax), %ecx
leaq -0x110(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x27a5(%rip), %rdx      # 0x9b18
movb $0x0, %al
callq 0x2140
movq -0x8(%rbp), %rax
addq $0x28, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/ct_dit_bi_G.c
// Function: ct_fft_bi
static inline void
ct_fft_bi(const complex double * restrict in,
	   complex double * restrict out,
	   int log2_N)
{
  unsigned N = 1 << log2_N;

  /* stage 0 */
  BIT_REVERSE2_LOOP(i, j, N, {
      ct_dit_bf2_0(1, N / 2, out + i, in + j);
  });

  /* stages 1 to log2_N - 1 */
  for (unsigned j = 1; j < log2_N; j++)
    {
      unsigned s = log2_N - j - 1;
      unsigned l = 1 << j;

      for (unsigned k = 0; k < l; k++)
        {
          complex double tw = get_twiddle(k << s, log2_N);
          for (unsigned i = 0; i < (1 << s); i++)
            ct_dit_bf2(l, out + k + (i << (j + 1)), tw);
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shrl %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1f37
movl -0x18(%rbp), %esi
shrl %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rcx
movl -0x24(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movl $0x1, %edi
callq 0x2060
movl -0x28(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
xorl $-0x1, %eax
movl -0x28(%rbp), %ecx
xorl -0x2c(%rbp), %ecx
bsrl %ecx, %edx
xorl $0x1f, %edx
movl $0x1f, %ecx
subl %edx, %ecx
shrl %cl, %eax
andl -0x20(%rbp), %eax
xorl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1ecf
jmp 0x1f39
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x201f
movl -0x14(%rbp), %eax
subl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x200f
movl -0x3c(%rbp), %edi
movl -0x34(%rbp), %ecx
shll %cl, %edi
movl -0x14(%rbp), %esi
callq 0x2110
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jae 0x1fff
movl -0x38(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rsi
movl -0x54(%rbp), %eax
movl -0x30(%rbp), %ecx
addl $0x1, %ecx
shll %cl, %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x68(%rbp)
movsd %xmm0, -0x60(%rbp)
movsd -0x68(%rbp), %xmm0
movsd -0x60(%rbp), %xmm1
callq 0x2150
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x1f99
jmp 0x2001
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1f6c
jmp 0x2011
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1f40
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x100020, %rsp         # imm = 0x100020
movq %rdi, -0x8(%rbp)
leaq 0x31aa(%rip), %rdi      # 0x61a0
callq 0x21e0
movl %eax, -0x100014(%rbp)
leaq -0x100010(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x2130
cmpl $0x0, -0x100014(%rbp)
jl 0x301f
jmp 0x303e
leaq 0x1251(%rip), %rdi      # 0x4277
leaq 0x1252(%rip), %rsi      # 0x427f
movl $0x14, %edx
leaq 0x1254(%rip), %rcx      # 0x428d
callq 0x2120
movl -0x100014(%rbp), %edi
leaq -0x100010(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20c0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x305f
jmp 0x307e
leaq 0x124c(%rip), %rdi      # 0x42b2
leaq 0x1212(%rip), %rsi      # 0x427f
movl $0x15, %edx
leaq 0x1214(%rip), %rcx      # 0x428d
callq 0x2120
movl -0x100014(%rbp), %edi
callq 0x2140
addq $0x100020, %rsp         # imm = 0x100020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30e6(%rip), %rdi      # 0x61a0
xorl %esi, %esi
movb $0x0, %al
callq 0x2220
movl %eax, -0x1014(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x30d4
jmp 0x30f3
leaq 0x119c(%rip), %rdi      # 0x4277
leaq 0x119d(%rip), %rsi      # 0x427f
movl $0x1e, %edx
leaq 0x11ef(%rip), %rcx      # 0x42dd
callq 0x2120
jmp 0x30f5
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
movl %eax, -0x1018(%rbp)
cmpl $0x0, -0x1018(%rbp)
jl 0x311d
jmp 0x313c
leaq 0x11ec(%rip), %rdi      # 0x4310
leaq 0x1154(%rip), %rsi      # 0x427f
movl $0x22, %edx
leaq 0x11a6(%rip), %rcx      # 0x42dd
callq 0x2120
cmpl $0x0, -0x1018(%rbp)
jne 0x3156
movl -0x1014(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x30f5
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
leaq 0xd35(%rip), %rax       # 0x2000
movq %rax, 0x2e36(%rip)      # 0x4108
leaq 0x57(%rip), %rax        # 0x1330
movq %rax, 0x2e30(%rip)      # 0x4110
leaq 0xc9(%rip), %rax        # 0x13b0
movq %rax, 0x2e2a(%rip)      # 0x4118
leaq 0x35b(%rip), %rax       # 0x1650
movq %rax, 0x2e24(%rip)      # 0x4120
leaq 0x5cd(%rip), %rax       # 0x18d0
movq %rax, 0x2e1e(%rip)      # 0x4128
leaq 0x5ff(%rip), %rax       # 0x1910
movq %rax, 0x2e18(%rip)      # 0x4130
leaq 0x2de9(%rip), %rax      # 0x4108
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcbd(%rip), %rsi       # 0x2004
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x135d
movb $0x0, -0x1(%rbp)
jmp 0x139c
leaq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x10b0
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x8, %edx
callq 0x1100
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x1959
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1928
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x42, -0x3c(%rbp)
movl $0x380, -0x40(%rbp)     # imm = 0x380
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x132b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2b00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1244
movq 0x3dd7(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x1dd1(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1322
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edi
callq 0x2ca0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
callq 0x27d0
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x3c(%rbp), %esi
movl -0x40(%rbp), %edx
movb $0x0, %al
callq 0x10b0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x12cd
movq 0x3d4e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1d75(%rip), %rsi      # 0x3031
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0x1311
movq 0x3d0a(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1d5d(%rip), %rsi      # 0x305d
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movl -0x24(%rbp), %edi
callq 0x1060
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/pileup.c
// Function: test_pileup
static int test_pileup(ptest_t *input) {
    bam_plp_t plp = NULL;
    const bam_pileup1_t *p;
    int tid, pos, n = 0;

    plp = bam_plp_init(readaln, input);
    if (!plp) {
        perror("bam_plp_init");
        goto fail;
    }
    while ((p = bam_plp_auto(plp, &tid, &pos, &n)) != 0) {
        if (tid < 0) break;
        if (tid >= input->fp_hdr->n_targets) {
            fprintf(stderr,
                    "bam_plp_auto returned tid %d >= header n_targets %d\n",
                    tid, input->fp_hdr->n_targets);
            goto fail;
        }

        printf("%s\t%d\t%d\t", input->fp_hdr->target_name[tid], pos+1, n);

        if (print_pileup_seq(p, n) < 0)
            goto fail;

        putchar('\t');
        print_pileup_qual(p, n);

        putchar('\n');
    }
    if (n < 0) {
        fprintf(stderr, "bam_plp_auto failed for \"%s\"\n", input->fname);
        goto fail;
    }

    bam_plp_destroy(plp);
    return 0;

 fail:
    bam_plp_destroy(plp);
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x14a(%rip), %rdi       # 0x5fe0
callq 0x2f390
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5eb7
leaq 0xe01b0(%rip), %rdi     # 0xe605d
callq 0x43d0
jmp 0x5fbc
jmp 0x5eb9
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq 0x30b50
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5f83
cmpl $0x0, -0x24(%rbp)
jge 0x5ee7
jmp 0x5f83
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
jl 0x5f20
movq 0xfe0db(%rip), %rax     # 0x103fd8
movq (%rax), %rdi
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %ecx
leaq 0xe01e8(%rip), %rsi     # 0xe60fc
movb $0x0, %al
callq 0x46f0
jmp 0x5fbc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x28(%rbp), %edx
addl $0x1, %edx
movl -0x2c(%rbp), %ecx
leaq 0xe0173(%rip), %rdi     # 0xe60b7
movb $0x0, %al
callq 0x4060
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x6040
cmpl $0x0, %eax
jge 0x5f5e
jmp 0x5fbc
movl $0x9, %edi
callq 0x46a0
movq -0x20(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x62f0
movl $0xa, %edi
callq 0x46a0
jmp 0x5eb9
cmpl $0x0, -0x2c(%rbp)
jge 0x5faa
movq 0xfe048(%rip), %rax     # 0x103fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe0120(%rip), %rsi     # 0xe60c1
movb $0x0, %al
callq 0x46f0
jmp 0x5fbc
movq -0x18(%rbp), %rdi
callq 0x2f530
movl $0x0, -0x4(%rbp)
jmp 0x5fcc
movq -0x18(%rbp), %rdi
callq 0x2f530
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x289b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x601c
jmp 0x6032
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
andl $0x704, %eax            # imm = 0x704
cmpl $0x0, %eax
je 0x6030
jmp 0x5ff8
jmp 0x6032
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x63c1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x14(%rcx), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movzwl 0x12(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x18(%rcx), %ecx
addl $0x1, %ecx
sarl %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movb $0x7e, -0x19(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x639e
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0x21, %eax
cmpl $0x7e, %eax
jge 0x639e
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0x21, %eax
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %edi
callq 0x46a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
jmp 0x6306
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
xorl $-0x1, %eax
movl -0x8(%rbp), %ecx
shll %cl, %eax
xorl $-0x1, %eax
andl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
xorl $-0x1, %eax
andl -0x10(%rbp), %eax
movl -0x8(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
orl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xe6a(%rip), %rdx       # 0x2004
callq 0x1050
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x124c
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x3a, %eax
je 0x11f1
jmp 0x11b8
movl -0x30(%rbp), %eax
subl $0x3f, %eax
je 0x121d
jmp 0x11c2
movl -0x30(%rbp), %eax
subl $0x61, %eax
je 0x11d6
jmp 0x11cc
movl -0x30(%rbp), %eax
subl $0x66, %eax
je 0x11e1
jmp 0x1247
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1247
movq 0x2de8(%rip), %rax      # 0x3fd0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1247
movq 0x2e00(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2dde(%rip), %rax      # 0x3fe0
movl (%rax), %edx
leaq 0xdfe(%rip), %rsi       # 0x2009
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1247
movq 0x2dd4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2db2(%rip), %rax      # 0x3fe0
movl (%rax), %edx
leaq 0xdf2(%rip), %rsi       # 0x2029
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x118c
cmpl $0x0, -0x1c(%rbp)
je 0x127a
movq 0x2d9f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xdda(%rip), %rsi       # 0x2044
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12f3
cmpl $0x0, -0x18(%rbp)
je 0x128e
leaq 0xde5(%rip), %rdi       # 0x206c
movb $0x0, %al
callq 0x1030
cmpq $0x0, -0x28(%rbp)
je 0x12a7
movq -0x28(%rbp), %rsi
leaq 0xdd0(%rip), %rdi       # 0x2070
movb $0x0, %al
callq 0x1030
movq 0x2d1a(%rip), %rax      # 0x3fc8
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12ec
movl -0x2c(%rbp), %esi
movq 0x2d03(%rip), %rax      # 0x3fc8
subl (%rax), %esi
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xd9d(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1030
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x12b3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x12a1
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1070
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jg 0x1284
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1278
movq $0x0, -0x30(%rbp)
jmp 0x1282
movq $-0x1, -0x8(%rbp)
jmp 0x12a9
jmp 0x1284
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x1243
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2db3(%rip), %eax      # 0x40a4
jg 0x1344
movslq -0x14(%rbp), %rax
leaq 0x2da6(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x1337
movslq -0x14(%rbp), %rcx
leaq 0x2d82(%rip), %rax      # 0x40a4
addq $0x4, %rax
imulq $0x64, %rcx, %rcx
addq %rcx, %rax
addq $0x32, %rax
movq %rax, -0x8(%rbp)
jmp 0x134c
jmp 0x1339
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x12e8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2d1d(%rip), %eax      # 0x40a4
jge 0x1408
movslq -0x14(%rbp), %rax
leaq 0x2d10(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x13f8
movslq -0x14(%rbp), %rax
leaq 0x2cec(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
addq $0x32, %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movslq -0x14(%rbp), %rax
leaq 0x2cc9(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
movl $0x1, -0x18(%rbp)
jmp 0x1465
jmp 0x13fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x137e
cmpl $0x0, -0x18(%rbp)
jne 0x1465
movl 0x2c90(%rip), %eax      # 0x40a4
addl $0x1, %eax
movl %eax, 0x2c87(%rip)      # 0x40a4
movslq 0x2c80(%rip), %rax      # 0x40a4
leaq 0x2c79(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
addq $0x32, %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movslq 0x2c5a(%rip), %rax      # 0x40a4
leaq 0x2c53(%rip), %rdi      # 0x40a4
addq $0x4, %rdi
imulq $0x64, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
leaq 0x918f1(%rip), %rcx     # 0xa7000
callq 0x130f0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movl $0x2, %esi
callq 0x13950
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x48(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x139a0
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movl $0x4, %esi
leaq 0x44(%rsp), %rdx
callq 0x14350
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x157c5
cmpl $0x1, 0x44(%rsp)
jne 0x1578b
movq 0x48(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x131a0
jmp 0x157c3
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x136c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x4, %esi
callq 0x134c0
movl %eax, 0x54(%rsp)
jmp 0x15858
jmp 0x157c5
cmpq $0x0, 0x18(%rsp)
je 0x157ee
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movss 0x24(%rsp), %xmm0
movq 0x10(%rsp), %rdx
callq 0x148b0
movq %rax, 0x30(%rsp)
jmp 0x15808
movq 0x28(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movq 0x10(%rsp), %rsi
callq 0x13fa0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15837
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffff4, %edi       # imm = 0xFFFFFFF4
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x54(%rsp)
jmp 0x15858
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x135f0
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x40(%rsp), %rdi
leaq 0x91772(%rip), %rcx     # 0xa7000
movl $0x1, %esi
leaq 0x38(%rsp), %rdx
callq 0x130f0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %ecx
leaq 0x34(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x13850
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x158f0
jmp 0x158e5
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x15902
jmp 0x15915
movl 0x34(%rsp), %eax
imull 0x30(%rsp), %eax
cltq
movq %rax, 0x28(%rsp)
jmp 0x15915
movl 0x34(%rsp), %eax
imull 0x30(%rsp), %eax
shll $0x2, %eax
cltq
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x14860
movq 0x40(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0x13c50
movq 0x40(%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0x13c50
movl $0x3, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x91682(%rip), %rcx     # 0xa7000
callq 0x130f0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x14070
movl %eax, 0x18(%rsp)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x13e30
movq 0x20(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0x13c50
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x13760
movl $0x2, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/atlas.c
// Function: Default_font
static int Default_font(lua_State *L)
    {
    ud_t *ud;
    nk_atlas_t *atlas = checkatlas(L, 1, &ud);
    if(!atlas->default_font) return 0;
    pushatlasfont(L, ud, atlas->default_font, NULL);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0x915c1(%rip), %rcx     # 0xa7000
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x170(%rax)
jne 0x15a62
movl $0x0, 0x24(%rsp)
jmp 0x15a89
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x170(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x135f0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0x18(%rsp), %rdx
leaq 0x91541(%rip), %rcx     # 0xa7000
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0x14470
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x48, %rdx
movl 0xc(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdx
callq 0x14e60
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x190, %esi            # imm = 0x190
callq 0x14c40
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x13ac0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
leaq 0x914bb(%rip), %rdx     # 0xa7000
leaq 0x914c0(%rip), %rcx     # 0xa700c
callq 0x15130
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
leaq 0xd1(%rip), %rcx        # 0x15c40
movq %rcx, 0x8(%rax)
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x91445(%rip), %rsi     # 0xa70b1
callq 0x131f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x91440(%rip), %rsi     # 0xa70c2
callq 0x131f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x91374(%rip), %rdx     # 0xa700c
callq 0x14f50
cmpl $0x0, %eax
jne 0x15cac
movl $0x0, 0x24(%rsp)
jmp 0x15ccd
movq 0x8(%rsp), %rdi
callq 0x14d50
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14230
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x20(%rsp), %rdx
leaq 0x912b6(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x14a30
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x3, %esi
callq 0x14070
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
ja 0x15e83
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movl $0xfffffffd, %edi       # imm = 0xFFFFFFFD
callq 0x14d10
movq (%rsp), %rdi
movq %rax, %rdx
movl $0x3, %esi
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x15ef8
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x4, %eax
cmpl $0x4, %eax
je 0x15eaf
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x9124f(%rip), %rdx     # 0xa70f3
callq 0x134c0
movl %eax, 0x34(%rsp)
jmp 0x15ef8
movq 0x20(%rsp), %rax
movl 0x70(%rax), %eax
andl $0x8, %eax
cmpl $0x8, %eax
jne 0x15ec9
movq 0x18(%rsp), %rdi
callq 0x14fc0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x13720
movq 0x20(%rsp), %rax
movl 0x70(%rax), %ecx
orl $0x8, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x70(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x911a7(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x141e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x15f59
movl $0x0, 0x24(%rsp)
jmp 0x15f70
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14600
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0x13, %esi
movl $0x1, %edx
callq 0x14470
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0x15fc8
jmp 0x15fae
movl (%rsp), %eax
subl $0x1, %eax
jne 0x15fd8
jmp 0x15fb8
movq 0x8(%rsp), %rdi
callq 0x16080
movl %eax, 0x14(%rsp)
jmp 0x15ffd
movq 0x8(%rsp), %rdi
callq 0x160c0
movl %eax, 0x14(%rsp)
jmp 0x15ffd
jmp 0x15fda
movq 0x8(%rsp), %rdi
leaq 0x91139(%rip), %rsi     # 0xa711f
leaq 0x9114c(%rip), %rdx     # 0xa7139
movl $0x56, %ecx
movb $0x0, %al
callq 0x14bf0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x1, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x15090
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1603d
jmp 0x16070
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
xorl %eax, %eax
movl %eax, %edx
leaq 0x9107b(%rip), %rcx     # 0xa70d5
callq 0x130f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x13f40
jmp 0x16021
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonnuklear/src/buffer.c
// Function: CreateDefault
static int CreateDefault(lua_State *L)
    {
    nk_buffer_t *buffer = (nk_buffer_t*)Malloc(L, sizeof(nk_buffer_t));
    nk_buffer_init_default(buffer);
    //void nk_buffer_init(nk_buffer_t*, const nk_allocator_t*, nk_size size);
    new_buffer(L, buffer);
    return 1;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x78, %esi
callq 0x14c40
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x14200
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x161d0
movl $0x1, %eax
addq $0x18, %rsp
retq