LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/zpole[P]IICV/src/test_mathop_abs.c
// Function: main
int
main(int argc VL_UNUSED, char**argv VL_UNUSED)
{
  VlRand * rand = vl_get_rand() ;
  vl_size numData = 100000000 ;
  vl_size i ;
  float * X = vl_malloc(sizeof(float) * numData) ;
  float * Y = vl_malloc(sizeof(float) * numData) ;
  float * X_end = X + numData ;

  for (i = 0 ; i < numData ; ++ i) {
    X[i] = vl_rand_real1(rand) - .5 ;
    Y[i] = 0 ;
  }

  {
    float * Xi = X ;
    float * Yi = Y ;
    vl_tic() ;
    while (Xi < X_end) {
      *Yi++ = fabsf (*Xi++) ;
    }
    VL_PRINTF("fabsf: %.3f\n", vl_toc()) ;
  }

  for (i = 0 ; i < numData ; ++ i) {
    X[i] = vl_rand_real1(rand) - .5 ;
    X[i] = 0 ;
  }

  {
    float * Xi = X ;
    float * Yi = Y ;
    vl_tic() ;
    while (Xi < X_end) {
      *Yi++ = vl_abs_f (*Xi++) ;
    }
    VL_PRINTF("vl_abs_f: %.3f\n", vl_toc()) ;
  }

  vl_free (Y) ;
  vl_free (X) ;

  return 0 ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x1090
movq %rax, %r15
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x1080
movq %rax, %rbx
movl $0x17d78400, %edi       # imm = 0x17D78400
callq 0x1080
movq %rax, %r14
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x1060
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0xe25(%rip), %xmm0      # 0x2008
addsd 0xe25(%rip), %xmm0      # 0x2010
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rbx,%r12,4)
movl $0x0, (%r14,%r12,4)
incq %r12
cmpq $0x5f5e100, %r12        # imm = 0x5F5E100
jne 0x11c9
callq 0x1030
movq $-0x4, %rax
movss 0x4(%rbx,%rax), %xmm0
andps 0xdfe(%rip), %xmm0      # 0x2020
movss %xmm0, 0x4(%r14,%rax)
addq $0x4, %rax
cmpq $0x17d783fc, %rax       # imm = 0x17D783FC
jb 0x1215
callq 0x1040
movq %rax, %r12
callq 0x1050
leaq 0xde7(%rip), %rdi       # 0x2030
movb $0x1, %al
callq *%r12
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x1060
movl $0x0, (%rbx,%r12,4)
incq %r12
cmpq $0x5f5e100, %r12        # imm = 0x5F5E100
jne 0x1251
callq 0x1030
movq $-0x4, %rax
movaps 0xda0(%rip), %xmm1      # 0x2020
movss 0x4(%rbx,%rax), %xmm0
andps %xmm1, %xmm0
movss %xmm0, 0x4(%r14,%rax)
addq $0x4, %rax
cmpq $0x17d783fc, %rax       # imm = 0x17D783FC
jb 0x1280
callq 0x1040
movq %rax, %r15
callq 0x1050
leaq 0xd8d(%rip), %rdi       # 0x203d
movb $0x1, %al
callq *%r15
movq %r14, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_08/bfree.c
// Function: c_malloc
void *c_malloc(size_t nr_of_bytes)
{
  Header *p;
  Header *prev_p;

  if (nr_of_bytes == 0 || nr_of_bytes >= UINT_MAX - MIN_NR_OF_UNITS)
  {
    fprintf(stderr, "Error(malloc): invalid size %zu\n", nr_of_bytes);
    return NULL;
  }

  size_t nr_of_units = (nr_of_bytes + sizeof(Header) - 1) / sizeof(Header);

  if ((prev_p = free_p) == NULL)
  {
    base.s.free_block_p = free_p = prev_p = &base;
    base.s.size = 0;
  }

  for (p = prev_p->s.free_block_p;; prev_p = p, p = p->s.free_block_p)
  {
    if (p->s.size >= nr_of_units)
    {
      if (p->s.size == nr_of_units)
      {
        prev_p->s.free_block_p = p->s.free_block_p;
      }
      else
      {
        p->s.size -= nr_of_units;
        p += p->s.size;
        p->s.size = nr_of_units;
      }

      free_p = prev_p;
      return (void *)(p + 1);
    }

    if (p == free_p)
    {
      if ((p = c_morecore(nr_of_units)) == NULL)
      {
        return NULL;
      }
    }
  }

  return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0xfffffbff, %rax      # imm = 0xFFFFFFFF00000401
leaq (%rdi,%rax), %rcx
incq %rax
cmpq %rax, %rcx
jb 0x133b
addq $0xf, %rbx
shrq $0x4, %rbx
movq 0x2db3(%rip), %rcx      # 0x4058
testq %rcx, %rcx
jne 0x12ca
leaq 0x2daf(%rip), %rcx      # 0x4060
movq %rcx, 0x2da0(%rip)      # 0x4058
movq %rcx, 0x2da1(%rip)      # 0x4060
movq $0x0, 0x2d9e(%rip) # 0x4068
movq (%rcx), %rax
movq 0x8(%rax), %rdx
cmpq %rbx, %rdx
jae 0x1300
cmpq 0x2d7b(%rip), %rax      # 0x4058
jne 0x12ec
movq %rbx, %rdi
callq 0x145a
testq %rax, %rax
je 0x1336
movq (%rax), %r14
movq 0x8(%r14), %rdx
movq %rax, %rcx
movq %r14, %rax
cmpq %rbx, %rdx
jb 0x12d6
jmp 0x1303
movq %rax, %r14
subq %rbx, %rdx
jne 0x1310
movq (%r14), %rax
movq %rax, (%rcx)
jmp 0x1320
movq %rdx, 0x8(%r14)
shlq $0x4, %rdx
movq %rbx, 0x8(%r14,%rdx)
addq %rdx, %r14
movq %rcx, 0x2d31(%rip)      # 0x4058
addq $0x10, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x132b
movq 0x2cb6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd3b(%rip), %rsi       # 0x2087
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x132b
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_08/bfree.c
// Function: c_free
void c_free(void *a_p)
{
  Header *p;
  Header *b_p = (Header *)a_p - 1;

  if (b_p->s.size == 0 || b_p->s.size == UINT_MAX - MIN_NR_OF_UNITS)
  {
    fprintf(stderr, "Error(free): invalid block size %zu\n", b_p->s.size);
    return;
  }

  for (p = free_p; !(b_p > p && b_p < p->s.free_block_p); p = p->s.free_block_p)
  {
    if (p >= p->s.free_block_p && (b_p > p || b_p < p->s.free_block_p))
    {
      break;
    }
  }

  if (b_p + b_p->s.size == p->s.free_block_p)
  {
    b_p->s.size += p->s.free_block_p->s.size;
    b_p->s.free_block_p = p->s.free_block_p->s.free_block_p;
  }
  else
  {
    b_p->s.free_block_p = p->s.free_block_p;
  }

  if (p + p->s.size == b_p)
  {
    p->s.size += b_p->s.size;
    p->s.free_block_p = b_p->s.free_block_p;
  }
  else
  {
    p->s.free_block_p = b_p;
  }

  free_p = p;
}

// Assembly:
movq -0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x13f6
movl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
cmpq %rax, %rdx
je 0x13f6
leaq -0x10(%rdi), %rcx
leaq 0x2cd7(%rip), %rax      # 0x4058
movq (%rax), %rax
cmpq %rax, %rcx
jbe 0x138e
cmpq (%rax), %rcx
jb 0x13a9
cmpq %rax, %rcx
seta %sil
movq (%rax), %r9
cmpq %r9, %rcx
setb %r8b
cmpq %r9, %rax
jb 0x1381
orb %r8b, %sil
je 0x1381
movq %rdx, %r8
shlq $0x4, %r8
addq %rcx, %r8
movq (%rax), %rsi
cmpq %rsi, %r8
jne 0x13c9
addq 0x8(%rsi), %rdx
movq %rdx, -0x8(%rdi)
movq (%rax), %rdx
movq (%rdx), %rsi
movq %rsi, (%rcx)
movq 0x8(%rax), %rdx
movq %rdx, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
cmpq %rcx, %rsi
jne 0x13eb
addq -0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq -0x10(%rdi), %rcx
movq %rcx, (%rax)
movq %rax, 0x2c63(%rip)      # 0x4058
retq
movq 0x2bfb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc31(%rip), %rsi       # 0x2038
xorl %eax, %eax
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_08/getch.c
// Function: main
int getch(void)
{
  char temp;

  if (buf != -1)
  {
    temp = buf;
    buf = -1;

    return temp;
  }

  return getchar();
}

// Assembly:
pushq %rbx
movl 0x2edd(%rip), %eax      # 0x4040
cmpl $-0x1, %eax
je 0x1174
movl $0xffffffff, 0x2ece(%rip) # imm = 0xFFFFFFFF
jmp 0x1179
callq 0x1050
movsbl %al, %ebx
leaq 0xe81(%rip), %rdi       # 0x2004
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
cmpl $-0x1, 0x2ead(%rip)     # 0x4040
je 0x11a3
leaq 0xe6c(%rip), %rdi       # 0x2008
callq 0x1030
jmp 0x11a9
movl %ebx, 0x2e97(%rip)      # 0x4040
movl 0x2e91(%rip), %eax      # 0x4040
cmpl $-0x1, %eax
je 0x11c0
movl $0xffffffff, 0x2e82(%rip) # imm = 0xFFFFFFFF
jmp 0x11c5
callq 0x1050
movsbl %al, %esi
leaq 0xe35(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_up
static void command_navigate_up(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_up(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7ed0
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_down
static void command_navigate_down(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_down(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7fbd
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_pageup
static void command_navigate_pageup(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_pageup(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7fd0
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_pagedown
static void command_navigate_pagedown(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_pagedown(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x8006
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_left
static void command_navigate_left(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	const char *oldpathname = NULL;

	save_current_position(app);

	if(path_remove_component(&app->cwd, &oldpathname))
		enter_directory(app, oldpathname);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x178(%rdi), %rbx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %rbx, %rdi
callq 0x4fdb
addq $-0x38, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x82b2
testb %al, %al
je 0x3913
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b4e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_right
static void command_navigate_right(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;

	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	save_current_position(app);

	size_t index = listview_getindex(&app->view);
	if(dirmodel_isdir(&app->model, index)) {
		const char *filename = dirmodel_getfilename(&app->model, index);
		if(!path_add_component(&app->cwd, filename))
			return;
		enter_directory(app, NULL);
	} else {
		command_invoke_handler(commandexecutor, "open");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x150(%rdi), %r15
movq %r15, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x3998
leaq -0x178(%rbx), %r14
movq %r14, %rdi
callq 0x4fdb
movq %r14, %rdi
callq 0x8053
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x68b9
testb %al, %al
je 0x39a4
movq %r15, %rdi
movq %r12, %rsi
callq 0x6899
addq $-0x38, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8202
testb %al, %al
je 0x3998
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4b4e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x57b0(%rip), %rsi      # 0x915b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3b8a
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_first
static void command_navigate_first(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_setindex(&app->view, 0);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
xorl %esi, %esi
callq 0x804a
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_last
static void command_navigate_last(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	size_t count = listmodel_count(&app->model.listmodel);

	if(count > 0) {
		listview_setindex(&app->view, count - 1);
		listview_refresh(&app->view);
		refresh_statusbar(app);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
callq 0x7c0c
testq %rax, %rax
je 0x3a1f
addq $-0x178, %rbx           # imm = 0xFE88
decq %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x804a
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_togglemark
static void command_togglemark(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	listmodel_setmark(&app->model.listmodel, index, !listmodel_ismarked(&app->model.listmodel, index));
	listview_down(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq -0x150(%rdi), %r14
movq %r14, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x3a87
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x8053
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7c23
xorb $0x1, %al
movzbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c14
movq %rbx, %rdi
callq 0x7fbd
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4d86
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_invert_marks
static void command_invert_marks(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	size_t count = listmodel_count(&app->model.listmodel);

	if(count > 0) {
		for(size_t i = 0; i < count; i++)
			listmodel_setmark(&app->model.listmodel, i, !listmodel_ismarked(&app->model.listmodel, i));
	}
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x150(%rdi), %r14
movq %r14, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x3ad5
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x7c23
xorb $0x1, %al
movzbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7c14
incq %r12
cmpq %r12, %r15
jne 0x3ab2
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_mark
static void command_mark(struct commandexecutor *commandexecutor, char *regex)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	dirmodel_regex_setmark(&app->model, regex, true);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
leaq -0x178(%rdi), %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
movl $0x1, %edx
callq 0x62b2
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_unmark
static void command_unmark(struct commandexecutor *commandexecutor, char *regex)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	dirmodel_regex_setmark(&app->model, regex, false);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
leaq -0x178(%rdi), %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
xorl %edx, %edx
callq 0x62b2
movq %rbx, %rdi
callq 0x7d78
movq %rbx, %rdi
popq %rbx
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_change_directory
static void command_change_directory(struct commandexecutor *commandexecutor, char *path)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	save_current_position(app);

	if(path_set_from_string(&app->cwd, path) == 0)
		enter_directory(app, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x178(%rdi), %rbx
movq %rbx, %rdi
callq 0x4fdb
addq $-0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8329
testl %eax, %eax
je 0x3b7b
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x4b4e
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_yank
static void command_yank(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	const struct list *list = NULL;

	int ret = dirmodel_getmarkedfilenames(&app->model, &list);
	char *cwd_copy = strdup(path_tocstr(&app->cwd));

	if(ret == ENOMEM)
		goto err;

	if(ret == 0) {
		if(cwd_copy == NULL)
			goto err;
	} else if(ret == ENOENT) {
		if(listmodel_count(&app->model.listmodel) == 0)
			goto err;

		struct list *selectedlist = list_new(1);
		if(selectedlist == NULL)
			goto err;
		list = selectedlist;

		size_t index = listview_getindex(&app->view);
		char *filename = strdup(dirmodel_getfilename(&app->model, index));
		if(filename == NULL)
			goto err;

		if(!list_append(selectedlist, filename)) {
			free(filename);
			goto err;
		}
	}
	clipboard_set_contents(&app->clipboard, cwd_copy, list);
	return;
err:
	free(cwd_copy);
	list_delete(list, free);
	clipboard_set_contents(&app->clipboard, NULL, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x150(%rdi), %r15
movq %r15, %rdi
callq 0x607c
movl %eax, %ebp
leaq -0x38(%rbx), %rdi
callq 0x81f0
movq %rax, %rdi
callq 0x36a0
movq %rax, %r14
cmpl $0xc, %ebp
je 0x3e51
cmpl $0x2, %ebp
je 0x3def
testl %ebp, %ebp
jne 0x3ddb
testq %r14, %r14
je 0x3e51
addq $-0x28, %rbx
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x3e75
movq %r15, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x3e51
movl $0x1, %edi
callq 0x7840
testq %rax, %rax
je 0x3e51
movq %rax, %r12
leaq -0x178(%rbx), %rdi
movq %rax, 0x8(%rsp)
callq 0x8053
movq %r15, %rdi
movq %rax, %rsi
callq 0x6899
movq %rax, %rdi
callq 0x36a0
testq %rax, %rax
je 0x3e51
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x78e2
testb %al, %al
jne 0x3ddb
movq %r15, %rdi
callq 0x3740
movq %r14, %rdi
callq 0x3740
movq 0x9150(%rip), %rsi      # 0xcfb0
movq 0x8(%rsp), %rdi
callq 0x7896
addq $-0x28, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52b4
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_mkdir
static void command_mkdir(struct commandexecutor *commandexecutor, char *dirname)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(mkdir(dirname, 0777) == 0) {
		dirmodel_notify_file_added_or_changed(&app->model, dirname);
		dirmodel_notify_flush(&app->model);
		select_filename(app, dirname);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3130
testl %eax, %eax
je 0x3eae
popq %rbx
popq %r14
popq %r15
retq
leaq -0x178(%r14), %r15
addq $-0x150, %r14           # imm = 0xFEB0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6561
movq %r14, %rdi
callq 0x65d7
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x5112
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_cmdline
static void command_cmdline(struct commandexecutor *commandexecutor, char *command)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	app->mode = MODE_COMMAND;
	curs_set(1);
	commandline_start(&app->commandline, L':');

	if(command != NULL) {
		size_t length = mbstowcs(NULL, command, 0);
		if(length != (size_t)-1) {
			wchar_t buffer[length + 1];
			mbstowcs(buffer, command, length);

			for(size_t i = 0; i < length; i++)
				commandline_handlekey(&app->commandline, buffer[i], false);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, 0x44(%rdi)
movl $0x1, %edi
callq 0x3140
addq $-0x80, %rbx
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x565a
testq %r15, %r15
je 0x3f76
xorl %edi, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x31a0
cmpq $-0x1, %rax
je 0x3f76
movq %rax, %r14
movq %rsp, %r13
movq %rsp, %r12
leaq 0x13(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r12
movq %r12, %rsp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x31a0
testq %r14, %r14
je 0x3f73
xorl %r15d, %r15d
movl (%r12,%r15,4), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58b9
incq %r15
cmpq %r15, %r14
jne 0x3f5d
movq %r13, %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_rename
static void command_rename(struct commandexecutor *commandexecutor, char *newfilename)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	const char *filename = dirmodel_getfilename(&app->model, index);

	if(rename(filename, newfilename) == 0) {
		dirmodel_notify_file_deleted(&app->model, filename);
		dirmodel_notify_file_added_or_changed(&app->model, newfilename);
		dirmodel_notify_flush(&app->model);
		select_filename(app, newfilename);
		if(app->mode == MODE_NORMAL)
			refresh_statusbar(app);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x150(%rdi), %r12
movq %r12, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x4003
leaq -0x178(%rbx), %r15
movq %r15, %rdi
callq 0x8053
movq %r12, %rdi
movq %rax, %rsi
callq 0x6899
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x3630
testl %eax, %eax
jne 0x4003
movq %r12, %rdi
movq %r13, %rsi
callq 0x6454
movq %r12, %rdi
movq %r14, %rsi
callq 0x6561
movq %r12, %rdi
callq 0x65d7
movq %r15, %rdi
movq %r14, %rsi
callq 0x5112
cmpl $0x0, 0x44(%rbx)
je 0x400d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4d86
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_search_next
static void command_search_next(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	if(!app->lastsearch_regex)
		return;

	size_t index = listview_getindex(&app->view);

	index = dirmodel_regex_getnext(&app->model, app->lastsearch_regex, index, app->lastsearch_direction);

	listview_setindex(&app->view, index);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0x4084
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x178(%rdi), %r14
movq %r14, %rdi
callq 0x8053
leaq -0x150(%rbx), %rdi
movq 0x50(%rbx), %rsi
movl 0x58(%rbx), %ecx
movq %rax, %rdx
callq 0x61ca
movq %r14, %rdi
movq %rax, %rsi
callq 0x804a
movq %r14, %rdi
callq 0x7d78
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d86
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: command_sort
static void command_sort(struct commandexecutor *commandexecutor, char *mode_string)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	enum dirmodel_sort_mode mode;
	if(strcmp(mode_string, "name+") == 0)
		mode = DIRMODEL_FILENAME;
	else if(strcmp(mode_string, "name-") == 0)
		mode = DIRMODEL_FILENAME_DESCENDING;
	else if(strcmp(mode_string, "size+") == 0)
		mode = DIRMODEL_SIZE;
	else if(strcmp(mode_string, "size-") == 0)
		mode = DIRMODEL_SIZE_DESCENDING;
	else if(strcmp(mode_string, "mtime+") == 0)
		mode = DIRMODEL_MTIME;
	else if(strcmp(mode_string, "mtime-") == 0)
		mode = DIRMODEL_MTIME_DESCENDING;
	else
		return;
	dirmodel_set_sort_mode(&app->model, mode);
	enter_directory(app, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50bc(%rip), %rsi      # 0x918b
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4142
leaq 0x50af(%rip), %rsi      # 0x9191
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4146
leaq 0x50a2(%rip), %rsi      # 0x9197
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x414d
leaq 0x5095(%rip), %rsi      # 0x919d
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4154
leaq 0x5088(%rip), %rsi      # 0x91a3
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x415b
leaq 0x507c(%rip), %rsi      # 0x91aa
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4162
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %esi, %esi
jmp 0x4167
movl $0x1, %esi
jmp 0x4167
movl $0x2, %esi
jmp 0x4167
movl $0x3, %esi
jmp 0x4167
movl $0x4, %esi
jmp 0x4167
movl $0x5, %esi
leaq -0x178(%rbx), %r14
addq $-0x150, %rbx           # imm = 0xFEB0
movq %rbx, %rdi
callq 0x643f
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b4e
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: handle_stdin
static void handle_stdin(struct application *app)
{
	wint_t key;
	int ret;

	ret = wget_wch(app->status, &key);
	if(ret == ERR)
		return;

	if(app->mode == MODE_COMMAND) {
		if(ret != KEY_CODE_YES && key == L'\n') {
			app->mode = MODE_NORMAL;
			curs_set(0);
			refresh_statusbar(app);

			const wchar_t *wcommand = commandline_getcommand(&app->commandline);
			char command[wcstombs(NULL, wcommand, 0) + 1];
			wcstombs(command, wcommand, sizeof(command));
			commandexecutor_execute(&app->commandexecutor, command);
			commandline_history_add(&app->commandline, wcommand);
		} else if(ret != KEY_CODE_YES && key == L'\t') {
		} else if(ret != KEY_CODE_YES && key == 27) {
			ret = wget_wch(app->status, &key);
			if(ret == ERR) {
				app->mode = MODE_NORMAL;
				curs_set(0);
				werase(app->status);
				wrefresh(app->status);
				return;
			}
			if(ret != KEY_CODE_YES && key == L'\n')
				insert_current_file_into_commandline(app);
		} else
			commandline_handlekey(&app->commandline, key, ret == KEY_CODE_YES ? true : false);

	} else
		keymap_handlekey(&app->keymap, key, ret == KEY_CODE_YES ? true : false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf0(%rdi), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3720
cmpl $-0x1, %eax
je 0x470f
cmpl $0x1, 0x1bc(%rbx)
movl -0x2c(%rbp), %esi
jne 0x46f6
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0xa, %esi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x471e
movl $0x0, 0x1bc(%rbx)
xorl %edi, %edi
callq 0x3140
movq %rbx, %rdi
callq 0x4d86
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x5cf6
movq %rax, %r15
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3660
movq %rsp, %r13
leaq 0x1(%rax), %rdx
addq $0x10, %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3660
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
movq %r12, %rsi
callq 0x55ea
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d3c
movq %r13, %rsp
jmp 0x470f
addq $0x168, %rbx            # imm = 0x168
xorl %edx, %edx
cmpl $0x100, %eax            # imm = 0x100
sete %dl
movq %rbx, %rdi
callq 0x6cc4
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0x9, %esi
sete %dl
testb %dl, %cl
jne 0x470f
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0x1b, %esi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4771
movq 0xf0(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3720
cmpl $-0x1, %eax
je 0x478c
cmpl $0x100, %eax            # imm = 0x100
je 0x470f
cmpl $0xa, -0x2c(%rbp)
jne 0x470f
movq %rbx, %rdi
callq 0x51ac
jmp 0x470f
addq $0xf8, %rbx
xorl %edx, %edx
cmpl $0x100, %eax            # imm = 0x100
sete %dl
movq %rbx, %rdi
callq 0x58b9
jmp 0x470f
movl $0x0, 0x1bc(%rbx)
xorl %edi, %edi
callq 0x3140
movq 0xf0(%rbx), %rdi
callq 0x30e0
movq 0xf0(%rbx), %rdi
callq 0x3390
jmp 0x470f
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: enter_directory
static bool enter_directory(struct application *app, const char *oldpathname)
{
	while(1) {
		const char *cwd = path_tocstr(&app->cwd);

		if(app->inotify_fd != -1) {
			if(app->inotify_watch != -1)
				inotify_rm_watch(app->inotify_fd, app->inotify_watch);

			app->inotify_watch = inotify_add_watch(app->inotify_fd, cwd,
				IN_CREATE |
				IN_ATTRIB |
				IN_DELETE |
				IN_MOVED_FROM |
				IN_MOVED_TO |
				IN_MODIFY |
				IN_EXCL_UNLINK
				);
		}

		if(chdir(cwd) == 0 && dirmodel_change_directory(&app->model, cwd))
			break;

		if(strcmp(cwd, "/") == 0) {
			puts("Cannot even open \"/\", exiting");
			app->running = false;
			return false;
		}
		path_remove_component(&app->cwd, &oldpathname);
	}

	update_terminal_title(app);
	select_stored_position(app, oldpathname);
	display_current_path(app);
	refresh_statusbar(app);
	listview_refresh(&app->view);

	app->inotify_cookie = 0;

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r15
movq %rsi, (%r15)
leaq 0x140(%rdi), %r14
leaq 0x28(%rdi), %r12
leaq 0x463d(%rip), %r13      # 0x91b1
movq %r14, %rdi
callq 0x81f0
movq %rax, %rbp
movl 0x1b0(%rbx), %edi
cmpl $-0x1, %edi
je 0x4bb3
movl 0x1b4(%rbx), %esi
cmpl $-0x1, %esi
je 0x4b9a
callq 0x36b0
movl 0x1b0(%rbx), %edi
movq %rbp, %rsi
movl $0x40003c6, %edx        # imm = 0x40003C6
callq 0x34b0
movl %eax, 0x1b4(%rbx)
movq %rbp, %rdi
callq 0x3250
testl %eax, %eax
jne 0x4bd3
movq %r12, %rdi
movq %rbp, %rsi
callq 0x68d6
movl $0x3, %ecx
testb %al, %al
jne 0x4c09
movq %rbp, %rdi
movq %r13, %rsi
callq 0x33d0
testl %eax, %eax
je 0x4bf1
movq %r14, %rdi
movq %r15, %rsi
callq 0x82b2
xorl %ecx, %ecx
jmp 0x4c09
leaq 0x45bb(%rip), %rdi      # 0x91b3
callq 0x3160
movb $0x0, 0x1c0(%rbx)
movl $0x1, %ecx
testl %ecx, %ecx
je 0x4b74
cmpl $0x1, %ecx
jne 0x4c1d
xorl %eax, %eax
jmp 0x4ce3
leaq 0x45ad(%rip), %rdi      # 0x91d1
callq 0x31f0
testl %eax, %eax
je 0x4c8c
leaq 0x45a0(%rip), %rdi      # 0x91d4
callq 0x35f0
movq %rax, %rdi
callq 0x3510
leaq 0x4590(%rip), %rdi      # 0x91d8
callq 0x3510
movq %r14, %rdi
callq 0x81f0
movq %rax, %rdi
callq 0x3510
leaq 0x457a(%rip), %rdi      # 0x91de
callq 0x3510
leaq 0x4570(%rip), %rdi      # 0x91e0
callq 0x35f0
movq %rax, %rdi
callq 0x3510
movq 0x8344(%rip), %rax      # 0xcfc8
movq (%rax), %rdi
callq 0x34a0
movq (%rsp), %rsi
testq %rsi, %rsi
jne 0x4cb2
movq 0xe0(%rbx), %r15
movq %r14, %rdi
callq 0x81f0
movq %r15, %rdi
movq %rax, %rsi
callq 0x602c
movq %rax, %rsi
testq %rsi, %rsi
je 0x4cbf
movq %rbx, %rdi
callq 0x5112
movq %rbx, %rdi
callq 0x5256
movq %rbx, %rdi
callq 0x4d86
movq %rbx, %rdi
callq 0x7d78
movl $0x0, 0x1b8(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: application_destroy
void application_destroy(struct application *app)
{
	free((void*)app->lastsearch_regex);
	listview_destroy(&app->view);
	path_destroy(&app->cwd);
	commandline_destroy(&app->commandline);
	if(app->status)
		delwin(app->status);
	if(app->pathbar)
		delwin(app->pathbar);
	dict_delete(app->stored_positions, true);
	dirmodel_destroy(&app->model);
	keymap_destroy(&app->keymap);
	clipboard_destroy(&app->clipboard);
	processmanager_destroy(&app->pm);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1c8(%rdi), %rdi
callq 0x3740
movq %rbx, %rdi
callq 0x81c9
leaq 0x140(%rbx), %rdi
callq 0x84cf
leaq 0xf8(%rbx), %rdi
callq 0x5edc
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x4d33
callq 0x31e0
movq 0xe8(%rbx), %rdi
testq %rdi, %rdi
je 0x4d44
callq 0x31e0
movq 0xe0(%rbx), %rdi
movl $0x1, %esi
callq 0x5f17
leaq 0x28(%rbx), %rdi
callq 0x6c9a
leaq 0x168(%rbx), %rdi
callq 0x6fcb
leaq 0x150(%rbx), %rdi
callq 0x53c4
addq $0x180, %rbx            # imm = 0x180
movq %rbx, %rdi
popq %rbx
jmp 0x8674
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: save_current_position
static void save_current_position(struct application *app)
{
	if(listmodel_count(&app->model.listmodel) != 0) {
		free(dict_get(app->stored_positions, path_tocstr(&app->cwd)));

		size_t index = listview_getindex(&app->view);
		const char *filename = dirmodel_getfilename(&app->model, index);

		char *filename_copy = strdup(filename);
		if(filename_copy == NULL)
			return;
		if(!dict_set(app->stored_positions, path_tocstr(&app->cwd), filename_copy))
			free(filename_copy);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r15
movq %r15, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x5064
movq 0xe0(%rbx), %r12
leaq 0x140(%rbx), %r14
movq %r14, %rdi
callq 0x81f0
movq %r12, %rdi
movq %rax, %rsi
callq 0x602c
movq %rax, %rdi
callq 0x3740
movq %rbx, %rdi
callq 0x8053
movq %r15, %rdi
movq %rax, %rsi
callq 0x6899
movq %rax, %rdi
callq 0x36a0
testq %rax, %rax
je 0x5064
movq %rax, %r15
movq 0xe0(%rbx), %rbx
movq %r14, %rdi
callq 0x81f0
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x5f82
testb %al, %al
je 0x5070
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3740
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: unblock_signals
static void unblock_signals(void)
{
	sigset_t sigset;

	sigemptyset(&sigset);
	sigaddset(&sigset, SIGWINCH);
	sigaddset(&sigset, SIGCHLD);
	sigaddset(&sigset, SIGALRM);
	sigprocmask(SIG_UNBLOCK, &sigset, NULL);
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x3400
movq %rbx, %rdi
movl $0x1c, %esi
callq 0x36e0
movq %rbx, %rdi
movl $0x11, %esi
callq 0x36e0
movq %rbx, %rdi
movl $0xe, %esi
callq 0x36e0
movl $0x1, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x30a0
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: background_process_and_unblock_signals
static void background_process_and_unblock_signals(void)
{
	int fd = open("/dev/null", O_RDWR);
	dup2(fd, 0);
	dup2(fd, 1);
	dup2(fd, 2);

	unblock_signals();
}

// Assembly:
pushq %rbx
leaq 0x40a4(%rip), %rdi      # 0x9181
movl $0x2, %esi
xorl %eax, %eax
callq 0x3600
movl %eax, %ebx
movl %eax, %edi
xorl %esi, %esi
callq 0x3270
movl %ebx, %edi
movl $0x1, %esi
callq 0x3270
movl %ebx, %edi
movl $0x2, %esi
callq 0x3270
popq %rbx
jmp 0x5083
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: select_filename
static void select_filename(struct application *app, const char *filename)
{
	size_t index;

	if(!dirmodel_get_index(&app->model, filename, &index))
		return;
	if(index == listmodel_count(&app->model.listmodel))
		index--;
	listview_setindex(&app->view, index);
	listview_refresh(&app->view);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x61bc
testb %al, %al
je 0x515f
movq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x7c0c
cmpq %rax, %r15
jne 0x514a
decq 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x804a
movq %rbx, %rdi
callq 0x7d78
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: search
static void search(struct application *app, const char *regex, int direction)
{
	free((void*)app->lastsearch_regex);
	app->lastsearch_regex = strdup(regex);
	app->lastsearch_direction = direction;

	command_search_next(&app->commandexecutor, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq 0x1c8(%rdi), %rdi
callq 0x3740
movq %r14, %rdi
callq 0x36a0
movq %rax, 0x1c8(%r15)
movl %ebx, 0x1d0(%r15)
addq $0x178, %r15            # imm = 0x178
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x402f
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: insert_current_file_into_commandline
static void insert_current_file_into_commandline(struct application *app)
{
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	const char *filename = dirmodel_getfilename(&app->model, index);
	size_t length = mbstowcs(NULL, filename, 0);

	if(length != (size_t)-1) {
		wchar_t buffer[length + 1];
		mbstowcs(buffer, filename, length);

		for(size_t i = 0; i < length; i++)
			commandline_handlekey(&app->commandline, buffer[i], false);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq %r14, %rdi
callq 0x7c0c
testq %rax, %rax
je 0x5247
movq %rbx, %rdi
callq 0x8053
movq %r14, %rdi
movq %rax, %rsi
callq 0x6899
movq %rax, %r12
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x31a0
cmpq $-0x1, %rax
je 0x5247
movq %rax, %r14
movq %rsp, %r13
movq %rsp, %r15
leaq 0x13(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x31a0
testq %r14, %r14
je 0x5244
addq $0xf8, %rbx
xorl %r12d, %r12d
movl (%r15,%r12,4), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58b9
incq %r12
cmpq %r12, %r14
jne 0x522e
movq %r13, %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/application.c
// Function: display_current_path
static void display_current_path(struct application *app)
{
	wmove(app->pathbar, 0, 0);
	werase(app->pathbar);
	wprintw(app->pathbar, "%s", path_tocstr(&app->cwd));
	wrefresh(app->pathbar);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3090
movq 0xe8(%rbx), %rdi
callq 0x30e0
movq 0xe8(%rbx), %r14
leaq 0x140(%rbx), %rdi
callq 0x81f0
leaq 0x3ec5(%rip), %rsi      # 0x9158
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3730
movq 0xe8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3390
nop
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/clipboard.c
// Function: clipboard_set_contents
bool clipboard_set_contents(struct clipboard *clipboard, const char *path, const struct list *filelist)
{
	if(clipboard->shared_clipboard_path) {
		int clipboard_dir_fd = open(clipboard->shared_clipboard_path, O_RDONLY);
		if(clipboard_dir_fd == -1) {
			free((void *)path);
			list_delete(filelist, free);
			return false;
		}

		unlinkat(clipboard_dir_fd, CLIPBOARD_PATH, 0);
		unlinkat(clipboard_dir_fd, CLIPBOARD_LIST, 0);
		bool ret = dump_contents_to_directory(clipboard_dir_fd, path, filelist);

		free((void *)path);
		list_delete(filelist, free);
		close(clipboard_dir_fd);

		return ret;
	} else {
		clipboard_destroy(clipboard);
		clipboard->path = path;
		clipboard->filelist = filelist;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5330
xorl %esi, %esi
xorl %eax, %eax
callq 0x3600
cmpl $-0x1, %eax
je 0x5353
movl %eax, %ebp
leaq 0x3f1c(%rip), %rsi      # 0x9200
movl %eax, %edi
xorl %edx, %edx
callq 0x3150
leaq 0x3f1b(%rip), %rsi      # 0x920f
movl %ebp, %edi
xorl %edx, %edx
callq 0x3150
movl %ebp, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5377
movl %eax, %r15d
movq %r14, %rdi
callq 0x3740
movq 0x7c94(%rip), %rsi      # 0xcfb0
movq %rbx, %rdi
callq 0x7896
movl %ebp, %edi
callq 0x3320
movl %r15d, %eax
jmp 0x536c
movq (%r15), %rdi
callq 0x3740
movq 0x7c71(%rip), %rsi      # 0xcfb0
movq 0x8(%r15), %rdi
callq 0x7896
movq %r14, (%r15)
movq %rbx, 0x8(%r15)
movb $0x1, %al
jmp 0x536c
movq %r14, %rdi
callq 0x3740
movq 0x7c4e(%rip), %rsi      # 0xcfb0
movq %rbx, %rdi
callq 0x7896
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/clipboard.c
// Function: dump_contents_to_directory
static bool dump_contents_to_directory(int dir_fd, const char *path, const struct list *filelist) {
	if(path && filelist) {
		if(!dump_string_to_file(dir_fd, CLIPBOARD_PATH, path))
			return false;

		if(!dump_filelist_to_file(dir_fd, CLIPBOARD_LIST, filelist))
			return false;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x53b7
movq %rsi, %rdx
movl %edi, %ebp
leaq 0x3e67(%rip), %rsi      # 0x9200
callq 0x8a33
testb %al, %al
je 0x53bb
leaq 0x3e66(%rip), %rsi      # 0x920f
movl %ebp, %edi
movq %rbx, %rdx
callq 0x8a81
testb %al, %al
je 0x53bb
movb $0x1, %al
jmp 0x53bd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/clipboard.c
// Function: clipboard_dump_contents_to_directory
bool clipboard_dump_contents_to_directory(struct clipboard *clipboard, int dir_fd)
{
	if(clipboard->shared_clipboard_path) {
		int clipboard_dir_fd = open(clipboard->shared_clipboard_path, O_RDONLY);
		if(clipboard_dir_fd == -1)
			return false;

		if((faccessat(clipboard_dir_fd, CLIPBOARD_PATH, F_OK, 0) != 0 &&
		    faccessat(clipboard_dir_fd, CLIPBOARD_LIST, F_OK, 0) != 0) ||
		   (linkat(clipboard_dir_fd, CLIPBOARD_PATH, dir_fd, CLIPBOARD_PATH, 0) == 0 &&
		    linkat(clipboard_dir_fd, CLIPBOARD_LIST, dir_fd, CLIPBOARD_LIST, 0) == 0)) {
			close(clipboard_dir_fd);
			return true;
		}
		close(clipboard_dir_fd);
		return false;
	} else {
		return dump_contents_to_directory(dir_fd, clipboard->path, clipboard->filelist);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %rax
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x5442
xorl %r14d, %r14d
xorl %esi, %esi
xorl %eax, %eax
callq 0x3600
cmpl $-0x1, %eax
je 0x5492
movl %eax, %ebp
leaq 0x3def(%rip), %rsi      # 0x9200
movl %eax, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3190
testl %eax, %eax
je 0x5454
leaq 0x3de8(%rip), %rsi      # 0x920f
movl %ebp, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3190
testl %eax, %eax
je 0x5454
movl %ebp, %edi
callq 0x3320
movb $0x1, %r14b
jmp 0x5492
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x5377
leaq 0x3da5(%rip), %rcx      # 0x9200
movl %ebp, %edi
movq %rcx, %rsi
movl %ebx, %edx
xorl %r8d, %r8d
callq 0x3550
testl %eax, %eax
jne 0x5488
leaq 0x3d9a(%rip), %rcx      # 0x920f
movl %ebp, %edi
movq %rcx, %rsi
movl %ebx, %edx
xorl %r8d, %r8d
callq 0x3550
testl %eax, %eax
je 0x5436
movl %ebp, %edi
callq 0x3320
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/commandexecutor.c
// Function: commandexecutor_verify
int commandexecutor_verify(struct commandexecutor *commandexecutor, const char *command) {
	command_ptr commandptr;
	char *param;

	char buffer[strlen(command) + 1];
	strcpy(buffer, command);

	return command_parse(buffer, &commandptr, &param, commandexecutor->commandmap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3230
movq %rsp, %r12
movq %rsp, %r15
addq $0x10, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3110
movq (%r14), %rcx
leaq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
callq 0x5507
movq %r12, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/commandexecutor.c
// Function: command_parse
static int command_parse(char *command, command_ptr *commandptr, char **param, struct command_map *commandmap)
{
	bool param_mandatory;
	bool characters_after_command = false;

	char *token = command;
	size_t length = strcspn(token, " \t");

	if(length > 0) {
		if(token[length] != '\0')
			characters_after_command = true;
		token[length] = '\0';
		map_command(commandmap, token, commandptr, &param_mandatory);
		if(*commandptr == NULL)
			return EINVAL;
	} else
		return EINVAL;

	if(characters_after_command) {
		token = token + length + 1 + strspn(token + length + 1, " \t");
		if(token[0] != '\0') {
			*param = token;
			return 0;
		}
	}

	*param = NULL;
	if(param_mandatory)
		return EINVAL;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x3cf6(%rip), %rsi      # 0x921e
callq 0x33a0
movl $0x16, %ebp
testq %rax, %rax
je 0x55d9
movq %rax, %r15
movq %rbx, 0x10(%rsp)
movb (%r14,%rax), %al
movb $0x0, (%r14,%r15)
movq $0x0, (%r12)
movq (%r13), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x559d
movb %al, 0xf(%rsp)
addq $0x18, %r13
movq %r14, %rsi
callq 0x33d0
testl %eax, %eax
je 0x5582
movq (%r13), %rdi
addq $0x18, %r13
testq %rdi, %rdi
jne 0x5567
jmp 0x5599
movq -0x10(%r13), %rax
movq %rax, (%r12)
xorl %eax, %eax
cmpb $0x0, -0x8(%r13)
movl $0x16, %ebx
cmovel %eax, %ebx
movb 0xf(%rsp), %al
cmpq $0x0, (%r12)
je 0x55d9
testb %al, %al
je 0x55cd
addq %r15, %r14
leaq 0x1(%r14), %rdi
leaq 0x3c68(%rip), %rsi      # 0x921e
callq 0x3340
cmpb $0x0, 0x1(%r14,%rax)
je 0x55cd
addq %r14, %rax
incq %rax
xorl %ebx, %ebx
jmp 0x55cf
xorl %eax, %eax
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movl %ebx, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cglindkamp[P]dfm/src/commandexecutor.c
// Function: commandexecutor_execute
int commandexecutor_execute(struct commandexecutor *commandexecutor, char *command) {
	command_ptr commandptr;
	char *param;

	int ret = command_parse(command, &commandptr, &param, commandexecutor->commandmap);
	if(ret == 0)
		commandptr(commandexecutor, param);
	else
		return ret;
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rax, %rdi
callq 0x5507
testl %eax, %eax
jne 0x5619
movq (%rsp), %rsi
movq %rbx, %rdi
callq *0x8(%rsp)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq