LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: hed_new_file_from_data
struct hed_file *hed_new_file_from_data(uint8_t *data, size_t data_len)
{
  struct hed_file *file = new_file();
  if (! file)
    return NULL;
  
  file->data = data;
  file->data_len = data_len;
  file->modified = (data != NULL);
  return file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x48, %edi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x1a(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x34(%rax)
movl $0x0, 0x44(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
testq %r14, %r14
setne 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: hed_free_file
void hed_free_file(struct hed_file *file)
{
  if (file->filename)
    free(file->filename);
  if (file->data)
    free(file->data);
  free(file);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3272
callq 0x2030
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3280
callq 0x2030
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: hed_read_file
struct hed_file *hed_read_file(const char *filename)
{
  FILE *f = fopen(filename, "r");
  if (! f) {
    show_msg("ERROR: can't open file '%s'", filename);
    return NULL;
  }

  uint8_t *data = NULL;
  char *new_filename = malloc(strlen(filename) + 1);
  if (! new_filename) {
    show_msg("ERROR: out of memory");
    goto err;
  }
  strcpy(new_filename, filename);
  
  if (fseek(f, 0, SEEK_END) < 0) {
    show_msg("ERROR: can't determine file size");
    goto err;
  }
  long size = ftell(f);
  if (size < 0 || (unsigned long) size > SIZE_MAX) {
    show_msg("ERROR: file is too large");
    goto err;
  }
  if (fseek(f, 0, SEEK_SET) == -1) {
    show_msg("ERROR: can't seek to start of file");
    goto err;
  }
  data = malloc((size_t) size);
  if (! data) {
    show_msg("ERROR: not enough memory for %ld bytes", size);
    goto err;
  }
  
  if (fread(data, 1, size, f) != (size_t) size) {
    show_msg("ERROR: error reading file");
    goto err;
  }
  
  struct hed_file *file = new_file();
  if (! file) {
    show_msg("ERROR: error reading file");
    goto err;
  }
  file->data = data;
  file->data_len = size;
  file->filename = new_filename;
  fclose(f);
  return file;

 err:
  if (new_filename)
    free(new_filename);
  if (data)
    free(data);
  fclose(f);
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x4460(%rip), %rsi      # 0x76fc
callq 0x2240
testq %rax, %rax
je 0x3381
movq %rax, %rbx
movq %r15, %rdi
callq 0x20e0
leaq 0x1(%rax), %rdi
callq 0x21d0
testq %rax, %rax
je 0x3397
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x2050
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21f0
testl %eax, %eax
js 0x33a7
movq %rbx, %rdi
callq 0x2180
testq %rax, %rax
js 0x33b0
movq %rax, %r15
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21f0
cmpl $-0x1, %eax
je 0x33b9
movq %r15, %rdi
callq 0x21d0
testq %rax, %rax
je 0x33e7
movq %rax, %r12
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x2090
cmpq %r15, %rax
jne 0x33fa
movl $0x48, %edi
callq 0x21d0
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x1a(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x34(%rax)
movl $0x0, 0x44(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, %rdi
callq 0x20c0
jmp 0x33da
leaq 0x4048(%rip), %rdi      # 0x73d0
xorl %r13d, %r13d
movq %r15, %rsi
xorl %eax, %eax
callq 0x2ce6
jmp 0x33da
leaq 0x404e(%rip), %rdi      # 0x73ec
xorl %eax, %eax
callq 0x2ce6
jmp 0x33cf
leaq 0x4053(%rip), %rdi      # 0x7401
jmp 0x33c0
leaq 0x406b(%rip), %rdi      # 0x7422
jmp 0x33c0
leaq 0x407b(%rip), %rdi      # 0x743b
xorl %eax, %eax
callq 0x2ce6
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x20c0
xorl %r13d, %r13d
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4070(%rip), %rdi      # 0x745e
movq %r15, %rsi
xorl %eax, %eax
callq 0x2ce6
jmp 0x33c7
leaq 0x4084(%rip), %rdi      # 0x7485
xorl %eax, %eax
callq 0x2ce6
movq %r14, %rdi
callq 0x2030
movq %r12, %rdi
jmp 0x33ca
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: hed_write_file
int hed_write_file(struct hed_file *file, const char *filename)
{
  if (! file->data)
    return 0;

  char *new_filename = NULL;
  if (! file->filename || strcmp(filename, file->filename) != 0) {
    new_filename = malloc(strlen(filename) + 1);
    if (! new_filename)
      return show_msg("ERROR: out of memory");
    strcpy(new_filename, filename);
  }
  
  FILE *f = fopen(filename, "w");
  if (! f) {
    free(new_filename);
    return show_msg("ERROR: can't open file '%s'", filename);
  }
  if (fwrite(file->data, 1, file->data_len, f) != file->data_len) {
    free(new_filename);
    fclose(f);
    return show_msg("ERROR: can't write file '%s'", filename);
  }
  fclose(f);
  show_msg("File saved: '%s'", filename);
  file->modified = false;

  if (new_filename) {
    if (file->filename)
      free(file->filename);
    file->filename = new_filename;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
je 0x34ec
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x3443
movq %rbx, %rdi
callq 0x2150
testl %eax, %eax
je 0x3482
movq %rbx, %rdi
callq 0x20e0
leaq 0x1(%rax), %rdi
callq 0x21d0
testq %rax, %rax
je 0x3469
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
jmp 0x3485
leaq 0x3f7c(%rip), %rdi      # 0x73ec
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ce6
xorl %r15d, %r15d
leaq 0x4013(%rip), %rsi      # 0x749f
movq %rbx, %rdi
callq 0x2240
testq %rax, %rax
je 0x34fa
movq %rax, %r12
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rdx
movl $0x1, %esi
movq %rax, %rcx
callq 0x22a0
cmpq 0x18(%r14), %rax
jne 0x350b
movq %r12, %rdi
callq 0x20c0
leaq 0x3ff8(%rip), %rdi      # 0x74be
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2ce6
movb $0x0, 0x28(%r14)
testq %r15, %r15
je 0x34ec
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x34e8
callq 0x2030
movq %r15, 0x20(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x2030
leaq 0x3ec7(%rip), %rdi      # 0x73d0
jmp 0x3522
movq %r15, %rdi
callq 0x2030
movq %r12, %rdi
callq 0x20c0
leaq 0x3f7f(%rip), %rdi      # 0x74a1
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2ce6
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: get_file_u16
bool get_file_u16(struct hed_file *file, size_t pos, uint16_t *data)
{
  if (! file->data || pos + 2 > file->data_len) return false;

  if (file->endianess == HED_DATA_LITTLE_ENDIAN) {
    *data = (((uint16_t) file->data[pos+1] << 8) |
             ((uint16_t) file->data[pos+0] << 0));
  } else {
    *data = (((uint16_t) file->data[pos+0] << 8) |
             ((uint16_t) file->data[pos+1] << 0));
  }
  return true;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3568
leaq 0x2(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
jbe 0x356b
xorl %eax, %eax
retq
cmpl $0x0, 0x2c(%rdi)
je 0x357b
movzwl (%rax,%rsi), %eax
rolw $0x8, %ax
jmp 0x357f
movzwl (%rax,%rsi), %eax
movw %ax, (%rdx)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: get_file_u32
bool get_file_u32(struct hed_file *file, size_t pos, uint32_t *data)
{
  if (! file->data || pos + 4 > file->data_len) return false;

  if (file->endianess == HED_DATA_LITTLE_ENDIAN) {
    *data = (((uint32_t) file->data[pos+3] << 24) |
             ((uint32_t) file->data[pos+2] << 16) |
             ((uint32_t) file->data[pos+1] <<  8) |
             ((uint32_t) file->data[pos+0] <<  0));
  } else {
    *data = (((uint32_t) file->data[pos+0] << 24) |
             ((uint32_t) file->data[pos+1] << 16) |
             ((uint32_t) file->data[pos+2] <<  8) |
             ((uint32_t) file->data[pos+3] <<  0));
  }
  return true;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3598
leaq 0x4(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
jbe 0x359b
xorl %eax, %eax
retq
cmpl $0x0, 0x2c(%rdi)
je 0x35a8
movl (%rax,%rsi), %eax
bswapl %eax
jmp 0x35ab
movl (%rax,%rsi), %eax
movl %eax, (%rdx)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: get_file_f32
bool get_file_f32(struct hed_file *file, size_t pos, float *data)
{
  if (! file->data || pos + 4 > file->data_len) return false;
  if (is_cpu_float_little_endian() == (file->endianess == HED_DATA_LITTLE_ENDIAN)) {
    memcpy(data, &file->data[pos], 4);
    return true;
  }
  uint8_t buf[4] = { file->data[pos+3], file->data[pos+2], file->data[pos+1], file->data[pos+0] };
  memcpy(data, buf, 4);
  return true;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x35f2
leaq 0x4(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
jbe 0x35f5
xorl %eax, %eax
retq
cmpb $0x0, 0x6fd4(%rip)      # 0xa5d0
jne 0x3605
movb $0x1, 0x6fcb(%rip)      # 0xa5d0
cmpl $0x0, 0x2c(%rdi)
je 0x362b
movb 0x3(%rax,%rsi), %cl
movb 0x2(%rax,%rsi), %dil
movb (%rax,%rsi), %r8b
movb 0x1(%rax,%rsi), %al
movb %cl, (%rdx)
movb %dil, 0x1(%rdx)
movb %al, 0x2(%rdx)
movb %r8b, 0x3(%rdx)
jmp 0x3630
movl (%rax,%rsi), %eax
movl %eax, (%rdx)
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file.c
// Function: get_file_f64
bool get_file_f64(struct hed_file *file, size_t pos, double *data)
{
  if (! file->data || pos + 8 > file->data_len) return false;

  if (is_cpu_float_little_endian() == (file->endianess == HED_DATA_LITTLE_ENDIAN)) {
    memcpy(data, &file->data[pos], 8);
    return true;
  }
  uint8_t buf[8] = {
    file->data[pos+7], file->data[pos+6], file->data[pos+5], file->data[pos+4],
    file->data[pos+3], file->data[pos+2], file->data[pos+1], file->data[pos+0],
  };
  memcpy(data, buf, 8);
  return true;
}

// Assembly:
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x3646
leaq 0x8(%rsi), %rcx
cmpq 0x18(%rdi), %rcx
jbe 0x3649
xorl %eax, %eax
retq
cmpb $0x0, 0x6f80(%rip)      # 0xa5d0
jne 0x3659
movb $0x1, 0x6f77(%rip)      # 0xa5d0
cmpl $0x0, 0x2c(%rdi)
je 0x36a4
pushq %rbx
movb 0x7(%rax,%rsi), %cl
movb 0x6(%rax,%rsi), %dil
movb 0x5(%rax,%rsi), %r8b
movb 0x4(%rax,%rsi), %r9b
movb 0x3(%rax,%rsi), %r10b
movb 0x2(%rax,%rsi), %r11b
movb (%rax,%rsi), %bl
movb 0x1(%rax,%rsi), %al
movb %cl, (%rdx)
movb %dil, 0x1(%rdx)
movb %r8b, 0x2(%rdx)
movb %r9b, 0x3(%rdx)
movb %r10b, 0x4(%rdx)
movb %r11b, 0x5(%rdx)
movb %al, 0x6(%rdx)
movb %bl, 0x7(%rdx)
movb $0x1, %al
popq %rbx
retq
movq (%rax,%rsi), %rax
movq %rax, (%rdx)
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/utf8.c
// Function: utf8_prev
const void *utf8_prev(const void *start, const void *str)
{
  const uint8_t *s = str;

  s--;
  while ((const void *)s > start && (*s & 0xc0) == 0x80) {
    s--;
  }
  const void *last = s;
  const void *next;
  while ((next = utf8_next(last)) != NULL && next < str) {
    last = next;
  }
  return last;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq -0x1(%rsi), %rcx
movq %rcx, %rax
cmpq %rdi, %rcx
jbe 0x36d7
movb (%rax), %dl
andb $-0x40, %dl
leaq -0x1(%rax), %rcx
negb %dl
jo 0x36bb
jmp 0x36d7
cmpq %rbx, %rax
jae 0x36e7
movq %rax, %r14
movq %rax, %rdi
callq 0x36f2
testq %rax, %rax
jne 0x36d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/utf8.c
// Function: utf8_next
const void *utf8_next(const void *str)
{
  const uint8_t *s = str;

  if (*s == 0)
    return NULL;
  
  if ((s[0] & 0x80) == 0) {
    return s + 1;
  }
  
  if ((s[0] & 0xe0) == 0xc0) {
    if ((s[1] & 0xc0) != 0x80)
      return s + 1;
    uint32_t val = ((s[0] & 0x1f) << 6) | (s[1] & 0x3f);
    if (val <= 0x7f)
      return s + 1;
    return s + 2;
  }

  if ((s[0] & 0xf0) == 0xe0) {
    if ((s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80)
      return s + 1;
    uint32_t val = ((s[0] & 0x0f) << 12) | ((s[1] & 0x3f) << 6) | (s[2] & 0x3f);
    if (val <= 0x7ff)
      return s + 1;
    return s + 3;
  }

  if ((s[0] & 0xf8) == 0xf0) {
    if ((s[1] & 0xc0) != 0x80 || (s[2] & 0xc0) != 0x80 || (s[3] & 0xc0) != 0x80)
      return s + 1;
    uint32_t val = ((s[0] & 0x07) << 18) | ((s[1] & 0x3f) << 12) | ((s[2] & 0x3f) << 6) | (s[3] & 0x3f);
    if (val <= 0xffff || val > 0x10ffff)
      return s + 1;
    return s + 4;
  }

  return s + 1;
}

// Assembly:
movzbl (%rdi), %ecx
testl %ecx, %ecx
je 0x3704
testb %cl, %cl
js 0x3707
incq %rdi
movq %rdi, %rax
retq
xorl %eax, %eax
retq
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x3731
leaq 0x1(%rdi), %rax
movb 0x1(%rdi), %dl
andb $-0x40, %dl
negb %dl
jno 0x37d0
addq $0x2, %rdi
testb $0x1e, %cl
cmovneq %rdi, %rax
retq
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0x3773
leaq 0x1(%rdi), %rax
movzbl 0x1(%rdi), %edx
movl %edx, %esi
andl $-0x40, %esi
cmpl $0x80, %esi
jne 0x37d0
movb 0x2(%rdi), %sil
andb $-0x40, %sil
negb %sil
jno 0x37d0
shll $0xc, %ecx
movzwl %cx, %ecx
andl $0x20, %edx
shll $0x6, %edx
addq $0x3, %rdi
orl %ecx, %edx
jmp 0x372c
movl %ecx, %edx
andl $-0x8, %edx
leaq 0x1(%rdi), %rax
cmpl $0xf0, %edx
jne 0x37d0
movzbl (%rax), %edx
movl %edx, %esi
andl $-0x40, %esi
cmpl $0x80, %esi
jne 0x37d0
movb 0x2(%rdi), %sil
andb $-0x40, %sil
negb %sil
jno 0x37d0
movb 0x3(%rdi), %sil
andb $-0x40, %sil
negb %sil
jno 0x37d0
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x30, %edx
shll $0xc, %edx
addl %edx, %ecx
addl $0xffef0000, %ecx       # imm = 0xFFEF0000
addq $0x4, %rdi
cmpl $0xfff00000, %ecx       # imm = 0xFFF00000
cmovaeq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file_sel.c
// Function: compare_files
static int compare_files(const void *p1, const void *p2)
{
  const struct file_item *f1 = *(struct file_item **)p1;
  const struct file_item *f2 = *(struct file_item **)p2;
  if (f1->is_file == f2->is_file)
    return strcmp(f1->filename, f2->filename);
  return (! f1->is_file) ? -1 : 1;
}

// Assembly:
movq (%rdi), %rdi
movq (%rsi), %rsi
movb 0x18(%rdi), %al
cmpb 0x18(%rsi), %al
jne 0x413b
addq $0x28, %rdi
addq $0x28, %rsi
jmp 0x2150
movzbl %al, %eax
decl %eax
orl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file_sel.c
// Function: move_sel_page_up
static void move_sel_page_up(struct file_sel *fs)
{
  struct hed_screen *scr = &fs->editor->screen;
  size_t n_page_lines = scr->h - 1 - EDITOR_BORDER_LINES;

  for (size_t i = 0; i < n_page_lines; i++) {
    if (fs->sel->prev)
      fs->sel = fs->sel->prev;
    else
      break;
  }
  if (fs->sel->index < fs->top_line) {
    if (fs->sel->index > n_page_lines/2)
      fs->top_line = fs->sel->index - n_page_lines/2;
    else
      fs->top_line = 0;
  }
  scr->redraw_needed = true;
}

// Assembly:
movq (%rdi), %rax
movq 0x28(%rdi), %rdx
movslq 0x110(%rax), %rcx
addq $-0x6, %rcx
testl %ecx, %ecx
je 0x4177
movq %rcx, %rsi
movq %rdx, %r8
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
je 0x417a
movq %rdx, 0x28(%rdi)
movq %rdx, %r8
decq %rsi
jne 0x415d
jmp 0x417a
movq %rdx, %r8
movq 0x10(%r8), %rdx
cmpq 0x30(%rdi), %rdx
jae 0x4194
shrq %rcx
xorl %esi, %esi
subq %rcx, %rdx
cmovaeq %rdx, %rsi
movq %rsi, 0x30(%rdi)
movb $0x1, 0x115(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/file_sel.c
// Function: move_sel_page_down
static void move_sel_page_down(struct file_sel *fs)
{
  struct hed_screen *scr = &fs->editor->screen;
  size_t n_page_lines = scr->h - 1 - EDITOR_BORDER_LINES;

  for (size_t i = 0; i < n_page_lines; i++) {
    if (fs->sel->next)
      fs->sel = fs->sel->next;
    else
      break;
  }
  if (fs->top_line + n_page_lines - 1 < fs->sel->index) {
    if (fs->sel->index > n_page_lines/2)
      fs->top_line = fs->sel->index - n_page_lines/2;
    else
      fs->top_line = 0;
  }
  scr->redraw_needed = true;
}

// Assembly:
movq (%rdi), %rax
movq 0x28(%rdi), %rdx
movslq 0x110(%rax), %rcx
addq $-0x6, %rcx
testl %ecx, %ecx
je 0x41ce
movq %rcx, %rsi
movq %rdx, %r8
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x41d1
movq %rdx, 0x28(%rdi)
movq %rdx, %r8
decq %rsi
jne 0x41b5
jmp 0x41d1
movq %rdx, %r8
movq 0x30(%rdi), %rdx
leaq (%rcx,%rdx), %rsi
decq %rsi
movq 0x10(%r8), %rdx
cmpq %rdx, %rsi
jae 0x41f5
shrq %rcx
xorl %esi, %esi
subq %rcx, %rdx
cmovaeq %rdx, %rsi
movq %rsi, 0x30(%rdi)
movb $0x1, 0x115(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: hed_add_file
void hed_add_file(struct hed_editor *editor, struct hed_file *file)
{
  // close current file if it's the only one and it's empty
  if (editor->file && editor->file == editor->file->next && ! editor->file->data)
    close_current_file(editor);
  
  if (! editor->file) {
    file->next = file;
    file->prev = file;
    editor->file = file;
    return;
  }
  
  file->next = editor->file;
  file->prev = editor->file->prev;
  file->prev->next = file;
  file->next->prev = file;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x628(%rdi), %rax
testq %rax, %rax
je 0x426d
cmpq (%rax), %rax
jne 0x4256
cmpq $0x0, 0x10(%rax)
jne 0x4256
movq %r14, %rdi
callq 0x4286
movq 0x628(%r14), %rax
testq %rax, %rax
je 0x426d
movq %rax, (%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movq %rbx, (%rax)
movq (%rbx), %r14
addq $0x8, %r14
jmp 0x427b
addq $0x628, %r14            # imm = 0x628
movq %rbx, (%rbx)
movq %rbx, 0x8(%rbx)
movq %rbx, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: close_current_file
static void close_current_file(struct hed_editor *editor)
{
  struct hed_file *file = editor->file;
  if (! file)
    return;
  if (file->next == file) {
    hed_free_file(file);
    editor->file = NULL;
    return;
  }
  
  file->next->prev = file->prev;
  file->prev->next = file->next;
  editor->file = file->next;
  hed_free_file(file);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x628(%rdi), %rdi
testq %rdi, %rdi
je 0x42c9
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x42b9
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq (%rdi), %rax
movq %rax, 0x628(%rbx)
popq %rbx
jmp 0x3260
callq 0x3260
movq $0x0, 0x628(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: hed_draw_key_help
void hed_draw_key_help(int x, int y, const char *key, const char *help)
{
  move_cursor(x, y);
  set_color(FG_BLACK, BG_GRAY);
  out("%s", key);
  reset_color();
  out(" %s", help);

  size_t txt_len = strlen(key) + strlen(help) + 1;
  for (size_t i = txt_len; i < EDITOR_KEY_HELP_SPACING-1; i++)
    out(" ");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
callq 0x31aa
movl $0x1e, %edi
movl $0x2f, %esi
callq 0x3124
leaq 0x365f(%rip), %rdi      # 0x794f
movq %r14, %rsi
xorl %eax, %eax
callq 0x2e58
callq 0x318e
leaq 0x3648(%rip), %rdi      # 0x794e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2e58
movq %r14, %rdi
callq 0x20e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rbx
addq %r14, %rax
incq %rax
cmpq $0xe, %rax
ja 0x434f
addq %r14, %rbx
leaq 0x34c5(%rip), %r14      # 0x7801
movq %r14, %rdi
xorl %eax, %eax
callq 0x2e58
incq %rbx
cmpq $0xe, %rbx
jb 0x433c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: hed_set_cursor_pos
void hed_set_cursor_pos(struct hed_editor *editor, size_t pos, size_t visible_len_after)
{
  struct hed_screen *scr = &editor->screen;
  struct hed_file *file = editor->file;
  size_t n_page_lines = get_num_displayed_file_lines(editor);
  size_t last_line = file->data_len / 16 + (file->data_len % 16 != 0);

  if (pos >= file->data_len)
    pos = (file->data_len == 0) ? 0 : file->data_len-1;
  if (pos + visible_len_after >= file->data_len)
    visible_len_after = file->data_len - pos;
  
  file->cursor_pos = pos;

  // If the cursor or 'visible_len_after' bytes after it are not visible,
  // center the screen vertically around the cursor
  if (! (file->cursor_pos / 16 >= file->top_line
         && (file->cursor_pos+visible_len_after) / 16 >= file->top_line
         && file->cursor_pos / 16 <= file->top_line + n_page_lines
         && (file->cursor_pos+visible_len_after) / 16 <= file->top_line + n_page_lines)) {
    if (file->cursor_pos / 16 < n_page_lines/2)
      file->top_line = 0;
    else {
      file->top_line = file->cursor_pos / 16 - n_page_lines/2;
      if (file->top_line + n_page_lines > last_line)
        file->top_line = last_line - n_page_lines;
    }
  }
  scr->redraw_needed = true;
}

// Assembly:
pushq %r14
pushq %rbx
movq 0x628(%rdi), %rax
movzbl 0x29(%rax), %ecx
movslq 0x110(%rdi), %r8
xorq $0x1, %rcx
leaq (%rcx,%rcx,4), %rcx
addq %rcx, %r8
addq $-0xa, %r8
movq 0x18(%rax), %r10
movq 0x40(%rax), %r9
movq %r10, %rcx
shrq $0x4, %rcx
movl %r10d, %r11d
andl $0xf, %r11d
cmpq $0x1, %r11
sbbq $-0x1, %rcx
xorl %r11d, %r11d
movq %r10, %rbx
subq $0x1, %rbx
cmovaeq %rbx, %r11
cmpq %rsi, %r10
cmovaq %rsi, %r11
movq %r11, 0x38(%rax)
movq %r11, %rsi
shrq $0x4, %rsi
cmpq %r9, %rsi
jb 0x43ec
leaq (%r11,%rdx), %r14
movq %r10, %rbx
subq %r11, %rbx
cmpq %r10, %r14
cmovbq %rdx, %rbx
addq %r11, %rbx
shrq $0x4, %rbx
cmpq %r9, %rbx
jae 0x4419
movq %r8, %rdx
shrq %rdx
subq %rdx, %rsi
jae 0x43fb
xorl %ecx, %ecx
jmp 0x440a
movq %rsi, 0x40(%rax)
addq %r8, %rsi
cmpq %rcx, %rsi
jbe 0x440e
subq %r8, %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x115(%rdi)
popq %rbx
popq %r14
retq
addq %r8, %r9
cmpq %r9, %rsi
ja 0x43ec
cmpq %r9, %rbx
jbe 0x440e
jmp 0x43ec
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: prompt_save_file
static int prompt_save_file(struct hed_editor *editor)
{
  char filename[256];
  if (editor->file->filename)
    snprintf(filename, sizeof(filename), "%s", editor->file->filename);
  else
    filename[0] = '\0';
  if (prompt_get_filename(editor, "Write file", filename, sizeof(filename)) < 0) {
    editor->screen.redraw_needed = true;
    return -1;
  }
  editor->screen.redraw_needed = true;
  return hed_write_file(editor->file, filename);
}

// Assembly:
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %rbx
movq 0x628(%rdi), %rax
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x5954
leaq 0x200c(%rip), %rdx      # 0x794f
movq %rsp, %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
callq 0x2100
jmp 0x5958
movb $0x0, (%rsp)
movl $0x1, 0x104(%rbx)
leaq 0x21d5(%rip), %rsi      # 0x7b3e
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x5d35
movb $0x1, 0x115(%rbx)
testl %eax, %eax
js 0x5990
movq 0x628(%rbx), %rdi
movq %rsp, %rsi
callq 0x3415
jmp 0x5995
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x100, %rsp            # imm = 0x100
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: perform_search
static int perform_search(struct hed_editor *editor)
{
  struct hed_file *file = editor->file;

  size_t search_len = strlen(editor->search_str);
  uint8_t *search_bytes;
  uint8_t search_buf[sizeof(editor->search_str)];
  if (file->pane == HED_PANE_TEXT) {
    search_bytes = (uint8_t *) editor->search_str;
  } else {
    search_len = conv_search_bytes(search_buf, sizeof(search_buf), editor->search_str);
    if (search_len == 0)
      return show_msg("Invalid byte sequence (must be a list pairs of hex numbers)");
    search_bytes = search_buf;
  }

  // TODO: Boyer-Moore search?
  bool found = false;
  size_t pos;
  for (pos = file->cursor_pos+1; pos + search_len < file->data_len; pos++) {
    if (memcmp(file->data + pos, search_bytes, search_len) == 0) {
      found = true;
      file->cursor_pos = pos;
      break;
    }
  }
  if (! found)
    return show_msg((file->pane == HED_PANE_HEX) ? "Byte sequence not found" : "Text not found");
  hed_set_cursor_pos(editor, pos, search_len);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
movq 0x628(%rdi), %r13
leaq 0x3(%rdi), %r14
movq %r14, %rdi
callq 0x20e0
movl 0x34(%r13), %esi
cmpl $0x1, %esi
jne 0x5a2c
movq %rax, %r15
movl %esi, 0xc(%rsp)
movq 0x18(%r13), %rbp
movq 0x38(%r13), %r12
incq %r12
leaq (%r15,%r12), %rax
cmpq %rbp, %rax
jae 0x5ae6
movq 0x10(%r13), %rdi
addq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21e0
incq %r12
testl %eax, %eax
jne 0x59e0
decq %r12
movq %r12, 0x38(%r13)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4368
movb (%r14), %cl
testb %cl, %cl
je 0x5add
xorl %eax, %eax
incq %r14
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x5a7c
leal -0x61(%rcx), %edx
cmpb $0x5, %dl
jbe 0x5a72
leal -0x41(%rcx), %edx
cmpb $0x5, %dl
jbe 0x5a77
cmpb $0x2c, %cl
je 0x5a61
movzbl %cl, %ecx
cmpl $0x20, %ecx
jne 0x5add
movb (%r14), %cl
incq %r14
testb %cl, %cl
jne 0x5a3c
decq %r14
xorl %edx, %edx
jmp 0x5a7c
addb $-0x57, %cl
jmp 0x5a7a
addb $-0x37, %cl
movl %ecx, %edx
testb $0x1, %al
jne 0x5aa8
shlb $0x4, %dl
movq %rax, %rcx
shrq %rcx
movb %dl, 0x10(%rsp,%rcx)
movb (%r14), %cl
testb %cl, %cl
je 0x5add
movq %rax, %rdx
orq $0x1, %rdx
cmpq $0x1ff, %rax            # imm = 0x1FF
movq %rdx, %rax
jb 0x5a39
jmp 0x5add
movq %rax, %rcx
shrq %rcx
orb %dl, 0x10(%rsp,%rcx)
leaq 0x1(%rax), %r15
movb (%r14), %cl
testb %cl, %cl
je 0x5acc
cmpq $0x1ff, %rax            # imm = 0x1FF
movq %r15, %rax
jb 0x5a39
movl %esi, 0xc(%rsp)
shrq %r15
leaq 0x10(%rsp), %r14
jmp 0x59d5
leaq 0x1e78(%rip), %rdi      # 0x795c
jmp 0x5afd
cmpl $0x0, 0xc(%rsp)
leaq 0x1ea6(%rip), %rax      # 0x7998
leaq 0x1eb7(%rip), %rdi      # 0x79b0
cmoveq %rax, %rdi
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ce6
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: cursor_right
static void cursor_right(struct hed_editor *editor)
{
  struct hed_screen *scr = &editor->screen;
  struct hed_file *file = editor->file;

  if (file->cursor_pos + 1 < file->data_len) {
    file->cursor_pos++;
    size_t n_page_lines = get_num_displayed_file_lines(editor);
    while (file->cursor_pos >= 16 * (file->top_line + n_page_lines))
      file->top_line++;
    scr->redraw_needed = true;
  }
}

// Assembly:
movq 0x628(%rdi), %rax
movq 0x38(%rax), %rcx
leaq 0x1(%rcx), %r9
cmpq 0x18(%rax), %r9
jae 0x5b99
movq %r9, 0x38(%rax)
movzbl 0x29(%rax), %r10d
movslq 0x110(%rdi), %r8
xorl $0x1, %r10d
leaq (%r10,%r10,4), %rdx
movq 0x40(%rax), %rsi
addq %rsi, %r8
addq %r8, %rdx
shlq $0x4, %rdx
addq $-0xa0, %rdx
cmpq %rdx, %r9
jb 0x5b92
leal (%r10,%r10,4), %r9d
addl $-0xa, %r9d
movslq %r9d, %r9
addq %r9, %r8
shlq $0x4, %r8
addq $0x10, %r8
addq $0x2, %rcx
cmpq %rcx, %r8
cmovaq %r8, %rcx
notq %rdx
addq %rcx, %rdx
shrq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
incq %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x115(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: cursor_down
static void cursor_down(struct hed_editor *editor)
{
  struct hed_screen *scr = &editor->screen;
  struct hed_file *file = editor->file;

  if (file->cursor_pos + 16 < file->data_len) {
    file->cursor_pos += 16;
    size_t n_page_lines = get_num_displayed_file_lines(editor);
    while (file->cursor_pos >= 16 * (file->top_line + n_page_lines))
      file->top_line++;
    scr->redraw_needed = true;
  }
}

// Assembly:
movq 0x628(%rdi), %rax
movq 0x38(%rax), %rcx
leaq 0x10(%rcx), %r9
cmpq 0x18(%rax), %r9
jae 0x5c1e
movq %r9, 0x38(%rax)
movzbl 0x29(%rax), %r10d
movslq 0x110(%rdi), %r8
xorl $0x1, %r10d
leaq (%r10,%r10,4), %rdx
movq 0x40(%rax), %rsi
addq %rsi, %r8
addq %r8, %rdx
shlq $0x4, %rdx
addq $-0xa0, %rdx
cmpq %rdx, %r9
jb 0x5c17
leal (%r10,%r10,4), %r9d
addl $-0xa, %r9d
movslq %r9d, %r9
addq %r9, %r8
shlq $0x4, %r8
addq $0x10, %r8
addq $0x11, %rcx
cmpq %rcx, %r8
cmovaq %r8, %rcx
notq %rdx
addq %rcx, %rdx
shrq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
incq %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x115(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: cursor_page_up
static void cursor_page_up(struct hed_editor *editor)
{
  struct hed_screen *scr = &editor->screen;
  struct hed_file *file = editor->file;
  int cursor_delta = file->cursor_pos - 16*file->top_line;
  size_t n_page_lines = get_num_displayed_file_lines(editor);

  if (file->top_line == 0)
    cursor_delta %= 16;
  else if (file->top_line >= n_page_lines)
    file->top_line -= n_page_lines;
  else
    file->top_line = 0;
  file->cursor_pos = 16*file->top_line + cursor_delta;
  scr->redraw_needed = true;
}

// Assembly:
movq 0x628(%rdi), %rax
movl 0x38(%rax), %ecx
movq 0x40(%rax), %rdx
movl %edx, %esi
shll $0x4, %esi
subl %esi, %ecx
testq %rdx, %rdx
je 0x5c62
movzbl 0x29(%rax), %esi
movslq 0x110(%rdi), %r8
xorq $0x1, %rsi
leaq (%rsi,%rsi,4), %rsi
addq %r8, %rsi
addq $-0xa, %rsi
subq %rsi, %rdx
jae 0x5c73
movq $0x0, 0x40(%rax)
jmp 0x5c6f
leal 0xf(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
andl $-0x10, %edx
subl %edx, %ecx
xorl %edx, %edx
jmp 0x5c7b
movq %rdx, 0x40(%rax)
shlq $0x4, %rdx
movslq %ecx, %rcx
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
movb $0x1, 0x115(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/moefh[P]hed/src/editor.c
// Function: cursor_page_down
static void cursor_page_down(struct hed_editor *editor)
{
  struct hed_screen *scr = &editor->screen;
  struct hed_file *file = editor->file;
  int cursor_delta = file->cursor_pos - 16*file->top_line;
  size_t n_page_lines = get_num_displayed_file_lines(editor);
  size_t last_line = file->data_len / 16 + (file->data_len % 16 != 0);

  if (last_line < n_page_lines || file->top_line == last_line - n_page_lines) {
    if (last_line < n_page_lines)
      file->top_line = 0;
    cursor_delta = file->data_len - 16*file->top_line - 1;
  } else if (last_line > n_page_lines && file->top_line + 2*n_page_lines < last_line)
    file->top_line += n_page_lines;
  else
    file->top_line = last_line - n_page_lines;
  file->cursor_pos = 16*file->top_line + cursor_delta;
  scr->redraw_needed = true;
}

// Assembly:
movq 0x628(%rdi), %rax
movq 0x18(%rax), %rcx
movzbl 0x29(%rax), %edx
movslq 0x110(%rdi), %rsi
xorq $0x1, %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rsi,%rdx), %r8
addq $-0xa, %r8
movq %rcx, %r9
shrq $0x4, %r9
movl %ecx, %edx
andl $0xf, %edx
cmpq $0x1, %rdx
sbbq $-0x1, %r9
movq %r9, %rdx
subq %r8, %rdx
jae 0x5cdb
movq $0x0, 0x40(%rax)
xorl %esi, %esi
jmp 0x5ce4
movq 0x40(%rax), %rsi
cmpq %rdx, %rsi
jne 0x5d0a
movq %rsi, %rdx
shlq $0x4, %rdx
notq %rdx
addq %rdx, %rcx
movq %rsi, %rdx
shlq $0x4, %rdx
movslq %ecx, %rcx
addq %rdx, %rcx
movq %rcx, 0x38(%rax)
movb $0x1, 0x115(%rdi)
retq
movq 0x38(%rax), %rcx
movq %rsi, %r10
shlq $0x4, %r10
subq %r10, %rcx
cmpq %r8, %r9
jbe 0x5d2f
leaq (%rsi,%r8,2), %r10
cmpq %r9, %r10
jae 0x5d2f
addq %r8, %rsi
movq %rsi, 0x40(%rax)
jmp 0x5cf1
movq %rdx, 0x40(%rax)
jmp 0x5cf4
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/rmdir.c
// Function: parse_arg
struct rmdir_args *parse_arg(struct rmdir_args *args, int argc, char **argv){
    args->paths = calloc(1, sizeof(char*) * argc);
    args->pcount = 0;
    for(int i = 0; i < argc; i++){
        if(!strcmp(argv[i], "--ignore-fail-on-non-empty")){
            args->ignore_fail = true;
        }
        else if(!strcmp(argv[i], "-p") || !strcmp(argv[i], "--parents")){
            args->parents = true;
        }
        else if(!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose")){
            args->verbose = true;
        }
        else if(argv[i][0] == '-'){
            fprintf(stderr, "%s: invalid operand '%s'\n", argv[0], argv[i]);
            exit(1);
        }
        else {
            args->paths[args->pcount++] = argv[i];
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl %esi, %r15d
movq %rdi, %r14
movslq %esi, %rbx
leaq (,%rbx,8), %rsi
movl $0x1, %edi
callq 0x1060
movq %rax, 0x8(%r14)
movl $0x0, 0x10(%r14)
testl %ebx, %ebx
jle 0x1388
movl %r15d, %r12d
movq $0x0, -0x30(%rbp)
xorl %r15d, %r15d
movq -0x38(%rbp), %rax
movq (%rax,%r15,8), %r13
movq %r13, %rdi
leaq 0xd54(%rip), %rsi       # 0x2004
callq 0x1070
testl %eax, %eax
je 0x130d
movb (%r13), %bl
cmpb $0x2d, %bl
jne 0x1313
cmpb $0x70, 0x1(%r13)
jne 0x12d0
cmpb $0x0, 0x2(%r13)
je 0x133b
movq %r13, %rdi
leaq 0xd45(%rip), %rsi       # 0x201f
callq 0x1070
testl %eax, %eax
je 0x133b
cmpb $0x76, 0x1(%r13)
jne 0x1342
cmpb $0x0, 0x2(%r13)
je 0x1377
movq %r13, %rdi
leaq 0xd2a(%rip), %rsi       # 0x2029
callq 0x1070
testl %eax, %eax
je 0x1377
jmp 0x139a
movb $0x1, (%r14)
jmp 0x137c
movq %r13, %rdi
leaq 0xd02(%rip), %rsi       # 0x201f
callq 0x1070
testl %eax, %eax
je 0x133b
movq %r13, %rdi
leaq 0xcf9(%rip), %rsi       # 0x2029
callq 0x1070
testl %eax, %eax
jne 0x135a
jmp 0x1377
movb $0x1, 0x1(%r14)
jmp 0x137c
movq %r13, %rdi
leaq 0xcdd(%rip), %rsi       # 0x2029
callq 0x1070
testl %eax, %eax
je 0x1377
cmpb $0x2d, %bl
je 0x139a
movq 0x8(%r14), %rax
movq -0x30(%rbp), %rdx
movslq %edx, %rcx
incl %edx
movl %edx, 0x10(%r14)
movq %r13, (%rax,%rcx,8)
movl %edx, %eax
movq %rax, -0x30(%rbp)
jmp 0x137c
movb $0x1, 0x2(%r14)
incq %r15
cmpq %r15, %r12
jne 0x129e
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/rmdir.c
// Function: main
int main(int argc, char **argv){
    if(argc == 1){
        fprintf(stderr, "%s: missing operand\n", argv[0]);
        return 1;
    }
    struct rmdir_args *args = calloc(1, sizeof(struct rmdir_args));
    args = parse_arg(args, argc, argv);
    for(int i = 1; i < args->pcount; i++){
        if(args->verbose){
            fprintf(stdout, "%s: removing directory, '%s'\n", argv[0], args->paths[i]);
        }
        if(rmdir(args->paths[i]) == -1){
            if(errno == ENOTEMPTY && !args->ignore_fail){
                fprintf(stderr, "%s: failed to remove '%s': %s\n", argv[0], args->paths[i], strerror(errno));
                return 1;
            }
        }
    }
    free(args->paths);
    free(args);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x1474
movl %edi, %r12d
movl $0x1, %r14d
movl $0x1, %edi
movl $0x18, %esi
callq 0x1060
movq %rax, %r15
movq %rax, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x124c
cmpl $0x2, 0x10(%r15)
jl 0x1452
movq %r15, %r12
addq $0x8, %r12
leaq 0xc64(%rip), %r13       # 0x2062
cmpb $0x1, 0x2(%r15)
jne 0x1424
movq 0x2bcc(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
movq (%rbx), %rdx
movq (%r12), %rax
movq (%rax,%r14,8), %rcx
movq %r13, %rsi
xorl %eax, %eax
callq 0x1080
movq (%r12), %rax
movq (%rax,%r14,8), %rdi
callq 0x1050
cmpl $-0x1, %eax
jne 0x1446
callq 0x1040
cmpl $0x27, (%rax)
jne 0x1446
cmpb $0x0, (%r15)
je 0x1483
incq %r14
movslq 0x10(%r15), %rax
cmpq %rax, %r14
jl 0x13fe
movq 0x8(%r15), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x1137
movl $0x1, %eax
jmp 0x1465
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x10ed
jmp 0x147c
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/main.c
// Function: main
int	main(int argc, char *argv[])
{
	t_game	game;
	int		w;

	ft_bzero(&game, sizeof(t_game));
	if (argc == 2)
	{
		if (check_map(argv[1], &game))
			game_config(&game);
		else
			return (check_error(INVALID_MAP));
		game_init(&game);
	}
	else
		return (check_error(INVALID_PARAM_NB));
	return (SUCCESS);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %rdi
movl $0x160, %esi            # imm = 0x160
callq 0x6600
cmpl $0x2, %ebp
jne 0x6589
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6d7d
testl %eax, %eax
je 0x6590
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x70ac
movq %rbx, %rdi
callq 0x7854
xorl %eax, %eax
jmp 0x659a
movl $0x2, %edi
jmp 0x6595
movl $0x1, %edi
callq 0x6f78
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/get_next_line.c
// Function: get_line
void	get_line(t_buffer *buffer)
{
	size_t	size;
	char	*tmp;
	int		desloc;

	desloc = buffer->desloc;
	size = get_line_size(&buffer->data[desloc]);
	if (buffer->line)
		size += get_line_size(buffer->line);
	tmp = (char *) ft_calloc(size + 1, sizeof(char));
	if (buffer->line)
	{
		append_line(tmp, buffer->line);
		free(buffer->line);
	}
	desloc = append_line(tmp, &buffer->data[desloc]);
	buffer->line = tmp;
	if (desloc == -1)
	{
		ft_bzero(buffer->data, BUFFER_SIZE);
		buffer->desloc = 0;
		if ((read(buffer->fd, buffer->data, BUFFER_SIZE)) > 0)
			get_line(buffer);
	}
	else
		buffer->desloc += desloc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4(%rdi), %r14
leaq 0x5(%rdi), %r12
movslq 0x6c(%rbx), %r13
leaq (%r14,%r13), %rbp
xorl %eax, %eax
movzbl (%rbp,%rax), %ecx
testl %ecx, %ecx
je 0x66a4
cmpl $0xa, %ecx
je 0x66a4
incq %rax
jmp 0x6691
xorl %edi, %edi
cmpb $0xa, %cl
sete %dil
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0x66d9
addq %rax, %rdi
movq %rdi, %rax
movzbl (%rcx), %edx
testl %edx, %edx
je 0x66d0
cmpl $0xa, %edx
je 0x66d0
incq %rax
incq %rcx
jmp 0x66bc
xorl %edi, %edi
cmpb $0xa, %dl
sete %dil
addq %rax, %rdi
incq %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %r15
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x6732
movq $-0x1, %rax
cmpb $0x0, 0x1(%r15,%rax)
leaq 0x1(%rax), %rax
jne 0x66fc
movb (%rdi), %cl
testb %cl, %cl
je 0x672d
movl %eax, %eax
addq %r15, %rax
xorl %edx, %edx
movb %cl, (%rax,%rdx)
cmpb $0xa, (%rdi,%rdx)
je 0x6729
movb 0x1(%rdi,%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x6715
movq 0x70(%rbx), %rdi
callq 0x6190
movq $-0x1, %rax
cmpb $0x0, 0x1(%r15,%rax)
leaq 0x1(%rax), %rax
jne 0x6739
movb (%rbp), %cl
testb %cl, %cl
je 0x6777
addq %r12, %r13
movl %eax, %eax
movq %r15, %rdx
addq %rax, %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movb %cl, (%rdx,%rsi)
cmpb $0xa, -0x1(%r13,%rsi)
je 0x677d
movb (%r13,%rsi), %cl
incq %rsi
decl %eax
testb %cl, %cl
jne 0x675e
movq %r15, 0x70(%rbx)
jmp 0x6786
movq %r15, 0x70(%rbx)
cmpl $-0x2, %esi
jne 0x67b4
movl $0x64, %esi
movq %r14, %rdi
callq 0x6600
movl $0x0, 0x6c(%rbx)
movl (%rbx), %edi
movl $0x64, %edx
movq %r14, %rsi
callq 0x6100
testq %rax, %rax
jg 0x6687
jmp 0x67b7
subl %eax, 0x6c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/get_next_line.c
// Function: get_next_line
char	*get_next_line(int fd)
{
	static t_buffer	list[255];
	t_buffer		*buffer;

	if (fd < 0 || fd > 255)
		return (0);
	buffer = &list[fd];
	buffer->fd = fd;
	buffer->line = 0;
	if (*buffer->data == 0)
	{
		if ((read(fd, buffer->data, BUFFER_SIZE)) <= 0)
			return (0);
	}
	get_line(buffer);
	if (*buffer->line == 0)
	{
		free(buffer->line);
		return (0);
	}
	return (buffer->line);
}

// Assembly:
cmpl $0xff, %edi
jbe 0x67d1
xorl %eax, %eax
retq
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %eax
imulq $0x78, %rax, %r14
leaq 0xcaae(%rip), %rbx      # 0x13290
movl %edi, (%r14,%rbx)
movq $0x0, 0x70(%r14,%rbx)
cmpb $0x0, 0x4(%r14,%rbx)
jne 0x680e
leaq (%r14,%rbx), %rsi
addq $0x4, %rsi
movl $0x64, %edx
callq 0x6100
testq %rax, %rax
jle 0x682a
addq %r14, %rbx
movq %rbx, %rdi
callq 0x6671
movq 0x70(%rbx), %rax
cmpb $0x0, (%rax)
jne 0x682c
movq %rax, %rdi
callq 0x6190
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/ft_substr.c
// Function: ft_substr
char	*ft_substr(char const *s, unsigned int start, size_t len)
{
	char	*string;
	size_t	size;
	size_t	index;

	index = 0;
	if (!s)
		return (0);
	if (start > ft_strlen(s))
		size = 0;
	else
	{
		size = ft_strlen(&s[start]);
		if (len < size)
			size = len;
	}
	string = (char *) ft_calloc(size + 1, sizeof(char));
	if (!string)
		return (0);
	while (index < size)
	{
		string[index] = s[start + index];
		index++;
	}
	string[index] = '\0';
	return (string);
}

// Assembly:
testq %rdi, %rdi
je 0x6872
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x65e8
cmpl %ebp, %eax
jae 0x6875
xorl %ebx, %ebx
jmp 0x6888
xorl %eax, %eax
retq
movl %ebp, %edi
addq %r14, %rdi
callq 0x65e8
cltq
cmpq %rbx, %rax
cmovbq %rax, %rbx
leaq 0x1(%rbx), %rdi
movl $0x1, %esi
callq 0x65a4
testq %rax, %rax
je 0x68bc
testq %rbx, %rbx
je 0x68b6
movl %ebp, %ecx
addq %rcx, %r14
xorl %ecx, %ecx
movb (%r14,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rbx
jne 0x68a7
movb $0x0, (%rax,%rbx)
jmp 0x68be
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/pixel_manipulation.c
// Function: copy_img_from
void	copy_img_from(t_data *dest, t_data *src, int info[4])
{
	int	pixel;
	int	x;
	int	y;
	int	holder;

	x = 0;
	y = 0;
	holder = info[1];
	while (x < info[2])
	{
		while (y < info[3])
		{
			pixel = my_mlx_get_pixel(src, info[0], info[1]);
			if (pixel != 0 && pixel != -16777216)
				my_mlx_pixel_put(dest, x, y, pixel);
			y++;
			info[1]++;
		}
		y = 0;
		info[1] = holder;
		info[0]++;
		x++;
	}
	free(info);
}

// Assembly:
movl 0x8(%rdx), %r9d
testl %r9d, %r9d
jle 0x69ba
pushq %rbp
pushq %rbx
movl 0x4(%rdx), %eax
movl 0xc(%rdx), %r8d
xorl %ecx, %ecx
testl %r8d, %r8d
jle 0x69a8
movq 0x8(%rsi), %r9
xorl %r10d, %r10d
movl %eax, %r11d
movl 0x10(%rsi), %ebx
leal 0x7(%rbx), %ebp
testl %ebx, %ebx
cmovnsl %ebx, %ebp
sarl $0x3, %ebp
movl 0x14(%rsi), %ebx
imull %r11d, %ebx
imull (%rdx), %ebp
addl %ebx, %ebp
movslq %ebp, %rbx
movl (%r9,%rbx), %ebx
cmpl $0xff000000, %ebx       # imm = 0xFF000000
je 0x6995
testl %ebx, %ebx
je 0x6995
movl 0x10(%rdi), %r8d
leal 0x7(%r8), %r11d
testl %r8d, %r8d
cmovnsl %r8d, %r11d
sarl $0x3, %r11d
movq 0x8(%rdi), %r8
movl 0x14(%rdi), %ebp
imull %r10d, %ebp
imull %ecx, %r11d
addl %ebp, %r11d
movslq %r11d, %r11
movl %ebx, (%r8,%r11)
movl 0x4(%rdx), %r11d
movl 0xc(%rdx), %r8d
incl %r10d
incl %r11d
movl %r11d, 0x4(%rdx)
cmpl %r8d, %r10d
jl 0x6934
movl 0x8(%rdx), %r9d
movl %eax, 0x4(%rdx)
incl (%rdx)
incl %ecx
cmpl %r9d, %ecx
jl 0x6925
popq %rbx
popq %rbp
movq %rdx, %rdi
jmp 0x6190
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/pixel_manipulation.c
// Function: copy_img_to
void	copy_img_to(t_data *dest, t_data *src, int info[4])
{
	int	pixel;
	int	x;
	int	y;
	int	holder;

	x = 0;
	y = 0;
	holder = info[1];
	while (x < info[2])
	{
		while (y < info[3])
		{
			pixel = my_mlx_get_pixel(src, x, y);
			if (pixel != 0 && pixel != -16777216)
				my_mlx_pixel_put(dest, info[0], info[1], pixel);
			y++;
			info[1]++;
		}
		y = 0;
		info[1] = holder;
		info[0]++;
		x++;
	}
	free(info);
}

// Assembly:
movl 0x8(%rdx), %r9d
testl %r9d, %r9d
jle 0x6a6b
pushq %rbp
pushq %rbx
movl 0x4(%rdx), %eax
movl 0xc(%rdx), %r8d
xorl %ecx, %ecx
testl %r8d, %r8d
jle 0x6a59
movq 0x8(%rsi), %r9
xorl %r10d, %r10d
movl %eax, %r11d
movl 0x10(%rsi), %ebx
leal 0x7(%rbx), %ebp
testl %ebx, %ebx
cmovnsl %ebx, %ebp
sarl $0x3, %ebp
movl 0x14(%rsi), %ebx
imull %r10d, %ebx
imull %ecx, %ebp
addl %ebx, %ebp
movslq %ebp, %rbx
movl (%r9,%rbx), %ebx
cmpl $0xff000000, %ebx       # imm = 0xFF000000
je 0x6a46
testl %ebx, %ebx
je 0x6a46
movl 0x10(%rdi), %r8d
leal 0x7(%r8), %ebp
testl %r8d, %r8d
cmovnsl %r8d, %ebp
sarl $0x3, %ebp
imull 0x14(%rdi), %r11d
movq 0x8(%rdi), %r8
imull (%rdx), %ebp
addl %r11d, %ebp
movslq %ebp, %r11
movl %ebx, (%r8,%r11)
movl 0x4(%rdx), %r11d
movl 0xc(%rdx), %r8d
incl %r10d
incl %r11d
movl %r11d, 0x4(%rdx)
cmpl %r8d, %r10d
jl 0x69e9
movl 0x8(%rdx), %r9d
movl %eax, 0x4(%rdx)
incl (%rdx)
incl %ecx
cmpl %r9d, %ecx
jl 0x69da
popq %rbx
popq %rbp
movq %rdx, %rdi
jmp 0x6190
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/ft_strcat.c
// Function: ft_strcat
void	ft_strcat(char *dest, char *src)
{
	while (*dest)
		dest++;
	while (*src && *src != '\n')
	{	
		*dest = *src;
		dest++;
		src++;
	}
}

// Assembly:
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x6b04
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
testl %ecx, %ecx
je 0x6b25
cmpl $0xa, %ecx
je 0x6b25
movb %cl, -0x1(%rdi,%rax)
incq %rax
jmp 0x6b0f
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/utils/ft_itoa.c
// Function: ft_itoa
char	*ft_itoa(int n)
{
	size_t			size;
	unsigned int	number;
	int				is_negative;

	is_negative = 0;
	if (n < 0)
	{
		number = n * -1;
		is_negative = 1;
	}
	else
		number = n;
	size = get_size(number);
	if (number == 0)
		size = 1;
	return (set_string(number, size, is_negative));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %ebp
negl %ebp
cmovsl %edi, %ebp
jae 0x6b5a
xorl %r14d, %r14d
movl $0xcccccccd, %eax       # imm = 0xCCCCCCCD
movl %ebp, %ecx
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x23, %rdx
incq %r14
cmpl $0x9, %ecx
movl %edx, %ecx
ja 0x6b44
jmp 0x6b60
movl $0x1, %r14d
movl %ebx, %r15d
shrl $0x1f, %r15d
leaq (%r14,%r15), %rdi
incq %rdi
movl $0x1, %esi
callq 0x65a4
testq %rax, %rax
je 0x6bb0
addq %r15, %r14
je 0x6ba9
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
movl %ebp, %edx
imulq %rcx, %rdx
shrq $0x23, %rdx
leal (%rdx,%rdx), %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %ebp
orb $0x30, %bpl
movb %bpl, -0x1(%rax,%r14)
movl %edx, %ebp
decq %r14
jne 0x6b87
testl %ebx, %ebx
jns 0x6bb0
movb $0x2d, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/alsmd[P]so_long/src/checks/check_map.c
// Function: get_all_content
int	get_all_content(int fd, t_game *game)
{
	int		x;
	int		y;
	char	*line;
	char	*all_content;

	x = -1;
	y = 0;
	all_content = 0;
	line = get_next_line(fd);
	while (line)
	{
		if (check_format(line) && (x == -1 || x == ft_strlen(line)))
		{
			if (x == -1)
				x = ft_strlen(line);
			append(&all_content, line);
		}
		else
			return (0);
		y++;
		line = get_next_line(fd);
	}
	make_layout(game, x, y, all_content);
	free(all_content);
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movl %edi, 0x14(%rsp)
callq 0x67c6
testq %rax, %rax
je 0x6d33
movq %rax, %r15
movq %r12, 0x8(%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
xorl %ebx, %ebx
movl $0x1, %eax
leaq 0x4407(%rip), %r12      # 0xb004
xorl %r14d, %r14d
movq %rax, %rbp
movq %r15, %r13
movzbl (%r13), %eax
testl %eax, %eax
je 0x6c2b
cmpl $0xa, %eax
je 0x6c2b
movsbl %al, %esi
movq %r12, %rdi
callq 0x6834
incq %r13
testl %eax, %eax
jne 0x6c06
jmp 0x6d2f
movq %r15, %rdi
callq 0x65e8
movl 0x4(%rsp), %ecx
cmpl $-0x1, %ecx
je 0x6c45
cmpl %eax, %ecx
je 0x6c47
jmp 0x6d2f
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
testq %r14, %r14
je 0x6c90
movq %r14, %rdi
callq 0x65e8
movl %eax, %r13d
movq %r15, %rdi
callq 0x65e8
addl %r13d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x6b04
movq %r14, %rdi
callq 0x6190
movq %r13, %r14
jmp 0x6caa
movq %r15, %rdi
callq 0x65e8
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x65a4
movq %rax, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6b04
movq %r15, %rdi
callq 0x6190
incl %ebx
movl 0x14(%rsp), %edi
callq 0x67c6
movq %rax, %r15
leaq 0x1(%rbp), %rax
testq %r15, %r15
jne 0x6c00
movl %ebx, %edi
movl $0x8, %esi
callq 0x65a4
movq 0x8(%rsp), %rcx
movq %rax, 0xc8(%rcx)
movslq 0x4(%rsp), %r15
xorl %r13d, %r13d
movq %r14, %r12
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x6854
movq 0x8(%rsp), %rcx
movq 0xc8(%rcx), %rcx
movq %rax, (%rcx,%r13)
addq %r15, %r12
addq $0x8, %r13
decq %rbp
jne 0x6cfb
movq 0x8(%rsp), %r12
movl 0x4(%rsp), %eax
jmp 0x6d51
xorl %eax, %eax
jmp 0x6d6e
xorl %ebx, %ebx
movl $0x8, %esi
xorl %edi, %edi
callq 0x65a4
movq %rax, 0xc8(%r12)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movl %eax, 0x128(%r12)
movl %ebx, 0x12c(%r12)
movq %r14, %rdi
callq 0x6190
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq