LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: rmtree_helper
static int rmtree_helper(const char *fpath, const struct stat *sb,
    int typeflag, struct FTW *ftwbuf)
{
  if (S_ISDIR(sb->st_mode))
    {
      if (rmdir(fpath) < 0)
	die("Cannot rmdir %s: %m", fpath);
    }
  else
    {
      if (unlink(fpath) < 0)
	die("Cannot unlink %s: %m", fpath);
    }
  return FTW_CONTINUE;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x471f
movq 0x20(%rsp), %rdi
callq 0x2170
cmpl $0x0, %eax
jge 0x471d
movq 0x20(%rsp), %rsi
leaq 0x2b88(%rip), %rdi      # 0x729e
movb $0x0, %al
callq 0x2ed0
jmp 0x4743
movq 0x20(%rsp), %rdi
callq 0x2070
cmpl $0x0, %eax
jge 0x4741
movq 0x20(%rsp), %rsi
leaq 0x2b78(%rip), %rdi      # 0x72b2
movb $0x0, %al
callq 0x2ed0
jmp 0x4743
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: find_device
static char *
find_device(char *path)
{
  FILE *f = setmntent("/proc/mounts", "r");
  if (!f)
    die("Cannot open /proc/mounts: %m");

  struct mntent *me;
  int best_len = 0;
  char *best_dev = NULL;
  while (me = getmntent(f))
    {
      if (!path_begins_with(me->mnt_fsname, "/dev"))
	continue;
      if (path_begins_with(path, me->mnt_dir))
	{
	  int len = strlen(me->mnt_dir);
	  if (len > best_len)
	    {
	      best_len = len;
	      free(best_dev);
	      best_dev = xstrdup(me->mnt_fsname);
	    }
	}
    }
  endmntent(f);
  return best_dev;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
leaq 0x2b6d(%rip), %rdi      # 0x753d
leaq 0x1b0d(%rip), %rsi      # 0x64e4
callq 0x2390
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x49f7
leaq 0x2b5a(%rip), %rdi      # 0x754a
movb $0x0, %al
callq 0x2ed0
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2380
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x4a97
movq 0x20(%rsp), %rax
movq (%rax), %rdi
leaq 0x2b3b(%rip), %rsi      # 0x7567
callq 0x4ab0
cmpl $0x0, %eax
jne 0x4a38
jmp 0x4a08
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x4ab0
cmpl $0x0, %eax
je 0x4a92
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2180
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jle 0x4a90
movl 0xc(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2030
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x3390
movq %rax, 0x10(%rsp)
jmp 0x4a92
jmp 0x4a08
movq 0x28(%rsp), %rdi
callq 0x2040
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: path_begins_with
static int
path_begins_with(char *path, char *with)
{
  while (*with)
    if (*path++ != *with++)
      return 0;
  return (!*with || *with == '/');
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpb $0x0, (%rax)
je 0x4afc
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rsp)
movsbl (%rax), %eax
movq -0x18(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x4afa
movl $0x0, -0x4(%rsp)
jmp 0x4b2b
jmp 0x4aba
movq -0x18(%rsp), %rcx
movb $0x1, %al
cmpb $0x0, (%rcx)
movb %al, -0x19(%rsp)
je 0x4b1e
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: box_inside
static int
box_inside(void *arg)
{
  char **args = arg;
  write_errors_to_fd = error_pipes[1];
  close(error_pipes[0]);
  meta_close();

  cg_enter();
  setup_root();
  setup_credentials();
  setup_fds();
  setup_rlimits();
  char **env = setup_environment();

  if (set_cwd && chdir(set_cwd))
    die("chdir: %m");

  execve(args[0], args, env);
  die("execve(\"%s\"): %m", args[0]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x5d3b(%rip), %eax      # 0xa884
movl %eax, 0x57e9(%rip)      # 0xa338
movl 0x5d2b(%rip), %edi      # 0xa880
callq 0x2280
callq 0x3900
callq 0x4f70
callq 0x5090
callq 0x5170
callq 0x51f0
callq 0x52d0
callq 0x53b0
movq %rax, (%rsp)
cmpq $0x0, 0x572f(%rip)      # 0xa2b8
je 0x4baa
movq 0x5726(%rip), %rdi      # 0xa2b8
callq 0x21a0
cmpl $0x0, %eax
je 0x4baa
leaq 0x2a2d(%rip), %rdi      # 0x75d0
movb $0x0, %al
callq 0x2ed0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x22d0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x2a0b(%rip), %rdi      # 0x75da
movb $0x0, %al
callq 0x2ed0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_enter
static void
cg_enter(void)
{
  if (!cg_enable)
    return;

  msg("Entering control group %s\n", cg_name);

  FOREACH_CG_CONTROLLER(controller)
    {
      if (cg_controller_optional(controller))
	cg_write(controller, "?tasks", "%d\n", (int) getpid());
      else
	cg_write(controller, "tasks", "%d\n", (int) getpid());
    }

  if (cg_memory_limit)
    {
      cg_write(CG_MEMORY, "memory.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
      cg_write(CG_MEMORY, "?memory.memsw.limit_in_bytes", "%lld\n", (long long) cg_memory_limit << 10);
    }

  if (cg_timing)
    cg_write(CG_CPUACCT, "cpuacct.usage", "0\n");
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x5345(%rip)      # 0xa2c0
jne 0x4f82
jmp 0x5085
leaq 0x2662(%rip), %rdi      # 0x75eb
leaq 0x53d0(%rip), %rsi      # 0xa360
movb $0x0, %al
callq 0x4090
movl $0x0, 0x14(%rsp)
cmpl $0x3, 0x14(%rsp)
jae 0x5015
movl 0x14(%rsp), %edi
callq 0x4750
cmpl $0x0, %eax
je 0x4fde
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0x2130
movl 0x10(%rsp), %edi
movl %eax, %ecx
leaq 0x2638(%rip), %rsi      # 0x7606
leaq 0x2564(%rip), %rdx      # 0x7539
movb $0x0, %al
callq 0x4770
jmp 0x5006
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x2130
movl 0xc(%rsp), %edi
movl %eax, %ecx
leaq 0x260f(%rip), %rsi      # 0x7607
leaq 0x253a(%rip), %rdx      # 0x7539
movb $0x0, %al
callq 0x4770
jmp 0x5008
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4f9f
cmpl $0x0, 0x52ec(%rip)      # 0xa308
je 0x5062
movslq 0x52e3(%rip), %rcx      # 0xa308
shlq $0xa, %rcx
xorl %edi, %edi
leaq 0x25db(%rip), %rsi      # 0x760d
leaq 0x215d(%rip), %rdx      # 0x7196
movb $0x0, %al
callq 0x4770
movslq 0x52c1(%rip), %rcx      # 0xa308
shlq $0xa, %rcx
xorl %edi, %edi
leaq 0x25cf(%rip), %rsi      # 0x7623
leaq 0x213b(%rip), %rdx      # 0x7196
movb $0x0, %al
callq 0x4770
cmpl $0x0, 0x52a3(%rip)      # 0xa30c
je 0x5085
movl $0x1, %edi
leaq 0x201f(%rip), %rsi      # 0x7096
leaq 0x1e82(%rip), %rdx      # 0x6f00
movb $0x0, %al
callq 0x4770
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: setup_root
static void
setup_root(void)
{
  if (mkdir("root", 0750) < 0 && errno != EEXIST)
    die("mkdir('root'): %m");

  /*
   * Ensure all mounts are private, not shared. We don't want our mounts
   * appearing outside of our namespace.
   * (systemd since version 188 mounts filesystems shared by default).
   */
  if (mount(NULL, "/", NULL, MS_REC|MS_PRIVATE, NULL) < 0)
    die("Cannot privatize mounts: %m");

  if (mount("none", "root", "tmpfs", 0, "mode=755") < 0)
    die("Cannot mount root ramdisk: %m");

  apply_dir_rules();

  if (chroot("root") < 0)
    die("Chroot failed: %m");

  if (chdir("root/box") < 0)
    die("Cannot change current directory: %m");
}

// Assembly:
pushq %rax
leaq 0x1379(%rip), %rdi      # 0x6411
movl $0x1e8, %esi            # imm = 0x1E8
callq 0x20b0
cmpl $0x0, %eax
jge 0x50bf
callq 0x2060
cmpl $0x11, (%rax)
je 0x50bf
leaq 0x2588(%rip), %rdi      # 0x7640
movb $0x0, %al
callq 0x2ed0
xorl %eax, %eax
movl %eax, %r8d
leaq 0x14e0(%rip), %rsi      # 0x65ab
movl $0x44000, %ecx          # imm = 0x44000
movq %r8, %rdi
movq %r8, %rdx
callq 0x2190
cmpl $0x0, %eax
jge 0x50ee
leaq 0x256b(%rip), %rdi      # 0x7652
movb $0x0, %al
callq 0x2ed0
leaq 0x2579(%rip), %rdi      # 0x766e
leaq 0x1315(%rip), %rsi      # 0x6411
leaq 0x2570(%rip), %rdx      # 0x7673
xorl %eax, %eax
movl %eax, %ecx
leaq 0x256b(%rip), %r8       # 0x7679
callq 0x2190
cmpl $0x0, %eax
jge 0x5126
leaq 0x2563(%rip), %rdi      # 0x7682
movb $0x0, %al
callq 0x2ed0
callq 0x55b0
leaq 0x12df(%rip), %rdi      # 0x6411
callq 0x20a0
cmpl $0x0, %eax
jge 0x514a
leaq 0x255d(%rip), %rdi      # 0x76a0
movb $0x0, %al
callq 0x2ed0
leaq 0x2561(%rip), %rdi      # 0x76b2
callq 0x21a0
cmpl $0x0, %eax
jge 0x5169
leaq 0x2559(%rip), %rdi      # 0x76bb
movb $0x0, %al
callq 0x2ed0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: setup_credentials
static void
setup_credentials(void)
{
  if (setresgid(box_gid, box_gid, box_gid) < 0)
    die("setresgid: %m");
  if (setgroups(0, NULL) < 0)
    die("setgroups: %m");
  if (setresuid(box_uid, box_uid, box_uid) < 0)
    die("setresuid: %m");
  setpgrp();
}

// Assembly:
pushq %rax
movl 0x5305(%rip), %edi      # 0xa47c
movl 0x52ff(%rip), %esi      # 0xa47c
movl 0x52f9(%rip), %edx      # 0xa47c
callq 0x21c0
cmpl $0x0, %eax
jge 0x519b
leaq 0x25ed(%rip), %rdi      # 0x7781
movb $0x0, %al
callq 0x2ed0
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x2290
cmpl $0x0, %eax
jge 0x51ba
leaq 0x25dc(%rip), %rdi      # 0x778f
movb $0x0, %al
callq 0x2ed0
movl 0x52b8(%rip), %edi      # 0xa478
movl 0x52b2(%rip), %esi      # 0xa478
movl 0x52ac(%rip), %edx      # 0xa478
callq 0x2140
cmpl $0x0, %eax
jge 0x51e4
leaq 0x25c0(%rip), %rdi      # 0x779d
movb $0x0, %al
callq 0x2ed0
callq 0x2490
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: setup_fds
static void
setup_fds(void)
{
  if (redir_stdin)
    {
      close(0);
      if (open(redir_stdin, O_RDONLY) != 0)
	die("open(\"%s\"): %m", redir_stdin);
    }
  if (redir_stdout)
    {
      close(1);
      if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
	die("open(\"%s\"): %m", redir_stdout);
    }
  if (redir_stderr)
    {
      close(2);
      if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
	die("open(\"%s\"): %m", redir_stderr);
    }
  else
    dup2(1, 2);
}

// Assembly:
pushq %rax
cmpq $0x0, 0x50d7(%rip)      # 0xa2d0
je 0x522e
xorl %edi, %edi
callq 0x2280
movq 0x50c7(%rip), %rdi      # 0xa2d0
xorl %esi, %esi
movb $0x0, %al
callq 0x2400
cmpl $0x0, %eax
je 0x522c
movq 0x50b2(%rip), %rsi      # 0xa2d0
leaq 0x2586(%rip), %rdi      # 0x77ab
movb $0x0, %al
callq 0x2ed0
jmp 0x522e
cmpq $0x0, 0x50aa(%rip)      # 0xa2e0
je 0x5276
movl $0x1, %edi
callq 0x2280
movq 0x5097(%rip), %rdi      # 0xa2e0
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x2400
cmpl $0x1, %eax
je 0x5274
movq 0x507a(%rip), %rsi      # 0xa2e0
leaq 0x253e(%rip), %rdi      # 0x77ab
movb $0x0, %al
callq 0x2ed0
jmp 0x5276
cmpq $0x0, 0x5072(%rip)      # 0xa2f0
je 0x52be
movl $0x2, %edi
callq 0x2280
movq 0x505f(%rip), %rdi      # 0xa2f0
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x2400
cmpl $0x2, %eax
je 0x52bc
movq 0x5042(%rip), %rsi      # 0xa2f0
leaq 0x24f6(%rip), %rdi      # 0x77ab
movb $0x0, %al
callq 0x2ed0
jmp 0x52cd
movl $0x1, %edi
movl $0x2, %esi
callq 0x21e0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: setup_rlimits
static void
setup_rlimits(void)
{
#define RLIM(res, val) setup_rlim("RLIMIT_" #res, RLIMIT_##res, val)

  if (memory_limit)
    RLIM(AS, (rlim_t)memory_limit * 1024);

  RLIM(STACK, (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY));

  if(file_limit)
    RLIM(NOFILE, file_limit);

  if(fsize_limit)
    RLIM(FSIZE, (rlim_t)fsize_limit * 1024);

  RLIM(MEMLOCK, 0);

  if (max_processes)
    RLIM(NPROC, max_processes);

#undef RLIM
}

// Assembly:
pushq %rax
cmpl $0x0, 0x5000(%rip)      # 0xa2d8
je 0x52f6
movslq 0x4ff7(%rip), %rdx      # 0xa2d8
shlq $0xa, %rdx
leaq 0x24ce(%rip), %rdi      # 0x77ba
movl $0x9, %esi
callq 0x5860
cmpl $0x0, 0x4fcb(%rip)      # 0xa2c8
je 0x5310
movslq 0x4fc2(%rip), %rax      # 0xa2c8
shlq $0xa, %rax
movq %rax, (%rsp)
jmp 0x531d
movq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x531d
movq (%rsp), %rdx
leaq 0x249c(%rip), %rdi      # 0x77c4
movl $0x3, %esi
callq 0x5860
cmpl $0x0, 0x4fd7(%rip)      # 0xa310
je 0x5353
movslq 0x4fce(%rip), %rdx      # 0xa310
leaq 0x2488(%rip), %rdi      # 0x77d1
movl $0x7, %esi
callq 0x5860
cmpl $0x0, 0x4fba(%rip)      # 0xa314
je 0x5378
movslq 0x4fb1(%rip), %rdx      # 0xa314
shlq $0xa, %rdx
leaq 0x2471(%rip), %rdi      # 0x77df
movl $0x1, %esi
callq 0x5860
leaq 0x246d(%rip), %rdi      # 0x77ec
movl $0x8, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x5860
cmpl $0x0, 0x4ecc(%rip)      # 0xa260
je 0x53ae
movslq 0x4ec3(%rip), %rdx      # 0xa260
leaq 0x2457(%rip), %rdi      # 0x77fb
movl $0x6, %esi
callq 0x5860
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: check_timeout
static void
check_timeout(void)
{
  if (wall_timeout)
    {
      int wall_ms = get_wall_time_ms();
      if (wall_ms > wall_timeout)
        err("TO: Time limit exceeded (wall clock)");
      if (verbose > 1)
        fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
    }
  if (timeout)
    {
      int ms = get_run_time_ms(NULL);
      if (verbose > 1)
	fprintf(stderr, "[time check: %d msec]\n", ms);
      if (ms > timeout && ms > extra_timeout)
	err("TO: Time limit exceeded");
    }
}

// Assembly:
pushq %rax
cmpl $0x0, 0x4788(%rip)      # 0xa300
je 0x5bc4
callq 0x3bc0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x4773(%rip), %eax      # 0xa300
jle 0x5b9d
leaq 0x1d3d(%rip), %rdi      # 0x78d3
movb $0x0, %al
callq 0x5c30
cmpl $0x1, 0x4758(%rip)      # 0xa2fc
jle 0x5bc2
movq 0x444b(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl 0x4(%rsp), %edx
leaq 0x1ddb(%rip), %rsi      # 0x7996
movb $0x0, %al
callq 0x2300
jmp 0x5bc4
cmpl $0x0, 0x472d(%rip)      # 0xa2f8
je 0x5c23
xorl %eax, %eax
movl %eax, %edi
callq 0x3930
movl %eax, (%rsp)
cmpl $0x1, 0x471c(%rip)      # 0xa2fc
jle 0x5bfd
movq 0x440f(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movl (%rsp), %edx
leaq 0x1dbc(%rip), %rsi      # 0x79b2
movb $0x0, %al
callq 0x2300
movl (%rsp), %eax
cmpl 0x46f2(%rip), %eax      # 0xa2f8
jle 0x5c21
movl (%rsp), %eax
cmpl 0x46f3(%rip), %eax      # 0xa304
jle 0x5c21
leaq 0x1ca1(%rip), %rdi      # 0x78bb
movb $0x0, %al
callq 0x5c30
jmp 0x5c23
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/isolate/isolate.c
// Function: cg_remove
static void
cg_remove(void)
{
  char buf[CG_BUFSIZE];

  if (!cg_enable)
    return;

  FOREACH_CG_CONTROLLER(controller)
    {
      if (cg_controller_optional(controller)) {
	if (!cg_read(controller, "?tasks", buf))
	  continue;
      } else
	cg_read(controller, "tasks", buf);

      if (buf[0])
	die("Some tasks left in controller %s of cgroup %s, failed to remove it",
	    cg_controller_name(controller), cg_name);

      char path[256];
      cg_makepath(path, sizeof(path), controller, "");

      if (rmdir(path) < 0)
	die("Cannot remove control group %s: %m", path);
    }
}

// Assembly:
subq $0x518, %rsp            # imm = 0x518
cmpl $0x0, 0x4502(%rip)      # 0xa2c0
jne 0x5dc5
jmp 0x5eb0
movl $0x0, 0x10c(%rsp)
cmpl $0x3, 0x10c(%rsp)
jae 0x5eb0
movl 0x10c(%rsp), %edi
callq 0x4750
cmpl $0x0, %eax
je 0x5e16
movl 0x10c(%rsp), %edi
leaq 0x110(%rsp), %rdx
leaq 0x1801(%rip), %rsi      # 0x7606
callq 0x3e60
cmpl $0x0, %eax
jne 0x5e14
jmp 0x5e9a
jmp 0x5e31
movl 0x10c(%rsp), %edi
leaq 0x110(%rsp), %rdx
leaq 0x17db(%rip), %rsi      # 0x7607
callq 0x3e60
cmpb $0x0, 0x110(%rsp)
je 0x5e5f
movl 0x10c(%rsp), %edi
callq 0x41a0
movq %rax, %rsi
leaq 0x1bdb(%rip), %rdi      # 0x7a2c
leaq 0x4508(%rip), %rdx      # 0xa360
movb $0x0, %al
callq 0x2ed0
movq %rsp, %rdi
movl 0x10c(%rsp), %edx
movl $0x100, %esi            # imm = 0x100
leaq 0x1aab(%rip), %rcx      # 0x7920
callq 0x4010
movq %rsp, %rdi
callq 0x2170
cmpl $0x0, %eax
jge 0x5e98
movq %rsp, %rsi
leaq 0x1bde(%rip), %rdi      # 0x7a6f
movb $0x0, %al
callq 0x2ed0
jmp 0x5e9a
movl 0x10c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10c(%rsp)
jmp 0x5dd0
addq $0x518, %rsp            # imm = 0x518
retq
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/obstcp-keygen.c
// Function: reada
static char
reada(int fd, void *buffer, size_t count) {
  size_t done = 0;

  while (count) {
    ssize_t n;
    do {
      n = read(fd, ((uint8_t *) buffer) + done, count);
    } while (n == -1 && errno == EINTR);

    if (n < 1)
      return 0;
    done += n;
    count -= n;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1657
jmp 0x15f4
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10c0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x28(%rbp)
movb %al, -0x29(%rbp)
jne 0x1626
callq 0x1050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x15f4
cmpq $0x1, -0x28(%rbp)
jge 0x163a
movb $0x0, -0x1(%rbp)
jmp 0x165b
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x15eb
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-zoe/dat-extract.c
// Function: main
int main( int argc, char **argv ) {
	
	tocDirectoryEntry workdir;
	unsigned int tgsfix = 0;
	FILE *f;
	
	memset( workdir.name, 0, DIRNAMELENGTH );
	
	if ( argc < 2 ) {
		printf("Not enough args!\nUse: %s DAT-file\n", argv[0]);
		return 1;
	}
	if( argc == 3 ) tgsfix = 1;
	
	
	if( !(f = fopen( argv[1], "rb" ))) {
		printf("Couldnt open file %s\n", argv[1]);
		return 1;
	}
	fseek( f, 0, SEEK_SET );
	
	fread( &workdir, sizeof(workdir), 1, f );
	
	processDirectory( f, workdir, NULL, tgsfix );
	
	printf("Done.\n");
	
	fclose(f);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x1090
cmpl $0x2, -0x8(%rbp)
jge 0x1764
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x9d3(%rip), %rdi       # 0x2124
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x1828
cmpl $0x3, -0x8(%rbp)
jne 0x1771
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x9c7(%rip), %rsi       # 0x2147
callq 0x10d0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x17ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x939(%rip), %rdi       # 0x20d7
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
jmp 0x1828
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10c0
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x20, %esi
movl $0x1, %edx
callq 0x1050
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq -0x30(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x1530
leaq 0x939(%rip), %rdi       # 0x214a
movb $0x0, %al
callq 0x1080
movq -0x40(%rbp), %rdi
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/conmon.c
// Function: disconnect_std_streams
static void disconnect_std_streams(int dev_null_r, int dev_null_w)
{
	if (dup2(dev_null_r, STDIN_FILENO) < 0)
		pexit("Failed to dup over stdin");
	if (dup2(dev_null_w, STDOUT_FILENO) < 0)
		pexit("Failed to dup over stdout");
	if (dup2(dev_null_w, STDERR_FILENO) < 0)
		pexit("Failed to dup over stderr");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x4090
cmpl $0x0, %eax
jge 0x6b58
jmp 0x6aff
movq 0xf4ea(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x8503(%rip), %rsi      # 0xf013
leaq 0x8800(%rip), %rdx      # 0xf317
movb $0x0, %al
callq 0x4830
leaq 0x24423(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x6b4e
leaq 0x2440f(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x84fd(%rip), %rsi      # 0xf03d
leaq 0x87d0(%rip), %rcx      # 0xf317
movb $0x0, %al
callq 0x4120
movl $0x1, %edi
callq 0x41e0
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0x4090
cmpl $0x0, %eax
jge 0x6bc5
jmp 0x6b6c
movq 0xf47d(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x8496(%rip), %rsi      # 0xf013
leaq 0x87c2(%rip), %rdx      # 0xf346
movb $0x0, %al
callq 0x4830
leaq 0x243b6(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x6bbb
leaq 0x243a2(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x8490(%rip), %rsi      # 0xf03d
leaq 0x8792(%rip), %rcx      # 0xf346
movb $0x0, %al
callq 0x4120
movl $0x1, %edi
callq 0x41e0
movl -0x8(%rbp), %edi
movl $0x2, %esi
callq 0x4090
cmpl $0x0, %eax
jge 0x6c32
jmp 0x6bd9
movq 0xf410(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x8429(%rip), %rsi      # 0xf013
leaq 0x8786(%rip), %rdx      # 0xf377
movb $0x0, %al
callq 0x4830
leaq 0x24349(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x6c28
leaq 0x24335(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x8423(%rip), %rsi      # 0xf03d
leaq 0x8756(%rip), %rcx      # 0xf377
movb $0x0, %al
callq 0x4120
movl $0x1, %edi
callq 0x41e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cmsg.c
// Function: sendfd
ssize_t sendfd(int sockfd, struct file_t file)
{
	struct msghdr msg = {0};
	struct iovec iov[1] = {{0}};
	struct cmsghdr *cmsg;
	int *fdptr;

	union {
		char buf[CMSG_SPACE(sizeof(file.fd))];
		struct cmsghdr align;
	} u;

	/*
	 * We need to send some other data along with the ancillary data,
	 * otherwise the other side won't receive any data. This is very
	 * well-hidden in the documentation (and only applies to
	 * SOCK_STREAM). See the bottom part of unix(7).
	 */
	iov[0].iov_base = file.name;
	iov[0].iov_len = strlen(file.name) + 1;

	msg.msg_name = NULL;
	msg.msg_namelen = 0;
	msg.msg_iov = iov;
	msg.msg_iovlen = 1;
	msg.msg_control = u.buf;
	msg.msg_controllen = sizeof(u.buf);

	cmsg = CMSG_FIRSTHDR(&msg);
	cmsg->cmsg_level = SOL_SOCKET;
	cmsg->cmsg_type = SCM_RIGHTS;
	cmsg->cmsg_len = CMSG_LEN(sizeof(int));

	fdptr = (int *)CMSG_DATA(cmsg);
	memcpy(fdptr, &file.fd, sizeof(int));

	return sendmsg(sockfd, &msg, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x40b0
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x40b0
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4360
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movl $0x0, -0x48(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x1, -0x38(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x18, -0x28(%rbp)
cmpq $0x10, -0x28(%rbp)
jb 0x6d24
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x6d2f
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x6d2f
movq -0x90(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x68(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x68(%rbp), %rax
movq $0x14, (%rax)
movq -0x68(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %edi
leaq -0x50(%rbp), %rsi
xorl %edx, %edx
callq 0x4490
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: count_chars_in_string
static int count_chars_in_string(const char *str, char ch)
{
	int count = 0;

	while (str) {
		str = strchr(str, ch);
		if (str == NULL)
			break;
		count++;
		str++;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7691
movq -0x8(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x4560
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x767a
jmp 0x7691
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7659
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: is_valid_label_name
static int is_valid_label_name(const char *str)
{
	while (*str) {
		if (*str == '=') {
			return 1;
		}
		if (!isupper(*str) && !isdigit(*str) && *str != '_') {
			return 0;
		}
		str++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x7730
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x76ca
movl $0x1, -0x4(%rbp)
jmp 0x7737
callq 0x43d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x771f
callq 0x43d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x771f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x771f
movl $0x0, -0x4(%rbp)
jmp 0x7737
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x76ac
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: write_to_logs
bool write_to_logs(stdpipe_t pipe, char *buf, ssize_t num_read)
{
	if (use_k8s_logging && write_k8s_log(pipe, buf, num_read) < 0) {
		nwarn("write_k8s_log failed");
		return G_SOURCE_CONTINUE;
	}
	if (use_journald_logging && write_journald(pipe, buf, num_read) < 0) {
		nwarn("write_journald failed");
		return G_SOURCE_CONTINUE;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, 0x1f72a(%rip)     # 0x26e84
je 0x77db
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7870
cmpl $0x0, %eax
jge 0x77db
leaq 0xed2c(%rip), %rax      # 0x164a4
cmpl $0x1, (%rax)
jb 0x77d2
jmp 0x777f
movq 0xe86a(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7a07(%rip), %rsi      # 0xf197
leaq 0x863c(%rip), %rdx      # 0xfdd3
movb $0x0, %al
callq 0x4830
leaq 0x237a3(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x77ce
leaq 0x2378f(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x6, %edi
leaq 0x7a12(%rip), %rsi      # 0xf1d2
leaq 0x860c(%rip), %rcx      # 0xfdd3
movb $0x0, %al
callq 0x4120
jmp 0x77d0
jmp 0x77d2
movb $0x1, -0x1(%rbp)
jmp 0x7864
cmpl $0x0, 0x1f6be(%rip)     # 0x26ea0
je 0x7860
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x7db0
cmpl $0x0, %eax
jge 0x7860
leaq 0xeca4(%rip), %rax      # 0x164a4
cmpl $0x1, (%rax)
jb 0x785a
jmp 0x7807
movq 0xe7e2(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x797f(%rip), %rsi      # 0xf197
leaq 0x85c9(%rip), %rdx      # 0xfde8
movb $0x0, %al
callq 0x4830
leaq 0x2371b(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x7856
leaq 0x23707(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x6, %edi
leaq 0x798a(%rip), %rsi      # 0xf1d2
leaq 0x8599(%rip), %rcx      # 0xfde8
movb $0x0, %al
callq 0x4120
jmp 0x7858
jmp 0x785a
movb $0x1, -0x1(%rbp)
jmp 0x7864
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: reopen_k8s_file
static void reopen_k8s_file(void)
{
	if (!use_k8s_logging)
		return;

	_cleanup_free_ char *k8s_log_path_tmp = g_strdup_printf("%s.tmp", k8s_log_path);

	/* Close the current k8s_log_fd */
	close(k8s_log_fd);

	/* Open with O_TRUNC: reset bytes written */
	k8s_bytes_written = 0;

	/* Open the log path file again */
	k8s_log_fd = open(k8s_log_path_tmp, O_WRONLY | O_TRUNC | O_CREAT | O_CLOEXEC, 0640);
	if (k8s_log_fd < 0)
		pexitf("Failed to open log file %s", k8s_log_path);

	/* Replace the previous file */
	if (rename(k8s_log_path_tmp, k8s_log_path) < 0) {
		pexit("Failed to rename log file");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x1eb35(%rip)     # 0x26e84
jne 0x8356
jmp 0x847d
movq 0x1eb2b(%rip), %rsi     # 0x26e88
leaq 0x7dce(%rip), %rdi      # 0x10132
movb $0x0, %al
callq 0x4380
movq %rax, -0x8(%rbp)
movl 0xe12b(%rip), %edi      # 0x164a0
callq 0x4100
movq $0x0, 0x1eb0b(%rip) # 0x26e90
movq -0x8(%rbp), %rdi
movl $0x80241, %esi          # imm = 0x80241
movl $0x1a0, %edx            # imm = 0x1A0
movb $0x0, %al
callq 0x48d0
movl %eax, 0xe100(%rip)      # 0x164a0
cmpl $0x0, 0xe0f9(%rip)      # 0x164a0
jge 0x8404
jmp 0x83ab
movq 0xdc3e(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq 0x1eacc(%rip), %rdx     # 0x26e88
leaq 0x7d76(%rip), %rsi      # 0x10139
movb $0x0, %al
callq 0x4830
leaq 0x22b77(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x83fa
leaq 0x22b63(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movq 0x1eaa1(%rip), %rcx     # 0x26e88
movl $0x3, %edi
leaq 0x7d71(%rip), %rsi      # 0x10164
movb $0x0, %al
callq 0x4120
movl $0x1, %edi
callq 0x41e0
movq -0x8(%rbp), %rdi
movq 0x1ea79(%rip), %rsi     # 0x26e88
callq 0x48e0
cmpl $0x0, %eax
jge 0x8474
jmp 0x841b
movq 0xdbce(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6be7(%rip), %rsi      # 0xf013
leaq 0x7d67(%rip), %rdx      # 0x1019a
movb $0x0, %al
callq 0x4830
leaq 0x22b07(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x846a
leaq 0x22af3(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x3, %edi
leaq 0x6be1(%rip), %rsi      # 0xf03d
leaq 0x7d37(%rip), %rcx      # 0x1019a
movb $0x0, %al
callq 0x4120
movl $0x1, %edi
callq 0x41e0
leaq -0x8(%rbp), %rdi
callq 0x8580
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: sync_logs
void sync_logs(void)
{
	/* Sync the logs to disk */
	if (k8s_log_fd > 0)
		if (fsync(k8s_log_fd) < 0)
			nwarnf("Failed to sync log file before exit: %m");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xe005(%rip)      # 0x164a0
jle 0x8504
movl 0xdffd(%rip), %edi      # 0x164a0
callq 0x4470
cmpl $0x0, %eax
jge 0x8502
leaq 0xdff0(%rip), %rax      # 0x164a4
cmpl $0x1, (%rax)
jb 0x8500
jmp 0x84bb
movq 0xdb2e(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7932(%rip), %rsi      # 0xfdfe
movb $0x0, %al
callq 0x4830
leaq 0x22a6e(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0x84fc
leaq 0x22a5a(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x6, %edi
leaq 0x793e(%rip), %rsi      # 0xfe33
movb $0x0, %al
callq 0x4120
jmp 0x84fe
jmp 0x8500
jmp 0x8502
jmp 0x8504
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: get_line_len
static bool get_line_len(ptrdiff_t *line_len, const char *buf, ssize_t buflen)
{
	bool partial = FALSE;
	const char *line_end = memchr(buf, '\n', buflen);
	if (line_end == NULL) {
		line_end = &buf[buflen - 1];
		partial = TRUE;
	}
	*line_len = line_end - buf + 1;
	return partial;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0xa, %esi
callq 0x4150
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x855c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x19(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rax, %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: writev_buffer_append_segment_no_flush
ssize_t writev_buffer_append_segment_no_flush(writev_buffer_t *buf, const void *data, ssize_t len)
{
	if (data == NULL)
		return 1;

	if (buf->iovcnt == WRITEV_BUFFER_N_IOV)
		return -1;

	if (len > 0) {
		buf->iov[buf->iovcnt].iov_base = (void *)data;
		buf->iov[buf->iovcnt].iov_len = (size_t)len;
		buf->iovcnt++;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x85c1
movq $0x1, -0x8(%rbp)
jmp 0x862c
movq -0x10(%rbp), %rax
cmpl $0x80, (%rax)
jne 0x85d7
movq $-0x1, -0x8(%rbp)
jmp 0x862c
cmpq $0x0, -0x20(%rbp)
jle 0x8624
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: stdpipe_name
static const char *stdpipe_name(stdpipe_t pipe)
{
	switch (pipe) {
	case STDIN_PIPE:
		return "stdin";
	case STDOUT_PIPE:
		return "stdout";
	case STDERR_PIPE:
		return "stderr";
	default:
		return "NONE";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x8878
jmp 0x8864
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x8885
jmp 0x886e
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x8892
jmp 0x889f
leaq 0x6ac1(%rip), %rax      # 0xf340
movq %rax, -0x8(%rbp)
jmp 0x88aa
leaq 0x6ae4(%rip), %rax      # 0xf370
movq %rax, -0x8(%rbp)
jmp 0x88aa
leaq 0x6b08(%rip), %rax      # 0xf3a1
movq %rax, -0x8(%rbp)
jmp 0x88aa
leaq 0x7887(%rip), %rax      # 0x1012d
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: writev_buffer_flush
static ssize_t writev_buffer_flush(int fd, writev_buffer_t *buf)
{
	size_t count = 0;

	for (int i = 0; i < buf->iovcnt; i++) {
		const char *ptr = buf->iov[i].iov_base;
		size_t remaining = buf->iov[i].iov_len;

		while (remaining > 0) {
			ssize_t written = write(fd, ptr, remaining);
			if (written < 0) {
				if (errno == EINTR)
					continue;
				return -1;
			}
			if (written == 0)
				return -1;

			ptr += written;
			remaining -= written;
			count += written;
		}
	}

	buf->iovcnt = 0;
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x8994
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x8984
movl -0xc(%rbp), %edi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x4840
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jge 0x894a
callq 0x45c0
cmpl $0x4, (%rax)
jne 0x8940
jmp 0x8912
movq $-0x1, -0x8(%rbp)
jmp 0x89a6
cmpq $0x0, -0x40(%rbp)
jne 0x895b
movq $-0x1, -0x8(%rbp)
jmp 0x89a6
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8912
jmp 0x8986
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x88ce
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/ctr_logging.c
// Function: writev_buffer_append_segment
ssize_t writev_buffer_append_segment(int fd, writev_buffer_t *buf, const void *data, ssize_t len)
{
	if (data == NULL)
		return 1;

	if (buf->iovcnt == WRITEV_BUFFER_N_IOV && writev_buffer_flush(fd, buf) < 0)
		return -1;

	if (len > 0) {
		buf->iov[buf->iovcnt].iov_base = (void *)data;
		buf->iov[buf->iovcnt].iov_len = (size_t)len;
		buf->iovcnt++;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x89d8
movq $0x1, -0x8(%rbp)
jmp 0x8a55
movq -0x18(%rbp), %rax
cmpl $0x80, (%rax)
jne 0x8a00
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x88b0
cmpq $0x0, %rax
jge 0x8a00
movq $-0x1, -0x8(%rbp)
jmp 0x8a55
cmpq $0x0, -0x28(%rbp)
jle 0x8a4d
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rdx
movslq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/utils.c
// Function: write_all
ssize_t write_all(int fd, const void *buf, size_t count)
{
	size_t remaining = count;
	const char *p = buf;
	ssize_t res;

	while (remaining > 0) {
		do {
			res = write(fd, p, remaining);
		} while (res == -1 && retryable_error(errno));

		if (res <= 0)
			return -1;

		remaining -= res;
		p += res;
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jbe 0x8cf0
jmp 0x8c8c
movl -0xc(%rbp), %edi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4840
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x38(%rbp)
movb %al, -0x39(%rbp)
jne 0x8cbb
callq 0x45c0
movl (%rax), %edi
callq 0x8d10
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8c8c
cmpq $0x0, -0x38(%rbp)
jg 0x8cd3
movq $-0x1, -0x8(%rbp)
jmp 0x8cf8
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x8c83
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/utils.c
// Function: get_signal_descriptor_mask
static void get_signal_descriptor_mask(sigset_t *set)
{
	sigemptyset(set);
	sigaddset(set, SIGCHLD);
	sigaddset(set, SIGUSR1);
	sigprocmask(SIG_BLOCK, set, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4790
movq -0x8(%rbp), %rdi
movl $0x11, %esi
callq 0x4610
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x4610
movq -0x8(%rbp), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0x44c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cli.c
// Function: initialize_cli
int initialize_cli(int argc, char *argv[])
{
	GOptionContext *context = g_option_context_new("- conmon utility");
	g_option_context_add_main_entries(context, opt_entries, "conmon");

	GError *error = NULL;
	if (!g_option_context_parse(context, &argc, &argv, &error)) {
		g_printerr("conmon: option parsing failed: %s\n", error->message);
		exit(EXIT_FAILURE);
	}

	g_option_context_free(context);
	context = NULL;

	if (opt_version) {
		g_print("conmon version " VERSION "\ncommit: " GIT_COMMIT "\n");
		exit(EXIT_SUCCESS);
	}

	if (opt_cid == NULL) {
		fprintf(stderr, "conmon: Container ID not provided. Use --cid\n");
		exit(EXIT_FAILURE);
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7d5f(%rip), %rdi      # 0x10c55
callq 0x4730
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xd5c6(%rip), %rsi      # 0x164d0
leaq 0x7d55(%rip), %rdx      # 0x10c66
callq 0x42e0
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x4(%rbp), %rsi
leaq -0x10(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x4480
cmpl $0x0, %eax
jne 0x8f58
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x7d26(%rip), %rdi      # 0x10c6d
movb $0x0, %al
callq 0x4240
movl $0x1, %edi
callq 0x41e0
movq -0x18(%rbp), %rdi
callq 0x41a0
movq $0x0, -0x18(%rbp)
cmpl $0x0, 0x21fe0(%rip)     # 0x2af50
je 0x8f87
leaq 0x7d17(%rip), %rdi      # 0x10c90
movb $0x0, %al
callq 0x4190
xorl %edi, %edi
callq 0x41e0
cmpq $0x0, 0x21fe1(%rip)     # 0x2af70
jne 0x8fb3
movq 0xd058(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x7d36(%rip), %rsi      # 0x10cd8
movb $0x0, %al
callq 0x4830
movl $0x1, %edi
callq 0x41e0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cgroup.c
// Function: setup_oom_handling
void setup_oom_handling(int pid)
{
	struct statfs sfs;

	if (statfs("/sys/fs/cgroup", &sfs) == 0 && sfs.f_type == CGROUP2_SUPER_MAGIC) {
		is_cgroup_v2 = TRUE;
		setup_oom_handling_cgroup_v2(pid);
		return;
	}
	setup_oom_handling_cgroup_v1(pid);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
leaq 0x7a7a(%rip), %rdi      # 0x10f1f
leaq -0x80(%rbp), %rsi
callq 0x4450
cmpl $0x0, %eax
jne 0x94d4
cmpq $0x63677270, -0x80(%rbp) # imm = 0x63677270
jne 0x94d4
leaq 0x21aa0(%rip), %rax     # 0x2af64
movl $0x1, (%rax)
movl -0x4(%rbp), %edi
callq 0x94f0
jmp 0x94dc
movl -0x4(%rbp), %edi
callq 0x96f0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cgroup.c
// Function: oom_cb_cgroup_v2
static gboolean oom_cb_cgroup_v2(int fd, GIOCondition condition, G_GNUC_UNUSED gpointer user_data)
{
	const size_t events_size = sizeof(struct inotify_event) + NAME_MAX + 1;
	char events[events_size];

	/* Drop the inotify events.  */
	ssize_t num_read = read(fd, &events, events_size);
	if (num_read < 0) {
		nwarn("Failed to read oom event from eventfd in v2");
		return G_SOURCE_CONTINUE;
	}

	gboolean ret = G_SOURCE_REMOVE;
	if ((condition & G_IO_IN) != 0) {
		ret = check_cgroup2_oom();
	}

	if (ret == G_SOURCE_REMOVE) {
		/* End of input */
		close(fd);
		inotify_fd = -1;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x110, -0x20(%rbp)     # imm = 0x110
movq %rsp, %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %edi
leaq -0x150(%rbp), %rsi
movl $0x110, %edx            # imm = 0x110
callq 0x4230
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0xa1b6
leaq 0xc35a(%rip), %rax      # 0x164a4
cmpl $0x1, (%rax)
jb 0xa1a6
jmp 0xa151
movq 0xbe98(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x5035(%rip), %rsi      # 0xf197
leaq 0x70a3(%rip), %rdx      # 0x1120c
movb $0x0, %al
callq 0x4830
leaq 0x20dd1(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0xa1a0
leaq 0x20dbd(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x6, %edi
leaq 0x5040(%rip), %rsi      # 0xf1d2
leaq 0x7073(%rip), %rcx      # 0x1120c
movb $0x0, %al
callq 0x4120
jmp 0xa1a2
jmp 0xa1a4
jmp 0xa1a6
movl $0x1, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0xa1f8
movl $0x0, -0x38(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa1d0
callq 0x9a30
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0xa1eb
movl -0x8(%rbp), %edi
callq 0x4100
leaq 0xcb7f(%rip), %rax      # 0x16d64
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cgroup.c
// Function: create_oom_files
static int create_oom_files()
{
	ninfo("OOM received");
	int r = 0;
	r |= create_oom_file(opt_persist_path);
	r |= create_oom_file(opt_bundle_path);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xbf05(%rip), %rax      # 0x164a4
cmpl $0x2, (%rax)
jb 0xa5f9
jmp 0xa5a6
movq 0xba43(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
leaq 0x6f6f(%rip), %rsi      # 0x11526
leaq 0x6fa5(%rip), %rdx      # 0x11563
movb $0x0, %al
callq 0x4830
leaq 0x2097c(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0xa5f5
leaq 0x20968(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movl $0x6, %edi
leaq 0x6f62(%rip), %rsi      # 0x11549
leaq 0x6f75(%rip), %rcx      # 0x11563
movb $0x0, %al
callq 0x4120
jmp 0xa5f7
jmp 0xa5f9
movl $0x0, -0x4(%rbp)
leaq 0x20991(%rip), %rax     # 0x2af98
movq (%rax), %rdi
callq 0xa640
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq 0x20974(%rip), %rax     # 0x2af90
movq (%rax), %rdi
callq 0xa640
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/containers[P]conmon/src/cgroup.c
// Function: create_oom_file
static int create_oom_file(const char *base_path)
{
	if (base_path == NULL || base_path[0] == '\0')
		return 0;

	_cleanup_free_ char *ctr_oom_file_path = g_build_filename(base_path, "oom", NULL);
	_cleanup_close_ int ctr_oom_fd = open(ctr_oom_file_path, O_CREAT | O_CLOEXEC, 0666);
	if (ctr_oom_fd < 0) {
		nwarnf("Failed to write oom file to the %s path", base_path);
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa65f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa66b
movl $0x0, -0x4(%rbp)
jmp 0xa730
movq -0x10(%rbp), %rdi
leaq 0x6efa(%rip), %rsi      # 0x11570
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x46a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x80040, %esi          # imm = 0x80040
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x48d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xa710
leaq 0xbdfa(%rip), %rax      # 0x164a4
cmpl $0x1, (%rax)
jb 0xa700
jmp 0xa6b1
movq 0xb938(%rip), %rax      # 0x15ff0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6eae(%rip), %rsi      # 0x11574
movb $0x0, %al
callq 0x4830
leaq 0x20874(%rip), %rax     # 0x2af48
cmpl $0x0, (%rax)
je 0xa6fa
leaq 0x20860(%rip), %rax     # 0x2af40
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x6, %edi
leaq 0x6eb6(%rip), %rsi      # 0x115a9
movb $0x0, %al
callq 0x4120
jmp 0xa6fc
jmp 0xa6fe
jmp 0xa700
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x20(%rbp)
jmp 0xa71e
movl $0x0, -0x4(%rbp)
movl $0x1, -0x20(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xa0d0
leaq -0x18(%rbp), %rdi
callq 0x9ca0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)