LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: writemap
void writemap(pid_t pid, int type, char *map) {
  char *path, *range, *text = NULL;
  int fd;
  unsigned count, first, lower;

  if (!map) {
    map = (getuid() == 0 ? rootdefault : userdefault)(type);
  } else if (getuid() != 0) {
    range = readranges(type);
    verifymap(map, range);
    free(range);
  }

  while ((map = mapitem(map, &first, &lower, &count)))
    append(&text, "%u %u %u\n", first, lower, count);

  path = string("/proc/%d/%s", pid, idfile(type));
  if ((fd = open(path, O_WRONLY)) < 0)
    errx(EXIT_FAILURE, "Failed to set container %s map", idname(type));
  else if (write(fd, text, strlen(text)) != (ssize_t) strlen(text))
    errx(EXIT_FAILURE, "Failed to set container %s map", idname(type));

  close(fd);
  free(path);
  free(text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b48
callq 0x2100
movl %eax, %edx
leaq 0x311(%rip), %rax       # 0x2e40
leaq 0x18a(%rip), %rcx       # 0x2cc0
cmpl $0x0, %edx
cmoveq %rcx, %rax
movl -0x8(%rbp), %edi
callq *%rax
movq %rax, -0x10(%rbp)
jmp 0x2b76
callq 0x2100
cmpl $0x0, %eax
je 0x2b74
movl -0x8(%rbp), %edi
callq 0x2fd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3240
movq -0x20(%rbp), %rdi
callq 0x2040
jmp 0x2b76
jmp 0x2b78
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2bb5
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %ecx
movl -0x30(%rbp), %r8d
leaq -0x28(%rbp), %rdi
leaq 0x1648(%rip), %rsi      # 0x41f4
movb $0x0, %al
callq 0x3680
jmp 0x2b78
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %ecx
leaq 0x1650(%rip), %rdx      # 0x4212
leaq 0x1641(%rip), %rax      # 0x420a
cmpl $0x0, %ecx
cmoveq %rax, %rdx
leaq 0x1627(%rip), %rdi      # 0x41fe
movb $0x0, %al
callq 0x3900
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movb $0x0, %al
callq 0x22a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jge 0x2c25
movl -0x8(%rbp), %ecx
leaq 0x1639(%rip), %rdx      # 0x423d
leaq 0x162e(%rip), %rax      # 0x4239
cmpl $0x0, %ecx
cmoveq %rax, %rdx
movl $0x1, %edi
leaq 0x15fc(%rip), %rsi      # 0x421a
movb $0x0, %al
callq 0x2110
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20e0
movl -0x4c(%rbp), %edi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x2090
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x20e0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x2c8f
movl -0x8(%rbp), %ecx
leaq 0x15cf(%rip), %rdx      # 0x423d
leaq 0x15c4(%rip), %rax      # 0x4239
cmpl $0x0, %ecx
cmoveq %rax, %rdx
movl $0x1, %edi
leaq 0x1592(%rip), %rsi      # 0x421a
movb $0x0, %al
callq 0x2110
jmp 0x2c91
movl -0x2c(%rbp), %edi
callq 0x2150
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: rootdefault
static char *rootdefault(int type) {
  char *cursor, *map, *result;
  unsigned count, first, last = INVALID, lower;

  cursor = map = getmap(-1, type);
  while ((cursor = mapitem(cursor, &first, &lower, &count)))
    if (last == INVALID || last < first + count - 1)
      last = first + count - 1;
  result = string("0:%u:1", last);

  cursor = map;
  while ((cursor = mapitem(cursor, &first, &lower, &count))) {
    if (first == 0) {
      if (count == 1 && first >= last)
        errx(EXIT_FAILURE, "No unprivileged %s available\n", idname(type));
      first++, lower++, count--;
    }

    if (last <= first + count - 1 && count > 0)
      count--;

    if (count > 0)
      append(&result, "%s%u:%u:%u", result ? "," : "", first, first, count);
  }

  free(map);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3370
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2d2a
cmpl $-0x1, -0x2c(%rbp)
je 0x2d1c
movl -0x2c(%rbp), %eax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x2d28
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2ce7
movl -0x2c(%rbp), %esi
leaq 0x150d(%rip), %rdi      # 0x4241
movb $0x0, %al
callq 0x3900
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x3290
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x2e25
cmpl $0x0, -0x28(%rbp)
jne 0x2dc4
cmpl $0x1, -0x24(%rbp)
jne 0x2da9
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jb 0x2da9
movl -0x4(%rbp), %ecx
leaq 0x14b5(%rip), %rdx      # 0x423d
leaq 0x14aa(%rip), %rax      # 0x4239
cmpl $0x0, %ecx
cmoveq %rax, %rdx
movl $0x1, %edi
leaq 0x14a6(%rip), %rsi      # 0x4248
movb $0x0, %al
callq 0x2110
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
ja 0x2de3
cmpl $0x0, -0x24(%rbp)
jbe 0x2de3
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0x2e20
movq -0x20(%rbp), %rcx
leaq 0x151e(%rip), %rdx      # 0x4312
leaq 0x1476(%rip), %rax      # 0x4271
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movl -0x28(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x24(%rbp), %r9d
leaq -0x20(%rbp), %rdi
leaq 0x144d(%rip), %rsi      # 0x4266
movb $0x0, %al
callq 0x3680
jmp 0x2d47
movq -0x18(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: userdefault
static char *userdefault(int type) {
  char *cursor, *map, *range, *result = NULL;
  unsigned count, first, index = 0, length, lower, start;

  if (geteuid() != 0)
    return string("0:%u:1", getid(type));

  map = getmap(-1, type);
  range = readranges(type);

  while ((range = rangeitem(range, &start, &length))) {
    cursor = map;
    while ((cursor = mapitem(cursor, &first, &lower, &count))) {
      if (start + length <= first || first + count <= start)
        continue;
      if (first + count < start + length)
        length = start - first + count;
      if (start < first) {
        index += first - start;
        length -= first - start;
        start = first;
      }
      append(&result, "%s%u:%u:%u", result ? "," : "", index, start, length);
      index += length;
    }
  }

  free(map);
  free(range);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x3c(%rbp)
callq 0x2140
cmpl $0x0, %eax
je 0x2e96
cmpl $0x0, -0xc(%rbp)
jne 0x2e74
callq 0x21e0
movl %eax, -0x4c(%rbp)
jmp 0x2e7c
callq 0x2100
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
leaq 0x13bb(%rip), %rdi      # 0x4241
movb $0x0, %al
callq 0x3900
movq %rax, -0x8(%rbp)
jmp 0x2fbd
movl -0xc(%rbp), %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3370
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x2fd0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x34f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2fa3
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x44(%rbp), %rdx
leaq -0x34(%rbp), %rcx
callq 0x3290
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2f9e
movl -0x48(%rbp), %eax
addl -0x40(%rbp), %eax
cmpl -0x38(%rbp), %eax
jbe 0x2f13
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl -0x48(%rbp), %eax
ja 0x2f15
jmp 0x2eda
movl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl -0x48(%rbp), %ecx
addl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jae 0x2f31
movl -0x48(%rbp), %eax
subl -0x38(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x38(%rbp), %eax
jae 0x2f59
movl -0x38(%rbp), %eax
subl -0x48(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x38(%rbp), %ecx
subl -0x48(%rbp), %ecx
movl -0x40(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x48(%rbp)
movq -0x30(%rbp), %rcx
leaq 0x13ae(%rip), %rdx      # 0x4312
leaq 0x1306(%rip), %rax      # 0x4271
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movl -0x3c(%rbp), %ecx
movl -0x48(%rbp), %r8d
movl -0x40(%rbp), %r9d
leaq -0x30(%rbp), %rdi
leaq 0x12dd(%rip), %rsi      # 0x4266
movb $0x0, %al
callq 0x3680
movl -0x40(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x2eda
jmp 0x2eb3
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: mapitem
static char *mapitem(char *map, unsigned *first, unsigned *lower,
    unsigned *count) {
  ssize_t skip;

  while (map && *map && strchr(",;", *map))
    map++;
  if (map == NULL || *map == '\0')
    return NULL;
  if (sscanf(map, "%u:%u:%u%zn", first, lower, count, &skip) < 3)
    errx(EXIT_FAILURE, "Invalid ID map '%s'", map);
  return map + skip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x31(%rbp)
je 0x32e2
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x32e2
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
leaq 0xfde(%rip), %rdi       # 0x42b1
callq 0x2120
cmpq $0x0, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x32eb
jmp 0x32f9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x32a8
cmpq $0x0, -0x10(%rbp)
je 0x330c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3316
movq $0x0, -0x8(%rbp)
jmp 0x3360
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq 0x101f(%rip), %rsi      # 0x434c
leaq -0x30(%rbp), %r9
movb $0x0, %al
callq 0x2210
cmpl $0x3, %eax
jge 0x3354
movq -0x10(%rbp), %rdx
movl $0x1, %edi
leaq 0x100b(%rip), %rsi      # 0x4358
movb $0x0, %al
callq 0x2110
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: getmap
static char *getmap(pid_t pid, int type) {
  char *line = NULL, *result = NULL, *path;
  size_t size;
  unsigned count, first, lower;
  FILE *file;

  if (pid == -1)
    path = string("/proc/self/%s", idfile(type));
  else
    path = string("/proc/%d/%s", pid, idfile(type));
  if (!(file = fopen(path, "r")))
    errx(EXIT_FAILURE, "Cannot read %s", path);

  while (getline(&line, &size, file) >= 0) {
    if (sscanf(line, " %u %u %u", &first, &lower, &count) != 3)
      errx(EXIT_FAILURE, "Invalid map data in %s", path);
    append(&result, "%s%u:%u:%u", result ? "," : "", first, lower, count);
  }

  if (!result)
    errx(EXIT_FAILURE, "Invalid map data in %s", path);

  fclose(file);
  free(line);
  free(path);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x33c0
movl -0x8(%rbp), %ecx
leaq 0xe74(%rip), %rsi       # 0x4212
leaq 0xe65(%rip), %rax       # 0x420a
cmpl $0x0, %ecx
cmoveq %rax, %rsi
leaq 0xec0(%rip), %rdi       # 0x4273
movb $0x0, %al
callq 0x3900
movq %rax, -0x20(%rbp)
jmp 0x33ed
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %ecx
leaq 0xe45(%rip), %rdx       # 0x4212
leaq 0xe36(%rip), %rax       # 0x420a
cmpl $0x0, %ecx
cmoveq %rax, %rdx
leaq 0xe1c(%rip), %rdi       # 0x41fe
movb $0x0, %al
callq 0x3900
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0xdfa(%rip), %rsi       # 0x41f2
callq 0x22b0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x341e
movq -0x20(%rbp), %rdx
movl $0x1, %edi
leaq 0xe6a(%rip), %rsi       # 0x4281
movb $0x0, %al
callq 0x2110
jmp 0x3420
movq -0x40(%rbp), %rdx
leaq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22d0
cmpq $0x0, %rax
jl 0x34ad
movq -0x10(%rbp), %rdi
leaq 0xe4e(%rip), %rsi       # 0x4290
leaq -0x30(%rbp), %rdx
leaq -0x34(%rbp), %rcx
leaq -0x2c(%rbp), %r8
movb $0x0, %al
callq 0x2210
cmpl $0x3, %eax
je 0x3471
movq -0x20(%rbp), %rdx
movl $0x1, %edi
leaq 0xe30(%rip), %rsi       # 0x429a
movb $0x0, %al
callq 0x2110
movq -0x18(%rbp), %rcx
leaq 0xe96(%rip), %rdx       # 0x4312
leaq 0xdee(%rip), %rax       # 0x4271
cmpq $0x0, %rcx
cmovneq %rax, %rdx
movl -0x30(%rbp), %ecx
movl -0x34(%rbp), %r8d
movl -0x2c(%rbp), %r9d
leaq -0x18(%rbp), %rdi
leaq 0xdc5(%rip), %rsi       # 0x4266
movb $0x0, %al
callq 0x3680
jmp 0x3420
cmpq $0x0, -0x18(%rbp)
jne 0x34cb
movq -0x20(%rbp), %rdx
movl $0x1, %edi
leaq 0xdd6(%rip), %rsi       # 0x429a
movb $0x0, %al
callq 0x2110
movq -0x40(%rbp), %rdi
callq 0x20b0
movq -0x10(%rbp), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: rangeitem
static char *rangeitem(char *range, unsigned *start, unsigned *length) {
  ssize_t skip;

  while (range && *range && strchr(",;", *range))
    range++;
  if (range == NULL || *range == '\0')
    return NULL;
  if (sscanf(range, "%u:%u%zn", start, length, &skip) < 2)
    errx(EXIT_FAILURE, "Invalid ID range '%s'", range);
  return range + skip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x353e
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x353e
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
leaq 0xd82(%rip), %rdi       # 0x42b1
callq 0x2120
cmpq $0x0, %rax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3547
jmp 0x3555
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3504
cmpq $0x0, -0x10(%rbp)
je 0x3568
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3572
movq $0x0, -0x8(%rbp)
jmp 0x35b8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xdca(%rip), %rsi       # 0x434f
leaq -0x28(%rbp), %r8
movb $0x0, %al
callq 0x2210
cmpl $0x2, %eax
jge 0x35ac
movq -0x10(%rbp), %rdx
movl $0x1, %edi
leaq 0xd0f(%rip), %rsi       # 0x42b4
movb $0x0, %al
callq 0x2110
movq -0x10(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/map.c
// Function: validate
static void validate(char *range, unsigned first, unsigned count) {
  unsigned length, start;

  while ((range = rangeitem(range, &start, &length)))
    if (first < start + length && start < first + count) {
      if (first < start)
        validate(range, first, start - first);
      if (first + count > start + length)
        validate(range, start + length, first + count - start - length);
      return;
    }
  errx(EXIT_FAILURE, "Cannot map onto IDs that are not delegated to you");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x34f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x3667
movl -0xc(%rbp), %eax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jae 0x3662
movl -0x18(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jae 0x3662
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x3631
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl -0xc(%rbp), %edx
callq 0x35d0
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jbe 0x365c
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl -0x14(%rbp), %esi
movl -0xc(%rbp), %edx
addl -0x10(%rbp), %edx
subl -0x18(%rbp), %edx
subl -0x14(%rbp), %edx
callq 0x35d0
addq $0x20, %rsp
popq %rbp
retq
jmp 0x35e2
movl $0x1, %edi
leaq 0xca7(%rip), %rsi       # 0x431a
movb $0x0, %al
callq 0x2110
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: append
char *append(char **destination, const char *format, ...) {
  char *extra, *result;
  va_list args;

  va_start(args, format);
  if (vasprintf(&extra, format, args) < 0)
    err(EXIT_FAILURE, "asprintf");
  va_end(args);

  if (*destination == NULL) {
    *destination = extra;
    return extra;
  }

  if (asprintf(&result, "%s%s", *destination, extra) < 0)
      err(EXIT_FAILURE, "asprintf");
  free(*destination);
  free(extra);
  *destination = result;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x36bb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x20a0
cmpl $0x0, %eax
jge 0x372c
movl $0x1, %edi
leaq 0xc47(%rip), %rsi       # 0x436c
movb $0x0, %al
callq 0x2200
leaq -0x40(%rbp), %rax
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x374f
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37ac
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq 0xc10(%rip), %rsi       # 0x4375
movb $0x0, %al
callq 0x2260
cmpl $0x0, %eax
jge 0x3784
movl $0x1, %edi
leaq 0xbef(%rip), %rsi       # 0x436c
movb $0x0, %al
callq 0x2200
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: seal
void seal(char **argv, char **envp) {
  const int seals = F_SEAL_SEAL | F_SEAL_SHRINK | F_SEAL_GROW | F_SEAL_WRITE;
  int dst, src;
  ssize_t length;

  if ((src = open("/proc/self/exe", O_RDONLY)) < 0)
    err(EXIT_FAILURE, "open /proc/self/exe");
  if (fcntl(src, F_GET_SEALS) == seals) {
    close(src);
    return;
  }

  dst = memfd_create("/proc/self/exe", MFD_CLOEXEC | MFD_ALLOW_SEALING);
  if (dst < 0)
    err(EXIT_FAILURE, "memfd_create");

  while (length = sendfile(dst, src, NULL, BUFSIZ), length != 0)
    if (length < 0 && errno != EAGAIN && errno != EINTR)
      err(EXIT_FAILURE, "sendfile");
  close(src);

  if (fcntl(dst, F_ADD_SEALS, seals) < 0)
    err(EXIT_FAILURE, "fcntl F_ADD_SEALS");
  fexecve(dst, argv, envp);
  err(EXIT_FAILURE, "fexecve");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xf, -0x14(%rbp)
leaq 0xba1(%rip), %rdi       # 0x437f
xorl %esi, %esi
movb $0x0, %al
callq 0x22a0
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x3802
movl $0x1, %edi
leaq 0xb7f(%rip), %rsi       # 0x437a
movb $0x0, %al
callq 0x2200
movl -0x1c(%rbp), %edi
movl $0x40a, %esi            # imm = 0x40A
movb $0x0, %al
callq 0x2080
cmpl $0xf, %eax
jne 0x3824
movl -0x1c(%rbp), %edi
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
leaq 0xb54(%rip), %rdi       # 0x437f
movl $0x3, %esi
callq 0x2060
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x3851
movl $0x1, %edi
leaq 0xb44(%rip), %rsi       # 0x438e
movb $0x0, %al
callq 0x2200
jmp 0x3853
movl -0x18(%rbp), %edi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x2000, %ecx           # imm = 0x2000
callq 0x2250
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x38a2
cmpq $0x0, -0x28(%rbp)
jge 0x38a0
callq 0x2050
cmpl $0xb, (%rax)
je 0x38a0
callq 0x2050
cmpl $0x4, (%rax)
je 0x38a0
movl $0x1, %edi
leaq 0xb02(%rip), %rsi       # 0x439b
movb $0x0, %al
callq 0x2200
jmp 0x3853
movl -0x1c(%rbp), %edi
callq 0x2150
movl -0x18(%rbp), %edi
movl $0x409, %esi            # imm = 0x409
movl $0xf, %edx
movb $0x0, %al
callq 0x2080
cmpl $0x0, %eax
jge 0x38d6
movl $0x1, %edi
leaq 0xad5(%rip), %rsi       # 0x43a4
movb $0x0, %al
callq 0x2200
movl -0x18(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x21a0
movl $0x1, %edi
leaq 0xac4(%rip), %rsi       # 0x43b6
movb $0x0, %al
callq 0x2200
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: string
char *string(const char *format, ...) {
  char *result;
  va_list args;

  va_start(args, format);
  if (vasprintf(&result, format, args) < 0)
    err(EXIT_FAILURE, "asprintf");
  va_end(args);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3938
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x20a0
cmpl $0x0, %eax
jge 0x39ac
movl $0x1, %edi
leaq 0x9c7(%rip), %rsi       # 0x436c
movb $0x0, %al
callq 0x2200
movq -0x10(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: tmpdir
char *tmpdir(void) {
  char *dir;

  if (!(dir = strdup("/tmp/XXXXXX")))
    err(EXIT_FAILURE, "strdup");
  else if (!mkdtemp(dir))
    errx(EXIT_FAILURE, "Failed to create temporary directory");
  return dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x9ef(%rip), %rdi       # 0x43be
callq 0x2300
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x39f1
movl $0x1, %edi
leaq 0x9e0(%rip), %rsi       # 0x43ca
movb $0x0, %al
callq 0x2200
movq -0x8(%rbp), %rdi
callq 0x2270
cmpq $0x0, %rax
jne 0x3a13
movl $0x1, %edi
leaq 0x9c5(%rip), %rsi       # 0x43d1
movb $0x0, %al
callq 0x2110
jmp 0x3a15
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: waitforexit
void waitforexit(pid_t child) {
  int status;

  if (waitpid(child, &status, 0) < 0)
    err(EXIT_FAILURE, "waitpid");
  else if (WEXITSTATUS(status) != EXIT_SUCCESS)
    exit(WEXITSTATUS(status));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x2290
cmpl $0x0, %eax
jge 0x3a51
movl $0x1, %edi
leaq 0x9ac(%rip), %rsi       # 0x43f6
movb $0x0, %al
callq 0x2200
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
je 0x3a72
movl -0x8(%rbp), %edi
andl $0xff00, %edi           # imm = 0xFF00
sarl $0x8, %edi
callq 0x22e0
jmp 0x3a74
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/util.c
// Function: waitforstop
void waitforstop(pid_t child) {
  int status;

  if (waitpid(child, &status, WUNTRACED) < 0)
    err(EXIT_FAILURE, "waitpid");
  if (!WIFSTOPPED(status))
    exit(WEXITSTATUS(status));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
movl $0x2, %edx
callq 0x2290
cmpl $0x0, %eax
jge 0x3ab4
movl $0x1, %edi
leaq 0x949(%rip), %rsi       # 0x43f6
movb $0x0, %al
callq 0x2200
movl -0x8(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
je 0x3ad2
movl -0x8(%rbp), %edi
andl $0xff00, %edi           # imm = 0xFF00
sarl $0x8, %edi
callq 0x22e0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/vm/entry.c
// Function: stack_push
bool stack_push(double val) {
    if(stack_ptr >= stack_sz) {
        ISSUE_ERROR("Stack overflow. Maximum segment size reached(%I64d)", 
            stack_sz);
    }

    code_seg[stack_ptr++] = val;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movq 0x2d84(%rip), %rax      # 0x40a8
cmpq 0x2d75(%rip), %rax      # 0x40a0
jl 0x1356
movq 0x2cc4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2d62(%rip), %rdx      # 0x40a0
leaq 0xcc5(%rip), %rsi       # 0x200a
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10c0
movsd -0x8(%rbp), %xmm0
movq 0x2d2e(%rip), %rax      # 0x4090
movq 0x2d3f(%rip), %rcx      # 0x40a8
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x2d31(%rip)      # 0x40a8
movsd %xmm0, (%rax,%rcx,8)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/vm/entry.c
// Function: stack_pop
double stack_pop(void) {
    if(stack_ptr <= 0) {
        ISSUE_ERROR("Stack underflow. Out of bounds(stack pointer: %I64d).", stack_ptr);
    }

    double ret_val = code_seg[--stack_ptr];
    code_seg[stack_ptr] = 0;

    return ret_val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x2d08(%rip)      # 0x40a8
jg 0x13cb
movq 0x2c4f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2cf5(%rip), %rdx      # 0x40a8
leaq 0xc85(%rip), %rsi       # 0x203f
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10c0
movq 0x2cbe(%rip), %rax      # 0x4090
movq 0x2ccf(%rip), %rcx      # 0x40a8
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, 0x2cc1(%rip)      # 0x40a8
movsd -0x8(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movq 0x2c97(%rip), %rax      # 0x4090
movq 0x2ca8(%rip), %rcx      # 0x40a8
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/generot[P]VM-0/src/vm/handling.c
// Function: handle_syscall
void handle_syscall(instr in, double *data_segment) {
    switch(in.scall) {
    case SC_READ:
        scanf("%lf", &data_segment[in.addr]);
        break;
    case SC_WRITE:
        printf("%lf", stack_pop());
        break;
    case SC_WRITELN:
        printf("%lf\n", stack_pop());
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x19c7
jmp 0x1990
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x19dc
jmp 0x199a
movl -0xc(%rbp), %eax
subl $0x2, %eax
jne 0x19ef
jmp 0x19a4
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x10(%rax), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq 0x73a(%rip), %rdi       # 0x20f8
movb $0x0, %al
callq 0x10b0
jmp 0x19ef
callq 0x1390
leaq 0x725(%rip), %rdi       # 0x20f8
movb $0x1, %al
callq 0x1060
jmp 0x19ef
callq 0x1390
leaq 0x714(%rip), %rdi       # 0x20fc
movb $0x1, %al
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/arrput.c
// Function: main
int
main(void)
{
    int i;
    int nextpe;
    int me, npes;
    long src[N];
    long *dest;
    struct utsname u;
    int su;

    su = uname(&u);
    assert(su == 0);

    shmem_init();
    me = shmem_my_pe();
    npes = shmem_n_pes();

    for (i = 0; i < N; i += 1) {
        src[i] = (long) me;
    }

    dest = (long *) shmem_malloc(N * sizeof(*dest));

    nextpe = (me + 1) % npes;

    shmem_long_put(dest, src, N, nextpe);

    shmem_barrier_all();

    for (i = 0; i < N; i += 1) {
        printf("%d @ %s: dest[%d] = %ld\n", me, u.nodename, i, dest[i]);
    }

    shmem_free(dest);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movl $0x0, 0x1f4(%rsp)
leaq 0x12(%rsp), %rdi
callq 0x1050
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1209
jmp 0x1228
leaq 0xdf4(%rip), %rdi       # 0x2004
leaq 0xdf5(%rip), %rsi       # 0x200c
movl $0x4a, %edx
leaq 0xdf2(%rip), %rcx       # 0x2015
callq 0x1060
callq 0x10c0
callq 0x1090
movl %eax, 0x1e8(%rsp)
callq 0x1070
movl %eax, 0x1e4(%rsp)
movl $0x0, 0x1f0(%rsp)
cmpl $0x7, 0x1f0(%rsp)
jge 0x1285
movslq 0x1e8(%rsp), %rcx
movslq 0x1f0(%rsp), %rax
movq %rcx, 0x1a0(%rsp,%rax,8)
movl 0x1f0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1f0(%rsp)
jmp 0x1250
movl $0x38, %edi
callq 0x10a0
movq %rax, 0x198(%rsp)
movl 0x1e8(%rsp), %eax
addl $0x1, %eax
cltd
idivl 0x1e4(%rsp)
movl %edx, 0x1ec(%rsp)
movq 0x198(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
movl 0x1ec(%rsp), %ecx
movl $0x7, %edx
callq 0x1040
callq 0x10b0
movl $0x0, 0x1f0(%rsp)
cmpl $0x7, 0x1f0(%rsp)
jge 0x1337
movl 0x1e8(%rsp), %esi
leaq 0x12(%rsp), %rdx
addq $0x41, %rdx
movl 0x1f0(%rsp), %ecx
movq 0x198(%rsp), %rax
movslq 0x1f0(%rsp), %rdi
movq (%rax,%rdi,8), %r8
leaq 0xd07(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
movl 0x1f0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1f0(%rsp)
jmp 0x12e1
movq 0x198(%rsp), %rdi
callq 0x10d0
callq 0x1080
xorl %eax, %eax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/basic_pipe.c
// Function: main
int main() {
  libforks_ServerConn conn;

  main_process_pid = getpid();

  check(pipe(pipe_fds) == 0);

  check(libforks_start(&conn) == libforks_OK);

  check(close(pipe_fds[1]) == 0);

  check(libforks_fork(
    conn,
    NULL, // pid_ptr
    NULL, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  ) == libforks_OK);

  // Make sure that we can read one and only one char written by the
  // child process
  char buffer[16];
  check(read(pipe_fds[0], buffer, sizeof buffer) == 1);
  check(buffer[0] == 'a');

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1090
movl %eax, 0x5dfa(%rip)      # 0x7114
leaq 0x5df7(%rip), %rdi      # 0x7118
callq 0x10f0
cmpl $0x0, %eax
jne 0x132d
jmp 0x1345
leaq 0x2cd0(%rip), %rdi      # 0x4004
leaq 0x2cdd(%rip), %rsi      # 0x4018
movl $0x13, %edx
callq 0x1460
leaq -0x10(%rbp), %rdi
callq 0x1b90
cmpl $0x0, %eax
jne 0x1355
jmp 0x136d
leaq 0x2ccf(%rip), %rdi      # 0x402b
leaq 0x2cb5(%rip), %rsi      # 0x4018
movl $0x15, %edx
callq 0x1460
movl 0x5da9(%rip), %edi      # 0x711c
callq 0x10d0
cmpl $0x0, %eax
jne 0x137f
jmp 0x1397
leaq 0x2cca(%rip), %rdi      # 0x4050
leaq 0x2c8b(%rip), %rsi      # 0x4018
movl $0x17, %edx
callq 0x1460
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0xfa(%rip), %r8         # 0x14a0
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x2360
cmpl $0x0, %eax
jne 0x13b8
jmp 0x13d0
leaq 0x2ca9(%rip), %rdi      # 0x4068
leaq 0x2c52(%rip), %rsi      # 0x4018
movl $0x1f, %edx
callq 0x1460
movl 0x5d42(%rip), %edi      # 0x7118
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1100
cmpq $0x1, %rax
jne 0x13ec
jmp 0x1404
leaq 0x2cb8(%rip), %rdi      # 0x40ab
leaq 0x2c1e(%rip), %rsi      # 0x4018
movl $0x24, %edx
callq 0x1460
movsbl -0x20(%rbp), %eax
cmpl $0x61, %eax
jne 0x140f
jmp 0x1427
leaq 0x2cc3(%rip), %rdi      # 0x40d9
leaq 0x2bfb(%rip), %rsi      # 0x4018
movl $0x25, %edx
callq 0x1460
movq -0x10(%rbp), %rdi
callq 0x25f0
cmpl $0x0, %eax
jne 0x1437
jmp 0x144f
leaq 0x2cac(%rip), %rdi      # 0x40ea
leaq 0x2bd3(%rip), %rsi      # 0x4018
movl $0x27, %edx
callq 0x1460
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/basic_pipe.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  check(libforks_free_conn(conn) == libforks_OK);
  check(close(pipe_fds[0]) == 0);
  check(socket_fd == -1);
  check(getpid() != main_process_pid);
  check(write(pipe_fds[1], "a", 1) == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2660
cmpl $0x0, %eax
jne 0x14bf
jmp 0x14d7
leaq 0x2c63(%rip), %rdi      # 0x4129
leaq 0x2b4b(%rip), %rsi      # 0x4018
movl $0x7, %edx
callq 0x1460
movl 0x5c3b(%rip), %edi      # 0x7118
callq 0x10d0
cmpl $0x0, %eax
jne 0x14e9
jmp 0x1501
leaq 0x2c61(%rip), %rdi      # 0x4151
leaq 0x2b21(%rip), %rsi      # 0x4018
movl $0x8, %edx
callq 0x1460
cmpl $-0x1, -0xc(%rbp)
jne 0x1509
jmp 0x1521
leaq 0x2c59(%rip), %rdi      # 0x4169
leaq 0x2b01(%rip), %rsi      # 0x4018
movl $0x9, %edx
callq 0x1460
callq 0x1090
cmpl 0x5be8(%rip), %eax      # 0x7114
je 0x1530
jmp 0x1548
leaq 0x2c42(%rip), %rdi      # 0x4179
leaq 0x2ada(%rip), %rsi      # 0x4018
movl $0xa, %edx
callq 0x1460
movl 0x5bce(%rip), %edi      # 0x711c
leaq 0x2c41(%rip), %rsi      # 0x4196
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
jne 0x1567
jmp 0x157f
leaq 0x2c2a(%rip), %rdi      # 0x4198
leaq 0x2aa3(%rip), %rsi      # 0x4018
movl $0xb, %edx
callq 0x1460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/converters/littcvt/littcvt.c
// Function: main
int main (int argc, char *argv[])
{
int i, k, bc;
unsigned char buf[FLPSIZ];
char *ppos, oname[256];
FILE *ifile, *ofile;

if ((argc < 2) || (argv[0] == NULL)) {
	printf ("Usage is: verb file [file...]\n");
	exit (0);  }

for (i = 1; i < argc; i++) {
	strcpy (oname, argv[i]);
        if (ppos = strrchr (oname, '.')) strcpy (ppos, ".new");
                else strcat (oname, ".new");
	ifile = fopen (argv[i], "rb");
	if (ifile == NULL) {
		printf ("Error opening file: %s\n", argv[i]);
		exit (0);  }
	ofile = fopen (oname, "wb");
	if (ofile == NULL) {
		printf ("Error opening file: %s\n", oname);
		exit (0);  }

	printf ("Processing file %s\n", argv[i]);
	fread (&bc, sizeof (int), 1, ifile);
	for (;;) {
		k = fread (buf, sizeof (char), FLPSIZ, ifile);
		if (k == 0) break;
		fwrite (buf, sizeof (char), k, ofile);  }
	fclose (ifile);
	fclose (ofile);
}

exit (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10140, %rsp          # imm = 0x10140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jl 0x11e9
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11fe
leaq 0xe14(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x10a0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1399
leaq -0x10130(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1030
leaq -0x10130(%rbp), %rdi
movl $0x2e, %esi
callq 0x1070
movq %rax, -0x10028(%rbp)
cmpq $0x0, %rax
je 0x125c
movq -0x10028(%rbp), %rdi
leaq 0xdce(%rip), %rsi       # 0x2023
callq 0x1030
jmp 0x126f
leaq -0x10130(%rbp), %rdi
leaq 0xdb9(%rip), %rsi       # 0x2023
callq 0x1090
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xda6(%rip), %rsi       # 0x2028
callq 0x1080
movq %rax, -0x10138(%rbp)
cmpq $0x0, -0x10138(%rbp)
jne 0x12b9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd80(%rip), %rdi       # 0x202b
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x10a0
leaq -0x10130(%rbp), %rdi
leaq 0xd7c(%rip), %rsi       # 0x2043
callq 0x1080
movq %rax, -0x10140(%rbp)
cmpq $0x0, -0x10140(%rbp)
jne 0x12f9
leaq -0x10130(%rbp), %rsi
leaq 0xd40(%rip), %rdi       # 0x202b
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x10a0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd3a(%rip), %rdi       # 0x2046
movb $0x0, %al
callq 0x1060
movq -0x10138(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x1040
leaq -0x10020(%rbp), %rdi
movq -0x10138(%rbp), %rcx
movl $0x1, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x1040
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x1355
jmp 0x1373
leaq -0x10020(%rbp), %rdi
movslq -0x18(%rbp), %rdx
movq -0x10140(%rbp), %rcx
movl $0x1, %esi
callq 0x10b0
jmp 0x132d
movq -0x10138(%rbp), %rdi
callq 0x1050
movq -0x10140(%rbp), %rdi
callq 0x1050
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1205
xorl %edi, %edi
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/pldstr.c
// Function: PLD_strncat
char *PLD_strncat( char *dst, const char *src, size_t len )
{
	char *dp = dst;
	const char *sp = src;
	size_t cc;

	if (len == 0) return dst;

	len--;

	// Locate the end of the current string.
	cc = 0;
	while ((*dp)&&(cc < len)) { dp++; cc++; }

	// If we have no more buffer space, then return the destination

	if (cc >= len) return dst;

	// While we have more source, and there's more char space left in the buffer

	while ((*sp)&&(cc < len))
	{
		cc++;
		*dp = *sp;
		dp++;
		sp++;
	}

	// Terminate dst, as a gaurantee of string ending.

	*dp = '\0';

	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x54d4
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55a9
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0x5507
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5510
jmp 0x552a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x54e8
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x553e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x55a9
jmp 0x5540
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
je 0x555f
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x5568
jmp 0x559a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5540
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/pldstr.c
// Function: PLD_strncate
char *PLD_strncate( char *dst, const char *src, size_t len, char *endpoint )
{
	char *dp = dst;
	const char *sp = src;
	size_t cc = 0;

	if (len == 0) return dst;

	len--;

	// If endpoint does not relate correctly, then force manual detection
	// of the endpoint.

	if ((!endpoint)||(endpoint == dst)||((endpoint -dst +1)>(int)len))
	{
		// Locate the end of the current string.
		cc = 0;
		while ((*dp != '\0')&&(cc < len)) { dp++; cc++; }
	}
	else {
		cc = endpoint -dst +1;
		dp = endpoint;
	}

	// If we have no more buffer space, then return the destination

	if (cc >= len) return dst;

	// While we have more source, and there's more char space left in the buffer

	while ((*sp)&&(cc < len))
	{
		cc++;
		*dp = *sp;
		dp++;
		sp++;
	}

	// Terminate dst, as a gaurantee of string ending.

	*dp = '\0';

	return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x55f0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x570e
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5628
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x5628
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq -0x20(%rbp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0x5674
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x564f
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x5658
jmp 0x5672
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x5630
jmp 0x568f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x56a3
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x570e
jmp 0x56a5
movq -0x38(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x42(%rbp)
je 0x56c4
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x56cd
jmp 0x56ff
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x56a5
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/pldstr.c
// Function: PLD_strncasecmp
int PLD_strncasecmp( char *s1, char *s2, int n )
{
	char *ds1 = s1, *ds2 = s2;
	char c1, c2;
	int result = 0;

	while(n > 0)
	{
		c1 = tolower(*ds1);
		c2 = tolower(*ds2);

		if (c1 == c2)
		{
			n--;
			ds1++;
			ds2++;
		}
		else
		{
			result = c2 - c1;
			n = 0;
		}

	}

	return result;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x57b3
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x1110
movb %al, -0x29(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %edi
callq 0x1110
movb %al, -0x2a(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x579d
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x57b1
movsbl -0x2a(%rbp), %eax
movsbl -0x29(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
jmp 0x574a
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/pldstr.c
// Function: PLD_dprintf
char *PLD_dprintf(const char *format, ...) 
{
	int n, size = 1024; // Assume we don't need more than 1K to start with
	char *p;
	va_list ap;

	// Attempt to allocate and then check 
	p = malloc(size *sizeof(char));
	if (p == NULL) return NULL;

	while (1) 
	{
		// Attempt to print out string out into the allocated space
		va_start(ap, format);
		n = vsnprintf (p, size, format, ap);
		va_end(ap);

		// If things went well, then return the new string
		if ((n > -1) && (n < size)) return p;

		// If things didn't go well, then we have to allocate more space
		//	based on which glibc we're using ( fortunately, the return codes
		//	tell us which glibc is being used! *phew*
		//
		// If n > -1, then we're being told precisely how much space we need
		// else (older glibc) we have to just guess again ...

		if (n > -1) size = n+1; // Allocate precisely what is needed
		else size *= 2;  // Double the amount allocated, note, we could just increase by 1K, but if we have a long string, we'd end up using a lot of realloc's

		// We could just realloc 'blind', but that'd be wrong and potentially cause a DoS, so
		//	instead, we'll be good and first attempt to realloc to a temp variable then, if all
		//	is well, we go ahead and update
		if (1)
		{
			char *tmp_p;

			tmp_p = realloc(p, size);
			if (tmp_p == NULL){ if (p != NULL) free(p); return NULL; }
			else p = tmp_p;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x611e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x400, -0x18(%rbp)     # imm = 0x400
movslq -0x18(%rbp), %rdi
shlq $0x0, %rdi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6171
movq $0x0, -0x8(%rbp)
jmp 0x6223
jmp 0x6173
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x1080
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rax
cmpl $-0x1, -0x14(%rbp)
jle 0x61cb
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x61cb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6223
cmpl $-0x1, -0x14(%rbp)
jle 0x61dc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x61e4
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x1170
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6216
cmpq $0x0, -0x20(%rbp)
je 0x620c
movq -0x20(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x6223
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x6173
movq -0x8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ripole.c
// Function: ROLE_set_defaults
int ROLE_set_defaults( struct ripOLE_object *role )
{
	role->outputdir = defaultdir;
	role->debug = 0;
	role->verbose = 0;
	role->save_unknown_streams = 0;
	role->inputfile = NULL;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x5c6d(%rip), %rcx      # 0xc130
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ripole.c
// Function: ROLE_set_parameters
int ROLE_set_parameters( struct ripOLE_object *role, struct OLE_object *ole )
{
	if(role->debug == 1)
	{
		OLE_set_debug(ole, OLE_DEBUG_NORMAL);
	} 

	if (role->verbose == 1)
	{
		OLE_set_verbose(ole, OLE_VERBOSE_NORMAL);
	}

	if (role->save_unknown_streams == 1)
	{
		OLE_set_save_unknown_streams(ole, 1);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6857
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x14f0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x686f
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1490
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x6887
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1550
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inflex[P]ripMIME/ripOLE/ripole.c
// Function: ROLE_init
int ROLE_init(struct ripOLE_object *role)
{
	role->debug = 0;
	role->verbose = 0;
	role->save_unknown_streams = 0;

	role->inputfile = NULL;
	role->outputdir = NULL;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)